我们从Python开源项目中，提取了以下29个代码示例，用于说明如何使用socket.SHUT_RD。
def __serve(self, client, server): 'Private class method.' pairs = {client: server, server: client} while pairs: read, write, error = _select.select(pairs.keys(), [], []) for socket in read: string = socket.recv(self.BUFFERSIZE) if string: pairs[socket].sendall(string) else: pairs[socket].shutdown(_socket.SHUT_WR) socket.shutdown(_socket.SHUT_RD) del pairs[socket] client.close() server.close() ################################################################################
def _rd_shutdown(self, conn, once=False): """action when connection should be read-shutdown :type conn: socket.SocketType """ if conn in self.conn_rd: self.conn_rd.remove(conn) try: conn.shutdown(socket.SHUT_RD) except: pass if not once and conn in self.map: # use the `once` param to avoid infinite loop # if a socket is rd_shutdowned, then it's # pair should be wr_shutdown. self._wr_shutdown(self.map[conn], True) if self.map.get(conn) not in self.conn_rd: # if both two connection pair was rd-shutdowned, # this pair sockets are regarded to be completed # so we gonna close them self._terminate(conn)
def close_socket_for_read(self): """Close the server-client socket for reads incoming from client. We do not completly close the socket right now to allow late reads in the client side. But this socket will soon be closed. """ if self._sock is not None: self.outmsg("Closing socket for reads") try: self._sock.shutdown(socket.SHUT_RD) except Exception: # already closed pass self._sock_accept_reads = False
def stop(self, timeout=5): # OmniMarkupPreviewer: Force shutdown without waiting too much while self._get_qsize() > 0: conn = self.get() if conn is not _SHUTDOWNREQUEST: conn.close() # Must shut down threads here so the code that calls # this method can know when all threads are stopped. for worker in self._threads: self._queue.put(_SHUTDOWNREQUEST) # Don't join currentThread (when stop is called inside a request). current = threading.currentThread() if timeout and timeout >= 0: endtime = time.time() + timeout while self._threads: worker = self._threads.pop() if worker is not current and worker.isAlive(): try: if timeout is None or timeout < 0: worker.join() else: remaining_time = endtime - time.time() if remaining_time > 0: worker.join(remaining_time) if worker.isAlive(): # We exhausted the timeout. # Forcibly shut down the socket. c = worker.conn if c and not c.rfile.closed: try: c.socket.shutdown(socket.SHUT_RD) except TypeError: # pyOpenSSL sockets don't take an arg c.socket.shutdown() worker.join() except (AssertionError, # Ignore repeated Ctrl-C. # See https://bitbucket.org/cherrypy/cherrypy/issue/691. KeyboardInterrupt): pass
def stop(self, timeout=5): # Must shut down threads here so the code that calls # this method can know when all threads are stopped. for worker in self._threads: self._queue.put(_SHUTDOWNREQUEST) # Don't join currentThread (when stop is called inside a request). current = threading.currentThread() if timeout and timeout >= 0: endtime = time.time() + timeout while self._threads: worker = self._threads.pop() if worker is not current and worker.isAlive(): try: if timeout is None or timeout < 0: worker.join() else: remaining_time = endtime - time.time() if remaining_time > 0: worker.join(remaining_time) if worker.isAlive(): # We exhausted the timeout. # Forcibly shut down the socket. c = worker.conn if c and not c.rfile.closed: try: c.socket.shutdown(socket.SHUT_RD) except TypeError: # pyOpenSSL sockets don't take an arg c.socket.shutdown() worker.join() except (AssertionError, # Ignore repeated Ctrl-C. # See http://www.cherrypy.org/ticket/691. KeyboardInterrupt), exc1: pass
def forward(source, destination): string = ' ' while string: string = source.recv(1024) if string: destination.sendall(string) else: #source.shutdown(socket.SHUT_RD) destination.shutdown(socket.SHUT_WR)
def stop(self, timeout=5): # Must shut down threads here so the code that calls # this method can know when all threads are stopped. for worker in self._threads: self._queue.put(_SHUTDOWNREQUEST) # Don't join currentThread (when stop is called inside a request). current = threading.currentThread() while self._threads: worker = self._threads.pop() if worker is not current and worker.isAlive(): try: if timeout is None or timeout < 0: worker.join() else: worker.join(timeout) if worker.isAlive(): # We exhausted the timeout. # Forcibly shut down the socket. c = worker.conn if c and not c.rfile.closed: if SSL and isinstance(c.socket, SSL.ConnectionType): # pyOpenSSL.socket.shutdown takes no args c.socket.shutdown() else: c.socket.shutdown(socket.SHUT_RD) worker.join() except (AssertionError, # Ignore repeated Ctrl-C. # See http://www.cherrypy.org/ticket/691. KeyboardInterrupt), exc1: pass
def shutdown_raw(self, direction): if self.closed[direction]: return self.closed[direction] = True if direction == "send": try: self.sock.shutdown(socket.SHUT_WR) except IOError as e: if e.errno == errno.ENOTCONN: pass else: raise if direction == "recv": try: self.sock.shutdown(socket.SHUT_RD) except IOError as e: if e.errno == errno.ENOTCONN: pass else: raise if False not in self.closed.values(): self.close()
def shutdown_rd(self): """ Send a shutdown signal for reading - you may no longer read from this socket. """ return self.shutdown(socket.SHUT_RD)
def do_kill_pydev_thread(self): #We must close the socket so that it doesn't stay halted there. self.killReceived = True try: self.sock.shutdown(SHUT_RD) #shutdown the socket for read except: #just ignore that pass
def _shutdown_read(self): """Shutdown reading.""" with self._lock: if self.socket: try: self.socket.shutdown(socket.SHUT_RD) except: pass
def stop(self, timeout=5): # Must shut down threads here so the code that calls # this method can know when all threads are stopped. for worker in self._threads: self._queue.put(_SHUTDOWNREQUEST) # Don't join currentThread (when stop is called inside a request). current = threading.currentThread() if timeout and timeout >= 0: endtime = time.time() + timeout while self._threads: worker = self._threads.pop() if worker is not current and worker.isAlive(): try: if timeout is None or timeout < 0: worker.join() else: remaining_time = endtime - time.time() if remaining_time > 0: worker.join(remaining_time) if worker.isAlive(): # We exhausted the timeout. # Forcibly shut down the socket. c = worker.conn if c and not c.rfile.closed: try: c.socket.shutdown(socket.SHUT_RD) except TypeError: # pyOpenSSL sockets don't take an arg c.socket.shutdown() worker.join() except (AssertionError, # Ignore repeated Ctrl-C. # See # https://github.com/cherrypy/cherrypy/issues/691. KeyboardInterrupt): pass
def server(self): print "[+] Redirect with script injection initialized." self.dnsspoof.start(None,"Inject") server = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) server_address = (self.host, self.port) print '[+] Injection URL - http://{}:{}'.format(self.host,self.port) server.bind(server_address) server.listen(1) for i in range (0,2): if i >= 1: domain = self.dnsspoof.getdomain() domain = domain [:-1] print "[+] Target was requesting: {}".format(domain) self.dnsspoof.stop() try: connection,client_address = server.accept() redirect = self.response + """<body> <meta http-equiv="refresh" content="0; URL='http://{}"/> </body>""".format(domain) connection.send("%s" % redirect) print "[+] Script Injected on: ", client_address connection.shutdown(socket.SHUT_WR | socket.SHUT_RD) connection.close() except KeyboardInterrupt: server.close() try: connection,client_address = server.accept() connection.send("%s" % self.response) connection.shutdown(socket.SHUT_WR | socket.SHUT_RD) connection.close() except KeyboardInterrupt: server.close()
def _shutdown_connection(connection): if not connection.rfile.closed: connection.socket.shutdown(socket.SHUT_RD)
def test_shutdown_connection(self): class DummyObect(object): pass connection = DummyObect() connection.rfile = DummyObect() connection.rfile.closed = False connection.socket = self.mox.CreateMockAnything() connection.socket.shutdown(socket.SHUT_RD) self.mox.ReplayAll() self.thread_pool._shutdown_connection(connection) self.mox.VerifyAll()
def test_fake_socket_passes_through_shutdown(): import socket HTTPretty.enable() s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.truesock = MagicMock() expect(s.shutdown).called_with(socket.SHUT_RD).should_not.throw(AttributeError) s.truesock.shutdown.assert_called_with(socket.SHUT_RD)
