def send_push(self, message, badge, data, socket): payload = {} aps = {} aps["alert"] = message aps["badge"] = badge payload["aps"] = aps if type(data) is dict: payload.update(data) else: payload["data"] = data token = binascii.unhexlify(self.devicetoken) payloadstr = json.dumps(payload, separators=(',',':')) payloadLen = len(payloadstr) # struct.pack format string breakdown: # ! - big-endian byte order for network transmission # c - char for command # H - 2 byte device token length (value should be 32) # 32s - 32 byte device token string # H - Lenth of payload # %ds - payload with length payloadLen fmt = "!cH32sH%ds" % payloadLen command = '\x00' # 0 for simple format, 1 for extended msg = struct.pack(fmt, command, 32, token, payloadLen, payloadstr) if len(msg) > 256: raise Exception('Message payload is too large') socket.send(msg)
def send(event=None): msg = chat.getMessage() signedText = encrypt_msg(socket, msg) socket.send(bytes(signedText, 'utf8')) if msg == 'q': chat.close()
def processClientMessage(self, socket, tokens): if tokens[0] == 'LOGOUT': self.logoutPlayer(socket) elif self.state == 'REGISTRATION' or self.state == 'RESTART': print "Registration state." if tokens[0] == 'LOGIN': print 'Login: '******'REGISTRATION': self.playGame(0, -1) else: # restarting interrupted game scores = self.gameState.currentScores() for i in range(self.numPlayers): self.players[i].score = scores[i] self.playGame(self.gameState.numHands(), self.gameState.nextDealer()) raise 'End server' else: print 'Error' socket.send('ERROR Unknown\n')
def get_html(self, socket, info): if info == "/": filename = self.html + '/index.html' else: filename = self.html + info # 打开网页 try: f = open(filename, "rb") except: response_headers = "HTTP/1.1 404 NOT FOUND\r\n" response_headers += "Content-Type:text/html\r\n" response_headers += "\r\n" response_content = "<h1> Sorry....</h1>" self.response = (response_headers + response_content).encode() else: response_content = f.read() response_headers = "HTTP/1.1 200 OK\r\n" response_headers += "Content-Type:text/html\r\n" # 必不可少 否则图片无法打开 response_headers += f"Content-Length:{len(response_content)}\r\n" response_headers += "\r\n" self.response = response_headers.encode() + response_content finally: # 将http响应发送给浏览器 socket.send(self.response)
def send_packet(source_ip, source_mac, destination_ip, destination_mac, msg, socket): IP_header = source_ip + destination_ip ethernet_header = source_mac + destination_mac #making the packet and sending it packet = IP_header + ethernet_header + msg socket.send(bytes(packet, "utf8"))
def handle_client(client_socket, address): global exchanged connected = True while connected: if len(client_sockets) == 2 and not exchanged: for socket in client_sockets: if client_sockets.index(socket) == 0: socket.send(str(public_keys[1]).encode(FORMAT)) else: socket.send(str(public_keys[0]).encode(FORMAT)) exchanged = True msg_length = client_socket.recv(HEADER).decode(FORMAT) if msg_length: msg_length = int(msg_length) msg = client_socket.recv(msg_length).decode(FORMAT) if msg == DISCONNECT_MESSAGE: connected = False exchanged = False update_clients(client_socket, address, msg) else: update_clients(client_socket, address, str(msg)) print(f'{address} disconnected.') del public_keys[client_sockets.index(client_socket)] client_sockets.remove(client_socket) client_socket.close()
def returnResponse (response, socket) : """ send bytes over a socket response the bytes to send socket the client socket to use """ socket.send(response)
def send_push(self, message, badge, data, socket): payload = {} aps = {} aps["alert"] = message aps["badge"] = badge payload["aps"] = aps if type(data) is dict: payload.update(data) else: payload["data"] = data token = binascii.unhexlify(self.devicetoken) payloadstr = json.dumps(payload, separators=(',', ':')) payloadLen = len(payloadstr) # struct.pack format string breakdown: # ! - big-endian byte order for network transmission # c - char for command # H - 2 byte device token length (value should be 32) # 32s - 32 byte device token string # H - Lenth of payload # %ds - payload with length payloadLen fmt = "!cH32sH%ds" % payloadLen command = '\x00' # 0 for simple format, 1 for extended msg = struct.pack(fmt, command, 32, token, payloadLen, payloadstr) if len(msg) > 256: raise Exception('Message payload is too large') socket.send(msg)
def processClientMessage(self, socket, tokens): if tokens[0] == 'LOGOUT': self.logoutPlayer(socket) elif self.state == 'REGISTRATION' or self.state == 'RESTART': print "Registration state." if tokens[0] == 'LOGIN': print 'Login: '******'REGISTRATION': self.playGame(0, -1) else: # restarting interrupted game scores = self.gameState.currentScores() for i in range(self.numPlayers): self.players[i].score = scores[i] self.playGame( self.gameState.numHands(), self.gameState.nextDealer()) raise 'End server' else: print 'Error' socket.send('ERROR Unknown\n')
def dynamicHTML(socket, data): page = '''\ <!doctype html> <html> <head> <b>Welcome <br> <br> </head> <body> <form method = "post" action = ""http://ocelot.aul.fiu.edu:45681""> <b> Enter file/directory name:<input type = "text" name = "filename" value = ""> <br> <input type = "submit" value = "Submit"> </form> <b> <br> <br> Enter . and submit to re-display the current directory. <br> Enter .. and submit to display the parent directory. <hr> <pre> {0} </pre> </body> </html> '''.format(data) headerline1 = "HTTP/1.1 200 OK\r\n" headerline2 = "Content-Length: " + str(len(page)) + "\r\n" headerline3 = "Content-Type: text/html\r\n\r\n" response = headerline1 + headerline2 + headerline3 + page socket.send(response)
def list(self, socket): #message header msg = '{memb}' #assembles list of rooms seperated by commas for client in self.clients: msg += self.clients[client] + ',' #sends entire message as one block socket.send(bytes(msg, 'utf8')) #sending just room names
def shout(self, socket): #message header msg = '{room}' #assembles list of rooms seperated by commas for room in self.rooms: msg += room + ',' #sends entire message as one block socket.send(bytes(msg, 'utf8')) #sending just room names
def send_message(socket: socket, message: dict): """ """ json_msg = json.dumps(message) outcoming_encoded_msg = json_msg.encode(DEFAULT_ENCODING) socket.send(outcoming_encoded_msg)
def push(): while True: for socket in clients: socket.send( json.dumps({ "time": str(datetime.datetime.now()) }).encode("utf8")) time.sleep(10)
def sendFile(socket, fileName, mime): f = open(fileName) outputdata = f.read() socket.send("HTTP/1.1 200 OK\r\n") socket.send("Content-Type:%s\r\n" % mime) socket.send("Content-Length:%d\r\n" % len(outputdata)) socket.send("\r\n") socket.send(outputdata)
def sendError(socket, code, msg): f = open("" + code + ".html") outputdata = f.read() socket.send("HTTP/1.1 %s %s\r\n" % (code, msg)) socket.send("Content-Type:text/html\r\n") socket.send("Content-Length:%d\r\n" % len(outputdata)) socket.send("\r\n") socket.send(outputdata)
def boardcast(client, server, SOCKET_LISTS, message): for socket in SOCKET_LISTS: if socket != client and socket != server: try: socket.send(message) except: socket.close() if socket in SOCKET_LISTS: SOCKET_LISTS.remove(socket)
def update_clients(client_socket, address, msg): if len(client_sockets) != 0: message = msg.encode(FORMAT) msg_length = len(message) send_length = str(msg_length).encode(FORMAT) send_length += b' ' * (HEADER - len(send_length)) for socket in client_sockets: socket.send(send_length) socket.send(message)
def send_all_data(socket, msg): try: socket.send(msg) return 1 except ConnectionResetError: return 0 except OSError: return 0
def process_quit(self, socket): regex_quit = re.compile(r"(QUIT)") match = self.process_command(regex_quit, socket) if (match): send_data = "221 hamburger.edu closing connection\r\n" socket.send(str.encode(send_data)) print("S: " + send_data) else: False
def logoutPlayer( self, socket ): player = findPlayer(socket) if player is not None: i = self.players.index(player) del self.players[i] player.sendMessage('OK') else: socket.send('ERROR\n')
def logoutPlayer(self, socket): player = findPlayer(socket) if player is not None: i = self.players.index(player) del self.players[i] player.sendMessage('OK') else: socket.send('ERROR\n')
def send_recv(socket, msg, code): if msg != None: print "Sending==> ", msg socket.send(msg + '\r\n') recv = socket.recv(1024) print "<==Received:\n", recv if recv[:3] != code: print '%s reply not received from server.' % code return recv
def exchange_keys(): # at the beginning of the communication each other's # public key and n get sent to the other msg = '%s;%s' % cert.getPubKey() socket.send(bytes(msg, 'utf8')) keys = socket.recv(BUFSIZ).decode('utf8') pub, n = keys.split(';') global server_cert server_cert = RSA(int(pub), int(n))
def broadcast(socket_list, server, message): """Broadcast chat message to all clients on socket_list (including sender).""" for socket in socket_list: # send the message only to peer if socket != server: try: socket.send(message.encode()) except: # broken socket connection socket.close() if socket in socket_list: socket_list.remove(socket)
def send_queue(self, tcp_connections): for attempt in range(2): try: message = self.SyslogService.syslog_queue.popleft() for socket in self.tcp_sockets: socket.send(message + LINEBREAK) except OSError: traceback.print_exc() self.tls_connect() else: break
def send(self, topic, msg): if type(topic) != bytes: topic = bytes(str(topic), 'utf-8') messagedata = bytes(json.dumps(msg), 'utf-8') context = zmq.Context() socket = context.socket(zmq.REQ) socket.connect(self._relay_in) socket.send(topic + b' ' + messagedata) reply = socket.recv() assert reply
def enviar_archivo(self, tipo, path, socket, reprodccion=0): if tipo == 'wav': with open(path, 'rb') as archivo: bytes_archivo = archivo.read() tamano = len( bytes_archivo ) + 5 # 3 bytes del tipo y 2 del segundo de reproducción bytes_tamano = tamano.to_bytes(4, byteorder='big') bytes_tipo = tipo.encode('utf-8') bytes_reproduccion = reprodccion.to_bytes(2, byteorder='big') socket.send(bytes_tamano + bytes_tipo + bytes_reproduccion + bytes_archivo)
def process_to(self, socket): regex_to = re.compile(r"RCPT TO: <(\w+)(@)(\w+)(\.)(\w+)>") match = self.process_command(regex_to, socket) if (match): mail_to = match.group(1) + match.group(2) + \ match.group(3) + match.group(4) + match.group(5) send_data = ("250 " + mail_to + " ... recipent Ok\r\n") socket.send(str.encode(send_data)) print("S: " + send_data) return True, mail_to else: return False
def wait_for_connections(SERVER): while True: try: socket, client_addr = SERVER.accept() socket.send(bytes(f"Hi, welcome! Now what s ur name ?", "utf8")) person = Persons(socket, client_addr) persons.append(person) Thread(target=client_communication, args=(person, ), name='client_com').start() except Exception as e: print('[Failure] when a client try to join...', e)
def SendQueue(self, tcp_connections, queue_lock): line_break = b'\r\n' with queue_lock: while self.SyslogService.syslog_queue: try: message = self.SyslogService.syslog_queue.popleft() for socket in tcp_connections: socket.send(message + line_break) except error: traceback.print_exc() finally: self.Disconnect(tcp_connections)
def proces_Helo(self, socket): socket.send(str.encode("220 " + self.domain + "\r\n")) print("S: 220 " + self.domain) regex_helo = re.compile(r"HELO (\w+)(\.)(\w+)") match = self.process_command(regex_helo, socket) if (match): send_data = ("250 HELLO " + match.group(1) + "." + match.group(3) + ", pleased to meet you\r\n") socket.send(str.encode(send_data)) print("S: " + send_data) return True else: return False
def broadcast(self, msg, prefix=""): func = inspect.currentframe().f_back.f_code sender = msg.decode('utf8').split(":")[0:-1] #logging.debug("sender={} msg={}".format(sender, msg)) logging.debug("{}".format(str(self.connections))) c = 0 for name, value in self.connections.items(): logging.debug("to={} info={} msg={}".format( name, str(self.connections[name][0]), msg)) socket = value[1] logging.debug("{}".format(str(socket))) socket.send(bytes(prefix, "utf8") + msg) c += 1
def request_order_confirm(input_data, socket): # global token t = time.time() ret_str = json.dumps(input_data) service_name = "order_confirm" print("send {} data: {}".format(service_name, ret_str)) service_code = name_service_code[service_name] sequence_code = 2 #token = b"43210" _size, msg = YzyProtocol().create_paket(service_code, ret_str.encode("utf-8"), token, sequence_code=sequence_code, req_or_res=YzyProtocolType.REQ, client_type=ClientType.WINDOWS) print("Send msg size: {}, msg: {}".format(_size, msg)) socket.send(msg)
def send(self, data, flags=0): self._checkClosed() if self._sslobj: if flags != 0: raise ValueError( "non-zero flags not allowed in calls to send() on %s" % self.__class__) return self._sslobj.write(data) else: return socket.send(self, data, flags)
def send(self, data, flags=0): self._checkClosed() if self._sslobj: if flags != 0: raise ValueError('non-zero flags not allowed in calls to send() on %s' % self.__class__) try: v = self._sslobj.write(data) except SSLError as x: if x.args[0] == SSL_ERROR_WANT_READ: return 0 if x.args[0] == SSL_ERROR_WANT_WRITE: return 0 raise return v continue else: return socket.send(self, data, flags)
def save_send(socket, data): """send data to a socket. socket: a connected socket object data: string to send over the socket """ #We have no control about how much data the clients accepts, #thus we send in chunks until done while len(data)>0: try: send_data_size = socket.send(data) #remove sent portion form data data = data[send_data_size:] except error, msg: #most likely socket busy, buffer full or not yet ready sleep(0.01)
def send(self, data, flags=0): if self._sslobj: if flags != 0: raise ValueError( "non-zero flags not allowed in calls to send() on %s" % self.__class__) while True: try: v = self._sslobj.write(data) except (SSLError) as x: if x.args[0] == SSL_ERROR_WANT_READ: return 0 elif x.args[0] == SSL_ERROR_WANT_WRITE: return 0 else: raise else: return v else: return socket.send(self, data, flags)
"non-zero flags not allowed in calls to send() on %s" % self.__class__) while True: try: v = self._sslobj.write(data) except SSLError, x: if x.args[0] == SSL_ERROR_WANT_READ: return 0 elif x.args[0] == SSL_ERROR_WANT_WRITE: return 0 else: raise else: return v else: return socket.send(self, data, flags) def sendto(self, data, addr, flags=0): if self._sslobj: raise ValueError("sendto not allowed on instances of %s" % self.__class__) else: return socket.sendto(self, data, addr, flags) def sendall(self, data, flags=0): if self._sslobj: if flags != 0: raise ValueError( "non-zero flags not allowed in calls to sendall() on %s" % self.__class__) amount = len(data)
def send(self, data, flags=0, raw=False): if not raw: return self._sslobj.send(data, flags) else: return socket.send(self, data, flags)
def close_socket_connection(socket): socket.send(mlprotocol.end_message()) socket.close()