def run(self): try: self.msg.emit('starting router') self.physicalRouterSocket = socket(AF_INET, SOCK_STREAM) self.physicalRouterSocket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1) self.physicalRouterSocket.bind(Layer.PhysicalRouter) self.host, self.port = Layer.PhysicalRouter self.physicalRouterSocket.listen(1) self.msg.emit("Setup:\nIP = " + str(self.host) + '\tPort = ' + str(self.port) + '\nListening...') except Exception as exc: self.errorMsg.emit('ERROR! It was not possible start the execution: \n' + str(exc)) try: while True: if not self.mtuSent: self.getMyIPMAC() self.connectAsServer(self.physicalRouterSocket) #receive request file from client if self.receiveFile(self.physicalRouterSocket, 'binaryRouterClientRequest.txt'): self.package = self.interpretPackage('binaryRouterClientRequest.txt', 'blue') #Sending to and receiving from network layer Layer.send(Layer.NetworkRouter, self.package) self.msg.emit('Waiting answer...') self.answer, success = Layer.receive(self.physicalRouterSocket) self.msg.emit('Received package from Network layer.') serverIP = json.loads(self.answer)['destiny'] self.getDstMAC(serverIP[0]) self.answer = json.loads(self.answer)['datagram'] #Creating binary file of request from client and sending to server self.createFrame_BinaryFile(self.answer, 'binaryRouterRequest.txt','green') self.msg.emit ('Sending to server IP = ' + str(Layer.PhysicalServer)) self.connectAsClient(Layer.PhysicalServer) self.msg.emit ('Request sent.'); success = Layer.send(Layer.PhysicalServer, 'binaryRouterRequest.txt', self.mtu) #receiving answer from server if success and self.receiveFile(self.physicalRouterSocket, 'binaryRouterServerAnswer.txt'): self.package = self.interpretPackage('binaryRouterServerAnswer.txt', 'blue') #sending to and receiving from network layer Layer.send(Layer.NetworkRouter, self.package) self.msg.emit('Waiting answer...') self.answer, success = Layer.receive(self.physicalServerSocket) self.msg.emit('Received package from Network layer.') destiny = json.loads(self.answer)['destiny'] self.answer = json.loads(self.answer)['datagram'] #creating binary file of answer from server and sending to client self.createFrame_BinaryFile(self.answer, 'binaryRouterAnswer.txt','green') Layer.send(Layer.PhysicalClient, 'binaryRouterAnswer.txt', self.mtu) except Exception as exc: exc_type, exc_obj, exc_tb = sys.exc_info() error = exc_tb.tb_frame line = exc_tb.tb_lineno fileName = error.f_code.co_filename self.errorMsg.emit('ERROR! It was not possible run the server: \n' + str(exc)+ '\nLine = ' + str(line)) return False
def receiveFromInternet(self): try: self.transportServerSocket = socket(AF_INET, SOCK_STREAM) self.transportServerSocket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1) self.transportServerSocket.bind(Layer.TransportServer) self.transportServerSocket.listen(1) print 'Listening...' while True: self.segment, success = Layer.receive(self.transportServerSocket) self.transportProtocol = json.loads(self.segment)['transportProtocol'] self.msg.emit('Received a ' + self.transportProtocol + ' segment.') if success: if self.transportProtocol == 'TCP': if not self.interpretTCPSegment(self.segment): self.errorMsg.emit('Error trying to interpret TCP segment') else: #UDP protocol self.interpretUDPSegment(self.segment) self.sendToApplication() if self.receiveAnswer(): self.createSegment(self.transportProtocol, self.applicationPack) sent = Layer.send(Layer.NetworkServer, self.segment) print 'Answer sent to internet layer' except KeyboardInterrupt: print 'Shutting down transport server' except Exception as exc: exc_type, exc_obj, exc_tb = sys.exc_info() error = exc_tb.tb_frame line = exc_tb.tb_lineno fileName = error.f_code.co_filename print "Error! " + str(exc) print 'error line = ' + str(line) self.transportServerSocket.close()
def run(self): self.getMyIPMAC() self.physicalClientSocket = socket(AF_INET, SOCK_STREAM) self.physicalClientSocket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1) self.physicalClientSocket.bind(Layer.PhysicalClient) self.physicalClientSocket.listen(1) while True: self.msg.emit('Waiting datagram from Network layer') self.package, success = Layer.receive(self.physicalClientSocket) if success: self.msg.emit('Received package from Network layer.') destiny = json.loads(self.package)['destiny'] self.destiny = (destiny[0], destiny[1]) self.msg.emit ('Destiny = ' + str(self.destiny)) self.getDstMAC(self.destiny) self.package = json.loads(self.package)['datagram'] if success: if not self.mtuReceived: self.connectAsClient(self.destiny) self.createFrame_BinaryFile(self.package, 'binaryRequestClient.txt', 'blue') if self.probCollision != 0: while random.randint(0, 10) <= self.probCollision: rand = random.randint(0, 10) self.msg.emit('Collision detected, ' + str(rand) + ' seconds to retry...') time.sleep(rand) sent = Layer.send(self.destiny, 'binaryRequestClient.txt', self.myMTU) self.msg.emit('Sent binary file to Physical server.') if self.receiveFile(self.physicalClientSocket, 'binaryAnswer.txt'): self.msg.emit('Received binary file from server') self.answer = self.interpretPackage('binaryAnswer.txt', 'red') sent = Layer.send(Layer.NetworkClient, self.answer)
def run(self): self.networkServerSocket = socket(AF_INET, SOCK_STREAM) self.networkServerSocket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1) self.networkServerSocket.bind (Layer.NetworkServer) self.networkServerSocket.listen(1) while True: self.package, success = Layer.receive(self.networkServerSocket) if success: self.interpretPackage(self.package, 'blue') sent = Layer.send(Layer.TransportServer, self.datagram['data']) if sent: self.answer, success = Layer.receive(self.networkServerSocket) self.msg.emit ('Received answer') networkPackage = self.createNetworkPackage(Layer.PhysicalClient,self.createDatagram(self.answer, 'red')) sent = Layer.send(Layer.PhysicalServer, networkPackage) self.msg.emit ('Answer sent to physical layer')
def threeWayHandshake(self): if self.receive(self.SYN): if self.send_SYN_ACK(): self.segment, success = Layer.receive(self.transportServerSocket) self.segment = json.loads(self.segment) if self.receive(self.ACK): self.msg.emit('Three way handshake protocol established connection!') #self.receive_Data() return True return False
def receiveAnswer(self): self.answer, success = Layer.receive(self.transportClientSocket) if success: self.msg.emit('Received answer from Network layer.') if self.transportProtocol == 'UDP': self.interpretUDPSegment(self.answer) else: self.interpretTCPSegment(self.answer) print 'received answer' + str(success) #self.answer = json.loads(self.answer) return success
def receive_SYN_ACK (self): try: self.answer, success = Layer.receive(self.transportClientSocket) if success: self.msg.emit('Checking SYN_ACK') self.answer = json.loads(self.answer) self.html.emit(PDUPrinter.TCP(self.answer, 'blue')) if self.answer['flags'] == self.SYN_ACK: return True else: self.msg.emit('Acknowledge sequence number doesn\'t check') return False except Exception as exc: self.errorMsg.emit('DID NOT Receive SYN_ACK\n' + str(exc)) return False
def run(self): self.networkClientSocket = socket(AF_INET, SOCK_STREAM) self.networkClientSocket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1) self.networkClientSocket.bind (Layer.NetworkClient) self.networkClientSocket.listen(1) try: while True: self.frame, success = Layer.receive(self.networkClientSocket) if success: self.msg.emit ('Received UDP package from Transport Layer') networkPackage = self.createNetworkPackage(Layer.PhysicalServer, self.createDatagram(self.frame, 'blue')) Layer.send(Layer.PhysicalClient, networkPackage) self.msg.emit('Datagram sent to Physical layer.') self.answer, success = Layer.receive(self.networkClientSocket) if success: self.msg.emit('Received answer') self.interpretPackage(self.answer, 'red') sent = Layer.send(Layer.TransportClient, json.loads(self.answer)['data']) self.msg.emit ('Sent msg to transport client ' + str(sent)) except KeyboardInterrupt: print 'Shutting down Internet Layer Client' self.saveRouterTable() #self.transportSocket.close() self.networkClientSocket.close()
def run(self): self.networkRouterSocket = socket(AF_INET, SOCK_STREAM) self.networkRouterSocket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1) self.networkRouterSocket.bind (Layer.NetworkRouter) self.networkRouterSocket.listen(1) self.msg.emit('Starting router network layer.') while True: self.package, success = Layer.receive(self.networkRouterSocket) if success: self.interpretPackage(self.package, 'blue') #maintain port # return to physical layer self.srcIP = json.loads(self.package)['srcIP'] dstIP = self.consultTable(self.srcIP, self.mask) self.msg.emit ('Source IP = ' + str(self.srcIP)) transpPackage = json.loads(self.package)['data'] port = json.loads(transpPackage)['dstPort'] Layer.PhysicalServer = (dstIP, int(port)) print 'PhysicalServer = ' + str(Layer.PhysicalServer) destiny = self.consultTable(self.srcIP, self.mask), Layer.PhysicalServer[1] networkPackage = self.createNetworkPackage(destiny, self.package) sent = Layer.send(Layer.PhysicalRouter, networkPackage) self.msg.emit ('Answer sent to physical layer')
def run(self): try: self.physicalServerSocket = socket(AF_INET, SOCK_STREAM) self.physicalServerSocket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1) self.physicalServerSocket.bind(Layer.PhysicalServer) self.host, self.port = Layer.PhysicalServer self.physicalServerSocket.listen(1) self.msg.emit("Setup:\nIP = " + str(self.host) + '\tPort = ' + str(self.port) + '\nListening...') except Exception as exc: self.errorMsg.emit('ERROR! It was not possible start the execution: \n' + str(exc)) try: while True: if not self.mtuSent: self.getMyIPMAC() self.connectAsServer(self.physicalServerSocket) if self.receiveFile(self.physicalServerSocket, 'binaryRequestServer.txt'): self.package = self.interpretPackage('binaryRequestServer.txt', 'blue') Layer.send(Layer.NetworkServer, self.package) self.msg.emit('Waiting answer...') self.answer, success = Layer.receive(self.physicalServerSocket) self.msg.emit('Received package from Network layer.') destiny = json.loads(self.answer)['destiny'] self.getDstMAC(destiny[0]) self.answer = json.loads(self.answer)['datagram'] if success: self.createFrame_BinaryFile(self.answer, 'server_binary.txt', 'red') #self.sendAnswer() Layer.send(Layer.PhysicalClient, 'server_binary.txt', self.mtu) except Exception as exc: exc_type, exc_obj, exc_tb = sys.exc_info() error = exc_tb.tb_frame line = exc_tb.tb_lineno fileName = error.f_code.co_filename self.errorMsg.emit('ERROR! It was not possible run the server: \n' + str(exc)+ '\nLine = ' + str(line)) return False
def receiveFile(self, socket, fileName): with open (fileName, "w") as self.rFile: data, success = Layer.receive(socket) self.rFile.write(data) self.msg.emit('Received frame') return success