UDP-with-RDT-Protocol/serverHandler.py at master · smit-1999/UDP-with-RDT-Protocol · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
import socket,os,pickle,time,random
from packet import Packet
from UDPsocket import MySocket

#encapsulate payload,adds seq number ack payload:basically use Packet class
#
class Server():
    def __init__(self):
        print('Creating handler for server')
        self.seq_num = 0
        self.expected_seq_num = 0
        self.mySocket = self.createSocket()
        self.your_ip = 0
        self.dictionary = {}
    def createSocket(self):
        x = MySocket()
        newSocket = x.create()
        boundSocket = x.bind(newSocket, 9999)
        return boundSocket

    def getMySocket(self):
        return self.mySocket

    def set_your_ip(self,ip):
        self.your_ip = ip

    def getseq_num(self):
        return self.seq_num

    def generateSeq(self):
        seq = random.randrange(100000,999999,50)
        self.seq_num = seq
        return seq

    def createPacket(self, msg, mySeq , yourSeq):
        packet = Packet(mySeq,msg,True,yourSeq)
        return packet

    def sendAcks(self, receiverSocket , mySeq, yourSeq):
        packet = Packet(myseq, 'ack', True, yourSeq)
        ackSender = MySocket()
        ackSender.send_bytes(self.mySocket, receiverSocket, packet)

    def listen(self):
        data, ip = self.mySocket.recvfrom(1024)
        if ip in self.dictionary.keys():
            print('\nConnection already established.')
        else:
            print('\nNew client connected')
            recvd_packet = pickle.loads(data)
            seq_num = recvd_packet.seq_num
            my_seq_num = self.generateSeq()
            print('My sequence number for client ip',ip,'is:',my_seq_num)
            self.dictionary[ip] = [seq_num, my_seq_num,0] #client seq,my seq,exp seq
        return data,ip

    def handleDuplicates(self, recvd_packet, ip):
        replyPacket = Packet(self.dictionary[ip][1] ,'ack',True, recvd_packet.seq_num + 1)
        self.mySocket.sendto(pickle.dumps(replyPacket),ip)

        # replyPacket = Packet(self.seq_num ,'ack',True, recvd_packet.seq_num + 1)
        # self.mySocket.sendto(pickle.dumps(replyPacket),ip)

    def handleExpectedPacket(self, recvd_packet,ip):
        self.dictionary[ip][1]+=1
        replyPacket = Packet(self.dictionary[ip][1] ,'ack',True,recvd_packet.seq_num + 1)
        self.dictionary[ip][2] = self.dictionary[ip][1] + 1
        self.mySocket.sendto(pickle.dumps(replyPacket),ip)
        # self.seq_num+=1
        # replyPacket = Packet(self.seq_num ,'ack',True,recvd_packet.seq_num + 1)
        # self.expected_seq_num = self.seq_num + 1
        # self.mySocket.sendto(pickle.dumps(replyPacket),ip)