def sendXPackets(self,eventQueue,t,x): #creates the packets packets = [] for i in range(x): nBytes = min(MAX_PACKET_DATA, len(self.msgBytes) - self.seq) data = self.msgBytes[self.seq:self.seq + nBytes] p = TCPPacket(seq=self.seq,ack=self.ack,ACK =True, data=data) # no reason to have ack here? #adding the checksum to the packet p.checksum = (checksum16(p.toBytes()) ^ 0xFFFF ) packets.append(p) # if self.seq extends the amount of data in msgBytes, there're # no more packets to make if self.seq + (len(p.data))>= len(self.msgBytes): #this will be the last packet if DEBUG: print('all the packets are sent!') p.FIN = True #at this point, also need to recalculate the checksum p.checksum = 0x0000 p.checksum = (checksum16(p.toBytes()) ^ 0xFFFF ) break #add to sequence self.seq += nBytes #now to send all the packets! for p in packets: e = ReceivePacketEvent(self.server, p) #there's a chance that the packet WON'T be lost: if(random.random()>LOST_PACKET_PROBABILITY): if DEBUG: print("packet %r isn't lost"% p.data) eventQueue.enqueue(e, t + TRANSMISSION_DELAY) #I'm moving this to when the serverreceives the last message #if p.FIN: #self.queueRequestMessage(eventQueue, 66 +t + ROUND_TRIP_TIME) else: #if lost #if DEBUG: print("packet %r is LOST!!!"% p.data) #remember to add a timeout event toe = TimeoutEvent(self.server, p) eventQueue.enqueue(toe, t + 2*TRANSMISSION_DELAY) t+=1 if DEBUG: print("all packets in this batch are sent") print("here's the event queue:",str(eventQueue))
def sendNextPacket(self, eventQueue, t): """Sends the next packet in the message.""" nBytes = min(MAX_PACKET_DATA, len(self.msgBytes) - self.seq) data = self.msgBytes[self.seq:self.seq + nBytes] p = TCPPacket(seq=self.seq, ack=self.ack, ACK=True, data=data) if self.seq + nBytes == len(self.msgBytes): p.FIN = True #adding the checksum to the packet p.checksum = (checksum16(p.toBytes()) ^ 0xFFFF ) #adds event for server to receive this packet e = ReceivePacketEvent(self.server, p) #there's a chance that the packet will be lost: if(random.random()>LOST_PACKET_PROBABILITY): eventQueue.enqueue(e, t + TRANSMISSION_DELAY) if p.FIN: # if this is the last packet, it will start over. self.queueRequestMessage(eventQueue, t + ROUND_TRIP_TIME) #remember to add a timeout event #toe = TimeoutEvent(self.server, p) toe = TimeoutEvent(self, p) eventQueue.enqueue(toe, t + 2*TRANSMISSION_DELAY)
def sendNextPacket(self, eventQueue, t): """Sends the next packet in the message.""" nBytes = min(MAX_PACKET_DATA, len(self.msgBytes) - self.seq) data = self.msgBytes[self.seq:self.seq + nBytes] p = TCPPacket(seq=self.seq, ack=self.ack, ACK=True, data=data) if self.seq + nBytes == len(self.msgBytes): p.FIN = True e = ReceivePacketEvent(self.server, p) if random.randint(0, 1) >= LOST_PACKET_PROBABILITY: eventQueue.enqueue(e, t + TRANSMISSION_DELAY) if p.FIN: self.queueRequestMessage(eventQueue, t + TIMEOUT)
def sendNextPacket(self, eventQueue, t): """Sends the next packet in the message.""" nBytes = min(MAX_PACKET_DATA, len(self.msgBytes) - self.seq) data = self.msgBytes[self.seq:self.seq + nBytes] p = TCPPacket(seq=self.seq, ack=self.ack, ACK=True, data=data) if self.seq + nBytes == len(self.msgBytes): p.FIN = True self.awaitingAck[checksum16(p.toBytes())] = p if keepPacketBool(): e = ReceivePacketEvent(self.server, p) eventQueue.enqueue(e, t + TRANSMISSION_DELAY) self.queueTimeoutMessage(p,eventQueue,t) if p.FIN: self.queueRequestMessage(eventQueue, t + TIMEOUT)
def receivePacket(self, p, eventQueue, t): """ Handles packets sent from the server and sends an acknowledgment back in return. This version assumes that the sequence numbers appear in the correct order. """ ## ## THIS JUST SENDS THE ACK!! ## #self.msgBytes.extend(p.data) if p.seq == self.seq: self.seq+= len(p.data) self.msgBytes.extend(p.data) #there used to be something here that kept track of received packets # so that client didn't need to resend EVERYTHING, but I didn't implement # it well so I deleted it. self.ack = self.seq if DEBUG: print("server received %r and its seq/ack is now %r" % (p.data,self.ack)) reply = TCPPacket(seq=self.seq, ack=self.ack, ACK=True) if p.FIN and self.ack >= p.seq: #I should also check here to make sure last complete set is here reply.FIN = True print("Server receives \"" + self.msgBytes.decode("UTF-8") + "\"") if DEBUG: print("Cool I got all the packets! ") self.resetForNextMessage() eventQueue.clear() self.client.queueRequestMessage(eventQueue, t + ROUND_TRIP_TIME) #adding the checksum to the packet reply.checksum = (checksum16(reply.toBytes()) ^ 0xFFFF ) # here is where we should send the ack e = ReceivePacketEvent(self.client, reply) eventQueue.enqueue(e, t + TRANSMISSION_DELAY)
def receivePacket(self, p, eventQueue, t): """ Handles packets sent from the server and sends an acknowledgment back in return. This version assumes that the sequence numbers appear in the correct order. """ self.msgBytes.extend(p.data) self.seq = p.ack self.ack = p.seq + len(p.data) reply = TCPPacket(seq=self.seq, ack=self.ack, ACK=True, checksum = ~checksum16(p.toBytes())) if p.FIN: reply.FIN = True print("Server receives \"" + self.msgBytes.decode("UTF-8") + "\"") self.resetForNextMessage() e = ReceivePacketEvent(self.client, reply) eventQueue.enqueue(e, t + TRANSMISSION_DELAY)
def receivePacket(self, p, eventQueue, t): """ Handles packets sent from the server and sends an acknowledgment back in return. This version assumes that the sequence numbers appear in the correct order. """ def checkAllReceived(): # Sorts self.recieved self.received.sort() correctAck = MAX_PACKET_DATA # Check if packets are missing for ack, _ in self.received: if ack > correctAck: return False correctAck += MAX_PACKET_DATA return True self.seq = p.ack self.ack = p.seq + len(p.data) if (self.ack, p.data) not in self.received: self.received.append((self.ack, p.data)) if p.FIN: self.receivedFIN = True reply = TCPPacket(seq=self.seq, ack=self.ack, ACK=True, checksum=~checksum16(p.toBytes()), window=RECIEVE_WINDOW) #If all packets are present, message complete. if self.receivedFIN and checkAllReceived(): self.received.sort() for _, data in self.received: self.msgBytes.extend(data) reply.FIN = True e = ReceivePacketEvent(self.client, reply) eventQueue.enqueue(e, t + TRANSMISSION_DELAY) print("Server receives \"" + self.msgBytes.decode("UTF-8") + "\"") self.resetForNextMessage() else: if random.random() > LOST_PACKET_PROBABILITY: e = ReceivePacketEvent(self.client, reply) eventQueue.enqueue(e, t + TRANSMISSION_DELAY)
def sendNextPacket(self, eventQueue, t): """Sends the next packet in the message.""" nBytes = min(MAX_PACKET_DATA, len(self.msgBytes) - self.seq) data = self.msgBytes[self.seq:self.seq + nBytes] p = TCPPacket(seq=self.seq, ack=self.ack, ACK=True, data=data) if self.seq + nBytes == len(self.msgBytes): p.FIN = True e = ReceivePacketEvent(self.server, p) #With some probability, lose the packet if random.random() > LOST_PACKET_PROBABILITY: eventQueue.enqueue(e, t + TRANSMISSION_DELAY) #Queue the timeout event timeout = TimeoutEvent(self, p) self.waitingForAck[checksum16(p.toBytes())] = p eventQueue.enqueue(timeout, t + 4 * TRANSMISSION_DELAY) self.seq += nBytes self.ack = self.seq + 1 #If we aren't finished and serverRecieveWindow allows it, send next bytes if not p.FIN and len(self.waitingForAck) < self.serverRecieveWindow: self.sendNextPacket(eventQueue, t)