def serve(): parser = argparse.ArgumentParser() # add arguments for dispacher's host and port parser.add_argument("--host", help="dispatcher's host, by default it is localhost", default="localhost", action="store") parser.add_argument("--port", help="dispatcher's port, by default it is 8888", default=8888, action="store") args = parser.parse_args() # start a new server server = ThreadingTCPServer((args.host, int(args.port)), DispatcherServer) print("Serving on %s:%s" % (args.host, int(args.port))) # spawn 2 threads for runner and redistributor runner_heartbeat = threading.Thread(target=runner_checker, args=(server, )) redistributor = threading.Thread(target=redistribute, args=(server, )) try: runner_heartbeat.start() redistributor.start() # Activate the server; this will keep running until you # interrupt the program with Ctrl+C or Cmd+C server.serve_forever() except (KeyboardInterrupt, Exception): # if any exception occurs, kill the thread server.dead = True runner_heartbeat.join() redistributor.join()
class Proxy(): def __init__(self): if hasattr(subprocess, 'STARTUPINFO'): self.si = subprocess.STARTUPINFO() self.si.dwFlags |= subprocess.STARTF_USESHOWWINDOW else: self.si = None def winrun(self, cmd): subprocess.check_output(cmd, stdin=subprocess.PIPE, stderr=subprocess.PIPE \ , startupinfo=self.si, env=os.environ) def start(self, address, port): try: self.server = ThreadingTCPServer((address, int(port)), ProxyHandler) logger.info("server started at {}:{}".format(address, port)) if setting.config['setproxy'] and sys.platform.startswith('win'): self.winrun( os.path.join(basepath, 'sysproxy.exe') + ' pac http://localhost:' + str(setting.config['webuiport']) + '/pac/?t=' + str(random.randrange(2**16))) self.server.serve_forever() except socket.error as e: logger.error(e) def shutdown(self): self.server.shutdown() def server_close(self): self.server.server_close()
def main(): global data, passwords1 tcp = False if '-t' in sys.argv: sys.argv.remove('-t') tcp = True #end if # Deterministic. if len(sys.argv) > 1: random.seed(sys.argv[1]) else: random.seed('0x31337') #end if data = open('1558121717.Vfe01I1b573a2M922672.suzy', 'rb').read().decode('utf-8', errors='replace') 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 tcp: port = 2045 addr = ('0.0.0.0', port) server = ThreadingTCPServer(addr, AAAS_Handler) server.serve_forever() else: print("tcp until you think of something")
def tcprelay(self, host: str, port: int): callback = self.onecmd welcome = f'vxi11cmd server, relay {host}:{port}, remote {self.address}.\r\n\r\n'.encode( ) class CmdServerHandler(StreamRequestHandler): def handle(self): self.request.send(welcome) buffer = bytearray() while True: buffer.extend(self.request.recv(64)) while True: i = buffer.find(b'\n') if i == -1: break line = bytes(buffer[:i + 1]) buffer[:] = buffer[i + 1:] command = line.decode().strip() print(command) try: answer = callback(command) if answer: self.request.send(answer.encode() + b'\r\n') except KeyboardInterrupt: sys.exit(2) except Exception as e: self.request.send(str(e).encode() + b'\r\n') server = ThreadingTCPServer((host, port), CmdServerHandler) server.serve_forever()
def run(): # create a genesis block t = str(datetime.now()) genesis_block = { "Index": 0, "Timestamp": t, "BPM": 0, "PrevHash": "", "Validator": "" } genesis_block["Hash"] = calculate_hash(genesis_block) print(genesis_block) block_chain.append(genesis_block) thread_canditate = threading.Thread(target=candidate, args=(candidate_blocks, ), daemon=True) thread_pick = threading.Thread(target=pick_winner, args=(announcements, ), daemon=True) thread_canditate.start() thread_pick.start() # start a tcp server serv = ThreadingTCPServer(('', 9090), HandleConn) serv.serve_forever()
def _do_preview(*, build, subdir, port): """Implements the "serve" (http) mode of main(). Args: build: Same as per main(). subdir: Same as per main(). port: Local port number to serve on, per the command line. """ print("Generating documentation preview ...") with tempfile.TemporaryDirectory(prefix="doc_builder_preview_") as scratch: if subdir: out_dir = join(scratch, subdir) os.mkdir(out_dir) else: out_dir = scratch pages = _call_build(build=build, out_dir=out_dir) assert len(pages) > 0 os.chdir(scratch) print(f"The files have temporarily been generated into {scratch}") print() print("Serving at the following URLs for local preview:") print() for page in pages: print(f" http://127.0.0.1:{port}/{join(subdir, page)}") print() print("Use Ctrl-C to exit.") ThreadingTCPServer.allow_reuse_address = True server = ThreadingTCPServer(("127.0.0.1", port), _HttpHandler) try: server.serve_forever() except KeyboardInterrupt: print() return
def start_server(addr): server = ThreadingTCPServer(addr, Handler, bind_and_activate=False) # 参数为监听地址和已建立连接的处理类 server.allow_reuse_address = True server.server_bind() server.server_activate() server.serve_forever() # 监听,建立好TCP连接后,为该连接创建新的socket和线程,并由处理类中的handle方法处理
def run(self): HOST = "localhost" PORT = upload_neighbor_port ADDR = ("localhost", PORT) print("ADDR: ", ADDR) server = ThreadingTCPServer(ADDR, Handler) # Handler: the Handler class whose connection has been established. print("waiting for connection on " + HOST + ":" + str(PORT)) server.serve_forever()
def main(): # tcpServ = TCP(ADDR,MyRequestHandler) #单线程 tcpServ = TCPThead(ADDR, MyRequestHandler) #多线程 tcpServ.allow_reuse_address = True #重用地址,即使客户端还没断开 print('waiting for connection...') tcpServ.serve_forever() tcpServ.server_close()
def start(program, options): ThreadingTCPServer.allow_reuse_address = True server = ThreadingTCPServer((host, port), QuasselGrepHandler) server.program = program server.options = options server.serve_forever() print("Finishing.")
def Recieve_serv(): HOST = IP.get() PORT = 8896 ADDR = (HOST, PORT) server = ThreadingTCPServer(ADDR, Handler) #参数为监听地址和已建立连接的处理类 print('Main----listening') server.serve_forever() #监听,建立好TCP连接后,为该连接创建新的socket和线程
def start_server(): myport = 8886 kill_server(myport) host = "127.0.0.1" port = myport addr = (host, port) Log.logger.debug('Start Server...') server = ThreadingTCPServer(addr, HttpServerHandler) server.serve_forever()
def SRun(ip='', port=20000, key=b'what#@!$THeFuck!@$You', root=None): ServerHandler.io = IO() ServerHandler.key = key if root: ServerHandler.root = root serv = ThreadingTCPServer(('', 20000), ServerHandler) serv.socket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1) serv.serve_forever()
def run(): """ 解析传入参数,并调用FTPHandler """ args = docopt(__doc__, version="1.0") host = args.get("<ip>") port = int(args.get("<port>")) server = ThreadingTCPServer((host, port), FTPHandler) server.serve_forever()
def serve_forever(self): try: ThreadingTCPServer.serve_forever(self) except Exception as e: if not self.run: return raise
def serve_forever(self): try: ThreadingTCPServer.serve_forever(self) except Exception as e: if not self.run: return raise
def masterServerThread(): # Responsible for generating threads that receive data from 1.slave RPi and update the display of data in the main interface HOST, PORT = "192.168.1" + ('0' if getOwnSSID() == 'm' else getOwnSSID()) + ".1", 9999 #HOST, PORT = "192.168.137.1", 9999 # Achieve multiple concurrent response clients to achieve multi-threaded multi-thread operation, # because the threads corresponding to "getandsend" and "recandsend" are connected to the server as clients. # In addition, the reconnection after disconnection can be realized. server = ThreadingTCPServer((HOST, PORT), MyTCPHandler) server.serve_forever() # Start server thread
def main(): class Child(MyHTTPHandler): logger = type('l', (), {'info': print})() # webserver = ThreadingTCPServer((socket.gethostname(), 8092), Child) webserver = ThreadingTCPServer(('0.0.0.0', 8091), Child) # import ssl # webserver.socket = ssl.wrap_socket(webserver.socket, server_side=True, certfile=_get_cert_path(), # keyfile=__get_key_path(), ssl_version=ssl.PROTOCOL_TLSv1_2) webserver.serve_forever()
class Server: def __init__(self, port): server_logger.info('listening to connections...') ThreadingTCPServer.allow_reuse_address = True self.serve = ThreadingTCPServer(('', port), ServerRequestHandler) def run(self): self.serve.serve_forever() def stop(self): self.serve.shutdown()
def start_server(): host = "127.0.0.1" port = 8886 address = (host, port) kill_server(port) Log.logger.debug('Start Server...') server = ThreadingTCPServer(address, HttpServerHandler) server.serve_forever()
def recAndSend(): # recieve data from own client and send the data to own server HOST, PORT = "192.168.1" + getOwnSSID() + ".1", 9999 # for example '192.168.11.1' # Generate a server-side thread queue that will automatically start a thread to join the queue # whenever it receives a socket connection request from the client and a connection is reached. # Set the ip and port number, and fill in the custom class, the class inherits the parent class "socketserver.BaseRequestHandler", # the rewritten "handle" function is the trigger function after the client connects with itself. server = ThreadingTCPServer((HOST, PORT), MyTCPHandler) # This is a blocking function that always waits for a new connection request and then opens a new server-side thread to join the thread queue. server.serve_forever()
def main(): example = 'Example:\n\n$ python3 server.py -U msf -P msf -v -s -l 4444' args = ArgumentParser(prog='Cooolis-ms', epilog=example) args.add_argument('-U', '--username', help='Metasploit web service username', required=True) args.add_argument('-P', '--password', help='Metasploit web service password', required=True) args.add_argument('-H', '--host', help='Metasploit web service host', default='localhost') args.add_argument('-p', '--port', help='Metasploit RPC service port', default=55553, type=int) args.add_argument('-S', '--server', help='Payload sender listen host', default='localhost') args.add_argument('-l', '--listen', help='Payload listen port', default=1111, type=int) args.add_argument('-u', '--uri', help='Metasploit RPC service uri', default='/api/1.0/') args.add_argument('-t', '--type', help='Payload Type', choices=('exe', 'ruby', 'c', 'dll', 'vbs', 'powershell')) args.add_argument('-s', '--ssl', help='Enable ssl', action="store_true", default=True) args.add_argument('-v', '--versobe', help='Enable debug', action="store_true") parser = args.parse_args() term.writeLine( "[*]Server Host : {host} , Server Port : {port}".format( host=parser.server, port=parser.port), term.green) server = ThreadingTCPServer((parser.server, parser.listen), Metasploit_RPC.Creator(parser)) server.serve_forever()
class DeviceServer: def __init__(self): self.server = ThreadingTCPServer(('', 5100), DataHandler) self.thread = Thread(target=DeviceServer.start, args=(self, )) def start(self): self.server.serve_forever() def startthread(self): self.thread.start() DeviceServer.log('Server thread start ' + str(self.server.server_address))
def get_data(external_device, PORT, datapoints, save_data=False): """ external_device = Name of the client device from which data is to be received. PORT = port of the host computer/controller device datapoints = Number of data points expected from external device """ server = ThreadingTCPServer(('', PORT), PairDevices) received_datapoints = datapoints print( "[i] Opening Port: {}\n[i] Expecting {} data points\n[?] Waiting for connection from {} >>" .format(PORT, datapoints, external_device)) server.serve_forever()
class tcp_server(QThread): # 为了Handle能够发送Qt信号 所以使用Qthread dataChanged = pyqtSignal(dict) # 自定义发送信号 def __init__(self, port, mode): # mode = 'grc' or 'hcr' super().__init__() self.serv = None self.port = port self.mode = mode def run(self): if self.mode == 'grc': self.serv = ThreadingTCPServer(('', self.port), GRC_Handler, bind_and_activate=False) self.serv.socket.settimeout(1) # 设置超时, 以便能够退出线程 self.serv.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True) # 设置端口重用, 以便异常socket断开后的重建 self.serv.qthread = self # 这里让Handle里面有信号的发射口 elif self.mode == 'hcr': self.serv = ThreadingTCPServer(('', self.port), HCR_Handler, bind_and_activate=False) self.serv.socket.settimeout(1) # 设置超时, 以便能够退出线程 self.serv.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True) # 设置端口重用, 以便异常socket断开后的重建 else: print("error") return # Bind and activate # self.setName("tcp_server " + self.mode) self.serv.server_bind() self.serv.server_activate() self.serv.serve_forever() def send_data(self, data): ''' Args: data: bytes data ''' if self.is_alive(): for client in client_socket: client.sendall(data) def shutdown(self): for client in client_socket: client.shutdown(1) shutdown_flag[0] = True self.serv.socket.close() self.serv.shutdown() self.serv.server_close()
def launch_server(host, port, input, show=True): print('launching server at {0:s}:{1:d} showing "{2:s}"'.format( host, port, input)) ThreadingTCPServer.allow_reuse_address = True httpd = ThreadingTCPServer((host, port), NotexHandler) if show: thrd = Thread(target=partial( open_in_browser, url='http://{0:s}:{1:d}'.format(host, port))) thrd.start() try: httpd.serve_forever() except KeyboardInterrupt: httpd.server_close()
class Proxy(): def start(self, address, port): try: self.server = ThreadingTCPServer((address, int(port)), ProxyHandler) logger.info("server started at {}:{}".format(address, port)) if sys.platform.startswith('win'): os.system(os.path.join(basepath, 'sysproxy.exe')+' pac http://localhost:7654/pac/?t=%random%') self.server.serve_forever() except socket.error as e: logger.error(e) def shutdown(self): self.server.shutdown() def server_close(self): self.server.server_close()
class GGServer: def __init__(self, addr, port): self.addr = addr self.port = port self.server = ThreadingTCPServer((self.addr, self.port), ClientHandler) pass def listen(self): try: logger.info("Server is listening at {}:{}".format(self.addr, self.port)) self.server.serve_forever() logger.error("Server stopped.") except Exception as e: logger.critical("GG server exception! {}".format(e))
class SockListener(BaseListener): handlerCls = SockServiceHandler def __init__(self, *args, **kwargs): super(SockListener, self).__init__(*args, **kwargs) # inject service_handler SockBoltHandler.service_handler = self.handler self.server = ThreadingTCPServer(self.address, SockBoltHandler) def run_forever(self): self.server.serve_forever() def shutdown(self): self.server.shutdown()
def startServer(): global name # take parameters via console if (len(sys.argv) < 4): print('Usage : python Server.py Chatname hostip port') sys.exit() name = sys.argv[1] HOST = sys.argv[2] PORT = int(sys.argv[3]) name = name.replace('|', "") print("Server started on " + str(HOST) + "; listening on " + str(PORT) + "...") serv = ThreadingTCPServer((HOST, PORT), Echo) serv.serve_forever()
class Master: def __init__(self, zk_hosts, zk_root, address): self.zk = KazooClient(zk_hosts) self.root = zk_root self.server = ThreadingTCPServer(address, MasterHandler) self.server.zk = self.zk self.server.root = self.root def start(self): self.zk.start() self.server.serve_forever() def shutdown(self): self.server.shutdown() self.zk.close()
finally: return result def handle(self): if self.checkconf(): data = self.readconf() self.writeconf(data) else: confsfile = open(self.confsfile) self.confs = loads(confsfile.read()) confsfile.close() for i in self.confs: print(str(i)+'=>'+self.confs[str(i)]['name']+'=>'+self.confs[str(i)]['cont']) data = urlopen(self.confs[str(i)]['cont']).read().decode('utf-8') print(data) print(self.client_address) if self.client_address[0] in self.safeip: print('此IP允许访问') sleep(60) self.data = self.request.recv(10240) self.request.sendall('收到的请求内容是'.encode('utf-8') + self.data) else: print('此IP不允许访问') # 变动位置 if __name__=="__main__": TCP.allow_reuse_address=True tcpServ = TTCP(ADDR, MyRequestHandler) print('等待新的连接。。。。') tcpServ.serve_forever()
# coding:utf-8 from socketserver import ThreadingTCPServer,StreamRequestHandler class LogRequestHandler(StreamRequestHandler): def handle(self): print('client {} is online!'.format(self.client_address)) filename = self.rfile.readline().decode().strip() fd = open('/logs/{0}'.format(filename),'a') while True: data = self.rfile.readline() if not data.strip(): break fd.write(data.decode()) fd.flush() print('close connection') fd.close() if __name__ == '__main__': addr = ('192.168.2.53',8080) server = ThreadingTCPServer(addr,LogRequestHandler) try: server.serve_forever() except KeyboardInterrupt: server.shutdown()
conn, addr = svrSock.accept() recvBuf = conn.recv(1024) print(len(recvBuf)) print(recvBuf) ''' ''' 우선 연결된 클라이언트 정보를 저장해서 allSend(가칭)를 구현해서 클라이언트도 대화내용을 알게해야한다! 대화 내용을 allSend로 보낼 때 들어온 메세지가 시간 순서에 맞게 되는지 항상 확인한다(?) --> 이게 오늘의 과제였나? ''' from socketserver import ThreadingTCPServer, StreamRequestHandler PORT = 2000 class MyRequestHandler(StreamRequestHandler): def handle(self): conn = self.request print('connection form', self.client_address) buf = conn.recv(1024) if not buf: print('nothing') else: print(buf.decode('utf-8')) server = ThreadingTCPServer(('127.0.0.1', 2000), MyRequestHandler) print('listening on port', PORT) server.serve_forever() # 얘는 한번만 실행되고 끝난다. 이걸 반복시킬 방법을 찾아야 한다!
class ModbusServer(object): """Modbus TCP server""" class ModbusService(BaseRequestHandler): def handle(self): while True: rx_head = self.request.recv(7) # close connection if no standard 7 bytes header if not (rx_head and len(rx_head) == 7): break # decode header (rx_hd_tr_id, rx_hd_pr_id, rx_hd_length, rx_hd_unit_id) = struct.unpack('>HHHB', rx_head) # close connection if frame header content inconsistency if not ((rx_hd_pr_id == 0) and (2 < rx_hd_length < 256)): break # receive body rx_body = self.request.recv(rx_hd_length - 1) # close connection if lack of bytes in frame body if not (rx_body and (len(rx_body) == rx_hd_length - 1)): break # body decode: function code rx_bd_fc = struct.unpack('B', rx_body[0:1])[0] # close connection if function code is inconsistent if rx_bd_fc > 0x7F: break # default except status exp_status = const.EXP_NONE # functions Read Coils (0x01) or Read Discrete Inputs (0x02) if rx_bd_fc in (const.READ_COILS, const.READ_DISCRETE_INPUTS): (b_address, b_count) = struct.unpack('>HH', rx_body[1:]) # check quantity of requested bits if 0x0001 <= b_count <= 0x07D0: bits_l = DataBank.get_bits(b_address, b_count) if bits_l: # allocate bytes list b_size = int(b_count / 8) b_size += 1 if (b_count % 8) else 0 bytes_l = [0] * b_size # populate bytes list with data bank bits for i, item in enumerate(bits_l): if item: byte_i = int(i/8) bytes_l[byte_i] = set_bit(bytes_l[byte_i], i % 8) # format body of frame with bits tx_body = struct.pack('BB', rx_bd_fc, len(bytes_l)) # add bytes with bits for byte in bytes_l: tx_body += struct.pack('B', byte) else: exp_status = const.EXP_DATA_ADDRESS else: exp_status = const.EXP_DATA_VALUE # functions Read Holding Registers (0x03) or Read Input Registers (0x04) elif rx_bd_fc in (const.READ_HOLDING_REGISTERS, const.READ_INPUT_REGISTERS): (w_address, w_count) = struct.unpack('>HH', rx_body[1:]) # check quantity of requested words if 0x0001 <= w_count <= 0x007D: words_l = DataBank.get_words(w_address, w_count) if words_l: # format body of frame with words tx_body = struct.pack('BB', rx_bd_fc, w_count * 2) for word in words_l: tx_body += struct.pack('>H', word) else: exp_status = const.EXP_DATA_ADDRESS else: exp_status = const.EXP_DATA_VALUE # function Write Single Coil (0x05) elif rx_bd_fc is const.WRITE_SINGLE_COIL: (b_address, b_value) = struct.unpack('>HH', rx_body[1:]) f_b_value = bool(b_value == 0xFF00) if DataBank.set_bits(b_address, [f_b_value]): # send write ok frame tx_body = struct.pack('>BHH', rx_bd_fc, b_address, b_value) else: exp_status = const.EXP_DATA_ADDRESS # function Write Single Register (0x06) elif rx_bd_fc is const.WRITE_SINGLE_REGISTER: (w_address, w_value) = struct.unpack('>HH', rx_body[1:]) if DataBank.set_words(w_address, [w_value]): # send write ok frame tx_body = struct.pack('>BHH', rx_bd_fc, w_address, w_value) else: exp_status = const.EXP_DATA_ADDRESS # function Write Multiple Coils (0x0F) elif rx_bd_fc is const.WRITE_MULTIPLE_COILS: (b_address, b_count, byte_count) = struct.unpack('>HHB', rx_body[1:6]) # check quantity of updated coils if (0x0001 <= b_count <= 0x07B0) and (byte_count >= (b_count/8)): # allocate bits list bits_l = [False] * b_count # populate bits list with bits from rx frame for i, item in enumerate(bits_l): b_bit_pos = int(i/8)+6 b_bit_val = struct.unpack('B', rx_body[b_bit_pos:b_bit_pos+1])[0] bits_l[i] = test_bit(b_bit_val, i % 8) # write words to data bank if DataBank.set_bits(b_address, bits_l): # send write ok frame tx_body = struct.pack('>BHH', rx_bd_fc, b_address, b_count) else: exp_status = const.EXP_DATA_ADDRESS else: exp_status = const.EXP_DATA_VALUE # function Write Multiple Registers (0x10) elif rx_bd_fc is const.WRITE_MULTIPLE_REGISTERS: (w_address, w_count, byte_count) = struct.unpack('>HHB', rx_body[1:6]) # check quantity of updated words if (0x0001 <= w_count <= 0x007B) and (byte_count == w_count * 2): # allocate words list words_l = [0] * w_count # populate words list with words from rx frame for i, item in enumerate(words_l): w_offset = i * 2 + 6 words_l[i] = struct.unpack('>H', rx_body[w_offset:w_offset + 2])[0] # write words to data bank if DataBank.set_words(w_address, words_l): # send write ok frame tx_body = struct.pack('>BHH', rx_bd_fc, w_address, w_count) else: exp_status = const.EXP_DATA_ADDRESS else: exp_status = const.EXP_DATA_VALUE else: exp_status = const.EXP_ILLEGAL_FUNCTION # check exception if exp_status != const.EXP_NONE: # format body of frame with exception status tx_body = struct.pack('BB', rx_bd_fc + 0x80, exp_status) # build frame header tx_head = struct.pack('>HHHB', rx_hd_tr_id, rx_hd_pr_id, len(tx_body) + 1, rx_hd_unit_id) # send frame self.request.send(tx_head + tx_body) self.request.close() def __init__(self, host='localhost', port=502, no_block=False, ipv6=False): """Constructor Modbus server constructor. :param host: hostname or IPv4/IPv6 address server address (optional) :type host: str :param port: TCP port number (optional) :type port: int :param no_block: set no block mode, in this mode start() return (optional) :type no_block: bool :param ipv6: use ipv6 stack :type ipv6: bool """ self.host = host self.port = port self.no_block = no_block self.ipv6 = ipv6 # set class attribute ThreadingTCPServer.address_family = socket.AF_INET6 if self.ipv6 else socket.AF_INET ThreadingTCPServer.daemon_threads = True # init server self._service = ThreadingTCPServer((self.host, self.port), self.ModbusService, bind_and_activate=False) # set socket options self._service.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self._service.socket.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1) # TODO test no_delay with bench self._service.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) # add thread for no block mode if self.no_block: self._serve_th = Thread(target=self._service.serve_forever) self._serve_th.daemon = True def start(self): # bind and activate self._service.server_bind() self._service.server_activate() # serve request if self.no_block: self._serve_th.start() else: self._service.serve_forever()
''' Created on 2011-9-13 @author: slieer ''' from socketserver import BaseRequestHandler, ThreadingTCPServer from time import sleep import sys, socket class WebLogHandler(BaseRequestHandler): def handle(self): print("Connected from", self.client_address) self.request.sendall('<hits>') try: while True: for hit in LOG.readlines(): self.request.sendall(hit) sleep(5) except socket.error: self.request.close() print("Disconnected from", self.client_address) if __name__=='__main__': global LOG LOG = open('access-log') LOG.seek(0, 2) # Start at end of current access log srv = ThreadingTCPServer(('',8888), WebLogHandler) srv.serve_forever()
active = True while active: transmission = self.request.recv(1024).decode() # wait for something to happen if transmission: command = transmission.split()[0] data = transmission[1+len(command): ] # the rest if command == 'ADD': username = data.strip() _socketLookup[username] = self.request _broadcast(('NEW %s\n' % username).encode()) elif command == 'MESSAGE': _broadcast(('MESSAGE %s\n%s\n' % (username,data)).encode() ) elif command == 'PRIVATE': rcpt = data.split('\n')[0] if rcpt in _socketLookup: content = data.split('\n')[1] _socketLookup[rcpt].send(('PRIVATE %s\n%s\n'%(username,content)).encode() ) elif command == 'QUIT': active = False self.request.send('GOODBYE\n'.encode()) # acknowledge else: active = False # socket failed self.request.close() _socketLookup.pop(username) _broadcast(('LEFT %s\n' % username).encode()) # inform others myServer = ThreadingTCPServer( ('localhost', 9000), ChatHandler) myServer.serve_forever()
if parsedurl.path == '/code': self.json_headers() liw.authentication.authorization_code = params_to_d(self.path).get('code') self.wfile.write(dumps({'access_token': liw.authentication.get_access_token(), 'routes': list(filter(lambda d: not d.startswith('_'), dir(liw.application)))}).encode('utf8')) elif parsedurl.path == '/routes': self.json_headers() self.wfile.write(dumps({'routes': list(filter(lambda d: not d.startswith('_'), dir(liw.application)))}).encode('utf8')) elif not authed: self.json_headers() if not globals()['run_already']: open_new_tab(liw.authentication.authorization_url) globals()['run_already'] = True self.wfile.write(dumps({'path': self.path, 'authed': type(liw.authentication.token) is None}).encode('utf8')) elif authed and len(parsedurl.path) and parsedurl.path[1:] in dir(liw.application): self.json_headers() self.wfile.write(dumps(getattr(liw.application, parsedurl.path[1:])()).encode('utf8')) else: self.json_headers(501) self.wfile.write(dumps({'error': 'NotImplemented'}).encode('utf8')) if __name__ == '__main__': httpd = ThreadingTCPServer(('localhost', PORT), CustomHandler) print('Server started on port:{}'.format(PORT)) httpd.serve_forever()
encrypted_message = encrypt_message(pw.encode('utf-8'), b'Hello world!!!!!') print(encrypted_message) o_message = decrypt_message(pw.encode('utf-8'), encrypted_message) print(o_message) # 发起一个线程, 扫描信息 thread = Thread(target = scan_messages, args = (10, )) thread.start() print ("thread finished...exiting") station_name = 'sv_station'; with open('public.pem','r') as f: station_pubic_key = f.read(); with open('private.pem','r') as f: station_private_key = f.read(); station_fingerprint = rsa_sign(station_name.encode('utf-8'), station_private_key, '111111'); station_address = btc_build_address( station_fingerprint ); # text = decrypt(station_private_key, encrypted_key); # print(text); with open('resources/moki_public_key.pem','r') as f: moki_pub = f.read(); HOST = '0.0.0.0' PORT = 8998; ADDR = (HOST,PORT); socketserver.TCPServer.allow_reuse_address = True; server = ThreadingTCPServer(ADDR,Handler) #参数为监听地址和已建立连接的处理类 print( station_name+'@'+ station_address +' is listening...'); server.serve_forever() #监听,建立好TCP连接后,为该连接创建新的socket和线程,并由处理类中的handle方法处理 print(server);
def main(): """ Create and start server. """ server = ThreadingTCPServer(('', 7000), ProbeHandler) server.serve_forever()
def _main(): host, port = socket.gethostname(), 1536 server = ThreadingTCPServer((host, port), TCPHandler) server.serve_forever()