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 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 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