Beispiel #1
0
    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())
Beispiel #2
0
    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)
Beispiel #6
0
	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()
Beispiel #7
0
 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())
Beispiel #8
0
 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)
Beispiel #9
0
    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
Beispiel #10
0
 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)
Beispiel #11
0
 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
Beispiel #12
0
 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))
Beispiel #14
0
    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)
        '''
Beispiel #15
0
 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()
Beispiel #16
0
 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
Beispiel #17
0
 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)
Beispiel #20
0
	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)
Beispiel #21
0
 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)
Beispiel #22
0
 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)
Beispiel #24
0
    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()')
Beispiel #25
0
    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)
Beispiel #26
0
    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 = []
Beispiel #28
0
    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")
Beispiel #29
0
    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)
Beispiel #33
0
 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")
Beispiel #34
0
	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 []
Beispiel #35
0
 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)
Beispiel #36
0
    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))
Beispiel #38
0
 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")
Beispiel #39
0
    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')
Beispiel #40
0
    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'))
Beispiel #41
0
 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
Beispiel #42
0
 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
Beispiel #43
0
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
Beispiel #44
0
 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)
Beispiel #45
0
    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))
Beispiel #46
0
 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
Beispiel #47
0
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)
Beispiel #48
0
    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)
Beispiel #49
0
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)
Beispiel #51
0
 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)
Beispiel #53
0
 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
Beispiel #54
0
 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)
Beispiel #55
0
    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()
Beispiel #56
0
 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)
Beispiel #58
0
    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)
Beispiel #59
0
    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
Beispiel #60
0
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