def message_handle(server: classmethod, client: socket):
"""
socketBlh的消息处理.
"""
global num_online_client, online_client
client_id = ''
client.sendall("连接服务器成功!".encode(encoding='utf8'))
while True:
buff = str(client.recv(1024), encoding='UTF-8')
if '[id]:' in buff:
tmp = buff.split(':')
client_id = str(tmp[1])
dm_logger(server, f'客户端上线! 客户端id: {client_id}\n')
online_client.append(client_id)
num_online_client += 1
time.sleep(0.5)
dm_logger(server, f'目前在线数量: {num_online_client}\n')
elif len(buff) == 0:
try:
g_conn_pool.remove(client)
online_client.remove(client_id)
client.close()
except:
pass
dm_logger(server, '有一个客户端下线了! 客户端id: {0}\n'.format(client_id))
try:
online_client.remove(client_id)
except:
pass
num_online_client -= 1
break
else:
dm_logger(server, "客户端消息: {0}\n".format(buff))
def make_play(self, s: socket, invitation: str):
proposed_play = input(invitation)
play_ord = ord(proposed_play)
s.sendall(play_ord.to_bytes(1, 'big'))
return int(proposed_play)
def handshake(s: socket, game_id: int) -> int:
f"""
Sends the handshake for rps.
:param game_id: {int}
:param s: {socket}
:return: {int} uid of player
"""
# Start with 4 'empty' bytes
empty_byte = 0
confirmation = 1
rule_set = 1
payload_length = 2
protocol_version = 1
packet = [
empty_byte, empty_byte, empty_byte, empty_byte, confirmation, rule_set,
payload_length, protocol_version, game_id
]
s.sendall(bytes(packet))
uid = get_uid(s)
return uid
def read(s: socket):
while True:
x: str = input("> ").ljust(4, '0')
s.sendall(x.encode())
if x[0] == 'q':
running = False
break
def button_click(self, gas:str, tempers:list, heattimes:list, staytimes:list, sock:socket, process_info:tuple):
count = len(tempers)
local_tempers = list(map(str, tempers))
local_heattimes = list(map(str, heattimes))
local_staytimes = list(map(str, staytimes))
heattime = ' '.join(local_heattimes)
staytime = ' '.join(local_staytimes)
temper = ' '.join(local_tempers)
if self.now_start_button:
msg = self.base_opt + ' ' + str(count) + ' ' + temper + ' ' + heattime + ' ' + staytime + ' ' + gas
else:
msg = self.base_opt
msg_byte = msg.encode()
sock.sendall(msg_byte)
loader = loadingGif.LoadingGif()
recv_msg = sock.recv(1024).decode()
loader.stopAnimation()
if self.now_start_button and not self.is_process_wokring:
process_info["id"], process_info["starttime"] = recv_msg.split('+')
self.custom_toggle()
for elem in self.disable_list:
elem.setEnabled(not self.now_start_button)
for elem in self.able_list:
elem.setEnabled(self.now_start_button)
def change_admin_password(client_socket: socket, user_info: dict,
msg: dict) -> dict:
user_info = Scripts.AdminRequests.change_self_password(
msg["Content"], user_info)
client_socket.sendall(json.dumps(Scripts.Responses.fine()).encode())
client_socket.close()
Scripts.LogWriter.admin_password_changed(msg["Time"])
return user_info
def _socks_sub_negotiation_send_chosen_method(self, socket_client: socket, method: SocksMethod) -> bool:
chosen_method_packet = b'\x05' + method.value
try:
socket_client.sendall(chosen_method_packet)
except socket.error as err:
logger.error(str(self), "Socket error while trying to communicate with client: \"{}\".".format(err))
return False
return True
def send_to_server(sock: socket, s: str):
if sock is None:
print(s)
else:
try:
sock.sendall(bytes(s + "\n", "utf-8"))
except:
raise ConnectionError
def process_server_response(sock: socket, message_code: int):
if message_code in INVITE_TO_PLAY:
if message_code == 88:
print(MESSAGES[3])
play = input(MESSAGES[message_code])
play_ord = ord(play)
print("Sending", play_ord)
sock.sendall(play_ord.to_bytes(1, 'big'))
def sendTcpMsg(sock: socket, msg: bytes):
sock.sendall(msg)
response = b""
while True:
chunk = sock.recv(4096)
if not chunk:
break
response += chunk
return response
def send_data_to_server(client_socket, server_socket: socket):
try:
while True:
client_data = client_socket.recv(BUFFER_SIZE)
server_socket.sendall(client_data)
if len(client_data) < 1:
break
except Exception as e:
print(e)
def recv_file(self, conn: socket, d: dict) -> None:
path = os.path.join(self.dir_files, d['FILENAME'])
conn.sendall(pickle.dumps("OK"))
with open(d['FILENAME'], 'wb') as f:
for _ in range(0, d['FILESIZE'], self.BUFFER_SIZE):
f.write(conn.recv(self.BUFFER_SIZE))
conn.sendall(pickle.dumps("DONE"))
def send_data_pickle(conn: socket, data: tuple):
"""
Send data turned into pickle to conn
:param conn: socket
:param data: data to send (MessageType Enum, DATA)
:return: None
"""
data_pickle = pickle.dumps(data)
conn.send(make_header(data_pickle))
conn.sendall(data_pickle)
def receive(s: socket):
s.sendall('readd'.encode())
res = ''
while True:
bytes_read = s.recv(1)
if ord(bytes_read) == 0:
break
res += bytes_read.decode()
return res
def connection_handler(connection: socket):
while True:
message = connection.recv(128)
if not message:
print(" !! Goodbye, a client went away...")
break
print("Client sent: " + message.decode("utf-8"))
connection.sendall(message)
def _socks_request_send_reply(self, socket_client: socket, reply: SocksReply) -> bool:
reply_packet = b'\x05' + reply.value + b'\x00' + SocksAddressType.IPV4.value + \
b'\x00' + b'\x00' + b'\x00' + b'\x00' + \
b'\x00' + b'\x00'
try:
socket_client.sendall(reply_packet)
except socket.error as err:
logger.error(str(self), "Socket error while trying to communicate with client: \"{}\".".format(err))
return False
return True
def recv_str(self, conn: socket) -> None:
conn.sendall(pickle.dumps("OK"))
while True:
message = conn.recv(self.BUFFER_SIZE)
if not message:
break
message_dec = message.decode()
conn.sendall(pickle.dumps("DONE"))
def send_rel(sock: socket, rel: list):
num_elements = len(rel) * (len(rel[0]) if rel else 0)
sock.sendall(struct.pack("i", num_elements))
as_bytes = bytearray(num_elements * INT_SIZE)
idx = 0
for row in rel:
for el in row:
struct.pack_into("i", as_bytes, idx, el)
idx += INT_SIZE
sock.sendall(as_bytes)
def listen_ws_and_forward_to_socket(client: socket, ws: websocket.WebSocket):
message = ' '
while message:
message = ws.recv()
if message:
# log.info(message)
client.sendall(message)
else:
#log.info("Dong cmn socket roi")
shutdown_socket(client)
def send_receive(s: socket, cmd: str) -> str:
s.sendall((cmd + (cmd[-2:] == '\n' and '' or '\n')).encode())
_buffer = ''
while True:
data = s.recv(CHUNK_LENGTH)
_buffer += data.decode()
if len(data) > CHUNK_LENGTH:
continue
else:
return parse_response(_buffer)
def send_payload(sock: socket, payload: PayloadEncoder or PayloadEventMessages, address=None):
if sock is None or sock._closed or payload is None:
print("[x] Unable to send payload [Payload %s, Socket %s]" % (payload, socket))
return
if isinstance(payload, PayloadEventMessages):
payload = payload.value
if address is None:
sock.sendall(encode_to_json(payload.content()).encode("utf-8"))
else:
sock.sendto(encode_to_json(payload.content()).encode("utf-8"), address)
def _rec_connect(self, conn: socket, public_key, addr):
self.crypto.save_conn_RSAkey(public_key)
session_key = self.crypto.generate_session_key()
public_key = self.crypto.import_pub_key(public_key)
enc_session_key = self.crypto.encryptRSA(session_key, public_key)
conn.sendall(enc_session_key)
self.connecting = True
self.connecting_addr = addr
time.sleep(2)
self.add_text_toshow(f"{addr[0]}:{addr[1]} was connected")
def send_message(sock: socket, secret: int) -> None:
while True:
msg = input("> ")
encrypt_client = AESCipher(msg, str(secret)).encrypt()
try:
sock.sendall(encrypt_client.encode("utf-8"))
except socket.error:
print("[ ERROR: Could not send message ]")
break
print(f"[ Connection closed ]\n")
sock.close()
def send_to_bob(s: socket, message: str, wait_for_reply: bool = True):
"""
Sends the encoded message to the server
:param s: the socket connecting to Bob
:param message: message as a string
:param wait_for_reply: boolean indicating if alice should expect a reply from Bob.
:return: Returns the message in bytes from the server if successful
"""
s.sendall(pack_message(message))
if wait_for_reply:
return receive_from_bob(s)
else:
return ''
def get_and_forward_to_client(client: socket, id: str):
while True:
try:
r = requests.get(URL + "/" + (encode(id)),
timeout=1200,
proxies=proxyDict)
if r.status_code == 200:
## log.info("Kaka " + str(r.content))
client.sendall(r.content)
else:
shutdown_socket(client)
return
except:
pass
def send_payload(sock: socket,
payload: PayloadEncoder or PayloadEventMessages,
address=None):
if sock is None or sock._closed or payload is None:
print("[x] Unable to send payload [Payload %s, Socket %s]" %
(payload, socket))
return
if isinstance(payload, PayloadEventMessages):
payload = payload.value
if address is None:
sock.sendall(encode_to_json(payload.to_dict()).encode("utf-8"))
else:
sock.sendto(encode_to_json(payload.to_dict()).encode("utf-8"), address)
def send_receive(s: socket, cmd: str) -> str:
cmd = ' '.join(list(map(clear_command, cmd.split('\n')))) + '\n'
s.sendall(cmd.encode())
_buffer = ''
while True:
data = s.recv(CHUNK_LENGTH)
decoded_data = data.decode()
_buffer += decoded_data
if '...' in decoded_data:
break
return parse_response(_buffer)
def make_play(self, s: socket, invitation: str):
proposed_play = -1
while 0 >= proposed_play >= 8:
proposed_play = input(invitation)
if not self.is_play_valid(proposed_play):
print("Invalid play")
proposed_play = -1
play_ord = ord(
proposed_play
) # This might need to change to ints instead of ASCII ordinal values
s.sendall(play_ord.to_bytes(1, 'big'))
return int(proposed_play)
def send_hash(self, conn: socket, addr: tuple):
self.lock.acquire(timeout=self.lock_timeout)
print(
f"{datetime.now()} - {self.name} - Client {addr} - Send File Hash - sending..."
)
self.lock.release()
# 发送切片文件的MD5
conn.sendall(json.dumps(list(self.file_parts.keys())).encode('utf-8'))
conn.close()
self.lock.acquire(timeout=self.lock_timeout)
print(
f"{datetime.now()} - {self.name} - Client {addr} - Send File Hash - finished"
)
self.lock.release()
def message_handle(client: socket):
"""
消息处理
:param client:
:return:
"""
client.sendall('链接服务器成功'.encode(encoding='utf-8'))
while True:
bytes = client.recv(1024)
print('来自客户端消息：', bytes.decode(encoding='utf-8'))
if len(bytes) == 0:
client.close()
socket_server_pool.remove(client)
print('有一个客户端下线了')
pass
pass
def __query_by_session_id(self, session_id: int, given_session_id: int,
connection: socket) -> bytes:
"""
Gets all results of session
:param session_id: id of session to look for
:param given_session_id: id of session requesting query
:param connection: connection socket
:return: answer for the client
"""
utils.log('querying by session_id: ' + str(session_id) + ' for ' +
str(given_session_id))
if session_id != given_session_id:
return self.__error(Error.UNAUTHORISED, Mode.QUERY_BY_SESSION_ID,
session_id)
if session_id not in self.results_storage:
return self.__error(Error.NOT_EXISTING_DATA,
Mode.QUERY_BY_SESSION_ID)
if not self.results_storage[session_id]:
return self.__error(Error.NOT_EXISTING_DATA,
Mode.QUERY_BY_SESSION_ID)
results = self.results_storage[session_id]
answer: List[Datagram] = list()
for result_id, result in results.items():
answer.append(
Datagram(Status.OK,
Mode.QUERY_BY_SESSION_ID,
session_id,
operation=result[0],
a=result[1],
b=result[2],
result=result[4],
result_id=result_id,
last=False))
# send all except last results to the client
for i in range(0, len(answer) - 1):
connection.sendall(answer[i].get_bytes())
# return last result to send
answer[len(answer) - 1].last = True
return answer[len(answer) - 1].get_bytes()
