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 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_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 recvloop(self, sock: socket.socket) -> None:
""" Receive message callback. """
while True:
# Receive 16 bytes (size of length prefix).
bdata, addr = sock.recvfrom(16)
data = bdata.decode("ascii")
logging.info("%s: %s", self.channel, data)
# If the data is from a valid sender.
if addr in (self.target, self.master):
# Handle timeout refresh tokens.
if data == "refresh":
sock.sendto("confirm".encode(), self.target)
if data == "confirm":
continue
# Parse the message length bytes.
if not data.isnumeric():
continue
length = int(data)
logging.info("%s: length: %d", self.channel, length)
# Receive the object.
bdata, addr = sock.recvfrom(length)
# Abort if the sender changed.
if addr not in (self.target, self.master):
logging.info("%s: sender address changed.", self.channel)
continue
self.in_funnel.send(bdata)
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 find_leader_address(leader_socket: socket.socket):
while True:
data, addr = leader_socket.recvfrom(len('leader'))
message = data.decode('utf-8')
if message == 'leader':
return addr
def dnn_server_udp(sock: socket.socket):
max_fps = -1
min_fps = 999
cnt = 0
while True:
cnt += 1
begin_time = time.time()
data, addr = sock.recvfrom(1024000)
print(f'receive: {len(data)} from {addr}')
img = bytes2img(data)
end_time = time.time()
fps = 1.0 / (end_time - begin_time)
cv2.putText(img, '%.2f fps' % (fps), (10, 50),
cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255))
if cnt > 100:
cnt = 0
max_fps = -1
min_fps = 999
if fps > max_fps:
max_fps = fps
if fps < min_fps:
min_fps = fps
cv2.putText(img, 'max : %.2f' % (max_fps), (200, 50),
cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0))
cv2.putText(img, 'min : %.2f' % (min_fps), (200, 100),
cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0))
cv2.imshow(f"{str(addr)}", img)
cv2.waitKey(1)
def recv_one_ping(rawsocket: socket.socket, icmp_id: int, icmp_sq: int,
time_out: float):
start_time = time.time()
while True:
try:
now_time = time.time()
received_packet, _ = rawsocket.recvfrom(1024)
recv_time = time.time()
except BlockingIOError as e:
time.sleep(0.00001)
except socket.error as e:
if e == socket.errno.EAGAIN or e == socket.errno.EWOULDBLOCK:
time.sleep(0.00001)
pass
else:
raise e
else:
if received_packet[20] == 0:
icmpHeader = received_packet[20:28]
ptype, _, _, packet_id, sequence = struct.unpack(
"!BBHHH", icmpHeader)
if ptype == 0 and packet_id == icmp_id and sequence == icmp_sq:
return (recv_time + now_time) / 2 - start_time
if now_time - start_time > time_out:
return -1
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
def listen_for_udp_reg(server_sock: socket.socket, addr_list, num_conn: int):
# TODO: PHILAD SECURITY VULNERABILITY - some sort of validation for correct user connecting to socket
for i in range(num_conn):
data, addr = server_sock.recvfrom(1024)
print("Registering addr", addr, "for udp")
addr_list.append(addr)
server_sock.sendto("".encode("utf-8"), addr)
def recvfrom_blob(
sock: socket.socket,
timeout: int = SOCKET_OPERATION_TIMEOUT) -> Tuple[bytes, str]:
"""
Receive DNS message from TCP/UDP socket.
"""
# deadline is always time.monotonic
deadline = time.monotonic() + timeout
while True:
try:
if sock.type & socket.SOCK_DGRAM:
handle_socket_timeout(sock, deadline)
data, addr = sock.recvfrom(RECEIVE_MESSAGE_SIZE)
elif sock.type & socket.SOCK_STREAM:
# First 2 bytes of TCP packet are the size of the message
# See https://tools.ietf.org/html/rfc1035#section-4.2.2
data = recv_n_bytes_from_tcp(sock, 2, deadline)
msg_len = struct.unpack_from("!H", data)[0]
data = recv_n_bytes_from_tcp(sock, msg_len, deadline)
addr = sock.getpeername()[0]
else:
raise NotImplementedError(
"[recvfrom_blob]: unknown socket type '%i'" % sock.type)
return data, addr
except socket.timeout as ex:
raise RuntimeError("Server took too long to respond") from ex
except OSError as ex:
if ex.errno == errno.ENOBUFS:
time.sleep(0.1)
else:
raise
def _recv(self, sock: socket.socket, mask):
local_addr = sock.getsockname()
data, addr = sock.recvfrom(65535) # maximum udp packet size
session = self._session.get_session((local_addr, addr))
session: _SessionPeer
# check if the session exist
if session is None:
_logger.info("new session from [%s]:%d" % (addr[0], addr[1]))
# session not exist, we should create a new relay session
destination_addrinfo = self._sock_to_destination[sock]
relay_sock = socket.socket(destination_addrinfo[0], socket.SOCK_DGRAM)
# send data to the destination at first,
# so the system will automatically bind a address for that socket
relay_sock.sendto(data, destination_addrinfo[4])
relay_local_addr = relay_sock.getsockname()
session = self._session.create_session((local_addr, addr), sock,
(relay_local_addr, destination_addrinfo[4]), relay_sock)
self.__selector.register(relay_sock, selectors.EVENT_READ, self._recv)
_logger.info("udp session created: [%s]:%d,[%s]:%d <> [%s]:%d,[%s]:%d" %
(MultiThreadUDPRelay._format_addr(addr) +
MultiThreadUDPRelay._format_addr(local_addr) +
MultiThreadUDPRelay._format_addr(relay_local_addr) +
MultiThreadUDPRelay._format_addr(destination_addrinfo[4])))
else:
session.socket.sendto(data, session.address)
session.session_info.update(len(data))
def parse_reply(my_socket: socket.socket, req_id: int, timeout: int,
addr_dst: str) -> tuple:
"""Receive an Echo reply"""
time_left = timeout
while True:
started_select = time.time()
what_ready = select.select([my_socket], [], [], time_left)
how_long_in_select = time.time() - started_select
if what_ready[0] == []: # Timeout
raise TimeoutError("Request timed out after 1 sec")
time_rcvd = time.time()
pkt_rcvd, addr = my_socket.recvfrom(1024)
if addr[0] != addr_dst:
raise ValueError(f"Wrong sender: {addr[0]}")
# Extract ICMP header from the IP packet and parse it
#print_raw_bytes(pkt_rcvd)
if pkt_rcvd[20] != 0:
raise ValueError(f"Invalid Ping Type: {pkt_rcvd[20]}")
else:
length = bytes_to_val(pkt_rcvd[2:4])
ttl = pkt_rcvd[8]
return (length, ttl)
# DONE: End of ICMP parsing
time_left = time_left - how_long_in_select
if time_left <= 0:
raise TimeoutError("Request timed out after 1 sec")
def _onUnknownReadable(self, conn : socket):
data, addr = conn.recvfrom(UDP_RECV_BUFF)
packet = Packet()
packet.op = Packet.OP_USER_MSG
packet.host, packet.port = addr
packet.data = data
packet.send(self.__source)
def _catch_dns_answer(self, dns_request_id: int,
dns_socket: socket.socket):
while True:
raw_data, addr = dns_socket.recvfrom(4096)
dns_query = DNSRecord.parse(raw_data)
if dns_query.header.id == dns_request_id:
return dns_query
def receive_one_ping(sock: socket.socket, identity: int, timeout: int) -> float:
left_time = timeout
while True:
start_select = default_timer()
what_ready = select.select([sock], [], [], left_time)
how_long_in_select = (default_timer() - start_select)
if what_ready[0] == []:
raise TimeoutError("request timeout.")
recv_time = default_timer()
recv_packet, recv_addr = sock.recvfrom(1024)
icmp_header = recv_packet[20:28]
recv_type, recv_code, recv_checksum, packet_id, sequence = struct.unpack(
"bbHHh", icmp_header
)
if recv_type in CONNECT_ERROR_INFO:
type_info = CONNECT_ERROR_INFO[recv_type]
if recv_code in type_info:
raise ConnectionError(type_info[recv_code] + ".")
if recv_type != ICMP_ECHO_REQUEST and packet_id == identity:
bytes_in_double = struct.calcsize('d')
sent_time = struct.unpack('d', recv_packet[28:28 + bytes_in_double])[0]
return recv_time - sent_time
left_time = left_time - how_long_in_select
if left_time <= 0:
raise TimeoutError("request timeout.")
def listen_tcp_forward_udp_to_tcp(udp_reserve_socket: socket.socket,
tcp_client_socket: socket.socket):
log.debug("Listening TCP: Forwarding UDP To TCP")
while True:
try:
server_msg = udp_reserve_socket.recvfrom(udp_bufsize)
if server_msg:
tcp_client_socket.sendall(server_msg[0])
else:
try:
udp_reserve_socket.close()
except:
pass
try:
tcp_client_socket.close()
except:
pass
break
except:
try:
udp_reserve_socket.close()
except:
pass
try:
tcp_client_socket.close()
except:
pass
break
def receive_one_ping(socket_: socket.socket, packet_id: int, packet_seq: int,
timeout: float, debug: bool):
"""
Waits for ICMP packet and then checks if it is valid. Checks as long as packet is not valid and timeout is left.
:param socket_: socket to listen on.
:param packet_id: expected ICMP packet id.
:param packet_seq: expected ICMP packet sequence number.
:param timeout: how long to look for packets.
:param debug: print extra info about received packets.
:return: timestamp of receipt (time.perf_counter()) or None.
"""
time_left = timeout
while True:
started_select = time.perf_counter()
tmp = select.select([socket_], [], [], time_left)
sek_in_select = time.perf_counter() - started_select
if not tmp[0]:
return None, 0, 0, 0
start_receive = time.perf_counter()
rec_packet, addr = socket_.recvfrom(2048)
ip_header, icmp_header = unpack_icmp_packet(rec_packet, debug)
if icmp_header.id == packet_id and icmp_header.seq == packet_seq and icmp_header.code == icmp_header.type == 0:
return start_receive, len(
icmp_header.payload), ip_header.src, ip_header.ttl
time_left -= sek_in_select
if time_left <= 0:
return None, 0, 0, 0
def receive_next(listener: socket.socket):
"Repeatedly tries receiving on the given socket until some data comes in."
LOGGER.debug("Waiting to receive data...")
while True:
try:
return listener.recvfrom(BUFFER_SIZE)
except socket.timeout:
LOGGER.debug("No data received yet: retrying.")
def main_loop(cam: GoProCamera.GoPro, cam_status: CamStatus,
gc_socket: socket.socket, loopControl: threading.Event):
previous_state = GameControlData.STATE_INITIAL
previous_output = ""
output = ""
gc_data = GameControlData()
while not loopControl.is_set():
try:
try:
# receive GC data
message, address = gc_socket.recvfrom(8192)
gc_data.unpack(message)
except socket.timeout:
# didn't receive anything from GameController - stop recording (if necessary)
if cam_status['recording']:
logger.warning("Not connected to GameController?")
stopRecording(cam)
continue
# handle output
if not args.background and not args.quiet:
output = "%s | %s | game state: %s |" % (
cam_status['mode'], "RECORDING!" if cam_status['recording']
else "Not recording", gc_data.getGameState())
print("\r" + output + " " *
(len(previous_output) - len(output)),
end="",
flush=True)
# handle game state changes
if not args.ignore and gc_data.secsRemaining < -args.max_time:
# only stop, if we're still recording
if cam_status['recording']:
stopRecording(cam)
elif not cam_status['recording'] and (gc_data.gameState in [
GameControlData.STATE_READY, GameControlData.STATE_SET,
GameControlData.STATE_PLAYING
]):
startRecording(cam, cam_status)
elif cam_status['recording'] and not (gc_data.gameState in [
GameControlData.STATE_READY, GameControlData.STATE_SET,
GameControlData.STATE_PLAYING
]):
stopRecording(cam)
# just for debugging/logging
if previous_state != gc_data.gameState:
logger.debug("Changed game state to: %s",
gc_data.getGameState())
# update loop vars
previous_output = output
previous_state = gc_data.gameState
except (KeyboardInterrupt, SystemExit):
logger.debug("Interrupted or Exit")
print("") # intentionally print empty line
loopControl.set()
except:
traceback.print_exc()
def receive_message(server_socket: socket.socket):
request, addr = server_socket.recvfrom(4096)
if request:
print(addr, " : ", request.decode())
print('sending acknowledgement to', addr)
server_socket.sendto('answer!!'.encode(), addr)
else:
server_socket.close()
def receive(sock: socket.socket, stop: threading.Event, results: dict):
while not stop.is_set():
try:
data, (ip, port) = sock.recvfrom(200)
if data == b"HF-A11ASSISTHREAD":
continue
if ip not in results:
results[ip] = data
except socket.timeout:
continue
def img_sync(self, sock: socket.socket):
while True:
sock.sendto(self.ip_choose.encode('utf8'), address_receiver)
data_b, conn = sock.recvfrom(1024)
if data_b == b'None':
continue
print("sync->", data_b)
if not data_b:
break
def listen_loop(self, sock: socket.socket):
"""Listen for incoming messages on a separate thread."""
self.logger.info("Listen loop started for %r", sock)
while True:
try:
data, addr = sock.recvfrom(4096)
message = unpackb(data)
self.message_queue.put((message, addr, sock))
except Exception:
self.logger.exception(
"Ran into an error in the listener loop for %r", sock)
def perform_client_handshake(sock: socket.socket, addr, seq):
pack1 = updpacket.create_udp_packet_header(seq, 0, 0, False, True, False)
sock.sendto(pack1, addr)
(buff1, addr1) = sock.recvfrom(524)
resp1 = updpacket.decode_udp_packet_header(buff1)
seq += 1
pack2 = updpacket.create_udp_packet_header(resp1[0], seq, resp1[2], True, True, False)
sock.sendto(pack2, addr1)
def udp_listener(shutdown_event, session_start_event, session_stop_event):
#chk server address path and remove it if there
try:
unlink(SERVER_ADDR)
except OSError:
if (path.exists(SERVER_ADDR)):
raise
sock = SOCKET(AF_UNIX, SOCK_DGRAM)
sock.bind(SERVER_ADDR)
while (not (shutdown_event.isSet())):
try:
while (not (shutdown_event.isSet())):
data, address = sock.recvfrom(2048)
if data:
data = data.decode().split()
if (data[0] == "start"):
ret = start_session(data[1], shutdown_event,
session_start_event,
session_stop_event)
sock.sendto(bytes(ret, "utf-8"), address)
elif (data[0] == "note"):
sock.sendto(bytes('go', "utf-8"), address)
data, address = sock.recvfrom(2048)
write_journal((("____________________ Note _________________________\n"), \
(str(data)), \
(datetime.now().strftime("%m/%d/%Y %H:%M:%S") + '\n\n')))
sock.sendto(bytes('ok', "utf-8"), address)
elif (data[0] == "stop"):
session_stop_event.set()
sleep(0.2)
shutdown_event.set()
sleep(0.2)
sock.sendto(bytes('bye', "utf-8"), address)
else:
break
finally:
sock.close()
pass
async def multicast_listen(sock: socket.socket,
client_protocol: Context) -> IoT_Resource:
"""Wrap recvfrom in an async generator which yields aiocoap Messages."""
while True:
try:
with suppress(UnparsableMessage):
raw = sock.recvfrom(1152)
message = Message.decode(rawdata=raw[0], remote=raw[1][0])
print('payload: ' + repr(message.payload))
print('options:')
for number, option in message.opt._options.items():
print(repr(number) + ':')
for element in option:
print(element.value)
links = await get_resource_links(client_protocol, message)
while (message.code is not CONTENT or links is None):
raw = sock.recvfrom(1152)
message = Message.decode(raw[0], raw[1][0])
links = await get_resource_links(client_protocol, message)
for link in links:
yield link
except BlockingIOError:
await asyncio.sleep(5)
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 receive(_socket: socket.socket, buffer_size=1024, encoding_type='utf8') -> str:
"""
Wrapper function for receiving data from a socket. It also decodes it to utf8 by default.
Args:
_socket (socket): Socket that will be receiving data from;
buffer_size (int): Size of the buffer used by socket.recv() method;
encoding_type (str): Encoding type for decoding incoming data.
"""
# UDP
addr = None
if _socket.type == 2:
data, addr = _socket.recvfrom(buffer_size)
else:
data = _socket.recv(buffer_size)
return pickle.loads(data, encoding=encoding_type), addr
def receive_ping(self, current_socket: socket.socket):
"""A ping listener. Opens the current socket, and waits for a sent ping to come back.
Args:
current_socket: The connection being used to send pings to
Returns:
The time in ms the amount of time the ping took to be received
None: The connection timed out, or the host was not valid
"""
time_left = self.timeout / 1000.0
while True:
start_time = default_timer()
open_connection = select.select([current_socket], [], [],
time_left)
wait_time = default_timer() - start_time
time_received = default_timer()
packet_data, address = current_socket.recvfrom(ICMP_MAX_RECV)
icmp_header_raw = packet_data[20:28]
icmp_header = self.convert_header_dictionary(
names=["type", "code", "checksum", "packet_id", "seq_number"],
struct_format="!BBHHH",
data=icmp_header_raw)
ip_header = self.convert_header_dictionary(
names=[
"version", "type", "length", "id", "flags", "ttl",
"protocol", "checksum", "src_ip", "dest_ip"
],
struct_format="!BBHHHBBHII",
data=packet_data[:20])
if open_connection[0] is None:
return None, 0, ip_header, icmp_header
if icmp_header["packet_id"] == self.own_id:
data_size = len(packet_data) - 28
return time_received, (data_size + 8), ip_header, icmp_header
time_left -= wait_time
if time_left <= 0:
return None, 0, ip_header, icmp_header
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 _onUnknownReadable(self, conn : socket):
data, _ = conn.recvfrom(UDP_RECV_BUFF)
packet = Packet()
packet.op = Packet.OP_USER_MSG
key = None
for k in self.__clients:
if conn is self.__clients[k]:
key = k
break
if key:
self.__lastaccess[key] = time()
packet.host, packet.port = eval(key)
packet.data = data
packet.send(self.__remote)
self.__lastaccess['remote'] = time()
else:
raise Exception('Cannot find target client.')
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 udp_import(sock: socket.socket,
data_size: int,
use_buffer: bool = False) -> Union[bytes, list, None]:
"""
Author:
Alexander Heilmeier
Description:
Import data via UDP.
Inputs:
sock: UDP socket (see below how to create it)
data_size: data size per message in byte (not bit!)
use_buffer: flag to show if the buffer should be returned completely (True) or only the newest message (False)
How to create a UDP socket to import data?
import socket
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.bind((own_external_ip, listening_port))
sock.setblocking(False)
"""
# ------------------------------------------------------------------------------------------------------------------
# FUNCTION BODY ----------------------------------------------------------------------------------------------------
# ------------------------------------------------------------------------------------------------------------------
data_b = None
buffer = []
try:
while True:
data_b, addr = sock.recvfrom(data_size)
if use_buffer:
buffer.append(data_b)
except socket.error:
pass
if use_buffer and buffer:
return buffer
elif use_buffer:
return None
else:
return data_b
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 on_receive(self, sock: socket.socket):
"""
Handle raw data and wrap it with DataContainer
"""
try:
data, addr = sock.recvfrom(2 ** 16)
except ConnectionResetError:
return
except OSError:
return
try:
data = data.decode()
except UnicodeDecodeError:
self.logger.warning('error in decoding received data')
return
action = data[:3]
data = data[3:]
self.logger.debug('action: {}; addr: {}; data: {}'
.format(action, addr, data))
dc = DataContainer(address=addr, action=action, data=data)
self.call_handler(dc)
def udp_reader(s: socket, iqueue: Queue, size: int) -> None:
"""Read one or more packets from an UDP socket."""
data, peer = s.recvfrom(size)
iqueue.put_nowait((peer, data))
