def pack(self):
'''
pack mail item for transmit
sender = 2 byte short
recipient = 2 byte short
subject = CONFIG['MAX_SUBJ_LEN'] bytes
body = CONFIG['MAX_BODY_LEN'] bytes
'''
p = ''
p += sp.pack_single_uint16(self.sender)
p += sp.pack_single_uint16(self.recipient)
p += sp.pack_single_string(self.subject)
p += sp.pack_single_string(self.body)
return p
def gen_bytes(self):
'''
Generate byte string containing tax years
'''
byte_str = ''
for y in self.tax_years:
byte_str += sp.pack_single_uint16(self.id)
return byte_str
def gen_bytes(self):
"""
Generate byte string containing tax years
"""
byte_str = ""
for y in self.tax_years:
byte_str += sp.pack_single_uint16(self.id)
return byte_str
def gen_new_person_bytes(self):
'''
Generate byte string sent to create a new person.
'''
byte_str = ''
byte_str += self.get_id_bytes()
byte_str += sp.pack_single_uint16(self.birth_year)
byte_str += sp.pack_single_string(self.fname)
byte_str += sp.pack_single_string(self.mname)
byte_str += sp.pack_single_string(self.lname)
return sp.pack_single_uint32(len(byte_str)) + byte_str
def gen_bytes(self):
'''
Generate byte string sent for each session
'''
byte_str = ''
byte_str += sp.pack_single_string(self.key)
byte_str += sp.pack_single_string(self.username)
byte_str += sp.pack_single_string(self.password)
byte_str += sp.pack_single_string(self.cmd)
byte_str += sp.pack_single_uint16(self.bytes)
byte_str += self.data
return byte_str
def gen_bytes2(self):
"""
Generate byte string sent for each session, split into 2 parts, leaving out password
"""
byte_str = ""
byte_str += sp.pack_single_string(self.key)
byte_str += sp.pack_single_string(self.username)
byte_str1 = sp.pack_single_string(self.cmd)
byte_str1 += sp.pack_single_uint16(self.bytes)
byte_str1 += self.data
return (byte_str, byte_str1)
def gen_bytes(self):
"""
Generate byte string sent for each session
"""
byte_str = ""
byte_str += sp.pack_single_string(self.key)
byte_str += sp.pack_single_string(self.username)
byte_str += sp.pack_single_string(self.password)
byte_str += sp.pack_single_string(self.cmd)
byte_str += sp.pack_single_uint16(self.bytes)
byte_str += self.data
return byte_str
def gen_bytes2(self):
'''
Generate byte string sent for each session, split into 2 parts, leaving out password
'''
byte_str = ''
byte_str += sp.pack_single_string(self.key)
byte_str += sp.pack_single_string(self.username)
byte_str1 = sp.pack_single_string(self.cmd)
byte_str1 += sp.pack_single_uint16(self.bytes)
byte_str1 += self.data
return (byte_str, byte_str1)
def get_plain_content(self):
pc = ""
pc += sp.pack_single_uint32(self.serialVersionUID)
pc += sp.pack_single_uint16(1 + len(self.args))
pc += sp.pack_single_string(self.fn_addr)
pc += sp.pack_single_char(" ")
pc += sp.pack_single_uint32(self.args[0])
pc += sp.pack_single_char(" ")
pc += sp.pack_single_uint32(self.args[1])
pc += sp.pack_single_char(" ")
pc += sp.pack_single_uint32(self.args[2])
pc += sp.pack_single_char("\0")
return pc
def get_plain_content(self):
pc = ''
pc += sp.pack_single_uint32(self.serialVersionUID)
pc += sp.pack_single_uint16(1 + len(self.args))
pc += sp.pack_single_string(self.fn_addr)
pc += sp.pack_single_char(' ')
pc += sp.pack_single_uint32(self.args[0])
pc += sp.pack_single_char(' ')
pc += sp.pack_single_uint32(self.args[1])
pc += sp.pack_single_char(' ')
pc += sp.pack_single_uint32(self.args[2])
pc += sp.pack_single_char('\0')
return pc
def get_serialized_content(self):
sc = ""
sc += sp.pack_single_uint32(self.serialVersionUID)
sc += sp.pack_single_string(self.typeName)
sc += sp.pack_single_uint16(1 + len(self.args))
sc += sp.pack_single_string(self.fn_addr)
sc += sp.pack_single_char(" ")
sc += sp.pack_single_uint32(self.args[0])
sc += sp.pack_single_char(" ")
sc += sp.pack_single_uint32(self.args[1])
sc += sp.pack_single_char(" ")
sc += sp.pack_single_uint32(self.args[2])
sc += sp.pack_single_char("\0")
return sc
def get_serialized_content(self):
sc = ''
sc += sp.pack_single_uint32(self.serialVersionUID)
sc += sp.pack_single_string(self.typeName)
sc += sp.pack_single_uint16(1 + len(self.args))
sc += sp.pack_single_string(self.fn_addr)
sc += sp.pack_single_char(' ')
sc += sp.pack_single_uint32(self.args[0])
sc += sp.pack_single_char(' ')
sc += sp.pack_single_uint32(self.args[1])
sc += sp.pack_single_char(' ')
sc += sp.pack_single_uint32(self.args[2])
sc += sp.pack_single_char('\0')
return sc
def add_address(self):
'''
Add one new address to the mail system
'''
self.send_cmd(self.CMD_ADD_ADDRESS)
if DEBUG:
print "cmd: add addresses"
invalid = False
if self.chance(.2):
invalid = True
addr = self.state['e'].get_new_address(invalid)
p_addr = sp.pack_single_uint16(addr)
self.write(p_addr)
if True == invalid:
self.recv_status(self.STATUS_ERR)
else:
self.recv_status(self.STATUS_OK)
self.state['e'].add_mailbox(addr)
return 0
def add_address(self):
'''
Add one new address to the mail system
'''
self.send_cmd(self.CMD_ADD_ADDRESS)
if DEBUG:
print "cmd: add addresses"
invalid = False
if self.chance(.2):
invalid = True
addr = self.state['e'].get_new_address(invalid)
p_addr = sp.pack_single_uint16(addr)
self.write(p_addr)
if True == invalid:
self.recv_status(self.STATUS_ERR)
else:
self.recv_status(self.STATUS_OK)
self.state['e'].add_mailbox(addr)
return 0
def gen_bytes(self):
"""
Generate byte string sent for a TenFourD.
"""
byte_str = sp.pack_single_uint16(self.tax_year)
for v in [self.fname, self.mname, self.lname, self.addy, self.csz]:
byte_str += sp.pack_single_string(v)
byte_str += sp.pack_single_uint32(self.id_num)
byte_str += sp.pack_single_char(self.donate)
byte_str += sp.pack_single_uint32(self.amount)
byte_str += sp.pack_single_uint32(self.party)
byte_str += sp.pack_single_uint32(self.wages)
byte_str += sp.pack_single_uint32(self.interest)
byte_str += sp.pack_single_uint32(self.biz_income)
byte_str += sp.pack_single_uint32(self.retirement_income)
byte_str += sp.pack_single_uint32(self.biz_expenses)
byte_str += sp.pack_single_uint32(self.edu_expenses)
byte_str += sp.pack_single_uint32(self.self_employ_expenses)
byte_str += sp.pack_single_uint32(self.edu_credits)
byte_str += sp.pack_single_uint32(self.child_credits)
byte_str += sp.pack_single_uint32(self.retirement_credits)
byte_str += sp.pack_single_uint32(self.home_buyer_credits)
byte_str += sp.pack_single_uint32(self.tax_withheld)
byte_str += sp.pack_single_uint32(self.tax_paid_non_taxable_income)
byte_str += sp.pack_single_string("".join(self.digital_signature))
byte_str += sp.pack_single_string(self.submission_date)
byte_str += sp.pack_single_uint32(self.tax_due)
byte_str += sp.pack_single_uint32(self.tax_refund)
return byte_str
def gen_bytes(self):
'''
Generate byte string sent for a TenFourD.
'''
byte_str = sp.pack_single_uint16(self.tax_year)
for v in [self.fname, self.mname, self.lname, self.addy, self.csz]:
byte_str += sp.pack_single_string(v)
byte_str += sp.pack_single_uint32(self.id_num)
byte_str += sp.pack_single_char(self.donate)
byte_str += sp.pack_single_uint32(self.amount)
byte_str += sp.pack_single_uint32(self.party)
byte_str += sp.pack_single_uint32(self.wages)
byte_str += sp.pack_single_uint32(self.interest)
byte_str += sp.pack_single_uint32(self.biz_income)
byte_str += sp.pack_single_uint32(self.retirement_income)
byte_str += sp.pack_single_uint32(self.biz_expenses)
byte_str += sp.pack_single_uint32(self.edu_expenses)
byte_str += sp.pack_single_uint32(self.self_employ_expenses)
byte_str += sp.pack_single_uint32(self.edu_credits)
byte_str += sp.pack_single_uint32(self.child_credits)
byte_str += sp.pack_single_uint32(self.retirement_credits)
byte_str += sp.pack_single_uint32(self.home_buyer_credits)
byte_str += sp.pack_single_uint32(self.tax_withheld)
byte_str += sp.pack_single_uint32(self.tax_paid_non_taxable_income)
byte_str += sp.pack_single_string(''.join(self.digital_signature))
byte_str += sp.pack_single_string(self.submission_date)
byte_str += sp.pack_single_uint32(self.tax_due)
byte_str += sp.pack_single_uint32(self.tax_refund)
return byte_str
def get_death_date_bytes(self):
return sp.pack_single_uint16(self.death_year)
def recv_uint16(val):
return sp.pack_single_uint16(val)
def gen_bytes(self):
byte_str = ""
byte_str += sp.pack_single_uint16(self.start_date)
byte_str += sp.pack_single_uint16(self.end_date)
return byte_str
def taxes_submitted(self):
'''
Determine list of years in which a taxpayer submitted a TenFourD
'''
if DEBUG:
print "cmd: taxes submitted"
s_invalid = False
s = self._get_random_session()
tdo = DateRange(randint(0, 0xfff), randint(0, 0xffff))
tdo_invalid = False
years = []
if None == s:
# create invalid session to trigger fail paths
tp = self._gen_random_taxpayer()
s_key = sp.random_string(12)
s = Session(s_key, tp, self.TAXES_SUBMITTED, "")
s_invalid = True
else:
tp = self.state['s'].get_taxpayer_by_username(s.username)
if False == tdo.is_valid():
tdo_invalid = True
else:
years = tp.get_list_submitted_tax_years(
tdo.start_date, tdo.end_date)
s = Session(s.key, tp, self.TAXES_SUBMITTED, tdo.gen_bytes())
if DEBUG:
print tdo
print " years: {0}".format(years)
buf = s.gen_bytes()
self.write(buf)
res = self.OK
ans = self.TAXES_DUE_OK
if True == s_invalid:
res = self.ERR
ans = self.NICE_TRY
elif True == tdo_invalid:
res = self.ERR
ans = self.TAXES_SUBMITTED_FAIL
else:
ans = self.TAXES_SUBMITTED_OK + ''.join(
[sp.pack_single_uint16(y) for y in years])
resp = Response(s.key, ans, res)
if DEBUG:
print resp
buf = resp.gen_bytes()
if res == self.ERR:
# cannot match key on ERR conditions, so trim
# it and assign it to regex
self.read(length=len(resp.s_key), assign=self.state['randkey'])
buf = buf[len(resp.s_key):]
self.read(length=len(resp.answer))
buf = buf[len(resp.answer):]
else:
st = buf[:len(resp.s_key) + len(resp.answer)]
self.read(length=len(st))
buf = buf[len(resp.s_key) + len(resp.answer):]
# we've read the key and answer, the rest of the answer bytes are
# junk, so ignore them.
self.read(length=len(buf) - len(resp.result))
# read result
buf = buf[len(buf) - len(resp.result):]
self.read(length=len(buf))
return 0
def get_refund(self):
'''
Get tax refund.
'''
if DEBUG:
print "cmd: get refund"
s_invalid = False
s = self._get_random_session()
p_invalid = False
years = []
refund = 0
if None == s:
# create invalid session to trigger fail paths
tp = self._gen_random_taxpayer()
s_key = sp.random_string(12)
s = Session(s_key, tp, self.GET_REFUND, "")
s_invalid = True
else:
tp = self.state['s'].get_taxpayer_by_username(s.username)
refund, years = tp.get_list_refund()
if [] == years:
p_invalid = True
s = Session(s.key, tp, self.GET_REFUND, "")
if DEBUG:
print "refund {0} years: {1}".format(refund, years)
buf = s.gen_bytes()
self.write(buf)
res = self.OK
ans = self.TAXES_DUE_OK
if True == s_invalid:
res = self.ERR
ans = self.NICE_TRY
elif True == p_invalid:
res = self.ERR
ans = self.GET_REFUND_FAIL
else:
ans = self.GET_REFUND_OK + sp.pack_single_uint32(refund) + ''.join(
[sp.pack_single_uint16(y) for y in years])
resp = Response(s.key, ans, res)
if DEBUG:
print resp
buf = resp.gen_bytes()
if res == self.ERR:
# cannot match key on ERR conditions, so trim
# it and assign it to regex
self.read(length=len(resp.s_key), assign=self.state['randkey'])
buf = buf[len(resp.s_key):]
self.read(length=len(resp.answer))
buf = buf[len(resp.answer):]
else:
st = buf[:len(resp.s_key) + len(resp.answer)]
self.read(length=len(st))
buf = buf[len(resp.s_key) + len(resp.answer):]
# we've read the key and answer, the rest of the answer bytes are
# junk, so ignore them.
self.read(length=len(buf) - len(resp.result))
# read result
buf = buf[len(buf) - len(resp.result):]
self.read(length=len(buf))
return 0
def recv_uint16(self, val, match=True):
if True == match:
self.read(length=2, expect=sp.pack_single_uint16(val))
else:
self.read(length=2)
def get_refund(self):
'''
Get tax refund.
'''
if DEBUG:
print "cmd: get refund"
s_invalid = False
s = self._get_random_session()
p_invalid = False
years = []
refund = 0
if None == s:
# create invalid session to trigger fail paths
tp = self._gen_random_taxpayer()
s_key = sp.random_string(12)
s = Session(s_key, tp, self.GET_REFUND, "")
s_invalid = True
else:
tp = self.state['s'].get_taxpayer_by_username(s.username)
refund, years = tp.get_list_refund()
if [] == years:
p_invalid = True
s = Session(s.key, tp, self.GET_REFUND, "")
if DEBUG:
print "refund {0} years: {1}".format(refund, years)
buf = s.gen_bytes()
self.write(buf)
res = self.OK
ans = self.TAXES_DUE_OK
if True == s_invalid:
res = self.ERR
ans = self.NICE_TRY
elif True == p_invalid:
res = self.ERR
ans = self.GET_REFUND_FAIL
else:
ans = self.GET_REFUND_OK + sp.pack_single_uint32(refund) + ''.join([sp.pack_single_uint16(y) for y in years])
resp = Response(s.key, ans, res)
if DEBUG:
print resp
buf = resp.gen_bytes()
if DEBUG:
print " Username: {0}".format(tp.username)
print " Response: K:{0}, A:{1}, R:{2} {3}".format(len(resp.s_key), len(resp.answer), len(resp.result), resp)
buf = resp.gen_bytes()
if DEBUG:
print " resp buf: ({0}) {1}".format(len(buf), sp.hexify(buf))
print " as text {0}".format(buf)
if res == self.ERR:
# cannot match key on ERR conditions, so just read len
e = buf[:len(resp.s_key)]
buf = buf[len(resp.s_key):]
self.read(length=len(e))
if DEBUG:
print " read resp.s_key = ({0}) {1}".format(len(e), sp.hexify(e))
print " new buf {0}".format(sp.hexify(buf))
e = buf[:len(resp.answer)]
buf = buf[len(resp.answer):]
self.read(length=len(e), expect=e)
if DEBUG:
print " read resp.answer = ({0}) {1}".format(len(e), sp.hexify(e))
print " new buf {0}".format(sp.hexify(buf))
else:
e = buf[:len(resp.s_key)+len(resp.answer)]
buf = buf[len(resp.s_key)+len(resp.answer):]
self.read(length=len(e), expect=e)
if DEBUG:
print " read resp.s_key + resp.answer = ({0}) {1}".format(len(e), sp.hexify(e))
print " new buf {0}".format(sp.hexify(buf))
# we've read the key and answer, the rest of the answer bytes are
# junk, so just read len
e = buf[:-len(resp.result)]
buf = buf[-len(resp.result):]
self.read(length=len(e))
if DEBUG:
print " read -len(resp.result) = ({0}) {1}".format(len(e), sp.hexify(e))
print " new buf {0}".format(sp.hexify(buf))
self.read(length=len(buf), expect=buf)
if DEBUG:
print " read final len(buf) = ({0}) {1}".format(len(buf), sp.hexify(buf))
return 0
def get_audited(self):
'''
Get audited.
'''
if DEBUG:
print "cmd: get audited"
s_invalid = False
s = self._get_random_session()
a_invalid = False
cmd = self.TRIGGER_AUDIT
if self.chance(0.4):
cmd = self.TRIGGER_AUDIT2
if None == s:
# create invalid session to trigger fail paths
tp = self._gen_random_taxpayer()
s_key = sp.random_string(12)
s = Session(s_key, tp, cmd, "")
s_invalid = True
else:
tp = self.state['s'].get_taxpayer_by_username(s.username)
s = Session(s.key, tp, cmd, "")
buf = s.gen_bytes()
self.write(buf)
ar = AuditRecord(tp)
if tp.id in self.state['s'].audits:
a_invalid = True
res = self.OK
ans = self.LUCKY_DAY
if True == s_invalid:
res = self.ERR
ans = self.NICE_TRY
elif True == a_invalid:
res = self.ERR
ans = self.AUDIT_FAIL
elif 0 == len(ar.tax_years):
ans = self.LUCKY_DAY
else:
ans = self.YOU_WIN + ''.join([sp.pack_single_uint16(y) for y in ar.tax_years])
self.state['s'].audit_taxpayer(ar)
if DEBUG:
print "audit years: {0}".format(ar.tax_years)
resp = Response(s.key, ans, res)
if DEBUG:
print resp
buf = resp.gen_bytes()
if DEBUG:
print " Username: {0}".format(tp.username)
print " Response: K:{0}, A:{1}, R:{2} {3}".format(len(resp.s_key), len(resp.answer), len(resp.result), resp)
buf = resp.gen_bytes()
if DEBUG:
print " resp buf: ({0}) {1}".format(len(buf), sp.hexify(buf))
print " as text {0}".format(buf)
if res == self.ERR:
# cannot match key on ERR conditions, so just read len
e = buf[:len(resp.s_key)]
buf = buf[len(resp.s_key):]
self.read(length=len(e))
if DEBUG:
print " read resp.s_key = ({0}) {1}".format(len(e), sp.hexify(e))
print " new buf {0}".format(sp.hexify(buf))
e = buf[:len(resp.answer)]
buf = buf[len(resp.answer):]
self.read(length=len(e), expect=e)
if DEBUG:
print " read resp.answer = ({0}) {1}".format(len(e), sp.hexify(e))
print " new buf {0}".format(sp.hexify(buf))
else:
e = buf[:len(resp.s_key)+len(resp.answer)]
buf = buf[len(resp.s_key)+len(resp.answer):]
self.read(length=len(e), expect=e)
if DEBUG:
print " read resp.s_key + resp.answer = ({0}) {1}".format(len(e), sp.hexify(e))
print " new buf {0}".format(sp.hexify(buf))
# we've read the key and answer, the rest of the answer bytes are
# junk, so just read len
e = buf[:-len(resp.result)]
buf = buf[-len(resp.result):]
self.read(length=len(e))
if DEBUG:
print " read -len(resp.result) = ({0}) {1}".format(len(e), sp.hexify(e))
print " new buf {0}".format(sp.hexify(buf))
self.read(length=len(buf), expect=buf)
if DEBUG:
print " read final len(buf) = ({0}) {1}".format(len(buf), sp.hexify(buf))
return 0
def taxes_submitted(self):
'''
Determine list of years in which a taxpayer submitted a TenFourD
'''
if DEBUG:
print "cmd: taxes submitted"
s_invalid = False
s = self._get_random_session()
tdo = DateRange(randint(0, 0xfff), randint(0, 0xffff))
tdo_invalid = False
years = []
if None == s:
# create invalid session to trigger fail paths
tp = self._gen_random_taxpayer()
s_key = sp.random_string(12)
s = Session(s_key, tp, self.TAXES_SUBMITTED, "")
s_invalid = True
else:
tp = self.state['s'].get_taxpayer_by_username(s.username)
if False == tdo.is_valid():
tdo_invalid = True
else:
years = tp.get_list_submitted_tax_years(tdo.start_date, tdo.end_date)
s = Session(s.key, tp, self.TAXES_SUBMITTED, tdo.gen_bytes())
if DEBUG:
print tdo
print " years: {0}".format(years)
buf = s.gen_bytes()
self.write(buf)
res = self.OK
ans = self.TAXES_DUE_OK
if True == s_invalid:
res = self.ERR
ans = self.NICE_TRY
elif True == tdo_invalid:
res = self.ERR
ans = self.TAXES_SUBMITTED_FAIL
else:
ans = self.TAXES_SUBMITTED_OK + ''.join([sp.pack_single_uint16(y) for y in years])
resp = Response(s.key, ans, res)
if DEBUG:
print resp
buf = resp.gen_bytes()
if DEBUG:
print " Username: {0}".format(tp.username)
print " Response: K:{0}, A:{1}, R:{2} {3}".format(len(resp.s_key), len(resp.answer), len(resp.result), resp)
buf = resp.gen_bytes()
if DEBUG:
print " resp buf: ({0}) {1}".format(len(buf), sp.hexify(buf))
print " as text {0}".format(buf)
if res == self.ERR:
# cannot match key on ERR conditions, so just read len
e = buf[:len(resp.s_key)]
buf = buf[len(resp.s_key):]
self.read(length=len(e))
if DEBUG:
print " read resp.s_key = ({0}) {1}".format(len(e), sp.hexify(e))
print " new buf {0}".format(sp.hexify(buf))
e = buf[:len(resp.answer)]
buf = buf[len(resp.answer):]
self.read(length=len(e), expect=e)
if DEBUG:
print " read resp.answer = ({0}) {1}".format(len(e), sp.hexify(e))
print " new buf {0}".format(sp.hexify(buf))
else:
e = buf[:len(resp.s_key)+len(resp.answer)]
buf = buf[len(resp.s_key)+len(resp.answer):]
self.read(length=len(e), expect=e)
if DEBUG:
print " read resp.s_key + resp.answer = ({0}) {1}".format(len(e), sp.hexify(e))
print " new buf {0}".format(sp.hexify(buf))
# we've read the key and answer, the rest of the answer bytes are
# junk, so just read len
e = buf[:-len(resp.result)]
buf = buf[-len(resp.result):]
self.read(length=len(e))
if DEBUG:
print " read -len(resp.result) = ({0}) {1}".format(len(e), sp.hexify(e))
print " new buf {0}".format(sp.hexify(buf))
self.read(length=len(buf), expect=buf)
if DEBUG:
print " read final len(buf) = ({0}) {1}".format(len(buf), sp.hexify(buf))
return 0
def recv_uint16(val):
return sp.pack_single_uint16(val)
def get_refund(self):
'''
Get tax refund.
'''
if DEBUG:
print "cmd: get refund"
s_invalid = False
s = self._get_random_session()
p_invalid = False
years = []
refund = 0
if None == s:
# create invalid session to trigger fail paths
tp = self._gen_random_taxpayer()
s_key = sp.random_string(12)
s = Session(s_key, tp, self.GET_REFUND, "")
s_invalid = True
else:
tp = self.state['s'].get_taxpayer_by_username(s.username)
refund, years = tp.get_list_refund()
if [] == years:
p_invalid = True
s = Session(s.key, tp, self.GET_REFUND, "")
if DEBUG:
print "refund {0} years: {1}".format(refund, years)
buf = s.gen_bytes()
self.write(buf)
res = self.OK
ans = self.TAXES_DUE_OK
if True == s_invalid:
res = self.ERR
ans = self.NICE_TRY
elif True == p_invalid:
res = self.ERR
ans = self.GET_REFUND_FAIL
else:
ans = self.GET_REFUND_OK + sp.pack_single_uint32(refund) + ''.join(
[sp.pack_single_uint16(y) for y in years])
resp = Response(s.key, ans, res)
if DEBUG:
print resp
buf = resp.gen_bytes()
if DEBUG:
print " Username: {0}".format(tp.username)
print " Response: K:{0}, A:{1}, R:{2} {3}".format(
len(resp.s_key), len(resp.answer), len(resp.result), resp)
buf = resp.gen_bytes()
if DEBUG:
print " resp buf: ({0}) {1}".format(len(buf), sp.hexify(buf))
print " as text {0}".format(buf)
if res == self.ERR:
# cannot match key on ERR conditions, so just read len
e = buf[:len(resp.s_key)]
buf = buf[len(resp.s_key):]
self.read(length=len(e))
if DEBUG:
print " read resp.s_key = ({0}) {1}".format(
len(e), sp.hexify(e))
print " new buf {0}".format(sp.hexify(buf))
e = buf[:len(resp.answer)]
buf = buf[len(resp.answer):]
self.read(length=len(e), expect=e)
if DEBUG:
print " read resp.answer = ({0}) {1}".format(
len(e), sp.hexify(e))
print " new buf {0}".format(sp.hexify(buf))
else:
e = buf[:len(resp.s_key) + len(resp.answer)]
buf = buf[len(resp.s_key) + len(resp.answer):]
self.read(length=len(e), expect=e)
if DEBUG:
print " read resp.s_key + resp.answer = ({0}) {1}".format(
len(e), sp.hexify(e))
print " new buf {0}".format(sp.hexify(buf))
# we've read the key and answer, the rest of the answer bytes are
# junk, so just read len
e = buf[:-len(resp.result)]
buf = buf[-len(resp.result):]
self.read(length=len(e))
if DEBUG:
print " read -len(resp.result) = ({0}) {1}".format(
len(e), sp.hexify(e))
print " new buf {0}".format(sp.hexify(buf))
self.read(length=len(buf), expect=buf)
if DEBUG:
print " read final len(buf) = ({0}) {1}".format(
len(buf), sp.hexify(buf))
return 0
def recv_uint16(self, uint16_val, match=True):
if True == match:
self.read(length=2, expect=sp.pack_single_uint16(uint16_val))
else:
self.read(length=2)
def gen_bytes(self):
byte_str = ''
byte_str += sp.pack_single_uint16(self.start_date)
byte_str += sp.pack_single_uint16(self.end_date)
return byte_str
def taxes_submitted(self):
'''
Determine list of years in which a taxpayer submitted a TenFourD
'''
if DEBUG:
print "cmd: taxes submitted"
s_invalid = False
s = self._get_random_session()
tdo = DateRange(randint(0, 0xfff), randint(0, 0xffff))
tdo_invalid = False
years = []
if None == s:
# create invalid session to trigger fail paths
tp = self._gen_random_taxpayer()
s_key = sp.random_string(12)
s = Session(s_key, tp, self.TAXES_SUBMITTED, "")
s_invalid = True
else:
tp = self.state['s'].get_taxpayer_by_username(s.username)
if False == tdo.is_valid():
tdo_invalid = True
else:
years = tp.get_list_submitted_tax_years(tdo.start_date, tdo.end_date)
s = Session(s.key, tp, self.TAXES_SUBMITTED, tdo.gen_bytes())
if DEBUG:
print tdo
print " years: {0}".format(years)
buf = s.gen_bytes()
self.write(buf)
res = self.OK
ans = self.TAXES_DUE_OK
if True == s_invalid:
res = self.ERR
ans = self.NICE_TRY
elif True == tdo_invalid:
res = self.ERR
ans = self.TAXES_SUBMITTED_FAIL
else:
ans = self.TAXES_SUBMITTED_OK + ''.join([sp.pack_single_uint16(y) for y in years])
resp = Response(s.key, ans, res)
if DEBUG:
print resp
buf = resp.gen_bytes()
if res == self.ERR:
# cannot match key on ERR conditions, so trim
# it and assign it to regex
self.read(length=len(resp.s_key), assign=self.state['randkey'])
buf = buf[len(resp.s_key):]
self.read(length=len(resp.answer))
buf = buf[len(resp.answer):]
else:
st = buf[:len(resp.s_key)+len(resp.answer)]
self.read(length=len(st))
buf = buf[len(resp.s_key)+len(resp.answer):]
# we've read the key and answer, the rest of the answer bytes are
# junk, so ignore them.
self.read(length=len(buf)-len(resp.result))
# read result
buf = buf[len(buf)-len(resp.result):]
self.read(length=len(buf))
return 0
def _create_stream(self, content_buf, type_buf):
b = type_buf
b += sp.pack_single_uint16(len(content_buf))
b += content_buf
return b
def taxes_submitted(self):
'''
Determine list of years in which a taxpayer submitted a TenFourD
'''
if DEBUG:
print "cmd: taxes submitted"
s_invalid = False
s = self._get_random_session()
tdo = DateRange(randint(0, 0xfff), randint(0, 0xffff))
tdo_invalid = False
years = []
if None == s:
# create invalid session to trigger fail paths
tp = self._gen_random_taxpayer()
s_key = sp.random_string(12)
s = Session(s_key, tp, self.TAXES_SUBMITTED, "")
s_invalid = True
else:
tp = self.state['s'].get_taxpayer_by_username(s.username)
if False == tdo.is_valid():
tdo_invalid = True
else:
years = tp.get_list_submitted_tax_years(
tdo.start_date, tdo.end_date)
s = Session(s.key, tp, self.TAXES_SUBMITTED, tdo.gen_bytes())
if DEBUG:
print tdo
print " years: {0}".format(years)
buf = s.gen_bytes()
self.write(buf)
res = self.OK
ans = self.TAXES_DUE_OK
if True == s_invalid:
res = self.ERR
ans = self.NICE_TRY
elif True == tdo_invalid:
res = self.ERR
ans = self.TAXES_SUBMITTED_FAIL
else:
ans = self.TAXES_SUBMITTED_OK + ''.join(
[sp.pack_single_uint16(y) for y in years])
resp = Response(s.key, ans, res)
if DEBUG:
print resp
buf = resp.gen_bytes()
if DEBUG:
print " Username: {0}".format(tp.username)
print " Response: K:{0}, A:{1}, R:{2} {3}".format(
len(resp.s_key), len(resp.answer), len(resp.result), resp)
buf = resp.gen_bytes()
if DEBUG:
print " resp buf: ({0}) {1}".format(len(buf), sp.hexify(buf))
print " as text {0}".format(buf)
if res == self.ERR:
# cannot match key on ERR conditions, so just read len
e = buf[:len(resp.s_key)]
buf = buf[len(resp.s_key):]
self.read(length=len(e))
if DEBUG:
print " read resp.s_key = ({0}) {1}".format(
len(e), sp.hexify(e))
print " new buf {0}".format(sp.hexify(buf))
e = buf[:len(resp.answer)]
buf = buf[len(resp.answer):]
self.read(length=len(e), expect=e)
if DEBUG:
print " read resp.answer = ({0}) {1}".format(
len(e), sp.hexify(e))
print " new buf {0}".format(sp.hexify(buf))
else:
e = buf[:len(resp.s_key) + len(resp.answer)]
buf = buf[len(resp.s_key) + len(resp.answer):]
self.read(length=len(e), expect=e)
if DEBUG:
print " read resp.s_key + resp.answer = ({0}) {1}".format(
len(e), sp.hexify(e))
print " new buf {0}".format(sp.hexify(buf))
# we've read the key and answer, the rest of the answer bytes are
# junk, so just read len
e = buf[:-len(resp.result)]
buf = buf[-len(resp.result):]
self.read(length=len(e))
if DEBUG:
print " read -len(resp.result) = ({0}) {1}".format(
len(e), sp.hexify(e))
print " new buf {0}".format(sp.hexify(buf))
self.read(length=len(buf), expect=buf)
if DEBUG:
print " read final len(buf) = ({0}) {1}".format(
len(buf), sp.hexify(buf))
return 0
def get_refund(self):
'''
Get tax refund.
'''
if DEBUG:
print "cmd: get refund"
s_invalid = False
s = self._get_random_session()
p_invalid = False
years = []
refund = 0
if None == s:
# create invalid session to trigger fail paths
tp = self._gen_random_taxpayer()
s_key = sp.random_string(12)
s = Session(s_key, tp, self.GET_REFUND, "")
s_invalid = True
else:
tp = self.state['s'].get_taxpayer_by_username(s.username)
refund, years = tp.get_list_refund()
if [] == years:
p_invalid = True
s = Session(s.key, tp, self.GET_REFUND, "")
if DEBUG:
print "refund {0} years: {1}".format(refund, years)
buf = s.gen_bytes()
self.write(buf)
res = self.OK
ans = self.TAXES_DUE_OK
if True == s_invalid:
res = self.ERR
ans = self.NICE_TRY
elif True == p_invalid:
res = self.ERR
ans = self.GET_REFUND_FAIL
else:
ans = self.GET_REFUND_OK + sp.pack_single_uint32(refund) + ''.join([sp.pack_single_uint16(y) for y in years])
resp = Response(s.key, ans, res)
if DEBUG:
print resp
buf = resp.gen_bytes()
if res == self.ERR:
# cannot match key on ERR conditions, so trim
# it and assign it to regex
self.read(length=len(resp.s_key), assign=self.state['randkey'])
buf = buf[len(resp.s_key):]
self.read(length=len(resp.answer))
buf = buf[len(resp.answer):]
else:
st = buf[:len(resp.s_key)+len(resp.answer)]
self.read(length=len(st))
buf = buf[len(resp.s_key)+len(resp.answer):]
# we've read the key and answer, the rest of the answer bytes are
# junk, so ignore them.
self.read(length=len(buf)-len(resp.result))
# read result
buf = buf[len(buf)-len(resp.result):]
self.read(length=len(buf))
return 0
def get_audited(self):
'''
Get audited.
'''
if DEBUG:
print "cmd: get audited"
s_invalid = False
s = self._get_random_session()
a_invalid = False
cmd = self.TRIGGER_AUDIT
if self.chance(0.4):
cmd = self.TRIGGER_AUDIT2
if None == s:
# create invalid session to trigger fail paths
tp = self._gen_random_taxpayer()
s_key = sp.random_string(12)
s = Session(s_key, tp, cmd, "")
s_invalid = True
else:
tp = self.state['s'].get_taxpayer_by_username(s.username)
s = Session(s.key, tp, cmd, "")
buf = s.gen_bytes()
self.write(buf)
ar = AuditRecord(tp)
if tp.id in self.state['s'].audits:
a_invalid = True
res = self.OK
ans = self.LUCKY_DAY
if True == s_invalid:
res = self.ERR
ans = self.NICE_TRY
elif True == a_invalid:
res = self.ERR
ans = self.AUDIT_FAIL
elif 0 == len(ar.tax_years):
ans = self.LUCKY_DAY
else:
ans = self.YOU_WIN + ''.join(
[sp.pack_single_uint16(y) for y in ar.tax_years])
self.state['s'].audit_taxpayer(ar)
if DEBUG:
print "audit years: {0}".format(ar.tax_years)
resp = Response(s.key, ans, res)
if DEBUG:
print resp
buf = resp.gen_bytes()
if DEBUG:
print " Username: {0}".format(tp.username)
print " Response: K:{0}, A:{1}, R:{2} {3}".format(
len(resp.s_key), len(resp.answer), len(resp.result), resp)
buf = resp.gen_bytes()
if DEBUG:
print " resp buf: ({0}) {1}".format(len(buf), sp.hexify(buf))
print " as text {0}".format(buf)
if res == self.ERR:
# cannot match key on ERR conditions, so just read len
e = buf[:len(resp.s_key)]
buf = buf[len(resp.s_key):]
self.read(length=len(e))
if DEBUG:
print " read resp.s_key = ({0}) {1}".format(
len(e), sp.hexify(e))
print " new buf {0}".format(sp.hexify(buf))
e = buf[:len(resp.answer)]
buf = buf[len(resp.answer):]
self.read(length=len(e), expect=e)
if DEBUG:
print " read resp.answer = ({0}) {1}".format(
len(e), sp.hexify(e))
print " new buf {0}".format(sp.hexify(buf))
else:
e = buf[:len(resp.s_key) + len(resp.answer)]
buf = buf[len(resp.s_key) + len(resp.answer):]
self.read(length=len(e), expect=e)
if DEBUG:
print " read resp.s_key + resp.answer = ({0}) {1}".format(
len(e), sp.hexify(e))
print " new buf {0}".format(sp.hexify(buf))
# we've read the key and answer, the rest of the answer bytes are
# junk, so just read len
e = buf[:-len(resp.result)]
buf = buf[-len(resp.result):]
self.read(length=len(e))
if DEBUG:
print " read -len(resp.result) = ({0}) {1}".format(
len(e), sp.hexify(e))
print " new buf {0}".format(sp.hexify(buf))
self.read(length=len(buf), expect=buf)
if DEBUG:
print " read final len(buf) = ({0}) {1}".format(
len(buf), sp.hexify(buf))
return 0
def _create_stream(self, content_buf, type_buf):
b = type_buf
b += sp.pack_single_uint16(len(content_buf))
b += content_buf
return b
