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()