def main_function():
if len(sys.argv) != 3:
usage()
start_time = time.time()
# See on kataloom (mälufailisüsteem) kus vahetulemusi hoiame.
if not ENV_EVOTE_TMPDIR in os.environ:
print 'Keskkonnamuutuja %s seadmata\n' % (ENV_EVOTE_TMPDIR)
sys.exit(1)
_hlr = HLR(sys.argv[1], os.environ[ENV_EVOTE_TMPDIR])
retval = _hlr.run(sys.argv[2])
print time.strftime("\nAega kulus %H:%M:%S", \
time.gmtime(long(time.time() - start_time)))
if retval:
print 'Häälte lugemine õnnestus'
sys.exit(0)
print 'Häälte lugemine ebaõnnestus'
print 'Viimane viga: %s' % evlog.AppLog().last_message()
sys.exit(1)
def hts_vote(self, valid_person, vote):
ik = valid_person[0]
en = valid_person[1]
pn = valid_person[2]
evlog.AppLog().set_person(ik)
import base64
decoded_vote = base64.decodestring(vote)
evlog.log('Hääle talletamine: %s %s' % (en, pn))
if not Election().can_vote(ik):
error = HESResult()
error.pole_valija(ik)
return self.__return_error(error)
inspector = VoteChecker(decoded_vote, ik)
mobid = False
if 'MOBILE_ID_CONTEXT' in os.environ:
mobid = True
if not inspector.check_vote(mobid):
return self.__return_error(inspector.error)
params = {}
params[evcommon.POST_EVOTE] = vote
params[evcommon.POST_PERSONAL_CODE] = ik
params[evcommon.POST_VOTERS_FILES_SHA1] = \
Election().get_voters_files_sha1()
params[evcommon.POST_SESS_ID] = sessionid.voting()
hts_connector = HTSConnector(params)
if not hts_connector.work_strict():
return self.__return_error(hts_connector.error)
return hts_connector.answer[1], hts_connector.answer[2]
def __init__(self):
evlog.AppLog().set_app('HES')
def __init__(self):
evlog.AppLog().set_app('MID')
self.__ctx = None
import evcommon
import evlog
import hesdisp
import protocol
import sessionid
import cgivalidator
import cgilog
import election
import os
if not evcommon.testrun():
os.umask(007)
hesd = hesdisp.HESVoterDispatcher()
form = cgi.FieldStorage()
result = protocol.msg_error_technical()
evlog.AppLog().set_app('HES')
try:
if form.has_key(evcommon.POST_EVOTE):
req_params = [evcommon.POST_EVOTE, evcommon.POST_SESS_ID]
if cgivalidator.validate_sessionid(form):
sessionid.setsid(form.getvalue(evcommon.POST_SESS_ID))
res, logline = cgivalidator.validate_form(form, req_params)
if res:
cgilog.do_log('vote/auth')
result = hesd.hts_vote(form.getvalue(evcommon.POST_EVOTE))
else:
cgilog.do_log_error('vote/auth/err')
evlog.log_error(logline)
print " %s <valimiste-id> <failinimi>" % sys.argv[0]
print " - rakendab tühistus-/ennistusnimekirja"
sys.exit(1)
if __name__ == '__main__':
if len(sys.argv) < 3:
usage()
elid = sys.argv[1]
infile = sys.argv[2]
p_time = "00:00:00"
evlog.AppLog().set_app('HTS', elid)
tmp_f = None
try:
try:
s_time = time.time()
evlog.AppLog().log(
'Tühistus-/ennistusnimekirja laadimine: ALGUS')
bdocpython.initialize()
bconf = bdocconfig.BDocConfig()
bconf.load(election.Election().get_bdoc_conf())
result = regrights.kontrolli_volitusi(elid, infile, 'TYHIS', bconf)
if not result[0]:
errmsg = 'Tühistus-/ennistusnimekirja volituste ' \
'kontroll andis negatiivse tulemuse: '
def tyhista_ennista(self, filename):
tmp_tyhis_f = None
try:
bdocpython.initialize()
bconf = bdocpythonutils.BDocConfig()
bconf.load(Election().get_bdoc_conf())
result = regrights.kontrolli_volitusi(\
self._elid, filename, 'TYHIS', bconf)
if not result[0]:
self._errmsg = \
'Tühistus-/ennistusnimekirja volituste ' \
'kontroll andis negatiivse tulemuse: '
self._errmsg += result[1]
raise Exception(self._errmsg)
_signercode = result[2]
tmp_tyhis_f = bdocpythonutils.get_doc_content_file(filename)
rl = revocationlists.RevocationList()
rl.attach_elid(self._elid)
rl.attach_logger(evlog.AppLog())
if not rl.check_format(tmp_tyhis_f, \
'Kontrollin tühistus-/ennistusnimekirja: '):
self._errmsg = 'Vigase formaadiga tühistus-/ennistusnimekiri'
raise Exception(self._errmsg)
g_l = None
b_l = None
act = ''
report = []
if rl.revoke:
act = 'tühistamine'
g_l, b_l = self.__tyhista_haaled(rl.rev_list, _signercode)
else:
act = 'ennistamine'
g_l, b_l = self.__ennista_haaled(rl.rev_list, _signercode)
for el in b_l:
el.append(act + ' nurjus')
report.append(el)
for el in g_l:
el.append(act + ' õnnestus')
report.append(el)
fn = self._reg.path(['hts', 'output', evcommon.REVREPORT_FILE])
self.__save_list(report, fn)
ksum.store(fn)
return len(rl.rev_list), len(g_l), len(b_l)
finally:
if tmp_tyhis_f != None:
os.unlink(tmp_tyhis_f)
"""
import cgi
import evcommon
import evlog
import protocol
import sessionid
import cgivalidator
import htsalldisp
import os
if not evcommon.testrun():
os.umask(007)
form = cgi.FieldStorage()
result = protocol.msg_error_technical()
evlog.AppLog().set_app("VERIFY")
try:
if cgivalidator.validate_sessionid(form):
sessionid.setsid(form.getvalue(evcommon.POST_SESS_ID))
req_params = [evcommon.POST_SESS_ID, evcommon.POST_VERIFY_VOTE]
res, logline = cgivalidator.validate_form(form, req_params)
if res:
vote = form.getvalue(evcommon.POST_VERIFY_VOTE)
result = htsalldisp.verify_vote(vote)
else:
evlog.log_error(logline)
except:
evlog.log_exception()
result = protocol.msg_error_technical()
def apply_changes(elid, voter_f):
"""Muudatuste rakendamine"""
vl = None
tokend = {}
def check_state():
if not ElectionState().can_apply_changes():
sys.stderr.write('Selles hääletuse faasis (%s) pole võimalik '
'nimekirju uuendada\n'
% ElectionState().str())
sys.exit(1)
try:
buflog = None
if Election().is_hes():
root = 'hes'
elif Election().is_hts():
root = 'hts'
else:
raise Exception('Vigane serveritüüp')
buflog = BufferedLog(Election().
get_path(evcommon.VOTER_LIST_LOG_FILE),
'APPLY-CHANGES', elid)
check_state()
reg = Election().get_sub_reg(elid)
ed = inputlists.Districts()
ed.load(root, reg)
vl = inputlists.VotersList(root, reg, ed)
vl.attach_elid(elid)
vl.ignore_errors()
evlog.AppLog().set_app('APPLY-CHANGES')
vl.attach_logger(evlog.AppLog())
print "Kontrollin valijate faili terviklikkust"
checkResult = sigverify.check_existent(voter_f, elid)
if not checkResult[0]:
raise Exception('Kontrollimisel tekkis viga: %s\n' % checkResult[1])
else:
print "Valijate faili terviklikkus OK"
voters_file_sha256 = ksum.compute(voter_f)
if Election().get_root_reg().check(
['common', 'voters_file_hashes', voters_file_sha256]):
raise Exception('Kontrollsummaga %s fail on juba laaditud\n'
% voters_file_sha256)
if not vl.check_format(voter_f, 'Kontrollin valijate nimekirja: '):
print "Valijate nimekiri ei vasta vormingunõuetele"
sys.exit(1)
else:
print 'Valijate nimekiri OK'
vl.attach_logger(buflog)
if not vl.check_muudatus(
'Kontrollin muudatuste kooskõlalisust: ',
ElectionState().election_on(), tokend):
print "Sisend ei ole kooskõlas olemasoleva konfiguratsiooniga"
else:
print "Muudatuste kooskõlalisus OK"
_apply = 1
if not buflog.empty():
print 'Muudatuste sisselaadimisel esines vigu'
buflog.output_errors()
_apply = uiutil.ask_yes_no(
'Kas rakendan kooskõlalised muudatused?')
if not _apply:
buflog.log_error('Muudatusi ei rakendatud')
print 'Muudatusi ei rakendatud'
else:
if ElectionState().election_on() and root == 'hts':
create_tokend_file(tokend, reg, elid)
a_count, d_count = vl.create('Paigaldan valijaid: ')
print 'Teostasin %d lisamist ja %d eemaldamist' \
% (a_count, d_count)
Election().copy_config_file(
elid, root, voter_f, evcommon.VOTERS_FILES)
Election().add_voters_file_hash(voter_f)
print 'Muudatuste rakendamine lõppes edukalt'
except SystemExit:
sys.stderr.write('Viga muudatuste laadimisel\n')
if buflog:
buflog.output_errors()
raise
except Exception as ex:
sys.stderr.write('Viga muudatuste laadimisel: ' + str(ex) + '\n')
if buflog:
buflog.output_errors()
sys.exit(1)
finally:
if vl is not None:
vl.close()
import evcommon
import middisp
import protocol
import evlog
import sessionid
import cgivalidator
import cgilog
import election
import os
if not evcommon.testrun():
os.umask(007)
form = cgi.FieldStorage()
result = protocol.msg_error_technical()
mid = middisp.MIDDispatcher()
evlog.AppLog().set_app('MID')
try:
has_sess = form.has_key(evcommon.POST_SESS_ID)
has_poll = form.has_key(evcommon.POST_MID_POLL)
if has_sess:
if cgivalidator.validate_sessionid(form):
sessionid.setsid(form.getvalue(evcommon.POST_SESS_ID))
if has_poll:
req_params = [evcommon.POST_MID_POLL, evcommon.POST_SESS_ID]
res, logline = cgivalidator.validate_form(form, req_params)
if res:
result = mid.poll()
else:
evlog.log_error(logline)
else:
"""
import cgi
import evcommon
import evlog
import protocol
import sessionid
import cgivalidator
import htsalldisp
import os
if not evcommon.testrun():
os.umask(007)
form = cgi.FieldStorage()
result = protocol.msg_error_technical()
evlog.AppLog().set_app("HTS")
try:
if cgivalidator.validate_sessionid(form):
sessionid.setsid(form.getvalue(evcommon.POST_SESS_ID))
if evcommon.POST_EVOTE in form:
# Store the vote
req_params = [
evcommon.POST_VOTERS_FILES_SHA256, evcommon.POST_SESS_ID,
evcommon.POST_PERSONAL_CODE, evcommon.POST_EVOTE
]
res, logline = cgivalidator.validate_form(form, req_params)
if res:
sha = form.getvalue(evcommon.POST_VOTERS_FILES_SHA256)
code = form.getvalue(evcommon.POST_PERSONAL_CODE)
