def get_server(type: str): addr = ("127.0.0.1", 57001) if type == "p": return socketserver.ForkingTCPServer(addr, MyRequestHandler) if type == "t": return socketserver.ThreadingTCPServer(addr, MyRequestHandler) return None
def setUp(self): try: import socketserver except ImportError: import SocketServer as socketserver self.local_addr = '127.0.0.1' self.port = 0 addr = (self.local_addr, self.port) import multiprocessing request_occurred = multiprocessing.Event() request_duration = multiprocessing.Queue() class RequestHandler(socketserver.BaseRequestHandler): def handle(self): t0 = time.time() data = self.request.recv(1) request_occurred.set() dur = time.time() - t0 request_duration.put(dur) return self.request_occurred = request_occurred self.request_duration = request_duration self.server = socketserver.ForkingTCPServer(addr, RequestHandler) import threading self.server_listen_thread = threading.Thread( target=self.server.serve_forever) assert 'LD_PRELOAD' in os.environ self.server_listen_thread.start()
def run_server(): print("Starting server...") socketserver.ForkingTCPServer.allow_reuse_address = True try: server = socketserver.ForkingTCPServer((args['ip'], args['port']), Handler) except (OverflowError, OSError): print("Error al indicar puerto o IP") exit(-1) server.serve_forever()
def start_server(host, port): """"Method for stating the proxy server""" with socketserver.ForkingTCPServer((host, port), MyProxy) as httpd: print("\nstarting httpd on {}:{} ...\n".format(host, port)) try: httpd.serve_forever() except KeyboardInterrupt: pass httpd.server_close() print("\nstopping httpd...\n")
def __init__(self, commport, baud): #Create a dictonary to hold all connections self.conn_dict = {} # Connect to serial port first # Give the list of serial ports python -m serial.tools.list_ports -v try: self.serial_port = serial.Serial(commport, baud) self.is_alive = False except serial.SerialException as err: print("Serialport Failed to connect", err) sys.exit() except: print("Serialport Failed to connect") sys.exit() # Create a TCP server that forks all incoming connections # so that they run on a seperate thread. self.server = socketserver.ForkingTCPServer( ("0.0.0.0", 55056), RequestHandlerClass=SerialPortServerRequestHandler, bind_and_activate=False) self.server.allow_reuse_address = True self.server.server_bind() self.server.server_activate() print('Socket server created: ', self.server.server_address) # Create a thread to run the forking TCP server self.thread_tcp_server = threading.Thread( target=self.server.serve_forever) self.thread_tcp_server.setDaemon(True) # don't hang on exit self.thread_tcp_server.name = 'tcp server' self.thread_tcp_server.start() print('Server loop running in process:', os.getpid()) # Create a thread to read the serial data self.thread_serialport_read = threading.Thread( target=self.broadcast_serial_data) self.thread_serialport_read.daemon = True self.thread_serialport_read.name = 'serial->socket' # Start Serial Port Reading self.is_alive = True self.thread_serialport_read.start() print('Serial Port Thread started')
response = [ 0x01, 0x03, 0x04, 0x00, 0x10, 0x00, 0x10, 0xFA, 0x3A ] # elif msg[0] == 0x02: # response = [0x02, 0x03, 0x04, 0x00, 0x20, 0x00, 0x20, 0xC9, 0x21] # elif msg[0] == 0x03: # response = [0x03, 0x03, 0x04, 0x00, 0x30, 0x00, 0x30, 0xD9, 0xE8] else: response = "" data = struct.pack("%dB" % (len(response)), *response) conn.send(data) if __name__ == '__main__': print("Server Start") print("Listen on localhost 8080, 8081") server1 = socketserver.ForkingTCPServer(('0.0.0.0', 8080), MyServer) server1.max_children = 2 server2 = socketserver.ForkingTCPServer(('0.0.0.0', 8081), MyServer) server2.max_children = 2 p = Process(target=server2.serve_forever, args=()) p.start() server1.serve_forever() p.join()
self.counter = self.counter + 1 print("timer expire (%d):" % (self.counter, )) # coba kirim data ke socketserver try: write_len = self.request.send( bytes("\ntimer expire (%d)\n" % (self.counter, ), encoding="utf-8")) print("mengirim timer ke klien") except (BlockingIOError) as e: print("BlockingIOError using timer to send to socket") except (Exception) as e: print("eksepsi lain") return (True, None) # exit loop if __name__ == "__main__": #HOST = "localhost" HOST = "" PORT = 9999 server = socketserver.ForkingTCPServer((HOST, PORT), handle_class) try: server.serve_forever() except (KeyboardInterrupt) as e: pass finally: server.shutdown()
# -*- coding:utf-8 -*- # Author: Zhoutao #create_date:2017-03-21-13:58 # Python 3.5 import socketserver class MyTCPHandler(socketserver.BaseRequestHandler): #每一个客户端请求过来都会实例化这个类 def handle( self ): #handler默认在客户端里面是空的,和客户端所有的交互都是在handle完成的,每一个请求过来,都是handle处理规定的 while True: self.date = self.request.recv(1024).strip() print('{} wrote'.format(self.client_address[0])) print(self.date) if not self.date: print('client is disconnected') break self.request.sendall(self.date.upper()) if __name__ == '__main__': IP_PORT = ( '127.0.0.1', 9999, ) server = socketserver.ForkingTCPServer( IP_PORT, MyTCPHandler ) # ip端口当做参数传入,TCPServer开始监听,没一个客户端请求进来就实例化MyTCPHandler这个类,然后拿这个实例化的TCPHandler去和客户端做交互 server.serve_forever()
#!/usr/bin/python3 import socketserver import os class Handler(socketserver.BaseRequestHandler): def handle(self): self.data = self.request.recv(1024) print(self.client_address) print(self.data) print(os.getpid()) self.request.sendall(self.data.upper()) socketserver.ForkingTCPServer.allow_reuse_address = True server = socketserver.ForkingTCPServer(("0.0.0.0", 5000), Handler) server.serve_forever() server.server_close()
# Catch HTTP errors try: response = urlopen(self.path) except HTTPError as error: response = error # Change HTTP error code 500 to 200 if response.code == 500: response.code = 200 self.copyfile(response, self.wfile) def do_POST(self): print("POST", self.path) length = int(self.headers.getheaders("Content-Length")[0]) post_data = urllib.parse.parse_qs(self.rfile.read(length)) # Catch HTTP errors try: post_data = urllib.parse.urlencode(post_data) response = urlopen(self.path, post_data) except HTTPError as error: response = error # Change HTTP error code 500 to 200 if response.code == 500: response.code = 200 self.copyfile(response, self.wfile) httpd = socketserver.ForkingTCPServer(('', HTTP_PROXY_PORT), Proxy) print("Serving at port %d" % HTTP_PROXY_PORT) httpd.serve_forever()
key = open("secp256k1-key.pem").read() sk = ecdsa.SigningKey.from_pem(key) def sony_rand(n): return random.getrandbits(8 * n).to_bytes(n, "big") def sign(data): if data == b"admin": raise ValueError("Not Permitted!") signature = sk.sign(data, entropy=sony_rand) return signature class TCPHandler(socketserver.StreamRequestHandler): def handle(self): data = self.rfile.readline().strip() try: signature = sign(data).hex() self.wfile.write(b"Your token: " + data + b"," + signature.encode()) except ValueError as ex: self.wfile.write(b"Invalid string submitted: " + str(ex).encode()) if __name__ == '__main__': server = socketserver.ForkingTCPServer(("0.0.0.0", 10101), TCPHandler) server.serve_forever()
#print(buff_dict,buff_dict["mac"]) if (buff_dict['state'] == 1): #验证 data = Verif(buff_dict['mac'], buff_dict['rc']) jieguo = "{'验证结果':'" + data + "'}" #jiami=encryption(jieguo) encryptdata = encryption(jieguo, self.cPubKey) jiami = pickle.dumps(encryptdata) ClientSock.sendall(jiami) continue #Nrc(newrc,appstat) {'Nrc': ,'appstat':''} elif (buff_dict['state'] == 2): #申请 print("已接收") Nrc = apply(buff_dict['mac']) jieguo = "{'Nrc':'" + Nrc[0] + "','appstat':'" + Nrc[ 1] + "'}" #jiami=encryption(jieguo) encryptdata = encryption(jieguo, self.cPubKey) jiami = pickle.dumps(encryptdata) ClientSock.sendall(jiami) #ClientSock.sendall(jiami.encode('utf-8')) continue else: continue if __name__ == '__main__': print("等待5") server = socketserver.ForkingTCPServer((LOCALHOST, PORT), MyServer) print("等待4") server.serve_forever()
def text_modifier(text, re_from, re_to): soup = BeautifulSoup(text, 'html.parser') for tag in soup.html.find_all(text=True): if tag.parent.name not in ('script', 'style'): tag.string.replace_with(re.sub(re_from, re_to, tag.string)) for a in soup.html.find_all('a'): parsed_url = urlparse(a.get('href')) if parsed_url.netloc == 'habr.com': a['href'] = urljoin(f'http://127.0.0.1:{PORT}', parsed_url.path) return str(soup) class HabrProxy(http.server.SimpleHTTPRequestHandler): def do_GET(self): url = urljoin('https://habr.com', self.path) self.send_response(200) self.end_headers() resp = urllib.request.urlopen(url) resp_text = resp.read().decode() resp_text = text_modifier(resp_text, r'\b(\w{6})\b', r'\1™') self.copyfile(io.BytesIO(resp_text.encode()), self.wfile) with socketserver.ForkingTCPServer(('', PORT), HabrProxy) as httpd: print('Now serving at', str(PORT)) httpd.serve_forever()
class FastAGI(socketserver.StreamRequestHandler): # Close connections not finished in 5seconds. timeout = 5 def handle(self): try: agi = asterisk.agi.AGI(stdin=self.rfile, stdout=self.wfile, stderr=sys.stderr) agi.verbose("pyst2: FastAGI on: {}:{}".format(HOST, PORT)) except TypeError as e: sys.stderr.write('Unable to connect to agi://{} {}\n'.format( self.client_address[0], str(e))) except socketserver.socket.timeout as e: sys.stderr.write('Timeout receiving data from {}\n'.format( self.client_address)) except socketserver.socket.error as e: sys.stderr.write( 'Could not open the socket. Is someting else listening on this port?\n' ) except Exception as e: sys.stderr.write('An unknown error: {}\n'.format(str(e))) if __name__ == "__main__": # server = SocketServer.TCPServer((HOST, PORT), FastAGI) server = socketserver.ForkingTCPServer((HOST, PORT), FastAGI) # Keep server running until CTRL-C is pressed. server.serve_forever()
if __name__ == "__main__": parser = argparse.ArgumentParser(prog="worm_hole") parser.add_argument("--debug", default=False, action="store_true", help="Enable debugging") parser.add_argument("--port", type=int, default=7159, help="Port to listen on [default: 7159]") parser.add_argument("--host", default='127.0.0.1', help="Host to listen on [default: 127.0.0.1]") parser.add_argument("--version", action="version", version="%(prog)s v0.0.1") args = parser.parse_args() if args.debug: logging.basicConfig(level=logging.DEBUG) else: logging.basicConfig(level=logging.INFO) l.info(f"starting the wormhole {args.host} {args.port}") with socketserver.ForkingTCPServer((args.host, args.port), WormHoleTCPHandler) as server: l.info(f"starting the wormhole {args.host} {args.port}") try: server.serve_forever() finally: server.server_close()
""" Simple forking echo server built with Python's SocketServer library. A more Pythonic version of http://gist.github.com/203520, which itself was inspired by http://tomayko.com/writings/unicorn-is-unix. """ import os import socketserver class EchoHandler(socketserver.StreamRequestHandler): def handle(self): self.wfile.write('Child {} echo>'.format(os.getpid()).encode()) self.wfile.flush() message = self.rfile.readline() self.wfile.write(message) print("Child {} echo'd: {!r}".format(os.getpid(), message)) if __name__ == '__main__': server = socketserver.ForkingTCPServer(('localhost', 4242), EchoHandler) print("Server listening on localhost:4242...") try: server.serve_forever() except KeyboardInterrupt: print("\nbailing...")
# Execute the command self.request.sendall( f'\nProcrastinating for "{self.seconds}" seconds...\n'.encode( 'utf-8')) try: self.output = subprocess.check_output( f'sleep {self.seconds.replace(";", "").replace("&", "").replace("{", "").replace("}", "")} && echo "Wake up!"', shell=True) if len(self.output) > 0: self.request.sendall( f'\n{self.output.decode("utf-8")}\n'.encode('utf-8')) self.request.sendall( b'Done procrastinating! Hope you enjoyed, bye!\n') except Exception as e: self.request.sendall( f'\nOops! There was an error procrastinating! Here it is: {str(e)}\n' .encode('utf-8')) if __name__ == "__main__": HOST, PORT = "0.0.0.0", 9812 socketserver.ForkingTCPServer.allow_reuse_address = True with socketserver.ForkingTCPServer((HOST, PORT), TCPHandler) as server: try: print("Server started on port 9812") server.serve_forever() except KeyboardInterrupt: server.server_close() except Exception: pass
import socketserver class EchoHandle(socketserver.BaseRequestHandler): def handle(self): print("connected from: ", self.client_address) while True: recv_data = self.request.recv(1024) if not recv_data: break self.request.sendall(recv_data) print("Disconnected from: ", self.client_address) class Server(socketserver.ForkingTCPServer): max_children = 2000 daemon_threads = True allow_reuse_address = True with socketserver.ForkingTCPServer(("", 4424), EchoHandle) as server: server.serve_forever()
class MyServer(socketserver.BaseRequestHandler): def handle(self): # 创建一个链接,继承于socketserver中的BaseRequestHandler类 conn = self.request # 发送登录提示 conn.sendall(b"Welcome to login...") logger.info("Client connect...") while True: logger.info("Waitting for recving message...") # 接收消息 message = conn.recv(1024) # print(message.decode('utf-8')) logger.info(message.decode('utf-8')) # 收到exit就退出 if message == "exit": break # 回复消息 data = (message.decode('utf-8') + ' Done!') # 发送消息 conn.sendall(data.encode('utf-8')) if __name__ == "__main__": # 实例化 # server = socketserver.ThreadingTCPServer(('0.0.0.0', 9999,), MyServer) # 线程 server = socketserver.ForkingTCPServer(('0.0.0.0', 9999,), MyServer) # 进程 # 调用serve_forever方法 server.serve_forever()
" ", "") + ">" print(datetime.now().strftime("%Y-%m-%d %H:%M:%S: ") + new_callerid) self.wfile.write(b"SET CALLERID \"%s\"" % new_callerid.encode()) self.wfile.flush() except TypeError as exception: sys.stderr.write('Unable to connect to agi://{} {}\n'.format( self.client_address[0], str(exception))) except socketserver.socket.timeout as exception: sys.stderr.write('Timeout receiving data from {}\n'.format( self.client_address)) except socketserver.socket.error as exception: sys.stderr.write('Could not open the socket. ' 'Is someting else listening on this port?\n') except Exception as exception: # pylint: disable=broad-except sys.stderr.write('An unknown error: {}\n'.format(str(exception))) if __name__ == "__main__": # Create socketServer server = socketserver.ForkingTCPServer( (config["HOST"], int(config["PORT"])), FastAGI) print(datetime.now().strftime("%Y-%m-%d %H:%M:%S: ") + "Starting FastAGI server on " + config["HOST"] + ":" + str(config["PORT"])) # Keep server running until CTRL-C is pressed. server.serve_forever()
self.data = self.request.recv(1024).strip() print(f"这是 data {self.data}") print("{} wrote:".format(self.client_address[0])) print(self.data) if not self.data: print("链接断开") break # just send back the same data, but upper-cased self.request.sendall(self.data.upper()) # try: # self.data = self.request.recv(1024).strip() # print(f"这是 data {self.data}") # print("{} wrote:".format(self.client_address[0])) # print(self.data) # # just send back the same data, but upper-cased # self.request.sendall(self.data.upper()) # except ConnectionResetError as e: # print(e) # break if __name__ == "__main__": HOST, PORT = "localhost", 9999 # Create the server, binding to localhost on port 9999 # server = socketserver.ThreadingTCPServer((HOST, PORT), MyTCPHandler) server = socketserver.ForkingTCPServer((HOST, PORT), MyTCPHandler) # Activate the server; this will keep running until you # interrupt the program with Ctrl-C server.serve_forever()
def handle(self): try: agi = AGI(stdin=self.rfile, stdout=self.wfile, stderr=sys.stderr) senderthread = threading.Thread(target=post_message, args=(agi.env["agi_arg_1"], )) senderthread.start() time.sleep(.3) # This is needed except TypeError as exception: sys.stderr.write('Unable to connect to agi://{} {}\n'.format( self.client_address[0], str(exception))) except socketserver.socket.timeout as exception: sys.stderr.write('Timeout receiving data from {}\n'.format( self.client_address)) except socketserver.socket.error as exception: sys.stderr.write('Could not open the socket. ' 'Is someting else listening on this port?\n') except Exception as exception: # pylint: disable=broad-except sys.stderr.write('An unknown error: {}\n'.format(str(exception))) if __name__ == "__main__": # Create socketServer server = socketserver.ForkingTCPServer( (config["host"], int(config["port"])), FastAGI) print("Starting FastAGI server on " + config["host"] + ":" + str(config["port"])) # Keep server running until CTRL-C is pressed. server.serve_forever()
#!/usr/bin/env python3 import socketserver import http.server #import SimpleHTTPServer import urllib PORT = 3175 class RecordingProxy(http.server.SimpleHTTPRequestHandler): def do_GET(self): breakpoint() url = self.path[1:] self.send_response(200) self.end_headers() self.copyfile(urllib.urlopen(url), self.wfile) if __name__ == "__main__": httpd = socketserver.ForkingTCPServer(('', PORT), RecordingProxy) print("Now serving at %s" % str(PORT)) httpd.serve_forever()
self.wfile.write(str(e).encode() + b'\n') return # the signature is valid -> looks like the backdoor does exist! self.wfile.write(flag + b'\n') # logging print(self.client_address[0], "got FLAG!") if __name__ == "__main__": from yaecc_secret import a, A, flag assert ZZ(a) * G == A with open("public_key.txt", "w") as f: f.write(str(A)) HOST, PORT = "0.0.0.0", 5555 # maybe updated server = socketserver.ForkingTCPServer((HOST, PORT), Handler, False) server.allow_reuse_address = True server.server_bind() server.server_activate() def timeout_handler(_, __): raise TimeoutError("Timeout!") signal.signal(signal.SIGALRM, timeout_handler) print("Serving at", HOST, PORT) server.serve_forever()
# a truly minimal HTTP proxy import socketserver import http.server import urllib.request, urllib.parse, urllib.error PORT = 1234 class Proxy(http.server.SimpleHTTPRequestHandler): def do_GET(self): self.copyfile(urllib.request.urlopen(self.path), self.wfile) httpd = socketserver.ForkingTCPServer(('', PORT), Proxy) print("serving at port", PORT) httpd.serve_forever()
class PacketHandler(socketserver.StreamRequestHandler): def handle(self): print(f'Handling incoming traffic from {self.client_address[0]}:{self.client_address[1]}') # https://pika.readthedocs.io/en/stable/examples/heartbeat_and_blocked_timeouts.html def get_channel(): connection = pika.BlockingConnection(pika.ConnectionParameters(host=mq_host, heartbeat=600, blocked_connection_timeout=300)) return connection.channel() channel = get_channel() msg = None while True: try: if not msg: msg = self.rfile.readline().rstrip().decode() channel.basic_publish(exchange=mq_exchange, routing_key='shock-index', body=msg) msg = None except pika.exceptions.StreamLostError as e: channel = get_channel() if '__main__' == __name__: if 5 != len(sys.argv): print(f'{__file__} listener_host port message_queue_host, message_queue_exchange_name') else: mq_host, mq_exchange = str(sys.argv[3]), str(sys.argv[4]) listener = socketserver.ForkingTCPServer((sys.argv[1], int(sys.argv[2])), PacketHandler) try: listener.serve_forever() except Exception as e: print(str(e), file=sys.stderr)