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)
python类SOL_SOCKET的实例源码
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 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 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 __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 __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 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)
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)
