Example #1
0
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
Example #4
0
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()
Example #6
0
  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)
Example #8
0
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))
Example #9
0
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)
Example #11
0
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()
Example #12
0
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****')
Example #13
0
 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.')
Example #14
0
def recv(socket):
    while True:
        try:
            data,addr = socket.recvfrom(1024)
            print(data.decode('utf-8'))
        except:
            return False
Example #15
0
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é")
Example #16
0
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))
Example #17
0
    def __dataThreadFunction(self, socket):

        while True:
            data, addr = socket.recvfrom(32768)

            if (len(data) > 0):
                self.__processMessage(data)
Example #18
0
    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)
Example #21
0
 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)
Example #22
0
 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)
Example #23
0
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()))
Example #24
0
 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)
Example #25
0
def broadcast_listener(socket):
    try:
        while True:
            data = socket.recvfrom(512)
            print(data)
    except KeyboardInterrupt:
        pass
Example #26
0
def receive_message():
    global initiator

    while True:

        message_in, _ = socket.recvfrom(4096)
        print('{}'.format(message_in.decode(encoding='UTF-8')))
Example #27
0
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)
Example #28
0
 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
Example #29
0
    def __grab_data__(self, socket):

        time.sleep(1)
        while self.streaming:
            data, address = socket.recvfrom(1024)
            jdata = json.loads(data)
            self.__refresh_data__(jdata)
Example #30
0
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
Example #31
0
    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
Example #32
0
 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)
Example #33
0
    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] )
Example #34
0
 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
Example #36
0
    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)
Example #38
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]
Example #40
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
Example #41
0
 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
Example #43
0
 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]
Example #44
0
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
Example #45
0
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)
Example #46
0
 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
Example #49
0
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))
Example #50
0
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]))
Example #51
0
 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
Example #52
0
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
Example #54
0
 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
Example #56
0
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()
Example #57
0
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]
Example #59
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")
Example #60
0

# 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))))