我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用socket.SOL_SOCKET。
def chat(host, port, task=None): task.set_daemon() sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) sock = pycos.AsyncSocket(sock) sock.bind((host, port)) sock.listen(128) print('server at %s' % str(sock.getsockname())) clients = set() try: while True: conn, addr = yield sock.accept() clients.add(conn) pycos.Task(client_send, clients, conn) except: for client in clients: client.shutdown(socket.SHUT_RDWR) client.close() raise
def __init__(self, addr="127.0.0.1", port=4444): """Initialize the socket and initialize pdb.""" # Backup stdin and stdout before replacing them by the socket handle self.old_stdout = sys.stdout self.old_stdin = sys.stdin # Open a 'reusable' socket to let the webapp reload on the same port self.skt = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.skt.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True) self.skt.bind((addr, port)) self.skt.listen(1) (clientsocket, address) = self.skt.accept() handle = clientsocket.makefile('rw') pdb.Pdb.__init__(self, completekey='tab', stdin=handle, stdout=handle) sys.stdout = sys.stdin = handle
def interact(self): from telnetlib import Telnet s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) s.bind((self._revHost, self._revPort)) s.listen(5) cli = s.accept()[0] s.close() print("[+] Got connect-back") t = Telnet() t.sock = cli t.interact()
def setup_sockets(self): self.sockets = {} ip_addresses = get_interface_addresses(self.logger) self.ip_addresses = ip_addresses multi_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP) multi_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) multi_sock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, self.ttl) for ip in ip_addresses: sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP) sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) mreq=socket.inet_aton(self.address)+socket.inet_aton(ip) multi_sock.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq) self.logger.info("Regestering multicast for: %s: %s"%(self.address, ip)) sock.bind((ip, self.port)) self.sockets[ip] = sock multi_sock.bind(("", self.port)) self.socks = [self.sockets[x] for x in self.sockets.keys()] self.multi_sock = multi_sock
def __init__(self, server_address): # Create a listening socket self.listen_socket = listen_socket = socket.socket( self.address_family, self.socket_type ) # Allow to reuse the same address listen_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # Bind listen_socket.bind(server_address) # Activate listen_socket.listen(self.request_queue_size) # Get server host name and port host, port = self.listen_socket.getsockname()[:2] self.server_name = socket.getfqdn(host) self.server_port = port # Return headers set by Web framework/Web application self.headers_set = []
def test_send_magic_packets(self, mock_socket): fake_socket = mock.Mock(spec=socket, spec_set=True) mock_socket.return_value = fake_socket() obj_utils.create_test_port(self.context, uuid=uuidutils.generate_uuid(), address='aa:bb:cc:dd:ee:ff', node_id=self.node.id) with task_manager.acquire( self.context, self.node.uuid, shared=True) as task: wol_power._send_magic_packets(task, '255.255.255.255', 9) expected_calls = [ mock.call(), mock.call().setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1), mock.call().sendto(mock.ANY, ('255.255.255.255', 9)), mock.call().sendto(mock.ANY, ('255.255.255.255', 9)), mock.call().close()] fake_socket.assert_has_calls(expected_calls) self.assertEqual(1, mock_socket.call_count)
def set_reuse_addr(self): # try to re-use a server port if possible try: self.socket.setsockopt( socket.SOL_SOCKET, socket.SO_REUSEADDR, self.socket.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR) | 1 ) except socket.error: pass # ================================================== # predicates for select() # these are used as filters for the lists of sockets # to pass to select(). # ==================================================
def _socketpair_compat(): """TCP/IP socketpair including Windows support""" listensock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_IP) listensock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) listensock.bind(("127.0.0.1", 0)) listensock.listen(1) iface, port = listensock.getsockname() sock1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_IP) sock1.setblocking(0) try: sock1.connect(("localhost", port)) except socket.error as err: if err.errno != errno.EINPROGRESS and err.errno != errno.EWOULDBLOCK and err.errno != EAGAIN: raise sock2, address = listensock.accept() sock2.setblocking(0) listensock.close() return (sock1, sock2)
def _handle_connect(self): err = self.socket.getsockopt(socket.SOL_SOCKET, socket.SO_ERROR) if err != 0: self.error = socket.error(err, os.strerror(err)) # IOLoop implementations may vary: some of them return # an error state before the socket becomes writable, so # in that case a connection failure would be handled by the # error path in _handle_events instead of here. if self._connect_future is None: gen_log.warning("Connect error on fd %s: %s", self.socket.fileno(), errno.errorcode[err]) self.close() return if self._connect_callback is not None: callback = self._connect_callback self._connect_callback = None self._run_callback(callback) if self._connect_future is not None: future = self._connect_future self._connect_future = None future.set_result(self) self._connecting = False
def __init__(self, ctx, sock=None): """Create SSL socket object @param ctx: SSL context @type ctx: OpenSSL.SSL.Context @param sock: underlying socket object @type sock: socket.socket """ if sock is not None: self.socket = sock else: self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.__ssl_conn = SSL.Connection(ctx, self.socket) self.buf_size = self.__class__.default_buf_size self._makefile_refs = 0
def bind(self, addr, port, tos, ttl, df): log.debug( "bind(addr=%s, port=%d, tos=%d, ttl=%d)", addr, port, tos, ttl) self.socket = socket.socket( socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP) self.socket.setsockopt(socket.IPPROTO_IP, socket.IP_TOS, tos) self.socket.setsockopt(socket.SOL_IP, socket.IP_TTL, ttl) self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.socket.bind((addr, port)) if df: if (sys.platform == "linux2"): self.socket.setsockopt(socket.SOL_IP, 10, 2) elif (sys.platform == "win32"): self.socket.setsockopt(socket.SOL_IP, 14, 1) elif (sys.platform == "darwin"): log.error("do-not-fragment can not be set on darwin") else: log.error("unsupported OS, ignore do-not-fragment option") else: if (sys.platform == "linux2"): self.socket.setsockopt(socket.SOL_IP, 10, 0)
def accept_thread(): global channels serversock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) serversock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) serversock.bind(("localhost", 39114)) serversock.listen(10) while True: client_sock, client_address = serversock.accept() msg = client_sock.recv(8192).strip().decode("utf-8") data = msg.split("\t") channel = data[0] print(len(data)) if len(data) <= 1: if channel in channels: del channels[channel] else: message = data[1] channels[channel] = message client_sock.close()
def connect(self): # create socket, connect to server, login and make a file object associated with the socket self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1) if self.aprs_filter: port = settings.APRS_SERVER_PORT_CLIENT_DEFINED_FILTERS else: port = settings.APRS_SERVER_PORT_FULL_FEED self.sock.connect((settings.APRS_SERVER_HOST, port)) self.logger.debug('Server port {}'.format(port)) login = create_aprs_login(self.aprs_user, -1, settings.APRS_APP_NAME, settings.APRS_APP_VER, self.aprs_filter) self.sock.send(login.encode()) self.sock_file = self.sock.makefile('rw') self._kill = False
def __init__(self, port=17935, clients=[], broadcast=True): util.Thread.__init__(self) self.port = port self.clients = clients msg = '\x00'.join(["PyritServerAnnouncement", '', str(port)]) md = hashlib.sha1() md.update(msg) self.msg = msg + md.digest() self.ucast_sckt = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) if broadcast: self.bcast_sckt = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self.bcast_sckt.bind(('', 0)) self.bcast_sckt.setsockopt(socket.SOL_SOCKET, \ socket.SO_BROADCAST, 1) else: self.bcast_sckt = None self.setDaemon(True) self.start()
def __init__(self, address, family, backlog=1): self._socket = socket.socket(getattr(socket, family)) try: self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self._socket.setblocking(True) self._socket.bind(address) self._socket.listen(backlog) self._address = self._socket.getsockname() except socket.error: self._socket.close() raise self._family = family self._last_accepted = None if family == 'AF_UNIX': self._unlink = Finalize( self, os.unlink, args=(address,), exitpriority=0 ) else: self._unlink = None
def listen(port=4444): global clisock, listening, done s = socket(AF_INET, SOCK_STREAM) s.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1) s.bind(('0.0.0.0', port)) s.listen(3) listening = True sock, addr = s.accept() clisock = sock print("Client connected from {}".format(addr)) data = "" while listening: try: rr, _, _ = select([sock,], [], [], 1) if rr: data = sock.recv(1024) print("{}".format(data), end="") except: exit() print("Done listening.") done = True
def _sock_connect_cb(self, fut, sock, address): if fut.cancelled(): return try: err = sock.getsockopt(socket.SOL_SOCKET, socket.SO_ERROR) if err != 0: # Jump to any except clause below. raise OSError(err, 'Connect call failed %s' % (address,)) except (BlockingIOError, InterruptedError): # socket is still registered, the callback will be retried later pass except Exception as exc: fut.set_exception(exc) else: fut.set_result(None)
def connect(self, conn, address): self._register_with_iocp(conn) # The socket needs to be locally bound before we call ConnectEx(). try: _overlapped.BindLocal(conn.fileno(), conn.family) except OSError as e: if e.winerror != errno.WSAEINVAL: raise # Probably already locally bound; check using getsockname(). if conn.getsockname()[1] == 0: raise ov = _overlapped.Overlapped(NULL) ov.ConnectEx(conn.fileno(), address) def finish_connect(trans, key, ov): ov.getresult() # Use SO_UPDATE_CONNECT_CONTEXT so getsockname() etc work. conn.setsockopt(socket.SOL_SOCKET, _overlapped.SO_UPDATE_CONNECT_CONTEXT, 0) return conn return self._register(ov, conn, finish_connect)
def test_create_server_sock(self): proto = asyncio.Future(loop=self.loop) class TestMyProto(MyProto): def connection_made(self, transport): super().connection_made(transport) proto.set_result(self) sock_ob = socket.socket(type=socket.SOCK_STREAM) sock_ob.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) sock_ob.bind(('0.0.0.0', 0)) f = self.loop.create_server(TestMyProto, sock=sock_ob) server = self.loop.run_until_complete(f) sock = server.sockets[0] self.assertIs(sock, sock_ob) host, port = sock.getsockname() self.assertEqual(host, '0.0.0.0') client = socket.socket() client.connect(('127.0.0.1', port)) client.send(b'xxx') client.close() server.close()
def run(self): try: self._tcpServer = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self._tcpServer.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self._tcpServer.bind((self._config.ip, self._config.port)) except socket.error: self._log.error("There was an error when trying to bind the server") exit(2) finally: self._log.info("Waiting for connections ...") while True: self._tcpServer.listen(4) (conn, (ip, port)) = self._tcpServer.accept() newthread = DownloadThread(conn, self._config) newthread.start() self.threads.append(newthread)
def server_loop(): global target if target == "0.0.0.0": log('w', "Listening interface not set, listening on all interfaces.") if ipv6: server = socket.socket(socket.AF_INET6, socket.SOCK_STREAM) else: server = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) server.bind((target, port)) server.listen(5) log('i', "Listening on %s:%i..." % (target, port)) if not single: while True: client_sock, addr = server.accept() log('s', 'New connection from %s:%i !' % (addr[0], addr[1])) handler_thr=threading.Thread(target=client_handler, args=(client_sock,)) handler_thr.daemon = True handler_thr.start() else: client_sock, addr = server.accept() log('s', 'New connection from %s:%i !' % (addr[0], addr[1])) client_handler(client_sock)
def echo_server(address): # Create a TCP/IP socket sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # Running several times with too small delay between executions, # could lead to: socket.error: [Errno 98] Address already in use sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True) # Associate the socket with the provided server address sock.bind(address) # Listen for incoming connections sock.listen(1) while True: # Wait for a connection connection, addr = sock.accept() # accept() returns an open connection between the server and client + the # address of the client. The connection is different socket on another port echo_handler(connection, addr)
def run(self): try: logger.info('Starting server on port %d' % self.port) self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.socket.bind((self.hostname, self.port)) self.socket.listen(self.backlog) while True: conn, addr = self.socket.accept() logger.debug('Accepted connection %r at address %r' % (conn, addr)) client = Client(conn, addr) self.handle(client) except Exception as e: logger.exception('Exception while running the server %r' % e) finally: logger.info('Closing server socket') self.socket.close()
def _prepare_server_socket(self): try: self.inmsg( '# Connecting Listening socket to IP: {0} PORT: {1}'.format( self.hostip, self.port)) self.listen_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.listen_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.listen_sock.bind((self.hostip, self.port)) self.listen_sock.listen(self.queue) self.inmsg('# Start Listening with queue size {0}'.format( self.queue)) except socket.error as msg: self.inmsg("[ERROR] {0}".format(msg)) raise Exception('error creating listening socket')
def get_free_ports(num_ports, ip='127.0.0.1'): """Get `num_ports` free/available ports on the interface linked to the `ip´ :param int num_ports: The number of free ports to get :param str ip: The ip on which the ports have to be taken :return: a set of ports number """ sock_ports = [] ports = set() try: for _ in range(num_ports): sock = socket.socket() cur = [sock, -1] # append the socket directly, # so that it'll be also closed (no leaked resource) # in the finally here after. sock_ports.append(cur) sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) sock.bind((ip, 0)) cur[1] = sock.getsockname()[1] finally: for sock, port in sock_ports: sock.close() ports.add(port) assert num_ports == len(ports) return ports
def handle_connect_event(self): if not self.handshaking: err = self.socket.getsockopt(socket.SOL_SOCKET, socket.SO_ERROR) if err != 0: raise socket.error(err, _strerror(err)) self.socket = ssl.wrap_socket (self.socket, do_handshake_on_connect = False) self.handshaking = True try: self.socket.do_handshake () except ssl.SSLError as why: if why.args[0] in (ssl.SSL_ERROR_WANT_READ, ssl.SSL_ERROR_WANT_WRITE): return # retry handshake raise ssl.SSLError(why) # handshaking done self.handle_connect() self.connected = True
def __init__(self, queue, options): """Init the pixelVloed server""" self.debug = options.debug if options.debug else False self.pixeloffset = 2 self.fps = 30 self.screen = None self.udp_ip = options.ip if options.ip else UDP_IP self.udp_port = options.port if options.port else UDP_PORT self.factor = options.factor if options.factor else 1 self.canvas() self.set_title() self.queue = queue self.limit = options.maxpixels if options.maxpixels else MAX_PIXELS self.pixels = None self.broadcastsocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self.broadcastsocket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1) self.broadcastsocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
def __init__(self, queue, options): """Init the pixelVloed server""" self.debug = options.debug if options.debug else False self.pixeloffset = 2 self.fps = 30 self.screen = None self.udp_ip = options.ip if options.ip else UDP_IP self.udp_port = options.port if options.port else UDP_PORT self.factor = options.factor if options.factor else 1 self.canvas() self.queue = queue self.limit = options.maxpixels if options.maxpixels else MAX_PIXELS self.pixels = None self.broadcastsocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self.broadcastsocket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1) self.broadcastsocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
def FindLocalIP(Iface, OURIP): if Iface == 'ALL': return '0.0.0.0' try: if IsOsX(): return OURIP elif OURIP == None: s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) s.setsockopt(socket.SOL_SOCKET, 25, Iface+'\0') s.connect(("127.0.0.1",9))#RFC 863 ret = s.getsockname()[0] s.close() return ret return OURIP except socket.error: print color("[!] Error: %s: Interface not found" % Iface, 1) sys.exit(-1) # Function used to write captured hashs to a file.
def _setup_connection(self, dstaddr, timeout=None): port = randint(10000, 60000) af, socktype, proto, _canonname, _sa = socket.getaddrinfo(dstaddr, port, socket.AF_INET, socket.SOCK_DGRAM)[0] s = socket.socket(af, socktype, proto) has_bind = 1 for _i in range(0, 10): # We try to bind to a port for 10 tries try: s.bind((INADDR_ANY, randint(10000, 60000))) s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1) has_bind = 1 except socket.error: pass if not has_bind: raise NetBIOSError, ('Cannot bind to a good UDP port', ERRCLASS_OS, errno.EAGAIN) self.__sock = s
def _receive_master(self): s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) # incase 'Address already in use error' s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) s.bind(('',self._s_port)) LOG.debug('listen on port:%d'%self._s_port) s.listen(1) sock, addr=s.accept() LOG.debug('receive from master host...') buff='' while True: d=sock.recv(4096) buff+=d if d.find('__EOF__')!=-1: break sock.send('ack') sock.close() s.close() # cut off last __EOF__ buff=buff[:-7] # return to origin args buff=buff.replace('__EOF___','__EOF__') return buff
def clientScan(report = None): try: s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1) s.settimeout(30) s.bind(('', 8000)) buf, address = s.recvfrom(64) address = address[0] port = int(str(buf, encoding='utf8')) reporting(report, "Master server found") return (address, port) except socket.timeout: reporting(report, "No master server on network", IOError) return ("", 8000) # return default values
def runp (self): host = '' port = 20666 server = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) server.bind((host,port)) server.listen(1) while True: client, addr = server.accept () if addr[0] != "127.0.0.1": client.send("Hacked By China!") client.close() continue request = client.recv(8192) request = request.split('\n') path = request[0].split()[1] client.send("HTTP/1.0 200 OK\r\n") client.send("Content-Type: text/html\r\n\r\n") if path == "/": client.send(json.dumps(self.sessions)) client.close()
def server(host, port, task=None): task.set_daemon() sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # setup socket for asynchronous I/O with pycos sock = pycos.AsyncSocket(sock) sock.bind((host, port)) sock.listen(128) while True: conn, addr = yield sock.accept() # create a task to process connection pycos.Task(process, conn) # pycos.logger.setLevel(pycos.Logger.DEBUG)
def server(host, port, task=None): task.set_daemon() sock = pycos.AsyncSocket(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) sock.bind((host, port)) sock.listen(5000) while True: conn, addr = yield sock.accept() pycos.Task(process, conn)
def discover_peers(self, port=None): """This method can be invoked (periodically?) to broadcast message to discover peers, if there is a chance initial broadcast message may be lost (as these messages are sent over UDP). """ ping_msg = {'signature': self._signature, 'name': self._name, 'version': __version__} def _discover(addrinfo, port, task=None): ping_sock = AsyncSocket(socket.socket(addrinfo.family, socket.SOCK_DGRAM)) ping_sock.settimeout(2) if addrinfo.family == socket.AF_INET: ping_sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1) else: # addrinfo.family == socket.AF_INET6 ping_sock.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_MULTICAST_HOPS, struct.pack('@i', 1)) ping_sock.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_MULTICAST_IF, addrinfo.ifn) ping_sock.bind((addrinfo.ip, 0)) if not port: port = addrinfo.udp_sock.getsockname()[1] ping_msg['location'] = addrinfo.location try: yield ping_sock.sendto('ping:'.encode() + serialize(ping_msg), (addrinfo.broadcast, port)) except: pass ping_sock.close() for addrinfo in self._addrinfos: SysTask(_discover, addrinfo, port)
