def run_client(server_address, server_port): # Ping a UDP pinger server running at the given address try: client_socket = Socket(socket.AF_INET, socket.SOCK_DGRAM) # Time out after 1 second client_socket.settimeout(1.0) print("Pinging", str(server_address), "on port", server_port) for i in range(10): client_socket.sendto("".encode(), (server_address, server_port)) try: time_start = time.time() _, _ = client_socket.recvfrom(1024) time_stop = time.time() except socket.timeout: print("Packet lost") else: print("RTT(Round trip time): {:.3f}ms".format((time_stop - time_start) * 1000)) finally: client_socket.close() return 0
def run_client(server_address, server_port): """Ping a UDP pinger server running at the given address """ client_socket = Socket(socket.AF_INET, socket.SOCK_DGRAM) message = "Ping" client_socket.settimeout(1) for i in range(0, 10): start_time = time.time() client_socket.sendto(message, (server_address, server_port)) try: data, server = client_socket.recvfrom(1024) end_time = time.time() elapsed = end_time - start_time print "%s, time: %f." % (data, elapsed) except: print "TIMEOUT!" time.sleep(1) return 0
def get_rtt(server_address, server_port): """Ping a UDP ping server running at the given address and show the ping status """ server = (server_address, server_port) message = bytes("", 'UTF-8') client_socket = Socket(socket.AF_INET, socket.SOCK_DGRAM) client_socket.settimeout(1.0) try: initial_time = current_milli_time() client_socket.sendto(message, server) client_socket.recvfrom(1024) final_time = current_milli_time() rtt = final_time - initial_time except: rtt = -1 client_socket.close() return rtt
def run_server(server_port): """Run the UDP pinger server """ # Create the server socket (to handle UDP requests using ipv4), make sure # it is always closed by using with statement. server_socket = Socket(socket.AF_INET, socket.SOCK_DGRAM) # The socket stays connected even after this script ends. So in order # to allow the immediate reuse of the socket (so that we can kill and # re-run the server while debugging) we set the following option. This # is potentially dangerous in real code: in rare cases you may get junk # data arriving at the socket. server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # Set the server port server_socket.bind(("", server_port)) # Start accepting ping requests print ("Ping server ready on port", server_port) while True: # Receive message and send one back _, client_address = server_socket.recvfrom(1024) server_socket.sendto("Pong".encode(), client_address) return 0
async def udp_writer(s: socket, oqueue: Queue) -> None: """Forward packets to the UDP socket.""" while True: peer, data = await oqueue.get() try: s.sendto(data, peer) finally: oqueue.task_done()
def send_one_ping(rawsocket: socket.socket, dst_addr: str, icmp_id: int, icmp_sq: int): packet = gen_packet(icmp_id, icmp_sq) send_time = time.time() addrs = socket.getaddrinfo(dst_addr, 0, socket.AF_INET6, 0, socket.SOL_IP) dest = None for addr in addrs: if addr[1] == socket.SOCK_RAW: dest = addr[4] rawsocket.sendto(packet, dest) return send_time, dst_addr
def send_one_ping(sock: socket.socket, dest_addr: str, ID: str): my_checksum = 0 header = struct.pack("bbHHh", ICMP_ECHO_REQUEST, 0, my_checksum, ID, 1) bytes_in_double = struct.calcsize('d') data = bytes((192 - bytes_in_double) * 'Q', 'utf-8') data = struct.pack('d', default_timer()) + data my_checksum = checksum(header + data) header = struct.pack( "bbHHh", ICMP_ECHO_REQUEST, 0, socket.htons(my_checksum), ID, 1 ) packet = header + data sock.sendto(packet, (dest_addr, 1))
def handle_query(s: socket.socket, data, emitter): m = parse_message(data) if m.question[0].qtype != QTypes.A_RECORD or m.question[ 0].qclass != QClasses.IN: raise ValueError( "I don't handle these kind of queries. Only basic baby-dns queries please." ) ip, ttl = get_ip(m.question[0].qname) response = construct_response(m.header.transaction_id, m.question[0].qname, ip, ttl) s.sendto(response.to_bytes(), emitter)
def SendDisconnectMessage(sock: socket.socket, dropped ,addr): #send a json to client. if(dropped == "null"): print('I need to DC: ') else: print('Told other client to quit: ') payload = {} #dictionary payload['header'] = SocketMessageType.DISCONNECT #fill in header payload['droppedID'] = dropped #payload['guessOptions'] = to_guess_options #add gameoptions. payload = json.dumps(payload).encode('utf-8') #convert obj to json formatted string. sock.sendto(bytes(payload), (addr[0], addr[1]))
def sendloop(self, sock: socket.socket) -> None: """ Send message callback. """ while True: obj = self.outq.get() # Serialize in bytes as a length-message pair. pair: bytes = get_length_message_pair(obj) logging.info("%s: sending pair: %s", self.channel, str(obj)) # Send to target client. sock.sendto(pair[:16], self.target) sock.sendto(pair[16:], self.target)
def echo_command(sock: socket.socket, q: mp.Queue, method: str = UDP): print('start echo') if method == 'UDP': while True: data, addr = q.get() print('echo', data, addr) if data == addr: return sock.sendto(b"a0" + data, addr) else: while True: con, data = q.get() if con == 'None': return con.send(data)
def generate(sock: socket.socket, ip: str, port: int, rate_hz: int): random.seed(1) while True: msg = { "data": [ random.uniform(0.7, 1.0), random.uniform(0.0, 0.3), random.uniform(0.3, 0.7), ] } sock.sendto(json.dumps(msg).encode(), (ip, port)) time.sleep(1.0 / rate_hz)
def perform_server_handshake(sock: socket.socket): (buff1, addr1) = sock.recvfrom(524) packbuff1 = updpacket.decode_udp_packet_header(buff1) print("one") pack1 = updpacket.create_udp_packet_header(server_seq, packbuff1[1], conn_id, True, True, False) sock.sendto(pack1, addr1) (buff2, addr2) = sock.recvfrom(524) packbuff2 = updpacket.decode_udp_packet_header(buff2) print("two") print(packbuff2)
def sendOnePing(mySocket: socket, destAddr: str, ID: int): # Header is type (8), code (8), checksum (16), id (16), sequence (16) myChecksum = 0 # Make a dummy header with a 0 checksum # struct -- Interpret strings as packed binary data header = struct.pack("!bbHHh", ICMP_ECHO_REQUEST, 0, myChecksum, ID, 1) data = struct.pack("!d", time()) # Calculate the checksum on the data and the dummy header. myChecksum = checksum(header + data) # Get the right checksum, and put in the header header = struct.pack("!bbHHh", ICMP_ECHO_REQUEST, 0, myChecksum, ID, 1) packet = header + data mySocket.sendto(packet, (destAddr, 1)) # AF_INET address must be tuple, not str
def start1(client_soc: socket.socket, udp: bool = False, address=None): """Funkce pro odeslání 9999 souborů o celkové velikosti 10 MB""" try: for file in os.listdir("cache"): os.remove(os.path.join("cache", file)) except FileNotFoundError: os.mkdir("cache") # Vytvoření 30 souborů v /client/cache/ for i in range(9999): name = "cache/test{0}.txt" print("Zapisuji", i + 1) if i < 10: fill = str(i) * int(2 ** 10) name = name.format("000" + str(i)) elif i < 100: fill = str(i) * int(2 ** 10 / 2) name = name.format("00" + str(i)) elif i < 1000: fill = str(i) * int(2 ** 10 / 3) name = name.format("0" + str(i)) else: fill = str(i) * int(2 ** 10 / 4) name = name.format(str(i)) with open(name, 'w') as file: file.write(fill) print("Zahajuji odesílání") i = 0 e = 0 m = 0 start_time = datetime.now() for file in os.listdir("cache"): f = open(os.path.join("cache", file), "rb").read() if udp: client_soc.sendto(f, address) else: client_soc.send(f) try: data: bytes = client_soc.recv(4096) i = i + 1 print(int(i/9999*1000)/10, "%") if f != data: e = e + 1 except socket.timeout: m = m + 1 end_time = datetime.now() p_results(udp, i, e, m, end_time - start_time)
def handle_messages(sock: socket.socket): print("listening to messages on new thread") while True: data, addr = sock.recvfrom(1024) data = str(data.decode("utf-8")) data = json.loads(data) #print(f'Recieved message from {addr}: {data}') #payload = "guess recieved" #payload = bytes(payload.encode("utf-8")) clients_lock.acquire() if(addr in clients): #check if address is already in client list, if so then do something with that client if (data['header'] == SocketMessageType.HEARTBEAT): #if header is heartbeat then update heartbeat time. #print(clients[addr]['lastBeat']) clients[addr]['lastBeat'] = datetime.now() #update heartbeat #print(clients[addr]['lastBeat']) elif(data['header'] == SocketMessageType.CONNECT): print(clients[addr]['lobbyID']) clients[addr]['lobbyID'] = data['lobbyID'] elif(data['header'] == SocketMessageType.RESTART): print("this player wants to restart " + str(addr)) clients[addr]['hand'] = "null" elif(data['header'] == SocketMessageType.HAND): print("got hand from " + str(addr) + " player " + data['hand']) clients[addr]['hand'] = data['hand'] elif(data['header'] == SocketMessageType.DISCONNECT): print("deleting player lobby/hand: " + str(addr)) clients[addr]['hand'] = "null" clients[addr]['lobbyID'] = "null" else: # if you arent part of the contact list then do the connection / badheartbeat... if(data['header'] == SocketMessageType.CONNECT): # if they are connecting.. clients[addr] = {} #create new obj clients[addr]['lastBeat'] = datetime.now() clients[addr]['lobbyID'] = data['lobbyID'] clients[addr]['hand'] = "null" message = {"header": 14,"players":[{"id":str(addr),"lobbyID":str(data['lobbyID']), "hand":str(clients[addr]['hand'])},]} # tell each client connected that a new player joined. m = json.dumps(message) sock.sendto(bytes(m,'utf8'), addr) print(clients[addr]['lobbyID']) if (data['header'] == SocketMessageType.HEARTBEAT): #if header is heartbeat then update heartbeat time. print(str(addr) + " has already been disconnected") SendDisconnectMessage(sock, "null", addr) clients_lock.release()
def spam_rrq(s: socket.socket, args: argparse.Namespace, connection_event: Event, msg: bytes): """ Used by the thread to resend a message until the server provides a valid response :param s: the UDP socket connected to the server :param args: the argparser object with the ip, ports, and filename fields :param connection_event: the thread event that signals when it is time to stop sending the same message to the server :param msg: the message sent to the server """ while not connection_event.is_set(): # print("sending " + str(msg)) s.sendto(msg, (args.ip, args.server_port)) sleep(1)
def sendto_ack(sock: socket.socket, pkt_data, addr: (str, int)): global blknum ack_received = False while not ack_received: sock.sendto(pkt_data, addr) try: rx_blknum = sock.recv(1)[0] if rx_blknum == blknum: ack_received = True blknum = (blknum + 1) % 0x100 except socket.timeout: print("\tTimed out, retrying...")
def send_ping(self, current_socket: socket.socket) -> float: """Example function with PEP 484 type annotations. Args: param1: The first parameter. param2: The second parameter. Returns: The return value. True for success, False otherwise. """ checksum = 0 # Make a dummy header with a 0 checksum. header = struct.pack("!BBHHH", ICMP_ECHO, 0, checksum, self.own_id, self.sequence_number) pad_bytes = [] start_val = 0x42 for i in range(start_val, start_val + self.packet_size): pad_bytes += [(i & 0xff)] # Keep chars in the 0-255 range data = bytearray(pad_bytes) # Calculate the checksum on the data and the dummy header. Checksum is in network order checksum = calculate_checksum(header + data) # Now that we have the right checksum, we put that in. It's just easier # to make up a new header than to stuff it into the dummy header = struct.pack("!BBHHH", ICMP_ECHO, 0, checksum, self.own_id, self.sequence_number) # Build packet and record time it was sent packet = header + data send_time = default_timer() # print(send_time) try: current_socket.sendto( packet, (self.stats.destination_ip, self.stats.destination_port)) except socket.error: error_type, error_value, etb = sys.exc_info() self._stderr.write("General failure (%s)\n" % (error_value.args[1])) send_time = None return send_time
def _send_msg(self, sock: socket.socket, msg: Any, addr: Tuple[str, int]) -> None: template1 = 'Send message :: {0}.' template2 = 'Send message to {0}:{1} using interface {2}:{3}.' if (isinstance(msg, str)): msg_bytes = self.serialized_str(msg) elif (isinstance(msg, dict)): msg_bytes = self.serialized_str(json.dumps(msg)) else: msg_bytes = msg # Send it ! sock.sendto(msg_bytes, addr) self._logger.debug(template1.format(msg)) self._logger.info( template2.format(addr[0], addr[1], *sock.getsockname()))
def send_packets(sock: socket.socket, host_ip: str, dst_ip: str, cipher: AESCipher, fd): ip_h = IPHeader(host_ip, dst_ip) # create an IP header packet_from_fd = read_from_fd(fd) # read the file descriptor for packets while packet_from_fd: encrypted_packet = cipher.encrypt( packet_from_fd) # encrypt the packet using AES # create esp header with encrypted packet esp_h = ESPHeader(encrypted_packet) # create final packet with payload packet = (ip_h.header + esp_h.payload) # send packet to destination ip sock.sendto(packet, (dst_ip, 0)) # re-read from the FD and loop packet_from_fd = read_from_fd(fd)
def clientSend(self,request:Request): sock_Response = Response(None) try: byte = str.encode(request.Data) client = Socket(socket.AF_INET,socket.SOCK_DGRAM) client.settimeout(setup.DELAY_TIMEOUT) client.sendto(byte,(request.IPAddress,request.Port)) recv = client.recvfrom(setup.SIZE_BUFFER_RETURN) sock_Response = Response(recv) sock_Response.received = True self.log_client(request,sock_Response) except Exception as ex: sock_Response.IPAddress = request.IPAddress sock_Response.Port = request.Port sock_Response.received = False sock_Response.Data = str(ex) return sock_Response
def run_server(server_port): # Run UDP pinger server try: server_socket = Socket(socket.AF_INET, socket.SOCK_DGRAM) server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) server_socket.bind(('', server_port)) print("Ping server ready on port", server_port) while True: _, client_address = server_socket.recvfrom(1024) server_socket.sendto("".encode(), client_address) finally: server_socket.close() return 0
def handle_request(data, addr, sock: socket.socket, cache): question = DNSRecord.parse(data) reply = DNSRecord(DNSHeader(id=question.header.id, qr=1, aa=1, ra=1), q=question.q) name = str(question.q.qname) cache.update() if not cache.contains(name): try: result = dns.resolver.resolve(name, 'A') except: # (dns.resolver.NXDOMAIN, dns.resolver.Timeout): sock.sendto(reply.pack(), addr) return cache_records(result, cache) ans = make_response(reply, cache, name) sock.sendto(ans, addr)
def receive_a_img(self, sock: socket.socket) -> BytesIO: buffer = BytesIO() while True: sock.sendto(self.ip_choose.encode('utf8'), address_receiver) data_b, conn = sock.recvfrom(1024) if data_b == b'None': continue if not data_b: break else: buffer.write(data_b) b_data = buffer.getvalue() buffer.close() print('receiver one img over->', time.time()) return b_data
def backsender(queue: mp.Queue, socket_lock: mp.Lock, output_lock: mp.Lock, sock: socket.socket): while True: with socket_lock: sock.settimeout(5) for answer_count in range(queue.qsize()): if queue.qsize() <= 0: break answer, addr, recv_time, mode = queue.get() if answer is None: continue with output_lock: cprint(f'[{datetime.now()}][{mode}{bytes_to_int(answer[:2])}]: {answer}', fore='cyan', style='reverse') answer = parse_msg(answer, fore='cyan') sock.sendto(answer, addr) send_time = datetime.now() time_cost = send_time - recv_time with output_lock: cprint(f'[{send_time}][time cost {bytes_to_int(answer[:2])}]: {time_cost}', fore='blue', style='reverse')
def broadcast_pos(sock: socket.socket, pos: float, clients: [(str, int)]) -> [int]: data = struct.pack('!d', pos) sent = [] for client in clients: sent.append(sock.sendto(data, client)) for client, written in zip(clients, sent): if written != 8: logging.error("Cannot send to '%s:%d'" % client) return sent
def send_message(self, message_num: int, sock: socket.socket, addr: tuple, trying=0): package = bytes(f's{chr(message_num)}{chr(0)}{self.messages[message_num]}', encoding='utf-8') sock.sendto(package, addr) print(f'send = {message_num % 256}') try: data, recv_addr = sock.recvfrom(2) print(f'recive = {chr(int(data[0]))}-{int(data[1])}') if recv_addr == addr: if data[0] == 97 and int(data[1]) == message_num: return False return True except Exception: if trying < 3: print('timeout - ', trying) return self.send_message(message_num, sock, addr, trying + 1) else: raise Exception('timeout')
def send(sock: socket.socket, init_address: Tuple[str, int], packets: List[Packet], window_size: int = 0, show_progress: bool = False): if window_size == 0: window_size = len(packets) if len(packets) < WINDOWS_SIZE else WINDOWS_SIZE length = len(packets) timeout = 0.4 sequence_number = 0 unacknowledged_number = 0 while sequence_number < length: try: ready = select.select([sock], [], [], timeout) if ready[0]: ack_data, address = sock.recvfrom(UDP_MAX_PACKET_SIZE) ack_data: Acknowledgment = pickle.loads(ack_data) if ack_data.ack_field == 0b1010101010101010: if ack_data.sequence_number == sequence_number: sequence_number += 1 unacknowledged_number -= 1 if show_progress: progress(ack_data.sequence_number, length) elif ack_data.sequence_number > sequence_number: # in case client received part of the window # but his ack was dropped (due to disconnect) sequence_number = ack_data.sequence_number unacknowledged_number = 0 else: # window has probably been dropped unacknowledged_number = 0 else: # timed out unacknowledged_number = 0 if unacknowledged_number < window_size and (unacknowledged_number + sequence_number) < length: sock.sendto(pickle.dumps(packets[unacknowledged_number + sequence_number]), init_address) unacknowledged_number += 1 continue except socket.error: continue if show_progress: progress(length, length) print('\n')
def serverP(self): server = Socket(socket.AF_INET,socket.SOCK_DGRAM) server.settimeout(setup.DELAY_TIMEOUT) server.bind((self.IPAddress,self.Port)) while True: try: recv = server.recvfrom(setup.SIZE_BUFFER_RETURN) sock_Response = Response(recv) reply = (sock_Response.IPAddress,sock_Response.Port) if sock_Response.received == True: self.packet_response(sock_Response.Data) if sock_Response.Data.startswith(setup.PREFIX_CHECK): packet = self.generate_packet(setup.PREFIX_CHECK) if sock_Response.Data.startswith(setup.PREFIX_UPDATE): packet = self.generate_packet(setup.PREFIX_UPDATE) byte = str.encode(packet) server.sendto(byte,reply) self.log_server(reply,sock_Response) except Exception: pass
def _handle_dns_query(self, raw_data: bytes, addr: (str, int), localhost_socket: socket.socket): dns_query = DNSRecord.parse(raw_data) self._logger.debug('dns query {}'.format(dns_query.questions)) for host_query in dns_query.questions: if self._is_blacklist(host_query.qname): self._replay_dns_none(addr, dns_query, localhost_socket) else: with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as dns_socket: self._logger.info('request dns - {}, id {}'.format( str(host_query.qname), hex(dns_query.header.id))) dns_socket.sendto(raw_data, (self._DNS_SERVER_IP, self._DNS_PORT)) dns_reply = self._catch_dns_answer(dns_query.header.id, dns_socket) self._logger.info('answer to {}, id {}, is {}'.format( str(host_query.qname), hex(dns_query.header.id), [x.rdata for x in dns_reply.rr])) localhost_socket.sendto(dns_reply.pack(), addr)
def sendto_msg(sock: socket.socket, message: bytes, addr: Optional[str] = None) -> None: """ Send DNS/UDP/TCP message. """ try: if sock.type & socket.SOCK_DGRAM: if addr is None: sock.send(message) else: sock.sendto(message, addr) elif sock.type & socket.SOCK_STREAM: data = struct.pack("!H", len(message)) + message sock.sendall(data) else: raise NotImplementedError( "[sendto_msg]: unknown socket type '%i'" % sock.type) except OSError as ex: # Reference: http://lkml.iu.edu/hypermail/linux/kernel/0002.3/0709.html if ex.errno != errno.ECONNREFUSED: raise
def main(serv_sock: socket.socket, udp: bool = False): """posílá veškerou komunikaci zpátky odesílateli. Hlavní program se nachází ve složce client""" print("Spouštím navraceč balíčků") if udp: while True: try: data, address = serv_sock.recvfrom(1024) if data == "VERIFY".encode('utf-8'): serv_sock.sendto("CONFVER".encode('utf-8'), address) print("Přijato připojení z", address) continue serv_sock.sendto(data, address) except ConnectionResetError: pass else: while True: data = serv_sock.recv(1024) if not data: break print("Přijmut balíček, odesílám přes TCP") serv_sock.send(data) serv_sock.close()
def discover(interface: str, timeout: float) -> Iterable[Host]: sock = Socket(AF_INET, SOCK_DGRAM) sock.settimeout(timeout) sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1) sock.setsockopt(SOL_SOCKET, SO_BROADCAST, 1) sock.bind((interface, 34569)) request = Packet(0, 0, 1530, b'', fragments=0, fragment=0) sock.sendto(request.encode(), ('255.255.255.255', 34569)) while True: try: data, (host, _) = sock.recvfrom(Packet.MAXLEN) except Timeout: break packet = Packet.decode(data) if not packet.payload: continue reply = DiscoverReply.frompackets([packet]).host if reply.host != host: raise DVRIPDecodeError('wrong IP address ' 'reported') yield reply
def send_window(sock: socket.socket, seq, receiver_ip, receiver_port, n): """send datagrams in `seq` Args: sock (socket.socket): seq (list): sending window n (int): if -1 send all datagrams in `seq`, otherwise send last n datagrams in `seq` """ if not seq: return # if timeout, re-send all datagrams in `seq` global timer timer = Timer(TIMEOUT_INTERVAL, send_window, [sock, seq[:], receiver_ip, receiver_port, -1]) if n == -1: for pkt in seq: sock.sendto(str(pkt), (receiver_ip, receiver_port)) else: for pkt in seq[-n:]: sock.sendto(str(pkt), (receiver_ip, receiver_port)) timer.start()
def _send(self, sock: socket.socket, addr: Tuple[Any, ...], message: Message, channel: Optional[int] = None, peer: Optional[PeerInfo] = None, do_tick: bool = True, originator: bool = True): if channel is not None: message.channel = channel else: channel = message.channel if originator: message.sender = self.self_info.channels[channel].id if do_tick: message = message.with_time(self.tick()) if peer is None: peer = self.routing_table[channel].by_address(addr) if peer: message.compress = peer.local.compression else: message.compress = CompressType.PLAIN # ACKs don't want an ACK # IDENTIFY doesn't want an ACK, it wants a HELLO # It's impractical to ACK a BROADCAST, just assume they got it if not isinstance( message, (AckMessage, IdentifyMessage, FloodMessage, BroadcastMessage)): self.awaiting_ack[message.nonce] = message def stale(): """If a message wasn't ACK'd, mark a miss.""" if message.nonce in self.awaiting_ack: del self.awaiting_ack[message.nonce] peer = self.routing_table[channel].by_address(addr) if peer: peer.local.misses += 1 self.schedule.enter(60, 100, stale) sock.sendto(packb(message), addr)
def send_data (sock : socket.socket, addr, data : str): ints = [int(data[i : i + 2], 16) for i in range(0, len(data), 2)] # add endian conversion if necessary sock.sendto(bytes(ints), addr)