def recvfrom(self, buflen=1024, flags=0):
self._checkClosed()
if self._sslobj:
raise ValueError("recvfrom not allowed on instances of %s" %
self.__class__)
else:
return socket.recvfrom(self, buflen, flags)
def ask_for_file(self, peer_info: Tuple[str, int], filename: str,
chunks: List[int]) -> List[int]:
""" Asks a peer for a given file.
Args:
peer_info: The address and port of a peer.
filename: The filename to ask the peer for.
chunks: The list of chunks to ask the peer for.
Returns:
The list of chunk Ids acquired for the file.
"""
# Create new TCP socket
try:
socket, port = utils.bind_UDP_port("")
except PortBindingException:
return False
# Ask for chunks
socket.sendto(utils.create_chunk_request_message(filename, chunks),
peer_info)
# Get each file, store in memory
chunks_data = []
try:
msg, addr = socket.recvfrom(constants.MAX_BUFFER_SIZE)
filename, c_id, data = utils.parse_file_chunk_message(msg)
self.shard_file_chunk(self.shard_dir, filename, c_id, data)
chunks_data.append(c_id)
except timeout:
_logger.info(f"Timeout occured when waiting for file: {filename}.")
return chunks_data
def send(Socket, address, act_ack, msg):
packs = []
while (len(msg) > 0):
preff_size = min(limit - 33, len(msg))
cur_ack = act_ack + len(packs)
cur_ack = transform_int(cur_ack)
packs.append(cur_ack + msg[0:preff_size])
msg = msg[preff_size:]
if (len(msg) == 0):
packs[-1] = b'1' + packs[-1]
else:
packs[-1] = b'0' + packs[-1]
for packet in packs:
while (True):
try:
Socket.sendto(packet, address)
serverAnswer, lixo = Socket.recvfrom(1)
if (serverAnswer == b'1'):
act_ack += 1
break
except socket.timeout as e:
continue
return act_ack
def recv(Socket, expected_ack):
confirma = b'1'
ans = b''
address = ('', -1)
while (True):
try:
answer = Socket.recvfrom(limit)
address = answer[1]
body = answer[0]
flag_fim = body[0:1]
this_ack = body[1:33]
real_msg = body[33:]
this_ack = int(this_ack, 2)
if (this_ack != expected_ack):
Socket.sendto(confirma, address)
continue
else:
Socket.sendto(confirma, address)
expected_ack += 1
ans += real_msg
if (flag_fim == b'1'):
break
else:
continue
except socket.timeout as e:
continue
return ans, address, expected_ack
def FIN(self,finNUM):
self.finNUM=finNUM
self.transmitted+=1
self.Send(self.finNUM, 1, False, False, True, '','')
STPpacket, addr = socket.recvfrom(2048)
STPpacket = pickle.loads(STPpacket)
self.flagNUM(STPpacket.syn,STPpacket.ack,STPpacket.fin)
log.write('{:10s}{:10.2f} {:5s}{:12d}{:12d}{:12d}\n'.format('rcv',(time.time()-self.beginTime),self.Flag,STPpacket.sequence,len(STPpacket.data),STPpacket.acknowledge))
if STPpacket.acknowledge == self.finNUM+1 and STPpacket.syn == False and STPpacket.ack == True and STPpacket.fin == False:
STPpacket, addr = socket.recvfrom(2048)
STPpacket = pickle.loads(STPpacket)
self.flagNUM(STPpacket.syn,STPpacket.ack,STPpacket.fin)
log.write('{:10s}{:10.2f} {:5s}{:12d}{:12d}{:12d}\n'.format('rcv',(time.time()-self.beginTime),self.Flag,STPpacket.sequence,len(STPpacket.data),STPpacket.acknowledge))
if STPpacket.acknowledge == self.finNUM+1 and STPpacket.syn == False and STPpacket.ack == False and STPpacket.fin == True:
self.transmitted+=1
self.Send(STPpacket.acknowledge, 2, False, True, False, '','')
return True
def log_response(socket):
"""Receive a response from socket and log it.
Args:
socket (socket.socket): The socket to receive from.
Returns:
--
"""
message, address = socket.recvfrom(BUFFERSIZE)
msg = message.decode('utf-8', 'ignore')
logger.debug('Received %s from %s' % (msg, address))
def send(Socket, adress, act_ack, msg):
adress = (adress[0], 3000)
msg = str(act_ack) + ' ' + msg
print(str(adress))
while (True):
try:
Socket.sendto(msg.encode('ascii'), adress)
serverAnswer, lixo = Socket.recvfrom(1024)
if (serverAnswer.decode('ascii') == '-'):
act_ack += 1
break
except socket.timeout as e:
continue
return
def receivepacket(self):
STPpacket, addr = socket.recvfrom(2048)
if self.beginTime == None:
self.beginTime = time.time()
self.Totalsegments += 1
self.sender_addr = addr
STPpacket = pickle.loads(STPpacket)
self.flagNUM(STPpacket.syn, STPpacket.ack, STPpacket.fin)
log.write('{:10s}{:10.2f} {:5s}{:12d}{:12d}{:12d}\n'.format(
'rcv', (time.time() - self.beginTime), self.Flag,
STPpacket.sequence, len(STPpacket.data), STPpacket.acknowledge))
return STPpacket
def await_reponse(socket):
running = True
socket.settimeout(1)
while running:
try:
data, client_conn = socket.recvfrom(2048)
print("\n" * 50)
print(data)
print("")
except timeout:
continue
except (KeyboardInterrupt, SystemExit):
self.__running__ = False
break
def Receive(self):
print('start 2')
self.DArcv={}
for i in self.packetNode:
self.DArcv[i]=0
Recived=[]
self.maxACK=0
while True:
STPpacket, addr = socket.recvfrom(2048)
STPpacket = pickle.loads(STPpacket)
self.flagNUM(STPpacket.syn,STPpacket.ack,STPpacket.fin)
if int(STPpacket.acknowledge)==len(self.data)+1:
self.notACK=[]
self.timestop=1
print('stop 2')
break
if STPpacket.acknowledge>self.maxACK:
self.maxACK=STPpacket.acknowledge
if STPpacket.acknowledge not in Recived:
Recived.append(STPpacket.acknowledge)
log.write('{:10s}{:10.2f} {:5s}{:12d}{:12d}{:12d}\n'.format('rcv',(time.time()-self.beginTime),self.Flag,STPpacket.sequence,len(STPpacket.data),STPpacket.acknowledge))
else:
self.DArcv[STPpacket.acknowledge]+=1
self.DupACKtotal+=1
log.write('{:10s}{:10.2f} {:5s}{:12d}{:12d}{:12d}\n'.format('rcv/DA',(time.time()-self.beginTime),self.Flag,STPpacket.sequence,len(STPpacket.data),STPpacket.acknowledge))
self.Lock.acquire()
if STPpacket.acknowledge-self.MSS in self.notACK:
self.Time=time.time()
if STPpacket.acknowledge-self.MSS in self.RTTstart:
SampleRTT=time.time()-self.RTTstart[STPpacket.acknowledge-self.MSS]
self.RTTstart={}
self.EstimatedRTT= 0.875*self.EstimatedRTT+0.125*SampleRTT
self.DevRTT=0.75*self.DevRTT+0.25*abs(SampleRTT-self.EstimatedRTT)
self.TimeoutInterval=self.EstimatedRTT+self.gamma*self.DevRTT
leng=len(self.notACK)
x=sorted(set(self.notACK)).index(STPpacket.acknowledge-self.MSS)
self.notACK=sorted(set(self.notACK))[x+1:]
self.rest+=(leng-len(self.notACK))*self.MSS
self.Lock.release()
else:
if self.DArcv[STPpacket.acknowledge]>=3:
if self.notinOrder==1:
self.numOrder+=1
self.DArcv[STPpacket.acknowledge]=0
self.rest+=len(self.packetNode[STPpacket.acknowledge])
self.PLD(STPpacket.acknowledge)
self.fasttotal+=1
self.Lock.release()
def receiver(self, socket):
config = component.get("Config")
# bind udp listener
interface = config.get('adapters.ethernet.interface', '0.0.0.0')
port = config.get('adapters.ethernet.port', '4444')
socket.bind((interface, port))
logger.debug('Binded on port: ' + str(port))
counter = 0
while True:
# blocking read
datagram, address = socket.recvfrom(1024)
# put datagram to queue
self.rq.put([datagram, address])
def FIN(self, STPpacket):
self.flagNUM(STPpacket.syn, STPpacket.ack, STPpacket.fin)
log.write('{:10s}{:10.2f} {:5s}{:12d}{:12d}{:12d}\n'.format(
'rcv', (time.time() - self.beginTime), self.Flag,
STPpacket.sequence, len(STPpacket.data), STPpacket.acknowledge))
self.Send(STPpacket.acknowledge, STPpacket.sequence + 1, False, True,
False, '', '')
self.Send(STPpacket.acknowledge, STPpacket.sequence + 1, False, False,
True, '', '')
STPpacket, addr = socket.recvfrom(2048)
self.Totalsegments += 1
self.sender_addr = addr
STPpacket = pickle.loads(STPpacket)
self.flagNUM(STPpacket.syn, STPpacket.ack, STPpacket.fin)
log.write('{:10s}{:10.2f} {:5s}{:12d}{:12d}{:12d}\n'.format(
'rcv', (time.time() - self.beginTime), self.Flag,
STPpacket.sequence, len(STPpacket.data), STPpacket.acknowledge))
return True
def handle_message(self, socket) -> packet:
""" Handles the receiving of packets, sending acks and storing data locally.
Args:
socket: The socket to receive data from.
Returns:
The parsed packet object of the most recent message.
"""
message, _ = socket.recvfrom(constants.PACKET_DATA_SIZE)
try:
p = packet.parse_udp_data(message)
except Exception as e:
logger.log(f"ERROR: {e}")
return None
logger.log(
f"Received packet with no: {p.seq_num}."
f"Looking for {(self.seq_num + 1) % constants.MODULO_RANGE}")
if p.type == constants.TYPE_EOT:
logger.log("Received EOT.")
return p
elif p.type == constants.TYPE_ACK:
# Should not happened
logger.log("[ERROR] Received ACK.")
return p
# Else data message
logger.arrival(p.seq_num)
if p.seq_num == (self.seq_num + 1) % constants.MODULO_RANGE:
# Expected, next packet
with open(self.filename, "a") as f:
f.write(p.data)
self.send_ack(self.seq_num)
logger.log(
f"Sending ACK for good packet with no: {self.seq_num + 1}")
self.seq_num = p.seq_num
else:
self.send_ack(self.seq_num)
logger.log(f"Sending ACK for bad packet with no: {self.seq_num}")
return p
def recv(Socket, expected_ack):
confirma = '-'
while (True):
try:
answer = Socket.recvfrom(1024)
body = answer[0].decode('ascii')
adress = answer[1]
adress = (adress[0], 3000)
this_ack, real_msg = body.split(' ', 1)
this_ack = int(this_ack)
if (this_ack != expected_ack):
Socket.sendto(confirma.encode('ascii'), adress)
continue
else:
Socket.sendto(confirma.encode('ascii'), adress)
expected_ack += 1
return real_msg, adress
except socket.timeout as e:
continue
return 'nunca deveria chegar aqui'
class TestRing:
self = socket(AF_INET, SOCK_DGRAM)
ttl = struct.pack('b', 1)
self.setsockopt(IPPROTO_IP, IP_MULTICAST_TTL, ttl)
self.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
self.setsockopt(SOL_SOCKET, SO_REUSEPORT, 1)
group = inet_aton(SERVER_GROUP_BASE_MULTICAST_ADDRESS)
mreq = struct.pack('4sL', group, INADDR_ANY)
self.setsockopt(IPPROTO_IP, IP_ADD_MEMBERSHIP, mreq)
self.bind(("", SERVER_GROUP_MULTICAST_PORT))
while True:
# Await an event on a readable socket descriptor
(read, write, exception) = select.select([self], [], [])
# Iterate through the tagged read descriptors
for socket in read:
# try:
data, address = socket.recvfrom(BUFFER_SIZE)
encoded_data = data.decode('utf-8')
print("encoded_data")
print(encoded_data)
def handle_giving_port(self, socket: socket, shard_directory: str):
""" A thread dedicated to listening for other peers communicating with it and
sending them file chunks that this peer has locally.
Args:
socket: A configured socket ready to accept TCP connections.
shard_directory: The temporary directory containing file shards.
"""
while constants.FOREVER:
try:
msg, peer_addr = socket.recvfrom(constants.MAX_BUFFER_SIZE)
self.giving_data = True
filename, chunks = utils.parse_chunk_request_message(msg)
# No new messages.
except timeout:
continue
# Main thread has ended. Terminate likewise
except OSError:
return
except UnexpectedMessageReceivedException as e:
_logger.error(
f"Error while parsing message from peer. Error: {str(e)}")
continue
for chunk in chunks:
with open(f"{shard_directory}/{filename}_{chunk}.chunk",
"r") as f:
data = f.read(constants.CHUNK_SIZE)
socket.sendto(
utils.create_file_chunk_message(filename, chunk, data),
peer_addr)
self.giving_data = True
def Transport(self):
self.nextSeq = 0
self.ACKed = []
self.drop = []
self.buffer = {}
self.data = {}
self.key = []
self.alreadysend = []
# if self.waiting==1:
while True:
STPpacket, addr = socket.recvfrom(2048)
self.Totalsegments += 1
# checksum=sum(STPpacket)&0xffff
# print('checksum:',checksum)
self.sender_addr = addr
STPpacket = pickle.loads(STPpacket)
# tempPacket= pickle.dumps(checksumpacket(STPpacket))
checksum = self.checksum(STPpacket.data)
print('checksum:', checksum, STPpacket.checksum)
print('waiting: ', self.waiting, 'Rec:', STPpacket.sequence)
self.flagNUM(STPpacket.syn, STPpacket.ack, STPpacket.fin)
# ending
if STPpacket.fin == True:
with open(self.filename, 'wb') as file:
print(sorted(set(self.key)))
self.lengthdata = 0
for m in sorted(set(self.key)):
self.lengthdata += len(self.data[m])
file.write(self.data[m])
if self.FIN(STPpacket):
L = [
self.lengthdata, self.Totalsegments, self.datatotal,
self.errortotal, self.Dupdata, self.DupACK
]
return L
self.datatotal += 1
if STPpacket.sequence in self.buffer or STPpacket.sequence in self.data:
self.Dupdata += 1
if self.waiting not in self.alreadysend:
self.alreadysend.append(self.waiting)
self.Send(STPpacket.acknowledge, self.waiting, False, True,
False, '', '')
else:
self.Send(STPpacket.acknowledge, self.waiting, False, True,
False, '', '/DA')
self.DupACK += 1
log.write(
'{:10s}{:10.2f} {:5s}{:12d}{:12d}{:12d}\n'.format(
'rcv/DA', (time.time() - self.beginTime), 'D',
STPpacket.sequence, len(STPpacket.data),
STPpacket.acknowledge))
if STPpacket.checksum != checksum:
self.errortotal += 1
print('no data')
# if self.waiting not in self.alreadysend:
# self.alreadysend.append(self.waiting)
# self.Send(STPpacket.acknowledge, self.waiting, False, True, False, '','')
# else:
# self.Send(STPpacket.acknowledge, self.waiting, False, True, False, '','/DA')
# self.DupACK+=1
log.write(
'{:10s}{:10.2f} {:5s}{:12d}{:12d}{:12d}\n'.format(
'rcv/corr', (time.time() - self.beginTime), 'D',
STPpacket.sequence, len(STPpacket.data),
STPpacket.acknowledge))
elif STPpacket.sequence == self.waiting:
print('yes')
# if STPpacket.sequence not in self.ACKed:
# self.ACKed.append(STPpacket.sequence)
self.key.append(STPpacket.sequence)
self.data[STPpacket.sequence] = STPpacket.data
log.write(
'{:10s}{:10.2f} {:5s}{:12d}{:12d}{:12d}\n'.format(
'rcv', (time.time() - self.beginTime), 'D',
STPpacket.sequence, len(STPpacket.data),
STPpacket.acknowledge))
b = STPpacket.sequence + len(STPpacket.data)
while b in self.buffer:
print('remove buffer:', b)
self.key.append(b)
self.data[b] = self.buffer[b]
length = len(self.buffer[b])
del self.buffer[b]
b += length
self.waiting = b
if self.waiting not in self.alreadysend:
self.alreadysend.append(self.waiting)
self.Send(STPpacket.acknowledge, self.waiting, False, True,
False, '', '')
else:
self.Send(STPpacket.acknowledge, self.waiting, False, True,
False, '', '/DA')
self.DupACK += 1
elif STPpacket.sequence > self.waiting:
print('buffer')
self.buffer[STPpacket.sequence] = STPpacket.data
if self.waiting not in self.alreadysend:
self.alreadysend.append(self.waiting)
self.Send(STPpacket.acknowledge, self.waiting, False, True,
False, '', '')
else:
self.Send(STPpacket.acknowledge, self.waiting, False, True,
False, '', '/DA')
self.DupACK += 1
log.write(
'{:10s}{:10.2f} {:5s}{:12d}{:12d}{:12d}\n'.format(
'rcv', (time.time() - self.beginTime), 'D',
STPpacket.sequence, len(STPpacket.data),
STPpacket.acknowledge))
#THIS FILE SHOULD BE RUN WHEN MULTIPLAYER IS DESIRED. ONLY ONE PLAYER NEEDS TO RUN THIS FILE TO HOST MULTIPLAYER
#Written based off of Documentation of Sockets Example 18.1.15 https://docs.python.org/3/library/socket.html#timeouts-and-the-accept-method
clients = {'player1': None, 'player2': None}
PORT_NUMBER = 5009
SIZE = 4096
hostName = gethostbyname(gethostname())
socket = socket(AF_INET, SOCK_DGRAM)
socket.bind((hostName, PORT_NUMBER))
print("Test server listening on port %s\n at %s\n\n" %
(str(PORT_NUMBER), str(gethostbyname(gethostname()))))
while True:
incoming = socket.recvfrom(SIZE)
(data, addr) = incoming
if pickle.loads(data) == '':
if clients.get('player2', None) == None:
if clients.get('player1', None) != None:
clients['player2'] = addr
print('Player 2 Connected')
else:
clients['player1'] = addr
print('Player 1 Connected')
if incoming[1] == clients['player1']:
if clients['player2'] != None:
socket.sendto(data, clients['player2'])
if incoming[1] == clients['player2']:
if clients['player1'] != None:
from socket import socket, AF_INET, SOCK_DGRAM
import sys
HOST = "0.0.0.0"
PORT_NUMBER = 8080
SIZE = 1024
socket = socket(AF_INET, SOCK_DGRAM)
socket.bind((HOST, PORT_NUMBER))
print("Server listening on port {0}\n".format(PORT_NUMBER))
i = 0
while True:
(data, addr) = socket.recvfrom(SIZE)
if data == b'stop':
break
with open("recieved_udp", 'ab+') as f:
f.write(data)
print(f"==================={i}===================")
print(data)
i += 1
socket.close()
sys.exit()
from socket import socket, SOCK_DGRAM, AF_INET
from pickled_calculator import process
import pickle
import threading
def handle(data, remote):
expression = pickle.loads(data)
try:
result = process(expression)
print('Resolved', expression, 'to', result)
socket.sendto(pickle.dumps(result), remote)
except Exception as error:
socket.sendto(pickle.dumps({'error': str(error)}), remote)
ADDRESS = ('', 8080)
with socket(AF_INET, SOCK_DGRAM) as socket:
socket.bind(ADDRESS)
while True:
data, remote = socket.recvfrom(1024)
threading.Thread(None, handle, args=(data, remote)).start()
def await_reponse(socket, textbox, buttons, main):
global running
socket.settimeout(1)
while running:
try:
data, client_conn = socket.recvfrom(2048)
result = json.loads(data.decode())
print(data)
if result.get("code"):
if result.get("code") == codes.FULL:
textbox.setText("\nThe run is full!\nWait and try again")
main.exit.setEnabled(True)
main.replay.setEnabled(True)
main.replay.setText("Try again")
if result.get("code") == codes.IS_RUNNING:
textbox.setText(
"\nThe gamming is running!\nWait some minutes and try again!"
)
main.exit.setEnabled(True)
main.replay.setEnabled(True)
main.replay.setText("Try again")
elif result.get("code") == codes.REGISTRED:
textbox.setText("Resgistred!\n\n Wait for more players...")
elif result.get("code") == codes.QUESTION:
msg = result["body"]["question"] + "\r\n"
textbox.setText(msg)
used_alterantives = []
for alternative in result["body"]["alternatives"]:
btn = buttons.get(alternative["code"])
if btn:
used_alterantives.append(alternative["code"])
btn.setText("\n" + alternative["text"])
btn.setEnabled(True)
for k, v in buttons.items():
if k not in used_alterantives:
v.setText("")
v.setEnabled(False)
elif result.get("code") == codes.FINISH_ROUND:
textbox.setText(result["body"])
for k, v in buttons.items():
v.setText("")
v.setEnabled(False)
elif result.get("code") == codes.RESULT_RANK:
players = list(result["body"].items())
players.sort(key=lambda x: x[1], reverse=True)
for k, v in buttons.items():
v.setText("")
v.setEnabled(False)
msg = "Scores\n\n"
for pos, (name, points) in enumerate(players):
msg += "{0}ยบ) \t {1} \t {2} points\n".format(
pos + 1, name, points)
textbox.setText(msg)
main.exit.setEnabled(True)
main.replay.setEnabled(True)
main.replay.setText("Replay")
running = False
break
except timeout:
continue
except (KeyboardInterrupt, SystemExit):
break
from socket import socket, AF_INET, SOCK_DGRAM
socket = socket(family=AF_INET, type=SOCK_DGRAM)
# 183.156.105.130
socket.bind(("localhost", 8002))
while True:
data, iphost = socket.recvfrom(1024)
print(data.decode("utf-8"), iphost)
