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)
