def server_bind(self): MADDR = "224.0.0.252" self.socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) self.socket.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 255) Join = self.socket.setsockopt(socket.IPPROTO_IP,socket.IP_ADD_MEMBERSHIP,socket.inet_aton(MADDR) + socket.inet_aton(OURIP)) UDPServer.server_bind(self)
def server_bind(self):
MADDR = '224.0.0.252'
MADDR6 = 'FF02:0:0:0:0:0:1:3'
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.socket.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 255)
Join = self.socket.setsockopt(
socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP,
socket.inet_aton(MADDR) + settings.Config.IP_aton)
#IPV6:
mreq = socket.inet_pton(socket.AF_INET6, MADDR6) + struct.pack(
'@I', if_nametoindex2(settings.Config.Interface))
self.socket.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_JOIN_GROUP,
mreq)
if OsInterfaceIsSupported():
try:
if settings.Config.Bind_To_ALL:
pass
else:
if (sys.version_info > (3, 0)):
self.socket.setsockopt(
socket.SOL_SOCKET, 25,
bytes(settings.Config.Interface + '\0', 'utf-8'))
self.socket.setsockopt(socket.IPPROTO_IPV6,
socket.IPV6_V6ONLY, False)
else:
self.socket.setsockopt(
socket.SOL_SOCKET, 25,
settings.Config.Interface + '\0')
self.socket.setsockopt(socket.IPPROTO_IPV6,
socket.IPV6_V6ONLY, False)
except:
pass
UDPServer.server_bind(self)
def server_bind(self): if OsInterfaceIsSupported(): try: self.socket.setsockopt(socket.SOL_SOCKET, 25, settings.Config.Bind_To+'\0') except: pass UDPServer.server_bind(self)
def server_bind(self):
MADDR = "224.0.0.252"
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.socket.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 255)
Join = self.socket.setsockopt(
socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP,
socket.inet_aton(MADDR) + settings.Config.IP_aton)
if OsInterfaceIsSupported():
try:
if settings.Config.Bind_To_ALL:
pass
else:
if (sys.version_info > (3, 0)):
self.socket.setsockopt(
socket.SOL_SOCKET, 25,
bytes(settings.Config.Interface + '\0', 'utf-8'))
else:
self.socket.setsockopt(
socket.SOL_SOCKET, 25,
settings.Config.Interface + '\0')
except:
raise
#pass
UDPServer.server_bind(self)
def server_bind(self): if utils.OsInterfaceIsSupported(): try: self.socket.setsockopt(socket.SOL_SOCKET, 25, responder_settings.Config.Bind_To+'\0') except: pass UDPServer.server_bind(self)
def __init__(self, HOST='localhost', PORT=4000, handler=KodemonUDPHandler, db_conn_string='sqlite:///AppData/Kodemon.sqlite'):
#Set up the server
UDPServer.__init__(self, (HOST, PORT), handler)
#Set up the database connection
engine = create_engine(db_conn_string)
self.Session = sessionmaker(bind=engine)
def server_bind(self): MADDR = "224.0.0.252" self.socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) self.socket.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 255) Join = self.socket.setsockopt(socket.IPPROTO_IP,socket.IP_ADD_MEMBERSHIP,socket.inet_aton(MADDR) + socket.inet_aton(OURIP)) UDPServer.server_bind(self)
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()
def __init__(self, server_address, RequestHandlerClass):
UDPServer.__init__(self, server_address, RequestHandlerClass)
self._shutdown_request = False
# watchdog guards against the failure mode when the remote target fails
# to send any packets. If the watchdog reaches the high water mark, the
# server is terminated so as not to leave the server thread unterminated
self.watchdog = 0.0
def __init__(self, *args, **kwargs):
"""
Initiate the server
"""
UDPServer.__init__(self, *args, **kwargs)
self.data = []
def __init__(self,
cdn_name,
port,
server_address,
handler_class=DNSUDPHandler):
self.name = cdn_name
UDPServer.__init__(self, server_address, handler_class)
return
def __init__(self,
server_address,
RequestHandlerClass,
container,
thread_class=Thread):
UDPServer.__init__(self, server_address, RequestHandlerClass)
CustomThreadingMixIn.__init__(self, thread_class)
self.container = container
self.daemon_threads = True
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 __init__(self, server_address, RequestHandlerClass, nametodns,
nameservers, ipv6, log):
self.nametodns = nametodns
self.nameservers = nameservers
self.ipv6 = ipv6
self.address_family = AF_INET6 if self.ipv6 else AF_INET
self.log = log
UDPServer.__init__(self, server_address, RequestHandlerClass)
self.daemon = True
def server_bind(self):
if OsInterfaceIsSupported():
try:
if settings.Config.Bind_To_ALL:
pass
else:
self.socket.setsockopt(socket.SOL_SOCKET, 25, settings.Config.Interface+'\0')
except:
pass
UDPServer.server_bind(self)
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
def __init__(self):
threading.Thread.__init__(self)
UDPServer.__init__(self,('0.0.0.0',1900),ssdpRequestHandler,False)
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
#self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
addr = socket.inet_aton(SSDP_ADDR)
interface = socket.inet_aton('0.0.0.0')
cmd = socket.IP_ADD_MEMBERSHIP
self.socket.setsockopt(socket.IPPROTO_IP, cmd, addr + interface)
self.socket.bind(('0.0.0.0', SSDP_PORT))
self.socket.settimeout(1)
def server_bind(self):
MADDR = "224.0.0.252"
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.socket.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 255)
self.socket.setsockopt(
socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP,
socket.inet_aton(MADDR) + socket.inet_aton(settings.Config.IP))
#self.socket.setsockopt(socket.SOL_SOCKET, 25, IP+'\0')
UDPServer.server_bind(self)
def __init__ (self):
from app import APP
port = APP.BE.LOGGING._i_server_port
UDPServer.__init__(self, ('127.0.0.1', port), None)
Process.__init__ (self, None, None, "pcLOG" )
self.queue = Queue( APP.BE.LOGGING._i_queue_size )
self.backend = LoggingBackend (self.queue)
self.backend.start()
self.on = True
self.start()
def shutdown(self):
for timer in self._scheduled_timers:
timer.cancel()
for notification in self._notifications:
handler = self.__get_multicast_handler()
handler.send_byebye(notification)
handler.release_response()
UDPServer.shutdown(self)
def server_bind(self): MADDR = "224.0.0.252" self.socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) self.socket.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 255) Join = self.socket.setsockopt(socket.IPPROTO_IP,socket.IP_ADD_MEMBERSHIP,socket.inet_aton(MADDR) + settings.Config.IP_aton) if OsInterfaceIsSupported(): try: self.socket.setsockopt(socket.SOL_SOCKET, 25, settings.Config.Bind_To+'\0') except: pass UDPServer.server_bind(self)
def server_bind(self):
MADDR = "224.0.0.252"
self.socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
self.socket.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 255)
Join = self.socket.setsockopt(socket.IPPROTO_IP,socket.IP_ADD_MEMBERSHIP,socket.inet_aton(MADDR) + settings.Config.IP_aton)
if OsInterfaceIsSupported():
try:
self.socket.setsockopt(socket.SOL_SOCKET, 25, settings.Config.Bind_To+'\0')
except:
pass
UDPServer.server_bind(self)
def server_bind(self): if OsInterfaceIsSupported(): try: if settings.Config.Bind_To_ALL: pass else: if (sys.version_info > (3, 0)): self.socket.setsockopt(socket.SOL_SOCKET, 25, bytes(settings.Config.Interface+'\0', 'utf-8')) else: self.socket.setsockopt(socket.SOL_SOCKET, 25, settings.Config.Interface+'\0') except: raise pass UDPServer.server_bind(self)
def __init__(self, regnancy_server_address):
for port in xrange(12000, 25000):
try:
logging.info("UDPServer starts")
UDPServer.__init__(self, ("", port), Handler)
logging.info("UDPServer runs %i", port)
break
except:
pass
self.timeout = 0.05
RegnancyUDPServer.regnancy_server_address = \
regnancy_server_address
self.running = True
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 __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 run_server():
# port 0 will choose a random free port
server = UDPServer(('localhost', 0), RequestHandler)
port = server.socket.getsockname()[1]
thr = Thread(target=server.serve_forever)
thr.daemon = True
thr.start()
return port
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()
def __init__(self, args):
"""Instantiate an OSCServer.
server_address ((host, port) tuple): the local host & UDP-port
the server listens on
"""
self.address_family = args.address_family
self.args = args
self.own_address = client_host, client_port = resolve_host(args.client_host, args.client_port, self.address_family, socket.AI_PASSIVE)
self.chaosc_address = chaosc_host, chaosc_port = resolve_host(args.chaosc_host, args.chaosc_port, self.address_family)
logger.info("binding to %s:%r", client_host, client_port)
UDPServer.__init__(self, self.own_address, OSCRequestHandler)
self.socket.setblocking(0)
if hasattr(args, "subscribe") and args.subscribe:
self.subscribe_me()
self.callbacks = {}
def __init__(self, address=("239.255.255.250", 1900), handler_class=SSDPHandler):
self._notifications = list()
self._scheduled_timers = list()
UDPServer.__init__(self, address, handler_class, bind_and_activate = False)
# needed to receive multicast messages
mreq = struct.pack("=4sl", socket.inet_aton("239.255.255.250"), socket.INADDR_ANY)
self.socket.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq)
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.socket.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 2)
self.socket.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_LOOP, 1)
self.notification_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.server_bind()
self.server_activate()
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 NodeReferee(object):
def __init__(self, verbose=False, name="NodeReferee"):
rospy.init_node(name, anonymous=False)
rospy.loginfo("Stop referee by pressing CTRL + C")
self.verbose = verbose
if verbose:
rospy.loginfo("Being verbose")
rospy.on_shutdown(self.shutdown)
# Publisher
self.topic = rospy.Publisher('soccer/referee', Bool, queue_size=10)
# UDP Server with callback
addr = ("", 4711)
rospy.loginfo("listening on %s:%s" % addr)
self.server = UDPServer(addr, Handler)
self.server.timeout = 5
self.server.callback = self.publish
# Stoppable serve_forever workaround =)
self.run = True
while(self.run):
self.server.handle_request()
def publish(self, data, client_address):
# By definition:
# 1 => keep going / start
# 0 => stop
running = (data == "1")
if self.verbose:
rospy.loginfo("Received '%s' from %s considered as %s" % (data, client_address, str(running)))
self.topic.publish(running)
def shutdown(self):
rospy.loginfo("Shutting down ... (can take up to %d seconds)" % self.server.timeout)
self.run = False
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()
def __init__(self, verbose=False, name="NodeReferee"):
rospy.init_node(name, anonymous=False)
rospy.loginfo("Stop referee by pressing CTRL + C")
self.verbose = verbose
if verbose:
rospy.loginfo("Being verbose")
rospy.on_shutdown(self.shutdown)
# Publisher
self.topic = rospy.Publisher('soccer/referee', Bool, queue_size=10)
# UDP Server with callback
addr = ("", 4711)
rospy.loginfo("listening on %s:%s" % addr)
self.server = UDPServer(addr, Handler)
self.server.timeout = 5
self.server.callback = self.publish
# Stoppable serve_forever workaround =)
self.run = True
while(self.run):
self.server.handle_request()
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 server_close(self):
UDPServer.server_close(self)
self.db.stop()
c = self.mbed.serial_readline(
) # 'UDPCllient waiting for server IP and port...'
if c is None:
self.print_result("ioerr_serial")
return
print c.strip()
stdout.flush()
class UDPEchoClient_Handler(BaseRequestHandler):
def handle(self):
""" One handle per connection
"""
data, socket = self.request
socket.sendto(data, self.client_address)
if '{{end}}' in data:
print
print data
else:
sys.stdout.write('.')
stdout.flush()
server = UDPServer((SERVER_IP, SERVER_PORT), UDPEchoClient_Handler)
print "HOST: Listening for connections..."
mbed_test = UDPEchoClientTest()
mbed_test.send_server_ip_port(SERVER_IP, SERVER_PORT)
server.serve_forever()
def __init__(self, cdn_name, server_address, handler_class=DNSUDPHandler):
self.name = cdn_name
UDPServer.__init__(self, server_address, handler_class)
return
def server_bind(self):
UDPServer.server_bind(self)
def serve_forever(self):
self.start_notifications()
UDPServer.serve_forever(self)
def __init__(self, **kwargs):
host = kwargs.get('host', '127.0.0.1')
port = int(kwargs.get('port', 8881))
UDPServer.__init__(self, (host, port), WowzaHandler)
self.db = DbLogger(**kwargs)
def __init__(self, server_address, RequestHandlerClass, container,
thread_class = Thread):
UDPServer.__init__(self, server_address, RequestHandlerClass)
CustomThreadingMixIn.__init__(self, thread_class)
self.container = container
self.daemon_threads = True
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 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()
def main():
server = UDPServer(('0.0.0.0', 41724), UDPRequestHandler)
print 'Server accepting UDP connections {}...'.format(server.server_address)
server.serve_forever()
def __init__(self, local_address = ('127.0.0.1', 69) ):
UDPServer.__init__(self, local_address, None)
def server_bind(self): self.allow_reuse_address = 1 #self.socket.setsockopt(socket.SOL_SOCKET, 25, 'eth0\0') UDPServer.server_bind(self)
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()
except (IOError, TypeError, OSError, ValueError, IndexError), err:
print "Error parsing request data: %s" % err
return "ERR"
class UDPHandle(BaseRequestHandler):
def handle(self):
addr = self.client_address
sock = self.request[1]
resp = ""
try:
raw_data = str(self.request[0]).strip().replace('\n', '')
if EOF not in raw_data or SOF not in raw_data:
print "Failed to pull entire stream..."
sock.sendto(ON_FAIL, addr)
return
print "From (%s): %s" % (str(addr), raw_data)
resp = data_handle(raw_data)
sock.sendto(SOF + resp + EOF, addr)
except (OSError, ValueError, TypeError, IOError), err:
print "UDP handle error: %s" % err
sock.sendto(SOF + resp + EOF, addr)
if __name__ == "__main__":
worx.set_thing(worx_thing)
server = UDPServer((BIND_ADDR, BIND_PORT), UDPHandle)
server.allow_reuse_address = True
print "Starting server...\nwaiting for data..."
server.serve_forever()
def __init__(self, server_address, handler_class=UDPHandler):
UDPServer.__init__(self, server_address, handler_class)
return
def server_bind(self): UDPServer.server_bind(self)
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()
def __init__(self, server_address, RequestHandlerClass, config):
self.config = config
UDPServer.__init__(self, server_address, RequestHandlerClass)
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()
def start(self):
UDPServer.allow_reuse_address = True
self.server = UDPServer((self.ip_address, self.port), SyslogUDPHandler)
th = Thread(target=self.server.serve_forever)
th.daemon = True
th.start()
