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)