def run(self): try: p = [] while self.goOn: # wait for data p = os.read(self.tunIf, self.ETHERNET_MTU) # convert input from a string to a byte list p = [ord(b) for b in p] # debug info if log.isEnabledFor(logging.DEBUG): log.debug('packet captured on tun interface: {0}'.format( u.formatBuf(p))) # make sure it's an IPv6 packet (i.e., starts with 0x6x) if (p[0] & 0xf0) != 0x60: log.info('this is not an IPv6 packet') continue # because of the nature of tun for Windows, p contains ETHERNET_MTU # bytes. Cut at length of IPv6 packet. p = p[:self.IPv6_HEADER_LENGTH + 256 * p[4] + p[5]] # call the callback self.callback(p) except Exception as err: errMsg = u.formatCrashMessage(self.name, err) print errMsg log.critical(errMsg) sys.exit(1)
def run(self): try: p =[] while self.goOn: # wait for data p = os.read(self.tunIf,self.ETHERNET_MTU) # convert input from a string to a byte list p = [ord(b) for b in p] # debug info if log.isEnabledFor(logging.DEBUG): log.debug('packet captured on tun interface: {0}'.format(u.formatBuf(p))) # remove tun ID octets p = p[4:] # make sure it's an IPv6 packet (i.e., starts with 0x6x) if (p[0]&0xf0) != 0x60: log.info('this is not an IPv6 packet') continue # because of the nature of tun for Windows, p contains ETHERNET_MTU # bytes. Cut at length of IPv6 packet. p = p[:self.IPv6_HEADER_LENGTH+256*p[4]+p[5]] # call the callback self.callback(p) except Exception as err: errMsg=u.formatCrashMessage(self.name,err) print errMsg log.critical(errMsg) sys.exit(1)
def run(self): try: # log log.info("starting to run") #start the eventBusClient self.eventBusClient.start() while True: # reset the statistics self._resetStats() # wait to be connected self.connectSem.acquire() self.connectSem.release() # log log.info("starting to listen for data") try: while True: # wait for some data input = self.socket.recv(4096) # disconnect if needed if not input: if self._isConnected(): self.disconnect("No input.") break # increment statistics self._incrementStats('receivedPackets') self._incrementStats('receivedBytes', step=len(input)) # handle received data # the data received from the LBR should be: # - first 8 bytes: EUI64 of the final destination # - remainder: 6LoWPAN packet and above if len(input)<8: log.error("received packet from LBR which is too short ({0} bytes)".format(len(input))) continue # dispatch the packet to network state to figure out source route. dispatcher.send( sender = 'lbrClient', signal = 'lowpanToMesh', data = input, ) except socket.error as err: # disconnect self.disconnect("socket error while listening: {0}".format(err)) except Exception as err: errMsg=u.formatCrashMessage(self.name,err) print errMsg log.critical(errMsg) sys.exit(1)
def run(self): try: rxbuffer = win32file.AllocateReadBuffer(self.ETHERNET_MTU) while self.goOn: # wait for data try: l, p = win32file.ReadFile(self.tunIf, rxbuffer, self.overlappedRx) win32event.WaitForSingleObject(self.overlappedRx.hEvent, win32event.INFINITE) self.overlappedRx.Offset = self.overlappedRx.Offset + len( p) except Exception as err: print err log.error(err) raise ValueError('Error writing to TUN') else: # convert input from a string to a byte list p = [ord(b) for b in p] #print "tun input" #print p # make sure it's an IPv6 packet (starts with 0x6x) if (p[0] & 0xf0) != 0x60: # this is not an IPv6 packet continue # because of the nature of tun for Windows, p contains ETHERNET_MTU # bytes. Cut at length of IPv6 packet. p = p[:self.IPv6_HEADER_LENGTH + 256 * p[4] + p[5]] # call the callback self.callback(p) except Exception as err: errMsg = u.formatCrashMessage(self.name, err) print errMsg log.critical(errMsg) sys.exit(1)
def run(self): try: rxbuffer = win32file.AllocateReadBuffer(self.ETHERNET_MTU) while self.goOn: # wait for data try: l, p = win32file.ReadFile(self.tunIf, rxbuffer, self.overlappedRx) win32event.WaitForSingleObject(self.overlappedRx.hEvent, win32event.INFINITE) self.overlappedRx.Offset = self.overlappedRx.Offset + len(p) except Exception as err: print err log.error(err) raise ValueError('Error writing to TUN') else: # convert input from a string to a byte list p = [ord(b) for b in p] #print "tun input" #print p # make sure it's an IPv6 packet (starts with 0x6x) if (p[0]&0xf0)!=0x60: # this is not an IPv6 packet continue # because of the nature of tun for Windows, p contains ETHERNET_MTU # bytes. Cut at length of IPv6 packet. p = p[:self.IPv6_HEADER_LENGTH+256*p[4]+p[5]] # call the callback self.callback(p) except Exception as err: errMsg=u.formatCrashMessage(self.name,err) print errMsg log.critical(errMsg) sys.exit(1)
def run(self): try: # log log.info("starting to run") #start the eventBusClient self.eventBusClient.start() while True: # reset the statistics self._resetStats() # wait to be connected self.connectSem.acquire() self.connectSem.release() # log log.info("starting to listen for data") try: while True: # wait for some data input = self.socket.recv(4096) # disconnect if needed if not input: if self._isConnected(): self.disconnect("No input.") break # increment statistics self._incrementStats('receivedPackets') self._incrementStats('receivedBytes', step=len(input)) # handle received data # the data received from the LBR should be: # - first 8 bytes: EUI64 of the final destination # - remainder: 6LoWPAN packet and above if len(input) < 8: log.error( "received packet from LBR which is too short ({0} bytes)" .format(len(input))) continue # dispatch the packet to network state to figure out source route. dispatcher.send( sender='lbrClient', signal='lowpanToMesh', data=input, ) except socket.error as err: # disconnect self.disconnect( "socket error while listening: {0}".format(err)) except Exception as err: errMsg = u.formatCrashMessage(self.name, err) print errMsg log.critical(errMsg) sys.exit(1)
def run(self): try: # log log.info("start running") while self.goOn: # open serial port # log log.info("open port {0}".format(self.portname)) if self.mode==self.MODE_SERIAL: self.serial = serial.Serial(self.serialport,self.baudrate) elif self.mode==self.MODE_EMULATED: self.serial = self.emulatedMote.bspUart elif self.mode==self.MODE_IOTLAB: self.serial = socket.socket(socket.AF_INET,socket.SOCK_STREAM) self.serial.connect((self.iotlabmote,20000)) else: raise SystemError() while self.goOn: # read bytes from serial port try: if self.mode==self.MODE_SERIAL: rxBytes = self.serial.read(1) elif self.mode==self.MODE_EMULATED: rxBytes = self.serial.read() elif self.mode==self.MODE_IOTLAB: rxBytes = self.serial.recv(1024) else: raise SystemError() except Exception as err: print err log.warning(err) time.sleep(1) break else: for rxByte in rxBytes: if ( (not self.busyReceiving) and self.lastRxByte==self.hdlc.HDLC_FLAG and rxByte!=self.hdlc.HDLC_FLAG ): # start of frame if log.isEnabledFor(logging.DEBUG): log.debug("{0}: start of hdlc frame {1} {2}".format(self.name, u.formatStringBuf(self.hdlc.HDLC_FLAG), u.formatStringBuf(rxByte))) self.busyReceiving = True self.inputBuf = self.hdlc.HDLC_FLAG self.inputBuf += rxByte elif ( self.busyReceiving and rxByte!=self.hdlc.HDLC_FLAG ): # middle of frame self.inputBuf += rxByte elif ( self.busyReceiving and rxByte==self.hdlc.HDLC_FLAG ): # end of frame if log.isEnabledFor(logging.DEBUG): log.debug("{0}: end of hdlc frame {1} ".format(self.name, u.formatStringBuf(rxByte))) self.busyReceiving = False self.inputBuf += rxByte try: tempBuf = self.inputBuf self.inputBuf = self.hdlc.dehdlcify(self.inputBuf) if log.isEnabledFor(logging.DEBUG): log.debug("{0}: {2} dehdlcized input: {1}".format(self.name, u.formatStringBuf(self.inputBuf), u.formatStringBuf(tempBuf))) except OpenHdlc.HdlcException as err: log.warning('{0}: invalid serial frame: {2} {1}'.format(self.name, err, u.formatStringBuf(tempBuf))) else: if self.inputBuf==chr(OpenParser.OpenParser.SERFRAME_MOTE2PC_REQUEST): with self.outputBufLock: if self.outputBuf: outputToWrite = self.outputBuf.pop(0) self.serial.write(outputToWrite) else: # dispatch dispatcher.send( sender = self.name, signal = 'fromMoteProbe@'+self.portname, data = [ord(c) for c in self.inputBuf], ) self.lastRxByte = rxByte if self.mode==self.MODE_EMULATED: self.serial.doneReading() except Exception as err: errMsg=u.formatCrashMessage(self.name,err) print errMsg log.critical(errMsg) sys.exit(-1)
def run(self): try: # log log.info("start running") while self.goOn: # open serial port # log log.info("open port {0}".format(self.portname)) if self.mode==self.MODE_SERIAL: self.serial = serial.Serial(self.serialport,self.baudrate) self.serial.setDTR(0) self.serial.setRTS(0) elif self.mode==self.MODE_EMULATED: self.serial = self.emulatedMote.bspUart elif self.mode==self.MODE_IOTLAB: self.serial = socket.socket(socket.AF_INET,socket.SOCK_STREAM) self.serial.connect((self.iotlabmote,20000)) else: raise SystemError() while self.goOn: # read bytes from serial port try: if self.mode==self.MODE_SERIAL: rxBytes = self.serial.read(1) elif self.mode==self.MODE_EMULATED: rxBytes = self.serial.read() elif self.mode==self.MODE_IOTLAB: rxBytes = self.serial.recv(1024) else: raise SystemError() except Exception as err: print err log.warning(err) time.sleep(1) break else: for rxByte in rxBytes: if ( (not self.busyReceiving) and self.lastRxByte==self.hdlc.HDLC_FLAG and rxByte!=self.hdlc.HDLC_FLAG ): # start of frame if log.isEnabledFor(logging.DEBUG): log.debug("{0}: start of hdlc frame {1} {2}".format(self.name, u.formatStringBuf(self.hdlc.HDLC_FLAG), u.formatStringBuf(rxByte))) self.busyReceiving = True self.inputBuf = self.hdlc.HDLC_FLAG self.inputBuf += rxByte elif ( self.busyReceiving and rxByte!=self.hdlc.HDLC_FLAG ): # middle of frame self.inputBuf += rxByte elif ( self.busyReceiving and rxByte==self.hdlc.HDLC_FLAG ): # end of frame if log.isEnabledFor(logging.DEBUG): log.debug("{0}: end of hdlc frame {1} ".format(self.name, u.formatStringBuf(rxByte))) self.busyReceiving = False self.inputBuf += rxByte try: tempBuf = self.inputBuf self.inputBuf = self.hdlc.dehdlcify(self.inputBuf) if log.isEnabledFor(logging.DEBUG): log.debug("{0}: {2} dehdlcized input: {1}".format(self.name, u.formatStringBuf(self.inputBuf), u.formatStringBuf(tempBuf))) except OpenHdlc.HdlcException as err: log.warning('{0}: invalid serial frame: {2} {1}'.format(self.name, err, u.formatStringBuf(tempBuf))) else: if self.inputBuf==chr(OpenParser.OpenParser.SERFRAME_MOTE2PC_REQUEST): with self.outputBufLock: if self.outputBuf: outputToWrite = self.outputBuf.pop(0) self.serial.write(outputToWrite) else: # dispatch dispatcher.send( sender = self.name, signal = 'fromMoteProbe@'+self.portname, data = [ord(c) for c in self.inputBuf], ) self.lastRxByte = rxByte if self.mode==self.MODE_EMULATED: self.serial.doneReading() except Exception as err: errMsg=u.formatCrashMessage(self.name,err) print errMsg log.critical(errMsg) sys.exit(-1)
def run(self): try: # log log.info("start running") while self.goOn: # open serial port # log log.info("open port {0}".format(self.portname)) if self.mode==self.MODE_SERIAL: self.serial = serial.Serial(self.serialport,self.baudrate,timeout=1,xonxoff=True,rtscts=False,dsrdtr=False) elif self.mode==self.MODE_EMULATED: self.serial = self.emulatedMote.bspUart elif self.mode==self.MODE_IOTLAB: self.serial = socket.socket(socket.AF_INET,socket.SOCK_STREAM) self.serial.connect((self.iotlabmote,20000)) elif self.mode==self.MODE_TESTBED: # subscribe to topic: opentestbed/deviceType/mote/deviceId/00-12-4b-00-14-b5-b6-49/notif/frommoteserialbytes self.mqtt_seriaqueue = self.serialbytes_queue else: raise SystemError() while self.goOn: # read bytes from serial port try: if self.mode==self.MODE_SERIAL: rxBytes = self.serial.read(1) if rxBytes == 0: # timeout continue elif self.mode==self.MODE_EMULATED: rxBytes = self.serial.read() elif self.mode==self.MODE_IOTLAB: rxBytes = self.serial.recv(1024) elif self.mode==self.MODE_TESTBED: rxBytes = self.mqtt_seriaqueue.get() rxBytes = [chr(i) for i in rxBytes] else: raise SystemError() except Exception as err: print err log.warning(err) time.sleep(1) break else: for rxByte in rxBytes: if ( (not self.busyReceiving) and self.lastRxByte==self.hdlc.HDLC_FLAG and rxByte!=self.hdlc.HDLC_FLAG ): # start of frame if log.isEnabledFor(logging.DEBUG): log.debug("{0}: start of hdlc frame {1} {2}".format(self.name, u.formatStringBuf(self.hdlc.HDLC_FLAG), u.formatStringBuf(rxByte))) self.busyReceiving = True self.xonxoffEscaping = False self.inputBuf = self.hdlc.HDLC_FLAG self._addToInputBuf(rxByte) elif ( self.busyReceiving and rxByte!=self.hdlc.HDLC_FLAG ): # middle of frame self._addToInputBuf(rxByte) elif ( self.busyReceiving and rxByte==self.hdlc.HDLC_FLAG ): # end of frame if log.isEnabledFor(logging.DEBUG): log.debug("{0}: end of hdlc frame {1} ".format(self.name, u.formatStringBuf(rxByte))) self.busyReceiving = False self._addToInputBuf(rxByte) try: tempBuf = self.inputBuf self.inputBuf = self.hdlc.dehdlcify(self.inputBuf) if log.isEnabledFor(logging.DEBUG): log.debug("{0}: {2} dehdlcized input: {1}".format(self.name, u.formatStringBuf(self.inputBuf), u.formatStringBuf(tempBuf))) except OpenHdlc.HdlcException as err: log.warning('{0}: invalid serial frame: {2} {1}'.format(self.name, err, u.formatStringBuf(tempBuf))) else: if self.sendToParser: self.sendToParser([ord(c) for c in self.inputBuf]) self.lastRxByte = rxByte if self.mode==self.MODE_EMULATED: self.serial.doneReading() except Exception as err: errMsg=u.formatCrashMessage(self.name,err) print errMsg log.critical(errMsg) sys.exit(-1) finally: if self.mode==self.MODE_SERIAL and self.serial is not None: self.serial.close()
def run(self): try: # log log.info("start running") while self.goOn: # open serial port # log log.info("open port {0}".format(self.portname)) if self.mode==self.MODE_SERIAL: self.serial = serial.Serial(self.serialport,self.baudrate,timeout=1,rtscts=False,dsrdtr=False) elif self.mode==self.MODE_EMULATED: self.serial = self.emulatedMote.bspUart elif self.mode==self.MODE_IOTLAB: self.serial = socket.socket(socket.AF_INET,socket.SOCK_STREAM) self.serial.connect((self.iotlabmote,20000)) elif self.mode==self.MODE_TESTBED: # subscribe to topic: opentestbed/deviceType/mote/deviceId/00-12-4b-00-14-b5-b6-49/notif/frommoteserialbytes self.mqtt_seriaqueue = self.serialbytes_queue else: raise SystemError() while self.goOn: # read bytes from serial port try: if self.mode==self.MODE_SERIAL: rxBytes = self.serial.read(1) if rxBytes == 0: # timeout continue elif self.mode==self.MODE_EMULATED: rxBytes = self.serial.read() elif self.mode==self.MODE_IOTLAB: rxBytes = self.serial.recv(1024) elif self.mode==self.MODE_TESTBED: rxBytes = self.mqtt_seriaqueue.get() rxBytes = [chr(i) for i in rxBytes] else: raise SystemError() except Exception as err: print err log.warning(err) time.sleep(1) break else: for rxByte in rxBytes: if ( (not self.busyReceiving) and self.lastRxByte==self.hdlc.HDLC_FLAG and rxByte!=self.hdlc.HDLC_FLAG ): # start of frame if log.isEnabledFor(logging.DEBUG): log.debug("{0}: start of hdlc frame {1} {2}".format(self.name, u.formatStringBuf(self.hdlc.HDLC_FLAG), u.formatStringBuf(rxByte))) self.busyReceiving = True self.inputBuf = self.hdlc.HDLC_FLAG self.inputBuf += rxByte elif ( self.busyReceiving and rxByte!=self.hdlc.HDLC_FLAG ): # middle of frame self.inputBuf += rxByte elif ( self.busyReceiving and rxByte==self.hdlc.HDLC_FLAG ): # end of frame if log.isEnabledFor(logging.DEBUG): log.debug("{0}: end of hdlc frame {1} ".format(self.name, u.formatStringBuf(rxByte))) self.busyReceiving = False self.inputBuf += rxByte try: tempBuf = self.inputBuf with open(socket.gethostname()+'.log','a') as f: f.write(self.inputBuf) self.inputBuf = self.hdlc.dehdlcify(self.inputBuf) if log.isEnabledFor(logging.DEBUG): log.debug("{0}: {2} dehdlcized input: {1}".format(self.name, u.formatStringBuf(self.inputBuf), u.formatStringBuf(tempBuf))) except OpenHdlc.HdlcException as err: log.warning('{0}: invalid serial frame: {2} {1}'.format(self.name, err, u.formatStringBuf(tempBuf))) else: if self.inputBuf==chr(OpenParser.OpenParser.SERFRAME_MOTE2PC_REQUEST): with self.outputBufLock: if self.outputBuf: outputToWrite = self.outputBuf.pop(0) self.serial.write(outputToWrite) else: # dispatch dispatcher.send( sender = self.name, signal = 'fromMoteProbe@'+self.portname, data = [ord(c) for c in self.inputBuf], ) self.lastRxByte = rxByte if self.mode==self.MODE_EMULATED: self.serial.doneReading() except Exception as err: errMsg=u.formatCrashMessage(self.name,err) print errMsg log.critical(errMsg) sys.exit(-1) finally: if self.mode==self.MODE_SERIAL and self.serial is not None: self.serial.close()