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)