def __init__(self, dns_server, disable_cache=False, host='127.0.0.1', port=53, hosts_file='/etc/hosts'): self.dns_server = dns_server self.hosts_file = hosts_file self.host_lines = load_hosts(hosts_file) self.disable_cache = disable_cache self.cache = {} ThreadingUDPServer.__init__(self, (host, port), DNSProxyHandler)
def __init__(self, ip_str, port_num, handler): """Constructor fills in the ip and port numbers, and sets up the response handler.""" self.SMPCentralNodeServerAddress = (ip_str, port_num) self.Handler = handler; # RQ 1 # RQ 3 ThreadingUDPServer.__init__(self, self.SMPCentralNodeServerAddress, self.Handler)
class upper_socket_server(threading.Thread): def __init__(self): threading.Thread.__init__(self) self.server = ThreadingUDPServer(('192.168.20.136', 20000), Handler) def run(self): self.server.serve_forever()
def __init__( self, host="localhost", port=logging.handlers.DEFAULT_UDP_LOGGING_PORT, handler=LogRecordDatagramHandler ): ThreadingUDPServer.__init__(self, (host, port), handler) self.abort = 0 self.timeout = 1 self.logname = None
def __init__(self, addr, handler, poll_interval=0.5, bind_and_activate=True): class DelegatingUDPRequestHandler(DatagramRequestHandler): def handle(self): self.server._handler(self) ThreadingUDPServer.__init__(self, addr, DelegatingUDPRequestHandler, bind_and_activate) ControlMixin.__init__(self, handler, poll_interval)
def __init__(self,racelistserver): log(Log.INFO,"init broadcast server on port %s:%d" % (config.servername, config.broadcastport)) StopableThread.__init__(self) self._racelistserver = racelistserver self.allow_reuse_address = 1 ThreadingUDPServer.__init__(self,("",config.broadcastport),BroadCastServerRequestHandler)
def __init__(self, host='localhost', port=logging.handlers.DEFAULT_UDP_LOGGING_PORT, handler=LogRecordDatagramHandler): ThreadingUDPServer.__init__(self, (host, port), handler) self.abort = 0 self.timeout = 1 self.logname = None
def __init__(self, ip_str, port_num, handler): """Constructor fills in the ip and port numbers, and sets up the response handler.""" self.SMPCentralNodeServerAddress = (ip_str, port_num) self.Handler = handler # RQ 1 # RQ 3 ThreadingUDPServer.__init__(self, self.SMPCentralNodeServerAddress, self.Handler)
def __init__(self, addr, handler, poll_interval=0.5, bind_and_activate=True, interfaces=None): ThreadingUDPServer.__init__(self, ('', addr[1]), handler, bind_and_activate) ControlMixin.__init__(self, handler, poll_interval) self._multicast_address = addr self._listen_interfaces = interfaces self.set_loopback_mode(1) # localhost self.set_ttl(2) # localhost and local network self.handle_membership(socket.IP_ADD_MEMBERSHIP)
def __init__(self, addr, handler, poll_interval=0.5, bind_and_activate=True, iface=None): ThreadingUDPServer.__init__(self, ('', addr[1]), handler, bind_and_activate) ControlMixin.__init__(self, handler, poll_interval) self._multicast_address = addr self._listen_interfaces = iface self.setLoopbackMode(1) # localhost self.setTTL(2) # localhost and local network self.handle_membership(socket.IP_ADD_MEMBERSHIP)
def __init__(self, dns_server, disable_cache=False, host='127.0.0.1', port=53, hooks=None): self.dns_server = dns_server self.cache = Cache() self.cache.enabled = not disable_cache self.hooks = hooks ThreadingUDPServer.__init__(self, (host, port), DNSProxyHandler)
class upper_socket_server(threading.Thread): def __init__(self): threading.Thread.__init__(self) self.server = ThreadingUDPServer(('', 20000), Handler) def run(self): self.server.serve_forever() def go(self): self.setDaemon(True) self.start()
def __init__(self, file_name, port, level=logging.INFO, format_pattern=DEFAULT_FORMAT_PATTERN): self.file_name = file_name self.level = level self.format_pattern = format_pattern ThreadingUDPServer.__init__(self, ('127.0.0.1', port), LogRecordHandler) self.abort = 0 self.timeout = 1
def __init__(self): log = open(DNS_LOCAL_PATH+'switch.log','w') log.write('This file will be clear up when restar !\nUnswitched DNS query :\n') log.close() self.hostslist = lodehosts() self.switchlist = loadswitchfile() self.servers,self.Log_all = loadconf() if not self.servers: print 'Loding ',DNS_CONFIG_FILE,' false ' sys.exit(0) print 'z.DNS is running now ! \nUsing DNS : ' + self.servers[0] + ' ' + self.servers[1] ThreadingUDPServer.__init__(self, ('127.0.0.1', 53), DNSProxyHandler)
def server_bind(self): ' Use ioctl signal to resolve address from interface. ' ''' Set our socket to accept broadcast messages and limit down our multicasting interfaces to the selected one. ''' self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1) self.socket.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_IF, self.server_address[0]) ' When binding we actually want _every_ address, for broadcasting. ' self.server_address = ('', self.server_address[1]) ThreadingUDPServer.server_bind(self)
def __init__(self): # read configuration from file (defaults included) config = ConfigParser({ 'loglevel': 'INFO', 'logfile': APPNAME + 'log', 'addr': '127.0.0.1', 'port': 5000, 'cryptokey': 'default' }) config.read([CONFFILE]) # set tunables self.loglevel = config.get(APPNAME, 'loglevel') self.logfile = config.get(APPNAME, 'logfile') self.addr = config.get(APPNAME, 'addr') self.port = config.getint(APPNAME, 'port') self.cryptokey = config.get(APPNAME, 'cryptokey') # set local variables self.filterlist = () self.pktcount = 0 self.handler = DNSFlowHandler self.server = ThreadingUDPServer((self.addr, self.port), self.handler) self.server.queue = Queue() # initialize and setup logging logging.basicConfig(filename=self.logfile, format=LOGFMT) self.log = logging.getLogger(APPNAME) if self.loglevel in LOGLEVELS: self.log.setLevel(LOGLEVELS[self.loglevel]) # crypto stuff -- choose AES128 CBC self.server.cryptocipher = AES.new self.server.cryptomode = AES.MODE_CBC self.server.cryptoblocksize = AES.block_size self.server.cryptokey = self._pad_pkcs7_block( self.cryptokey, self.server.cryptoblocksize) # build a list of DNS IDS filter functions callable = lambda i: hasattr(i, '__call__') isfilter = lambda o, i: callable(getattr(o, i)) \ and i[:7] == 'filter_' self.filterlist = [ getattr(sniff_filters, i) for i in dir(sniff_filters) if isfilter(sniff_filters, i) ] # start listening/analysing service self.log.info('Started %s @ %s' % (APPNAME, time.asctime())) thread.start_new_thread(self.process_flow, ()) self.server.serve_forever()
def start_malware_center(ip="localhost", port=56565): '''Starts Malware Center. Args: ip: IP address of Malware Center server. port: port of Malware Center server. ''' server = ThreadingUDPServer((ip, port), Malware_request_handler) server.allow_reuse_address = True print("Malware Center started") print("IP: " + ip) print("PORT: " + str(port)) #print("new worm instance h3-eth0:77.77.77.77") server.serve_forever()
def server_bind(self): try: if hasattr(socket, "SO_REUSEADDR"): self.socket.setsockopt( socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) except Exception as e: logging.log(e) try: if hasattr(socket, "SO_REUSEPORT"): self.socket.setsockopt( socket.SOL_SOCKET, socket.SO_REUSEPORT, 1) except Exception as e: logging.log(e) ThreadingUDPServer.server_bind(self)
def server_bind(self): try: if hasattr(socket, "SO_REUSEADDR"): self.socket.setsockopt( socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) except Exception as e: logger.error(e) try: if hasattr(socket, "SO_REUSEPORT"): self.socket.setsockopt( socket.SOL_SOCKET, socket.SO_REUSEPORT, 1) except Exception as e: logger.error(e) ThreadingUDPServer.server_bind(self)
def __init__( self, dns_server, backup_server=None, disable_cache=False, host="127.0.0.1", port=53, hosts_file=DEFAULT_FILE, ): self.dns_server = dns_server self.backup_server = backup_server self.hosts_file = hosts_file self.host_lines = load_hosts(hosts_file) self.disable_cache = disable_cache self.cache = {} ThreadingUDPServer.__init__(self, (host, port), DNSProxyHandler)
def __init__(self, addr, clients): self.clients = clients broadcast = inet_iton(clients.subnet + clients.hosts + 1) # Set static options self.server_opts = { 1 : clients.mask, # Subnet mask 3 : clients.addr, # Router address 6 : clients.addr, # Domain Name Server address 28 : broadcast, # Broadcast address 51 : 60 * 60, # IP address lease time 54 : clients.addr, # DHCP Server identifier 58 : 60 * 30, # Renewal time 59 : 60 * 50 # Rebinding time } ThreadingUDPServer.__init__(self, (addr, 67), self.handle_message)
class ReceiveDataUDPServer(threading.Thread): """Thread the runs the main UDP Server""" def __init__(self): super(ReceiveDataUDPServer, self).__init__() self.daemon = True # Setup threading UDP server host, port = "", 9767 self.server = ThreadingUDPServer((host, port), ReceiveDataUDPHandler) def run(self): """Run method""" self.server.serve_forever() def stop(self): """Stop the UDP server""" LOG.info('UDP server stop called') self.server.shutdown() while self.isAlive(): time.sleep(0.01) LOG.info('UDP server stopped')
def __init__(self): # read configuration from file (defaults included) config = ConfigParser({'loglevel': 'INFO', 'logfile': APPNAME + 'log', 'addr': '127.0.0.1', 'port': 5000, 'cryptokey': 'default'}) config.read([CONFFILE]) # set tunables self.loglevel = config.get(APPNAME, 'loglevel') self.logfile = config.get(APPNAME, 'logfile') self.addr = config.get(APPNAME, 'addr') self.port = config.getint(APPNAME, 'port') self.cryptokey = config.get(APPNAME, 'cryptokey') # set local variables self.filterlist = () self.pktcount = 0 self.handler = DNSFlowHandler self.server = ThreadingUDPServer((self.addr, self.port), self.handler) self.server.queue = Queue() # initialize and setup logging logging.basicConfig(filename=self.logfile, format=LOGFMT) self.log = logging.getLogger(APPNAME) if self.loglevel in LOGLEVELS: self.log.setLevel(LOGLEVELS[self.loglevel]) # crypto stuff -- choose AES128 CBC self.server.cryptocipher = AES.new self.server.cryptomode = AES.MODE_CBC self.server.cryptoblocksize = AES.block_size self.server.cryptokey = self._pad_pkcs7_block(self.cryptokey, self.server.cryptoblocksize) # build a list of DNS IDS filter functions callable = lambda i: hasattr(i, '__call__') isfilter = lambda o, i: callable(getattr(o, i)) \ and i[:7] == 'filter_' self.filterlist = [getattr(sniff_filters, i) for i in dir(sniff_filters) if isfilter(sniff_filters, i)] # start listening/analysing service self.log.info('Started %s @ %s' % (APPNAME, time.asctime())) thread.start_new_thread(self.process_flow, ()) self.server.serve_forever()
def start_udp(self, port): """Create a UDP server and start listening for data. Put any input data on the inq for listen to read, and send any data on the outq. The drvAsynIPPortConfigure should connect to localhost:port if the simulation is on the same machine as the IOC.""" if self.started: self.diagnostic("Server already started") else: self.inq, self.outq = Queue.Queue(), Queue.Queue() self.started = True self.udp = True # store the request to respond to self.outreq = None def MakeHandler(device): # make a basic tcp handler that puts messages on a queue class ProxyHandler(BaseRequestHandler): def setup(self): BaseRequestHandler.setup(self) device.onHandlerSetup(self) def finish(self): BaseRequestHandler.finish(self) device.onHandlerFinish(self) def handle(self): if self.request != None: data = "nothing yet" device.outreq = (self.request[1], self.client_address) device.inq.put(self.request[0]) return ProxyHandler self.server = ThreadingUDPServer(("", port), MakeHandler(self)) # start to listen on the master port self.__daemon(self.server.serve_forever) # start to respond to any messages put on the outq self.__daemon(self.__ip_out) # start the worker thread self.__daemon(self.__process)
def main(): server = ThreadingUDPServer((HOST, PORT), ThreadedUDPRequestHandler) server_thread = threading.Thread(target=server.serve_forever) server_thread.daemon = True try: server_thread.start() logger = logging.getLogger("app") logger.info("Server started at {} port {}".format(HOST, PORT)) # 一个死循环 while True: time.sleep(100) except (KeyboardInterrupt, SystemExit): server.shutdown() server.server_close() exit()
def __init__(self, local, master, hosts): self.local = local self.master = master self.hosts = hosts ThreadingUDPServer.__init__(self, local, ProxyDnsHandler)
def __init__(self, disable_cache=False, host='127.0.0.1', port=53000): self.disable_cache = disable_cache self.cache = {} ThreadingUDPServer.__init__(self, (host, port), DNSHandler)
def __init__(self, port_num): ThreadingUDPServer.__init__(self, ('', port_num), DNS_Handler_class) return
def __init__(self, server_address, data_store_handler, RequestHandlerClass=DRRequestHandler, bind_and_activate=True): ThreadingUDPServer.__init__(self, server_address, RequestHandlerClass) self.data_store_handler = data_store_handler
def __init__(self, port_num): ThreadingUDPServer.__init__(self, ('',port_num), DNS_Handler_class) return
def start_malware_center(self, ip="1.2.3.254", port=56565): server = ThreadingUDPServer((ip, port), Malware_request_handler) server.allow_reuse_address = True print("server started") server.serve_forever() return server
def __init__(self): super(ReceiveDataUDPServer, self).__init__() self.daemon = True # Setup threading UDP server host, port = "", 9767 self.server = ThreadingUDPServer((host, port), ReceiveDataUDPHandler)
stream_handler.setFormatter(formatter) file_handler.setFormatter(formatter) from logging import getLogger log = getLogger(__name__) log.addHandler(file_handler) # log.addHandler(stream_handler) # f**k = getLogger("{}_stream_logger".format(__name__)) # f**k.addHandler(stream_handler) from logging import INFO log.setLevel(INFO) # f**k.setLevel(INFO) intercept_domain, intercept_rr = [], [] with open(args.intercept) as zonefile: for zone in zonefile: intercept_domain.append(zone.split(" ")[0]) intercept_rr.append(zone) intercept_domain = list(set(intercept_domain)) server = ThreadingUDPServer((args.host, args.port), CleanDNSHandler) # server_thread = Thread(target=server.serve_forever) # server_thread.daemon = False try: # server_thread.start() server.serve_forever() except KeyboardInterrupt: server.shutdown() server.server_close()
def __init__(self, local_server, dns_server, hosts='/ets/hosts'): self.local_server = local_server self.dns_server = dns_server self.hosts = Hosts(hosts) ThreadingUDPServer.__init__(self, local_server, DnsProxyHandler)
def __init__(self, local_server, dns_server): self.local_server = local_server self.dns_server = dns_server ThreadingUDPServer.__init__(self, local_server, DnsProxyHandler)
def __init__(self, addr, handler, timeout=1): ThreadingUDPServer.__init__(self, addr, LogRecordDatagramHandler) BaseServer.__init__(self, handler, timeout)
class DNSFlowServer(ThreadingUDPServer): """Central threading UDP server (central console) class.""" def __init__(self): # read configuration from file (defaults included) config = ConfigParser({'loglevel': 'INFO', 'logfile': APPNAME + 'log', 'addr': '127.0.0.1', 'port': 5000, 'cryptokey': 'default'}) config.read([CONFFILE]) # set tunables self.loglevel = config.get(APPNAME, 'loglevel') self.logfile = config.get(APPNAME, 'logfile') self.addr = config.get(APPNAME, 'addr') self.port = config.getint(APPNAME, 'port') self.cryptokey = config.get(APPNAME, 'cryptokey') # set local variables self.filterlist = () self.pktcount = 0 self.handler = DNSFlowHandler self.server = ThreadingUDPServer((self.addr, self.port), self.handler) self.server.queue = Queue() # initialize and setup logging logging.basicConfig(filename=self.logfile, format=LOGFMT) self.log = logging.getLogger(APPNAME) if self.loglevel in LOGLEVELS: self.log.setLevel(LOGLEVELS[self.loglevel]) # crypto stuff -- choose AES128 CBC self.server.cryptocipher = AES.new self.server.cryptomode = AES.MODE_CBC self.server.cryptoblocksize = AES.block_size self.server.cryptokey = self._pad_pkcs7_block(self.cryptokey, self.server.cryptoblocksize) # build a list of DNS IDS filter functions callable = lambda i: hasattr(i, '__call__') isfilter = lambda o, i: callable(getattr(o, i)) \ and i[:7] == 'filter_' self.filterlist = [getattr(sniff_filters, i) for i in dir(sniff_filters) if isfilter(sniff_filters, i)] # start listening/analysing service self.log.info('Started %s @ %s' % (APPNAME, time.asctime())) thread.start_new_thread(self.process_flow, ()) self.server.serve_forever() def _pad_pkcs7_block(self, msg, blocksize): """PKCS#7 padding. Returns string.""" nrpad = blocksize - (len(msg) % blocksize) return msg + chr(nrpad) * nrpad def process_flow(self): """Process received flow with registered IDS filters. Returns nothing. """ while True: addr, pkt = self.server.queue.get() self.pktcount += 1 # dump debug info logging.debug('Current time: %s | Packet number: %d \ | Received from: %s | Packet dump: %s' % (time.asctime(), self.pktcount, addr, pkt)) # process IDS filters for i in self.filterlist: logging.debug('Calling IDS filter: %s', i) i(pkt)
class DNSFlowServer(ThreadingUDPServer): """Central threading UDP server (central console) class.""" def __init__(self): # read configuration from file (defaults included) config = ConfigParser({ 'loglevel': 'INFO', 'logfile': APPNAME + 'log', 'addr': '127.0.0.1', 'port': 5000, 'cryptokey': 'default' }) config.read([CONFFILE]) # set tunables self.loglevel = config.get(APPNAME, 'loglevel') self.logfile = config.get(APPNAME, 'logfile') self.addr = config.get(APPNAME, 'addr') self.port = config.getint(APPNAME, 'port') self.cryptokey = config.get(APPNAME, 'cryptokey') # set local variables self.filterlist = () self.pktcount = 0 self.handler = DNSFlowHandler self.server = ThreadingUDPServer((self.addr, self.port), self.handler) self.server.queue = Queue() # initialize and setup logging logging.basicConfig(filename=self.logfile, format=LOGFMT) self.log = logging.getLogger(APPNAME) if self.loglevel in LOGLEVELS: self.log.setLevel(LOGLEVELS[self.loglevel]) # crypto stuff -- choose AES128 CBC self.server.cryptocipher = AES.new self.server.cryptomode = AES.MODE_CBC self.server.cryptoblocksize = AES.block_size self.server.cryptokey = self._pad_pkcs7_block( self.cryptokey, self.server.cryptoblocksize) # build a list of DNS IDS filter functions callable = lambda i: hasattr(i, '__call__') isfilter = lambda o, i: callable(getattr(o, i)) \ and i[:7] == 'filter_' self.filterlist = [ getattr(sniff_filters, i) for i in dir(sniff_filters) if isfilter(sniff_filters, i) ] # start listening/analysing service self.log.info('Started %s @ %s' % (APPNAME, time.asctime())) thread.start_new_thread(self.process_flow, ()) self.server.serve_forever() def _pad_pkcs7_block(self, msg, blocksize): """PKCS#7 padding. Returns string.""" nrpad = blocksize - (len(msg) % blocksize) return msg + chr(nrpad) * nrpad def process_flow(self): """Process received flow with registered IDS filters. Returns nothing. """ while True: addr, pkt = self.server.queue.get() self.pktcount += 1 # dump debug info logging.debug('Current time: %s | Packet number: %d \ | Received from: %s | Packet dump: %s' % (time.asctime(), self.pktcount, addr, pkt)) # process IDS filters for i in self.filterlist: logging.debug('Calling IDS filter: %s', i) i(pkt)
def __init__(self, server, hosts, proxy_dns): self.hosts = hosts self.proxy_dns = proxy_dns ThreadingUDPServer.__init__(self, server, CmdHandler)
server_port = int(cf["server_port"]) server_address = (server_ip,server_port) class listener(DRH): def handle(self): gqueue.put((self.request[0],self.client_address)) if __name__ == '__main__': print("begin to listen") num = int(cf["num_threads"]) for i in range(num): p = Process(target=handle,args=(tuple())) p.start() try : server = UDP(server_address,listener) except Exception as err: logging.error(err) logging.error("no server has been built") logger.error("不能建立server,建立server有问题,err为%s"%(err)) server.serve_forever() print("end listen")
def __init__(self): threading.Thread.__init__(self) self.server = ThreadingUDPServer(('', 20000), Handler)
def __init__(self, server_addr, reqhandler, log_dirname): ThreadingUDPServer.__init__(self, server_addr, reqhandler); self.log_dirname = log_dirname;
else: conf = mwconf.dbpc dbpc_sender = dbpc(conf.host, int(conf.port), conf.service, conf.component_prefix + MODULE_NAME, logger, int(conf.heartbeat_interval)) dbpc_sender.start() logger.info('dbpc thread started. host is %s, port is %s' % (conf.host, conf.port)) try: saver = threading.Thread(target=event_saver) saver.setDaemon(True) saver.start() logger.info('cache saver thread running....') logger.info("UDP Server start, host is %s, port is %d" % (bind_host, bind_port)) server = ThreadingUDPServer((bind_host, bind_port), RequestHandler) server.serve_forever() saver.join() except: logger.error( "catch unhandler exception, I will exit", exc_info=True) # program exit. It's easy to be found time.sleep(1) os._exit(1)
from logging import Formatter formatter = Formatter( fmt='%(asctime)s %(lineno)d %(message)s', datefmt='%Y-%m-%d %H:%M:%S') stream_handler.setFormatter(formatter) file_handler.setFormatter(formatter) from logging import getLogger log = getLogger(__name__) log.addHandler(file_handler) f**k = getLogger("{}_stream_logger".format(__name__)) f**k.addHandler(stream_handler) from logging import INFO log.setLevel(INFO) f**k.setLevel(INFO) frequency_db = StrictRedis(db=FREQUENCY_DB_NO) cache_db = StrictRedis(db=CACHE_DB_NO) setup_domain_db = StrictRedis(db=SETUP_DOMAIN_DB_NO) gray_domain_db = StrictRedis(db=GRAY_DOMAIN_DB_NO) server = ThreadingUDPServer(("0.0.0.0", 5353), CleanDNSHandler) server_thread = Thread(target=server.serve_forever) server_thread.daemon = True try: f**k.info("threading DNS server start at 0.0.0.0:53") server_thread.start() except KeyboardInterrupt: f**k.info("keyborad interrupt!") server.shutdown() server.server_close()
server_ip = cf["server_ip"] server_port = int(cf["server_port"]) server_address = (server_ip, server_port) class listener(DRH): def handle(self): gqueue.put((self.request[0], self.client_address)) if __name__ == '__main__': print("begin to listen") num = int(cf["num_threads"]) for i in range(num): p = Process(target=handle, args=(tuple())) p.start() try: server = UDP(server_address, listener) except Exception as err: logging.error(err) logging.error("no server has been built") logger.error("不能建立server,建立server有问题,err为%s" % (err)) server.serve_forever() print("end listen")
def __init__( self, port,name,liveaddr, handle=handle ): self.name=name self.liveaddr=liveaddr UDP.__init__( self, ('', port), handle )
def __init__(self, port): ThreadingUDPServer.__init__(self, ('', port), RequestHandler)
def __init__(self): threading.Thread.__init__(self) self.server = ThreadingUDPServer(('192.168.20.136', 20000), Handler)
self.is_server = False self.translate_table = {} self.security_belt = [] BaseRequestHandler.__init__(self, *args, **kwargs) def handle(self): self.address = self.server.server_address[0] data = self.request[0] socket = self.request[1] sender_address = self.client_address if "search" in data.split(" "): key = data.split(" ")[-1] if self.is_server: if key in self.translate_table: socket.sendto(json.dumps(self.translate_table[key]), sender_address) elif self.security_belt: #TODO: ask other servers pass else: socket.sendto(json.dumps([None]), sender_address) elif key == self.server.name: socket.sendto(json.dumps([self.address]), sender_address) if __name__ == "__main__": HOST, PORT = "localhost", 5000 server = ThreadingUDPServer((HOST, PORT), Node) server.name = "test" ip, port = server.server_address server.serve_forever()