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