def forward_tcp_to_tcp(source: socket.socket, destination: socket.socket):
try:
log.debug("Ongoing connection route: %s ---> %s ---> %s" %
(source.getpeername(), source.getsockname(),
destination.getpeername()))
except:
# Do nothing
log.debug("Socket closed maybe??")
message = ' '
while message:
message = source.recv(tcp_bufsize)
if message:
destination.sendall(message)
else:
try:
source.shutdown(socket.SHUT_RD)
except:
# traceback.print_exc()
pass # Do nothing then
try:
destination.shutdown(socket.SHUT_WR)
except:
# traceback.print_exc()
pass # Do nothing then
break
async def handle(self, client: socket.socket) -> None:
"""Handle a single client socket from the server."""
start_time = time.time_ns()
# Read & parse connection.
await (conn := Connection(client)).read()
if 'Host' not in conn.headers:
log('Connection missing Host header.', Ansi.LRED)
client.shutdown(socket.SHUT_RDWR)
client.close()
return
# Dispatch the handler.
code = await self.dispatch(conn)
if self.debug:
# Event complete, stop timing, log result and cleanup.
time_taken = (time.time_ns() - start_time) / 1e6
col = (Ansi.LGREEN if 200 <= code < 300 else
Ansi.LYELLOW if 300 <= code < 400 else Ansi.LRED)
uri = f'{conn.headers["Host"]}{conn.path}'
log(f'[{conn.cmd}] {code} {uri}', col, end=' | ')
printc(f'Elapsed: {time_taken:.2f}ms', Ansi.LBLUE)
try:
client.shutdown(socket.SHUT_RDWR)
client.close()
except socket.error:
pass
def listen_udp_forward_tcp_to_udp(tcp_client_socket: socket.socket,
udp_listening_socket: socket.socket,
udp_client: tuple):
log.debug("Listening UDP: Forwarding TCP to UDP")
server_msg = ' '
while server_msg:
try:
server_msg = tcp_client_socket.recv(tcp_bufsize)
if server_msg:
udp_listening_socket.sendto(server_msg, udp_client)
else:
try:
tcp_client_socket.shutdown(socket.SHUT_RD)
except:
pass
try:
del udp_over_tcp[udp_client]
except:
pass
except:
traceback.print_exc()
try:
tcp_client_socket.close()
except:
pass
try:
del udp_over_tcp[udp_client]
except:
pass
break
async def handle(self, client: socket.socket) -> None:
"""Handle a single client socket from the server."""
start_time = time.time_ns()
# Read & parse connection.
await (conn := Connection(client)).read()
if 'Host' not in conn.headers:
# This should never happen?
client.shutdown(socket.SHUT_RDWR)
client.close()
return
# Dispatch the handler.
code = await self.dispatch(conn)
# Event complete, stop timing, log result and cleanup.
time_taken = (time.time_ns() - start_time) / 1e6
colour = (Ansi.LGREEN if 200 <= code < 300 else
Ansi.LYELLOW if 300 <= code < 400 else Ansi.LRED)
uri = f'{conn.headers["Host"]}{conn.path}'
log(f'[{conn.cmd}] {code} {uri}', colour)
if self.verbose:
log(f'Request took {time_taken:.2f}ms', Ansi.LBLUE)
client.shutdown(socket.SHUT_RDWR)
client.close()
def handle(self, conn: socket.socket):
try:
in_ = conn.makefile('r')
out = conn.makefile('w')
# we must read in the full header even if we dont
# intend to use it...
header = []
line = " "
while line not in ['\n', '\r\n', '']:
line = in_.readline()
header.append(line)
print(
f"""HTTP/1.1 201
Content-Type: text/plain; charset=UTF-8
Server-name: CPO debugger
CPO State {datetime.datetime.now()}
""", file=out)
self.show_cso_state(file=out)
out.flush()
out.close()
conn.shutdown(0)
conn.close()
finally:
if conn is not None:
conn.close()
def shutdown_socket(to_shutdown: socket.socket):
try:
#log.info("Shutting down socket")
to_shutdown.shutdown(SHUT_RD)
#log.info("Shutdown socket successfully")
except:
pass
def channel_thread(channel: socket.socket):
host, port = channel.getpeername()[0:2]
while True:
size_buffer = channel.recv(1)
if len(size_buffer) == 0:
break
size = size_buffer[0]
print('(pending: {})'.format(size))
if size == 0:
print('Closing connection to [{}]:{}'.format(host, port))
break
buffer = bytes()
while len(buffer) < size:
buffer_size = min([size - len(buffer), 64])
buffer = buffer + channel.recv(buffer_size)
print('Received message from [{}]:{}.'.format(host, port))
print(buffer.decode('utf-8'))
channel.send(bytes([
size,
]))
channel.send(buffer)
send_john_cena(channel)
channel.shutdown(socket.SHUT_WR)
channel.close()
def transfer(src: socket.socket, dst: socket.socket, send: bool) -> None:
"""
Send data received on the source socket to the destination socket.
"""
src_addr, src_port = src.getsockname()
dst_addr, dst_port = dst.getsockname()
while True:
try:
buffer = src.recv(0x400)
except socket.error:
break
if len(buffer) == 0:
logging.debug("[-] No data received! Breaking...")
break
try:
dst.send(buffer)
except socket.error:
break
logging.debug(f"[+] Closing connections! [{src_addr}:{src_port}]")
try:
src.shutdown(socket.SHUT_RDWR)
src.close()
except socket.error:
pass
logging.debug(f"[+] Closing connections! [{dst_addr}:{dst_port}]")
try:
dst.shutdown(socket.SHUT_RDWR)
dst.close()
except socket.error:
pass
def send_and_wait_file(client_socket: socket.socket):
transfer_mode_bytes = struct.pack('i', SEND_AND_WAIT_MODE)
print(
"send to server tranfer_mode -->send_and_wait (0 --> stream; 1--> send_and_wait)"
)
client_socket.send(transfer_mode_bytes)
file_name = os.path.basename(file_path)
file_name_size_bytes = struct.pack('i', len(file_name))
client_socket.send(file_name_size_bytes)
client_socket.send(file_name.encode('utf-8'))
total_bytes_sent = 0
total_messages_sent = 0
start_time = ctime_millis()
file_size = os.path.getsize(file_path)
try:
f = open(file_path, 'rb')
while file_size > 0:
if BLOCK_SIZE < file_size:
sent_size = BLOCK_SIZE
else:
sent_size = file_size
message = f.read(sent_size)
client_socket.send(message)
while True:
# waiting for ack from server
try:
# unsigmned long long is on 8 bytes Q
ACK = client_socket.recv(8)
ACK = struct.unpack('Q', ACK)[0]
print("ACK is: {}".format(ACK))
except Exception as e:
print(e)
# ACK is lost
client_socket.send(message)
else:
break
file_size -= sent_size
total_bytes_sent += sent_size
total_messages_sent += 1
except:
pass
print("Done sending file {} ".format(file_path))
client_socket.shutdown(socket.SHUT_RDWR)
client_socket.close()
end_time = ctime_millis()
time_diff = end_time - start_time
print("File was sent in: {}".format(nice_time(time_diff)))
print("Total number of messages sent: {}".format(total_messages_sent))
print("Total number of bytes sent: {}".format(total_bytes_sent))
def _close_socket_on_stop(self, sock: socket.socket) -> None:
# This function runs in the background waiting for the `stop` Event to
# be set at which point it closes the socket, causing the server to
# shutdown. This allows the server threads to be cleanly closed on
# demand.
self.wait_stopped()
sock.shutdown(socket.SHUT_RD)
sock.close()
def serve_client(self, client_sock: socket.socket):
client_sock.settimeout(TIMEOUT)
while True:
data = client_sock.recv(1024)
if data == b"":
client_sock.shutdown(1)
client_sock.close()
break
if data:
client_sock.sendall(data)
def _command_quit(sock: socket.socket, msg: str, socket_id):
global sockets, msg_buffer
log('debug', f'Closed connection {socket_id} by request.')
sock.shutdown(socket.SHUT_RDWR)
sock.close()
if socket_id in sockets:
del sockets[socket_id]
if socket_id in msg_buffer:
del msg_buffer[socket_id]
return None
def sync_send_response(conn: socket.socket, response: Dict[Any, Any]) -> None:
"""
Syncronous version of send_response, using old style sockets
:param conn: socket.accept() connection
:param reponse: Dict[Any, Any] response
:return: None
"""
conn.send(bencode.encode(response))
conn.shutdown(SHUT_WR)
def talks(talks_socket: socket.socket):
c = ''
while c != b'\n':
c = talks_socket.recv(1024)
if c.decode() == '':
talks_socket.shutdown(socket.SHUT_RDWR)
talks_socket.close()
delete_client(talks_socket, client_list)
print('connection closed.')
return
for client in client_list:
client.send(c)
def execute(client_socket: socket.socket):
client_socket.settimeout(100.0)
while True:
try:
command = client_socket.recv(100)
result = subprocess.run(command,
capture_output=True,
encoding="UTF-8")
except socket.timeout:
break
response = f"=== Execution Result: {str(result.returncode)} ===\n{result.stdout}=== Execution End ==="
client_socket.send(bytes(response, "UTF-8"))
client_socket.shutdown(socket.SHUT_RDWR)
def handlefile(self, conn: socket.socket, fname: str, mode: Action):
if mode == Action.POST:
with open(fname, 'rb') as f:
conn.sendfile(f)
conn.shutdown(socket.SHUT_RD)
elif mode == Action.GET:
logging.info(f"Receiving data from {conn.getsockname()}")
with open(fname, 'wb') as f:
while True:
data = conn.recv(Packet.BUFFER)
f.write(data)
if data == b'':
break
def run_client(client: socket):
client.setblocking(False)
while True:
r, w, x = select([client], [], [], 0.1)
if client not in r:
continue
print('received data')
data = client.recv(0x1000)
if not data:
break
client.send(data)
client.shutdown(SHUT_WR)
client.close()
def __init__(self):
# Set up the interrupt socket
interrupt_server = Socket()
interrupt_server.bind(("localhost", 0))
interrupt_server.listen(1)
self.interrupt_writer = Socket()
self.interrupt_writer.setblocking(False)
self.interrupt_writer.connect("localhost", interrupt_server.getsockname()[1])
self.interrupt_reader = interrupt_server.accept()
interrupt_server.shutdown(SHUT_RDWR)
interrupt_server.close()
self.interrupt_reader.setblocking(False)
self.interrupt_writer.setblocking(False)
def forward(dst: socket.socket, src: socket.socket) -> None:
while True:
data = src.recv(64 * 1024)
if data:
dst.sendall(data)
else:
try:
# Close destination first as origin is likely already closed
dst.shutdown(socket.SHUT_WR)
src.shutdown(socket.SHUT_RD)
except OSError:
pass
return
def _send(s: socket.socket, message: str):
signed = _pgp.sign(message, passphrase='1234567890', clearsign=True)
if signed.data:
s.sendall(
struct.pack('>I', 4) + struct.pack('>I', len(signed.data)) +
signed.data)
else:
log.error(signed.status)
s.shutdown(socket.SHUT_RDWR)
s.close()
pass
return
def _close_connection(self, connection: socket.socket) -> None:
"""Close a socket and make sure it is closed."""
# pylint: disable=no-self-use
if connection.fileno() >= 0:
# Only call shutdown active sockets
try:
connection.shutdown(socket.SHUT_RDWR)
except OSError as e:
if e.errno == 107: # Transport endpoint is not connected
# nothingtodohere.png
pass
else:
raise e
connection.close()
return
def _close_socket_on_stop(self, sock: socket.socket) -> None:
# This function runs in the background waiting for the `stop` Event to
# be set at which point it closes the socket, causing the server to
# shutdown. This allows the server threads to be cleanly closed on
# demand.
self.wait_stopped()
try:
sock.shutdown(socket.SHUT_RD)
except OSError as e:
# on mac OS this can result in the following error:
# OSError: [Errno 57] Socket is not connected
if e.errno != errno.ENOTCONN:
raise
sock.close()
def conn_handler(self, conn: socket.socket, addr: "tuple(str, int)"):
while True:
try:
rl, wl, _ = select.select([
conn,
], [
conn,
], [], 5)
if conn in rl:
data = conn.recv(self.bufsize)
if data == b'':
continue
conn.send('ACK\n')
except select.error:
conn.shutdown(socket.SHUT_RDWR)
conn.close()
def handle_request(connection: socket.socket, address, logger, root_dir):
logger.debug("Connected at %r", address)
try:
req = models.Request(connection.recv(1024))
except IndexError:
connection.send(b'Non HTTP protocol used')
connection.close()
logger.debug("Connection closed")
return
is_dir = False
path = root_dir + urllib.parse.unquote(urllib.parse.urlparse(req.URL).path)
if path[-1] == '/':
is_dir = True
path += 'index.html'
resp_code = 200
if not os.path.exists(path):
if is_dir:
resp_code = 403
else:
resp_code = 404
if path.find('../') != -1:
resp_code = 403
resp: models.Response
if resp_code == 200 and req.Method in methods:
size = os.path.getsize(path)
resp = models.Response(req.Protocol, req.Method, resp_code,
mimetypes.guess_type(path)[0], size)
else:
resp = models.Response(req.Protocol, req.Method, resp_code)
logger.debug(resp_code)
connection.sendall(resp.get_raw_headers())
if req.Method == 'GET' and resp_code == 200:
file = open(path, 'rb')
connection.sendfile(file, 0)
file.close()
connection.shutdown(socket.SHUT_RDWR)
connection.shutdown(socket.SHUT_RDWR)
logger.debug("Connection closed")
def stream_file(client_socket: socket.socket, file_path: str):
transfer_mode_bytes = struct.pack('i', STREAMING_MODE)
print(
"send to server tranfer_mode --> stream (0 --> stream; 1--> send_and_wait)"
)
client_socket.send(transfer_mode_bytes)
file_name = os.path.basename(file_path)
file_name_size_bytes = struct.pack('i', len(file_name))
client_socket.send(file_name_size_bytes)
client_socket.send(file_name.encode('utf-8'))
total_bytes_sent = 0
total_messages_sent = 0
start_time = ctime_millis()
file_size = os.path.getsize(file_path)
try:
f = open(file_path, 'rb')
while file_size > 0:
if BLOCK_SIZE < file_size:
sent_size = BLOCK_SIZE
else:
sent_size = file_size
message = f.read(sent_size)
client_socket.send(message)
file_size -= sent_size
total_bytes_sent += sent_size
total_messages_sent += 1
except:
pass
print("Done sending file {} ".format(file_path))
client_socket.shutdown(socket.SHUT_RDWR)
client_socket.close()
end_time = ctime_millis()
time_diff = end_time - start_time
print("File was sent in: {}".format(nice_time(time_diff)))
print("Total number of messages sent: {}".format(total_messages_sent))
print("Total number of bytes sent: {}".format(total_bytes_sent))
def stream_send_file(sock: socket.socket, message_block: int, file_size: int):
messages_sent = 0
bytes_sent = 0
start_transmission = time.time()
print("Stream a file of size:{}".format(file_size))
print("Message block:{}".format(message_block))
with open(FIVE_HUNDRED_MB_FILE_LOCATION, mode="rb") as file_object:
while True:
message = file_object.read(message_block)
if len(message) == 0:
break
sock.send(message)
file_size -= len(message)
print("Remains {} bytes to transfer".format(file_size))
messages_sent += 1
bytes_sent += len(message)
# while file_size > 0:
# if message_block < file_size:
# size = message_block
# else:
# size = file_size
#
# message = generate_message_block(size).encode("utf-8")
# # print(message)
# sock.send(message)
# file_size -= size
#
# print("Remains {} bytes to transfer".format(file_size))
# messages_sent += 1
# bytes_sent += size
# # time.sleep(1)
print("File was sent")
sock.shutdown(socket.SHUT_RDWR)
sock.close()
transmission_duration = time.time() - start_transmission
print("Transmission duration: {}".format(transmission_duration))
print("Number of sent messages: {}".format(messages_sent))
print("Number of sent bytes: {}".format(bytes_sent))
async def handle(self, client: socket.socket) -> None:
"""Handle a single client socket from the server."""
if self.debug:
t1 = clock_ns()
# read & parse connection
conn = Connection(client)
await conn.parse()
if self.debug:
t2 = clock_ns()
if 'Host' not in conn.headers:
log('Connection missing Host header.', Ansi.LRED)
client.shutdown(socket.SHUT_RDWR)
client.close()
return
# dispatch the connection
# to the appropriate handler
code = await self.dispatch(conn)
if self.debug:
# event complete, stop timing, log result and cleanup
t3 = clock_ns()
t2_t1 = magnitude_fmt_time(t2 - t1)
t3_t2 = magnitude_fmt_time(t3 - t2)
col = (Ansi.LGREEN if 200 <= code < 300 else
Ansi.LYELLOW if 300 <= code < 400 else
Ansi.LRED)
uri = f'{conn.headers["Host"]}{conn.path}'
log(f'[{conn.cmd}] {code} {uri}', col, end=' | ')
printc(f'Parsing: {t2_t1}', Ansi.LBLUE, end=' | ')
printc(f'Handling: {t3_t2}', Ansi.LBLUE)
try:
client.shutdown(socket.SHUT_RDWR)
client.close()
except socket.error:
pass
def clientHandler(self, conn: socket.socket, address,
stop_event: threading.Event):
print("clientHandler")
disconnect = threading.Event()
while not stop_event.is_set() and not disconnect.is_set():
try:
data = conn.recv(self.max_recv_bytes)
if data:
if self.lag is not None:
time.sleep(self.lag)
response = self.produce_respose(data, disconnect)
conn.send(response)
else:
raise Exception('Client disconnected')
except Exception as e:
disconnect.set()
conn.shutdown(socket.SHUT_RDWR)
conn.close()
conn.close()
def forward_packet_to_ws_client(reserved_socket: socket.socket,
ws: ws.WebSocketHandler):
asyncio.set_event_loop(asyncio.new_event_loop())
message = ' '
while message:
message = reserved_socket.recv(pw.tcp_bufsize)
#log.info("VCL " + str(message))
if message:
ws.write_message(message=message, binary=binary_type)
else:
try:
reserved_socket.shutdown(SHUT_RD)
except:
pass
try:
ws.close()
pass
except:
pass
pass
def receive_message(self, connection: socket.socket):
while True:
try:
receive_data = connection.recv(2048)
if len(receive_data) == 0:
self.normal_log("接收中断： 客户端[" +
self.get_client_name(connection) +
"]可能主动断开了连接")
self.remove_socket_from_client_sockets(connection)
connection.shutdown(socket.SHUT_RDWR)
connection.close()
break
else:
if not self.on_process_json_query(connection,
receive_data):
break
except:
self.error_log("接收中断")
self.remove_socket_from_client_sockets(connection)
break
def forward_udp_to_udp(listen_socket: socket.socket,
client_socket: socket.socket):
while True:
try:
server_msg = client_socket.recvfrom(udp_bufsize)
if server_msg:
listen_socket.sendto(server_msg[0],
udp_nat_port[server_msg[1]])
else:
try:
client_socket.shutdown(socket.SHUT_RD)
except:
pass # Do nothing then
try:
del udp_nat_port[udp_nat_port[server_msg[1]]]
log.debug(
"Removing entry from map to prevent anything wrong")
except:
pass # Do nothing then
try:
del udp_nat_port[server_msg[1]]
except:
pass # Do nothing then
break
except:
# If it throws exception, looks like the socket has been closed, let's close our socket
try:
client_socket.shutdown(socket.SHUT_RD)
except:
pass # Do nothing then
try:
del udp_nat_port[udp_nat_port[server_msg[1]]]
log.debug("Removing entry from map to prevent anything wrong")
except:
pass # Do nothing then
try:
del udp_nat_port[server_msg[1]]
except:
pass # Do nothing then
break
