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