def unpack(self, u: xdrlib.Unpacker): last = u.unpack_uint() + u.get_position() if u.get_position() < last: self.time_A = struct.unpack('>Q', u.unpack_fopaque(8))[0] if u.get_position() < last: self.time_B = struct.unpack('>Q', u.unpack_fopaque(8))[0] u.set_position(last)
def unpack(self, u: xdrlib.Unpacker): last = u.unpack_uint() + u.get_position() ret = ReturnCode.unpack(u) if ret == ReturnCode.OK: last2 = u.unpack_uint() + u.get_position() if u.get_position() < last2: self.digest = u.unpack_fopaque(20) if u.get_position() < last2: self.salt = u.unpack_fopaque(8) u.set_position(last2) u.set_position(last)
def run(self): while self.server_running: potential_read = [self.server_socket] if self.client is not None: potential_read.append(self.client) try: ready_to_read, ready_to_write, in_erro = select.select( potential_read, [], []) if self.server_socket in ready_to_read: conn, addr = self.server_socket.accept() self.client = conn print('New connection from ', addr) elif self.client in ready_to_read: # self.client.recv_into(self.buffer, 512) recv = self.client.recv(128) self.buffer += recv if len(recv) == 0: print('Disconnection from client') self.client.close() self.client = None self.buffer = '' continue unpack = Unpacker(self.buffer) if len(self.buffer) >= unpack.unpack_int(): unpack.set_position(0) size = unpack.unpack_int() cmd = unpack.unpack_int() if cmd == ServerMouseController.PACKET_MOVE: # Mouse move control x = unpack.unpack_float() y = unpack.unpack_float() print(size, cmd, x, y) self.mouse_controller.move( self.mouse_controller.position()[0] - x, self.mouse_controller.position()[1] - y) elif cmd == ServerMouseController.PACKET_CLICK: # Mouse click control button = unpack.unpack_int() nb_click = unpack.unpack_int() print(size, cmd, button, nb_click) self.mouse_controller.click( self.mouse_controller.position()[0], self.mouse_controller.position()[1], button, nb_click) elif cmd == ServerMouseController.PACKET_SCROLL: # Mouse scrolling x = unpack.unpack_float() y = unpack.unpack_float() print(size, cmd, x, y) self.mouse_controller.scroll( vertical=int(y), horizontal=int(x)) self.buffer = self.buffer[unpack.get_position():] except select.error as e: print(e) if self.client is not None: self.client.close() self.server_socket.close() print('Server stop')
def get_tlv(wrapped_message): unpacker = Unpacker(wrapped_message) tag = unpacker.unpack_uint() message = unpacker.unpack_string() pos = unpacker.get_position() buff = unpacker.get_buffer() rest = buff[pos:] return tag, message, rest
def unpack(self, u: xdrlib.Unpacker): self.needs_attention = u.unpack_bool() self.fixing = u.unpack_bool() self.wwn = u.unpack_opaque() self.management_class_name = u.unpack_string() self.storage_array_label = u.unpack_string().decode('utf-16be') self.boot_time = struct.unpack('>Q', u.unpack_fopaque(8))[0] self.fw_version = u.unpack_fopaque(4) self.app_version = u.unpack_fopaque(4) self.boot_version = u.unpack_fopaque(4) self.nvsram_version = u.unpack_string() self.fw_prefix = u.unpack_string() self.chassis_serial_number = u.unpack_string() self.event_configuration_data_version = u.unpack_string() self.array_attributes = [] nb = u.unpack_uint() for i in range(nb): self.array_attributes.append(u.unpack_uint()) self.res4 = [] nb = u.unpack_uint() for i in range(nb): self.res4.append(u.unpack_uint()) self.res5 = [] nb = u.unpack_uint() for i in range(nb): self.res5.append(u.unpack_uint()) self.res6 = [] nb = u.unpack_uint() for i in range(nb): self.res6.append(u.unpack_uint()) self.res7 = u.unpack_opaque() last = u.unpack_int() if last > 0: this.reserved1 = u.get_opaque() u.set_position(u.get_position() + last)
def unpack(self, u: xdrlib.Unpacker): last = u.unpack_uint() + u.get_position() if u.get_position() < last: last2 = u.unpack_uint() self.canditate_selection_type = CandidateSelectionType( u.unpack_uint()) if self.canditate_selection_type == CandidateSelectionType.CANDIDATE_SEL_MANUAL: last3 = u.unpack_uint() + u.get_position() if u.get_position() < last3: nb = u.unpack_uint() self.drive_refs = [] for i in range(nb): self.drive_refs.append(u.unpack_fopaque(20)) u.set_position(last3) u.set_position(last2) if u.get_position() < last: self.raid_level = RaidLevel(u.unpack_int()) if u.get_position() < last: self.phyiscal_drive_type = PhysicalDriveType(u.unpack_int())
class trrParser: """ Parses .trr Gromacs trajectory file """ def __init__(self, file): self.nframes = 0 self.headers = [] ## header = { ## "ir_size":None, ## "e_size": None, ## "box_size" :None, ## "vir_size": None, ## "pres_size": None, ## "top_size ": None, ## "sym_size ": None, ## "x_size ": None, ## "v_size ": None, ## "f_size ": None, ## "natoms ": None, ## "step ": None, ## "nre ": None, ## "version":'GMX_trn_file', ## "magicnum" :1993, ## "bDouble ": None, ## } self.file = file self.coords = [] self.velocities = {} self.forces = {} def nFloatSize(self, h): nflsize = 0 if h["box_size"]: nflsize = h["box_size"] / (DIM * DIM) elif h["x_size"]: nflsize = h["x_size"] / (h["natoms"] * DIM) elif h["v_size"]: nflsize = h["v_size"] / (h["natoms"] * DIM) elif h["f_size"]: nflsize = h["f_size"] / (h["natoms"] * DIM) else: print("Can not determine precision of trr file") if (nflsize != calcsize("f")) and (nflsize != calcsize("d")): print("Float size %d. Maybe different CPU?" % nflsize) return nflsize def read(self): fext = os.path.splitext(self.file)[-1] assert fext == ".trr" fp = open(self.file, "rb") self.data = data = fp.read() self.coords = [] self.v = {} self.f = {} self.up = Unpacker(data) curpos = self.up.get_position() datasize = len(data) nframe = 0 #each frame begins with a header while curpos < datasize: #print "current position:", curpos h = self.readHeader(nframe) self.headers.append(h) self.readData(nframe) nframe = nframe + 1 curpos = self.up.get_position() #print "end of readTraj, cur position : %d, datazize: %d" %(self.up.get_position(), datasize) self.nframes = nframe if self.nframes: return 1 else: return 0 def readHeader(self, nframe): #print "reading header, frame %d" %nframe up = self.up header = {} header["magicnum"] = up.unpack_int() #print "magicnum: ", header["magicnum"] #1993 i1 = up.unpack_int() #13 version = up.unpack_string() #'GMX_trn_file' header["version"] = version #print "version:", version header["ir_size"] = up.unpack_int() #print "ir_size=", header["ir_size"] header["e_size"] = up.unpack_int() #print "e_size=", header["e_size"] header["box_size"] = up.unpack_int() #print "box_size=", header["box_size"] header["vir_size"] = up.unpack_int() #print "vir_size=", header["vir_size"] header["pres_size"] = up.unpack_int() #print "pres_size=", header["pres_size"] header["top_size"] = up.unpack_int() #print "top_size=", header["top_size"] header["sym_size"] = up.unpack_int() #print "sym_size=", header["sym_size"] header["x_size"] = up.unpack_int() #print "x_size=", header["x_size"] header["v_size"] = up.unpack_int() #print "v_size=", header["v_size"] header["f_size"] = up.unpack_int() #print "f_size=", header["f_size"] header["natoms"] = up.unpack_int() #print "natoms=", header["natoms"] header["step"] = up.unpack_int() #print "step=", header["step"] header["nre"] = up.unpack_int() #print "nre=", header["nre"] if self.nFloatSize(header) == calcsize("d"): header["bDouble"] = True else: header["bDouble"] = False if header["bDouble"]: header["time"] = up.unpack_double() header["lam"] = up.umpack_double() else: header["time"] = up.unpack_float() header["lam"] = up.unpack_float() #print "time = ", header["time"] #print "lambda = ", header["lam"] #print "natoms=%10d step=%10d time=%10g lambda=%10g"% (header["natoms"],header["step"],header["time"],header["lam"]) #print "current position:", up.get_position() return header def readData(self, nframe): up = self.up h = self.headers[nframe] box = [] if h["box_size"] != 0: for i in range(3): box.append(up.unpack_farray(3, up.unpack_float)) #print " box (3x3):" #print box self.headers[nframe]["box"] = box pv = [] if h["vir_size"] != 0: for i in range(3): pv.append(up.unpack_farray(3, up.unpack_float)) #print "pv:" #print pv self.headers[nframe]["pv"] = pv if h["pres_size"] != 0: pv.append(up.unpack_farray(3, up.unpack_float)) #print "pv:" #print pv self.headers[nframe]["pv"] = pv natoms = h["natoms"] if h["x_size"] != 0: x = [] for i in range(natoms): x.append(up.unpack_farray(3, up.unpack_float)) #self.coords["frame%d"%nframe] = x self.coords.append(x) if h["v_size"] != 0: v = [] for i in range(natoms): v.append(up.unpack_farray(3, up.unpack_float)) self.velocities["frame%d" % nframe] = v if h["f_size"] != 0: f = [] for i in range(natoms): f.append(up.unpack_farray(3, up.unpack_float)) self.forces["frame%d" % nframe] = f
def parse(self, wired_string): """ @returns (counterparty_pub_key_sexp, cleartext,) @raises SessionInvalidated if the incoming message was an "invalidate session" message \000\000\000\002. @raises UnknownSession error if the incoming message did not identify a known session key. @precondition `wired_string' must be a string.: type(wired_string) == types.StringType: "wired_string: %s :: %s" % (hr(wired_string), hr(type(wired_string))) @postcondition `counterparty_pub_key_sexp' is a public key.: MojoKey.publicRSAKeyForCommunicationSecurityIsWellFormed(counterparty_pub_key_sexp): "counterparty_pub_key_sexp: %s" % hr(counterparty_pub_key_sexp) """ assert type(wired_string) == types.StringType, "precondition: `wired_string' must be a string." + " -- " + "wired_string: %s :: %s" % (hr(wired_string), hr(type(wired_string))) session = None try: u = Unpacker(wired_string) mtype = u.unpack_fstring(4) if mtype == '\000\000\000\000': # a message with a full PK header header = u.unpack_string() iv = u.unpack_fstring(8) prefix = wired_string[:u.get_position()] encrypted = u.unpack_string() u.done() counterparty_pub_key_sexp, symmetric_key = self._session_keeper.parse_header(header) decrypted = tripledescbc.new(symmetric_key).decrypt(iv, encrypted) u = Unpacker(decrypted) message = u.unpack_string() mac = u.unpack_fstring(SIZE_OF_UNIQS) u.done() # debugprint("------ ------ ------ ------ hmachish(key=%s, message=%s)\n" % (`symmetric_key`, `message`)) maccomp = cryptutil.hmacish(key=symmetric_key, message=message) if mac != maccomp: raise Error, 'incorrect MAC' return (counterparty_pub_key_sexp, message) elif mtype == '\000\000\000\001': # a message using an already established session id session = u.unpack_fstring(SIZE_OF_UNIQS) iv = u.unpack_fstring(8) prefix = wired_string[:u.get_position()] encrypted = u.unpack_string() u.done() counterparty_pub_key_sexp, symmetric_key, want_ack = self._session_keeper.get_session_info(session) decrypted = tripledescbc.new(symmetric_key).decrypt(iv, encrypted) u = Unpacker(decrypted) message = u.unpack_string() mac = u.unpack_fstring(SIZE_OF_UNIQS) u.done() counterparty_id = idlib.make_id(counterparty_pub_key_sexp, 'broker') # debugprint("------ ------ ------ ------ hmachish(key=%s, message=%s)\n" % (`symmetric_key`, `message`)) maccomp = cryptutil.hmacish(key=symmetric_key, message=message) if mac != maccomp: raise Error, 'incorrect MAC' if want_ack: self._session_keeper.got_ack(counterparty_id) return (counterparty_pub_key_sexp, message) elif mtype == '\000\000\002\002': # a short "message" invalidating an outgoing session id bad_session_id_out = u.unpack_fstring(SIZE_OF_UNIQS) unverified_counterparty_id = u.unpack_fstring(SIZE_OF_UNIQS) self._session_keeper.invalidate_session(bad_session_id_out, unverified_counterparty_id) raise SessionInvalidated, 'session_id %s with %s invalidated' % (`bad_session_id_out`, idlib.to_ascii(unverified_counterparty_id)) else: raise Error, 'unsupported message type' except (modval.Error, tripledescbc.Error, xdrlib.Error, EOFError), le: debugprint("got error in mesgen.parse(): %s", args=(le,), v=4, vs="debug") if session is not None: raise UnknownSession(session, self.get_id()) else: raise Error, le
def __parse_header(self, header): """ Parses a header and stores information contained in it as necessary Returns (counterparty pub key sexp, symmetric key) throws Error """ assert type(header) == type('') try: hash = sha(header).digest() cached = self.__cached_headers.get(hash) if cached is not None: return cached u = Unpacker(header) # messages start with the hash of the recipient's public id recipient_id = u.unpack_fstring(SIZE_OF_UNIQS) if recipient_id != self.__my_public_key_id: raise Error, 'message not intended for me' # unpack PK encrypted public key encrypted_key = u.unpack_string() self.__key.set_value_string(encrypted_key) self.__key.decrypt() # PKop decrypted = self.__key.get_value() try: symmetric_key = cryptutil.oaep_decode(decrypted[1:]) # Leave off the initial 0 byte. ### XX check whether it really is 0 and raise bad-encoding error if not. --Zooko 2000-07-29 except cryptutil.OAEPError, le: raise Error, 'bad encryption -- pad badding: padded: %s, Error: %s' % (`decrypted`, `le.args`) iv = u.unpack_fstring(8) # first half of the MAC # XXX A.K.A. the key? --Zooko 2000-07-29 prefix = header[:u.get_position()] # all data except the symmetric key and recipient, encrypted encrypted = u.unpack_string() u.done() decrypted = tripledescbc.new(symmetric_key).decrypt(iv, encrypted) u = Unpacker(decrypted) # the full public key of the sender sender_key = u.unpack_string() full_key = MojoKey.makePublicRSAKeyForCommunicating(modval.new(sender_key, HARDCODED_RSA_PUBLIC_EXPONENT)) full_key_id = idlib.make_id(full_key, 'broker') # the session id for messages sent 'here' id_in = _mix_counterparties(full_key_id, self.__my_public_key_id, u.unpack_fstring(SIZE_OF_UNIQS)) # the session id for messages sent 'there' id_out = _mix_counterparties(full_key_id, self.__my_public_key_id, u.unpack_fstring(SIZE_OF_UNIQS)) # check that the pk encrypted symmetric key used to send this message is the same was generated properly strl = u.unpack_fstring(SIZE_OF_UNIQS) sr = HashRandom.SHARandom(_mix_counterparties(full_key_id, self.__my_public_key_id, strl)) spaml = sr.get(SIZE_OF_SYMMETRIC_KEYS) if symmetric_key != spaml: raise Error, 'improperly generated key' # the second half of what's in the MAC # XXX A.K.A. the message? --Zooko 2000-07-29 end = decrypted[:u.get_position()] # the signature of everything signature = u.unpack_fstring(len(sender_key)) u.done() # debugprint("------ ------ ------ ------ hmachish(key=%s, message=%s)\n" % (`symmetric_key`, `end`)) summary = cryptutil.hmacish(key=symmetric_key, message=end) x = modval.new(sender_key, HARDCODED_RSA_PUBLIC_EXPONENT, signature) x.undo_signature() # PKop signed_value = x.get_value() try: thingie = cryptutil.oaep_decode(signed_value[1:]) # Leave off the initial 0 byte. ### XX check whether it really is 0 and raise bad-encoding error if not. --Zooko 2000-07-29 except cryptutil.OAEPError, le: raise Error, 'bad encryption -- pad badding: padded: %s, Error: %s' % (`signed_value`, `le.args`)
else: logging.info(str(flow_sample_cache)) ### Flow Sample ### if enterprise_format_num in [[0, 1], [0, 3]]: # Flow Sample # Iterate through the flow records for record_counter_num in range( 0, flow_sample_cache["Record Count"] ): # For each staged sample record_ent_form_number = enterprise_format_numbers( unpacked_sample_data.unpack_uint() ) # [Enterprise, Format] numbers counter_data_length = int( unpacked_sample_data.unpack_uint()) # Length of record current_position = int(unpacked_sample_data.get_position() ) # Current unpack buffer position skip_position = current_position + counter_data_length # Bail out position if unpack fails for skipping logging.info("Flow record " + str(record_counter_num + 1) + " of " + str(flow_sample_cache["Record Count"]) + ", type " + str(record_ent_form_number) + ", length " + str(counter_data_length) + ", XDR position " + str(current_position) + ", skip position " + str(skip_position)) # Unpack the opaque flow record unpacked_record_data = Unpacker( unpacked_sample_data.unpack_fopaque( counter_data_length))
class trrParser: """ Parses .trr Gromacs trajectory file """ def __init__(self, file): self.nframes = 0 self.headers=[] ## header = { ## "ir_size":None, ## "e_size": None, ## "box_size" :None, ## "vir_size": None, ## "pres_size": None, ## "top_size ": None, ## "sym_size ": None, ## "x_size ": None, ## "v_size ": None, ## "f_size ": None, ## "natoms ": None, ## "step ": None, ## "nre ": None, ## "version":'GMX_trn_file', ## "magicnum" :1993, ## "bDouble ": None, ## } self.file = file self.coords = [] self.velocities = {} self.forces = {} def nFloatSize(self, h): nflsize=0; if h["box_size"]: nflsize = h["box_size"]/(DIM*DIM); elif h["x_size"]: nflsize = h["x_size"]/(h["natoms"]*DIM); elif h["v_size"]: nflsize = h["v_size"]/(h["natoms"]*DIM); elif h["f_size"]: nflsize = h["f_size"]/(h["natoms"]*DIM); else: print "Can not determine precision of trr file" if (nflsize != calcsize("f")) and (nflsize != calcsize("d")): print "Float size %d. Maybe different CPU?"%nflsize return nflsize def read(self): fext = os.path.splitext(self.file)[-1] assert fext == ".trr" fp = open(self.file, "rb") self.data = data = fp.read() self.coords = [] self.v = {} self.f = {} self.up = Unpacker(data) curpos = self.up.get_position() datasize = len(data) nframe = 0 #each frame begins with a header while curpos < datasize: #print "current position:", curpos h = self.readHeader(nframe) self.headers.append(h) self.readData(nframe) nframe = nframe + 1 curpos = self.up.get_position() #print "end of readTraj, cur position : %d, datazize: %d" %(self.up.get_position(), datasize) self.nframes = nframe if self.nframes: return 1 else: return 0 def readHeader(self, nframe): #print "reading header, frame %d" %nframe up = self.up header = {} header["magicnum"] = up.unpack_int() #print "magicnum: ", header["magicnum"] #1993 i1 = up.unpack_int() #13 version = up.unpack_string() #'GMX_trn_file' header["version"] = version #print "version:", version header["ir_size"] = up.unpack_int() #print "ir_size=", header["ir_size"] header["e_size"]=up.unpack_int() #print "e_size=", header["e_size"] header["box_size"] =up.unpack_int() #print "box_size=", header["box_size"] header["vir_size"] = up.unpack_int() #print "vir_size=", header["vir_size"] header["pres_size"] = up.unpack_int() #print "pres_size=", header["pres_size"] header["top_size"]=up.unpack_int() #print "top_size=", header["top_size"] header["sym_size"]=up.unpack_int() #print "sym_size=", header["sym_size"] header["x_size"]=up.unpack_int() #print "x_size=", header["x_size"] header["v_size"]=up.unpack_int() #print "v_size=", header["v_size"] header["f_size"]=up.unpack_int() #print "f_size=", header["f_size"] header["natoms"]=up.unpack_int() #print "natoms=", header["natoms"] header["step"]=up.unpack_int() #print "step=", header["step"] header["nre"]=up.unpack_int() #print "nre=", header["nre"] if self.nFloatSize(header) == calcsize("d"): header["bDouble"] = True else: header["bDouble"] = False if header["bDouble"]: header["time"] = up.unpack_double() header["lam"] = up.umpack_double() else: header["time"] = up.unpack_float() header["lam"] = up.unpack_float() #print "time = ", header["time"] #print "lambda = ", header["lam"] #print "natoms=%10d step=%10d time=%10g lambda=%10g"% (header["natoms"],header["step"],header["time"],header["lam"]) #print "current position:", up.get_position() return header def readData(self, nframe): up = self.up h = self.headers[nframe] box = [] if h["box_size"] != 0 : for i in range(3): box.append(up.unpack_farray(3, up.unpack_float)) #print " box (3x3):" #print box self.headers[nframe]["box"] = box pv = [] if h["vir_size"] != 0: for i in range(3): pv.append(up.unpack_farray(3, up.unpack_float)) #print "pv:" #print pv self.headers[nframe]["pv"] = pv if h["pres_size"]!= 0: pv.append(up.unpack_farray(3, up.unpack_float)) #print "pv:" #print pv self.headers[nframe]["pv"] = pv natoms = h["natoms"] if h["x_size"] != 0: x= [] for i in range (natoms): x.append(up.unpack_farray(3, up.unpack_float)) #self.coords["frame%d"%nframe] = x self.coords.append(x) if h["v_size"] != 0: v = [] for i in range (natoms): v.append(up.unpack_farray(3, up.unpack_float)) self.velocities["frame%d"%nframe] = v if h["f_size"] != 0: f = [] for i in range (natoms): f.append(up.unpack_farray(3, up.unpack_float)) self.forces["frame%d"%nframe] = f
def handle_message(self, opaque_bytes, client_id): """ Handles a message, start to finish. Takes the opaque bytes representing the XDR encoded RPC message. Produces an RPC reply, also encoded as opaque bytes. """ from xdrlib import Unpacker, Packer unpacker = Unpacker(opaque_bytes) msg = rpc_msg.unpack(unpacker) print(msg.body.mtype.value) if msg.body.mtype != msg_type.CALL: print("No reply!") return None # do not reply to such a bad message. #response = self.handle_message(msg, # opaque_bytes[unpacker.get_position():]) print("Well-formed message!") print("rpc version: %d" % msg.body.cbody.rpcvers) print("program id: %d" % msg.body.cbody.prog) print("version id: %d" % msg.body.cbody.vers) print("procedure id: %d" % msg.body.cbody.proc) print("cred flavor: %d" % msg.body.cbody.cred.flavor) print("verf flavor: %d" % msg.body.cbody.verf.flavor) print("remaining bytes: %s" % opaque_bytes[unpacker.get_position():]) if msg.body.cbody.cred.flavor == auth_flavor.AUTH_SYS: print("using system auth") unpacker2 = Unpacker(msg.body.cbody.cred.body.bytes) params = authsys_parms.unpack(unpacker2) print(params) id = self.next_short_id self.next_short_id += 1 self.system_auth[id] = params packer = Packer() packer.pack_uint(id) verf = opaque_auth(flavor=auth_flavor.AUTH_SHORT, body=packer.get_buffer()) else: verf = opaque_auth.NONE() def _pack(reply): packer = Packer() reply.pack(packer) return packer.get_buffer() _body = rpc_msg.body _rbody = reply_body _rreply = rejected_reply _areply = accepted_reply _rdata = accepted_reply.reply_data if msg.body.cbody.rpcvers != 2: reply = rpc_msg(xid=msg.xid, body=_body(mtype=msg_type.REPLY, rbody=_rbody(stat=reply_stat.MSG_DENIED, rreply=_rreply(stat=reject_stat.RPC_MISMATCH, mismatch_info=mismatch_info(low=2, high=2))))) return _pack(reply) if msg.body.cbody.prog not in self.programs: print("no such program!") reply = rpc_msg(xid=msg.xid, body=_body(mtype=msg_type.REPLY, rbody=_rbody(stat=reply_stat.MSG_ACCEPTED, areply=_areply(verf=verf, reply_data=_rdata(stat=accept_stat.PROG_UNAVAIL))))) return _pack(reply) program = self.programs[msg.body.cbody.prog] print("program: %s" % str(program)) version = program.get_version_impl(msg.body.cbody.vers) print("version: %s" % str(version)) procedure = version.get_procedure_by_id(msg.body.cbody.proc) print("procedure: %s" % str(procedure)) print("procedure.arg_type: %s" % str(procedure.argument_type)) args = procedure.argument_type.unpack(unpacker) print("args: %s" % str(args)) response = procedure(version, msg, args) print("response: %s" % str(response)) reply = rpc_msg(xid=msg.xid, body=_body(mtype=msg_type.REPLY, rbody=_rbody(stat=reply_stat.MSG_ACCEPTED, areply=_areply(verf=verf, reply_data=_rdata(stat=accept_stat.SUCCESS))))) print("reply: %s" % str(reply)) packer = Packer() reply.pack(packer) response.pack(packer) print("bytes: %s" % str(packer.get_buffer())) return packer.get_buffer()