Python socket.MSG_DONTWAIT() Examples

The following are code examples for showing how to use socket.MSG_DONTWAIT(). They are extracted from open source Python projects. You can vote up the examples you like or vote down the exmaples you don't like. You can also save this page to your account.

Example 1
Project: Static-UPnP   Author: nigelb   File: upnp_reciever.py    (license) View Source Project 7 votes vote down vote up
def socket_handler(self, queue, running):
        self.logger = logging.getLogger("UPnPServiceResponder.schedule_handler")
        self.logger.info("PID: %s"%os.getpid())
        register_worker_signal_handler(self.logger)
        while running.value:
            try:
                ready = select.select([self.multi_sock], [], [], 10)
                for sock in ready[0]:
                    rec = sock.recvfrom(self.buffer_size, socket.MSG_DONTWAIT)
                    # Don't log packets from out IP Addresses
                    if not rec[1][0] in self.ip_addresses:
                        self.logger.debug(rec)
                    queue.put(rec)
            except socket.error as se:
                pass
            except Exception as e:
                self.logger.error(e)

        self.do_notify(b"ssdp:goodbye")
        for sock in self.socks:
            sock.close()
        self.multi_sock.close()
        self.logger.warn("Socket Handler shutting down...") 
Example 2
Project: Static-UPnP   Author: nigelb   File: mDNS.py    (license) View Source Project 6 votes vote down vote up
def socket_handler(self, queue, running):
        self.logger = logging.getLogger("mDNSResponder.schedule_handler")
        self.logger.info("PID: %s" % os.getpid())
        register_worker_signal_handler(self.logger)
        while running.value:
            try:
                ready = select.select([self.multi_sock], [], [], 10)
                for sock in ready[0]:
                    rec = sock.recvfrom(self.buffer_size, socket.MSG_DONTWAIT)
                    self.logger.log(0, rec)
                    queue.put(rec)
            except socket.error as se:
                pass
            except Exception as e:
                self.logger.exception("Message")
            except KeyboardInterrupt as ki:
                time.sleep(1)

        for sock in self.socks:
            sock.close()
        self.multi_sock.close()
        self.logger.warn("Socket Handler shutting down...") 
Example 3
Project: BlueDot   Author: martinohanlon   File: btcomm.py    (license) View Source Project 6 votes vote down vote up
def _read(self):
        #read until the server is stopped or the client disconnects
        while self._client_connected:
            #read data from Bluetooth socket
            try:
                data = self._client_sock.recv(1024, socket.MSG_DONTWAIT)
            except IOError as e:
                self._handle_bt_error(e)
                data = b""
            if data:
                if self._data_received_callback:
                    if self._encoding:
                        data = data.decode(self._encoding)
                    self.data_received_callback(data)
            if self._conn_thread.stopping.wait(BLUETOOTH_TIMEOUT):
                break

        #close the client socket
        self._client_sock.close()
        self._client_sock = None
        self._client_info = None
        self._client_connected = False 
Example 4
Project: BlueDot   Author: martinohanlon   File: btcomm.py    (license) View Source Project 6 votes vote down vote up
def _read(self):
        #read until the client is stopped or the client disconnects
        while self._connected:
            #read data from Bluetooth socket
            try:
                data = self._client_sock.recv(1024, socket.MSG_DONTWAIT)
            except IOError as e:
                self._handle_bt_error(e)
                data = b""
            if data:
                #print("received [%s]" % data)
                if self._data_received_callback:
                    if self._encoding:
                        data = data.decode(self._encoding)
                    self.data_received_callback(data)
            if self._conn_thread.stopping.wait(BLUETOOTH_TIMEOUT):
                break 
Example 5
Project: zenchmarks   Author: squeaky-pl   File: test_sendmsg.py    (license) View Source Project 6 votes vote down vote up
def test_flags(self):
        """
        The C{flags} argument to L{send1msg} is passed on to the underlying
        C{sendmsg} call, to affect it in whatever way is defined by those
        flags.
        """
        # Just exercise one flag with simple, well-known behavior. MSG_DONTWAIT
        # makes the send a non-blocking call, even if the socket is in blocking
        # mode.  See also test_flags in RecvmsgTests
        for i in range(1024):
            try:
                send1msg(self.input.fileno(), "x" * 1024, MSG_DONTWAIT)
            except error as e:
                self.assertEqual(e.args[0], errno.EAGAIN)
                break
        else:
            self.fail(
                "Failed to fill up the send buffer, "
                "or maybe send1msg blocked for a while") 
Example 6
Project: zenchmarks   Author: squeaky-pl   File: test_sendmsg.py    (license) View Source Project 6 votes vote down vote up
def test_flags(self):
        """
        The C{flags} argument to L{sendmsg} is passed on to the underlying
        C{sendmsg} call, to affect it in whatever way is defined by those
        flags.
        """
        # Just exercise one flag with simple, well-known behavior. MSG_DONTWAIT
        # makes the send a non-blocking call, even if the socket is in blocking
        # mode.  See also test_flags in RecvmsgTests
        for i in range(1024):
            try:
                sendmsg(self.input, b"x" * 1024, flags=MSG_DONTWAIT)
            except error as e:
                self.assertEqual(e.args[0], errno.EAGAIN)
                break
        else:
            self.fail(
                "Failed to fill up the send buffer, "
                "or maybe send1msg blocked for a while") 
Example 7
Project: simulator   Author: P2PSP   File: simulator_stuff.py    (license) View Source Project 6 votes vote down vote up
def sendto(self, msg, address):
        self.lg.info("{} - [{}] -> {}".format(self.sock.getsockname(), \
                                              msg, \
                                              address))
        try:
            return self.sock.sendto(msg, socket.MSG_DONTWAIT, address + "_udp")
        except ConnectionRefusedError:
            self.lg.error("simulator_stuff.sendto: the message {} has not been delivered because the destination {} left the team".format(msg, address))
            raise
        except KeyboardInterrupt:
            self.lg.warning("simulator_stuff.sendto: send_packet {} to {}".format(msg, address))
            raise
        except FileNotFoundError:
            self.lg.error("simulator_stuff.sendto: {}".format(address + "_udp"))
            raise
        except BlockingIOError:
            raise 
Example 8
Project: solar   Author: mhvis   File: samil.py    (license) View Source Project 5 votes vote down vote up
def __make_request(self, identifier, payload, response_id=None):
        """Directly makes a request and returns the response."""
        # Acquire socket request lock
        with self.lock:
            # Cancel a (possibly) running keep-alive timer
            self.keep_alive.cancel()
            # Receive non-blocking, to clear the receive buffer
            try:
                self.sock.recv(1024, socket.MSG_DONTWAIT)
            except socket.error as err:
                if err.errno != 11:
                    raise err
            else:
                logger.info('Receive buffer was not empty before a request')
            request = _construct_request(identifier, payload)
            self.sock.send(request)
            # Receive message, possibly retrying when wrong message arrived
            while True:
                data = self.sock.recv(1024)
                response = _tear_down_response(data)
                if not response_id or response_id == response[0]:
                    break
                else:
                    logger.info('Received unexpected message, waiting for a '
                            'new one')
            logger.debug('Request: %s', request)
            logger.debug('Response: %s', response)
            # Set keep-alive timer
            self.keep_alive = threading.Timer(keep_alive_time, self.__keep_alive)
            self.keep_alive.daemon = True
            self.keep_alive.start()
        return response 
Example 9
Project: packet-queue   Author: google   File: libnetfilter_queue.py    (license) View Source Project 5 votes vote down vote up
def process(self):
    """Without blocking, read available packets and invoke their callbacks."""
    data = self.socket.recv(BUFFER_SIZE, socket.MSG_DONTWAIT)
    buf = ctypes.create_string_buffer(data)
    nfq.nfq_handle_packet(self.handle, buf, len(data)) 
Example 10
Project: igcollect   Author: innogames   File: haproxy.py    (license) View Source Project 5 votes vote down vote up
def read_ha_proxy_stats(haproxy_stats_socket):
    conn = socket(AF_UNIX, SOCK_STREAM)
    try:
        conn.connect(haproxy_stats_socket)
        conn.sendall(b'show stat\r\n')
        data = conn.recv(BUFFER_SIZE)
        while len(data) % BUFFER_SIZE == 0:
            try:
                data += conn.recv(BUFFER_SIZE, MSG_DONTWAIT)
            except socket.error:
                break
        return data
    finally:
        conn.close() 
Example 11
Project: pyrocket   Author: Contraz   File: socket.py    (license) View Source Project 5 votes vote down vote up
def _read(self, count, blocking=True):
        try:
            if blocking:
                data = self.sock.recv(count)
            else:
                data = self.sock.recv(count, socket.MSG_DONTWAIT)
        except BlockingIOError:
            return None

        if len(data) == 0:
            raise SocketConnError("Connection probably closed")
        return data 
Example 12
Project: web_ctp   Author: molebot   File: test_socket.py    (license) View Source Project 5 votes vote down vote up
def _testSendmsgTimeout(self):
        try:
            self.cli_sock.settimeout(0.03)
            with self.assertRaises(socket.timeout):
                while True:
                    self.sendmsgToServer([b"a"*512])
        finally:
            self.misc_event.set()

    # XXX: would be nice to have more tests for sendmsg flags argument.

    # Linux supports MSG_DONTWAIT when sending, but in general, it
    # only works when receiving.  Could add other platforms if they
    # support it too. 
Example 13
Project: web_ctp   Author: molebot   File: test_socket.py    (license) View Source Project 5 votes vote down vote up
def testSendmsgDontWait(self):
        # Check that MSG_DONTWAIT in flags causes non-blocking behaviour.
        self.assertEqual(self.serv_sock.recv(512), b"a"*512)
        self.assertTrue(self.misc_event.wait(timeout=self.fail_timeout)) 
Example 14
Project: web_ctp   Author: molebot   File: test_socket.py    (license) View Source Project 5 votes vote down vote up
def _testSendmsgDontWait(self):
        try:
            with self.assertRaises(socket.error) as cm:
                while True:
                    self.sendmsgToServer([b"a"*512], [], socket.MSG_DONTWAIT)
            self.assertIn(cm.exception.errno,
                          (errno.EAGAIN, errno.EWOULDBLOCK))
        finally:
            self.misc_event.set() 
Example 15
Project: ouroboros   Author: pybee   File: test_socket.py    (license) View Source Project 5 votes vote down vote up
def _testSendmsgTimeout(self):
        try:
            self.cli_sock.settimeout(0.03)
            with self.assertRaises(socket.timeout):
                while True:
                    self.sendmsgToServer([b"a"*512])
        finally:
            self.misc_event.set()

    # XXX: would be nice to have more tests for sendmsg flags argument.

    # Linux supports MSG_DONTWAIT when sending, but in general, it
    # only works when receiving.  Could add other platforms if they
    # support it too. 
Example 16
Project: ouroboros   Author: pybee   File: test_socket.py    (license) View Source Project 5 votes vote down vote up
def testSendmsgDontWait(self):
        # Check that MSG_DONTWAIT in flags causes non-blocking behaviour.
        self.assertEqual(self.serv_sock.recv(512), b"a"*512)
        self.assertTrue(self.misc_event.wait(timeout=self.fail_timeout)) 
Example 17
Project: ouroboros   Author: pybee   File: test_socket.py    (license) View Source Project 5 votes vote down vote up
def _testSendmsgDontWait(self):
        try:
            with self.assertRaises(OSError) as cm:
                while True:
                    self.sendmsgToServer([b"a"*512], [], socket.MSG_DONTWAIT)
            self.assertIn(cm.exception.errno,
                          (errno.EAGAIN, errno.EWOULDBLOCK))
        finally:
            self.misc_event.set() 
Example 18
Project: logdevourer   Author: Korbank   File: sources.py    (license) View Source Project 5 votes vote down vote up
def try_readlines(self):
        try:
            while True:
                msg = self.socket.recv(4096, socket.MSG_DONTWAIT)
                yield msg.rstrip("\n")
        except socket.error, e:
            if e.errno == errno.EWOULDBLOCK or e.errno == errno.EAGAIN:
                # this is expected when there's nothing in the socket queue
                return
            else:
                raise # other error, rethrow 
Example 19
Project: logdevourer   Author: Korbank   File: sources.py    (license) View Source Project 5 votes vote down vote up
def try_readlines(self):
        try:
            while True:
                msg = self.socket.recv(4096, socket.MSG_DONTWAIT)
                yield msg.rstrip("\n")
        except socket.error, e:
            if e.errno == errno.EWOULDBLOCK or e.errno == errno.EAGAIN:
                # this is expected when there's nothing in the socket queue
                return
            else:
                raise # other error, rethrow 
Example 20
Project: zenchmarks   Author: squeaky-pl   File: test_sendmsg.py    (license) View Source Project 5 votes vote down vote up
def test_flags(self):
        """
        The C{flags} argument to L{recv1msg} is passed on to the underlying
        C{recvmsg} call, to affect it in whatever way is defined by those
        flags.
        """
        # See test_flags in SendmsgTests
        reader, writer = socketpair(AF_UNIX)
        exc = self.assertRaises(
            error, recv1msg, reader.fileno(), MSG_DONTWAIT)
        self.assertEqual(exc.args[0], errno.EAGAIN) 
Example 21
Project: kbe_server   Author: xiaohaoppy   File: test_socket.py    (license) View Source Project 5 votes vote down vote up
def _testSendmsgTimeout(self):
        try:
            self.cli_sock.settimeout(0.03)
            with self.assertRaises(socket.timeout):
                while True:
                    self.sendmsgToServer([b"a"*512])
        finally:
            self.misc_event.set()

    # XXX: would be nice to have more tests for sendmsg flags argument.

    # Linux supports MSG_DONTWAIT when sending, but in general, it
    # only works when receiving.  Could add other platforms if they
    # support it too. 
Example 22
Project: kbe_server   Author: xiaohaoppy   File: test_socket.py    (license) View Source Project 5 votes vote down vote up
def testSendmsgDontWait(self):
        # Check that MSG_DONTWAIT in flags causes non-blocking behaviour.
        self.assertEqual(self.serv_sock.recv(512), b"a"*512)
        self.assertTrue(self.misc_event.wait(timeout=self.fail_timeout)) 
Example 23
Project: kbe_server   Author: xiaohaoppy   File: test_socket.py    (license) View Source Project 5 votes vote down vote up
def _testSendmsgDontWait(self):
        try:
            with self.assertRaises(OSError) as cm:
                while True:
                    self.sendmsgToServer([b"a"*512], [], socket.MSG_DONTWAIT)
            self.assertIn(cm.exception.errno,
                          (errno.EAGAIN, errno.EWOULDBLOCK))
        finally:
            self.misc_event.set() 
Example 24
Project: mitm_relay   Author: jrmdev   File: mitm_relay.py    (license) View Source Project 4 votes vote down vote up
def do_relay_tcp(client_sock, server_sock, cfg):
	server_sock.settimeout(1.0)   
	client_sock.settimeout(1.0)

	server_peer = server_sock.getpeername()
	client_peer = client_sock.getpeername()

	while True:

		# Peek for the beginnings of an ssl handshake
		try:
			packet = client_sock.recv(BUFSIZE, socket.MSG_PEEK | socket.MSG_DONTWAIT)

			if packet.startswith('\x16\x03'): # SSL/TLS Handshake.

				if not (cfg.cert and cfg.key):
					print color("[!] SSL/TLS handshake detected, provide a server cert and key to enable interception.", 1)
				
				else:
					print color('------------------ Wrapping sockets ------------------', 2)
					client_sock = ssl.wrap_socket(client_sock, server_side=True, suppress_ragged_eofs=True, certfile=cfg.cert.name, keyfile=cfg.key.name)
					server_sock = ssl.wrap_socket(server_sock, suppress_ragged_eofs=True)
		except:
			pass

		receiving, _, _ = select([client_sock, server_sock], [], [])


		try:
			if client_sock in receiving:
				data_out = client_sock.recv(BUFSIZE)

				if not len(data_out): # client closed connection
					print "[+] Client disconnected", client_peer
					client_sock.close()
					server_sock.close()
					break

				data_out = proxify(data_out, cfg, client_peer, server_peer, to_server=True)
				server_sock.send(data_out)

		 	if server_sock in receiving:
				data_in = server_sock.recv(BUFSIZE)

				if not len(data_in): # server closed connection
					print "[+] Server disconnected", server_peer
					client_sock.close()
					server_sock.close()
					break

				data_in = proxify(data_in, cfg, client_peer, server_peer, to_server=False)
				client_sock.send(data_in)

		except socket.error as e:
			print color("[!] %s" % str(e))