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()
