def write(self, value, sideEffects=False): """ Write a new value to the register. The value may be a bytearray or a value appropriate to the register type. """ reg = [CADI.CADIReg(self._info.regNumber, 0, i, False, self._info.attribute) for i in xrange(self.__reg_count)] full_array = bytearray(self.__reg_count * 16) if isinstance(value, bytearray): full_array[0 : len(value)] = value elif self.__conversion_str != None: if self.__conversion_str != "": pack_into(self.__conversion_str, full_array, 0, value) elif self._info.display == CADI.CADI_REGTYPE_SYMBOL: if value not in self.__symbols: raise ValueError('"%s" is not a valid symbol for register %s' % self._info.name) pack_into("<I", full_array, 0, self.__symbols.index(value)) elif self._info.display == CADI.CADI_REGTYPE_STRING: full_array[0 : len(value)] = value else: raise TypeError("Expecting a bytearray or %s" % self.__type_str) offset = 0 for r in reg: r.bytes = full_array[offset : (offset + 16)] offset += 16 self.__cadi.CADIRegWrite(reg, sideEffects)
def pack_header(self): """ Given a type and length, pack a header to be sent to the port agent. """ if self.__data is None: log.error('pack_header: no data!') else: # Set the packet type if it was not passed in as parameter if self.__type is None: self.__type = self.DATA_FROM_DRIVER self.set_data_length(len(self.__data)) self.set_timestamp() variable_tuple = (0xa3, 0x9d, 0x7a, self.__type, self.__length + HEADER_SIZE, 0x0000, self.__port_agent_timestamp) header_format = '>BBBBHHd' header_size = struct.calcsize(header_format) temp_header = ctypes.create_string_buffer(header_size) struct.pack_into(header_format, temp_header, 0, *variable_tuple) self.__header = temp_header.raw # do the checksum last, since the checksum needs to include the # populated header fields. # NOTE: This method is only used for test; messages TO the port_agent # do not include a header (as I mistakenly believed when I wrote # this) self.__checksum = self.calculate_checksum() self.__recv_checksum = self.__checksum
def sendChatMessageOIE(self, message): self.typemsgenvoye=4 typeMsg=4 ack=0 res=0 ack_num=0 lengthDatagram=len(message)+len(self.userName)+9 Message=message buf = ctypes.create_string_buffer(lengthDatagram) header=(typeMsg<<28)|(ack<<27)|(res<<26)|(ack_num<<13)|(self.seq_num) if(self.RoomName==ROOM_IDS.MAIN_ROOM): print "envoie de message main room cote client" formatDatagram=">LHHLH"+str(len(Message))+"s" print "********************%d"%self.userId struct.pack_into(formatDatagram, buf,0,header,lengthDatagram,self.userId,0,0,Message) self.EnvoiMsg(buf) else: print "on a envoyé la request pour chat movie room" Movie=self.MovieStore.getMovieByTitle(self.RoomName) IpAdressMovie=Movie.movieIpAddress MoviePort=Movie.moviePort Tab=IpAdressMovie.split('.') formatDatagram=">LHHBBBBH"+str(len(Message))+"s" struct.pack_into(formatDatagram, buf,0,header,lengthDatagram,self.userId,int(Tab[0]),int(Tab[1]),int(Tab[2]),int(Tab[3]),MoviePort,Message) self.EnvoiMsg(buf) print "Request send chat Msg envoyé"
def _boot_pkt(socket, host, op, a1, a2, a3, data=None, offset=0, datasize=0): """ Packs the given data into the format required by the Boot ROM program that executes automatically when SpiNNaker is first turned on. :param socket: stream to write the command to :param host: hostname of the target SpiNNaker :param op: boot ROM command :param arg1: argument 1 -- varies with ``op`` :param arg2: argument 2 -- varies with ``op`` :param arg3: argument 3 -- varies with ``op`` :param data: optional data :param offset: the offset into the data to start from :param datasize: the maximum amount of data to write from the data """ if data is not None: pkt_data = numpy.zeros(datasize + 18, dtype=numpy.uint8) struct.pack_into(">HLLLL", pkt_data, 0, BOOT_PROT_VER, op, a1, a2, a3) off = 0 readsize = datasize if (offset + readsize) > data.size: readsize = data.size - offset while off < readsize: the_word = struct.unpack_from("<I", data, offset + off)[0] struct.pack_into(">I", pkt_data, 18 + off, the_word) off += 4 socket.sendto(pkt_data, (host, BOOT_PORT)) else: hdr = struct.pack(">HLLLL", BOOT_PROT_VER, op, a1, a2, a3) socket.sendto(hdr, (host, BOOT_PORT)) time.sleep(BOOT_DELAY)
def sendJoinRoomRequestOIE(self,roomName): self.RoomName=roomName # il y'avait self.thisRoomName??? ack_num=0 res=0 ack=0 if (roomName!=ROOM_IDS.MAIN_ROOM): self.userStatus=userStatus['waitingfMovieRoomUserList'] self.typemsgenvoye="6" typeMsg=6 msgLength=14 Movie=self.MovieStore.getMovieByTitle(roomName) print Movie.movieTitle IpAdressMovie=Movie.movieIpAddress print IpAdressMovie MoviePort=Movie.moviePort buf=ctypes.create_string_buffer(14) header=(typeMsg<<28)|(ack<<27)|(res<<26)|(ack_num<<13)|(self.seq_num) Tab=IpAdressMovie.split('.') print Tab struct.pack_into(">LHHBBBBH", buf,0,header,msgLength,self.userId,int(Tab[0]),int(Tab[1]),int(Tab[2]),int(Tab[3]),MoviePort) self.EnvoiMsg(buf) else: typeMsg=7 self.userStatus=userStatus['waitingMainRoom'] self.typemsgenvoye="7" msgLength=8 buf=ctypes.create_string_buffer(8) header=(typeMsg<<28)|(ack<<27)|(res<<26)|(ack_num<<13)|(self.seq_num) struct.pack_into(">LHH", buf,0,header,msgLength,self.userId) self.EnvoiMsg(buf) print "Request join movie room envoyé"
def __setitem__(self, position, value): try: offset = self._offset_data_start \ + sum(self._allocated_bytes[:position]) current_format = self._get_packing_format(position) except IndexError: raise IndexError("assignment index out of range") if not isinstance(value, (str, bytes)): new_format = self._types_mapping[type(value)] else: if len(value) > self._allocated_bytes[position]: raise ValueError("exceeds available storage for existing str") if current_format[-1] == "s": new_format = current_format else: new_format = self._types_mapping[str] % ( self._allocated_bytes[position], ) self._set_packing_format_and_transform( position, new_format, value ) value = value.encode(_encoding) if isinstance(value, str) else value struct.pack_into(new_format, self.shm.buf, offset, value)
def SerializeArray(self, value, data_offset, data, handle_offset): size = (serialization.HEADER_STRUCT.size + self.sub_type.GetByteSize() * len(value)) data_end = len(data) position = len(data) + serialization.HEADER_STRUCT.size data.extend(bytearray(size + serialization.NeededPaddingForAlignment(size))) returned_handles = [] to_pack = [] for item in value: (new_data, new_handles) = self.sub_type.Serialize( item, len(data) - position, data, handle_offset + len(returned_handles)) to_pack.extend(serialization.Flatten(new_data)) returned_handles.extend(new_handles) position = position + self.sub_type.GetByteSize() serialization.HEADER_STRUCT.pack_into(data, data_end, size, len(value)) # TODO(azani): Refactor so we don't have to create big formatting strings. struct.pack_into(('%s' % self.sub_type.GetTypeCode()) * len(value), data, data_end + serialization.HEADER_STRUCT.size, *to_pack) return (data_offset, returned_handles)
def updateDossierCompDescr(self, dossierCompDescrArray, offset, size): length = len(self.__data) newSize = length * self.__itemSize if self.__isExpanded: fmt = '<' + self.__itemFormat * length values = [] for key, value in self.__data.iteritems(): values += self.__itemToList(key, value) if newSize == size: struct.pack_into(fmt, dossierCompDescrArray, offset, *values) return (dossierCompDescrArray, newSize) return (dossierCompDescrArray[:offset] + array('c', struct.pack(fmt, *values)) + dossierCompDescrArray[offset + size:], newSize) offsets = self.__offsets for key in self.__changed: recordOffset = offset + offsets[key] struct.pack_into(('<' + self.__itemFormat), dossierCompDescrArray, recordOffset, *self.__itemToList(key, self.__data[key])) self.__changed.clear() if self.__added: values = [] recordOffset = size for key in self.__added: values += self.__itemToList(key, self.__data[key]) offsets[key] = recordOffset recordOffset += self.__itemSize fmt = '<' + self.__itemFormat * len(self.__added) dossierCompDescrArray = dossierCompDescrArray[:offset + size] + array('c', struct.pack(fmt, *values)) + dossierCompDescrArray[offset + size:] self.__added.clear() return (dossierCompDescrArray, newSize)
def updateDossierCompDescr(self, dossierCompDescrArray, offset, size): length = size / self.__itemSize newLength = len(self.__list) newSize = newLength * self.__itemSize if self.__isExpanded: fmt = '<' + self.__itemFormat * newLength values = [] for item in self.__list: values += self.__itemToList(item) if newSize == size: struct.pack_into(fmt, dossierCompDescrArray, offset, *values) return (dossierCompDescrArray, newSize) return (dossierCompDescrArray[:offset] + array('c', struct.pack(fmt, *values)) + dossierCompDescrArray[offset + size:], newSize) for idx in self.__changed: if idx < length: itemOffset = offset + idx * self.__itemSize struct.pack_into(('<' + self.__itemFormat), dossierCompDescrArray, itemOffset, *self.__itemToList(self.__list[idx])) self.__changed.clear() added = self.__list[length:] if added: values = [] for item in added: values += self.__itemToList(item) fmt = '<' + self.__itemFormat * len(added) dossierCompDescrArray = dossierCompDescrArray[:offset + size] + array('c', struct.pack(fmt, *values)) + dossierCompDescrArray[offset + size:] return (dossierCompDescrArray, newSize)
def blockListPacket(context, data): data = bytearray(data) print("[BlockList] Got block list! Updating local cache and rewriting packet...") # Jump to 0x28, 0x88 sep pos = 0x28 while pos < len(data) and data[pos] != 0: name = data[pos:pos+0x40].decode('utf-16le') o1, o2, o3, o4, port = struct.unpack_from('BBBBH', buffer(data), pos+0x40) ipStr = "%i.%i.%i.%i" % (o1, o2, o3, o4) if port not in blocks.blockList: if verbose: print("[BlockList] Discovered new block %s at addr %s:%i! Recording..." % (name, ipStr, port)) blocks.blockList[port] = (ipStr, name) if bNameMode == 0: blockstring = ("%s%s:%i" % (name[:6], ipStr, port)).encode('utf-16le') struct.pack_into('%is' % len(blockstring), data, pos, blockstring) if len(blockstring) < 0x40: struct.pack_into('%ix' % (0x40 - len(blockstring)), data, pos + len(blockstring)) elif bNameMode == 1 and name[:5] in config.blockNames: blockstring = config.blockNames[name[:5]].encode('utf-16le') struct.pack_into('%is' % len(blockstring), data, pos, blockstring) if len(blockstring) < 0x40: struct.pack_into('%ix' % (0x40 - len(blockstring)), data, pos + len(blockstring)) struct.pack_into('BBBB', data, pos+0x40, int(i0), int(i1), int(i2), int(i3)) pos += 0x88 return str(data)
def pack_into(self, buff, offset): """Serialize and write to ``buff`` starting at offset ``offset``. Intentionally follows the pattern of ``struct.pack_into`` :param buff: The buffer to write into :param offset: The offset to start the write at """ if self.partition_key is None: fmt = "!BBii%ds" % len(self.value) args = (self.MAGIC, self.compression_type, -1, len(self.value), self.value) else: fmt = "!BBi%dsi%ds" % (len(self.partition_key), len(self.value)) args = ( self.MAGIC, self.compression_type, len(self.partition_key), self.partition_key, len(self.value), self.value, ) struct.pack_into(fmt, buff, offset + 4, *args) fmt_size = struct.calcsize(fmt) data = buffer(buff[(offset + 4) : (offset + 4 + fmt_size)]) crc = crc32(data) & 0xFFFFFFFF struct.pack_into("!I", buff, offset, crc)
def changeTone(self, v_to, v_from='C'): folder_name = self.samples_folder+'/'+self.instrument.lower() to_filename = v_to.lower().replace('#', 's')+'.raw' from_filename = v_from.lower().replace('#', 's')+'.raw' f = open(folder_name+'/'+from_filename, 'rb') spam = f.read() f.close() i = 0 ratio = float(self.notes[v_to])/self.notes[v_from] out = ctypes.create_string_buffer(int(float(len(spam))/ratio)) while i<int(float(len(spam))/ratio): j = int(float(ratio)*i) j += i%4 - j%4 if j+6<=len(spam): tmp1 = struct.unpack('h', spam[j:j+2])[0] tmp2 = struct.unpack('h', spam[j+4:j+6])[0] tmp = int(tmp1+(tmp2-tmp1)*(ratio-1)) if tmp>256**2: tmp = 256**2 elif tmp<-256**2: tmp = -256**2 struct.pack_into('h', out, i, tmp) i = i+2 f = open(folder_name+'/'+to_filename, 'wb') f.write(out) f.close()
def _pack_packet(hostname, service, state, output, timestamp): """This is more complicated than a call to struct.pack() because we want to pad our strings with random bytes, instead of with zeros.""" requested_length = struct.calcsize(_data_packet_format) packet = array.array('c', '\0'*requested_length) # first, pack the version, initial crc32, timestamp, and state # (collectively:header) header_format = '!hxxLLh' offset = struct.calcsize(header_format) struct.pack_into('!hxxLLh', packet, 0, PACKET_VERSION, 0, timestamp, state) # next, pad & pack the hostname hostname = hostname + '\0' if len(hostname) < MAX_HOSTNAME_LENGTH: hostname += get_random_alphanumeric_bytes(MAX_HOSTNAME_LENGTH - len(hostname)) struct.pack_into('!%ds' % (MAX_HOSTNAME_LENGTH,), packet, offset, hostname) offset += struct.calcsize('!%ds' % (MAX_HOSTNAME_LENGTH,)) # next, pad & pack the service description service = service + '\0' if len(service) < MAX_DESCRIPTION_LENGTH: service += get_random_alphanumeric_bytes(MAX_DESCRIPTION_LENGTH - len(service)) struct.pack_into('%ds' % (MAX_DESCRIPTION_LENGTH,), packet, offset, service) offset += struct.calcsize('!%ds' % (MAX_DESCRIPTION_LENGTH)) # finally, pad & pack the plugin output output = output + '\0' if len(output) < MAX_PLUGINOUTPUT_LENGTH: output += get_random_alphanumeric_bytes(MAX_PLUGINOUTPUT_LENGTH - len(output)) struct.pack_into('%ds' % (MAX_PLUGINOUTPUT_LENGTH,), packet, offset, output) # compute the CRC32 of what we have so far crc_val = binascii.crc32(packet) & 0xffffffffL struct.pack_into('!L', packet, 4, crc_val) return packet.tostring()
def serialize(self, payload=None, prev=None): present = 0 hdr = bytearray() optional = bytearray() if self.checksum is not None: present |= GRE_CHECKSUM_FLG # For purposes of computing the checksum, # the value of the checksum field is zero. # Also, because Reserved1 is always 0x00 of 2 bytes, # Set in conjunction with checksum. optional += b'\x00' * self._CHECKSUM_LEN if self._key is not None: present |= GRE_KEY_FLG optional += struct.pack(self._KEY_PACK_STR, self._key) if self.seq_number is not None: present |= GRE_SEQUENCE_NUM_FLG optional += struct.pack(self._SEQNUM_PACK_STR, self.seq_number) msg_pack_into(self._PACK_STR, hdr, 0, present, self.version, self.protocol) hdr += optional if self.checksum: self.checksum = packet_utils.checksum(hdr) struct.pack_into(self._CHECKSUM_PACK_STR, hdr, self._MIN_LEN, self.checksum) return hdr
def test_checksum(self): """ This tests the checksum algorithm; if somebody changes the algorithm this test should catch it. Had to jump through some hoops to do this; needed to add set_data_length and set_header because we're building our own header here (the one in PortAgentPacket includes the timestamp so the checksum is not consistent). """ test_data = "This tests the checksum algorithm." test_length = len(test_data) self.pap.attach_data(test_data) # Now build a header variable_tuple = (0xa3, 0x9d, 0x7a, self.pap.DATA_FROM_DRIVER, test_length + HEADER_SIZE, 0x0000, 0) self.pap.set_data_length(test_length) header_format = '>BBBBHHd' size = struct.calcsize(header_format) temp_header = ctypes.create_string_buffer(size) struct.pack_into(header_format, temp_header, 0, *variable_tuple) # Now set the header member in PortAgentPacket to the header # we built self.pap.set_header(temp_header.raw) # Now get the checksum and verify it is what we expect it to be. checksum = self.pap.calculate_checksum() self.assertEqual(checksum, 2)
def serialize(self, payload, prev): offset = self.offset << 4 h = bytearray(struct.pack( tcp._PACK_STR, self.src_port, self.dst_port, self.seq, self.ack, offset, self.bits, self.window_size, self.csum, self.urgent)) if self.option: if isinstance(self.option, (list, tuple)): option_buf = bytearray() for opt in self.option: option_buf.extend(opt.serialize()) h.extend(option_buf) mod = len(option_buf) % 4 else: h.extend(self.option) mod = len(self.option) % 4 if mod: h.extend(bytearray(4 - mod)) if self.offset: offset = self.offset << 2 if len(h) < offset: h.extend(bytearray(offset - len(h))) if self.offset == 0: self.offset = len(h) >> 2 offset = self.offset << 4 struct.pack_into('!B', h, 12, offset) if self.csum == 0: total_length = len(h) + len(payload) self.csum = packet_utils.checksum_ip(prev, total_length, h + payload) struct.pack_into('!H', h, 16, self.csum) return six.binary_type(h)
def test3(): class X(object): def __init__(self, a,b): self.a, self.b = a,b # ubyte, float def __eq__(self, other): return self.a == other.a and abs(self.b - other.b) < 1e-6 x = [ X(1, .1), X(2, .2) ] fmt = "=Bf" x_bytes = struct.calcsize(fmt) assert( x_bytes == 5 ) buf = bytearray( len(x) * x_bytes ) for i,n in enumerate(x): struct.pack_into( fmt, buf, i*x_bytes, n.a, n.b ) back = [] count = int( len(buf) / x_bytes ) for i in range(count): ab = struct.unpack_from( fmt, buf, i*x_bytes ) back += [ X(*ab) ] assert( back == x )
def __setitem__(self, idx, value): if not isinstance(idx, int): raise TypeError("Expected an integer index") ptr = ((idx % self.type_size) * self._ctype_size + idx // self.type_size * self.byte_stride) + self.byte_offset struct.pack_into(self._ctype, self._buffer_data, ptr, value)
def sendlistMovie(self,ack_num,seq_num): print "-----------------------" print seq_num typeMsg=3 ack=0 res=0 Data_length = 0 List_Movies=self.serverProxy.getMovieList() print List_Movies Nb_Movies=len(List_Movies) print Nb_Movies for movie in List_Movies: Data_length += len(movie.movieTitle)+7 Msg_length=Data_length+8 buf = ctypes.create_string_buffer(Msg_length) header=(typeMsg<<28)|(ack<<27)|(res<<26)|(ack_num<<13)|(seq_num) struct.pack_into('>LHH',buf,0,header,Msg_length,Nb_Movies) # Header packing pos_buffer=8 for movie in List_Movies: Tab=movie.movieIpAddress.split('.') print movie.movieTitle print("%s"%movie.movieIpAddress) FormatData='>BBBBHB' + str(len(movie.movieTitle)) + 's' struct.pack_into(FormatData,buf,pos_buffer,int(Tab[0]),int(Tab[1]),int(Tab[2]),int(Tab[3]),movie.moviePort,len(movie.movieTitle),movie.movieTitle)# packing each movie pos_buffer+=len(movie.movieTitle)+7 self.EnvoiMsg(buf) print "message a été bien envoyé"
def serialize(self): self.opt_para_len = 0 # use a 2-octets AS number placeholder here, and the # real(maybe 4 octets) AS number is in support_4_octets_as_num # capability. # Note that the "23456" isn't just a random number, it's # defined in RFC4893 two_octet_as = 23456 if self.my_as > 65535 else self.my_as hdr = bytearray(struct.pack(bgp4_open._PACK_STR, self.version, two_octet_as, self.hold_time, self.bgp_identifier.value, self.opt_para_len)) if self.data != []: hdr += bytearray(struct.pack('!BB', self.type_, self.para_len)) for para in self.data: #hdr += bytearray(struct.pack('!BB', para.code, para.length)) cls_ = self._CAPABILITY_ADVERTISEMENT.get(para.code, None) if cls_: hdr += para.serialize() self.para_len += para._MIN_LEN self.opt_para_len = self.para_len + 2 struct.pack_into('!B', hdr, 9, self.opt_para_len) struct.pack_into('!B', hdr, 11, self.para_len) return hdr
def serialize(self): #serialize wd_routes_len and path_attr_len first hdr = bytearray(struct.pack(self._PACK_STR + 'HB', self.flag, self.code, self.length, self.addr_family, self.sub_addr_family)) self.length = 3 # assume in NLRI serialize we only handle IPv6 hdr += bytearray(struct.pack('!B', self.next_hop_len)) self.length += 1 for i in self.next_hop: hdr += bytearray(i.packed) self.length += self.next_hop_len hdr += bytearray(struct.pack('!B', self.reserved)) self.length += 1 #nlri for i in self.nlri: sub_hdr = i.serialize() self.length += len(sub_hdr) hdr += sub_hdr #print '## mp_reach_nlri serialize nlri success' if self._PACK_STR == '!BBH': struct.pack_into('!H', hdr, 2, self.length) else: struct.pack_into('!B', hdr, 2, self.length) return hdr
def toBytes(self, destBuf, newOffset=None, imgDataOffset=None, destOffset=0, order="="): if newOffset is None and self.isOffset: newOffset = self.val if self.isOffset: valFmt = 'L' val = newOffset elif self.isImageDataOffsetEntry() and imgDataOffset: # we are writing image data offsets within this entry; they are not themselves offset # for this to not be offset, there must be only one, since it's a long valFmt = 'L' val = imgDataOffset else: valFmt = lookupTagType(self.type).fmt * self.count val = self.val fmt = order+"HHI"+valFmt fmtSize = struct.calcsize(fmt) if fmtSize < 12: fmt += 'x'*(12-fmtSize) packing = [self.tag, self.type, self.count] if isinstance(val, tuple): packing += list(val) else: packing.append(val) struct.pack_into(fmt, destBuf, destOffset, *packing) return 12
def comms_on(): sock = Udpsocket([]) data = ctypes.create_string_buffer(13) data[0:9] = 'RF SW CMD' struct.pack_into("<I", data, 9, settings.RF_SW_CMD_ON_INT) d = bytearray(data) sock.sendto(d, (packet_settings.FRAME_RECEIVER_IP, packet_settings.FRAME_RECEIVER_PORT))
def scan_rays(rays, max_distance, ray_origins=False, keep_render_setup=False, do_shading=True): elementsPerRay = 3 if ray_origins == True: elementsPerRay = 6 numberOfRays = int(len(rays)/elementsPerRay) rays_buffer = (ctypes.c_float * numberOfRays*elementsPerRay)() struct.pack_into("%df"%(numberOfRays*elementsPerRay), rays_buffer, 0, *rays[:numberOfRays*elementsPerRay]) returns_buffer = (ctypes.c_float * (numberOfRays * ELEMENTS_PER_RETURN))() print ("Raycount: ", numberOfRays) returns_buffer_uint = ctypes.cast(returns_buffer, ctypes.POINTER(ctypes.c_uint)) array_of_returns = [] try: bpy.ops.render.blensor(raycount = numberOfRays,maximum_distance = max_distance, vector_strptr="%016X"%(ctypes.addressof(rays_buffer)), return_vector_strptr="%016X"%(ctypes.addressof(returns_buffer)), elements_per_ray = elementsPerRay, keep_render_setup=keep_render_setup, shading = do_shading) for idx in range(numberOfRays): if returns_buffer[idx*ELEMENTS_PER_RETURN] < max_distance and returns_buffer[idx*ELEMENTS_PER_RETURN]>0.0 : #The ray may have been reflecten and refracted. But the laser #does not know that so we need to calculate the point which #is the measured distance away from the sensor but without #beeing reflected/refracted. We use the original ray direction vec = [float(rays[idx*elementsPerRay]), float(rays[idx*elementsPerRay+1]), float(rays[idx*elementsPerRay+2])] veclen = math.sqrt(vec[0]**2+vec[1]**2+vec[2]**2) raydistance = float(returns_buffer[idx*ELEMENTS_PER_RETURN]) vec[0] = raydistance * vec[0]/veclen vec[1] = raydistance * vec[1]/veclen vec[2] = raydistance * vec[2]/veclen ret = [ float(returns_buffer[e + idx*ELEMENTS_PER_RETURN]) for e in range(4) ] ret[1] = vec[0] ret[2] = vec[1] ret[3] = vec[2] ret.append(returns_buffer_uint[idx*ELEMENTS_PER_RETURN+4]) #objectid ret.append((returns_buffer[idx*ELEMENTS_PER_RETURN+5], returns_buffer[idx*ELEMENTS_PER_RETURN+6], returns_buffer[idx*ELEMENTS_PER_RETURN+7])) # RGB Value of the material ret.append(idx) # Store the index per return as the last element array_of_returns.append(ret) except TypeError as e: exc_type, exc_value, exc_traceback = sys.exc_info() traceback.print_tb(exc_traceback) finally: del rays_buffer del returns_buffer return array_of_returns
async def initial_connection(self, data): state = self._connection state.ssrc = data['ssrc'] state.voice_port = data['port'] packet = bytearray(70) struct.pack_into('>I', packet, 0, state.ssrc) state.socket.sendto(packet, (state.endpoint_ip, state.voice_port)) recv = await self.loop.sock_recv(state.socket, 70) log.debug('received packet in initial_connection: %s', recv) # the ip is ascii starting at the 4th byte and ending at the first null ip_start = 4 ip_end = recv.index(0, ip_start) state.ip = recv[ip_start:ip_end].decode('ascii') # the port is a little endian unsigned short in the last two bytes # yes, this is different endianness from everything else state.port = struct.unpack_from('<H', recv, len(recv) - 2)[0] log.debug('detected ip: %s port: %s', state.ip, state.port) # there *should* always be at least one supported mode (xsalsa20_poly1305) modes = [mode for mode in data['modes'] if mode in self._connection.supported_modes] log.debug('received supported encryption modes: %s', ", ".join(modes)) mode = modes[0] await self.select_protocol(state.ip, state.port, mode) log.info('selected the voice protocol for use (%s)', mode) await self.client_connect()
def icmpv6_csum(prev, buf): ph = struct.pack('!16s16sBBH', prev.src, prev.dst, 0, prev.nxt, prev.payload_length) h = bytearray(buf) struct.pack_into('!H', h, 2, 0) return socket.htons(packet_utils.checksum(ph + h))
def throttle(self,speed,direction): ''' This method controls the train's throttle. The two parameters are: speed 0 - 127 where 0 = stop direction 0 - FORWARD 1 - REVERSE For imformation about the message sent by this method refer to the XpressNet protocol: 'Locomotive speed and direction operations' example: t1.throttle(15,FORWARD) # move train forward with a speed of 15 steps t1.throttle(0,FORWARD) # stop train ''' message = bytearray('E400000000'.decode('hex')) message[1] = 0x13 #128 speed steps struct.pack_into(">H",message,2,self.address) # NB If speed is set to max, the command has to be done differently # else the elink bombs, so it is just easier to block it. if speed > 120: speed = 120 message[4] = speed if direction == FORWARD : message[4] |= 0x80 elif direction == REVERSE : message[4] &= 0x7F parity(message) send (message)
def pdpte_create_binary_file(self): # pae needs a pdpte at 32byte aligned address # Even though we have only 4 entries in the pdpte we need to move # the self.output_offset variable to the next page to start pushing # the pd contents # # FIXME: This wastes a ton of RAM!! if args.verbose: print("PDPTE at 0x%x" % self.pd_start_addr) for pdpte in range(self.total_pages + 1): if pdpte in self.get_pdpte_list(): present = 1 << 0 addr_of_pd = (((self.pd_start_addr + 4096) + self.get_pdpte_list().index(pdpte) * 4096) >> 12) << 12 binary_value = (present | addr_of_pd) else: binary_value = 0 struct.pack_into(page_entry_format, self.output_buffer, self.output_offset, binary_value) self.output_offset += struct.calcsize(page_entry_format)
def set(self, value): """ If a primitive, assigns data. Complex objects should raise a ValueError. """ struct.pack_into(self.pack, self.buf, self.offset, value)
def pack_into_format(frg,ack,type_field,rt,seq_number, u_id, d_id, data_length): # buff = ctypes.create_string_buffer(HEADER_L+data_length) # first_byte = 0b00000000 # in case the rt or type_field are higher than normal if( len(bin(rt))-2 > RT_L): sys.exit('ERROR : RT = '+format(rt)+' - * RT (Room Type) field is too big * -') first_byte += rt if(len(bin(type_field))-2 > TYPE_FIELD_L): sys.exit('ERROR : Type = '+format(type_field)+' - * Type field is too big * -') first_byte += type_field << 2 # frg and ack fields can be either True (1) or False (0) if frg: first_byte += 0b10000000 if ack: first_byte += 0b01000000 # if(seq_number>255 or u_id >255 or d_id > 255): sys.exit('Error : Sequence Number, User Id or Destination Id field is too big'+ '') struct.pack_into(HEADER_FORMAT, buff, 0, first_byte, seq_number, u_id, d_id, data_length) # data_length is the length of the data in bytes # struct.pack_into(format(data_length)+'B',buff, HEADER_L, data) return buff
def offsets_accelerometer(self, offsets): data = bytearray(6) struct.pack_into("<hhh", data, 0, *offsets) self._write_register(_OFFSET_ACCEL_REGISTER, bytes(data))
def pack(self, buffer, offset): """ Construts a packed c structure for the protocol header :return: bytes """ return struct.pack_into(self.struct_format, buffer, offset, 0, self.type, 0)
def pack(self, buffer, offset): """ Constructs a packed c structure from properties and provided target :return: byte array """ struct.pack_into(self.struct_format, buffer, offset, self.target, 0,0,0,0,0,0, self.binary_field, self.sequence)
def radius_magnetometer(self, radius): data = bytearray(2) struct.pack_into("<h", data, 0, radius) self._write_register(_RADIUS_MAGNET_REGISTER, bytes(data))
def radius_accelerometer(self, radius): data = bytearray(2) struct.pack_into("<h", data, 0, radius) self._write_register(_RADIUS_ACCEL_REGISTER, bytes(data))
def offsets_gyroscope(self, offsets): data = bytearray(6) struct.pack_into("<hhh", data, 0, *offsets) self._write_register(_OFFSET_GYRO_REGISTER, bytes(data))
def offsets_magnetometer(self, offsets): data = bytearray(6) struct.pack_into("<hhh", data, 0, *offsets) self._write_register(_OFFSET_MAGNET_REGISTER, bytes(data))
def swap16(data, offs): struct.pack_into("<H", data, offs, struct.unpack_from(">H", data, offs)[0])
def main(): """ Multicast example, sender part. An example where data is read from a file, encoded, and then send via the network. """ parser = argparse.ArgumentParser(description=main.__doc__) """The parser takes a path to a file as input.""" parser.add_argument( "--file-path", type=str, help="Path to the file which should be sent.", default=os.path.realpath(__file__), ) """The parser takes the target IP-address as input.""" parser.add_argument("--ip", type=str, help="The IP address to send to.", default=MCAST_GRP) """The parser takes the target port as input.""" parser.add_argument("--port", type=int, help="The port to send to.", default=MCAST_PORT) """One can tell the parser to run without using the network.""" parser.add_argument("--dry-run", action="store_true", help="Run without network use.") args = parser.parse_args() # Check the file. if not os.path.isfile(args.file_path): print("{} is not a valid file.".format(args.file_path)) sys.exit(1) file_stats = os.stat(args.file_path) block_bytes = file_stats.st_size symbol_bytes = 1400 symbols = block_bytes // symbol_bytes + 1 width = kodo.perpetual.Width._8 # Create and configure the encoder, coefficient generator and offset generator. encoder = kodo.perpetual.Encoder(width) encoder.configure(block_bytes, symbol_bytes) generator = kodo.perpetual.generator.RandomUniform(width) offset_generator = kodo.perpetual.offset.RandomUniform() offset_generator.configure(symbols) sock = socket.socket(family=socket.AF_INET, type=socket.SOCK_DGRAM, proto=socket.IPPROTO_UDP) sock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 2) # Read the input data from the file, only the block_bytes first bytes # can fit into a single generation. No more data will be sent. # If the file is smaller than block_bytes then it will be zero-padded. f = open(os.path.expanduser(args.file_path), "rb") data_in = bytearray(f.read().ljust(encoder.block_bytes)) f.close() # Assign the data_in buffer to the encoder symbol_storage. encoder.set_symbols_storage(data_in) if args.dry_run: sys.exit(0) address = (args.ip, args.port) header_data = bytearray(27) print("Processing...") while True and not args.dry_run: time.sleep(0.2) # Generate an encoded packet. seed = random.randint(0, 2**64 - 1) offset = offset_generator.offset() coefficients = generator.generate(seed) symbol = encoder.encode_symbol(coefficients, offset) struct.pack_into( "<QQBIIH", header_data, 0, seed, offset, width.value, block_bytes, symbol_bytes, width, ) # Send the encoded packet with seed and offset. packet = header_data + symbol sock.sendto(packet, address) print("Packet sent!")
def packData(self): struct.pack_into(self.DataPatern, self.data, self.DataOffset, *list(self.ds1.values()))
def _build_loop_code(o_code, with_start, with_end, loop_count): code = type(o_code) # With statement: # # Header: # # 0 LOAD_GLOBAL n (context_manager) # 3 SETUP_WITH xx (to zz+4) # 6 STORE_FAST m (context_manager variable (with ... as foobar)) # # Body: # 9 <code_string> # # Footer: # # zz+0 POP_BLOCK # zz+1 LOAD_CONST p (None) # >> zz+4 WITH_CLEANUP # zz+5 END_FINALLY # zz+6 LOAD_CONST p (None) # zz+9 RETURN_VALUE # move past the SETUP_WITH opcode (1 byte opcode itself + 2 bytes delta) code_start = with_start + 3 # skip the next bytecode which can be one of POP_TOP, STORE_FAST, STORE_NAME, UNPACK_SEQUENCE (POP_TOP is 1 byte, the others are 3) if ord(o_code.co_code[code_start]) == dis.opmap['POP_TOP']: code_start += 1 else: code_start += 3 # at the end there is a POP_BLOCK + LOAD_CONST (index) (1 + 3 = 4 bytes) code_end = with_end - 4 code_bytes = bytearray(o_code.co_code[code_start:code_end]) try: xrange except NameError: names = o_code.co_names + ('range', ) else: names = o_code.co_names + ('xrange', ) code_constants = o_code.co_consts + (loop_count, ) # Loop header: # # 0 SETUP_LOOP xx (to zz+4) # 3 LOAD_NAME n (xrange) # 6 LOAD_CONST m (1000) # 9 CALL_FUNCTION 1 # 12 GET_ITER # >> 13 FOR_ITER yy (to zz+3) # 16 POP_TOP # # Code body: # 17 <code_bytes> # # Loop footer: # # zz+0 JUMP_ABSOLUTE 13 # >> zz+3 POP_BLOCK # >> zz+4 LOAD_CONST l (None) # zz+7 RETURN_VALUE # # zz = len(loop_header) + len(code_bytes) # xx + 3 == zz + 4 -> xx = len(loop_header) + len(code_bytes) + 4 - 3 = len(loop_header) + len(code_bytes) + 1 # yy + 16 == zz + 3 -> yy = len(loop_header) + len(code_bytes) + 3 - 16 = len(loop_header) + len(code_bytes) - 13 (13 is the FOR_ITER bytecode offset) loop_header = bytearray( '\x78\x00\x00\x65\x00\x00\x64\x00\x00\x83\x01\x00\x44\x5d\x00\x00\x01' ) loop_footer = bytearray('\x71\x0d\x00\x57\x64\x00\x00\x53') struct.pack_into('<H', loop_header, 1, len(loop_header) + len(code_bytes) + 1) # SETUP_LOOP delta (xx) # LOAD_NAME index for range function struct.pack_into('<H', loop_header, 4, len(names) - 1) # LOAD_CONST index for loop count struct.pack_into('<H', loop_header, 7, len(code_constants) - 1) struct.pack_into('<H', loop_header, 14, len(loop_header) + len(code_bytes) - 13) # FOR_ITER delta (yy) struct.pack_into( '<H', loop_footer, 5, code_constants.index(None)) # LOAD_CONST index for None # adjust the jump addresses within the original code block to match the new bytecode offset they will have within the for loop index = 0 code_length = len(code_bytes) offset = len(loop_header) - code_start while index < code_length: opcode = code_bytes[index] index += 1 if opcode >= dis.HAVE_ARGUMENT: if opcode in dis.hasjabs: jump_address = struct.unpack_from('<H', code_bytes, index)[0] struct.pack_into('<H', code_bytes, index, jump_address + offset) index += 2 new_code_bytes = bytes(loop_header + code_bytes + loop_footer) # adjust the line numbers table class WithinCodeRange(object): def __init__(self, size): self.limit = size self.bytes = 0 def __call__(self, increment_pair): byte_increment, line_increment = increment_pair self.bytes += byte_increment return self.bytes < self.limit byte_increments = deque(bytearray(o_code.co_lnotab[0::2])) line_increments = deque(bytearray(o_code.co_lnotab[1::2])) byte_offset = line_offset = 0 while byte_offset < code_start: byte_offset += byte_increments.popleft() line_offset += line_increments.popleft() byte_increments.appendleft(len(loop_header)) line_increments.appendleft(1) line_numbers_table = bytes( bytearray( chain.from_iterable( takewhile(WithinCodeRange(len(loop_header + code_bytes)), zip(byte_increments, line_increments))))) return code(o_code.co_argcount, o_code.co_nlocals, o_code.co_stacksize, o_code.co_flags, new_code_bytes, code_constants, names, o_code.co_varnames, o_code.co_filename, o_code.co_name, o_code.co_firstlineno + line_offset - 1, line_numbers_table, o_code.co_freevars, o_code.co_cellvars)
def swap32(data, offs): struct.pack_into("<I", data, offs, struct.unpack_from(">I", data, offs)[0])
# Read in the original ROM if romFileName != "": print("File '" + romFileName + "' found.") with open(romFileName, mode="rb") as file: fileContent = bytearray(file.read()) # Check if ROM needs to be byte swapped if fileContent[0] == 0x40: # Byte Swap ROM # TODO: This is pretty slow at the moment. Look into optimizing it later... print("ROM needs to be byte swapped...") i = 0 while i < len(fileContent): tmp = struct.unpack_from("BBBB", fileContent, i) struct.pack_into("BBBB", fileContent, i + 0, tmp[3], tmp[2], tmp[1], tmp[0]) i += 4 perc = float(i) / float(len(fileContent)) if i % (1024 * 1024 * 4) == 0: print(str(perc * 100) + "%") print("Byte swapping done.") else: print("Error: Could not find baserom_original.z64/baserom_original.n64.") sys.exit(1) # Strip the overdump print("Stripping overdump...") strippedContent = list(fileContent[0:0x3600000])
def _put_sample(cp, size, i, val, signed=True): fmt = _struct_format(size, signed) struct.pack_into(fmt, cp, i * size, val)
def test_read_partial_netlink_msgs(self, m_read_netlink_socket, m_socket): '''Read partial messages in receive call''' ifname = "eth0" bytes = ifname.encode("utf-8") data1 = bytearray(112) data2 = bytearray(32) struct.pack_into("=LHHLL", data1, 0, 48, RTM_NEWLINK, 0, 0, 0) struct.pack_into("HH4sHHc", data1, RTATTR_START_OFFSET, 8, 3, bytes, 5, 16, int_to_bytes(OPER_DOWN)) struct.pack_into("=LHHLL", data1, 48, 48, RTM_NEWLINK, 0, 0, 0) struct.pack_into("HH4sHHc", data1, 80, 8, 3, bytes, 5, 16, int_to_bytes(OPER_DOWN)) struct.pack_into("=LHHLL", data1, 96, 48, RTM_NEWLINK, 0, 0, 0) struct.pack_into("HH4sHHc", data2, 16, 8, 3, bytes, 5, 16, int_to_bytes(OPER_UP)) m_read_netlink_socket.side_effect = [data1, data2] wait_for_media_disconnect_connect(m_socket, ifname) self.assertEqual(m_read_netlink_socket.call_count, 2)
def do_relocation_text(env, text_addr, r): # Extract relevant info about symbol that's being relocated s = r.sym s_bind = s.entry["st_info"]["bind"] s_shndx = s.entry["st_shndx"] s_type = s.entry["st_info"]["type"] r_offset = r["r_offset"] + text_addr r_info_type = r["r_info_type"] try: # only for RELA sections r_addend = r["r_addend"] except KeyError: r_addend = 0 # Default relocation type and name for logging reloc_type = "le32" log_name = None if (env.arch.name == "EM_386" and r_info_type in (R_386_PC32, R_386_PLT32) or env.arch.name == "EM_X86_64" and r_info_type in (R_X86_64_PC32, R_X86_64_PLT32) or env.arch.name == "EM_ARM" and r_info_type in (R_ARM_REL32, R_ARM_THM_CALL, R_ARM_THM_JUMP24) or s_bind == "STB_LOCAL" and env.arch.name == "EM_XTENSA" and r_info_type == R_XTENSA_32 # not GOT ): # Standard relocation to fixed location within text/rodata if hasattr(s, "resolved"): s = s.resolved sec = s.section if env.arch.separate_rodata and sec.name.startswith(".rodata"): raise LinkError( "fixed relocation to rodata with rodata referenced via GOT") if sec.name.startswith(".bss"): raise LinkError( "{}: fixed relocation to bss (bss variables can't be static)". format(s.filename)) if sec.name.startswith(".external"): raise LinkError( "{}: fixed relocation to external symbol: {}".format( s.filename, s.name)) addr = sec.addr + s["st_value"] reloc = addr - r_offset + r_addend if r_info_type in (R_ARM_THM_CALL, R_ARM_THM_JUMP24): # Both relocations have the same bit pattern to rewrite: # R_ARM_THM_CALL: bl # R_ARM_THM_JUMP24: b.w reloc_type = "thumb_b" elif (env.arch.name == "EM_386" and r_info_type == R_386_GOTPC or env.arch.name == "EM_ARM" and r_info_type == R_ARM_BASE_PREL): # Relocation to GOT address itself assert s.name == "_GLOBAL_OFFSET_TABLE_" addr = env.got_section.addr reloc = addr - r_offset + r_addend elif (env.arch.name == "EM_386" and r_info_type in (R_386_GOT32, R_386_GOT32X) or env.arch.name == "EM_ARM" and r_info_type == R_ARM_GOT_BREL): # Relcation pointing to GOT reloc = addr = env.got_entries[s.name].offset elif env.arch.name == "EM_X86_64" and r_info_type in ( R_X86_64_GOTPCREL, R_X86_64_REX_GOTPCRELX, ): # Relcation pointing to GOT got_entry = env.got_entries[s.name] addr = env.got_section.addr + got_entry.offset reloc = addr - r_offset + r_addend elif env.arch.name == "EM_386" and r_info_type == R_386_GOTOFF: # Relocation relative to GOT addr = s.section.addr + s["st_value"] reloc = addr - env.got_section.addr + r_addend elif env.arch.name == "EM_XTENSA" and r_info_type == R_XTENSA_SLOT0_OP: # Relocation pointing to GOT, xtensa specific sec = s.section if sec.name.startswith(".text"): # it looks like R_XTENSA_SLOT0_OP into .text is already correctly relocated return assert sec.name.startswith(".literal"), sec.name lit_idx = "{}+0x{:x}".format(sec.filename, r_addend) lit_ptr = env.xt_literals[lit_idx] if isinstance(lit_ptr, str): addr = env.got_section.addr + env.got_entries[lit_ptr].offset log_name = "GOT {}".format(lit_ptr) else: addr = env.lit_section.addr + env.lit_entries[lit_ptr].offset log_name = "LIT" reloc = addr - r_offset reloc_type = "xtensa_l32r" elif env.arch.name == "EM_XTENSA" and r_info_type == R_XTENSA_DIFF32: if s.section.name.startswith(".text"): # it looks like R_XTENSA_DIFF32 into .text is already correctly relocated return assert 0 else: # Unknown/unsupported relocation assert 0, r_info_type # Write relocation if reloc_type == "le32": (existing, ) = struct.unpack_from("<I", env.full_text, r_offset) struct.pack_into("<I", env.full_text, r_offset, (existing + reloc) & 0xFFFFFFFF) elif reloc_type == "thumb_b": b_h, b_l = struct.unpack_from("<HH", env.full_text, r_offset) existing = (b_h & 0x7FF) << 12 | (b_l & 0x7FF) << 1 if existing >= 0x400000: # 2's complement existing -= 0x800000 new = existing + reloc b_h = (b_h & 0xF800) | (new >> 12) & 0x7FF b_l = (b_l & 0xF800) | (new >> 1) & 0x7FF struct.pack_into("<HH", env.full_text, r_offset, b_h, b_l) elif reloc_type == "xtensa_l32r": l32r = unpack_u24le(env.full_text, r_offset) assert l32r & 0xF == 1 # RI16 encoded l32r l32r_imm16 = l32r >> 8 l32r_imm16 = (l32r_imm16 + reloc >> 2) & 0xFFFF l32r = l32r & 0xFF | l32r_imm16 << 8 pack_u24le(env.full_text, r_offset, l32r) else: assert 0, reloc_type # Log information about relocation if log_name is None: if s_type == "STT_SECTION": log_name = s.section.name else: log_name = s.name log(LOG_LEVEL_3, " {:08x} {} -> {:08x}".format(r_offset, log_name, addr))
def f64_store(self, addr: int, value: float) -> None: self._check_addr(addr) struct.pack_into("d", self.memory_view, addr, float(value))
def do_relocation_text(env, text_addr, r): # Extract relevant info about symbol that's being relocated s = r.sym s_bind = s.entry['st_info']['bind'] s_shndx = s.entry['st_shndx'] s_type = s.entry['st_info']['type'] r_offset = r['r_offset'] + text_addr r_info_type = r['r_info_type'] try: # only for RELA sections r_addend = r['r_addend'] except KeyError: r_addend = 0 # Default relocation type and name for logging reloc_type = 'le32' log_name = None if (env.arch.name == 'EM_386' and r_info_type in (R_386_PC32, R_386_PLT32) or env.arch.name == 'EM_X86_64' and r_info_type in (R_X86_64_PC32, R_X86_64_PLT32) or env.arch.name == 'EM_ARM' and r_info_type in (R_ARM_REL32, R_ARM_THM_CALL, R_ARM_THM_JUMP24) or s_bind == 'STB_LOCAL' and env.arch.name == 'EM_XTENSA' and r_info_type == R_XTENSA_32 # not GOT ): # Standard relocation to fixed location within text/rodata if hasattr(s, 'resolved'): s = s.resolved sec = s.section if env.arch.separate_rodata and sec.name.startswith('.rodata'): raise LinkError('fixed relocation to rodata with rodata referenced via GOT') if sec.name.startswith('.bss'): raise LinkError('{}: fixed relocation to bss (bss variables can\'t be static)'.format(s.filename)) if sec.name.startswith('.external'): raise LinkError('{}: fixed relocation to external symbol: {}'.format(s.filename, s.name)) addr = sec.addr + s['st_value'] reloc = addr - r_offset + r_addend if r_info_type in (R_ARM_THM_CALL, R_ARM_THM_JUMP24): # Both relocations have the same bit pattern to rewrite: # R_ARM_THM_CALL: bl # R_ARM_THM_JUMP24: b.w reloc_type = 'thumb_b' elif (env.arch.name == 'EM_386' and r_info_type == R_386_GOTPC or env.arch.name == 'EM_ARM' and r_info_type == R_ARM_BASE_PREL ): # Relocation to GOT address itself assert s.name == '_GLOBAL_OFFSET_TABLE_' addr = env.got_section.addr reloc = addr - r_offset + r_addend elif (env.arch.name == 'EM_386' and r_info_type in (R_386_GOT32, R_386_GOT32X) or env.arch.name == 'EM_ARM' and r_info_type == R_ARM_GOT_BREL ): # Relcation pointing to GOT reloc = addr = env.got_entries[s.name].offset elif env.arch.name == 'EM_X86_64' and r_info_type == R_X86_64_REX_GOTPCRELX: # Relcation pointing to GOT got_entry = env.got_entries[s.name] addr = env.got_section.addr + got_entry.offset reloc = addr - r_offset + r_addend elif env.arch.name == 'EM_386' and r_info_type == R_386_GOTOFF: # Relocation relative to GOT addr = s.section.addr + s['st_value'] reloc = addr - env.got_section.addr + r_addend elif env.arch.name == 'EM_XTENSA' and r_info_type == R_XTENSA_SLOT0_OP: # Relocation pointing to GOT, xtensa specific sec = s.section if sec.name.startswith('.text'): # it looks like R_XTENSA_SLOT0_OP into .text is already correctly relocated return assert sec.name.startswith('.literal'), sec.name lit_idx = '{}+0x{:x}'.format(sec.filename, r_addend) lit_ptr = env.xt_literals[lit_idx] if isinstance(lit_ptr, str): addr = env.got_section.addr + env.got_entries[lit_ptr].offset log_name = 'GOT {}'.format(lit_ptr) else: addr = env.lit_section.addr + env.lit_entries[lit_ptr].offset log_name = 'LIT' reloc = addr - r_offset reloc_type = 'xtensa_l32r' elif env.arch.name == 'EM_XTENSA' and r_info_type == R_XTENSA_DIFF32: if s.section.name.startswith('.text'): # it looks like R_XTENSA_DIFF32 into .text is already correctly relocated return assert 0 else: # Unknown/unsupported relocation assert 0, r_info_type # Write relocation if reloc_type == 'le32': existing, = struct.unpack_from('<I', env.full_text, r_offset) struct.pack_into('<I', env.full_text, r_offset, (existing + reloc) & 0xffffffff) elif reloc_type == 'thumb_b': b_h, b_l = struct.unpack_from('<HH', env.full_text, r_offset) existing = (b_h & 0x7ff) << 12 | (b_l & 0x7ff) << 1 if existing >= 0x400000: # 2's complement existing -= 0x800000 new = existing + reloc b_h = (b_h & 0xf800) | (new >> 12) & 0x7ff b_l = (b_l & 0xf800) | (new >> 1) & 0x7ff struct.pack_into('<HH', env.full_text, r_offset, b_h, b_l) elif reloc_type == 'xtensa_l32r': l32r = unpack_u24le(env.full_text, r_offset) assert l32r & 0xf == 1 # RI16 encoded l32r l32r_imm16 = l32r >> 8 l32r_imm16 = (l32r_imm16 + reloc >> 2) & 0xffff l32r = l32r & 0xff | l32r_imm16 << 8 pack_u24le(env.full_text, r_offset, l32r) else: assert 0, reloc_type # Log information about relocation if log_name is None: if s_type == 'STT_SECTION': log_name = s.section.name else: log_name = s.name log(LOG_LEVEL_3, ' {:08x} {} -> {:08x}'.format(r_offset, log_name, addr))
iv=VALUES["frame_base"].iv, ciphertext=VALUES["frame_base"].ciphertext, tag=VALUES["frame_base"].tag, sequence_number=2, final_frame=False, ) VALUES["deserialized_body_final_frame_3"] = MessageFrameBody( iv=VALUES["final_frame_base"].iv, ciphertext=VALUES["final_frame_base"].ciphertext, tag=VALUES["final_frame_base"].tag, sequence_number=3, final_frame=True, ) VALUES["serialized_header_invalid_object_type"] = bytearray( VALUES["serialized_header"]) struct.pack_into(">B", VALUES["serialized_header_invalid_object_type"], 1, 0) VALUES["serialized_header_invalid_object_type"] = array_byte( VALUES["serialized_header_invalid_object_type"]) VALUES["serialized_header_invalid_version"] = bytearray( VALUES["serialized_header"]) struct.pack_into(">B", VALUES["serialized_header_invalid_version"], 0, 0) VALUES["serialized_header_invalid_version"] = array_byte( VALUES["serialized_header_invalid_version"]) VALUES["serialized_header_invalid_algorithm"] = VALUES["serialized_header"] VALUES["serialized_header_disallowed_algorithm"] = VALUES["serialized_header"] header_value_position = 22 header_value_position += len(VALUES["serialized_encryption_context"]) header_value_position += 2 header_value_position += len(VALUES["serialized_encrypted_data_key"]) VALUES["serialized_header_unknown_content_type"] = bytearray( VALUES["serialized_header"])
def write_frame(type_, channel, method_sig, args, content): chunk_size = connection.frame_max - 8 offset = 0 properties = None args = str_to_bytes(args) if content: properties = content._serialize_properties() body = content.body bodylen = len(body) framelen = ( len(args) + (len(properties) or 0) + bodylen + FRAME_OVERHEAD ) bigbody = framelen > chunk_size else: body, bodylen, bigbody = None, 0, 0 if bigbody: # ## SLOW: string copy and write for every frame frame = (b''.join([pack('>HH', *method_sig), args]) if type_ == 1 else b'') # encode method frame framelen = len(frame) write(pack('>BHI%dsB' % framelen, type_, channel, framelen, frame, 0xce)) if body: frame = b''.join([ pack('>HHQ', method_sig[0], 0, len(body)), properties, ]) framelen = len(frame) write(pack('>BHI%dsB' % framelen, 2, channel, framelen, frame, 0xce)) for i in range(0, bodylen, chunk_size): frame = body[i:i + chunk_size] framelen = len(frame) write(pack('>BHI%dsB' % framelen, 3, channel, framelen, str_to_bytes(frame), 0xce)) else: # ## FAST: pack into buffer and single write frame = (b''.join([pack('>HH', *method_sig), args]) if type_ == 1 else b'') framelen = len(frame) pack_into('>BHI%dsB' % framelen, buf, offset, type_, channel, framelen, frame, 0xce) offset += 8 + framelen if body: frame = b''.join([ pack('>HHQ', method_sig[0], 0, len(body)), properties, ]) framelen = len(frame) pack_into('>BHI%dsB' % framelen, buf, offset, 2, channel, framelen, frame, 0xce) offset += 8 + framelen framelen = len(body) pack_into('>BHI%dsB' % framelen, buf, offset, 3, channel, framelen, str_to_bytes(body), 0xce) offset += 8 + framelen write(view[:offset]) connection.bytes_sent += 1
def perform(self, cmd, msg, tail=None): t0 = ticks() # times the entire command rcv_at = ticks() # last received message for timeout purposes got_error = None # flag to signal the end, False->OK; True->abort with raise sz = 0 next_seq = 0 # next expected sequence number ack = -1 # ack for flow-control subscribed = False # flag to pop out of loop waiting for subscription output = b"" # output ultimately returned from perform # generate an ID we can use for the MQTT topics to match replies self._topic_id = MQTT._gen_id(6) def on_reply(cli, ud, msg): nonlocal sz, next_seq, ack, rcv_at, output, got_error self.debug( f"Received reply on topic '{msg.topic}' with QoS {msg.qos}") # parse message header if len(msg.payload) < 2: return seq = ((msg.payload[0] & 0x7F) << 8) | msg.payload[1] last = (msg.payload[0] & 0x80) != 0 # check sequence number if seq < next_seq: self.debug( f"Duplicate message, expected seq={next_seq}, got {seq}") return if seq > next_seq: raise click.ClickException( f"Missing message(s), expected seq={next_seq}, got {seq}") # handle ACK for long streams (a bit of a hack!) if len(msg.payload) - 2 < 10 and msg.payload[2:].startswith( b"SEQ "): try: s = int(msg.payload[6:]) if s > ack: ack = s print(".", end="") return except ValueError: raise click.ClickException("Bad ACK received") sz += len(msg.payload) - 2 output += msg.payload[2:] rcv_at = ticks() if last: dt = ticks() - t0 self.debug("{:.3f}kB in {:.3f}s -> {:.3f}kB/s".format( sz / 1024, dt, sz / 1024 / dt)) got_error = False def on_error(cli, ud, message): nonlocal got_error click.echo(message.payload.strip(), err=True) got_error = True def on_sub(client, userdata, mid, granted_qos): nonlocal subscribed subscribed = True def loop(): if ticks() - rcv_at > self._timeout: raise click.ClickException("Timeout!") self._mqclient.loop(0.1) # first connect self.connect() # subscribe to the response topics reply_topic = self._mktopic("reply/out") err_topic = self._mktopic("reply/err") self._mqclient.message_callback_add(reply_topic, on_reply) self._mqclient.message_callback_add(err_topic, on_error) self._mqclient.on_subscribe = on_sub (res, sub_mid) = self._mqclient.subscribe([(reply_topic, 1), (err_topic, 1)]) self.debug(f"Subscribing to {reply_topic} and {err_topic}") if res != paho.MQTT_ERR_SUCCESS: raise click.ClickException("Subscribe failed") while not subscribed: loop() # iterate through content and send one buffer at a time seq = 0 if isinstance(msg, str): msg = msg.encode() buf = bytearray(BUFLEN + 2) cmd_topic = self._mktopic(cmd, tail=tail) flowctrl = len(msg) > 100 * 1024 # hack while len(msg) > 0 and got_error is None: # make sure we're not more than 16 messages ahead of flow-control ACKs while flowctrl and seq - ack > 16 and got_error is None: loop() # construct outgoing message with 2-byte header (last flag and seq number) buf[2:] = msg[:BUFLEN] msg = msg[BUFLEN:] last = len(msg) == 0 struct.pack_into("!H", buf, 0, last << 15 | seq) # publish sz += len(buf) self.debug(f"Pub {cmd_topic} #{seq} last={last} len={len(buf)}") self._mqclient.publish(cmd_topic, buf, qos=1) seq += 1 loop() # self.debug("done publishing") # wait for replies while got_error is None: loop() # wrap up self._mqclient.unsubscribe(reply_topic) self._mqclient.unsubscribe(err_topic) if got_error: raise click.Abort() return output
def fill_buffer(self, buffer: bytes, start_pos: int) -> int: if not self.total_size: raise Exception('calc_real_size is not invoked') if len(buffer) - start_pos < 0: raise Exception('start_pos > buffer size') if start_pos + self.total_size > len(buffer): raise Exception('start_pos + total_size > buffer size') pos = start_pos vehicleId_var = self.m_vehicleId struct.pack_into(Constant.CLOUD_PROTOCOL_ENDIAN_SIGN + '8s', buffer, pos, vehicleId_var) VehicleToCloudRun.__logger.debug(f'fill vehicleId_var:{vehicleId_var}') pos += struct.calcsize('8s') timestampGNSS_var = self.m_timestampGNSS struct.pack_into(Constant.CLOUD_PROTOCOL_ENDIAN_SIGN + 'H', buffer, pos, timestampGNSS_var) VehicleToCloudRun.__logger.debug( f'fill timestampGNSS_var:{timestampGNSS_var}') pos += struct.calcsize('H') velocityGNSS_var = self.m_velocityGNSS struct.pack_into(Constant.CLOUD_PROTOCOL_ENDIAN_SIGN + 'H', buffer, pos, velocityGNSS_var) VehicleToCloudRun.__logger.debug( f'fill velocityGNSS_var:{velocityGNSS_var}') pos += struct.calcsize('H') longitude_var = self.m_longitude struct.pack_into(Constant.CLOUD_PROTOCOL_ENDIAN_SIGN + 'I', buffer, pos, longitude_var) VehicleToCloudRun.__logger.debug(f'fill longitude_var:{longitude_var}') pos += struct.calcsize('I') latitude_var = self.m_latitude struct.pack_into(Constant.CLOUD_PROTOCOL_ENDIAN_SIGN + 'I', buffer, pos, latitude_var) VehicleToCloudRun.__logger.debug(f'fill latitude_var:{latitude_var}') pos += struct.calcsize('I') elevation_var = self.m_elevation struct.pack_into(Constant.CLOUD_PROTOCOL_ENDIAN_SIGN + 'i', buffer, pos, elevation_var) VehicleToCloudRun.__logger.debug(f'fill elevation_var:{elevation_var}') pos += struct.calcsize('i') heading_var = self.m_heading struct.pack_into(Constant.CLOUD_PROTOCOL_ENDIAN_SIGN + 'I', buffer, pos, heading_var) VehicleToCloudRun.__logger.debug(f'fill heading_var:{heading_var}') pos += struct.calcsize('I') hdop_var = self.m_hdop struct.pack_into(Constant.CLOUD_PROTOCOL_ENDIAN_SIGN + 'B', buffer, pos, hdop_var) VehicleToCloudRun.__logger.debug(f'fill hdop_var:{hdop_var}') pos += struct.calcsize('B') vdop_var = self.m_vdop struct.pack_into(Constant.CLOUD_PROTOCOL_ENDIAN_SIGN + 'B', buffer, pos, vdop_var) VehicleToCloudRun.__logger.debug(f'fill vdop_var:{vdop_var}') pos += struct.calcsize('B') tapPos_var = self.m_tapPos struct.pack_into(Constant.CLOUD_PROTOCOL_ENDIAN_SIGN + 'B', buffer, pos, tapPos_var) VehicleToCloudRun.__logger.debug(f'fill tapPos_var:{tapPos_var}') pos += struct.calcsize('B') steeringAngle_var = self.m_steeringAngle struct.pack_into(Constant.CLOUD_PROTOCOL_ENDIAN_SIGN + 'i', buffer, pos, steeringAngle_var) VehicleToCloudRun.__logger.debug( f'fill steeringAngle_var:{steeringAngle_var}') pos += struct.calcsize('i') lights_var = self.m_lights struct.pack_into(Constant.CLOUD_PROTOCOL_ENDIAN_SIGN + 'H', buffer, pos, lights_var) VehicleToCloudRun.__logger.debug(f'fill lights_var:{lights_var}') pos += struct.calcsize('H') velocityCAN_var = self.m_velocityCAN struct.pack_into(Constant.CLOUD_PROTOCOL_ENDIAN_SIGN + 'H', buffer, pos, velocityCAN_var) VehicleToCloudRun.__logger.debug( f'fill velocityCAN_var:{velocityCAN_var}') pos += struct.calcsize('H') acceleration_V_var = self.m_acceleration_V struct.pack_into(Constant.CLOUD_PROTOCOL_ENDIAN_SIGN + 'H', buffer, pos, acceleration_V_var) VehicleToCloudRun.__logger.debug( f'fill acceleration_V_var:{acceleration_V_var}') pos += struct.calcsize('H') acceleration_H_var = self.m_acceleration_H struct.pack_into(Constant.CLOUD_PROTOCOL_ENDIAN_SIGN + 'H', buffer, pos, acceleration_H_var) VehicleToCloudRun.__logger.debug( f'fill acceleration_H_var:{acceleration_H_var}') pos += struct.calcsize('H') accelPos_var = self.m_accelPos struct.pack_into(Constant.CLOUD_PROTOCOL_ENDIAN_SIGN + 'B', buffer, pos, accelPos_var) VehicleToCloudRun.__logger.debug(f'fill accelPos_var:{accelPos_var}') pos += struct.calcsize('B') engineSpeed_var = self.m_engineSpeed struct.pack_into(Constant.CLOUD_PROTOCOL_ENDIAN_SIGN + 'i', buffer, pos, engineSpeed_var) VehicleToCloudRun.__logger.debug( f'fill engineSpeed_var:{engineSpeed_var}') pos += struct.calcsize('i') engineTorque_var = self.m_engineTorque struct.pack_into(Constant.CLOUD_PROTOCOL_ENDIAN_SIGN + 'i', buffer, pos, engineTorque_var) VehicleToCloudRun.__logger.debug( f'fill engineTorque_var:{engineTorque_var}') pos += struct.calcsize('i') brakeFlag_var = self.m_brakeFlag struct.pack_into(Constant.CLOUD_PROTOCOL_ENDIAN_SIGN + 'B', buffer, pos, brakeFlag_var) VehicleToCloudRun.__logger.debug(f'fill brakeFlag_var:{brakeFlag_var}') pos += struct.calcsize('B') brakePos_var = self.m_brakePos struct.pack_into(Constant.CLOUD_PROTOCOL_ENDIAN_SIGN + 'B', buffer, pos, brakePos_var) VehicleToCloudRun.__logger.debug(f'fill brakePos_var:{brakePos_var}') pos += struct.calcsize('B') brakePressure_var = self.m_brakePressure struct.pack_into(Constant.CLOUD_PROTOCOL_ENDIAN_SIGN + 'H', buffer, pos, brakePressure_var) VehicleToCloudRun.__logger.debug( f'fill brakePressure_var:{brakePressure_var}') pos += struct.calcsize('H') yawRate_var = self.m_yawRate struct.pack_into(Constant.CLOUD_PROTOCOL_ENDIAN_SIGN + 'H', buffer, pos, yawRate_var) VehicleToCloudRun.__logger.debug(f'fill yawRate_var:{yawRate_var}') pos += struct.calcsize('H') wheelVelocity_FL_var = self.m_wheelVelocity_FL struct.pack_into(Constant.CLOUD_PROTOCOL_ENDIAN_SIGN + 'H', buffer, pos, wheelVelocity_FL_var) VehicleToCloudRun.__logger.debug( f'fill wheelVelocity_FL_var:{wheelVelocity_FL_var}') pos += struct.calcsize('H') wheelVelocity_RL_var = self.m_wheelVelocity_RL struct.pack_into(Constant.CLOUD_PROTOCOL_ENDIAN_SIGN + 'H', buffer, pos, wheelVelocity_RL_var) VehicleToCloudRun.__logger.debug( f'fill wheelVelocity_RL_var:{wheelVelocity_RL_var}') pos += struct.calcsize('H') wheelVelocity_RR_var = self.m_wheelVelocity_RR struct.pack_into(Constant.CLOUD_PROTOCOL_ENDIAN_SIGN + 'H', buffer, pos, wheelVelocity_RR_var) VehicleToCloudRun.__logger.debug( f'fill wheelVelocity_RR_var:{wheelVelocity_RR_var}') pos += struct.calcsize('H') absFlag_var = self.m_absFlag struct.pack_into(Constant.CLOUD_PROTOCOL_ENDIAN_SIGN + 'B', buffer, pos, absFlag_var) VehicleToCloudRun.__logger.debug(f'fill absFlag_var:{absFlag_var}') pos += struct.calcsize('B') tcsFlag_var = self.m_tcsFlag struct.pack_into(Constant.CLOUD_PROTOCOL_ENDIAN_SIGN + 'B', buffer, pos, tcsFlag_var) VehicleToCloudRun.__logger.debug(f'fill tcsFlag_var:{tcsFlag_var}') pos += struct.calcsize('B') espFlag_var = self.m_espFlag struct.pack_into(Constant.CLOUD_PROTOCOL_ENDIAN_SIGN + 'B', buffer, pos, espFlag_var) VehicleToCloudRun.__logger.debug(f'fill espFlag_var:{espFlag_var}') pos += struct.calcsize('B') lkaFlag_var = self.m_lkaFlag struct.pack_into(Constant.CLOUD_PROTOCOL_ENDIAN_SIGN + 'B', buffer, pos, lkaFlag_var) VehicleToCloudRun.__logger.debug(f'fill lkaFlag_var:{lkaFlag_var}') pos += struct.calcsize('B') accMode_var = self.m_accMode struct.pack_into(Constant.CLOUD_PROTOCOL_ENDIAN_SIGN + 'B', buffer, pos, accMode_var) VehicleToCloudRun.__logger.debug(f'fill accMode_var:{accMode_var}') pos += struct.calcsize('B') return pos
def move_next_from_pgthb_to_pgtha(self): pid, thid, process, thread = struct.unpack_from('=IQBB', self.pgthb, 4) self.pgtha_pid = pid self.pgtha_thread = thid struct.pack_into('=IQBB', self.pgtha, 0, pid, thid, process, thread)
def pack(self, structure, offset, *values): struct.pack_into("%s%s" % (self._endian, structure), self.data, offset, *values)
def adsSumWrite( port: int, address: AmsAddr, data_names_and_values: Dict[str, Any], data_symbols: Dict[str, SAdsSymbolEntry], ) -> Dict[str, ADSError]: """Perform a sum write to write the value of multiple ADS variables :param int port: local AMS port as returned by adsPortOpenEx() :param pyads.structs.AmsAddr address: local or remote AmsAddr :param data_names_and_values: dict of variable names and values to be written :type data_names_and_values: dict[str, Any] :param data_symbols: list of dictionaries of ADS Symbol Info :type data_symbols: dict[str, ADSSymbolInfo] :return: result: dict of variable names and error codes :rtype: dict[str, ADSError] """ offset = 0 num_requests = len(data_names_and_values) total_request_size = num_requests * 3 * 4 # iGroup, iOffset & size for data_name in data_names_and_values.keys(): total_request_size += data_symbols[data_name].size buf = bytearray(total_request_size) for data_name in data_names_and_values.keys(): struct.pack_into("<I", buf, offset, data_symbols[data_name].iGroup) struct.pack_into("<I", buf, offset + 4, data_symbols[data_name].iOffs) struct.pack_into("<I", buf, offset + 8, data_symbols[data_name].size) offset += 12 for data_name, value in data_names_and_values.items(): if (data_symbols[data_name].dataType != ADST_STRING and data_symbols[data_name].dataType != ADST_WSTRING): struct.pack_into( DATATYPE_MAP[ads_type_to_ctype[ data_symbols[data_name].dataType]], buf, offset, value, ) else: buf[offset:offset + len(value)] = value.encode("utf-8") offset += data_symbols[data_name].size sum_response = adsSyncReadWriteReqEx2( port, address, ADSIGRP_SUMUP_WRITE, num_requests, None, buf, None, return_ctypes=False, check_length=False, ) errors = list(struct.iter_unpack("<I", sum_response)) error_descriptions = [ERROR_CODES[i[0]] for i in errors] return dict(zip(data_names_and_values.keys(), error_descriptions))
def write_value(self, key, value): if key not in self._positions: self._init_value(key) pos = self._positions[key] # We assume that writing to an 8 byte aligned value is atomic struct.pack_into(b'd', self._m, pos, value)
def convert_from_older_version( self, msg: AbstractInternalMessage ) -> AbstractInternalMessage: msg_type = msg.MESSAGE_TYPE if msg_type not in self._MSG_TYPE_TO_NEW_MSG_CLASS_MAPPING: raise ValueError( f"Tried to convert unexpected old message type from v10: {msg_type}" ) new_msg_class = self._MSG_TYPE_TO_NEW_MSG_CLASS_MAPPING[msg_type] new_payload_len = msg.payload_len() + self._LENGTH_DIFFERENCE default_new_stats = 0 new_msg_bytes = bytearray(self._NEW_MESSAGE_LEN) new_msg_bytes[:self._INTERVAL_TIMES_BREAKPOINT] = msg.rawbytes()[:self._INTERVAL_TIMES_BREAKPOINT] off = self._BASE_LENGTH + self._INTERVAL_TIMES_LENGTH # memory struct.pack_into("<H", new_msg_bytes, off, default_new_stats) off += constants.UL_SHORT_SIZE_IN_BYTES # single blockchain peer struct.pack_into("<H", new_msg_bytes, off, 1) off += constants.UL_SHORT_SIZE_IN_BYTES # placeholder ip/port message_utils.pack_ip_port(new_msg_bytes, off, "0.0.0.0", 0) off += constants.IP_ADDR_SIZE_IN_BYTES + constants.UL_SHORT_SIZE_IN_BYTES new_msg_bytes[off:off + self._FIRST_STATS_SETS_LENGTH] = \ msg.rawbytes()[ self._INTERVAL_TIMES_BREAKPOINT:self._INTERVAL_TIMES_BREAKPOINT + self._FIRST_STATS_SETS_LENGTH ] off += self._FIRST_STATS_SETS_LENGTH struct.pack_into("<I", new_msg_bytes, off, default_new_stats) off += constants.UL_INT_SIZE_IN_BYTES struct.pack_into("<I", new_msg_bytes, off, default_new_stats) off += constants.UL_INT_SIZE_IN_BYTES struct.pack_into("<I", new_msg_bytes, off, default_new_stats) off += constants.UL_INT_SIZE_IN_BYTES struct.pack_into("<I", new_msg_bytes, off, default_new_stats) off += constants.UL_INT_SIZE_IN_BYTES struct.pack_into("<I", new_msg_bytes, off, default_new_stats) off += constants.UL_INT_SIZE_IN_BYTES new_msg_bytes[off:] = msg.rawbytes()[self._FIRST_STATS_SETS_BREAKPOINT:] return AbstractBloxrouteMessage.initialize_class( new_msg_class, new_msg_bytes, (msg_type, new_payload_len) )
def _choose_level(self, environment_id, level_data=None, include_semantic_data=False, pixel_observations=True, tile_observations=False): environment_id_bytes = environment_id.encode() environment_id_bytes_length = len(environment_id_bytes) level_data_bytes_length = 0 # If we have a custom environment we should also pass the data if 'custom' in environment_id: if level_data is None: level_data = 'wwww\nwA.w\nw0ww\nwwww\n' level_data_bytes = level_data.encode() level_data_bytes_length = len(level_data_bytes) choose_level_data = bytearray(4 + environment_id_bytes_length + 7 + level_data_bytes_length) # Environment Id pack_into('>i', choose_level_data, 0, environment_id_bytes_length) pack_into('%ds' % environment_id_bytes_length, choose_level_data, 4, environment_id_bytes) # Environment Data Options pack_into('?', choose_level_data, environment_id_bytes_length + 4, include_semantic_data) pack_into('?', choose_level_data, environment_id_bytes_length + 5, tile_observations) pack_into('?', choose_level_data, environment_id_bytes_length + 6, pixel_observations) # Level Data pack_into('>i', choose_level_data, environment_id_bytes_length + 7, level_data_bytes_length) if level_data_bytes_length > 0: data_start = environment_id_bytes_length + 11 pack_into('%ds' % level_data_bytes_length, choose_level_data, data_start, level_data_bytes) self.io.writeToServer(AgentPhase.CHOOSE_LEVEL_STATE, choose_level_data)
def pack_into(self, struct, offset, *args): struct.pack_into(self._buf, offset, *args)
def _transmit_missing_seq_nums(self, seq_nums, transceiver, placement): # locate missing seq nums from pile missing_seq_nums = self._calculate_missing_seq_nums(seq_nums) self._lost_seq_nums.append(len(missing_seq_nums)) # self._print_missing(seq_nums) if len(missing_seq_nums) == 0: return True # print("doing retransmission") # figure n packets given the 2 formats n_packets = 1 length_via_format2 = \ len(missing_seq_nums) - (self.DATA_PER_FULL_PACKET - 2) if length_via_format2 > 0: n_packets += int( math.ceil( float(length_via_format2) / float(self.DATA_PER_FULL_PACKET - 1))) # transmit missing seq as a new sdp packet first = True seq_num_offset = 0 for _packet_count in range(0, n_packets): length_left_in_packet = self.DATA_PER_FULL_PACKET offset = 0 data = None size_of_data_left_to_transmit = None # if first, add n packets to list if first: # get left over space / data size size_of_data_left_to_transmit = min( length_left_in_packet - 2, len(missing_seq_nums) - seq_num_offset) # build data holder accordingly data = bytearray((size_of_data_left_to_transmit + 2) * self.WORD_TO_BYTE_CONVERTER) # pack flag and n packets struct.pack_into("<I", data, offset, self.SDP_PACKET_START_MISSING_SEQ_COMMAND_ID) struct.pack_into("<I", data, self.WORD_TO_BYTE_CONVERTER, n_packets) # update state offset += 2 * self.WORD_TO_BYTE_CONVERTER length_left_in_packet -= 2 first = False else: # just add data # get left over space / data size size_of_data_left_to_transmit = min( self.DATA_PER_FULL_PACKET_WITH_SEQUENCE_NUM, len(missing_seq_nums) - seq_num_offset) # build data holder accordingly data = bytearray((size_of_data_left_to_transmit + 1) * self.WORD_TO_BYTE_CONVERTER) # pack flag struct.pack_into("<I", data, offset, self.SDP_PACKET_MISSING_SEQ_COMMAND_ID) offset += 1 * self.WORD_TO_BYTE_CONVERTER length_left_in_packet -= 1 # fill data field struct.pack_into( "<{}I".format(size_of_data_left_to_transmit), data, offset, *missing_seq_nums[seq_num_offset:seq_num_offset + size_of_data_left_to_transmit]) seq_num_offset += length_left_in_packet # build sdp message message = SDPMessage(sdp_header=SDPHeader( destination_chip_x=placement.x, destination_chip_y=placement.y, destination_cpu=placement.p, destination_port=self.SDP_PACKET_PORT, flags=SDPFlag.REPLY_NOT_EXPECTED), data=data) # debug # self._print_out_packet_data(data) # send message to core transceiver.send_sdp_message(message=message) # sleep for ensuring core doesnt lose packets time.sleep(self.TIME_OUT_FOR_SENDING_IN_SECONDS) # self._print_packet_num_being_sent(packet_count, n_packets) return False