def __init__(self, address, cls): """Initialize the server.""" self.allow_reuse_address = True ThreadingTCPServer.__init__(self, address, cls) self.engine = None self.engine_lock = threading.Lock()
def __init__(self, host='localhost', port=logging.handlers.DEFAULT_TCP_LOGGING_PORT, handler=LogRecordStreamHandler): ThreadingTCPServer.__init__(self, (host, port), handler) self.abort = 0 self.timeout = 1 self.logname = None
def __init__(self, host='localhost', port=DEFAULT_LOGGING_CONFIG_PORT, handler=None): ThreadingTCPServer.__init__(self, (host, port), handler) logging._acquireLock() self.abort = 0 logging._releaseLock() self.timeout = 1
def __init__(self, host, port, traceback_frames, ignore_selects, ignored_sources, ignored_request_paths): ThreadingTCPServer.__init__(self, (host, port), LogRecordStreamHandler) self.timeout = 1 self.traceback_frames = traceback_frames self.ignore_selects = ignore_selects self.ignored_sources = [ignored_line_re.match(s).groupdict() for s in ignored_sources] self.ignored_request_paths = {self._process_path(x) for x in ignored_request_paths}
def __init__(self, host='localhost', port=logging.handlers.DEFAULT_TCP_LOGGING_PORT, handler=LogRecordStreamHandler): ThreadingTCPServer.__init__(self, (host, port), handler) self.abort = False self.timeout = 0.1 self.finished = threading.Event()
def __init__(self, server_address, RequestHandlerClass, server_ssl=True, bind_and_activate=True, encrypted=True): ThreadingTCPServer.__init__(self, server_address, RequestHandlerClass, False) self.secure = server_ssl self.__shutdown_request = False self.networked = [] self.messagebox = [] self.watch = threading.Thread(target=self._network_watch) self.watch.start() self._key = Random.new().read(AES.key_size[-1]) self._cipherobj = AES.new(self._key, AES.MODE_CBC, Random.new().read(AES.block_size)) self._encrypted = encrypted self._aes_buffer = b'\x90' * 3 + b'\x05' signal.signal(signal.SIGINT, self.stop_thread) if bind_and_activate: try: self.server_bind() self.server_activate() except: self.server_close() raise
def process_request(self, request, client_address): # Processa uma nova requisicao. Adiciona o novo cliente na lista de clientes # mantida pelo servidor e chama o mesmo metodo da classe-base. print("Novo cliente conectado " + request.getpeername()[0]) self.clients.append(request) ThreadingTCPServer.process_request(self, request, client_address)
def start(self): """Start the server. Do nothing if server is already running. This function will block if no_block is not set to True. """ if not self.is_run: # 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) # bind and activate self._service.server_bind() self._service.server_activate() # serve request if self.no_block: self._serve_th = Thread(target=self._serve) self._serve_th.daemon = True self._serve_th.start() else: self._serve()
def __init__(self, server_address, session, probe): self._session = session self._probe = probe ThreadingTCPServer.__init__(self, server_address, DebugProbeRequestHandler, bind_and_activate=False)
def __init__(self, host="", port=COBRA_PORT, sslcrt=None, sslkey=None, sslca=None, msgpack=False, json=False): ''' Construct a cobra daemon object. Parameters: host - Optional hostname/ip to bind the service to (default: inaddr_any) port - The port to bind (Default: COBRA_PORT) msgpack - Use msgpack serialization # SSL Options sslcrt / sslkey - Specify sslcrt and sslkey to enable SSL server side sslca - Specify an SSL CA key to use validating client certs ''' self.thr = None self.run = True self.shared = {} self.dowith = {} self.host = host self.port = port self.reflock = RLock() self.refcnts = {} self.authmod = None self.sflags = 0 if msgpack and json: raise Exception('CobraDaemon can not use both msgpack *and* json!') if msgpack: requireMsgpack() self.sflags |= SFLAG_MSGPACK if json: self.sflags |= SFLAG_JSON # SSL Options self.sslca = sslca self.sslcrt = sslcrt self.sslkey = sslkey self.cansetattr = True self.cangetattr = True if sslcrt and not os.path.isfile(sslcrt): raise Exception('CobraDaemon: sslcrt param must be a file!') if sslkey and not os.path.isfile(sslkey): raise Exception('CobraDaemon: sslkey param must be a file!') if sslca and not os.path.isfile(sslca): raise Exception('CobraDaemon: sslca param must be a file!') self.allow_reuse_address = True ThreadingTCPServer.__init__(self, (host, port), CobraRequestHandler) if port == 0: self.port = self.socket.getsockname()[1] self.daemon_threads = True self.recvtimeout = None
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()
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 __init__(self, ip, port, handler): ThreadingTCPServer.__init__(self, (ip, port), handler) Thread.__init__(self, target=self.serve_forever) # Set the thread name to the class name Thread.setName(self, f'TCP-{self.__class__.__name__} Server') self.daemon = True
def __init__(self, server_address, RequestHandlerClass, bind_and_activate=True): """Constructor. May be extended, do not override.""" ThreadingTCPServer.__init__(self, server_address, RequestHandlerClass) self.stopped = False
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 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 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 main(): if len(sys.argv) < 2: print("Usage: {} binFile [port]\n\t".format(sys.argv[0])) exit(-1) binFile = sys.argv[1] port = DEFAULT_PORT if len(sys.argv) < 3 else int(sys.argv[2]) print('binFile:', binFile, 'port:', port) server = ThreadingTCPServer(('', port), EncodeHandler) def sigint_handler(signum, frame): print('sig {} raised: {}'.format(signum, frame)) server.socket.close() server.shutdown() sys.exit(0) signal.signal(signal.SIGINT, sigint_handler) # main thread will handle signals try: EncodeHandler.bitmapList = load_video_bin(binFile) waiterThread = Thread(target=server.serve_forever, args=()) waiterThread.start() waiterThread.join() except Exception as e: print('exception raised:', e) finally: server.socket.close() server.shutdown()
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 __init__(self, host, port, dispatcher): Thread.__init__(self) self.daemon = True self.server = ThreadingTCPServer((host, port), RequestHandler, bind_and_activate=False) self.server.allow_reuse_address = True self.server.server_bind() self.server.server_activate() self.server.dispatcher = dispatcher
def Recieve_serv(): HOST = IP.get() PORT = 8896 ADDR = (HOST, PORT) server = ThreadingTCPServer(ADDR, Handler) #参数为监听地址和已建立连接的处理类 print('Main----listening') server.serve_forever() #监听,建立好TCP连接后,为该连接创建新的socket和线程
def server_bind(self): ThreadingTCPServer.server_bind(self) # wrap the socket early self.socket = ssl.wrap_socket(self.socket, server_side=True, certfile=CERT_PATH, keyfile="server.key", do_handshake_on_connect=False)
def __init__(self, *args: Any) -> None: Beak.__init__(self, *args) address = (self._config.props['address'], self._config.props['port']) ThreadingTCPServer.__init__(self, address, _TCPHandler, False) self.server_thread = Thread(target=self.serve_forever) self.consumer_thread = Thread(target=self.mb_receive_loop) self.bind_tries = TCPServerBeak.MAX_BIND_TRIES
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 shutdown(self): """ Safely shutdown server and thread :return: None """ ThreadingTCPServer.shutdown(self) Thread.join(self)
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 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 __init__(self, server_address, RequestHandlerClass, service, data=None): self.data = data self.service = service #HTTPServer.__init__(self, server_address, RequestHandlerClass) ThreadingTCPServer.__init__(self, server_address, RequestHandlerClass)
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 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 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 serve_forever(self): try: ThreadingTCPServer.serve_forever(self) except Exception as e: if not self.run: return raise
def __init__(self, host="", port=COBRA_PORT, sslcrt=None, sslkey=None, sslca=None, sess_timeout=24, attr=True): ''' Construct a cobra daemon object. Parameters: host - Optional hostname/ip to bind the service to (default: inaddr_any) port - The port to bind (Default: COBRA_PORT) timeout - The length any session can last, before forcing reconnect attr - Toggle to turn off the ability to set or get attributes # SSL Options sslcrt / sslkey - Specify sslcrt and sslkey to enable SSL server side sslca - Specify an SSL CA key to use validating client certs ''' self.shared = {} self.host = host self.port = port self.reflock = RLock() self.refcnts = {} self.authmod = None self.attr = attr self.sessions = {} # authenticated sessions self.sess_timeout=sess_timeout*60 # SSL Options self.sslca = sslca self.sslcrt = sslcrt self.sslkey = sslkey if sslcrt and not os.path.isfile(sslcrt): raise Exception('CobraDaemon: sslcrt param must be a file!') if sslkey and not os.path.isfile(sslkey): raise Exception('CobraDaemon: sslkey param must be a file!') if sslca and not os.path.isfile(sslca): raise Exception('CobraDaemon: sslca param must be a file!') #ThreadingTCPServer.__init__(self, (host, port), CobraHttpConnectionHandler) ThreadingTCPServer.__init__(self, (host, port), CobraHttpRequestHandler) t = Thread(target=self._timeoutSessions) t.setDaemon(1) t.start() if port == 0: self.port = self.socket.getsockname()[1] self.daemon_threads = True self.recvtimeout = None
def __init__(self, config, handler_class): server_address = (config['server']['ip'], config['server']['port'],) # Bind and activate server in I{activate} method ThreadingTCPServer.__init__(self, server_address, handler_class, 0) Daemon.__init__(self, config['server']['pid']) # Signals not catched in serve_forever, we need to execute serve_forever # again because signals are raised exception in I{main} method self.__by_signal_do = 0 self.__local_sock = None self.allow_reuse_address = 1 self._config = config.copy() self._aliases = {} self.timeout = config['server']['timeout']
class WebUI(object): version = "Bitcoin WebUI v0.0.1" def __init__(self, config): self.config = config credentials = config.rpcusername + ":" + config.rpcpassword self.rpcauth = "Basic " + base64.b64encode(credentials.encode("utf_8")).decode("ascii") self.httpd = None def start(self): self.httpd = ThreadingTCPServer((self.config.bindip, self.config.bindport), RequestHandler, False) self.httpd.webui = self self.httpd.allow_reuse_address = True self.httpd.daemon_threads = True tcp_socket = socket.socket(self.httpd.address_family, self.httpd.socket_type) self.httpd.socket = ssl.wrap_socket(tcp_socket, self.config.privkeyfile, self.config.pubkeyfile, True) self.httpd.server_bind() self.httpd.server_activate() self.serverthread = Thread(None, self.httpd.serve_forever, "httpd") self.serverthread.start() def stop(self): self.httpd.shutdown() self.serverthread.join(5) self.httpd.server_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 run(self): ThreadingTCPServer.__init__(self, (self.host, self.port), self.handler) self.abort = 0 self.timeout = 1 self.logname = None import select abort = 0 while not abort: rd, wr, ex = select.select([self.socket.fileno()], [], [], self.timeout) if rd: self.handle_request() abort = self.abort
def finish_request(self, request, client_address): try: return ThreadingTCPServer.finish_request(self, request, client_address) except Exception as e: from traceback import format_exception i = sys.exc_info() logging.error('\n'.join(format_exception(i[0], i[1], i[2])).strip())
def _start(self): super(WebUI, self)._start() self.httpd = ThreadingTCPServer(("", self.settings.port), RequestHandler, False) self.httpd.webui = self self.httpd.allow_reuse_address = 1 self.httpd.server_bind() self.httpd.server_activate() self.serverthread = Thread(None, self.httpd.serve_forever, self.settings.name + "_httpd") self.serverthread.daemon = True self.serverthread.start() self.port = self.settings.port
def start(self): self.httpd = ThreadingTCPServer((self.config.bindip, self.config.bindport), RequestHandler, False) self.httpd.webui = self self.httpd.allow_reuse_address = True self.httpd.daemon_threads = True tcp_socket = socket.socket(self.httpd.address_family, self.httpd.socket_type) self.httpd.socket = ssl.wrap_socket(tcp_socket, self.config.privkeyfile, self.config.pubkeyfile, True) self.httpd.server_bind() self.httpd.server_activate() self.serverthread = Thread(None, self.httpd.serve_forever, "httpd") self.serverthread.start()
class ThreadingServerInThread(object): """ Context manager for running a threading http server in a thread. Since the Thread is not using "daemon=True", it will keep Python running until the context manager exits, which means until request completion. """ def __init__(self, port=8000): self._server_address = ("127.0.0.1", port) self._handler = SimpleHTTPRequestHandlerHere self.httpd = ThreadingTCPServer( self._server_address, self._handler, bind_and_activate=False ) def _bind_and_activate(self): try: self.httpd.server_bind() self.httpd.server_activate() except Exception as e: self.httpd.server_close() raise e def start(self): self._bind_and_activate() thread = threading.Thread(target=self.httpd.serve_forever) thread.start() def stop(self): self.httpd.shutdown() self.httpd.server_close() def __enter__(self): self.start() return self def __exit__(self, exc_type, exc_val, exc_tb): self.stop()
def listening(self): if hasattr(self, "server"): self.server.shutdown() self.server = None self.t._stop() listenIP = self.txtLocalIP.text() listenPort = self.txtLocalPort.text() try: self.server = ThreadingTCPServer((listenIP, int(listenPort)), EchoRequestHandler) print("server running at", listenIP, listenPort) self.txtConsole.append("server running at " + listenIP + " " + listenPort) self.t = Thread(target=self.server.serve_forever) self.t.start() except Exception as e: print(e) self.txtConsole.append(str(e))
# 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()
def __init__(self, addr, handler, timeout=1): ThreadingTCPServer.__init__(self, addr, LogRecordStreamHandler) BaseServer.__init__(self, handler, timeout)
PORT = 12000 class MyRequestHandler(StreamRequestHandler): def handle(self): now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") conn = self.request buf = conn.recv(1024) if not buf: print("{0}, connection from {1}, message: nothing".format(now, self.client_address)) else: print("{0}, connection from {1}, message: {2}".format(now, self.client_address, buf)) server = ThreadingTCPServer(("127.0.0.1", PORT), MyRequestHandler) print("listening on port", PORT) server.serve_forever() class ClientThread(threading.Thread): def run(self): for n in range(0, 60): print("[{0}] Thread {1:03d}".format(self.getName(), random.randrange(1, 999))) time.sleep(1) th = [] for i in range(3): th.append(ClientThread())
def __init__(self,listen,prefix): self.allow_reuse_address=True ThreadingTCPServer.__init__(self,listen, TCPCauldronRequestHandler) CauldronServer.__init__(self, prefix)
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()
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()
def get_request(self): sock, addr = ThreadingTCPServer.get_request(self) logging.info('%s:%s incoming request' % addr) return sock, addr
class WebUI(BaseFrontend): version = "theseven.webui v0.1.0" default_name = "WebUI" can_log = True can_configure = True can_autodetect = True settings = dict( BaseFrontend.settings, **{ "port": {"title": "HTTP port", "type": "int", "position": 1000}, "users": { "title": "Users", "type": "dict", "key": {"title": "User:Password", "type": "string"}, "value": { "title": "Privilege level", "type": "enum", "values": [ {"value": "readonly", "title": "Read only access"}, {"value": "admin", "title": "Full access"}, ], }, "position": 2000, }, "log_buffer_max_length": {"title": "Maximum log buffer length", "type": "int", "position": 3000}, "log_buffer_purge_size": {"title": "Log buffer purge size", "type": "int", "position": 3010}, } ) @classmethod def autodetect(self, core): core.add_frontend(self(core)) def __init__(self, core, state=None): super(WebUI, self).__init__(core, state) self.log_lock = RLock() def apply_settings(self): super(WebUI, self).apply_settings() if not "port" in self.settings: self.settings.port = 8832 if not "users" in self.settings: self.settings.users = {"admin:mpbm": "admin"} if not "uiconfig" in self.settings: self.settings.uiconfig = {"loggadget": {"loglevel": self.core.default_loglevel}} if not "log_buffer_max_length" in self.settings: self.settings.log_buffer_max_length = 1000 if not "log_buffer_purge_size" in self.settings: self.settings.log_buffer_purge_size = 100 if self.started and self.settings.port != self.port: self.async_restart(3) def _reset(self): self.log_buffer = [] self.log_listeners = [] def _start(self): super(WebUI, self)._start() self.httpd = ThreadingTCPServer(("", self.settings.port), RequestHandler, False) self.httpd.webui = self self.httpd.allow_reuse_address = True self.httpd.daemon_threads = True self.httpd.server_bind() self.httpd.server_activate() self.serverthread = Thread(None, self.httpd.serve_forever, self.settings.name + "_httpd") self.serverthread.daemon = True self.serverthread.start() self.port = self.settings.port def _stop(self): self.httpd.shutdown() self.serverthread.join(10) self.httpd.server_close() super(WebUI, self)._stop() def write_log_message(self, source, timestamp, loglevel, messages): if not self.started: return data = { "timestamp": time.mktime(timestamp.timetuple()) * 1000 + timestamp.microsecond / 1000.0, "loglevel": loglevel, "source": source.settings.name, "message": [{"data": data, "format": format} for data, format in messages], } with self.log_lock: for queue in self.log_listeners: queue.put(data) self.log_buffer.append(data) if len(self.log_buffer) > self.settings.log_buffer_max_length: self.log_buffer = self.log_buffer[self.settings.log_buffer_purge_size :] def register_log_listener(self, listener): with self.log_lock: if not listener in self.log_listeners: self.log_listeners.append(listener) for data in self.log_buffer: listener.put(data) def unregister_log_listener(self, listener): with self.log_lock: while listener in self.log_listeners: self.log_listeners.remove(listener)
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);
''' 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()
def __init__(self, addr, handler, timeout=1): ThreadingTCPServer.__init__(self, addr, LogRecordStreamHandler) BaseServer.__init__(self, handler, timeout) self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
def _main(): host, port = socket.gethostname(), 1536 server = ThreadingTCPServer((host, port), TCPHandler) server.serve_forever()
def __init__(self, port=8000): self._server_address = ("127.0.0.1", port) self._handler = SimpleHTTPRequestHandlerHere self.httpd = ThreadingTCPServer( self._server_address, self._handler, bind_and_activate=False )
def __init__( self, host=LOG_SERVER_HOST, port=LOG_SERVER_PORT, handler=LogRecordStreamHandler): ThreadingTCPServer.__init__(self, (host, port), handler) self.abort = 0 self.timeout = 1