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)
