예제 #1
0
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()
예제 #2
0
파일: accesser.py 프로젝트: LCinHK/Accesser
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()
예제 #3
0
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")
예제 #4
0
    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()
예제 #5
0
파일: pos.py 프로젝트: vin136/py-bitcoin
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()
예제 #6
0
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
예제 #7
0
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方法处理
예제 #8
0
 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()
예제 #9
0
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()
예제 #10
0
파일: server.py 프로젝트: zkrx/quasselgrep
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.")
예제 #11
0
    def Recieve_serv():

        HOST = IP.get()
        PORT = 8896
        ADDR = (HOST, PORT)
        server = ThreadingTCPServer(ADDR, Handler)  #参数为监听地址和已建立连接的处理类
        print('Main----listening')
        server.serve_forever()  #监听,建立好TCP连接后,为该连接创建新的socket和线程
예제 #12
0
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()
예제 #13
0
    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()
예제 #14
0
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()
예제 #15
0
    def serve_forever(self):
        try:

            ThreadingTCPServer.serve_forever(self)

        except Exception as e:
            if not self.run:
                return

            raise
예제 #16
0
    def serve_forever(self):
        try:

            ThreadingTCPServer.serve_forever(self)

        except Exception as e:
            if not self.run:
                return

            raise
예제 #17
0
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
예제 #18
0
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()
예제 #19
0
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()
예제 #21
0
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()
예제 #22
0
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()
예제 #23
0
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))
예제 #24
0
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()
예제 #25
0
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()
예제 #26
0
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()
예제 #27
0
파일: accesser.py 프로젝트: exbug/Accesser
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()
예제 #28
0
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))
예제 #29
0
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()
예제 #30
0
파일: Server.py 프로젝트: slinksoft/PyChat
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()
예제 #31
0
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()
예제 #32
0
        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()

예제 #33
0
# 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()
예제 #34
0
파일: server.py 프로젝트: skykhk01/python
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()          # 얘는 한번만 실행되고 끝난다. 이걸 반복시킬 방법을 찾아야 한다!
예제 #35
0
파일: server.py 프로젝트: Siuol/pyModbusTCP
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()
예제 #36
0
'''
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()
예제 #37
0
    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()
예제 #38
0
파일: http_api.py 프로젝트: Dankeee/spider
        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()
예제 #39
0
파일: server_start.py 프로젝트: selvn/dimp
	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);
예제 #40
0
파일: proby.py 프로젝트: bmaca/proby
def main():
    """
    Create and start server.
    """
    server = ThreadingTCPServer(('', 7000), ProbeHandler)
    server.serve_forever()
예제 #41
0
파일: tcpserver.py 프로젝트: crvv/weather
def _main():
    host, port = socket.gethostname(), 1536
    server = ThreadingTCPServer((host, port), TCPHandler)
    server.serve_forever()