def keep_alive(pwd, salt, cookie, svr, socket): log('DEBUG', 'keep_alive') old_cookie = cookie keep_alive1(salt, old_cookie, pwd, svr, socket) svr_num = 0 svr_num, cookie = keep_alive_pre_1(svr_num, cookie, svr, socket) svr_num, cookie = keep_alive_pre_2(svr_num, cookie, svr, socket) svr_num, cookie = keep_alive_pre_3(svr_num, cookie, svr, socket) i = svr_num while True: packet = keep_alive_package_builder(i, cookie, 1, False) socket.sendto(packet, (svr, 61440)) data, address = socket.recvfrom(1024) cookie = data[16:20] packet = keep_alive_package_builder(i+1, cookie, 3, False) socket.sendto(packet, (svr, 61440)) data, address = socket.recvfrom(1024) cookie = data[16:20] i = (i+2) % 0xFF time.sleep(20) keep_alive1(salt, old_cookie, pwd, svr, socket)
def GetFile(Filename, Key): # Tell server what to do ServerCommand = "Requesting File" socket.sendto(ServerCommand.encode(), serverAddr) # Request File socket.sendto(Filename.encode(), serverAddr) # Receive Hash Value HashValue, addr = socket.recvfrom(2048) HashValue = HashValue.decode() # Get size of file Size, addr = socket.recvfrom(2048) Size = int(Size.decode()) # Receive Message file = open(Filename, 'wb+') FileToWrite = [] for Byte in range(Size): Value, addr = socket.recvfrom(2048) FileToWrite.append(Value.decode()) FileToWrite = RSADecrypt(FileToWrite, int(Key.get('D')), int(Key.get('n'))) file.write(bytes(FileToWrite)) file.close() # Compare Hash Values print("Hash of received file:", HashValue) print("Calculated Hash of Downloaded file:", CalculateHash(Filename))
def recieve_packet(socket, packet_size=65000, timeout_kill=False): message = b'' address = () try: byte_length, address = socket.recvfrom(4) length = struct.unpack('!i', byte_length)[0] if length > 0: socket.sendto(byte_length, address) recieved = 0 while recieved < length - packet_size: byte_message, address = socket.recvfrom(packet_size) message += _message recieved += packet_size _message, address = socket.recvfrom(length % packet_size) message += _message except Exception as e: if str(e) == 'timed out': if timeout_kill: return 1, 1 else: StreamUtils.dbgprint( 'Exception caught in StreamUtils::recieve_packet:', str(e), ) return message, address
def ServerPut(): msg = "Put komutu dogru." msgEn = msg.encode('utf-8') socket.sendto(msgEn, clientAddr) if t2[0] == "put": dosya = open(t2[1], "wb") d = 0 print("Dosya mevcut ise islem basliyor.") try: Count, countaddress = socket.recvfrom(4096) # paket numarası except ConnectionResetError: print("Port hatasi") sys.exit() except: print("Zaman asimi veya diger.") sys.exit() tillI = Count.decode('utf8') tillI = int(tillI) while tillI != 0: ServerData, serverAddr = socket.recvfrom(4096) dataS = dosya.write(ServerData) d += 1 tillI = tillI - 1 print("packet number:" + str(d)) dosya.close() print("Yeni dosya kapandi klasoru kontrol ediniz.")
def sendOnePing(self, socket, destinationAddress, ID): # 0. Create packet packet = self.packet(ID) # 0.1. Attempt to flush out any existing data before closing (only done if a timeout is very very low) if (self.timeout < 0.5): try: recv, recv2 = socket.recvfrom(1024) except Exception as e: pass # Second attempt at receiving in case the first one timed out try: recv, recv2 = socket.recvfrom(1024) except Exception as e: pass # 1. Send packet using socket if (self.socketType == 'icmp'): socket.sendto(packet, (destinationAddress, 1)) elif (self.socketType == 'udp'): socket.sendto(packet, (destinationAddress, 34000)) # 2. Record time of sending self.SendingTime = time.time()
def solicitarArquivo(self, fileName, socket): content = 'GET/file/' + fileName socket.sendto(content.encode(), (self.SERVER_IP, self.SERVER_PORT)) #Answer about the size size, client = socket.recvfrom(1024) size = int(size.decode()) socket.sendto(b'Ok!', client) print('Size:', size) print('\nRecebendo o arquivo...') fileSize = 0 package = {} with open(fileName, 'wb') as f: while True: # Receiving the next package data, server = socket.recvfrom(1024) # ACK about the last package socket.sendto(data[-16:0], server) # Add the tuple Index:Data to the package Dict package[data[-16:]] = data[0:-16] fileSize += len(data[0:-16]) if(fileSize >= size): break for i in sorted(package): f.write(package[i]) print('Arquivo salvo!\n')
def rectangle(): socket.sendto('forward 50'.encode('utf-8'), ryze_addr) response, ip = socket.recvfrom(1024) if response == b'ok': socket.sendto('ccw 90'.encode('utf-8'), ryze_addr) response, ip = socket.recvfrom(1024) if response == b'ok': time.sleep(1)
def recieve_packet(socket, port): #create_socket() socket.bind(("", port)) (data, addr) = socket.recvfrom(1024) while True: while socket.recvfrom(1024): recv = time.clock() print data, recv return (float(data), float(recv))
def upload_by_batch(socket, batch): try: socket.sendto(pickle.dumps(batch), (UDP_IP, UDP_PORT)) data, ip = socket.recvfrom(BUFFER_SIZE) decoded_data = pickle.loads(data) sig = int(decoded_data.get("ack")) if len(data) is not None and (sig == sys.maxsize or sig == batch[2]): if sig == sys.maxsize: print("File upload successfully completed.") return 0 print( f'recieved acknowledgement {decoded_data.get("ack")} from server' ) return 0 else: raise AcknowlegemntError("ack error") except Exception as e: print(f'did not recieve acknowledgement from server') retry = 0 while retry < RETRY: try: print(f'resending pacakge') socket.sendto(pickle.dumps(batch), (UDP_IP, UDP_PORT)) data, ip = socket.recvfrom(BUFFER_SIZE) if len(data) is not None: data = pickle.loads(data) if int(data.get("ack")) == batch[2]: print( f'recieved acknowledgement {data.get("ack")} from server' ) return 0 # wrong package acknowledgement else: retry = retry + 1 time.sleep(BACKOFF * retry) # not recieving acknowledgement else: retry = retry + 1 time.sleep(BACKOFF * retry) # socket errors except: retry = retry + 1 time.sleep(BACKOFF * retry) if batch[4]: return -2 return -1
def calculate(): socket.sendto('tof?'.encode('utf-8'), ryze_addr) responseTof, ip = socket.recvfrom(256) print("tof: ", responseTof) actualHeight = int(responseTof[0:3]) print("actual height [mm]: ", actualHeight) if actualHeight > 400: downValue = int((actualHeight - 400) / 10) strDownValue = str(downValue) print("diff [cm]: ", strDownValue) socket.sendto(('down %s' % strDownValue).encode('utf-8'), ryze_addr) responseDown, ip = socket.recvfrom(256) print(responseDown)
def parse_user_input(address, operation, file_name=None): socket, server_address = setup_socket(address) tftp_object = TftpProcessor() if operation == "push": tftp_object.read_file(file_name) tftp_object.upload_file(file_name) write_request = tftp_object.get_next_output_packet() sent = socket.sendto(write_request, server_address) print("waiting for response") data, server = socket.recvfrom(4096) print("connection successfully...") while True: tftp_object.process_udp_packet(data, server) if tftp_object.has_pending_packets_to_be_sent(): data_packet = tftp_object.get_next_output_packet() size = len(data_packet) socket.sendto(data_packet, server) print("waiting for acknowledge for the sending block...") data, server = socket.recvfrom(4096) print("upload successfully...") tftp_object.count = tftp_object.count + 1 # block_no if size < 516: break else: break elif operation == "pull": tftp_object.request_file(file_name) read_request = tftp_object.get_next_output_packet() sent = socket.sendto(read_request, server_address) while True: print("waiting for response") data, server = socket.recvfrom(4096) print("connection successfully...") tftp_object.process_udp_packet(data, server) if tftp_object.has_pending_packets_to_be_sent(): ack_packet = tftp_object.get_next_output_packet() socket.sendto(ack_packet, server) tftp_object.write_blocks.append(data[4:]) if len(data) < 516: break else: break if len(tftp_object.write_blocks) != 0: tftp_object.write_file(file_name) socket.close()
def do_socket_logic(protocol, address, request_packet): socket, server = setup_sockets(address) if request_packet: socket.sendto(request_packet, server) if protocol.isReceiving: packet, rev_addr = socket.recvfrom((512 + 4)) while not protocol.isFinished: protocol.process_udp_packet(packet, rev_addr) if protocol.has_packets_to_send(): socket.sendto(protocol.get_next_packet(), rev_addr) if protocol.isReceiving: packet, rev_addr = socket.recvfrom((512 + 4)) print('****FINISH****')
def recv_file_len(self, socket): pkt, adr = socket.recvfrom(600) unpkd = packet(pkd_data=pkt,type='bytes') ack_p = ack(checksum=calc_checksum(unpkd.data.decode()),seqno=0).pack() socket.send(ack_p) self.file_len = int(unpkd.data) print('Required file length = ', self.file_len, ' packets.')
def recv(socket): while True: try: data,addr = socket.recvfrom(1024) print(data.decode('utf-8')) except: return False
def send(addr_dest, data, socket, filename): ##get print("Requête get du fichier ",filename," vers l'adresse de destination = ", addr_dest) ack = 1 print(filename) isExist = os.path.exists(filename) print(isExist) if (not isExist): print("Le fichier n'existe pas") ack_error_msg = b'\x00\x05\x00\x11' + bytes("FILE NOT FOUND", 'utf-8') + b'\x00' socket.sendto(ack_error_msg, addr_dest) socket.close() return with open(filename, mode='r') as f: while True: data_to_send = f.read(BLKSIZE) data_bytes = bytes(data_to_send, 'utf-8') data_paquet = b'\x00\x03' + ack.to_bytes(2,'big') + data_bytes print("Envoi du paquet",data_paquet) socket.sendto(data_paquet, addr_dest) data_ack, addr_ack = socket.recvfrom(BLKSIZE) ack_msg = (b'\x00\x08') + ack.to_bytes(2,byteorder='big') if (ack_msg != data_ack): print("Le ACK attendu ne correspond pas au ACK reçu") ack_error_msg = b'\x00\x05\x00\x10' + bytes("ACK ERR", 'utf-8') + b'\x00' socket.sendto(ack_error_msg, addr_dest) break ack+=1 if (len(data_paquet) < BLKSIZE): print("Fin de l'envoi") f.close() socket.close() break f.close() socket.close() print("Requête get du fichier ", filename, "terminé")
def echo_listen(socket): while True: payload, (ip, port) = socket.recvfrom(64) logger.debug('Pong %s', payload) if payload.startswith(b'PING'): payload = b"ACK " + payload socket.sendto(payload, (ip, port))
def __dataThreadFunction(self, socket): while True: data, addr = socket.recvfrom(32768) if (len(data) > 0): self.__processMessage(data)
def _send_socket(self, cmd, rtnCmd, ip, port): socket = self._socket try: _LOGGER.debug('Sending to GW {0}'.format(cmd)) self._read_unwanted_data() socket.settimeout(30.0) socket.sendto(cmd.encode(), (ip, port)) socket.settimeout(30.0) data, addr = socket.recvfrom(1024) if len(data) is not None: resp = json.loads(data.decode()) _LOGGER.debug('Recieved from GW {0}'.format(resp)) if resp["cmd"] == rtnCmd: return resp else: _LOGGER.error( "Response from {0} does not match return cmd".format( ip)) _LOGGER.error(data) else: _LOGGER.error("No response from Gateway") except socket.timeout: _LOGGER.error("Cannot connect to Gateway") socket.close()
def receive(socket): global LBA global seq_no global window global ack_no global nbytes datagram, address = socket.recvfrom(4096) header, data = extr_datagram(datagram.decode("utf-8")) senderLog.write( "rcv %.3f A %d %d %d\n" % ((time.clock() - timer_start) * 1000, header[0], nbytes, header[1])) if header[2:] == (1, 0, 0): print('#', header) if header[1] > LBA: ack_no = header[1] #print(header) LBA = header[1] - 1 to_remove = [] for seq_no in window: if seq_no < header[1]: to_remove.append(seq_no) for seq_no in to_remove: window.pop(seq_no)
def __grab_data__(self, socket): time.sleep(1) while self.streaming: data, address = socket.recvfrom(1024) jdata = json.loads(data) self.__refresh_data__(jdata)
def __commandThreadFunction(self, socket, stop_event): while not stop_event.is_set(): # Block for input data, addr = socket.recvfrom(32768) # 32k byte buffer size if (len(data) > 0): #print(data) self.__processMessage(data)
def __dataThreadFunction(self, socket): while True and not self.stopThreads: # Block for input data, addr = socket.recvfrom(32768) # 32k byte buffer size # print(data) if (len(data) > 0): self.__processMessage(data)
def moverX(owner, socket): setupLoggerFile("INFO", "a") GL.logging.info(threading.current_thread().name + "START: " + str(time.time())) data = "" try: data, addr = socket.recvfrom(40) except: pass # print with showing off purpouse only if len(data) == 0: print("no data") GL.logging.debug("No data yet!") else: print("data -> ", data) data = str(data, 'utf-8') GL.logging.info("Data received: " + data + threading.current_thread().name + str(time.time())) applyRotationX(data) owner.update() GL.logging.info(threading.current_thread().name + "FINISH: " + str(time.time()))
def recv_window_size(self,socket): pkt, adr = socket.recvfrom(600) unpkd = packet(pkd_data=pkt, type='bytes') ack_p = ack(checksum=calc_checksum(unpkd.data.decode()), seqno=0).pack() socket.send(ack_p) self.window_size = int(unpkd.data) print('Window size = ', self.window_size)
def broadcast_listener(socket): try: while True: data = socket.recvfrom(512) print(data) except KeyboardInterrupt: pass
def receive_message(): global initiator while True: message_in, _ = socket.recvfrom(4096) print('{}'.format(message_in.decode(encoding='UTF-8')))
def run(): r = [tun, socket] w = [] e = [] write_to_tun_data = b'' send_to_socket_data = b'' while True: readable, writable, exceptional = select.select(r, w, e) if tun in readable: send_to_socket_data = tun.read(tun.mtu) if socket in readable: data, addr = socket.recvfrom(65523) pair = decode_query(data) query_queue.put((pair[1], addr)) write_to_tun_data = pair[0] if tun in writable: tun.write(write_to_tun_data) write_to_tun_data = '' if socket in writable and not query_queue.empty(): query_dns_pkt, target_addr = query_queue.get() socket.sendto(encode_response(send_to_socket_data, query_dns_pkt), target_addr) send_to_socket_data = b'' r = [] w = [] if send_to_socket_data: w.append(socket) else: r.append(tun) if write_to_tun_data: w.append(tun) else: r.append(socket)
def toggle_listener(self, io, cond, socket): connection = socket.recvfrom(len(TOGGLE_INSTRUCTION)) instruction = connection[0].decode() # Quit the app upon receiving the toggle-signal. if TOGGLE_INSTRUCTION == instruction: Gtk.main_quit() return True
def run(): r = [tun, socket] w = [] e = [] write_to_tun_data = b'' send_to_socket_data = b'' timer = time.time() while True: readable, writable, exceptional = select.select(r, w, e) if tun in readable: send_to_socket_data = tun.read(tun.mtu) if socket in readable: write_to_tun_data, target_addr = socket.recvfrom(65532) write_to_tun_data = decode_response(write_to_tun_data) if tun in writable: tun.write(write_to_tun_data) write_to_tun_data = b'' if socket in writable: socket.sendto(encode_query(send_to_socket_data), local_dns_server) send_to_socket_data = b'' r = [] w = [] if write_to_tun_data: w.append(tun) else: r.append(socket) if not send_to_socket_data: r.append(tun) now = time.time() if now - timer > 0.4 or send_to_socket_data: w.append(socket) timer = now
def _get_packet(self, socket): """ Read packet and put it into inbox :param socket: Socket to read from :type socket: socket.socket :return: Read packet :rtype: APPMessage """ data, (ip, port) = socket.recvfrom(self._buffer_size) packet, remainder = self._unpack(data) self.inbox.put((ip, port, packet)) self.new_packet.set() self.debug(u"RX: {}".format(packet)) if packet.header.sequence_number is not None: # Packet needs to be acknowledged self._send_ack(ip, port, packet) ack_seq = packet.header.ack_sequence_number if ack_seq is not None: # Packet got acknowledged with self._seq_ack_lock: if ack_seq in self._seq_ack: self.debug(u"Seq {} got acked".format(ack_seq)) self._seq_ack.remove(ack_seq) return packet
def run(self): """ Run the mailbox to attend petitions and manage the status of sent messages. """ events = self._select.select(0) for key, mask in events: socket = key.fileobj if socket.fileno() == -1: continue data, address = socket.recvfrom(1024) if not len(data) >= header.size: continue id, type = header.unpack_from(data) if type == DATA: payload = data[header.size:] #Do something with the payload socket.sendto(header.pack(id, ACK), address) if not id in self._received: if callable(self._protocol): self._protocol(payload, address, self) message = self._messages.pop() message.id = id message.data = payload self._received[id] = message self._mysched.enter(1, 1, self._remove_message, argument=(id,)) elif type == ACK: if id not in self._sent: continue event = self._sent[id].event if event in self._mysched.queue: self._mysched.cancel(event) message = self._sent.pop(id) message.reset() self._messages.append(message) self._mysched.run(False)
def Listen(self,socket, port): while self.listen: message, address = socket.recvfrom(1024) print(message.decode()) if message.decode().rstrip().split(',')[0] == "LOGIN": print("Login request from user: ", message.decode().rstrip().split(',')[1]) self.newclient(0, address, message.decode().rstrip().split(',')[1] )
def __proto_recv_handler_udp(self,socket,header_type): '''udp server接收数据''' if 0 == header_type: print "recv.." self.data_recv,addr = socket.recvfrom(int(get_conf_value('mock_info','BUFFERSIZE'))) getattr(self.request_proto,"ParseFromString")(self.data_recv) self.list_proto(self.request_proto,self.recv_proto_info) return addr elif 1 == header_type: self.data_recv,addr = socket.recvfrom(int(get_conf_value('mock_info','BUFFERSIZE'))) if len(self.data_recv) > 36: self.data_recv = self.data_recv[36:] getattr(self.request_proto,"ParseFromString")(self.data_recv) self.list_proto(self.request_proto,self.recv_proto_info) return addr else: print '[conf error] header_type.'
def readSocket(socket): text ="" while True: string, address = socket.recvfrom(Util.SIZE) if string == "": break text = text + string return text
def leerSocket(self, socket, tam): msg = "" while len(msg) < tam: (chunk, dir) = socket.recvfrom(tam - len(msg)) if chunk == "": print RuntimeError("socket connection broken flujo Ogg") msg = msg + chunk return (msg, dir)
def send_and_receive(packet): socket.sendto(packet, ("127.0.0.1", port)) try: data, addr = socket.recvfrom(4096) except socket.error, e: print "ERROR", e import sys sys.exit(0)
def _callback(self, socket, *args): '''Asynchronous connection listener. Starts a handler for each connection.''' # sock == self.socket data, address = socket.recvfrom(8192) if self.keepListening and (self.addressManager is not None): #self.socket = socket self.remote = address self.addressManager.handle(data, address) return self.keepListening
def get_cash(self,socket) : header = self.get_header(14,801) socket.sendall(header) print "packet sent" packet, address = socket.recvfrom( 50 ) print "recieving" #print len(packet[2:4]) balance = packet[42:50] #value = struct.unpack('s', len)[0] balance = struct.unpack('d',balance) return balance[0]
def recv_n_bytes(n, socket): """ recieve a fixed number of bytes from socket. """ data = '' while len(data)< n: chunk, addr = socket.recvfrom(n - len(data)) if chunk == '': return None, None data += chunk return data, addr
def loop(): while True: message = socket.recvfrom(256) for i in message: if i == ",": counter = counter + 1 else: commands[counter] = commands[counter] + message[i] """ENTER MOTOR COMMANDS HERE""" counter = 0 commands[:] = []
def recieve_data(socket): while True: global identifier marshalled_message,server_addr = socket.recvfrom(1024) unmarshalled_message = pickle.loads(marshalled_message) # This function unmarshalls the message in my case it is tuple. keyword = unmarshalled_message[0] # Keyword can be Incoming or Identifier message = unmarshalled_message[1] # it is braodcast message from server sent by any connected user if keyword.startswith('Identifier'): identifier = message # sets identifier elif keyword.startswith('Incoming'): print message # prints message sent from server only else: pass # if client recieves any other packet without key word Incoming or Identifier then it does nothing
def __send_request__(self, socket, request): try : socket.sendto(request.data, (request.host, request.port)) # receive data from client (data, addr) d = socket.recvfrom(1024) reply = d[0] #addr = d[1] return DHTResponse(reply) except socket.error, msg: raise 'Error Code : ' + str(msg[0]) + ' Message ' + msg[1]
def receive(socket, number_of_bytes): """ Receive an amount of bytes. Works for both python2 and python3 :param socket: The socket to use. :param number_of_bytes: The number of bytes to receive. """ data, address = socket.recvfrom(number_of_bytes) if sys.version_info[0] > 2 and isinstance(data, bytes): return str(data, 'utf-8'), address return data, address
def event_loop(name): global epoll #global fd_to_socket global serverSocket #print 'Run task %s (%s)...' % (name, os.getpid()) #epoll = select.epoll() #添加服务器监听fd到等待读事件集合 #epoll.register(serverSocket.fileno(), select.EPOLLIN) while True: #print "等待活动连接......" #轮询注册的事件集合 try: events = epoll.poll(timeout) if not events: #logging.debug("epoll超时无活动连接,重新轮询......") continue #logging.debug("有%d个新事件,开始处理......", len(events)) for fd, event in events: #socket = fd_to_socket[fd] socket = serverSocket #可读事件 if event & select.EPOLLIN: data, cliaddr = socket.recvfrom(1024) if data: logging.debug("收到数据:%s, 客户端:%s", data, cliaddr) cmd = data[0:1] (data_report if cmd in ['$', '@', '#', '!'] else deal_command)(data, cliaddr) #d = {'$':period_report, '@':realtime_report, '#':nogsm_report} #else: # #Command 命令 # #dc = {"1":"Deprecated", "2":"soft_reset", "7":"modify_gps_package_freq", "16":"change_server_ip", "17":"change_server_port"} # #dc = {"1":Deprecated, "2":soft_reset, "7":modify_gps_package_freq, "16":change_server_ip, "17":change_server_port} # dc = {"7":modify_gps_package_freq, "16":change_server_ip} # if dc.has_key(l[2]): # #exec(d[l[2]] + '()') # dc[l[2]]() # else: # #不识别的命令 # logging.debug("unkown command") elif select.EPOLLHUP & events: #epoll_wait被更高级的系统调用打断,忽略这种错误 logging.error("epoll interrupt by system") except IOError, e: #惊群 pass except Exception, e: logging.debug("%s", e)
def receive_data(self, socket): #global data bytes_received = len(self.data) self.data += socket.recvfrom(1029-bytes_received)[0] frame_number = 0000 if len(self.data) >= 1029: frame_number = int(self.data[:5].split(b'\0', 1)[0]) # frame_data = data[6:1029].split(b'\0', 1)[0] if len(self.data) > 1029: self.data = self.data[1030:] else: self.data = "" if frame_number == "9999": return True return False
def _server_alive_watchog(self, socket, list_of_servers): '''The watch dog listens if the server is still alive. If not - sets a particular flag. ''' socket.settimeout(WATCHDOG_PING) try: while self.is_alive: message, address = socket.recvfrom(8192) if message == '\DIE': if address == globvar[1]: # If the registered server is the one that broadcasted, then it's alive self.is_alive = False print 'Watchdog thread ended!' socket.close() except Exception: socket.close()
def processRipPacket(socket, router): data,addr = socket.recvfrom(8000) my_bytes = bytearray(data) packet = RipPacket() packet.fromBytes(my_bytes) router = updateRoutingTable(packet, router) for destinationID in router.routing_table: resetTimeoutTimer(router, destinationID, packet) print("--------------------ROUTING TABLE UPDATED--------------------") print("Source: " + str(packet.routerID)) for destination, information in router.routing_table.iteritems(): # print("Destination: " + str(destination)) print("Information: " + str(information)) return router
def processRipPacket(socket): '''Process the rip packet received over the wire''' global router data,addr = socket.recvfrom(8000) my_bytes = bytearray(data) packet = RipPacket() packet.fromBytes(my_bytes) updateRoutingTable(packet) for destinationID in router.routing_table: resetTimeoutTimer(destinationID, packet) print("--------------------ROUTING TABLE UPDATED--------------------") print("Source: " + str(packet.routerID)) for destination, information in router.routing_table.iteritems(): print("Destination: " + str(destination)) print("Information: " + str(information))
def read_base_station(boat_1, boat_2, buoy_list, socket): data, addr = socket.recvfrom(1024) data_list = data.split(',') # boat 1 boat_1_index = data_list.index(boat_1.greek) pos_1 = (int(data_list[boat_1_index+1]), int(data_list[boat_1_index+2])) heading_1 = math.radians(int(data_list[boat_1_index+3])-90) boat_1.update(pos_1, heading_1) # boat 2 boat_2_index = data_list.index(boat_2.greek) pos_2 = (int(data_list[boat_2_index+1]), int(data_list[boat_2_index+2])) heading_2 = math.radians(int(data_list[boat_2_index+3])-90) boat_2.update(pos_2, heading_2) # buoy for buoy in buoy_list: buoy_index = data_list.index(buoy.name) buoy.position = (int(data_list[buoy_index+1]), int(data_list[buoy_index+2]))
def listen(self): while self.running: read, write, error = select.select( [self.socket], [self.socket], [], self.select_timeout) for socket in read: try: packet = socket.recvfrom(self.buffer_size) data, addr = packet data = data.decode() self.inbound.put((data, addr)) except ConnectionAbortedError: log("ERR: Connection aborted") except ConnectionResetError: log("ERR: Connection reset by peer") for socket in write: try: packet = self.outbound.get_nowait() data, addr = packet data = data.encode() self.socket.sendto(data, addr) except queue.Empty: pass
def receive_data(frame_list, last_frame_num, socket): """receives data from the socket. Returns a Frame if enough data, else returns none""" global data, inorder, ooorder bytes_received = len(data) data += socket.recvfrom(1029-bytes_received)[0] if len(data) >= 1029: frame_number = int(data[:5].split(b'\0', 1)[0]) frame_data = data[6:1029].split(b'\0', 1)[0] new_frame = Frame(frame_number, data) if frame_number == 9999: print("!!!!----------Client received qos packet---------!!!!") return if len(data) > 1029: data = data[1030:] else: data = "" try: frame_num = frame_deque[0].frame_num except: frame_num = last_frame_num if new_frame.frame_num == frame_num + 1 and len(frame_deque) != frame_deque.maxlen: print "!!STRAIGHT TO DEQUE!! {}".format(new_frame.frame_num) inorder += 1 frame_deque.appendleft(new_frame) else: ooorder += 1 add_frame_to_list(frame_list, new_frame, last_frame_num) # find frame in request_list and remove it for i, x in enumerate(requests_sent): if x[0] == frame_number: RTT.append(current_milli_time() - x[1]) del requests_sent[i] print("request_list: {}".format([(x[0], current_milli_time() - x[1]) for x in requests_sent])) return
def receivingData (socket): recData, addr = socket.recvfrom(1024) return recData,addr
def cb_read(self, socket, condition): if condition == gobject.IO_IN: data, address = socket.recvfrom(6024) self.received_data(data, address) return True
# </editor-fold> def socket_send(frame_get): result, imgencode = cv2.imencode('.jpg', frame_get, encode_param) data = array(imgencode) stringdata = data.tostring() try: TCP_Socket.send((str(len(stringdata)).encode()).ljust(16)) TCP_Socket.send(stringdata) except: print(" OOPS! \nConnection Terminated by HOST!\nThread one has been Killed!\n :| ") quit() # <editor-fold desc="Second Thread -> Get Setting ↓"> ''' socket.recvfrom(bufsize[, flags]) Receive data from the socket. The return value is a pair (string, address) where string is a string representing the data received and address is the address of the socket sending the data. See the Unix manual page recv(2) for the meaning of the optional argument flags; it defaults to zero. (The format of address depends on the address family.) get setting by UDP connection and update flags ''' # </editor-fold> def get_setting(): global autonomous_flag
import socket #Setup UDP socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) #Conf. Host and Port HOSTNAME = '192.168.1.1' #drone ip, will be assigned by router PORT = 5555 RCVVID = 1 #boolean flag for receiving nav data, may need to change into a monitor or semaphore or other process control method #Connect socket.connect((HOSTNAME, PORT)) try: MSG = " " #initiates video data stream socket.send(MSG) #ack control command #MSG = "AT*CTRL=0" #socket.send(MSG) except socket.error, msg: print "Exception, Killing", msg; #socket.bind( (HOSTNAME,PORT) ) while True: data, addr = socket.recvfrom( 1024 ) # buffer size is 1024 bytes print "received message:", data socket.close()
import sys import socket sys.path.append('build/lib.linux-i686-2.6/') import ipfix import time print dir( ipfix ) cparser = ipfix.CParser() if __name__ == '__main__': socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) socket.bind( ('0.0.0.0', 6769) ) t1 = time.time() count = 0 while True: ( data, addr ) = socket.recvfrom( 4096 ) for pd in cparser.parse( data, addr[0] ): print pd.source_address, pd.destination_address, pd.octets, pd.packets count += 1 if count == 2000000: break print time.time() - t1
def transceive(socket, ip, data): print data socket.sendto(data, (ip, PORT)) print socket.recvfrom(1024**2)[0]
from urllib.parse import urlparse """ Testing example implementing a ping tool for CoAP devices. """ def ping(url, maxNum=5, maxTime=5): def inms(t): return "%f ms" % t * 1000.0 def ins(t): return "%f second" % t try: sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, timeout=maxTime) except Exception, e: print(type(e.reason)) print("Trying #{maxnum} times with #{dest} at port #{port}, waiting #{ins(maxtime)} max:") for tentative in range(maxNum): sock.sendto([0b01000000, 0, tentative].pack("CCn"), 0) response, addr = socket.recvfrom(100) if len(response) != 4: print(response, addr) else: hd, code, seq = response.unpack("CCn") if hd != 0b01110000 or code != 0 or seq != n: print((inms(Time.now-t[seq]) ), [hd.to_s(2), code, seq], addr) else: print("#{%d % n} #{inms(Time.now - t[n])} #{addr[2]}") ping("coap://coap.me:5683")
# print "Bad packet found. Ignoring..." if __name__ == "__main__": RoverDrivePort = get_controlPort(RoverDrivePortString) DrvSer = serial.Serial(RoverDrivePort, serbaud, timeout=sertimeout) time.sleep(2) DrvSer.write(chr(68)) time.sleep(2) Packet = "Ready" socket.sendto(Packet, (UDP_REMOTE, UDP_SEND)) data = None while 1: socket.sendto(Packet, (UDP_REMOTE, UDP_SEND)) data, addr = socket.recvfrom(1024) if data == "Ready": socket.sendto(Packet, (UDP_REMOTE, UDP_SEND)) break while 1: os.system("clear") data, addr = socket.recvfrom(1024) if data: estop = data[1] left = data[2] right = data[3] chksum = data[4] print "Left Value: " + str(int(ord(left))) print "Right Value: " + str(int(ord(right))) print "E-Stop: " + str(bool(int(ord(estop))))