class DNSServer: def __init__(self, blacklist=[], redirect_ip=None, port=PORT, addr="", max_cache_size=2048): self.blacklist = blacklist self.redirect_ip = redirect_ip self.port = port self.dns_addr = addr self.max_cache_size = int(max_cache_size) self.cache = {} handler = Handler handler.host = self self.server = ThreadingUDPServer((HOST_IP, self.port), Handler) def start(self): print("dnsruse running on {} port {} ...".format(HOST_IP, self.port)) self.server.serve_forever() def log(self, info): print(info) def add_cache(self, domain, ip): if sys.getsizeof(self.cache) < self.max_cache_size: self.cache[domain] = ip return "cached." else: return "unable to cache, full"
def main(): udp = False if '-u' in sys.argv: sys.argv.remove('-u') udp = True #end if # Deterministic. if len(sys.argv) > 1: random.seed(sys.argv[1]) else: random.seed('0x31337') #end if if udp: port = 6811 addr = ('0.0.0.0', port) server = ThreadingUDPServer(addr, M68HC11_Handler) server.serve_forever() else: file_iteration = 3 while os.path.exists('test1e{0}.S'.format(file_iteration)): file_iteration += 1 #loop filename = 'test1e{0}.S'.format(file_iteration) iterations = 200 source = gen_flag(get_flag(), filename, iterations) open(filename, 'w').write(source) print(filename)
def __init__(self, ip, port, handler): ThreadingUDPServer.__init__(self, (ip, port), handler) Thread.__init__(self, target=self.serve_forever) # Set the thread name to the class name Thread.setName(self, f'UDP-{self.__class__.__name__} Server') self.daemon = True
def main(): global data, passwords1 udp = False if '-u' in sys.argv: sys.argv.remove('-u') udp = True #end if # Deterministic. if len(sys.argv) > 1: random.seed(sys.argv[1]) else: random.seed('0x31337') #end if data = get_ton_unic0de() passwords = 'A a aa aal aalii aam Aani aardvark aardwolf Aaron Aaronic Aaronical Aaronite Aaronitic Aaru Ab aba Ababdeh Ababua abac'.split( ' ') passwords1 = [] for password in passwords: # add junk to it p = data[random.randint(0, len(data) - 1)] passwords1.append(password + p) #next password if udp: port = 2044 addr = ('0.0.0.0', port) server = ThreadingUDPServer(addr, Unic0de_Handler) server.serve_forever() else: res = get_unic0de(data) print(res.encode('utf-7'))
class service_udpserver(BaseRequestHandler): recv_queue: msg_queue port: int name: str udpserver: ThreadingUDPServer def listen(self, recv_queue: msg_queue, port: int, name: str): self.recv_queue = recv_queue self.port = port self.name = name # Start udp server self.udpserver = ThreadingUDPServer(('', self.port), self) logger.info("Start udpserver, [name]: %s, [port]: %s" % (self.name, self.port)) self.udpserver.serve_forever() def handle(self): ip_port = f"{self.client_address[0]}:{self.client_address[1]}" # logger.info("[%s][%s]device connected." # % (self.name, ip_port)) # Get message and client socket udp_msg, sock = self.request # Replay sock.sendto(udp_replay_str, self.client_address) # Packet msg logger.debug("UDP receive data [%s] from %s" % (udp_msg, ip_port)) recv_pkt = udp_packet_item(server_port=self.port, recv_time=datetime.now(), recv_address=ip_port, recv_msg=udp_msg) # Add msg to the queue if self.recv_queue is not None: self.recv_queue.put(recv_pkt.to_dict())
def shutdown(self): """ Safely shutdown server and thread :return: None """ ThreadingUDPServer.shutdown(self) Thread.join(self)
def main(): host = '127.0.0.1' port = 6001 try: server = ThreadingUDPServer((host, port), StatsHandler) server.serve_forever() except KeyboardInterrupt: print('Interrupted...')
def listen(self, recv_queue: msg_queue, port: int, name: str): self.recv_queue = recv_queue self.port = port self.name = name # Start udp server self.udpserver = ThreadingUDPServer(('', self.port), self) logger.info("Start udpserver, [name]: %s, [port]: %s" % (self.name, self.port)) self.udpserver.serve_forever()
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 create_udp_server(self): """ Crea un servidor UDP en un hilo externo para recibir los mensajes punto a punto de la aplicación. Es decir, una vez registrado en la aplicación el cliente puede recibir mensajes directamente mediante este servidor """ self.udp_server = ThreadingUDPServer((self.user.ip, self.user.port), ThreadedUDPRequestHandler) self.udp_server_thread = threading.Thread(target=self.udp_server.serve_forever) self.udp_server_thread.daemon = True
def __init__(self, server_address, RequestHandlerClass, wrappers, sname, sid, ttl, timeout, logger): ThreadingUDPServer.__init__(self, server_address, RequestHandlerClass) self.wrappers = wrappers self.sname = sname self.sid = sid self.ttl = ttl self.timeout = timeout # Logger parameters self.logger = logger self._LOGGING_ = False if logger is None else True
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, blacklist=[], redirect_ip=None, port=PORT, addr="", max_cache_size=2048): self.blacklist = blacklist self.redirect_ip = redirect_ip self.port = port self.dns_addr = addr self.max_cache_size = int(max_cache_size) self.cache = {} handler = Handler handler.host = self self.server = ThreadingUDPServer((HOST_IP, self.port), Handler)
def __init__( self, server_address: Tuple[str, int], accounts: Dict[str, SIAAccount], func: Callable[[SIAEvent], None], counts: Counter, ): """Create a SIA UDP Server. Arguments: server_address Tuple[string, int] -- the address the server should listen on. accounts Dict[str, SIAAccount] -- accounts as dict with account_id as key, SIAAccount object as value. func Callable[[SIAEvent], None] -- Function called for each valid SIA event, that can be matched to a account. counts Counter -- counter kept by client to give insights in how many errorous events were discarded of each type. """ ThreadingUDPServer.__init__(self, server_address, SIAUDPHandler) BaseSIAServer.__init__(self, accounts, func, counts)
def simulate_main(app_py: str, conf: Konfig) -> None: from socketserver import DatagramRequestHandler, ThreadingUDPServer from threading import Thread class SimUDPBCastHandler(DatagramRequestHandler): def handle(self): data = self.request[0].strip() socket = self.request[1] for addr in conf.gen_all_agent_addrs(): socket.sendto(data, addr) server = ThreadingUDPServer(conf.udp_bcast_addr, SimUDPBCastHandler) server_thread = Thread(target=server.serve_forever) try: server_thread.daemon = True server_thread.start() # Start server before all other agent processes simulate_agents(app_py, conf) finally: server.shutdown() print("Shuting down simulated broadcast server thread...") server_thread.join(timeout=5.0) if server_thread.is_alive(): print( "Simulated broadcast server is still alive. Terminate with main thread." ) server.server_close()
def main() -> None: """Wrapper for TCP and UDP workers""" ThreadingTCPServer.allow_reuse_address = True ThreadingUDPServer.allow_reuse_address = True tcp_proxy = ThreadingTCPServer((PROXY_ADDR, PROXY_PORT), DNSoverTCP) udp_proxy = ThreadingUDPServer((PROXY_ADDR, PROXY_PORT), DNSoverUDP) tcp_process = multiprocessing.Process(target=tcp_proxy.serve_forever) udp_process = multiprocessing.Process(target=udp_proxy.serve_forever) tcp_process.start() logging.info('DNS Proxy over TCP started and listening on port %s', PROXY_PORT) udp_process.start() logging.info('DNS Proxy over UDP started and listening on port %s', PROXY_PORT)
def udp(host, port, echo): """ Runs a threaded UDP server that logs all datagrams it receives. It can alos act as an UDP echo server using the --echo flag """ if echo: request_handler = EchoUdpHandler else: request_handler = SimpleUdpHandler with ThreadingUDPServer((host, port), request_handler) as server: click.secho( f"Staring {server.__class__.__name__} on {host}:{port}", fg="bright_yellow", blink=True, ) server.serve_forever()
def main() -> None: global FSP_PASSWORD, FSP_SERVER_DIR # check python version before running assert version_info.major == 3 and version_info.minor >= 8, "This script requires Python 3.8 or greater!" parser = argparse.ArgumentParser(description=__description__) parser.add_argument("-a", "--address", type=parse_hostname_port, default=("0.0.0.0", 7717), help="The address to bind to") parser.add_argument("-p", "--password", type=str, default="", help="The password to use") parser.add_argument("-d", "--directory", type=str, default="server", help="The directory to serve from") args = parser.parse_args() assert type(args.address) == tuple, "Invalid address:port pair specified" FSP_PASSWORD = args.password FSP_SERVER_DIR = args.directory assert osp.isdir( FSP_SERVER_DIR), "The specified server directory doesn't exist" print(f"FSP server running on {args.address[0]}:{args.address[1]}...") print(f"Base Directory: \"{osp.abspath(FSP_SERVER_DIR)}\"") with ThreadingUDPServer((args.address[0], args.address[1]), FSPPacketHandler) as server: server.socket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1) server.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) server.socket.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, FSP_MAXSPACE) server.socket.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, FSP_MAXSPACE) server.serve_forever()
from socketserver import BaseRequestHandler, ThreadingUDPServer import time class TimeHandler(BaseRequestHandler): def handle(self): print('Got connection from', self.client_address) msg, sock = self.request resp = time.ctime() sock.sendto(resp.encode(), self.client_address) if __name__ == '__main__': serv = ThreadingUDPServer(('', 20000), TimeHandler) serv.serve_forever()
if not msg: return msg = json.loads(msg.decode("utf-8")) log.logger.info('[INPUT_{0}] {1}'.format(msg['arg01'],msg)) #num = int(random.uniform(1, 15)*10) / 10 rst = {} ai_ret = 8.5 if isinstance(ai_ret, float): rst['result'] = int(ai_ret * 10) / 10.0 rst['error'] = '' else: log.logger.error(ai_ret) rst['result'] = '' rst['error'] = ai_ret rst['arg01'] = msg['arg01'] rst['patient_id'] = msg['patient_id'] rst['detect_id'] = msg['detect_id'] rst['last'] = '' r = json.dumps(rst) #time.sleep(10) cost_time = time.time() - start log.logger.info('[TOTAL_COST_TIME]: {0}'.format(cost_time)) sock.sendto(str.encode(r), self.client_address) if __name__ == '__main__': log.logger.info('ai api(udp) starts:') serv = ThreadingUDPServer(('', 62000), UDPHandler) serv.serve_forever()
def __init__(self, addr, handler, timeout=1): ThreadingUDPServer.__init__(self, addr, LogRecordDatagramHandler) BaseServer.__init__(self, handler, timeout)
def send_test_query_sdns(port): req = DNSRecord.question("xyzmail.sec.mycompany.com", qtype="A") print("\nIssuing client request (sdns)...") send_req_and_print_resp(req.pack(), port) def send_test_query_public(port): # Request the v6 address of google.com req = DNSRecord.question("google.com", qtype="A") print("Issuing client request (public)...") send_req_and_print_resp(req.pack(), port) if __name__ == "__main__": LISTEN_PORT = 1053 # TODO: change to 53 later (requires admin perms) server = ThreadingUDPServer(("localhost", LISTEN_PORT), LocalDNSRequestHandler) server_thread = threading.Thread(target=server.serve_forever) server_thread.daemon = True server_thread.start() print("Server started on port {}".format(LISTEN_PORT)) # TODO: for testing, send a sample request, then exit... final implementation would just run serve_forever() in the # main thread send_test_query_sdns(LISTEN_PORT) #send_test_query_public(LISTEN_PORT) server.shutdown() server.server_close()
def __init__(self, port=53, lib={}, debug_mode=0, dns_addr=''): DNSServer.lib = lib self.port = port DNSServer.debug_mode = debug_mode DNSServer.dns_addr = dns_addr self.server = ThreadingUDPServer((HOST_IP, self.port), DNSHandler)
emojiDlg.exec_() print(emojiDlg.selectEmoji) img = '<img src=\"%s\"></img>' % emojiDlg.selectEmoji.path self.textEdit.append(img) #打开图片选择界面 def onClickImage(self): pass if __name__ == '__main__': app = QtWidgets.QApplication(sys.argv) window = FeiQMainWindow() UDPSERVER = ThreadingUDPServer((setting.IPADDRESS, setting.PORT), UdpHandle) UDPSERVER.socket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1) UDPSERVER.socket.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 60000) serverMainThread = threading.Thread(target=UDPSERVER.serve_forever, name='后台主线程') serverMainThread.setDaemon(True) serverMainThread.start() Instance.start(UDPSERVER.socket.sendto, window.onViewDispatch) window.show() sys.exit(app.exec_()) UDPSERVER.server_close() Instance.stopAll()
from socketserver import ThreadingUDPServer from socketserver import BaseRequestHandler, DatagramRequestHandler import socket import logging import time, datetime class UdpHandle(BaseRequestHandler): COUNT = 0 def handle(self): # t = threading.Thread(target=self.dealPacket, args=(self.client_address, self.request[0])) # t.start() packet = self.request[0] # print(datetime.datetime.now().isoformat()+str(UdpHandle.COUNT)) self.server.socket.sendto(packet, self.client_address) UdpHandle.COUNT += 1 UDPSERVER = ThreadingUDPServer(('0.0.0.0', 50001), UdpHandle) UDPSERVER.socket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1) UDPSERVER.socket.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 60000) UDPSERVER.serve_forever()
传统的 send() 和 recv() 也可以,但一般用于 tcp """ """ UDP天生是不可靠的(因为通信没有建立连接,消息可能丢失) 需要自行处理丢失消息的情况 如果可靠性对于你程序很重要,你需要借助于序列号、重试、超时以及一些其他方法来保证。 UDP通常被用在那些对于可靠传输要求不是很高的场合。 例如,在实时应用如多媒体流以及游戏领域, 无需返回恢复丢失的数据包(程序只需简单的忽略它并继续向前运行)。 """ """ UDPServer 类是单线程的,也就是说一次只能为一个客户端连接服务 并发操作,可以实例化一个 ForkingUDPServer 或 ThreadingUDPServer 对象 """ from socketserver import ThreadingUDPServer if __name__ == "__main__": serv = ThreadingUDPServer(('', 20000), TimeHandler) serv.serve_forever() """ 直接使用 socket 来实现一个UDP服务器也不难 """ from socket import socket, AF_INET, SOCK_DGRAM import time def time_server(address): sock = socket(AF_INET, SOCK_DGRAM) sock.bind(address) while True: msg, addr = sock.recvfrom(8192) print('连接请求来自', addr) resp = time.ctime()
def __init__( self, port,name,liveaddr, handle=handle ): self.name=name self.liveaddr=liveaddr UDP.__init__( self, ('', port), handle )
def __init__(self, address, port): self.servers = [ ThreadingUDPServer((address, port), UDPHandler), ThreadingTCPServer((address, port), TCPHandler), ]
#-*- coding:utf-8 -*- ''' 创建UDPServer ''' from socketserver import BaseRequestHandler,ThreadingUDPServer,UDPServer import time class TimeHandler(BaseRequestHandler): def handle(self): print('Got connection from ',self.client_address) msg,sock=self.request resp=time.ctime() sock.sendto(resp.encode('ascii'),self.client_address) if __name__=='__main__': # #单线程模式(一次只能响应一个连接请求) # serv=UDPServer(('',20000),TimeHandler) #多线程模式(响应多个客户端的连接) serv=ThreadingUDPServer(('',20000),TimeHandler) serv.serve_forever()
encrypted_as_mandate = params['encrypted_as_mandate'].encode('utf-8') as_mandate = simplejson.loads( Fernet(TGS_KEY).decrypt(encrypted_as_mandate)) as_session_key = as_mandate['as_session_key'] if self.validate_mandate(as_mandate): session_key = Fernet.generate_key() encrypted_session_key = Fernet(as_session_key).encrypt(session_key) client_ip, _ = self.client_address mandate = { 'tgs_session_key': session_key, 'public_text': PUBLIC_TEXT, 'time': time(), 'client_ip': client_ip } encrypted_mandate = Fernet(TGS_KEY).encrypt( simplejson.dumps(mandate).encode('utf-8')) sock.sendto( simplejson.dumps({ 'encrypted_tgs_session_key': encrypted_session_key, 'encrypted_tgs_mandate': encrypted_mandate }).encode('utf-8'), self.client_address) else: sock.close() if __name__ == '__main__': serv = ThreadingUDPServer(('', 20001), TGSHandler) serv.serve_forever()
user.client_address) except: pass db.close_shop(shop.owner_id) reply += "已关闭此店" elif header == "/users": if user is None or user.user_id != 999: reply += "您没有该权限" else: reply += "有以下用户\n" print(db.users) for each in db.users: a = "用户ID: {0} 用户名: {1} \n".format( each.user_id, each.user_name) reply += a print(reply) except AssertionError: reply += "指令参数错误!" ans.reply = reply self.request[1].sendto(ans.send(), self.client_address) if __name__ == '__main__': print("Data Version:", db["version"]) print(db) server = ThreadingUDPServer(('0.0.0.0', 25365), Handler) # 参数为监听地址和已建立连接的处理类 print('listening') server.serve_forever() # 监听,建立好UCP连接后,为该连接创建新的socket和线程,并由处理类中的handle方法处理 print(server)
FileType TEXT NOT NULL );''') conn.execute( 'INSERT INTO FILES (FileName, FileType) VALUES (:file_name, :file_type)', { "file_name": 'test_text.txt', "file_type": 'text' }) conn.commit() conn.execute( 'INSERT INTO FILES (FileName, FileType) VALUES (:file_name, :file_type)', { "file_name": 'hello.bin', "file_type": 'binary' }) conn.commit() conn.close() ThreadingUDPServer.allow_reuse_address = True ThreadingUDPServer.daemon_threads = True with ThreadingUDPServer((host, port), ThreadedServerHandler) as server: try: print( f'\n{datetime.now()}', f'\nStarting UDP server at {host}:{port}\nQuit the server with CONTROL-C.\n' ) server.serve_forever() except KeyboardInterrupt: print('') server.shutdown()