def test_valid_packet_counter(self): p = Packet(content="content", receiver="receiver") self.assertFalse(p.is_looped()) for i in range(Packet.MAX_HOP - 1): p.hop() self.assertFalse(p.is_looped())
def run(self): """ Run the ETL Chain. :return: """ log.info('Running Chain: %s' % self.chain_str) # One time init for entire Chain self.first_comp.do_init() # Do ETL as long as input available in Packet packet = Packet() rounds = 0 try: while not packet.is_end_of_stream(): # try: # Invoke the first component to start the chain packet.init() packet = self.first_comp.process(packet) rounds += 1 # except (Exception), e: # log.error("Fatal Error in ETL: %s"% str(e)) # break finally: # Always one time exit for entire Chain self.first_comp.do_exit() log.info('DONE - %d rounds - chain=%s ' % (rounds, self.chain_str))
def _send_command(self, command, data): p = Packet(seq=self.txseq, cmd=command, data=data) self.logger.debug("Msg to mastercontroller: %s" % list(p.toMessage())) msg = self.aes.encrypt([ord(x) for x in p.toMessage()], self.key, AES.keySize["SIZE_128"]) msg = "".join([chr(x) for x in msg]) self.interface.writeMessage(self.address, msg)
def run(self): while 1: msg = self.connection.recv(1024) data = bytearray(msg) pck = Packet() pck.data = data self.onpacketdata(pck.getPacketID(), data)
def test_average_bitrate_single_packet(self): for i in range(10): packet_size_bytes = random.uniform(1.0, 8000.0) delay_ms = random.uniform(10.0, 300.0) packet = Packet(1, 0.0, packet_size_bytes) packet.arrival_time_ms = delay_ms self.assertEqual(average_bitrate_kbps([packet]), 8.0 * packet_size_bytes / delay_ms)
def transfer_file(self, share_ID, file_name, return_address, start_offset=0, end_offset=999999999999, block_skip=1): """Sends a piece of a file to a peer in pieces. Initiated by JSONRPC: get_file() start_offset: start sending file from this offset end_offset: if this bytes is reached, send no more. block_skip: send a block, then skip this many blocks, then send the next etc. """ #continue to send all file blocks full_file_path = os.path.join(self.storage_directory, share_ID, file_name) f = open(full_file_path, 'rb') f.seek(start_offset) block_size = 5 file_offset = start_offset logging.debug('file_name: %s start_offset: %d, end_offset: %d' %(file_name, start_offset, end_offset)) while (file_offset < end_offset): #@TODO: stop sending if given signal from return_address logging.debug('file_offset: %d' %(file_offset)) block_bytes = f.read(64*block_size) if block_bytes == "": logging.debug('no bytes read from file') break p_out_block = Packet() p_out_block.json_RPC_object = dict(jsonrpc="2.0", method="save_file_block", params=[1.0, None, [self.my_machine_ID, share_ID, file_name, file_offset]], ) #id=rpc_id p_out_block.binary_blob = block_bytes p_out_block.to_address = return_address self.send_block_choke(p_out_block, return_address, 3) time.sleep(0.002) file_offset+=block_size logging.debug('finished file transfer') f.close()
def on_tunnel_received(_, __, data): packet = Packet(data) addr_list, id_, _ = try_parse_dns_result(packet) if addr_list is not None: update_blocked_address(addr_list) try_restore_dns(packet, id_) tundev.send(packet.get_packet())
def run(self): while True: data, addr = self.server.recv() pkg = Packet.unpack(data) # print "got packet: %s, %s, %s" % (pkg.tick, pkg.players, pkg.input) with self.lock: net_tick = self.parent.net_tick if addr not in self.clients: if pkg.tick == 0 and len(pkg.players) == 0 and len(pkg.input) == 0: self.clients[addr] = Client(addr, self.next_id, Player(50 + self.next_id * 30, 50)) self.next_id += 1 pkg_response = Packet(net_tick) pkg_response.add_player(self.clients[addr].id, self.clients[addr].player) self.server.send(pkg_response, addr) print "authenticating new client: %s -> %s" % (addr, self.clients[addr].id) else: print "invalid authentication attempt: %s, %s, %s" % (pkg.tick, pkg.players, pkg.input) else: client = self.clients[addr] client.ack() if pkg.tick >= net_tick: if len(pkg.input) > 0: client.events[pkg.tick] = pkg.input # if net_tick not in self.pkg_queue: # self.pkg_queue[net_tick] = [] # self.pkg_queue[net_tick].insert(0, pkg) else: print "discard packet (too old: %d < %d)" % (pkg.tick, net_tick)
def _send_command(self, command, data): p = Packet(seq=self.tx_seq, cmd=command, data=data, seq_sync=False) msg = p.toMessage(key = self.key) self.logger.debug('%s Msg to door: %s'%(self.name, list(p.toMessage()))) self.interface.writeMessage(self.priority, self.address, msg, self.tx_msg_queue) self.tx_seq += 1
def test_drop_old_packet(self): w1 = Node(name="w1") p = Packet(content="X", receiver="w2", sender="w3") p._hopcounter = p.MAX_HOP w1.drop_packet = FunctionCalledChecker(w1.drop_packet) w1.accept(p) self.assertTrue(w1.drop_packet.was_called)
def __init__(self,source_address=1,source_port=0, destination_address=1,destination_port=0, ident=0,protocol="TCP",body="",length=0, syn=False,ack=False,fin=False,sequence=0,ack_number=0): Packet.__init__(self,source_address,source_port,destination_address, destination_port,ident,protocol,body,length) self.sequence = sequence self.ack_number = ack_number
def get(self): import sys pkt = Packet() args = map(lambda v: String(v), sys.argv) pkt.item = Array(args) pkt.item.append(String("aaa")) pkt.item.append(Url("http://www.yahoo.co.jp/")) return chain([pkt,])
def packet_read(self, conn, raw_packet): """ Read in a packet and dispatch -- asyncore callback. """ packet = Packet.decode(raw_packet) print "packet in with protocol" if Packet.is_named(packet.protocol): # protocol is named, resolve id first name = packet.protocol id = self.server_map.resolve_id(name) if id: named = MappedName() named.name = name named.id = id msg = Message(0, named) self.q_out.fifo_put((conn, msg)) else: print "unmapped name: " + str(name) rejected = MessageRejected() rejected.id = 0 rejected.reason = rejected.UNMAPPED_NAME rejected.message = "Unmapped name: '%s'" % name msg = Message(0, rejected) self.q_out.fifo_put((conn, msg)) # stop processing return else: # just take id id = packet.protocol # this seems slightly silly in the case where the message was # a named message (it shouldn't hurt though) name = self.server_map.resolve_name(id) if not name: # if the reverse name lookup fails print "unmapped id: " + str(id) rejected = MessageRejected() rejected.id = 0 rejected.reason = rejected.UNMAPPED_ID rejected.message = "Unmapped ID: %d" % id msg = Message(0, rejected) self.q_out.fifo_put((conn, msg)) # stop processing return protobuf_class = self.server_map.resolve_protobuffer(name) assert protobuf_class protobuf = protobuf_class() protobuf.ParseFromString(packet.payload) message = Message(packet.track_id, protobuf, name=name) print "have protobuf: {" + str(protobuf) + "}" self.q_in.fifo_put((conn, message))
def _send_command(self, command, data): p = Packet(seq=self.txseq, cmd=command, data=data) msg = self.aes.encrypt([ord(x) for x in p.toMessage()], self.key, AES.keySize["SIZE_128"]) msg = ''.join([chr(x) for x in msg]) self.logger.debug('Msg to door %s: %s'%(self.name, list(p.toMessage()))) self.interface.writeMessage(self.address, msg) '''
def encode(self, protocol): """ Encodes the message as a packet (serializing it first if needed) using the given protocol. """ if not self.serialized: self.serialized = self.pbuffer.SerializeToString() packet = Packet(self.track_id, protocol, self.serialized) return packet.encode()
def get(self): for pkt in self.source.get(): items = pkt.item if isinstance(items, Array): for item in items: ret = Packet() ret.item = item yield ret raise StopIteration
def get(self): for pkt in self.source.get(): url = pkt.item if isinstance(url, Url): rss = Rss(url) for entry in rss.entries(): pkt = Packet() pkt.item = entry yield pkt raise StopIteration
def test_average_bitrate_two_packets(self): for i in range(10): packet_size_bytes = random.uniform(1.0, 8000.0) delay_ms = random.uniform(10.0, 300.0) gap_ms = random.uniform(10.0, 50.0) packet1 = Packet(1, 0.0, packet_size_bytes) packet2 = Packet(2, gap_ms, packet_size_bytes) packet1.arrival_time_ms = delay_ms packet2.arrival_time_ms = gap_ms + delay_ms self.assertNear(average_bitrate_kbps([packet1, packet2]), 8.0 * packet_size_bytes / gap_ms, 0.001)
def test_receiving_rate_kbps_single_packet(self): payload_sizes_bytes = [0.0, 500.0, 1200.0] # Empty or non-empty packet. for payload_size_bytes in payload_sizes_bytes: # id and send_time don't matter here. packet = Packet(None, None, payload_size_bytes) for i in range(10): packet.arrival_time_ms = i time_window_ms = random.uniform(100.0, 1000.0) self.assertEqual(receiving_rate_kbps([packet], time_window_ms), 8.0 * packet.payload_size_bytes / time_window_ms)
def enqueuePacket(self, data): packet = Packet(data) if self.init: packet.seg = self.seg self.seg += 1 else: self.requesting = True packet.con = self.nextSeg # con packet: seg = 0; ack = 0; con = nextSeg self.buff.put(packet)
def get_state(self, *args): """ Respond to an incoming get_state request :param args: not applicable to this command :return: """ log.msg('get_state: %r %d' % (self.connections, self.num_connections)) if len(self.connections) == self.num_connections: return Packet.create('CONNECTED', PacketType.PA_STATUS) return Packet.create('DISCONNECTED', PacketType.PA_STATUS)
def __init__(self,source_address=1,source_port=0, destination_address=1,destination_port=0, ident=0,ttl=100,protocol="TCP",body="",length=0, syn=False,ack=False,fin=False,sequence=0,ack_number=0,drop_packet=False): Packet.__init__(self,source_address=source_address, source_port=source_port, destination_address=destination_address, destination_port=destination_port, ttl=ttl,ident=ident,protocol=protocol, body=body,length=length,drop_packet=drop_packet) self.sequence = sequence self.ack_number = ack_number
def receiveFromClient(self,s,address): while True: pkt = Packet() try: pkt.construct(s) except socket.error as error: if error.errno == 10054 or error.errno == 104: del self.toClient[address[0]] print address[0] + " closed client!" break else: raise pkt.returnIP = address[0] self.enqueueToVirus(pkt)
def getBasicPacket(self, timeout = DEFAULT_TIMEOUT) : try: self.s.setTimeout(timeout) packet = Packet([]) character = self.s.read() while character : packet.addBytes(character) if packet.isComplete : break character = self.s.read() return packet except Exception, e: print 'Exception occured in getBasicPacket(): ' + str(e) raise CommException('Error occured in getBasicPacket()')
def fileRetrieved(self, write_result): file_obj, file_attributes, file_size = write_result # Remove '.part' from the end of the file name now that the download is complete new_file_path = file_obj.name[:-5] os.rename(file_obj.name, new_file_path) new_filename = os.path.basename(new_file_path) log.msg('File downloaded: ', new_filename) orig_filename = new_filename.split('_')[1] self.retrieved_file_queue.append(orig_filename) file_obj.close() # Send a message to the driver indicating that a new image has been retrieved # The driver will then associate metadata with the image file name packets = Packet.create('New Image:' + str(new_filename), PacketType.FROM_INSTRUMENT) self.router.got_data(packets) reactor.callLater(0, self.fetch_file)
def _read(self): """ Read one packet, publish if appropriate, then return. We must not read all packets in a loop here, or we will not actually publish them until the end... """ if self._filehandle is None and not self.files: log.msg('Completed reading specified port agent logs, exiting...') reactor.stop() return if self._filehandle is None: name = self.files.pop(0) log.msg('Begin reading:', name) self._filehandle = open(name, 'r') packet = Packet.packet_from_fh(self._filehandle) if packet is not None: if packet.header.packet_type in self.target_types: self.router.got_data([packet]) else: self._filehandle.close() self._filehandle = None # allow the reactor loop to process other events reactor.callLater(0.01, self._read)
def __init__(self, update_flag, update_data, reconfig_flag): """ Extend threading class. Parameters ---------- callback : obj Callback for controller, relays data from rf subsystem to controller """ threading.Thread.__init__(self) self.update_flag = update_flag self.update_data = update_data self.reconfig_flag = reconfig_flag self.stop_event = threading.Event() self.data = NodeAData() self.packet = Packet('A') self.radio = RadioAPI() self.last_state = 'stop' self.current_state = 'stop' self.current_location = 1 self.tx_packet_number = 1 self.cw_rssi = []
def authenticate(self): """ call this before opening the game gets the current tick from the server and synchronizes the game state """ def threaded_recv(retlist): response, addr = self.client.recv() retlist.append(response) pkg_request = Packet(0) self.client.send(pkg_request) retlist = [] t = Thread(target=lambda: threaded_recv(retlist)) t.daemon = True t.start() wait_start = time.get_ticks() wait_end = wait_start + 1000 while len(retlist) <= 0 and time.get_ticks() < wait_end: time.wait(1) if len(retlist) > 0: response = retlist[0] pkg_response = Packet.unpack(response) self.start_tick = pkg_response.tick if len(pkg_response.players) <= 0: raise RuntimeError("Invalid response: %s" % pkg_response) self.id = pkg_response.players[0][0] self.set_state(pkg_response, backtrack=False) else: raise RuntimeError("Server not responding")
def add(self, dst, data): ptype, pid, unknown, _ = Packet.get_type(data) if not ptype: self.invalid += 1 return self.records += 1 self.size_accum += len(data) if ptype == PacketType.Control: self.control += 1 self.control_types[pid] += 1 self.control_dst[pid][dst.value] += 1 elif ptype == PacketType.Game: self.game += 1 self.game_types[pid] += 1 self.game_dst[pid][dst.value] += 1 else: raise RuntimeError("Unsupported packet type: " + str(ptype)) if dst == PacketDest.Server: self.to_server += 1 elif dst == PacketDest.Client: self.to_client += 1 else: raise RuntimeError("Unsupported packet destination: " + str(dst)) if unknown: self.unknown += 1
def _set_select(self, command, *args): if len(args) == 0: num_sources = self.orb.select('') else: num_sources = self.orb.select(args[0]) msg = 'Orb select(%s) yielded num_sources: %d' % (args[:1], num_sources) return Packet.create(msg + NEWLINE, PacketType.PA_STATUS)
def test_global_loss_ratio_shuffled_packets(self): for i in range(10): first_id = random.randint(0, 100) number_packets = random.randint(0, 1000) packets = [ Packet(first_id + i, None, None) for i in range(number_packets) ] random.shuffle(packets) self.assertEqual(global_loss_ratio(packets), 0.0)
def createProject(self, form): db = self.__db cursor = self.__cursor hostname = self.__hostname #print "Content-type:text/html" # TEMPORARY, REMOVE AFTER DEBUGGING TO HAVE SCRIPT REDIRECT PROPERLY!!!!!! #print # DITTO #print `form` # Handlers pHandler = ProjectDatabaseHandler(db, cursor) uHandler = UserHandler(db, cursor) # Get form values projectID = form.getvalue("packetID") ownerID = form.getvalue("packetOwner") # get owner's name packetOwner = uHandler.getUserByID(ownerID) packetName = form.getvalue("packetName") packetDescription = form.getvalue("packetDescription") # private or public if form.getvalue("private_or_public") == "public": isPrivate = False else: isPrivate = True # Lists of project readers & editors # These are lists of INTEGER USER IDs!!!!! # A User instance needs to be created for each!!!!!!! projectReaderIDs = form.getlist("readersTargetList") projectWriterIDs = form.getlist("writersTargetList") projectReaders = [] projectWriters = [] for rID in projectReaderIDs: tmpReader = uHandler.getUserByID(rID) projectReaders.append(tmpReader) for wID in projectWriterIDs: tmpWriter = uHandler.getUserByID(wID) # Now check if the user is an OpenFreezer writer - otherwise cannot be made Writer on a project if tmpWriter.getCategory() != 'Reader': projectWriters.append(tmpWriter) newProject = Packet(projectID, packetName, packetDescription, packetOwner, isPrivate, projectReaders, projectWriters) packetID = pHandler.insertPacket( newProject) # new project is empty by default self.showProjectDetails('view', newProject)
def recv(self, pkt: DNS): if pkt is not None: packet = Packet(pkt, self.domain) for i, (rrname, rdata) in enumerate(packet.answers): logging.info("Message %i (%s): %s", i, rrname, rdata) logging.info("Decoded: %s", Content.decode(rdata)) logging.info(packet.dns.summary()) else: logging.warn("Packet was none, most likely timeout")
def step(self): self.time += 1 if self.time % self.ticksPerEvent == self.firstEventOffset: packet = Packet(self.time, Device.cloud_id, self.id) id = packet.packet_id self.data.putSendTime(id, self.time) return [packet] else: return []
def _orb_stop(self, *args): self.keep_going = False if self.orb_thread is not None: self.orb_thread.join() self.orb_thread = None msg = 'Stopped orb thread' else: msg = 'Orb thread not running!' return Packet.create(msg + NEWLINE, PacketType.PA_STATUS)
def _set_seek(self, command, *args): if len(args) == 0: seek = ORBOLDEST else: seek = int(args[0]) self.orb.seek(seek) msg = 'Orb seek set to %s' % seek return Packet.create(msg + NEWLINE, PacketType.PA_STATUS)
def add_packets_to_tree(sim): """ Packets are added to the active array, the attributes of the packet are the arrival slot and its own number :param sim: the simulation object instance """ for j in range(0, sim.packets_gen): sim.active_array.append(Packet(sim.slot_no, sum(sim.sim_state.arrival_stat_array) + j + 1, sim.branch_node.branch_status))
def test_login_packet_other_secret(self): # FIXME: update protocol test with changed key # 78 78 11 01 03 55 95 10 91 34 92 95 36 08 00 02 00 02 08 97 0d 0a packet = b"\x78\x78\x11\x01\x03\x55\x95\x10\x91\x34\x92\x95\x36\x08\x00\x02\x00\x02\x08\x97\x0d\x0a" parsed = self.pparse(packet, Packet(crc_secret='testsecret')) self.assertEqual(parsed.protocol, "login") self.assertEqual(binascii.hexlify(parsed.data.imei), b"0355951091349295") self.assertEqual(parsed.data.model, b"\x36\x08")
def file_to_packets(filename): try: with open(filename, 'rb') as file_to_split: pid = Packet.pick_id() seq = 0 chunk = file_to_split.read(MAX_DATA_SIZE) while chunk: next_chunk = file_to_split.read(MAX_DATA_SIZE) if next_chunk: yield Packet('DATA', pid, seq, len(chunk), chunk) chunk = next_chunk else: yield Packet('FIN', pid, seq, len(chunk), chunk) chunk = False seq += 1 except OSError as err: print(f'File {filename} doesn\'t exist')
def sendFileTo(self, dest): filepath = "" if dest == self.Jan: filepath = "confidential/Ann/Chan-_Jan.txt" elif dest == self.Chan: filepath = "confidential/Ann/Chan-_Ann.txt" seqnum = 0 acknum = 0 flags = (0, 0, 0, 1, 0, 0, 0) filecontent = "" with open(filepath, 'r') as file_to_send: for data in file_to_send: filecontent += data filepacket = Packet(2003, dest, seqnum, acknum, flags, filecontent) self.log(filepacket) self.client_socket.send(filepacket.serialize().encode('utf-8'))
def send(self, message_body): self.send_lock.acquire() if self.s: try: self.s.send(Packet(Message(message_body).to_text()).to_raw()) except Exception, e: print(self.host, self.port, e) self.send_lock.release() raise e
def acks(self, conn, port): while self.listen_nak: response, sender = self.connections.recvfrom(1024) p = Packet.from_bytes(response) if (p.packet_type == 4): p.packet_type = 0 print('Recieved ack for packet:', p.seq_num) self.window_acks[p.seq_num] = p.payload return
def recv(sock): """ UDT receive interface :param sock: """ pkt_byte, addr = sock.recvfrom(1024) packet = Packet().decode(pkt_byte) print('-> Receive ACK', packet.ack_num) return packet, addr
def broadcast(self, seq_num, g, exclu_port): for port in self.links.keys(): if port == exclu_port: continue packet = Packet(kind=Packet.ROUTING, srcAddr=self.addr, dstAddr=self.ports[port], content=dumps((seq_num, g))) self.send(port, packet)
def process(client, inpacket): # Get sensor identifier and angle request type = inpacket.decodeUShort() uid = inpacket.decodeUShort() angle = inpacket.decodeInt() # Construct sensor identifier key = str(type) + ":" + str(uid) sensor = client.sensors.get(key) if (sensor): # Write desired angle to sensor (arduino) outpacket = Packet() outpacket.encodeInt(angle) sensor.write(outpacket) print("[Rotator] Requested angle: " + str(angle)) else: print("[Rotator] Invalid sensor request: " + str(uid))
def resend_packet(self, conn, router_addr, router_port, peer_ip, server_port): while (len(self.window_acks) != len(self.window)): for i in self.window: if not self.window_acks.keys().__contains__(i): p = Packet(packet_type=0, seq_num=i, peer_ip_addr=peer_ip, peer_port=server_port, payload=bytes(self.window[i])) print('retransmitting packet:', p.seq_num) self.connections.sendto(p.to_bytes(), (router_addr, router_port)) time.sleep(self.delay) if (len(self.window_acks) == len(self.window)): self.window.clear() self.window_acks.clear() return
def from_network_bytes(response_bytes): packet_type = int.from_bytes(response_bytes[0:1], byteorder="big") sequence_number = int.from_bytes(response_bytes[1:5], byteorder="big") peer_address = str(ipaddress.IPv4Address(bytes(response_bytes[5:9]))) peer_port = int.from_bytes(response_bytes[9:11], byteorder="big") payload = response_bytes[11:] return Packet(packet_type, sequence_number, peer_address, peer_port, payload)
def dns_responder(self, pkt: IP): packet = Packet(pkt, self.domain) if packet.is_valid_dnsquery(): self.logger.info("got a packet from %s:%i", packet.src, packet.sport) subdomain = packet.subdomain_from_qname.split('.')[0] self.logger.debug("subdomain: %s", subdomain) try: data = Domain.decode(subdomain) except binascii.Error: # couldn't decode, drop the packet and do nothing return # keep destination answer = Packet.build_reply( { "src": self.host_ip, "dst": packet.src, "dport": packet.sport, "dns": { "id": packet.id, "question": packet.question, # TODO ensure that we're under the 500 bytes limit "messages": [ DNSRR( rrname=packet.qname, rdata=Content.encode( self.on_query(data, packet.src)), type=DNSAnswer.Type.Text, ttl=60, # a minute long ), ], }, }, self.domain, ) self.logger.debug("Answering %s", answer.dns.summary()) send(answer.packet, verbose=0, iface=self.interface)
def load_kitti(path, mode='train', image_dir=None, label_dir=None): packets = [] with open(path + mode + '.txt', 'rb') as f: file_list = [x.strip() for x in f.readlines()] for file in file_list: image_path = image_dir + file + '.png' label_path = label_dir + file + '.txt' with open(label_path) as f: object_list = [] for line in f: obj_class, truncated, occluded, alpha, bx1, by1, bx2, by2, dz, dy, dx, tx, ty, tz, rot_y = line.split( ) if obj_class == 'Car': #and float(truncated) == 0: #and float(occluded) == 0 : size = [float(x) for x in [dx, dy, dz]] position = [float(x) for x in [tx, ty, tz]] rot_y = float(rot_y) top_left = (int(float(bx1)), int(float(by1))) bottom_right = (int(float(bx2)), int(float(by2))) obj = Object(obj_class, top_left=top_left, bottom_right=bottom_right) obj.size = size obj.position = position object_list.append(obj) if object_list != []: packet = Packet(image_path, objects=object_list) else: continue packets.append(packet) return packets
def __handle_trace_message(self, message): message.get_hops().append(self.__addr) if message.get_destination() == self.__addr: trace = Packet.json_encoding(message.to_dict()) message = Data(self.__addr, message.get_source(), "data", trace) self.send_message(message) else: self.send_message(message)
def send_text(self, message_text): message_text = message_text.encode('utf-8') self.send_lock.acquire() if self.s: try: self.s.send(Packet(message_text).to_raw()) except Exception, e: print(self.host, self.port, e) self.send_lock.release() raise e
def receiveFromVirus(self,s,address): while True: pkt = Packet() try: pkt.construct(s) except socket.error as error: if error.errno == 10054 or error.errno == 104: del self.toVirus[address[0]] self.sendIPList() print address[0] + " uninfected or turned computer off!" break else: raise if pkt.state == '100': tup = self.toVirus[address[0]] pkt.RSADecryptData(self.RSAPrivateKey) self.toVirus[address[0]] = (tup[0],tup[1],pkt.data) self.sendIPList() else: self.enqueueToClient(pkt)
def get_created_packet(self, receiver, payload=None): key_hash = hashlib.sha1(str( self.__dh_sharedkey).encode("utf-8")).hexdigest() msg = (self.dhke.public_key, key_hash) packet = Packet(src_id=self.id, op=OP.CREATED, dest=receiver, payload=(msg, None)) print("{}: Sending CREATED packet to {}".format(self.id, receiver)) return packet
def handleTime(self, timeMillisecs): """TODO: handle current time""" if timeMillisecs - self.last_time >= self.heartbeatTime: self.last_time = timeMillisecs # Hints: # broadcast the link state of this router to all neighbors self.sequence+=1 for i in self.forward_table.keys(): a=Packet(2,self.addr,i,content=dumps({'state':self.state,'seq':self.sequence,'removal':False})) self.send(self.forward_table[i],a)
def send(self, filepath, id): # will lock the thread if self.mode == RSMode.RecvMode: raise Exception queue = Queue() self.connection_manager[id] = queue # コネクションを登録 data_fragments = utils.split_file_into_mtu(filepath, self.mtu) all_packets = [] for (seq, df) in enumerate(data_fragments): # create header header = Header(id) # create packet packet = Packet() payload = rsc.encode(df) packet.from_dict({ "header": header, "payload": payload, }) all_packets.append(packet) while True: try: while True: try: del (self.connection_manager[id]) # コネクションを解除 return except Exception as e: # キューが空の時 if e == KeyboardInterrupt: raise KeyboardInterrupt else: break with self.lock: # 複数のsendメソッドが並列に同時実行されている可能性があるため,ロックが必要 self.socket.sendto(all_packets[seq].raw(), self.receiver_address) # パケット送信 except Exception as e: # sendtoが失敗した時は(適当) if e == KeyboardInterrupt: raise KeyboardInterrupt else: import traceback traceback.print_exc()
def test_bottleneck_queue_limit(self): for i in range(10): capacity_kbps = random.uniform(150.0, 2500.0) link_simulator = LinkSimulator(capacity_kbps, 0) # Package larger than bottleneck queue limit, should be lost. payload_size_bytes = (1.1 * link_simulator.BOTTLENECK_QUEUE_SIZE_MS * capacity_kbps) / 8 packet = Packet(1, 0.0, payload_size_bytes) link_simulator.send_packet(packet) self.assertIs(packet.arrival_time_ms, None)
def packet_with_new_timestamp(pkt, new_timestamp): return Packet(timestamp=new_timestamp, size_in_bytes=pkt.size_in_bytes, src_address=pkt.src_address, src_port=pkt.src_port, dst_address=pkt.dst_address, dst_port=pkt.dst_port, seq=pkt.seq, ack=pkt.ack, flags=pkt.flags)
async def send_packet(self, packet: Packet) -> Packet: if not self.connected: raise RuntimeError("No connection to server!") can_send = await self.socket.poll(self.timeout, flags=zmq.POLLOUT) if can_send & zmq.POLLOUT: text = bytes(packet.serialize(), "utf-8") await self.socket.send(text) else: self.disconnect() raise CommunicationError("Connection timed out") can_receive = await self.socket.poll(self.timeout, flags=zmq.POLLIN) print(can_receive) if can_receive & zmq.POLLIN: response_text = await self.socket.recv() else: self.disconnect() raise CommunicationError("Connection timed out") return Packet.deserialize(response_text)
def handleNewLink(self, port, endpoint, cost): """handle new link""" # 此函数的目的是在新的链路建立时在当前路由节点进行一定处理,以更新路由信息 # 需要更新的内容: # 1.当前节点的routersPort,routersAddr:增加端口 # 2.当前节点的routersCost[endpoint],routersNext[endpoint]:不必是最短路径的信息,之后可以更新 # 3. # 这个函数是在Router基类中被定义,并被函数addLink调用,但是addLink中只是更新了当前路由节点的 # links(与邻居节点的链路)信息,却没有更新当前子类DVrouter节点的信息如self.routersPort、self.routersAddr等 # port:新邻居节点的端口号(整数),这个port可能原来已经存在,此时就直接将原来port对应的link替换为当前的新link # 下面循环中的内容不是必要的,但是可以使网络的路由信息尽快更新 for router in self.routersPort: # endpoint maybe connect to router via other nodes, now the new link connects them directly. if (endpoint not in self.routersCost) or ( self.routersCost[endpoint] > cost): # 将当前节点与endpoint节点之间的信息发送给当前节点之前所有的邻居节点 content = {} content["src"] = self.addr content["dst"] = endpoint content["cost"] = cost content_str = dumps(content) packet = Packet(Packet.ROUTING, self.addr, router, content_str) # send the new router info to other routers self.send(self.routersPort[router], packet) # 将当前节点与之前邻居节点之间的距离发送给新的邻居节点endpoint content1 = {} content1["src"] = self.addr content1["dst"] = router content1["cost"] = self.routersCost[router] content1_str = dumps(content1) packet1 = Packet(Packet.ROUTING, self.addr, endpoint, content1_str) # send other router infos to the new router self.send(port, packet1) # update the routing table at self self.routersPort[endpoint] = port self.routersNext[endpoint] = endpoint # 不一定? self.routersAddr[port] = endpoint if (endpoint not in self.routersCost) or (self.routersCost[endpoint] > cost): self.routersCost[endpoint] = cost
def get_packet(in_data): valid_packet = False packet = None if in_data != b'': header = get_header(in_data) checksum = header[1] pac_type = header[2] seq_no = header[3] data_len = header[4] if data_len >= len(in_data) - 20: data = get_data(in_data, data_len) packet = Packet(pac_type, seq_no, data_len, data, checksum) valid_packet = packet.checksum == packet.calculate_checksum() return packet, valid_packet