def connect(self, factory, name, port, connectionType="RAW"): name = str( name) # force to a string in case we're accidentally given an addr try: pAddr = PlaygroundAddress.FromString(name) except: pAddr = None self.__trueConnectD = defer.Deferred() trueConnect = lambda address: self.__trueConnectD.callback( self.__clientBase.connect(factory, address, port, connectionType)) if not pAddr: if not isinstance(self.__n2pServerAddr, PlaygroundAddress): try: self.__n2pServerAddr = PlaygroundAddress.FromString( self.__n2pServerAddr) except: Timer.callLater( .1, lambda: self.__trueConnectD.errback( Exception( "Could not connect to resolver. Bad address %s" % self.__n2pServerAddr))) return self.__trueConnectD srcport, self.__resolver = self.__clientBase.connect( N2PClient(), self.__n2pServerAddr, N2PServer.DEFAULT_SERVING_PORT, "SECURE_STREAM") d = self.__resolver.waitForConnection() d.addCallback( lambda result: self.__resolverConnected(name, trueConnect)) d.addErrback(self.__resolverConnectFailed) else: Timer.callLater(.1, lambda: trueConnect(pAddr)) return self.__trueConnectD
def __checkConnectionState(self): if self.__connected == CONNECTED and self.__state == DATA: self.__processBuffer() elif self.__connected == CONNECTED and self.__state == FIN: self.transport.loseConnection() self.getHigherProtocol().connectionLost("Sent FIN, Timed out") else: Timer.callLater(0.05, lambda:self.__checkConnectionState())
def write(self, serialized_msg_from_top): #print "write" self.__pushToList(serialized_msg_from_top) logger.info("Message put in buffer, checking connection state") if (self.__connected == NOTCONNECTED): # No existing connection initiating handshake logger.info("PSST Handshake: Starting handshake") self.__initiateHandshake() Timer.callLater(0.05, lambda:self.__checkConnectionState()) elif (self.__connected == HANDSHAKE): # Handshake still not complete, buffer the messages logger.info("PSST Handshake: Handshake not complete") Timer.callLater(0.05, lambda:self.__checkConnectionState()) elif (self.__connected == CONNECTED): logger.info("PSST Handshake: Hanshake now complete, ready to send buffered messages") self.__processBuffer() else: logger.debug("PSST Handshake: Unknown connected state reached")
def writeSignedMessage(self, rMessage, shouldRetransmit): if self.idleTimeout: self.resetTimeout() else: self.initTimeout() rMessage.sequence_number = self.nextSequenceNumber rMessage.sessionID = self.sessionID rMessage.signature = "" unsignedMessage = rMessage.__serialize__() sig = self.sign(unsignedMessage) rMessage.signature = sig sMessage = rMessage.__serialize__() if len(rMessage.data) == 0: if not rMessage.acknowledgement_flag or rMessage.sequence_number_notification_flag: self.nextSequenceNumber = self.nextSequenceNumber + 1 else: self.nextSequenceNumber = self.nextSequenceNumber + len(rMessage.data) if len(self.unacknowledgedSent) >= self.maxSent and not rMessage.acknowledgement_flag: self.sendOverflow.append((self.nextSequenceNumber, sMessage, shouldRetransmit)) else: self.lowerTransport().write(sMessage) if shouldRetransmit: callNum = Timer.callLater(self.timeout, self.retransmit, self.nextSequenceNumber, sMessage) self.unacknowledgedSent.append([self.nextSequenceNumber, sMessage, callNum])
def retransmit(self, seqNum, sMessage): if not self.state == "CLOSED": if seqNum in [x[0] for x in self.unacknowledgedSent]: i = [x[0] for x in self.unacknowledgedSent].index(seqNum) self.unacknowledgedSent[i][2] = Timer.callLater(self.timeout, self.retransmit, seqNum, sMessage) logger.debug("RIP--Retransmitting packet %d", seqNum) self.lowerTransport().write(sMessage)
def transmitOverflow(self): self.sendOverflow.sort() while len(self.unacknowledgedSent) < self.maxSent and len(self.sendOverflow) > 0: seqNum, sMessage, shouldRetransmit = self.sendOverflow.pop() self.lowerTransport().write(sMessage) if shouldRetransmit: callNum = Timer.callLater(self.timeout, self.retransmit, seqNum, sMessage) self.unacknowledgedSent.append([seqNum, sMessage, callNum])
def start(self, clientBase, args): self.clientBase = clientBase result, msg = True, "" if "start_server" in args: mobileCodeServer = playground.network.client.sampleservers.ClientMobileCodeServer( ) result = clientBase.listen(mobileCodeServer, 100) if result == True: self.serving = True else: msg = "Could not start server" if "start_client" in args: print "start client" computePi = ComputePi( clientBase, playground.network.client.sampleservers.MobileCodeClient()) Timer.callLater(0, lambda: computePi.start(10000000)) self.client = computePi if not self.serving and not self.client: result, msg = False, "computePi requires either 'start_server', 'start_client', or both" return result, msg
def __initiateFIN(self): hmac = self.__generateHMAC(self.__sym_key, "FIN") fin_msg = self.__buildDataMessage("FIN", hmac, "") self.__send(fin_msg) self.__state = FIN Timer.callLater(2,lambda:self.__checkConnectionState())
def __generalFailure(self, e): self.transport.write("Got error: %s\n" % e) Timer.callLater(.1, self.shutdown) return Failure
def initTimeout(self): self.idleTimeout = Timer.callLater(self.idleTimeoutPeriod, self.timeoutExpired)
def __handleConnectionMessages(self, state, msgObj=None): if state == 0: self.__state = 0 self.__connected = 0 self.__handshake = 1 self.__currSeq = random.getrandbits(32) ##print "Preparing to send a SYN Message" ##print "The sequence number I am sending is :", self.__currSeq responseMessageBuilder = MessageData.GetMessageBuilder(PTCLMessage) responseMessageBuilder["Hash"].setData('0') responseMessageBuilder["MessageType"].setData("SYN") responseMessageBuilder["MessageSeq"].setData(self.__currSeq) responseMessageBuilder["AckSeq"].setData(0) responseMessageBuilder["Data"].setData("") # TODO Calculate the hash of the whole packet created above # and fill it in the HASH field of the packet msg_hash = self.hash_it(responseMessageBuilder) responseMessageBuilder["Hash"].setData(msg_hash) self.__waiting = 1 self.transport.writeMessage(responseMessageBuilder) Timer.callLater(0.1, lambda: self.checkState(0)) elif state == 1: # Server state where server received a SYN packet and will now send an SYNACK if (self.__state == 3 or self.__state == 2): ##print "Already Connected" return ##print "I have got a SYN and will now Send a SYNACK" self.__state = 1 self.__currSeq = random.getrandbits(32) #self.__curr_ackSeq = msgObj.MessageSeq ##print "The sequence number I got in the SYN is : ",msgObj.MessageSeq,"and the sequence number I am sending in the SYNACK is: ", self.__currSeq if (msgObj != None): self.__curr_ackSeq = msgObj.MessageSeq logger.debug( "Harsh: %s Hey! We got our SYN, setting curr_ackSeq to %d" % (self._addr, self.__curr_ackSeq)) #Prepare and send a SYNACK Message responseMessageBuilder = MessageData.GetMessageBuilder( PTCLMessage) responseMessageBuilder["Hash"].setData('0') responseMessageBuilder["MessageType"].setData("SYNACK") responseMessageBuilder["MessageSeq"].setData(self.__currSeq) responseMessageBuilder["AckSeq"].setData(self.__curr_ackSeq) responseMessageBuilder["Data"].setData("") msg_hash = self.hash_it(responseMessageBuilder) responseMessageBuilder["Hash"].setData(msg_hash) self.transport.writeMessage(responseMessageBuilder) Timer.callLater(0.1, lambda: self.checkState(1)) elif state == 2: if (self.__state >= 2): ##print "Multiple SYNACK, Discard" return self.__state = 2 ##print "I have got a SYNACK and will now send an ACK followed by data" ##print "The sequence number I got is : ",msgObj.MessageSeq, "and the sequence number i am sending is : ", self.__currSeq # Extract sequence number and set state variable self.__curr_ackSeq = msgObj.MessageSeq logger.debug( "Harsh: %s Hey! We got our SYNACK, setting curr_ackSeq to %d" % (self._addr, self.__curr_ackSeq)) #Prepare and send an ACK Message responseMessageBuilder = MessageData.GetMessageBuilder(PTCLMessage) responseMessageBuilder["Hash"].setData('0') responseMessageBuilder["MessageType"].setData("ACK") responseMessageBuilder["MessageSeq"].setData(0) responseMessageBuilder["AckSeq"].setData(msgObj.MessageSeq) responseMessageBuilder["Data"].setData("") #TODO Calculate the hash of the whole packet created above # and fill it in the HASH field of the packet msg_hash = self.hash_it(responseMessageBuilder) responseMessageBuilder["Hash"].setData(msg_hash) self.transport.writeMessage(responseMessageBuilder) ##print "sent an ACK , we are connected ,now sending Data:" ##print "Setting connected in client" self.__handshake = 1 self.__connected = 1 #self.__last_contig = self.__curr_ackSeq #set the timer #No timer because now data has to be sent, after sending ACK you don't # wait and start pushing data directly ##print "Sent Data" #print "Setting hb timer on receiver" self.__hb_timer = Timer.OneshotTimer(lambda: self.checkData()) self.__hb_timer.run(10) Timer.callLater(0.1, lambda: self.processQueue()) self.__session_timer = Timer.OneshotTimer( lambda: self.checkSession()) self.__session_timer.run(35) #Timer.callLater(0.1,lambda:self.checkState(2,msgObj)) #Check if the state has looped back to the same state. Store the current time # and check if it has changed after timeout elif state == 3: # Server side state, once server has received ACK from Client in response to SYNACK self.__state = 3 # Extract sequence number, check and set state variable ##print "I have got an ACK" #self.__currSeq = self.__currSeq +1 ##print "Setting connected in server" self.__connected = 1 self.__handshake = 1 self.__last_contig = msgObj.MessageSeq ##print "The sequence number I got is: ", msgObj.MessageSeq #print "Setting hb timer on sender" self.__hb_timer = Timer.OneshotTimer(lambda: self.checkData()) self.__hb_timer.run(10) self.__session_timer = Timer.OneshotTimer( lambda: self.checkSession()) self.__session_timer.run(35) elif state == 5: self.__state = 5 # Extract sequence number and set state variable ##print "I am going to send a FIN Message" self.__currSeq = self.__currSeq + 1 #Prepare and send an FIN Message responseMessageBuilder = MessageData.GetMessageBuilder(PTCLMessage) responseMessageBuilder["Hash"].setData('0') responseMessageBuilder["MessageType"].setData("FIN") responseMessageBuilder["MessageSeq"].setData(self.__currSeq) responseMessageBuilder["AckSeq"].setData(0) responseMessageBuilder["Data"].setData("") #TODO Calculate the hash of the whole packet created above # and fill it in the HASH field of the packet msg_hash = self.hash_it(responseMessageBuilder) responseMessageBuilder["Hash"].setData(msg_hash) self.transport.writeMessage(responseMessageBuilder) #set the timer self.__timely = Timer.callLater(0.1, lambda: self.checkState(5)) elif state == 6: ##print "I got a FIN Message and I will send a FINACK" self.__finhandshake = 1 self.__state = 6 self.__curr_ackSeq = msgObj.MessageSeq #Prepare and send an FINACK Message responseMessageBuilder = MessageData.GetMessageBuilder(PTCLMessage) responseMessageBuilder["Hash"].setData('0') responseMessageBuilder["MessageType"].setData("FINACK") responseMessageBuilder["MessageSeq"].setData(0) responseMessageBuilder["AckSeq"].setData(self.__curr_ackSeq) responseMessageBuilder["Data"].setData("") #TODO Calculate the hash of the whole packet created above # and fill it in the HASH field of the packet msg_hash = self.hash_it(responseMessageBuilder) responseMessageBuilder["Hash"].setData(msg_hash) ##print "Sending FINACK now: " self.transport.writeMessage(responseMessageBuilder) Timer.callLater( 0.1, lambda: self.getHigherProtocol().connectionLost( "Received FIN")) self.transport.loseConnection() self.__connected = 0 elif state == 7: ###print "I am suppose to send an ACK for data received:" responseMessageBuilder = MessageData.GetMessageBuilder(PTCLMessage) responseMessageBuilder["Hash"].setData('0') responseMessageBuilder["MessageType"].setData("ACK") responseMessageBuilder["MessageSeq"].setData(0) logger.info("Harsh: %s Sending ACK with ACK Sequence %d" % (self._addr, self.__curr_ackSeq)) responseMessageBuilder["AckSeq"].setData(self.__curr_ackSeq) # There is no data being piggy bagged on the ACK , if required put the data here from the # buffer where it is stored. responseMessageBuilder["Data"].setData("") responseMessageBuilder["Hash"].setData( self.hash_it(responseMessageBuilder)) self.transport.writeMessage(responseMessageBuilder) elif state == 8: self.__state = 8 self.__currSeq = 0 self.__curr_ackSeq = 0 ##print "I received a FINACK - Trying to terminate connection" ##print "dataList and rcvWindow are both empty, safe to terminate, connectionLost() called" Timer.callLater( 0.2, lambda: self.getHigherProtocol().connectionLost( "Received FINACK")) self.transport.loseConnection() if self.__timely: self.__timely.cancel() self.__connected = 0 else: pass
def checkSession(self): #print "I have been waiting for 35 seconds. this shit is not worth it.. I am leaving.." Timer.callLater( 0.1, lambda: self.getHigherProtocol().connectionLost( "Connection Lost Due to Inactivity"))