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()
