def receive_message(sock: socket):
try:
# get the size of the message
# print("processing_request")
b = sock.recv(4)
# print("check for closed connection")
if not b:
# socket closed by Server
print("Socket closed by Server. Do a register!")
sock.close()
return None
size = int.from_bytes(bytes=b, byteorder='big', signed=False)
# get the message itself
data = sock.recv(size)
# decode the data
payload = data.decode('utf-8')
# convert the json string to a dict
payload_dict = json.loads(payload)
return payload_dict
except ConnectionResetError:
sock.close()
except json.decoder.JSONDecodeError:
# TODO: handle with malformed request (Exception thrown by json.loads(payload))
# one possible failure occurs if the size is wrong.
# The client is not able to receive any message, because it will not get the right size.
print("RECEIVED MSG WAS MALFORMED")
except socket.timeout:
# close connection if socket timed out
sock.close()
return {}
def deal_client(newSocket: socket, addr):
global queue_
status = False
while True:
sleep(1)
try:
if status and not queue_.empty():
submissionId_proId = queue_.get()
print(submissionId_proId)
newSocket.send(("judge|%s" % submissionId_proId).encode())
data = newSocket.recv(1024)
recv_data = data.decode()
if recv_data == 'gotten':
status = False
else:
queue_.put(submissionId_proId)
else:
newSocket.send('get_status'.encode())
data = newSocket.recv(1024)
recv_data = data.decode()
if recv_data == "ok":
status = True
print(addr, status)
except socket.error:
newSocket.close()
except Exception as e_:
newSocket.close()
print(e_)
def recv_data(app: str, sock: socket):
"""
Get response from socket with proper start/end headers
:app: Which application is receiving the data
:sock: Socket to pull data from
:return: String of data received
"""
logger = logging.getLogger(app)
data = ""
data_start = "-- DATA START --"
data_end = "-- DATA END --"
data_header = sock.recv(16)
if data_header.decode("utf-8") == data_start:
logger.debug("Getting response: [{}]".format(
data_header.decode("utf-8")))
else:
logger.error("Error with get response, aborting")
logger.error("data_header: [{}]".format(data_header.decode("utf-8")))
return None
while True:
data += sock.recv(1024).decode("utf-8")
if data.endswith(data_end):
# Strip "data_end" from data
data = data[:-len(data_end)]
logger.debug("Data received: [{}]".format(data))
return data
else:
logger.debug("Incomplete data received so far: [{]]".format(data))
return None
def recv_file(sock: socket, filename: str):
recieved = []
bytes_recieved = 0
while bytes_recieved < 4:
got = sock.recv(4 - bytes_recieved)
if got == b'':
print("Connection has been closed.")
return ""
recieved.append(got)
bytes_recieved += len(got)
message_size = int.from_bytes(b''.join(recieved), byteorder='big')
recieved.clear()
bytes_recieved = 0
while bytes_recieved < message_size:
got = sock.recv(message_size - bytes_recieved)
if got == b'':
print("Connection has been closed.")
return ""
recieved.append(got)
bytes_recieved += len(got)
with open(filename, 'wb') as file:
file.write(b''.join(recieved))
file.flush()
print("Got file {0}".format(filename))
def send_state(self, job_id: str, state: StateType, sock: socket):
syncaccept = SyncAccept.FromString(sock.recv())
if syncaccept.job_id != job_id:
raise Exception("Job ids do not match: {}/{}".format(
job_id, syncaccept.job_id))
inflight = 0
last_index = 0
total_size = state.get_state_size()
while last_index < total_size:
while inflight < syncaccept.max_inflight and last_index < total_size:
end_index = last_index + min(total_size - last_index,
syncaccept.chunk_size)
syncstate = SyncState()
syncstate.job_id = job_id
syncstate.rel_start_index = last_index
vec_to_pbvec(state.get_relative_range(last_index, end_index),
pbvec=syncstate.data)
inflight += 1
last_index = end_index
syncstate.done = last_index == total_size
sock.send(syncstate.SerializeToString())
# Overwrite syncaccept to allow live changes to inflight and chunk_size.
syncaccept = SyncAccept.FromString(sock.recv())
inflight -= 1
if syncaccept.job_id != job_id:
raise Exception("Job ids do not match: {}/{}".format(
job_id, syncaccept.job_id))
def recv_message(sock: socket) -> str:
recieved = []
bytes_recieved = 0
while bytes_recieved < 4:
got = sock.recv(4 - bytes_recieved)
if got == b'':
print("Connection has been closed.")
return ""
recieved.append(got)
bytes_recieved += len(got)
message_size = int.from_bytes(b''.join(recieved), byteorder='big')
recieved.clear()
bytes_recieved = 0
while bytes_recieved < message_size:
got = sock.recv(message_size - bytes_recieved)
if got == b'':
print("Connection has been closed.")
return ""
recieved.append(got)
bytes_recieved += len(got)
return b''.join(recieved).decode('utf-8')
def client_thread(conn: socket, addr):
question = json.dumps({
'hour': time.localtime().tm_hour + 3,
'minute': time.localtime().tm_min,
'nick': 'server',
'message': 'What\'s your name?'
})
conn.send(bytes(question, encoding='utf8'))
username = conn.recv(1024).decode("utf-8")
if len(username) == 0 or username[0:14] != token:
remove(curr_connection=conn)
conn.close()
greeting_message = "Welcome to the club " + username[14:]
greeting = json.dumps({
'hour': time.localtime().tm_hour + 3,
'minute': time.localtime().tm_min,
'nick': 'server',
'message': greeting_message
})
try:
conn.send(bytes(greeting, encoding='utf8'))
except Exception as e:
print("User not auth")
conn.close()
remove(conn)
broadcast_meeting(username=username[14:], connection=conn)
try:
while True:
message = conn.recv(1024).decode("utf-8")
auth(message=message)
if len(message) > 0:
message_to_send = json.dumps({
'hour':
time.localtime().tm_hour - 3,
'minute':
time.localtime().tm_min,
'nick':
username[14:],
'message':
message[14:]
})
print("cool")
broadcast(message_to_send, conn)
else:
conn.close()
remove(conn)
except ConnectionResetError:
print("Connection lost")
conn.close()
remove(conn)
except Exception as e:
print(str(e))
conn.close()
remove(conn)
def serve_client(self, sock: socket):
# Wait for desired state
self.logger.waiting_for_setup()
setup = StateSetup.FromString(sock.recv())
state_handle = self.make_state(setup)
self.logger.making_state(state_handle.state_handle, setup.n)
sock.send(state_handle.SerializeToString())
# Apply operations
running_job = True
try:
while running_job:
self.logger.waiting_for_operation(state_handle.state_handle)
op = WorkerOperation.FromString(sock.recv())
self.logger.running_operation(state_handle.state_handle, op)
returned_data = None
if op.HasField("close"):
running_job = False
else:
with self.pool_lock:
pool = self.job_pools[state_handle.state_handle]
returned_workers, returned_data = pool.send_op(op)
if returned_workers:
self.logger.returning_workers(
state_handle.state_handle, len(returned_workers))
with self.worker_lock:
self.free_workers.extend(returned_workers)
self.logger.done_running_operation(state_handle.state_handle,
op)
conf = WorkerConfirm()
conf.job_id = state_handle.state_handle
if returned_data:
conf.measure_result.CopyFrom(returned_data)
sock.send(conf.SerializeToString())
except IOError as e:
self.logger.log_error("Unknown exception: {}".format(e))
conf = WorkerConfirm()
conf.error_message = str(e)
try:
sock.send(conf.SerializeToString())
except IOError as e:
self.logger.log_error("Error sending error code: {}".format(e))
finally:
with self.pool_lock:
pool = self.job_pools[state_handle.state_handle]
returned_workers = pool.close(state_handle.state_handle)
self.logger.returning_workers(state_handle.state_handle,
len(returned_workers))
with self.worker_lock:
self.free_workers.extend(returned_workers)
self.logger.closing_state(state_handle.state_handle)
sock.close()
def tgs_rep(sock: socket, key_c_tgs: DesKey):
data_tgs = sock.recv(1024)
if b'Error' in data_tgs:
print(data_tgs.decode('utf-8'))
return None
st = sock.recv(1024)
data_tgs = key_c_tgs.decrypt(data_tgs)
data_tgs = json.loads(data_tgs)
return data_tgs, st
def listenClient(
client: socket, client_addr: tuple
): #слушаем входящие сообщения от клиента, при получении отправляем всем другим клиентам
global clients
try:
data = client.recv(1024)
client_nick = data.decode("utf-8")
print(
f"Клиент {client_nick} ({client_addr[0]}:{client_addr[1]}) подключился к серверу."
)
sendAll(f"{client_nick} подключился.", client)
except Exception as e:
print(
f"Клиент {client_addr[0]}:{client_addr[1]} не смог подключиться к серверу из-за ошибки \"{e}\"."
)
clients.remove(client)
client.close()
return
while True:
try:
data = client.recv(1024)
if not data:
print(
f"Клиент {client_nick} ({client_addr[0]}:{client_addr[1]}) отключился от сервера."
)
clients.remove(client)
client.close()
sendAll(f"{client_nick} отключился.")
return
try:
toSend = data.decode("utf-8")
toSend = f"{client_nick}: {toSend}"
print(toSend)
sendAll(toSend, client)
except UnicodeDecodeError:
print(
"\nОшибка расшифровки входящего сообщения (оно пришло не от клиента?).\n"
)
except ConnectionResetError:
print(
f"Клиент {client_nick} ({client_addr[0]}:{client_addr[1]}) отключился от сервера."
)
clients.remove(client)
client.close()
sendAll(f"{client_nick} отключился.")
return
except Exception as e:
print(
f"Произошла неизвестная ошибка: \"{e}\".\nПерезапустите сервер, когда интернет будет в порядке."
)
clients.remove(client)
client.close()
return
def receive_server_response(s: socket, response: HttpRequestInfo) -> list:
s.send(response.to_byte_array(response.to_http_string()))
received_data = s.recv(Constants.MAX_RECEIVE)
server_response = []
while len(received_data) > 0:
server_response.append(received_data)
received_data = s.recv(Constants.MAX_RECEIVE)
s.close()
return server_response
def RegisterListener(csocket: socket, port):
csocket.send(server_services['RegisterListener'])
resp = csocket.recv(1024)
if resp == server_services['RegisterListener']:
csocket.send(bytes(str(port), 'utf-8'))
response = csocket.recv(1024)
if response == b'OK':
return True
else:
return False
def recieve_message(client_socket: socket):
try:
message_header = client_socket.recv(HEADER_LEN)
if not len(message_header):
return False
message_length = int(message_header.decode("utf-8").strip())
return {
"header": message_header,
"data": client_socket.recv(message_length)
}
except:
return False
def GetPublicKey(username: str, csocket: socket):
try:
csocket.send(server_services['GetPublicKey'])
resp = csocket.recv(1024)
if resp == server_services['GetPublicKey']:
csocket.send(bytes(username, 'utf-8'))
key = csocket.recv(1024).decode(encoding='utf-8').split(';')
else:
key = 0, 0
except Exception:
return 0, 0
return int(key[0]), int(key[1])
def AI(s: socket, command: str, column_number: int) -> None:
'''receive actions from server'''
if command == 'A':
s.send(str('DROP ' + str(column_number) + '\r\n').encode(encoding = 'utf-8'))
c = s.recv(4096).decode(encoding = 'utf-8')
reply_A = s.recv(4096).decode(encoding = 'utf-8')
return reply_A
elif command == 'B':
s.send(str('POP ' + str(column_number) + '\r\n').encode(encoding = 'utf-8'))
c = s.recv(4096).decode(encoding = 'utf-8')
reply_B = s.recv(4096).decode(encoding = 'utf-8')
return reply_B
def receive_data_pickle(conn: socket):
"""
receive a data with header
:param conn: socket
:return: unpickle object (MessageType Enum, DATA)
"""
msg_length = conn.recv(HEADER).decode(
FORMAT) # get the length of the incoming msg
if msg_length:
msg_length = int(msg_length)
msg = conn.recv(msg_length) # adjust the buffer size
message_object = pickle.loads(msg)
return message_object
def as_rep(sock: socket, key_c: DesKey, tgt_path, data_path):
data = sock.recv(1024)
if b'Error' in data:
raise Exception(data.decode('utf-8')[7:])
data = key_c.decrypt(data)
data = json.loads(data)
# save key
with open(data_path, 'w') as jf:
json.dump(data, jf)
tgt = sock.recv(1024)
# save ticket
with open(tgt_path, 'wb') as f:
f.write(tgt)
return data, tgt
def handle_client(connection: socket, address):
print(f"[NEW CONNECTION ESTABLISHED] {address} connected")
connected = True
# while client has not free the thread, handle the session
while connected:
msg_length = connection.recv(HEADER).decode()
if msg_length: # in case we got any messages
msg_length = int(msg_length)
msg = connection.recv(msg_length).decode()
if msg == DISCONNECT_MESSAGE: # if the client has sent the disconnect message - free the thread
connected = False
print(f"[RECEIVED DATA] {address} sent {msg}")
# close the socket with this current client
connection.close()
def ascii_str_by_socket(sock: socket):
"""Messages are received through sock and converted into ascii equivalent strings using str_to_ascii_str, and sent back via sock
Args:
sock: socket
The socket connection by which communication with the
client is implemented (AF_INET, SOCK_STREAM)
Returns:
(none)
Raises:
(none)
"""
msg_out: str = ' '
msg_in: str = ' '
while True:
msg_in = sock.recv(DEFAULT_BUFFER_SIZE)
if (msg_in.decode(UTF_8) == END_OF_FILE):
break
print('[S]: Message received from client: \'{}\''.format(
msg_in.decode(UTF_8)))
msg_out = str_to_ascii_str(msg_in.decode(UTF_8), '_')
print('[S]: Message sending to client: \'{}\''.format(msg_out))
sock.send(msg_out.encode(UTF_8))
def prompt_username(self, sock: socket) -> str:
"""Get a unique username from the client."""
while True:
try:
data = sock.recv(self.buf_size)
except OSError as e:
logging.warning(f"Error: {e}")
return ""
# Decrypt and decode data
if (decrypted := aes_cipher.decrypt(data)) is None:
return ""
username = decrypted.decode("utf-8", "ignore")
# Verify username
if username in self.connections.keys():
message = f"{username} is already taken, choose another name."
broadcast_to_client(message, sock)
elif not username.isalnum() or len(username) > 8:
message = "Your name must be alphanumeric only\n"
message = message + "and no longer than 8 characters.\n"
message = message + "e.g, The3vil1"
broadcast_to_client(message, sock)
else:
return username
def listenServer(
serv: socket
): #слушаем входящие сообщения от сервера, которые приходят от него тогда, когда другой клиент что-то написал
while True:
try:
data = serv.recv(1024)
if not data:
print(
"\nОшибка подключения к серверу.\nПерезапустите клиент, когда интернет и сервер будут в порядке."
)
serv.close()
return
try:
print(data.decode("utf-8"))
except UnicodeDecodeError:
print(
"\nОшибка расшифровки входящего сообщения (оно пришло не от сервера?).\n"
)
except ConnectionResetError:
print(
"\nСервер отключился.\nПерезапустите клиент, когда сервер будет в порядке."
)
serv.close()
return
except Exception as e:
print(
f"\nПроизошла неизвестная ошибка: \"{e}\".\nПерезапустите клиент, когда интернет и сервер будут в порядке."
)
serv.close()
return
def recv_file(filename: str, conn: socket) -> None:
with open(filename, 'wb') as f:
while True:
data = conn.recv(1024)
if not data:
break
f.write(data)
def ascii_list_by_socket(sock: socket, lines: [str]) -> [str]:
"""Sends str from lines: [str] through client socket connection sock: socket and returns a new [str] with equivalent ascii-formatted strings
from lines, generated by a server program
Args:
sock: socket
The client socket connection by which communication with the
server is implemented (AF_INET, SOCK_STREAM)
lines: [str]
str elements parsed from an input file, using function file_to_list, that will be sent to a server via sock
Returns:
A [str] with ascii-formatted strings equivalent to the elements from within lines: [str]
Raises:
(none)
"""
msg_out: str = ' '
msg_in: str = ' '
output: [str] = []
for element in lines:
msg_out = element
print('[C]: Message sending to server: \'{}\''.format(msg_out))
sock.send(msg_out.encode(UTF_8))
msg_in = sock.recv(DEFAULT_BUFFER_SIZE)
print('[C]: Message received from server: \'{}\''.format(
msg_in.decode('utf-8')))
output.append(msg_in.decode(UTF_8))
return output
def recv(self, sock: socket, rip):
while not self.event.is_set():
data = sock.recv(1024) # recv默认是阻塞的
logging.info('{}{}'.format(rip, data.decode()))
# 迭代self.clients中所有建立连接的sock；并向它们发送消息
for socks in self.clients.values():
socks.send('ACK {}'.format(data.decode()).encode())
def crack_user(sock: socket) -> str:
# Define a list of common admin usernames.
common_usernames = [
'admin', 'Admin', 'admin1', 'admin2', 'admin3', 'user1', 'user2',
'root', 'default', 'new_user', 'some_user', 'new_admin',
'administrator', 'Administrator', 'superuser', 'super', 'su', 'alex',
'suser', 'rootuser', 'adminadmin', 'useruser', 'superadmin',
'username', 'username'
]
# Attempt to login via the specified socket with each of the common admin usernames.
for usr in common_usernames:
# Create a dictionary of the current credentials being tested.
credentials = {"login": usr, "password": "******"}
# Create a JSON string from the credentials, encode it and send it to the specified socket.
sock.send(dumps(credentials).encode())
# Decode the site's response, load a dictionary from that JSON string and retrieve the value paired with the
# 'result' key.
result = loads(sock.recv(1024).decode())['result']
# If the result is 'Wrong password!', the correct username was found.
if result == 'Wrong password!':
return usr
# If none of the common admin usernames are the correct one, raise an exception.
raise AssertionError('Unable to determine admin username.')
def event_enqueue(conn: socket, addr):
global link_status
with conn:
msg = pickle.loads(conn.recv(1024))
logger.debug("received event from %s", addr)
if isinstance(msg, message) and link_status[msg.sender]:
event_queue.put(msg.event)
def handle_reply(current_socket: socket, request: str) -> dict:
"""
Отправляет сообщение на сервер, получает и обрабатывает ответ
:param current_socket: сокет для общения с сервером
:param request: сформированный запрос на сервер
:return: ответ о проверке лабораторной работы
"""
logger.info("Sending request on server to check the lab...")
logger.debug("The request is: {request}".format(request=request))
current_socket.send(request.encode())
try:
reply_data: dict = json.loads(current_socket.recv(1024).decode())
logger.info("Got a reply from server!")
message_type: int = reply_data.pop('messageType')
if message_type == MessageType.WRONG_REQUEST.value:
raise SystemError(
"We've got problems: an error \n {error} \n occurred with a key '{key}'"
.format(error=reply_data['text'], key=reply_data['key']))
elif message_type == MessageType.SERVER_ERROR.value:
raise SystemError("Server has got a problem: {error}".format(
error=reply_data['errorMessage']))
elif message_type == MessageType.DEFAULT_ANSWER.value:
logger.debug("The lab was successfully checked, moving on..")
return reply_data
except TypeError as err:
raise TypeError(
"Error reading data from server: {error} \n with traceback {tb}".
format(error=err, tb=traceback.format_exc()))
def game_in_progress_loop(s: socket):
while True:
package = rp(s.recv(256))
request_type = package.get("rt")
message = package.get("msg")
if request_type == RT.start_turn.value: # Player start turn
print("msg from server: ", message)
coordinate = raw_input(": ")
while not valid_coordinate(coordinate=coordinate):
coordinate = raw_input(": ")
s.sendto(create_message(RT.send_coord.value, coordinate), ADDR)
elif request_type == RT.hit.value: # Player hit
draw_opponents_map(coordinate=coordinate, hit=True)
print("msg from server: ", message)
coordinate = raw_input(": ")
while not valid_coordinate(coordinate=coordinate):
coordinate = raw_input(": ")
s.sendto(create_message(RT.send_coord.value, coordinate), ADDR)
elif request_type == RT.miss.value: # Player missed
draw_opponents_map(coordinate=coordinate, hit=False)
print("msg from server: ", message)
elif request_type == RT.msg.value: # Message from server
print("msg from server: ", message)
s.close()
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 sock_readline(sock: socket, timeout_left: float):
"""Read a line from a socket, respecting timeout_left. Returns a string on success, or None on timeout."""
if sock is None:
try:
return input("C:")
except EOFError:
return None # This way we can test timeouts by sending ^D.
else:
try:
select([sock], [], [], timeout_left)
c = ""
ret = ""
while c != "\n":
ret += c
c = str(sock.recv(1), "utf-8")
if len(
c
) == 0: # Nothing left in the buffer, but we didn't get a newline.
return None
return ret
except BlockingIOError: # The recv() would have blocked, i.e. no data.
return None
except ValueError: # Generally, timeout was 0 or negative.
return None
except:
raise ConnectionError
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 handleClient(clientSocket:socket):
received = clientSocket.recv(1024)
print('Received data', received)
clientSocket.send('hello')
clientSocket.close()
def receive_payload(sock: socket):
data = str(sock.recv(1024), "utf-8")
if data is not None and len(data) > 0:
received = decode_from_json(data)
return build_payload(received)
