示例#1
0
    def __reconstructPacket(self, data, checkAckNum = False):

        log("Calling fromByteArray inside ReconstructPacket...\n")
        packet = RxPacket.fromByteArray(data)
        log("Packet created using fromByteArray inside ReconstructPacket...\n")

        log("Calling isValid() inside Reconstruct packet...\n")
        if not packet.isValid():
            log("Packet wasn't valid...\n")
            return None
        else:
            log("Packet was valid...\n")


        if checkAckNum:

			packetAckNum = packet.header['ackNum']

			ackMismatch = (int(packetAckNum) - checkAckNum - 1)

			if packetAckNum and ackMismatch:
				return ackMismatch

        log("About to return ReconstructedPacket...\n")
        log("The packet header for this Reconstruct packet is: " + str(packet.header) + "\n")
        if packet.data:
            log("The number of pytes for this Reconstructed packet is :" + str(len(packet.data)))
            log("PACKET DATA: " + packet.data.decode('UTF-8'))
        return packet
示例#2
0
    def __init__(self, srcRxPPort, debug = True):
        self.state = 'CLOSED'
        self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        self.recvWindowSize = RxPacket.maxWinSize()  # Receive Window size in bytes
        self.sendWindowSize = 1 # Send window size in bytes
        self.srcRxPPort = srcRxPPort  # Local RxP port, not UDP port
        self.desRxPPort = None     # Destination RxP Port, not UDP port
        self.desAddr = None
        self.srcAddr = "127.0.0.1"
        self.srcUDPPort = None
        self.desUDPPort = None
        self.timeout = None
        self.resetLimit = 50
        self.finalCnctAckNum = 2
        self.debug = debug

        # Note on Sequence and Acknoledgment numbers: The sequence number should
        #  increase every time you SEND data, by the number of bytes. This should be
        #  the entire packet size, not just the data size. The acknowldgement number
        #  should increase every time we RECEIVED data, by the number of bytes. This
        #  should also be the entire packet size, for continuity.

        self.seqNum = 0
        self.ackNum = 0
示例#3
0
    def listen(self):
        if self.srcUDPPort is None:
            self.log("An attempt to listen an un unbound port was made...\n")
            raise Exception("Socket not bound")
            sys.exit(1)

        self.state = 'LISTENING'

        waitLimit = self.resetLimit * 100

        self.log("Waiting for init packet...\n")
        while waitLimit:

            #receive INIT
            try:
                self.log("Calling recvfrom to see if we have anything...\n")
                theBytes, address = self.recvfrom(self.recvWindowSize)
                self.log("Recvfrom called....\n")
                packet = self.__reconstructPacket(data = bytearray(theBytes))
                log("Packet has been reconstructed. We're in listen. Header: " + str(packet.header) + "\n")

                if packet is None:
                    waitLimit -= 1
                    continue

            except socket.timeout:
                waitLimit -= 1
                continue

            except Exception:
                waitLimit -= 1
                continue

            else:
                log("Checking to see if packet isInit, in listen...\n")
                if (packet.isInit()):
                    log("Packet is INIT; breaking out of while loop in listen...\n")
                    break
                else:
                    waitLimit -= 1


        if not waitLimit:
            log("Socket timed out!\n")
            raise Exception('socket timeout')


        self.ackNum = packet.header['seqNum'] + 1
        self.log("Setting destination RxPPort to " + str(packet.header['desPort']))
        self.desRxPPort = packet.header['desPort']
        self.desAddr = address[0]
        self.log("Setting destination UDP port to " + str(address[1]))
        self.desUDPPort = address[1]

        #Send Ack 1
        waitLimit = self.resetLimit * 100
        while waitLimit:

            try:
                #create packet
                flags = (False, False, True, False, False, False)
                initPacket = RxPacket(
                            srcPort = self.srcRxPPort,
                            desPort = self.desRxPPort,
                            seqNum = self.seqNum,
                            ackNum = self.ackNum,
                            flagList = flags,
                            winSize = self.recvWindowSize,
                            )
                self.sendto(initPacket.toByteArray(), (self.desAddr, self.desUDPPort))


                data, address = self.recvfrom(self.recvWindowSize)
                packet = self.__reconstructPacket(data = bytearray(data))
                if not packet:
                    waitLimit -= 1
                    continue
            except socket.timeout:
                waitLimit -= 1
            except Exception:
                waitLimit -= 1
            else:
                if packet.isCnct():
                    break
                else:
                    waitLimit -= 1

        if not waitLimit:
            raise Exception('socket timeout')

        self.ackNum = packet.header['seqNum'] + 1
        self.finalCnctAckNum = self.ackNum

        #send the second ACK
        flags = (False, False, True, False, False, False)
        initPacket = RxPacket(
                    srcPort = self.srcRxPPort,
                    desPort = self.desRxPPort,
                    seqNum = self.seqNum,
                    ackNum = self.ackNum,
                    flagList = flags,
                    winSize = self.recvWindowSize,
                    )
        try:
            self.sendto(initPacket.toByteArray(), (self.desAddr, self.desUDPPort))
        except socket.timeout:
            self.sendto(initPacket.toByteArray(), (self.desAddr, self.desUDPPort))
        except Exception:
            self.sendto(initPacket.toByteArray(), (self.desAddr, self.desUDPPort))

        self.state = 'ESTABLISHED'
示例#4
0
    def __sendCnct(self):

        #create packet
        self.log("Creating init packet......\n")

        try:
            self.log("Setting flags...\n")
            flags = (True, False, False, False, False, False)
        except Exception as e:
            self.log("Exception: " + str(e))
            sys.exit(0)
        self.log("Flags created...\n")

        try:
            cnctPacket = RxPacket.getCnct(
                        srcPort = self.srcRxPPort,
                        desPort = self.desRxPPort,
                        seqNum = self.seqNum,
                        ackNum = self.ackNum,
                        winSize = self.recvWindowSize,
                        )
        except Exception as e:
            self.log("Exception: " + str(e))
            sys.exit(0)

        #increment seq num
        self.log("Incrementing sequence number......\n")
        self.seqNum = self.seqNum + 1 #increment by number of bytes (20 byte header only)
        if self.seqNum > RxPacket.maxSeqNum():
            self.seqNum = 0

        #transfer packet
        resetsLeft = self.resetLimit
        self.log("Entering send loop for CNCT packet......\n")
        while resetsLeft:
            self.log("Sending init to IP: " + self.desAddr + " and Port:" + str(self.desUDPPort) +"...\n")

            try:
                self.sendto(cnctPacket.toByteArray(), (self.desAddr, self.desUDPPort))
            except Exception as e:
                self.log("Exception while calling sendto: " + str(e) + "\n")

            self.log("SENT INIT PACKET!\n")

            try:
                self.log("Waiting for ack......\n")
                data, address = self.recvfrom(self.recvWindowSize)
                log("Packet received successfully, calling reconstructPacket from _sendCNCT...\n")
                packet = self.__reconstructPacket(data = bytearray(data))
                log("Packet successfully reconstructed inside _sendCNCT...\n")

                if not packet:
                    self.log("Checksum failed......\n")
                    resetsLeft -= 1
                    continue
            except socket.timeout:
                resetsLeft -= 1
            except Exception:
                resetsLeft -= 1
            else:
                if packet.isAck() and packet.header['ackNum'] == self.seqNum:
                    self.log("init has been acked......\n")
                    break
                else:
                    self.log("Wrong packet recieved, restarting cnct loop......\n")
                    resetsLeft -= 1

        if not resetsLeft:
            self.log("socket timeout......\n")
            raise Exception('socket timeout')

        return packet
示例#5
0
    def __closePassive(self, ackPacket):
        if self.srcRxPPort is None:
            self.socket.close()
            raise RxPException("Socket not bound")


        if self.state != 'ESTABLISHED':
            self.socket.close()
            raise Exception("Connection not established")

        fin_flags = (False, False, False, True, False, False)
        finPacket = RxPacket(
                    srcPort = self.srcRxPPort,
                    desPort = self.desRxPPort,
                    seqNum = self.seqNum,
                    ackNum = self.ackNum,
                    flagList = fin_flags,
                    winSize = self.recvWindowSize,
                    )

        self.seqNum += 1
        if self.seqNum > RxPacket.maxSeqNum():
            self.seqNum = 0

        resetsLeft = self.resetLimit

        isFinAcked = False

        while resetsLeft and (not isFinAcked):
            self.sendto(finPacket.toByteArray(), (self.desAddr, self.desUDPPort))

            try:
                data, address = self.recvfrom(self.recvWindowSize)
                packet = self.__reconstructPacket(data)

                if not packet:
                    resetsLeft -= 1
            except socket.timeout:
                resetsLeft -= 1
                continue
            except Exception:
                resetsLeft -= 1
                continue
            else:
                if (packet.isAck() and packet.header['ackNum'] == self.seqNum):
                    isFinAcked = True

                if (packet.isFin()):
                    ack_flags = (False, False, False, True, False, False)
                    finPacket = RxPacket(
                                srcPort = self.srcRxPPort,
                                desPort = self.desRxPPort,
                                seqNum = self.seqNum,
                                ackNum = self.ackNum,
                                flagList = fin_flags,
                                winSize = self.recvWindowSize,
                                )

                    self.sendto(finPacket.toByteArray(), (self.desAddr, self.desUDPPort))

        self.socket.close()
        self = RxPSocket(self.srcRxPPort, self.debug)
        self.state = 'CLOSED'
示例#6
0
    def recv(self, maxLength):
        if self.srcRxPPort is None:
            self.log("Socket already closed")

        if self.state != 'ESTABLISHED':
            self.log("Socket already closed")

        message = bytes()
        log("INTIIAL INSTANTIATED MESSAGE: " + message.decode('UTF-8') + "\n")
        log("INTIAL MESSAGE LENGTH: " + str(len(message)))

        resetsLeft = self.resetLimit
        while resetsLeft:
            try:
                data, address = self.recvfrom(self.recvWindowSize)

            except socket.timeout:
                print "timeout in recv"
                flags = (False, False, True, False, False, False)
                ackPacket = RxPacket(
                            srcPort = self.srcRxPPort,
                            desPort = self.desRxPPort,
                            seqNum = self.seqNum,
                            ackNum = self.ackNum,
                            flagList = flags,
                            winSize = self.recvWindowSize,
                            )
                self.sendto(ackPacket.toByteArray(), (self.desAddr, self.desUDPPort))
                resetsLeft -= 1
                continue
            except Exception:
                print "timeout in recv"
                flags = (False, False, True, False, False, False)
                ackPacket = RxPacket(
                            srcPort = self.srcRxPPort,
                            desPort = self.desRxPPort,
                            seqNum = self.seqNum,
                            ackNum = self.ackNum,
                            flagList = flags,
                            winSize = self.recvWindowSize,
                            )
                self.sendto(ackPacket.toByteArray(), (self.desAddr, self.desUDPPort))
                resetsLeft -= 1
                continue

            packet = self.__reconstructPacket(bytearray(data))

            if not packet:
                flags = (False, False, True, False, False, False)
                ackPacket = RxPacket(
                            srcPort = self.srcRxPPort,
                            desPort = self.desRxPPort,
                            seqNum = self.seqNum,
                            ackNum = self.ackNum,
                            flagList = flags,
                            winSize = self.recvWindowSize,
                            )
                self.sendto(ackPacket.toByteArray(), (self.desAddr, self.desUDPPort))
                resetsLeft -= 1
                continue

            else:
                self.ackNum = packet.header['seqNum'] + 1
                if self.ackNum > RxPacket.maxAckNum():
                    self.ackNum = 0

                if packet.isAck():
                    resetsLeft -= 1
                    continue
                if packet.data:
                    message += packet.data

                #log("Message so far is " + message.decode('UTF-8') + "\n")
                #log("Individual packet this time was " + packet.data.decode('UTF-8') + "\n")

                flags = (False, False, True, False, False, False)
                ackPacket = RxPacket(
                            srcPort = self.srcRxPPort,
                            desPort = self.desRxPPort,
                            seqNum = self.seqNum,
                            ackNum = self.ackNum,
                            flagList = flags,
                            winSize = self.recvWindowSize,
                            )
                try:
                    self.sendto(ackPacket.toByteArray(), (self.desAddr, self.desUDPPort))
                except socket.timeout:
                    flags = (False, False, True, False, False, False)
                    ackPacket = RxPacket(
                                srcPort = self.srcRxPPort,
                                desPort = self.desRxPPort,
                                seqNum = self.seqNum,
                                ackNum = self.ackNum,
                                flagList = flags,
                                winSize = self.recvWindowSize,
                                )
                    self.sendto(ackPacket.toByteArray(), (self.desAddr, self.desUDPPort))
                except Exception:
                    flags = (False, False, True, False, False, False)
                    ackPacket = RxPacket(
                                srcPort = self.srcRxPPort,
                                desPort = self.desRxPPort,
                                seqNum = self.seqNum,
                                ackNum = self.ackNum,
                                flagList = flags,
                                winSize = self.recvWindowSize,
                                )
                    self.sendto(ackPacket.toByteArray(), (self.desAddr, self.desUDPPort))
                if (packet.isEndOfMessage()):
                    break

                if (packet.isFin()):
                    flags = (False, False, True, False, False, False)
                    ackPacket = RxPacket(
                                srcPort = self.srcRxPPort,
                                desPort = self.desRxPPort,
                                seqNum = self.seqNum,
                                ackNum = self.ackNum,
                                flagList = flags,
                                winSize = self.recvWindowSize,
                                )
                    self.sendto(ackPacket.toByteArray(), (self.desAddr, self.desUDPPort))
                    self.__closePassive(ackPacket)
                    break

                #superlog("Returning message of length: " + str(len(message)))
                #return message


        if not resetsLeft:
            raise Exception('Socket timeout')

        superlog("Returning message of length: " + str(len(message)))
        return message
示例#7
0
    def send(self, msg):

        superlog("We're sending: " + str(len(msg)) + " bytes.\n")

        if self.srcRxPPort is None:
            raise Exception("Socket not bound")

        if self.state != 'ESTABLISHED':
            raise Exception("Connection not established")

        dataQueue = deque()
        packetQueue = deque()
        sentQueue = deque()
        lastSeqNum = self.seqNum

        log("Fragmenting data, adding it to que...\n")
        #fragment data and add it to data queue
        for i in range(0, len(msg), RxPacket.getDataLength()):
            if (i + RxPacket.getDataLength() > len(msg)):
                dataQueue.append(bytearray(msg[i : ]))
                log("In send dataQue loop, adding: " + bytearray(msg[i : ]).decode('UTF-8') )
            else:
                dataQueue.append(bytearray(msg[i : i + RxPacket.getDataLength()]))
                log("In send dataQue loop, adding: " + bytearray(msg[i : i + RxPacket.getDataLength()]).decode('UTF-8'))


        log("Constructing to data queue...\n")
        #construct packet queue from data queue

        #numPackQd = 0

        for data in dataQueue:
            if data == dataQueue[0]:
                flags = (False, False, False, False, True, False)
            if data == dataQueue[-1]:
                flags = (False, False, False, False, False, True)
            else:
                flags = (False, False, False, False, False, False)
            packet = RxPacket(
                    srcPort = self.srcRxPPort,
                    desPort = self.desRxPPort,
                    seqNum = self.seqNum,
                    ackNum = self.ackNum,
                    flagList = flags,
                    winSize = self.recvWindowSize,
                    data = data
                    )


            self.seqNum += 1
            if self.seqNum >= RxPacket.maxSeqNum():
                self.seqNum = 0


            if packet.isAck():
                sys.exit(0)

            packetQueue.append(packet)
            #numPackQd += 1
            #print numPackQd

        log("Packet queue created...\n")

        log("Preparing to send packets...\n")

        numPackSent = 0


        resetsLeft = self.resetLimit
        while packetQueue and resetsLeft:
            #send packets in send window
            window = self.sendWindowSize
            while window and packetQueue:
                packetToSend = packetQueue.popleft()

                if (packetToSend and not isinstance(packetToSend, int)) and (not packetToSend.isAck()):
                    #log("Sending RxPPacket to IP: " + str(self.desAddr) + " and port + " + str(self.desUDPPort) + "...\n")
                    self.sendto(packetToSend.toByteArray(), (self.desAddr, self.desUDPPort))
                    numPackSent+=1
                    #log("RxPPacket sent!\n")
                    #log("RXP PACKET SIZE: " + str(len(packet.toByteArray())))
                    lastSeqNum = packetToSend.header['seqNum']

                    window -= 1
                    sentQueue.append(packet)

                else:
                    continue

            try:
                data, address = self.recvfrom(self.recvWindowSize)
                handShakeFinishedCheck = self.__reconstructPacket(bytearray(data))
                packet = self.__reconstructPacket(data = bytearray(data),  checkAckNum = lastSeqNum)

                if not packet:
                    sentQueue.reverse()
                    packetQueue.extendleft(sentQueue)
                    sentQueue.clear()
                    resetsLeft -= 1
                    continue

            except socket.timeout:
                window = 1
                resetsLeft -= 1
                sentQueue.reverse()
                packetQueue.extendleft(sentQueue)
                sentQueue.clear()

            except Exception:

                window = 1
                resetsLeft -= 1
                sentQueue.reverse()
                packetQueue.extendleft(sentQueue)
                sentQueue.clear()

            else:
                window += 1
                if (isinstance(packet, int)):
                    while packet < 0 and sentQueue:
                        packetQueue.appendleft(sentQueue.pop())
                        packet += 1
                        continue
                elif handShakeFinishedCheck.isAck() and handShakeFinishedCheck.header['ackNum'] == self.finalCnctAckNum:

                    flags = (False, False, True, False, False, False)
                    ackPacket = RxPacket(
                                srcPort = self.srcRxPPort,
                                desPort = self.desRxPPort,
                                seqNum = self.seqNum,
                                ackNum = self.ackNum,
                                flagList = flags,
                                winSize = self.recvWindowSize,
                                )
                    self.sendto(ackPacket.toByteArray(), (self.desAddr, self.desUDPPort))

                    resetsLeft = self.resetLimit

                    sentQueue.reverse()
                    packetQueue.extendleft(sentQueue)
                    sentQueue.clear()
                elif packet.isAck():
                    self.seqNum = packet.header['ackNum']
                    resetsLeft = self.resetLimit
                    sentQueue.clear()

        if not resetsLeft:
            raise Exception('socket timeout')