def accept_connection(sock: socket):
"""
Accepts a connection given a socket object. If the initial connection
times out, (None, None) is returned. If the connection to get the clients
name times out after MAX_RETIRES, then the connection is aborted.
Parameters:
sock (socket): The socket to connect to
Returns:
(socket, tuple): A tuple containing the socket object
and address of the connecting process. Or None, None
if the connection times out.
"""
try:
conn, addr = sock.accept()
except socket.timeout:
return (None, None)
retries = 0
while True:
try:
client_name = mp.recv_msg_protocol(conn)
client_list.addToList(conn, client_name, DEFAULT_ROOM)
send_help(conn)
return (conn, addr)
except socket.timeout:
if retries < MAX_RETIRES:
retries += 1
print('Retrying...')
else:
# If the user takes too long to respond with a name
# close the connection
print(f"[CLOSING] {addr} took too long to respond")
conn.close()
return (None, None)
def infinite_stream_txt_file_over_socket(file_path: str, soc: socket) -> None:
"""
This function will send text file contents row by row over provided socket
I've made it to test pysparks wordcount
:param file_path:
:param soc:
:return:
"""
while True:
print('\nListening for a client at', host, port)
conn, addr = soc.accept()
print('\nConnected by', addr)
try:
print('\nReading file...\n')
with open(file_path) as f:
for line in f:
send_line_via_connection(line, conn)
sleep(0.02)
print('End Of Stream.')
except socket.error:
print('Error Occurred.\n\nClient disconnected.\n')
except OSError:
destroy_socket(conn, soc)
soc = setup_socket(host, port)
except KeyboardInterrupt:
destroy_socket(conn, soc)
def create_connection(sock: socket, port: int, host: str) -> socket:
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # solution for: "socket.error: [Errno 98] Address already in use"
sock.bind((host, port))
sock.listen(5)
connection, client_address = sock.accept() # accept connection returns tuple
print("Got connection from ", client_address)
return connection
def handleClient(sock: socket):
workersock, clientaddr = sock.accept()
log(f"Connection from {clientaddr}")
initial = workersock.recv(1024)
log(f"Message from {clientaddr}: {initial.decode()}")
file = open("home.html", 'r')
page = file.read()
#print(page)
workersock.send(
str(http_classes.myResponse("OK", 200, "HTTP/1.1", page)).encode())
# workersock.send(str(http_classes.ok).encode())
# workersock.send(str(http_classes.htmltype).encode())
# workersock.send(b'\n')
# workersock.sendfile(page)
log("Sent file: homepage.html")
# begin page handler here
log(f"Working with client {clientaddr}")
while True:
req = parseHttp(workersock, clientaddr)
def on_accept(self, sock: socket):
print("getting data from {0}".format(sock.fileno()))
conn, addr = sock.accept()
print('accepted connection from {0}'.format(addr))
conn.setblocking(False)
# set it state for Any in coming message
# register this new conn to read event
self.selector.register(fileobj=conn, events=selectors.EVENT_READ)
def start(proxy_socket: socket):
cache = Cache()
try:
while True:
client, address = proxy_socket.accept()
threading.Thread(target=client_handler,
args=(client, address, cache)).start()
except KeyboardInterrupt:
proxy_socket.close()
def start_server(server: socket, client_list: list):
print("Started listening....")
server.listen(5)
while True:
conn, addr = server.accept()
print("\nNew connection from: " + str(addr))
client_list.append(conn)
_is_running.append(False)
print("reverse_tcp>", end='', flush=True)
def __accept_wrapper(self, sock: socket):
connection, address = sock.accept() # Should be ready to read
connection.setblocking(False)
data = types.SimpleNamespace(addr=address, inb=b'', outb=b'')
events = selectors.EVENT_READ | selectors.EVENT_WRITE
self.__selector.register(connection, events, data=data)
print("Connection accepted from:", address)
# Send info to client about successful connection
connection.sendall(b'200:Connection established.')
def serverMonitoring(conct: socket):
global end
global command
global clients
kills = 0
while end != False:
try:
client, address = conct.accept()
obj = ClientCo()
tmp = Thread(target=clientThread, args=[client, address, obj])
tmp.start()
obj.setThread(tmp)
clients.append(obj)
except:
continue
sys.exit(0)
def downlisten(socket: socket, path: str):
childsocket, childsaddr = socket.accept()
head = {}
head['name'] = os.path.basename(path)
head['size'] = os.path.getsize(path)
head_json = json.dumps(head).encode()
head_len = struct.pack('i', len(head_json))
childsocket.send(head_len)
childsocket.send(head_json)
with open(path, 'rb') as f:
while True:
sen = f.read(1024)
if len(sen) == 0:
break
childsocket.send(sen)
childsocket.close()
socket.close()
def do_socket_logic(proxy_socket: socket, proxy_port_number):
"""
Example function for some helper logic, in case you
want to be tidy and avoid stuffing the main function.
Feel free to delete this function.
"""
proxy_socket.bind(("127.0.0.1", int(proxy_port_number)))
proxy_socket.listen(10)
cache = {}
while True:
client_socket, address = proxy_socket.accept()
print(f"Started conn with {address}")
start_new_thread(handle_client, (client_socket, cache, address))
proxy_socket.close()
pass
def accept_connections(sock: socket):
'''
Loop forever, accepting connections until program is manually terminated
:param sock: The socket to bind
:return:
'''
socket_id = 1
while True:
connection, remote_address = sock.accept()
msg = "Accepted a new connection from {}:{}".format(
remote_address[0], remote_address[1])
log.info(msg)
print(msg)
receiver = ThreadedReceiver(connection, remote_address, socket_id)
receiver.start()
socket_id += 1
def read_event(s: socket):
"""读事件处理流程"""
# 如果是新的套接字是 主连接的套接字
if s is sk:
connection, client_info = s.accept() # 该套接字监控其他连接
connection.setblocking(False) # 改成非阻塞
inputs.append(connection) # 添加该连接到监控
message[connection] = queue.Queue() # 给它准备好要发送的数据队列
else:
# 与已发送数据的客户端建立连接 获取已发送数据
data = s.recv(1024)
if data:
message[s].put(data) # 处理接收到的信息
if s not in outputs:
outputs.append(s)
else:
# 没有数据关闭连接
socket_close(s)
def _accept_client_loop(self, server_socket: socket):
logger.info(str(self), "Ready to receive requests.")
while not self.STOP:
if threading.active_count() > self.max_threads:
sleep(5) # It means that the thread will take 5 seconds maximum to return
continue
try:
client_socket, _ = server_socket.accept()
client_socket.setblocking(True)
except socket.timeout:
continue
except socket.error:
continue
except TypeError as err:
logger.error(str(self), "Error: \"{}\".".format(err))
return
exchange_thread = threading.Thread(target=self.handle_request, args=(client_socket,))
exchange_thread.start()
server_socket.close()
logger.info(str(self), "Stopping server.")
def listen_from_client(socket_name: socket):
print(socket_name)
try:
(client_socket, client_address) = socket_name.accept()
print("get connect: " + str(client_socket.getpeername()))
print("socketserver timeout: " + str(client_socket.gettimeout()))
client_socket.settimeout(10)
try:
data = client_socket.recv(4096)
if len(data) is not 0:
print("get data from[" + str(client_socket.getpeername) +
"]: " + str(data))
except TimeoutError as te:
print(te)
client_socket.close()
# data = "4D504F53010101007B22737461747573223A223030222C226D7367223A226C6F67696E2073756363657373222C" \
# "2264617461223A5B7B22736E223A223030323130313031303031313030303030303037227D2C7B22736E223A22" \
# "3030323130313031303031313030303030303038227D2C7B22736E223A22303032313031303130303131303030" \
# "3030303133227D2C7B22736E223A223030323130313031303031313030303030303233227D2C7B22736E223A22" \
# "3030323130313031303031313030303030303239227D2C7B22736E223A22303032313031303130303131303030" \
# "3030303837227D2C7B22736E223A223030323130313031303430313030303030323030227D5D7D4A00"
# client_socket.send(bytes.fromhex(data))
# client_socket.send(bytes("\nI get it!", "utf-8"))
# sleep(5)
send_by_random(client_socket)
# no_response()
try:
client_socket.close()
except Exception as e:
traceback.print_exc()
print(e)
except InterruptedError as ie:
traceback.print_exc()
print(ie)
def ListenThread(self, sock: socket, myusername, ssocket):
while 1:
conn, addr = sock.accept()
service = conn.recv(1024)
if service == b'SWAP':
conn.send(b'SWAP')
client_name = conn.recv(1024).decode(encoding='utf-8')
partner_public_mas = GetPublicKey(client_name, ssocket)
partner_public = Point(partner_public_mas[0], partner_public_mas[1])
secret = get_secret(int(self.__private_key), partner_public)
msgtext = myusername + ', your shared key with %s is:\n' % client_name + str(secret.x)
self.ShowDialog(msgtext)
conn.close()
elif service == b'MSG':
conn.send(b'MSG')
params = conn.recv(4096)
conn.send(b'Ok')
c_text = conn.recv(1024)
msg, sender = FormatRecievedMessageFtomBytes(params, c_text, int(self.__private_key))
text_to_show = myusername + ', you have recieved message from %s:\n %s' % (sender, msg)
self.ShowDialog(text_to_show)
conn.close()
print('Procedure ends')
def server_communicate(s: socket):
client, addr = s.accept()
serv_log.info("Получен запрос на соединение от %s" % str(addr))
msg_from_client = recv_message(client, addr)
server_response(msg_from_client, client)
def accept(s: socket):
n = s.accept()
IO._setupsocket(n[0])
return n
def accept_client_conn(serv_sock: socket, cid: int) -> socket:
client_sock, client_addr = serv_sock.accept()
print(f'Client #{cid} connected ' f'{client_addr[0]}:{client_addr[1]}')
return client_sock
def send_msg(s: socket): # отправляет ответ клиенту;
client, adr = s.accept()
msg_from_client = get_msg(client)
resp_from_server(msg_from_client, client)
