update,

hk1234566/python_networking/NetworkApplications_working.py

@@ -0,0 +1,685 @@
+#!/usr/bin/env python3
+
+
+
+# -*- coding: UTF-8 -*-
+
+
+
+######
+
+import argparse
+
+import socket
+
+import os
+
+import sys
+
+import struct
+
+import time
+
+
+
+
+
+def setupArgumentParser() -> argparse.Namespace:
+
+        parser = argparse.ArgumentParser(
+
+            description='A collection of Network Applications developed for SCC.203.')
+
+        parser.set_defaults(func=ICMPPing, hostname='lancaster.ac.uk')
+
+        subparsers = parser.add_subparsers(help='sub-command help')
+
+
+
+        parser_p = subparsers.add_parser('ping', aliases=['p'], help='run ping')
+
+        parser_p.add_argument('hostname', type=str, help='host to ping towards')
+
+        parser_p.add_argument('count', nargs='?', type=int,
+
+                            help='number of times to ping the host before stopping')
+
+        parser_p.add_argument('timeout', nargs='?',
+
+                            type=int,
+
+                            help='maximum timeout before considering request lost')
+
+        parser_p.set_defaults(func=ICMPPing)
+
+
+
+        parser_t = subparsers.add_parser('traceroute', aliases=['t'],
+
+                            help='run traceroute')
+
+        parser_t.add_argument('hostname', type=str, help='host to traceroute towards')
+
+        parser_t.add_argument('timeout', nargs='?', type=int,
+
+                            help='maximum timeout before considering request lost')
+
+        parser_t.add_argument('protocol', nargs='?', type=str,
+
+                            help='protocol to send request with (UDP/ICMP)')
+
+        parser_t.set_defaults(func=Traceroute)
+
+
+
+        parser_w = subparsers.add_parser('web', aliases=['w'], help='run web server')
+
+        parser_w.set_defaults(port=8080)
+
+        parser_w.add_argument('port', type=int, nargs='?',
+
+                            help='port number to start web server listening on')
+
+        parser_w.set_defaults(func=WebServer)
+
+
+
+        parser_x = subparsers.add_parser('proxy', aliases=['x'], help='run proxy')
+
+        parser_x.set_defaults(port=8000)
+
+        parser_x.add_argument('port', type=int, nargs='?',
+
+                            help='port number to start web server listening on')
+
+        parser_x.set_defaults(func=Proxy)
+
+
+
+        args = parser.parse_args()
+
+        return args
+
+
+
+
+
+
+
+class NetworkApplication:
+
+
+
+    def checksum(self, dataToChecksum: str) -> str: 
+
+        csum = 0
+
+        countTo = (len(dataToChecksum) // 2) * 2
+
+        count = 0
+
+        
+
+        while count < countTo:
+
+            thisVal = dataToChecksum[count+1] * 256 + dataToChecksum[count]
+
+            csum = csum + thisVal
+
+            csum = csum & 0xffffffff
+
+            count = count + 2
+
+
+
+        if countTo < len(dataToChecksum):
+
+            csum = csum + dataToChecksum[len(dataToChecksum) - 1]
+
+            csum = csum & 0xffffffff
+
+            
+
+        csum = (csum >> 16) + (csum & 0xffff)
+
+        csum = csum + (csum >> 16)
+
+        answer = ~csum
+
+        answer = answer & 0xffff
+
+        answer = answer >> 8 | (answer << 8 & 0xff00)
+
+        answer = socket.htons(answer)
+
+        return answer
+
+
+
+    def printOneResult(self, destinationAddress: str, packetLength:
+
+        int, time: float, ttl: int, destinationHostname=''):
+
+
+
+        if destinationHostname:
+
+            print("%d bytes from %s (%s):ttl=%d time=%.2f ms" % (packetLength, destinationHostname, destinationAddress, ttl, time))
+
+        else:
+
+            print("%d bytes from %s: ttl=%dtime=%.2f ms" % (packetLength, destinationAddress, ttl, time))
+
+
+
+    def printAdditionalDetails(self, packetLoss=0.0, minimumDelay=0.0,averageDelay=0.0, maximumDelay=0.0):
+
+        print("%.2f%% packet loss" % (packetLoss))
+
+        if minimumDelay > 0 and averageDelay > 0 and maximumDelay > 0:
+
+            print("rtt min/avg/max = %.2f/%.2f/%.2fms" % (minimumDelay, averageDelay, maximumDelay))
+
+
+
+
+
+class ICMPPing(NetworkApplication):
+
+
+
+    def receiveOnePing(self, icmpSocket, destinationAddress, ID,timeout):
+
+         # 1. Wait for the socket to receive a reply
+
+        timeLeft = timeout/1000 
+
+        select = 0
+
+        startedSelect = time.time()
+
+        whatReady = select.select([icmpSocket],[],[],timeLeft)
+
+        howLongInSelect =(time.time() - startedSelect)
+
+
+
+        # 2. Once received, record time of receipt, otherwise, handle a timeout
+
+        if whatReady[0] == []:#timeout 
+
+            return None
+
+
+
+        timeLeft = timeLeft - howLongInSelect
+
+        if timeLeft <= 0:
+
+            return None
+
+
+
+        recPacket, addr = icmpSocket.recvfrom(ICMP_MAX_RECV)
+
+        timeRecieved = time.time()      
+
+        icmpHeader = recPacket[20:28]
+
+
+
+        # 3. Compare the time of receipt to time of sending, producing the total network delay
+
+        timeSent = self.sendOnePing(icmpSocket, destinationAddress, 111) 
+
+        Delay = timeRecieved - timeSent
+
+
+
+        # 4. Unpack the packet header for useful information, including the ID
+
+        icmpType,icmpCode,icmpChecksum,icmpPacketID,icmpSeqNumber = struct.unpack("bbHHh",icmpHeader)
+
+        
+
+        # 5. Check that the ID matches between the request and reply
+
+        
+
+        # 6. Return total network delay  
+
+        if(icmpPacketID == ID):
+
+            return addr[0].Delay
+
+        
+
+        else:
+
+            return 0
+
+
+
+    def sendOnePing(self, icmpSocket, destinationAddress, ID):
+
+        # 1. Build ICMP header
+
+        Type = 8
+
+        code = 0
+
+        chksum = 0 
+
+        seq = 1
+
+        data = "data"
+
+        icmpHeader = struct.pack("bbHHh", Type, code,chksum, ID,seq) 
+
+    
+
+        # 2. Checksum ICMP packet using given function
+
+        real_chksum = self.checksum(icmpHeader)
+
+
+
+        # 3. Insert checksum into packet
+
+        icmpheader = struct.pack("bbHHh", type,code,real_chksum,ID,seq)
+
+        packet = icmpHeader
+
+        
+
+        # 4. Send packet using socket
+
+        icmpSocket.sendto(packet, (destinationAddress,1) ) #double check this //run with wireshark
+
+        
+
+        # 5. Record time of sending
+
+        sent_time = time.time()
+
+        return sent_time
+
+        
+
+    def doOnePing(self, destinationAddress, timeout):
+
+        # 1. Create ICMP socket
+
+        ICMP_CODE = socket.getprotobyname("icmp") #Translate an Internet protocol name (for example, 'icmp') to a constant suitable for passing as the (optional) third argument to the socket() function.
+
+        icmpSocket = socket.socket(socket.AF_INET,socket.SOCK_RAW, ICMP_CODE)
+
+        
+
+        # 2. Call sendOnePing function
+
+        timeSent = self.sendOnePing(icmpSocket, destinationAddress, 111)
+
+      
+
+        # 3. Call receiveOnePing function
+
+        AddressAndDelay = self.receiveOnePing(icmpSocket, destinationAddress, 111, 1000,timeSent)
+
+        
+
+        # 4. Close ICMP socket
+
+        icmpSocket.close()  
+
+
+
+        # 5. Return total network delay
+
+        return AddressAndDelay[0], AddressAndDelay[1]
+
+
+
+    def __init__(self, args):
+
+        print('Ping to: %s...' % (args.hostname))
+
+        # 1. Look up hostname, resolving it to an IP address
+
+        ip_address = socket.gethostbyname(args.hostname)
+
+
+
+        # 2. Call doOnePing function approximately every second
+
+        while True:
+
+            time.sleep(1)
+            testVariable = args.timeout
+            print("testing:", testVariable)
+            recAddressAndDelay = self.doOnePing(ip_address, testVariable, 1)
+
+
+
+        # 3. Print out the returned delay (and other relevant details) using the printOneResult method
+
+        self.printOneResult(ip_address, 50, recAddressAndDelay[1]*1000,150)
+
+         #Example use of printOneResult - complete as appropriate
+
+        # 4. Continue this process until stopped - would this be a loop? and when should we stop? 
+
+
+
+class Traceroute(NetworkApplication):
+
+
+
+    def __init__(self, args):
+
+        #
+
+        # Please ensure you print each result using the printOneResult method!
+
+        print('Traceroute to: %s...' % (args.hostname))
+
+        # 1. Look up hostname, resolving it to an IP address
+
+        ip_address = socket.gethostbyname(args.hostname)
+
+        # 2. Call PingOneNode function approximately every second
+
+        while True:
+
+            time.sleep(1)
+
+            nodalDelay = self.pingOneNode(ip_address,args.timeout,1)
+
+            # 4. Continue this process until stopped - until ICMP = 0
+
+            if ICMP == 0:
+
+                break
+
+        # 3. Print out the returned delay (and other relevant details) using the printOneResult method
+
+        self.printOneResult(ip_address, 50, nodalDelay[1]*1000,150) #check this don't think its right
+
+        
+
+    def pingOneNode():
+
+ # 1. Create ICMP socket
+
+        ICMP_CODE = socket.getprotobyname("icmp") #Translate an Internet protocol name (for example, 'icmp') to a constant suitable for passing as the (optional) third argument to the socket() function.
+
+        icmpSocket = socket.socket(socket.AF_INET,socket.SOCK_RAW, ICMP_CODE)
+
+        # 2. Call sendNodePing function
+
+        timeSent = self.sendNodePing(icmpSocket, destinationAddress, 111)
+
+        # 3. Call recieveNodePing function
+
+        AddressAndDelay = self.recieveNodePing(icmpSocket, destinationAddress, 111, 1000,timeSent)
+
+        # 4. Close ICMP socket
+
+        icmpSocket.close()  
+
+        # 5. Return total network delay- add up all the nodes 
+
+        for x in Nodes:
+
+            TotalDelay = (AddressAndDelay[x] + AddressAndDelay[x +1])
+
+            if x == "numberOfNodes":
+
+                break
+
+            return TotalDelay
+
+                
+
+    def sendNodePing():
+
+         # 1. Build ICMP header
+
+        Type = 8
+
+        code = 0
+
+        chksum = 0 
+
+        seq = 1
+
+        data = "data"
+
+        icmpHeader = struct.pack("bbHHh", Type, code,chksum, ID,seq) 
+
+        # 2. Checksum ICMP packet using given function
+
+        real_chksum = self.checksum(icmpHeader)
+
+        # 3. Insert checksum into packet
+
+        icmpheader = struct.pack("bbHHh", type,code,real_chksum,ID,seq)
+
+        packet = icmpHeader
+
+        # 4. Send packet using socket
+
+        icmpSocket.sendto(packet, (destinationAddress,1) ) #double check this //run with wireshark
+
+        # 5. Record time of sending
+
+        sentTime = time.time()
+
+        return sentTime
+
+
+
+    def recieveNodePing():
+
+         # 1. Wait for the socket to receive a reply- TTL = 0
+
+        timeLeft = timeout/1000 
+
+        select = 0
+
+        startedSelect = time.time()
+
+        whatReady = select.select([icmpSocket],[],[],timeLeft)
+
+        howLongInSelect =(time.time() - startedSelect)
+
+
+
+        # 2. Once received, record time of receipt, otherwise, handle a timeout
+
+        if TTL != 0:#timeout 
+
+            return None
+
+        timeLeft = timeLeft - howLongInSelect
+
+        if TTL == 0:       
+
+            recPacket, addr = icmpSocket.recvfrom(ICMP_MAX_RECV)
+
+            timeRecieved = time.time()     
+
+            icmpHeader = recPacket[20:28]
+
+            return timeLeft
+
+
+
+        # 3. Compare the time of receipt to time of sending, producing the total network delay
+
+        timeSent = self.sendNodePing(icmpSocket, destinationAddress, 111)    
+
+        Delay = timeRecieved - timeSent
+
+
+
+        # 4. Unpack the packet header for useful information, including the ID   
+
+        icmpType,icmpCode,icmpChecksum,icmpPacketID,icmpSeqNumber = struct.unpack("bbHHh",icmpHeader)
+
+        
+
+        # 5. Check that the ID matches between the request and reply
+
+        # 6. Return total network delay  
+
+        if(icmpPacketID == ID):
+
+            return pingOneNode.TotalDelay 
+
+        else:
+
+            return 0
+
+
+
+
+
+
+
+class WebServer(NetworkApplication):
+
+
+
+    def handleRequest(tcpSocket):
+
+        # 1. Receive request message from the client on connection socket
+
+        bufferSize = tcpSocket.CMSG_SPACE(4) #IPv4 address is 4 bytes in length
+
+        requestMessage = tcpSocket.recvmsg(bufferSize[0,[0]])
+
+        # 2. Extract the path of the requested object from the message (second part of the HTTP header)
+
+        file = requestMessage.unpack_from(format, buffer, offset=1) #returns a tuple 
+
+        # 3. Read the corresponding file from disk
+
+        socket.sendfile(file, offset=0, count=None)
+
+        # 4. Store in temporary buffer
+
+        buffer = socket.makefile(mode='r', buffering=None, encoding=None,errors=None, newline=None)
+
+        struct.pack_into(format, self.buffer, 0, file)
+
+        # 5. Send the correct HTTP response error
+
+        # 6. Send the content of the file to the socket
+
+        tcpSocket.recvmsg(bufferSize[0, 0])
+
+        # 7. Close the connection socket
+
+        tcpSocket.close()
+
+        pass
+
+
+
+    def __init__(self, args):
+
+        print('Web Server starting on port: %i...' % (args.port))
+
+        # 1. Create server socket
+
+        serverSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+
+        print("creating server socket")
+
+        # 2. Bind the server socket to server address and server port
+
+        serverSocket.bind((socket.gethostname(), 80))
+
+        print("binding socket")
+
+        # 3. Continuously listen for connections to server socket
+
+        serverSocket.listen(5)
+
+        # 4. When a connection is accepted, call handleRequest function, passing new connection socket (see https://docs.python.org/3/library/socket.html#socket.socket.accept)
+
+        newSocket = socket.accept()
+
+        while True:
+
+            handleRequest(newSocket)
+
+            print("calling handleRequest")
+
+            # 5. Close server socket
+
+            serverSocket.close()
+
+
+
+class Proxy(NetworkApplication):
+
+
+
+    def __init__(self, args):
+
+        print('Web Proxy starting on port: %i...' % (args.port))
+
+
+
+if __name__ == "__main__":
+
+      args = setupArgumentParser()    
+
+      args.func(args)
+
+ # 1. Receive request message from the client on connection socket
+         # IPv4 address is 4 bytes in length
+        bufferSize = connectionSocket.CMSG_SPACE(4)
+        requestMessage = connectionSocket.recvmsg(bufferSize[0, [0]])
+        # 2. Extract the path of the requested object from the message (second part of the HTTP header)
+        file = requestMessage.unpack_from( format, buffer, offset = 1)  # returns a tuple
+         # 2. send HTTP request for object to proxy server
+        httpRequest= ("GET /" + file + " HTTP/1.1\r\n\r\n")
+        connectionSocket.send(httpRequest.encode())
+        #connctionSocket.send("HTTP/1.1 200 OK\r\n\r\n")
+        print("Request message sent")
+        # 3. proxy server checks to see if copy of object is stored locally- calls class localObject
+        filename= requestMessage.split()[1]
+        try:
+            isObjectLocal=open(filename[1:], "r")  # open file in text mode
+            # 1.  if it does, the proxy server returns the object within a HTTP response message to the client browser
+            # 3. Read the corresponding file from disk
+            socket.sendfile(object, offset = 0, count =None)
+            #send via HTTP response message to client Browser
+
+        except isObjectLocal == "false":
+            # 2.  if it doesn’t, the proxy server opens a TCP connection to the origin server:
+            proxySocket=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            # bind the socket to a public host, and a well-known port
+            proxySocket.bind((socket.gethostname(), 80))
+            #sends HTTP request for object
+            proxySocket.send(httpRequest.encode())
+            #origin server recieves request
+            connectionSocket.recvmessage(httpRequest.encode())
+        # 4. proxy server sends HTTP request for the object into the cache-to-server TCP connection
+
+        # 5. origin server receives request
+
+        # 6. origin server sends object to proxy server within a HTTP response
+
+        # 7. proxy server receives the object
+        object= serverSocket.recvmsg(bufferSize[0, 0])
+
+        # 8. proxy server stores copy in its local storage
+
+        # 9. proxy server sends copy -in HTTP response message- to client browser over TCP connection
+
+        # proxy server checks to see if copy of object is stored locally
+