Python select.select() Examples
The following are 30
code examples of select.select().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
select
, or try the search function
.
Example #1
Source File: flow.py From pwnypack with MIT License | 6 votes |
def interact(self): """ Interact with the socket. This will send all keyboard input to the socket and input from the socket to the console until an EOF occurs. """ sockets = [sys.stdin, self.channel] while True: ready = select.select(sockets, [], [])[0] if sys.stdin in ready: line = sys.stdin.readline().encode('latin1') if not line: break self.write(line) if self.channel in ready: self.read(1, echo=True)
Example #2
Source File: tls.py From oscrypto with MIT License | 6 votes |
def select_read(self, timeout=None): """ Blocks until the socket is ready to be read from, or the timeout is hit :param timeout: A float - the period of time to wait for data to be read. None for no time limit. :return: A boolean - if data is ready to be read. Will only be False if timeout is not None. """ # If we have buffered data, we consider a read possible if len(self._decrypted_bytes) > 0: return True read_ready, _, _ = select.select([self._socket], [], [], timeout) return len(read_ready) > 0
Example #3
Source File: _socket_proxy.py From oscrypto with MIT License | 6 votes |
def proxy(src, dst, callback=None): timeout = 10 try: read_ready, _, _ = select.select([src], [], [], timeout) while len(read_ready): if callback: callback(src, dst) else: dst.send(src.recv(8192)) read_ready, _, _ = select.select([src], [], [], timeout) except (socket.error, select.error, OSError, ValueError): pass try: src.shutdown(socket.SHUT_RDWR) except (socket.error, OSError, ValueError): pass src.close() try: dst.shutdown(socket.SHUT_RDWR) except (socket.error, OSError, ValueError): pass dst.close()
Example #4
Source File: pgexecute.py From pgcli with BSD 3-Clause "New" or "Revised" License | 6 votes |
def register_hstore_typecaster(conn): """ Instead of using register_hstore() which converts hstore into a python dict, we query the 'oid' of hstore which will be different for each database and register a type caster that converts it to unicode. http://initd.org/psycopg/docs/extras.html#psycopg2.extras.register_hstore """ with conn.cursor() as cur: try: cur.execute( "select t.oid FROM pg_type t WHERE t.typname = 'hstore' and t.typisdefined" ) oid = cur.fetchone()[0] ext.register_type(ext.new_type((oid,), "HSTORE", ext.UNICODE)) except Exception: pass
Example #5
Source File: XAsyncSockets.py From MicroWebSrv2 with MIT License | 6 votes |
def _doSSLHandshake(self) : count = 0 while count < 10 : try : self._socket.do_handshake() break except ssl.SSLError as sslErr : count += 1 if sslErr.args[0] == ssl.SSL_ERROR_WANT_READ : select([self._socket], [], [], 1) elif sslErr.args[0] == ssl.SSL_ERROR_WANT_WRITE : select([], [self._socket], [], 1) else : raise XAsyncTCPClientException('SSL : Bad handshake : %s' % sslErr) except Exception as ex : raise XAsyncTCPClientException('SSL : Handshake error : %s' % ex) # ------------------------------------------------------------------------
Example #6
Source File: socketserver.py From misp42splunk with GNU Lesser General Public License v3.0 | 6 votes |
def serve_forever(self, poll_interval=0.5): """Handle one request at a time until shutdown. Polls for shutdown every poll_interval seconds. Ignores self.timeout. If you need to do periodic tasks, do them in another thread. """ self.__is_shut_down.clear() try: while not self.__shutdown_request: # XXX: Consider using another file descriptor or # connecting to the socket to wake this up instead of # polling. Polling reduces our responsiveness to a # shutdown request and wastes cpu at all other times. r, w, e = _eintr_retry(select.select, [self], [], [], poll_interval) if self in r: self._handle_request_noblock() self.service_actions() finally: self.__shutdown_request = False self.__is_shut_down.set()
Example #7
Source File: socketserver.py From misp42splunk with GNU Lesser General Public License v3.0 | 6 votes |
def service_actions(self): """Called by the serve_forever() loop. May be overridden by a subclass / Mixin to implement any code that needs to be run during the loop. """ pass # The distinction between handling, getting, processing and # finishing a request is fairly arbitrary. Remember: # # - handle_request() is the top-level call. It calls # select, get_request(), verify_request() and process_request() # - get_request() is different for stream or datagram sockets # - process_request() is the place that may fork a new process # or create a new thread to finish the request # - finish_request() instantiates the request handler class; # this constructor will handle the request all by itself
Example #8
Source File: socketserver.py From misp42splunk with GNU Lesser General Public License v3.0 | 6 votes |
def handle_request(self): """Handle one request, possibly blocking. Respects self.timeout. """ # Support people who used socket.settimeout() to escape # handle_request before self.timeout was available. timeout = self.socket.gettimeout() if timeout is None: timeout = self.timeout elif self.timeout is not None: timeout = min(timeout, self.timeout) fd_sets = _eintr_retry(select.select, [self], [], [], timeout) if not fd_sets[0]: self.handle_timeout() return self._handle_request_noblock()
Example #9
Source File: socketserver.py From misp42splunk with GNU Lesser General Public License v3.0 | 6 votes |
def _handle_request_noblock(self): """Handle one request, without blocking. I assume that select.select has returned that the socket is readable before this function was called, so there should be no risk of blocking in get_request(). """ try: request, client_address = self.get_request() except socket.error: return if self.verify_request(request, client_address): try: self.process_request(request, client_address) except: self.handle_error(request, client_address) self.shutdown_request(request)
Example #10
Source File: wait.py From misp42splunk with GNU Lesser General Public License v3.0 | 6 votes |
def select_wait_for_socket(sock, read=False, write=False, timeout=None): if not read and not write: raise RuntimeError("must specify at least one of read=True, write=True") rcheck = [] wcheck = [] if read: rcheck.append(sock) if write: wcheck.append(sock) # When doing a non-blocking connect, most systems signal success by # marking the socket writable. Windows, though, signals success by marked # it as "exceptional". We paper over the difference by checking the write # sockets for both conditions. (The stdlib selectors module does the same # thing.) fn = partial(select.select, rcheck, wcheck, wcheck) rready, wready, xready = _retry_on_intr(fn, timeout) return bool(rready or wready or xready)
Example #11
Source File: wait.py From misp42splunk with GNU Lesser General Public License v3.0 | 6 votes |
def poll_wait_for_socket(sock, read=False, write=False, timeout=None): if not read and not write: raise RuntimeError("must specify at least one of read=True, write=True") mask = 0 if read: mask |= select.POLLIN if write: mask |= select.POLLOUT poll_obj = select.poll() poll_obj.register(sock, mask) # For some reason, poll() takes timeout in milliseconds def do_poll(t): if t is not None: t *= 1000 return poll_obj.poll(t) return bool(_retry_on_intr(do_poll, timeout))
Example #12
Source File: websocket.py From cproto with MIT License | 6 votes |
def _read_messages(self): while self.connected: try: r, w, e = select.select([self.sock], [], []) except select.error: break if r and self.connected: with self.cLock: data = self.recv() message = json.loads(data) # If id is present -> notifies main thread to return this message as a reply # Otherwise puts message into events queue so it will be dispatched as event if 'id' in message: self.replies[message['id']] = message self.cLock.notify() else: self.events.put(message)
Example #13
Source File: wait.py From misp42splunk with GNU Lesser General Public License v3.0 | 6 votes |
def select_wait_for_socket(sock, read=False, write=False, timeout=None): if not read and not write: raise RuntimeError("must specify at least one of read=True, write=True") rcheck = [] wcheck = [] if read: rcheck.append(sock) if write: wcheck.append(sock) # When doing a non-blocking connect, most systems signal success by # marking the socket writable. Windows, though, signals success by marked # it as "exceptional". We paper over the difference by checking the write # sockets for both conditions. (The stdlib selectors module does the same # thing.) fn = partial(select.select, rcheck, wcheck, wcheck) rready, wready, xready = _retry_on_intr(fn, timeout) return bool(rready or wready or xready)
Example #14
Source File: wait.py From misp42splunk with GNU Lesser General Public License v3.0 | 6 votes |
def _retry_on_intr(fn, timeout): if timeout is None: deadline = float("inf") else: deadline = monotonic() + timeout while True: try: return fn(timeout) # OSError for 3 <= pyver < 3.5, select.error for pyver <= 2.7 except (OSError, select.error) as e: # 'e.args[0]' incantation works for both OSError and select.error if e.args[0] != errno.EINTR: raise else: timeout = deadline - monotonic() if timeout < 0: timeout = 0 if timeout == float("inf"): timeout = None continue
Example #15
Source File: tiny_proxy.py From sslyze with GNU Affero General Public License v3.0 | 6 votes |
def _read_write(self, soc, max_idling=20): iw = [self.connection, soc] ow = [] count = 0 while 1: count += 1 (ins, _, exs) = select.select(iw, ow, iw, 3) if exs: break if ins: for i in ins: if i is soc: out = self.connection else: out = soc data = i.recv(8192) if data: out.send(data) count = 0 else: logging.warning("Idle") if count == max_idling: break
Example #16
Source File: pyopenssl.py From jawfish with MIT License | 6 votes |
def recv(self, *args, **kwargs): try: data = self.connection.recv(*args, **kwargs) except OpenSSL.SSL.SysCallError as e: if self.suppress_ragged_eofs and e.args == (-1, 'Unexpected EOF'): return b'' else: raise except OpenSSL.SSL.ZeroReturnError as e: if self.connection.get_shutdown() == OpenSSL.SSL.RECEIVED_SHUTDOWN: return b'' else: raise except OpenSSL.SSL.WantReadError: rd, wd, ed = select.select( [self.socket], [], [], self.socket.gettimeout()) if not rd: raise timeout('The read operation timed out') else: return self.recv(*args, **kwargs) else: return data
Example #17
Source File: wait.py From gist-alfred with MIT License | 6 votes |
def _retry_on_intr(fn, timeout): if timeout is None: deadline = float("inf") else: deadline = monotonic() + timeout while True: try: return fn(timeout) # OSError for 3 <= pyver < 3.5, select.error for pyver <= 2.7 except (OSError, select.error) as e: # 'e.args[0]' incantation works for both OSError and select.error if e.args[0] != errno.EINTR: raise else: timeout = deadline - monotonic() if timeout < 0: timeout = 0 if timeout == float("inf"): timeout = None continue
Example #18
Source File: wait.py From gist-alfred with MIT License | 6 votes |
def select_wait_for_socket(sock, read=False, write=False, timeout=None): if not read and not write: raise RuntimeError("must specify at least one of read=True, write=True") rcheck = [] wcheck = [] if read: rcheck.append(sock) if write: wcheck.append(sock) # When doing a non-blocking connect, most systems signal success by # marking the socket writable. Windows, though, signals success by marked # it as "exceptional". We paper over the difference by checking the write # sockets for both conditions. (The stdlib selectors module does the same # thing.) fn = partial(select.select, rcheck, wcheck, wcheck) rready, wready, xready = _retry_on_intr(fn, timeout) return bool(rready or wready or xready)
Example #19
Source File: wait.py From gist-alfred with MIT License | 6 votes |
def poll_wait_for_socket(sock, read=False, write=False, timeout=None): if not read and not write: raise RuntimeError("must specify at least one of read=True, write=True") mask = 0 if read: mask |= select.POLLIN if write: mask |= select.POLLOUT poll_obj = select.poll() poll_obj.register(sock, mask) # For some reason, poll() takes timeout in milliseconds def do_poll(t): if t is not None: t *= 1000 return poll_obj.poll(t) return bool(_retry_on_intr(do_poll, timeout))
Example #20
Source File: mitm_relay.py From mitm_relay with Apache License 2.0 | 6 votes |
def do_relay_udp(relay_sock, server, cfg): client = None while True: receiving, _, _ = select([relay_sock], [], []) if relay_sock in receiving: data, addr = relay_sock.recvfrom(BUFSIZE) if addr == server: data = proxify(data, cfg, client, server, to_server=False) relay_sock.sendto(data, client) else: client = addr data = proxify(data, cfg, client, server, to_server=True) relay_sock.sendto(data, server)
Example #21
Source File: socketserver.py From misp42splunk with GNU Lesser General Public License v3.0 | 6 votes |
def service_actions(self): """Called by the serve_forever() loop. May be overridden by a subclass / Mixin to implement any code that needs to be run during the loop. """ pass # The distinction between handling, getting, processing and # finishing a request is fairly arbitrary. Remember: # # - handle_request() is the top-level call. It calls # select, get_request(), verify_request() and process_request() # - get_request() is different for stream or datagram sockets # - process_request() is the place that may fork a new process # or create a new thread to finish the request # - finish_request() instantiates the request handler class; # this constructor will handle the request all by itself
Example #22
Source File: firefox_decrypt.py From firefox_decrypt with GNU General Public License v3.0 | 6 votes |
def ask_password(profile, interactive): """ Prompt for profile password """ if not PY3: profile = profile.encode(SYS_ENCODING) passmsg = "\nMaster Password for profile {0}: ".format(profile) if sys.stdin.isatty() and interactive: passwd = getpass(passmsg) else: # Ability to read the password from stdin (echo "pass" | ./firefox_...) if sys.stdin in select.select([sys.stdin], [], [], 0)[0]: passwd = sys.stdin.readline().rstrip("\n") else: LOG.warning("Master Password not provided, continuing with blank password") passwd = "" return py2_decode(passwd)
Example #23
Source File: socketserver.py From verge3d-blender-addon with GNU General Public License v3.0 | 6 votes |
def serve_forever(self, poll_interval=0.5): """Handle one request at a time until shutdown. Polls for shutdown every poll_interval seconds. Ignores self.timeout. If you need to do periodic tasks, do them in another thread. """ self.__is_shut_down.clear() try: while not self.__shutdown_request: # XXX: Consider using another file descriptor or # connecting to the socket to wake this up instead of # polling. Polling reduces our responsiveness to a # shutdown request and wastes cpu at all other times. r, w, e = _eintr_retry(select.select, [self], [], [], poll_interval) if self in r: self._handle_request_noblock() self.service_actions() finally: self.__shutdown_request = False self.__is_shut_down.set()
Example #24
Source File: socketserver.py From verge3d-blender-addon with GNU General Public License v3.0 | 6 votes |
def service_actions(self): """Called by the serve_forever() loop. May be overridden by a subclass / Mixin to implement any code that needs to be run during the loop. """ pass # The distinction between handling, getting, processing and # finishing a request is fairly arbitrary. Remember: # # - handle_request() is the top-level call. It calls # select, get_request(), verify_request() and process_request() # - get_request() is different for stream or datagram sockets # - process_request() is the place that may fork a new process # or create a new thread to finish the request # - finish_request() instantiates the request handler class; # this constructor will handle the request all by itself
Example #25
Source File: socketserver.py From verge3d-blender-addon with GNU General Public License v3.0 | 6 votes |
def handle_request(self): """Handle one request, possibly blocking. Respects self.timeout. """ # Support people who used socket.settimeout() to escape # handle_request before self.timeout was available. timeout = self.socket.gettimeout() if timeout is None: timeout = self.timeout elif self.timeout is not None: timeout = min(timeout, self.timeout) fd_sets = _eintr_retry(select.select, [self], [], [], timeout) if not fd_sets[0]: self.handle_timeout() return self._handle_request_noblock()
Example #26
Source File: socketserver.py From verge3d-blender-addon with GNU General Public License v3.0 | 6 votes |
def _handle_request_noblock(self): """Handle one request, without blocking. I assume that select.select has returned that the socket is readable before this function was called, so there should be no risk of blocking in get_request(). """ try: request, client_address = self.get_request() except socket.error: return if self.verify_request(request, client_address): try: self.process_request(request, client_address) except: self.handle_error(request, client_address) self.shutdown_request(request)
Example #27
Source File: agps3.py From gps3 with MIT License | 6 votes |
def next(self, timeout=0): """Return empty unless new data is ready for the client. Arguments: timeout: Default timeout=0 range zero to float specifies a time-out as a floating point number in seconds. Will sit and wait for timeout seconds. When the timeout argument is omitted the function blocks until at least one file descriptor is ready. A time-out value of zero specifies a poll and never blocks. """ try: waitin, _waitout, _waiterror = select.select((self.streamSock,), (), (), timeout) if not waitin: return else: gpsd_response = self.streamSock.makefile() # '.makefile(buffering=4096)' In strictly Python3 self.response = gpsd_response.readline() return self.response except StopIteration as error: sys.stderr.write('The readline exception in GPSDSocket.next is--> {}'.format(error))
Example #28
Source File: gps3.py From gps3 with MIT License | 6 votes |
def next(self, timeout=0): """Return empty unless new data is ready for the client. Arguments: timeout: Default timeout=0 range zero to float specifies a time-out as a floating point number in seconds. Will sit and wait for timeout seconds. When the timeout argument is omitted the function blocks until at least one file descriptor is ready. A time-out value of zero specifies a poll and never blocks. """ try: waitin, _waitout, _waiterror = select.select((self.streamSock,), (), (), timeout) if not waitin: return else: gpsd_response = self.streamSock.makefile() # '.makefile(buffering=4096)' In strictly Python3 self.response = gpsd_response.readline() return self.response except StopIteration as error: sys.stderr.write('The readline exception in GPSDSocket.next is--> {}'.format(error))
Example #29
Source File: socketserver.py From misp42splunk with GNU Lesser General Public License v3.0 | 6 votes |
def handle_request(self): """Handle one request, possibly blocking. Respects self.timeout. """ # Support people who used socket.settimeout() to escape # handle_request before self.timeout was available. timeout = self.socket.gettimeout() if timeout is None: timeout = self.timeout elif self.timeout is not None: timeout = min(timeout, self.timeout) fd_sets = _eintr_retry(select.select, [self], [], [], timeout) if not fd_sets[0]: self.handle_timeout() return self._handle_request_noblock()
Example #30
Source File: socketserver.py From misp42splunk with GNU Lesser General Public License v3.0 | 6 votes |
def _handle_request_noblock(self): """Handle one request, without blocking. I assume that select.select has returned that the socket is readable before this function was called, so there should be no risk of blocking in get_request(). """ try: request, client_address = self.get_request() except socket.error: return if self.verify_request(request, client_address): try: self.process_request(request, client_address) except: self.handle_error(request, client_address) self.shutdown_request(request)