Merge branch 'a2' of tarfeef101/cs456 into master

a2/README.md

@@ -0,0 +1,18 @@
+# CS 456 A2 - Go-Back-N-ARQ
+
+This assignment consists of 2 python applications: sender.sh and receiver.sh. These are interfaces for the respective files.py. There is also the provided packet.py class which was provided, and is used for these apps to work. The cleanup.sh is simply there for convenience when I was testing. There are also the provided test files and emulator program.
+
+## Build Information
+ - This was tested on linux.student.cs.uwaterloo.ca, so the ubuntu1604 servers maintained by the CS faculty at uWaterloo.
+ - Testing included using the same server (002) for all of the emulator, sender, and receiver, as well as all 3 simultaneously.
+ - The python version used was 3.5.2
+
+## Deployment
+
+To run either the sender or the receiver, simply type "./[sender/receiver].sh" followed by all the arguments that need to be provided. Of course, the emulator should be run as well, in accordance with the provided spec. The arguments for the sender and receiver follow spec as well, but will be listed below for convenience.
+
+- Sender: host address, host port, sender's port, and filename to be sent
+- Receiver: host address, host port, receiver's port, and filename to be saved
+## Authors
+
+* **Tareef Dedhar** - *All work*

a2/cleanup.sh

@@ -0,0 +1,2 @@
+#!/bin/bash
+rm ack.log arrival.log segnum.log output.txt

a2/packet.py

@@ -0,0 +1,47 @@
+class packet:
+    MAX_DATA_LENGTH = 500
+    SEQ_NUM_MODULO = 32
+
+    # type is 0=ACK, 1=data, 2=EOT
+    # seq_num is the sequence number (mod 32)
+    # data is the string which is the data (empty if no data)
+    def __init__(self, type, seq_num, data):
+        if len(data) > self.MAX_DATA_LENGTH:
+            raise Exception("Data too large (max 500 char): ", len(data))
+
+        self.type = type
+        self.seq_num = seq_num % self.SEQ_NUM_MODULO
+        self.data = data
+
+    def get_udp_data(self):
+        array = bytearray()
+        array.extend(self.type.to_bytes(length=4, byteorder="big"))
+        array.extend(self.seq_num.to_bytes(length=4, byteorder="big"))
+        array.extend(len(self.data).to_bytes(length=4, byteorder="big"))
+        array.extend(self.data.encode())
+        return array
+
+    @staticmethod
+    def create_ack(seq_num):
+        return packet(0, seq_num, "")
+
+    @staticmethod
+    def create_packet(seq_num, data):
+        return packet(1, seq_num, data)
+
+    @staticmethod
+    def create_eot(seq_num):
+        return packet(2, seq_num, "")
+
+    @staticmethod
+    def parse_udp_data(UDPdata):
+        type = int.from_bytes(UDPdata[0:4], byteorder="big")
+        seq_num = int.from_bytes(UDPdata[4:8], byteorder="big")
+        length = int.from_bytes(UDPdata[8:12], byteorder="big")
+        if type == 0:
+            return packet.create_ack(seq_num)
+        elif type == 2:
+            return packet.create_eot(seq_num)
+        else:
+            UDPdata = UDPdata[12:12 + length].decode()
+            return packet(type, seq_num, UDPdata)

a2/receiver.py

@@ -0,0 +1,58 @@
+from packet import packet
+import socket, sys
+
+# save values needed to talk to host emulator
+haddr = sys.argv[1] # network host address
+dport = int(sys.argv[2]) # dest port on host
+rport = int(sys.argv[3]) # recv port for this app
+received = sys.argv[4] # filename to be used to record recvd data
+
+# try opening the file
+try:
+    msgfile = open(received, 'a')
+except IOError:
+    sys.stderr.write("Failed to open file to write data. Stop being terrible at life pls")
+    raise SystemExit
+
+# logfile (received packets)
+# at end call things.close()
+arrlog = open("arrival.log", "a")
+
+# some vars needed for execution
+expected = 0 # next packet # expected
+confirmed = None # last confirmed packet
+sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # socket!
+sock.bind(('', rport)) # set socket to recv on rport
+pack_size = 512 # packet size in bytes
+
+# let's get this bread! I mean packets. yes, I re-used that joke.
+while(True):
+    pack, addr = sock.recvfrom(pack_size)
+    
+    # if we can't get a packet
+    if (not pack):
+        break
+    else:
+        packet = packet.parse_udp_data(pack)
+        
+    snum = packet.seq_num
+    arrlog.write(str(snum) + "\n")
+    
+    if (snum == expected): # got the next packet
+        if (packet.type == 2): # EOT packet
+            # send EOT and exit
+            sock.sendto(packet.create_eot(snum).get_udp_data(), (haddr, dport))
+            break
+        elif (packet.type == 1): # data packet
+            # send ACK, record snum, increment expected
+            sock.sendto(packet.create_ack(snum).get_udp_data(), (haddr, dport))
+            confirmed = snum
+            expected = confirmed + 1
+            # deal with new data
+            msgfile.write(packet.data)
+            
+    elif (confirmed): # got wrong packet, send confirmation only of last good packet
+        sock.sendto(packet.create_ack(confirmed).get_udp_data(), (haddr, dport))
+        
+
+arrlog.close()

a2/receiver.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+
+#Run script for receiver as part of
+#Assignment 2
+#Computer Networks (CS 456)
+#Number of parameters: 4
+#Parameter:
+#    $1: <host_address>
+#    $2: <receiving_port_on_host>
+#    $3: <receiveing_port_on_receiver>
+#    $4: file_to_be_saved
+
+#For Python implementation
+if [ "$#" -ne 4 ];
+then
+  echo "Program takes 4 parameters, which are a host address, host port, receiver's port, and filename to be saved"
+  exit 1
+fi
+
+python3 receiver.py $1 $2 $3 $4

a2/sender.py

@@ -0,0 +1,122 @@
+from packet import packet
+import socket, sys, os, threading
+
+# save values needed to talk to host emulator
+haddr = sys.argv[1] # network host address
+dport = int(sys.argv[2]) # dest port on host
+rport = int(sys.argv[3]) # recv port for this app
+msg = sys.argv[4] # filename to be sent
+
+# logfiles (segnums and acks, respectively)
+# at end call things.close()
+seglog = open("segnum.log", "a")
+acklog = open("ack.log", "a")
+
+# some config vars
+winsize = 10 # window size
+tmout = 0.2 # tmout limit in s
+lock = threading.Lock() # used to avoid thread synch issues
+cv = threading.Condition(lock) # used to let our threads sleep when not needed
+timer = None # will be used for timing packet sendtimes
+first = 0 # first packet in the window
+confirmed = 0 # total confirmed packets for the current file
+snum = 0 # current number we want to send (sequence number, that is)
+char_limit = 500 # max num of characters in one packet's data field
+packets = [] # list to be turned into a list of packets
+total_packets = 0 # total number of packets
+waking = False # flag if the receiver is waking the sender thread
+pack_size = 512 # packet size in bytes
+
+# try opening the file
+try:
+    msgfile = open(msg, 'r')
+except IOError:
+    sys.stderr.write("Failed to open file. Stop being terrible at life pls")
+    raise SystemExit
+
+# create packets list
+while(True):
+    string = msgfile.read(char_limit)
+    if (not string):
+        break
+    packets.append(packet.create_packet(total_packets, string))
+    total_packets += 1
+   
+# make winsize not bigger than the file allows
+winsize = min(winsize, total_packets)
+
+# create socket
+sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+sock.bind(('', rport))
+
+# start receiver thread
+# receiver function
+def receiver():
+    global confirmed
+    global waking
+ 
+    while(True):
+        # get a packet, turn into packet type
+        pack, addr = sock.recvfrom(pack_size)
+        newpacket = packet.parse_udp_data(pack)
+        
+        lock.acquire()
+        # what type is this?
+        if (newpacket.type == 2): # EOT
+            acklog.write(str(newpacket.seq_num) + "\n")
+            lock.release()
+            return
+        elif (newpacket.type == 1): # data
+            lock.release()
+            sys.stderr.write("Got data from receiver. Exiting")
+            raise SystemExit
+        else: # ACK packet
+            acklog.write(str(newpacket.seq_num) + "\n")
+            if (newpacket.seq_num >= confirmed): # new ACK
+                confirmed = newpacket.seq_num + 1
+                waking = True
+                cv.notify_all()
+            
+            lock.release()
+            
+        
+
+recthread = threading.Thread(target=receiver, args=())
+#recthread.dameon = True
+recthread.start()
+    
+# let's get this bread! I mean send some packets
+while (confirmed < total_packets):
+    lock.acquire()
+    
+    # while we have room for packets in the window, send some
+    while(snum < confirmed + winsize and snum < total_packets):
+        sock.sendto(packets[snum].get_udp_data(), (haddr, dport))
+        seglog.write(str(snum) + "\n")
+        snum += 1
+        
+    # use cv to sleep for 0.2s, or if woken up
+    cv.wait(tmout) # we get lock back when this returns
+ 
+    # check if we woke from timer or not (status of waking flag)
+    # this means we were woken by an ACK.
+    if (waking):
+        # logic to deal with ACKS deal with in receiver
+        waking = False
+    else: # we need to reset window
+        snum = confirmed + 1 # reset to first unconfirmed packet
+        waking = False
+        
+    # ensure we don't overflow due to window reaching the end
+    winsize = min(winsize, total_packets - confirmed)
+    lock.release()
+
+
+# send EOT to receiver before closing
+sock.sendto(packet.create_eot(snum).get_udp_data(), (haddr, dport))
+recthread.join()
+sock.close()
+
+# cleanup for testing
+seglog.close()
+acklog.close()

a2/sender.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+
+#Run script for sender as part of
+#Assignment 2
+#Computer Networks (CS 456)
+#Number of parameters: 4
+#Parameter:
+#    $1: <host_address>
+#    $2: <receiving_port_on_host>
+#    $3: <receiveing_port_on_sender>
+#    $4: file_to_be_transmitted
+
+#For Python implementation
+if [ "$#" -ne 4 ];
+then
+  echo "Program takes 4 parameters, which are a host address, host port, sender's port, and filename to be sent"
+  exit 1
+fi
+
+python3 sender.py $1 $2 $3 $4