def create_broadcast_sockets():
sender = Socket(AF_INET, SOCK_DGRAM)
sender.setsockopt(SOL_SOCKET, SO_REUSEADDR, True)
sender.setsockopt(SOL_SOCKET, SO_BROADCAST, True)
sender.bind(("", 0))
receiver = Socket(AF_INET, SOCK_DGRAM)
receiver.settimeout(constants.broadcast_receiver_timeout)
receiver.setsockopt(SOL_SOCKET, SO_REUSEADDR, True)
receiver.setsockopt(SOL_SOCKET, SO_BROADCAST, True)
receiver.bind(("", constants.broadcast_port))
return sender, receiver
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--port',
'-p',
default=2000,
type=int,
help='port to use')
args = parser.parse_args()
server_socket = Socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server_socket.bind(('', args.port))
server_socket.listen(1)
print "server running"
while True:
connection_socket = server_socket.accept()[0]
request = connection_socket.recv(1024)
reply = http_handler(request)
connection_socket.send("HTTP/1.1 200 OK\n")
connection_socket.send("\n")
connection_socket.send(reply)
connection_socket.close()
print "received request"
print "reply sent"
return 0
def _set_nodelay(sock: socket.socket) -> None:
if (
sock.family in {socket.AF_INET, socket.AF_INET6}
and sock.type & _sock_type_mask == socket.SOCK_STREAM
and sock.proto == socket.IPPROTO_TCP
):
sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
def bind_unused_port(
sock: socket.socket,
host: Union[str, ipaddress.IPv4Address,
ipaddress.IPv6Address] = 'localhost'
) -> int:
"""Bind the socket to a free port and return the port number.
This code is based on the code in the stdlib's test.test_support module."""
if sock.family in (socket.AF_INET,
socket.AF_INET6) and sock.type == socket.SOCK_STREAM:
if hasattr(socket, "SO_EXCLUSIVEADDRUSE"):
with contextlib.suppress(socket.error):
sock.setsockopt(socket.SOL_SOCKET, socket.SO_EXCLUSIVEADDRUSE,
1)
if not isinstance(host, str):
host = str(host)
if sock.family == socket.AF_INET:
if host == 'localhost':
sock.bind(('127.0.0.1', 0))
else:
sock.bind((host, 0))
elif sock.family == socket.AF_INET6:
if host == 'localhost':
sock.bind(('::1', 0, 0, 0))
else:
sock.bind((host, 0, 0, 0))
else:
raise CommunicationError("unsupported socket family: " +
str(sock.family))
return sock.getsockname()[1]
def _set_keepalive_windows(sock: socket.socket,
keep_alive_time: int = 1,
keep_alive_interval: int = 3,
max_probes: int = 5):
"""
Set TCP keepalive on an open socket.
If keep alive is on (1)
it activates after 1 second (keep_alive_time) of idleness,
then sends a keepalive ping once every 3 seconds (keep_alive_interval),
for 10 times, because for Windwos Vista and higher this number is
fixed and can not be changed.
All time params are measured in ms
"""
second = 1000
struct_format = 'hh' if platform.system() == 'Windows' else 'ii'
l_onoff = 0
l_linger = 10
sock.setsockopt(socket.SOL_SOCKET, socket.SO_LINGER,
struct.pack(struct_format, l_onoff, l_linger))
sock.ioctl(socket.SIO_KEEPALIVE_VALS,
(1, keep_alive_time * second, keep_alive_interval * second))
def main():
register_builtin_interface()
server = Socket()
if len(sys.argv) > 1:
server_port = int(sys.argv[1])
else:
server_port = DEFAULT_PORT
print "Listening on port " + str(server_port)
server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
server.bind(("", server_port))
server.listen(50)
Thread(target=process_event_queue).start()
print "\nAutobus has successfully started up."
try:
while True:
socket, address = server.accept()
connection = Connection(socket, address)
event_queue.put((connection.id, discard_args(connection.register)), block=True)
connection.start()
except KeyboardInterrupt:
print "KeyboardInterrupt received, shutting down"
event_queue.put((None, None), block=True)
print "Event queue has been notified to shut down"
except:
print "Unexpected exception occurred in the main loop, shutting down. Stack trace:"
print_exc()
event_queue.put((None, None), block=True)
print "Event queue has been notified to shut down"
server.close()
def _set_socket_options(sock: socket.socket,
options: Optional[_TYPE_SOCKET_OPTIONS]) -> None:
if options is None:
return
for opt in options:
sock.setsockopt(*opt)
def output_worker(controller: 'SpotifyController', address: str, port: int,
sock: socket.socket, stdout: Optional[IO[AnyStr]]):
# Connect to address
sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
sock.connect((address, port))
# Clear stdout
if stdout.seekable() and platform.system() == "Linux":
stdout.seek(-8, os.SEEK_END)
else:
print("Cannot seek in stdout")
# Start sending data
try:
while (not stdout.closed) or (not controller.stop_threads):
# Read and send 0.25 seconds of audio
sock.send(stdout.read(CHUNK_SIZE))
# Wait 250ms before reading the next chunk
time.sleep(0.25)
except (ConnectionResetError, BrokenPipeError, OSError):
print(
"Disconnected from bot. Either user disconnected, bot disconnected or there are connection problems."
)
controller.on_bot_disconnect()
finally:
if sock is not None:
sock.close()
print(f"OutputWorker stopped")
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--port', '-p', default=8080, type=int,
help='Port to use')
args = parser.parse_args()
try:
server_socket = Socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, BUFFER_SIZE)
server_socket.bind(('', args.port))
server_socket.listen(1)
cache_dict = {}
print "Proxy server ready..."
while True:
try:
connection_socket = server_socket.accept()[0]
t = Thread(target=handle_http, args=[cache_dict, connection_socket])
t.setDaemon(1)
t.start()
t.join()
except socket.error, e:
print e
finally:
connection_socket.close()
def run_server(server_port):
"""Run the UDP pinger server
"""
# Create the server socket (to handle UDP requests using ipv4), make sure
# it is always closed by using with statement.
server_socket = Socket(socket.AF_INET, socket.SOCK_DGRAM)
# The socket stays connected even after this script ends. So in order
# to allow the immediate reuse of the socket (so that we can kill and
# re-run the server while debugging) we set the following option. This
# is potentially dangerous in real code: in rare cases you may get junk
# data arriving at the socket.
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# Set the server port
server_socket.bind(("", server_port))
# Start accepting ping requests
print ("Ping server ready on port", server_port)
while True:
# Receive message and send one back
_, client_address = server_socket.recvfrom(1024)
server_socket.sendto("Pong".encode(), client_address)
return 0
def bind_unused_port(sock: socket.socket, host: str = 'localhost') -> int:
"""Bind the socket to a free port and return the port number.
This code is based on the code in the stdlib's test.test_support module."""
if sock.family in (socket.AF_INET,
socket.AF_INET6) and sock.type == socket.SOCK_STREAM:
if hasattr(socket, "SO_EXCLUSIVEADDRUSE"):
try:
sock.setsockopt(socket.SOL_SOCKET, socket.SO_EXCLUSIVEADDRUSE,
1)
except socket.error:
pass
if sock.family == socket.AF_INET:
if host == 'localhost':
sock.bind(('127.0.0.1', 0))
else:
sock.bind((host, 0))
elif sock.family == socket.AF_INET6:
if host == 'localhost':
sock.bind(('::1', 0, 0, 0))
else:
sock.bind((host, 0, 0, 0))
else:
raise CommunicationError("unsupported socket family: " +
str(sock.family))
return sock.getsockname()[1]
def _save_ttl(sock: socket.socket):
old_ttl = sock.getsockopt(socket.SOL_IP, socket.IP_TTL)
try:
yield
finally:
sock.setsockopt(socket.SOL_IP, socket.IP_TTL, old_ttl)
return
def disable_ipv6_only_or_raise(s: socket.socket) -> None:
"""Make V6 sockets work for both V4 and V6 (required for Windows)."""
try:
s.setsockopt(_IPPROTO_IPV6, socket.IPV6_V6ONLY, False)
except OSError:
log.error(
'Support for dual V4-V6 sockets is not present, use IPVersion.V4 or IPVersion.V6'
)
raise
def _set_keepalive_osx(sock: socket.socket, keep_alive_interval: int = 3):
"""
Set TCP keepalive on an open socket.
sends a keepalive ping once every 3 seconds (keep_alive_interval)
"""
# scraped from /usr/include, not exported by python's socket module
TCP_KEEPALIVE = 0x10
sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
sock.setsockopt(socket.IPPROTO_TCP, TCP_KEEPALIVE, keep_alive_interval)
def _listen(self, sock: socket.socket):
"""Open up a listener for a client to connect to.
Args:
sock (socket.socket): connection to client
"""
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.bind((self.host, self.port))
sock.listen(1)
self._sock, _ = sock.accept()
def server_init(sock: socket.socket, address: tuple, timeout):
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.settimeout(timeout)
try:
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
except AttributeError:
pass
except socket.error as e:
if e.errno != errno.ENOPROTOOPT:
raise
sock.bind(address)
def __init__(self): global server_socket, serverpid server_socket = Socket(AF_INET, SOCK_STREAM) server_socket.setblocking(0) try: server_socket.setsockopt(SOL_SOCKET, SO_REUSEADDR, server_socket.getsockopt(SOL_SOCKET, SO_REUSEADDR) | 1) except error: pass serverpid = server_socket.fileno() pollster.register(serverpid, RE)
class TCPSocket(Socket):
def __init__(self, socket=None):
# Create a default socket if given None
self.__socket = Socket(AF_INET6,
SOCK_STREAM) if socket is None else socket
# Set to re-use the address to avoid error: "Address already in use"
self.__socket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
@property
def socket(self):
return self.__socket
def accept(self):
# Wraps the socket in our custom TCPSocket class
socket, addr = self.socket.accept()
return TCPSocket(socket), addr
def bind(self, addr):
self.socket.bind(addr)
def close(self):
self.socket.close()
def connect(self, addr):
self.socket.connect(addr)
def listen(self):
self.socket.listen()
def recv(self, size=None):
# If size isn't valid, get 4 bytes of data and use that instead
if type(size) != int:
size = int.from_bytes(self.socket.recv(4), 'big')
# Our data is encoded using base64 encoder (smaller size and more secure)
try:
return json.loads(
b64decode(self.socket.recv(size)).decode('utf-8'))
except:
return dict()
def send(self, obj):
# Only accept strings or dict objects
if type(obj) == str:
obj = {'type': 'MESSAGE', 'message': obj}
if type(obj) != dict:
raise Exception(
'TCPSocket::send(...) expects a str or dict at argument 1!')
# Encode our stringified json using base64
content = b64encode(json.dumps(obj).encode('utf-8'))
# Get the size (4-bytes with big-endian encoding)
size = len(content).to_bytes(4, 'big')
# Send the data
self.socket.send(size + content)
def main():
# Command line arguments. Use a port > 1024 by default so that we can run
# without sudo, for use as a real server you need to use port 80.
parser = argparse.ArgumentParser()
parser.add_argument('--port',
'-p',
default=2080,
type=int,
help='Port to use')
args = parser.parse_args()
# Create the server socket (to handle tcp requests using ipv4), make sure
# it is always closed by using with statement.
#with Socket(socket.AF_INET, socket.SOCK_STREAM) as server_socket:
ss = Socket(socket.AF_INET, socket.SOCK_STREAM)
# COMPLETE (1)
# The socket stays connected even after this script ends. So in order
# to allow the immediate reuse of the socket (so that we can kill and
# re-run the server while debugging) we set the following option. This
# is potentially dangerous in real code: in rare cases you may get junk
# data arriving at the socket.
ss.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# COMPLETE (2)
endpoint = ('', args.port)
# COMPLETE (3)
ss.bind(endpoint)
ss.listen(1)
print("server ready")
while True:
cs = ss.accept()[0]
request = cs.recv(1024).decode('ascii')
print(request)
reply = http_handle(request)
cs.send(reply.encode('ascii'))
print("\n\nReceived request")
print("======================")
print(request.rstrip())
print("======================")
print("\n\nReplied with")
print("======================")
print(reply.rstrip())
print("======================")
return 0
def listen(self):
"""
Bind and listen.
:return: The open socket.
:rtype: socket.socket
"""
address = (self.host, self.port)
socket = Socket(AF_INET, SOCK_STREAM)
socket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
socket.bind(address)
socket.listen(5)
log.info('listening on: %d', self.port)
return socket
def listen(self):
"""
Bind and listen.
:return: The open socket.
:rtype: socket.socket
"""
address = (self.host, self.port)
socket = Socket(AF_INET, SOCK_STREAM)
socket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
socket.bind(address)
socket.listen(5)
log.info('listening on: %d', self.port)
return socket
def main():
dnsSocket = Socket(socket.AF_INET, socket.SOCK_STREAM)
dnsSocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# Comunicacao com o server
############################
dnsSocket.bind(('', 2010))
dnsSocket.listen(1)
print('------------Conectou com o SERVER')
connection_socket = dnsSocket.accept()[0]
print('Aceitou conexão com o SERVER')
msg = connection_socket.recv(1024).decode('ascii')
domainName, ipAddress = msg.split("#")
#domainName = connection_socket.recv(1024).decode('ascii')
#print(domainName)
#ipAddress = connection_socket.recv(1024).decode('ascii')
print('Recebi do SERVER o dominio: ' + domainName)
print('Recebi do SERVER o IP: ' + ipAddress)
map[domainName] = ipAddress
connection_socket.send('Mensagem do DNS para o SERVER'.encode('ascii'))
############################
# Comunicacao com o Client
############################
UDPServerSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
UDPServerSocket.bind(('localhost', 2001))
while (True):
bytesAddressPair = UDPServerSocket.recvfrom(1024)
domainName = bytesAddressPair[0].decode('ascii')
address = bytesAddressPair[1]
print('Recebi do Client: ' + domainName + ' ' + str(address))
if not domainName:
break
if (domainName in map):
msg = map.get(domainName)
#connection_socket.send(ipAddress.encode('ascii'))
else:
msg = 'Nao existe esse dominio'
#connection_socket.send(msg.encode('ascii'))
UDPServerSocket.sendto(msg.encode('ascii'), address)
"""
def anetKeepAlive(fd: socket.socket, interval: int) -> None:
if sys.platform != 'linux':
fd.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
return
fd.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, interval)
fd.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, interval // 3 or 1)
fd.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 3)
def forward_connection(self, server_socket: socket.socket):
self.client_socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY,
1)
server_socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
self.log.debug(
f"start forwarding {self.client_socket.getpeername()[0]}:{self.client_socket.getpeername()[1]} "
f"<----->"
f" {server_socket.getpeername()[0]}:{server_socket.getpeername()[1]}"
)
while not self.stop:
(read, write, exp) = select.select(
[self.client_socket, server_socket],
[],
[self.client_socket, server_socket],
1,
)
if len(exp) != 0:
self.stop = True
if self.client_socket in read:
try:
data = self.client_socket.recv(65535)
if data == b"":
self.stop = True
except socket.error:
self.stop = True
finally:
self.log.debug(f"client>server: {len(data)} Bytes...")
server_socket.send(data)
if server_socket in read:
try:
data = server_socket.recv(65535)
if data == b"":
self.stop = True
except socket.error:
self.stop = True
finally:
self.log.debug(f"server>client: {len(data)} Bytes...")
self.client_socket.send(data)
self.log.debug(
f"stop forwarding {self.client_socket.getpeername()[0]}:{self.client_socket.getpeername()[1]} "
f"<----->"
f" {server_socket.getpeername()[0]}:{server_socket.getpeername()[1]}"
)
def set_so_reuseport_if_available(s: socket.socket) -> None:
"""Set SO_REUSEADDR on a socket if available."""
# SO_REUSEADDR should be equivalent to SO_REUSEPORT for
# multicast UDP sockets (p 731, "TCP/IP Illustrated,
# Volume 2"), but some BSD-derived systems require
# SO_REUSEPORT to be specified explicitly. Also, not all
# versions of Python have SO_REUSEPORT available.
# Catch OSError and socket.error for kernel versions <3.9 because lacking
# SO_REUSEPORT support.
if not hasattr(socket, 'SO_REUSEPORT'):
return
try:
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1) # pylint: disable=no-member
except OSError as err:
if err.errno != errno.ENOPROTOOPT:
raise
def run_server(server_port):
# Run UDP pinger server
try:
server_socket = Socket(socket.AF_INET, socket.SOCK_DGRAM)
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server_socket.bind(('', server_port))
print("Ping server ready on port", server_port)
while True:
_, client_address = server_socket.recvfrom(1024)
server_socket.sendto("".encode(), client_address)
finally:
server_socket.close()
return 0
def add_multicast_member(
listen_socket: socket.socket,
interface: Union[str, Tuple[Tuple[str, int, int], int]],
) -> bool:
# This is based on assumptions in normalize_interface_choice
is_v6 = isinstance(interface, tuple)
err_einval = {errno.EINVAL}
if sys.platform == 'win32':
# No WSAEINVAL definition in typeshed
err_einval |= {cast(Any, errno).WSAEINVAL} # pylint: disable=no-member
log.debug('Adding %r (socket %d) to multicast group', interface,
listen_socket.fileno())
try:
if is_v6:
iface_bin = struct.pack('@I', cast(int, interface[1]))
_value = _MDNS_ADDR6_BYTES + iface_bin
listen_socket.setsockopt(_IPPROTO_IPV6, socket.IPV6_JOIN_GROUP,
_value)
else:
_value = _MDNS_ADDR_BYTES + socket.inet_aton(cast(str, interface))
listen_socket.setsockopt(socket.IPPROTO_IP,
socket.IP_ADD_MEMBERSHIP, _value)
except socket.error as e:
_errno = get_errno(e)
if _errno == errno.EADDRINUSE:
log.info(
'Address in use when adding %s to multicast group, '
'it is expected to happen on some systems',
interface,
)
return False
if _errno == errno.EADDRNOTAVAIL:
log.info(
'Address not available when adding %s to multicast '
'group, it is expected to happen on some systems',
interface,
)
return False
if _errno in err_einval:
log.info(
'Interface of %s does not support multicast, '
'it is expected in WSL', interface)
return False
raise
return True
def __init__(self,
sock: socket,
sender_id: str,
target_id: Optional[str] = None) -> None:
self._sock = sock
sock.setsockopt(SOL_TCP, TCP_NODELAY, 1)
self._next_send_seq_num = 1
self._next_recv_seq_num = 1
self._sender_id = sender_id
self._target_id = target_id
self._last_send_time = time.time()
self._last_recv_time = time.time()
self._heartbeat_interval = 30.
self._has_session = False
self._disconnected = Event()
self._send_lock = BoundedSemaphore(1)
gevent.spawn(self._close_on_exit)
self.messages = self._get_messages()
def discover(interface: str, timeout: float) -> Iterable[Host]:
sock = Socket(AF_INET, SOCK_DGRAM)
sock.settimeout(timeout)
sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
sock.setsockopt(SOL_SOCKET, SO_BROADCAST, 1)
sock.bind((interface, 34569))
request = Packet(0, 0, 1530, b'', fragments=0, fragment=0)
sock.sendto(request.encode(), ('255.255.255.255', 34569))
while True:
try:
data, (host, _) = sock.recvfrom(Packet.MAXLEN)
except Timeout:
break
packet = Packet.decode(data)
if not packet.payload: continue
reply = DiscoverReply.frompackets([packet]).host
if reply.host != host:
raise DVRIPDecodeError('wrong IP address ' 'reported')
yield reply
def output_worker(address: str, port: int, sock: socket.socket, stdout):
# Connect to address
sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
sock.connect((address, port))
# Start sending data
try:
while (not stdout.closed):
# Read and send 0.25 seconds of audio
sock.send(stdout.read(CHUNK_SIZE))
# Wait 250ms before reading the next chunk
time.sleep(0.25)
except (ConnectionResetError, BrokenPipeError, OSError):
print(
"Disconnected from bot. Either user disconnected, bot disconnected or there are connection problems."
)
finally:
if sock is not None:
sock.close()
print("OutputWorker stopped")
def set_socket_reuse_port(sock: socket.socket) -> bool:
"""Mutate a socket object to allow multiple process listening on the same port.
Returns:
success(bool): whether the setting was successful.
"""
try:
# These two socket options will allow multiple process to bind the the
# same port. Kernel will evenly load balance among the port listeners.
# Note: this will only work on Linux.
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
if hasattr(socket, "SO_REUSEPORT"):
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
# In some Python binary distribution (e.g., conda py3.6), this flag
# was not present at build time but available in runtime. But
# Python relies on compiler flag to include this in binary.
# Therefore, in the absence of socket.SO_REUSEPORT, we try
# to use `15` which is value in linux kernel.
# https://github.com/torvalds/linux/blob/master/tools/include/uapi/asm-generic/socket.h#L27
else:
sock.setsockopt(socket.SOL_SOCKET, 15, 1)
return True
except Exception as e:
logger.debug(
f"Setting SO_REUSEPORT failed because of {e}. SO_REUSEPORT is disabled."
)
return False
def supports_dualstack(self, sock: socket.socket = None) -> bool:
'''
Checks if the system kernel supports dual stack sockets, listening to both: IPv4 + IPv6
If a socket is provided, the check is made against the provided socket
'''
try:
socket.AF_INET6
socket.IPPROTO_IPV6
socket.IPV6_V6ONLY
except AttributeError:
return False
try:
if sock is not None:
return not sock.getsockopt(socket.IPPROTO_IPV6,
socket.IPV6_V6ONLY)
else:
sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
with contextlib.closing(sock):
sock.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 0)
return True
except socket.error:
return False
def listen(self):
global listening, listenSocket
listenSocket = Socket(AF_INET, SOCK_STREAM)
listenSocket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
listenSocket.bind(('0.0.0.0', self.localPeer.addr[1]))
listening = True
listenSocket.listen(len(self.remotePeerDict))
try:
while True:
socket, addr = listenSocket.accept()
msg = socket.recv(6)
if msg[:4] == 'PEER':
idx = int(msg[4:])
self.remotePeerDict[idx].onConnect(socket)
elif msg == 'CLIENT':
client = Peer('client', None)
client.network = self
client.onConnect(socket)
except SocketError:
pass
def _set_keepalive_linux(sock: socket.socket,
keep_alive_time: int = 1,
keep_alive_interval: int = 3,
max_probes: int = 5):
"""
Set TCP keepalive on an open socket.
It activates after 1 second (keep_alive_time) of idleness,
then sends a keepalive ping once every 3 seconds (keep_alive_interval),
and closes the connection after 5 failed ping (max_probes), or 15 seconds
"""
sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPIDLE, keep_alive_time)
sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPINTVL,
keep_alive_interval)
sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPCNT, max_probes)
def bind_port(sock: socket.socket, host: str = HOST) -> int:
"""Bind the socket to a free port and return the port number. Relies on
ephemeral ports in order to ensure we are using an unbound port. This is
important as many tests may be running simultaneously, especially in a
buildbot environment. This method raises an exception if the sock.family
is AF_INET and sock.type is SOCK_STREAM, *and* the socket has SO_REUSEADDR
or SO_REUSEPORT set on it. Tests should *never* set these socket options
for TCP/IP sockets. The only case for setting these options is testing
multicasting via multiple UDP sockets.
Additionally, if the SO_EXCLUSIVEADDRUSE socket option is available (i.e.
on Windows), it will be set on the socket. This will prevent anyone else
from bind()'ing to our host/port for the duration of the test.
"""
if sock.family == socket.AF_INET and sock.type == socket.SOCK_STREAM:
if hasattr(socket, "SO_REUSEADDR"):
if sock.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR) == 1:
raise ValueError("tests should never set the SO_REUSEADDR "
"socket option on TCP/IP sockets!")
if hasattr(socket, "SO_REUSEPORT"):
try:
if sock.getsockopt(socket.SOL_SOCKET,
socket.SO_REUSEPORT) == 1:
raise ValueError("tests should never set the SO_REUSEPORT "
"socket option on TCP/IP sockets!")
except OSError:
# Python's socket module was compiled using modern headers
# thus defining SO_REUSEPORT but this process is running
# under an older kernel that does not support SO_REUSEPORT.
pass
if hasattr(socket, "SO_EXCLUSIVEADDRUSE"):
sock.setsockopt(socket.SOL_SOCKET, socket.SO_EXCLUSIVEADDRUSE, 1)
sock.bind((host, 0))
port = sock.getsockname()[1]
assert isinstance(port, int)
return port
def main():
parser=argparse.ArgumentParser()
parser.add_argument('--port','-p',default=2000,type=int,help='port to use')
args=parser.parse_args()
server_socket=Socket(socket.AF_INET,socket.SOCK_STREAM)
server_socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
server_socket.bind(('',args.port))
server_socket.listen(1)
print "server running"
while True:
connection_socket=server_socket.accept()[0]
request=connection_socket.recv(1024)
reply=http_handler(request)
connection_socket.send("HTTP/1.1 200 OK\n")
connection_socket.send("\n")
connection_socket.send(reply)
connection_socket.close()
print "received request"
print "reply sent"
return 0
def discover(self, retries=10):
msg = '\r\n'.join([
f'M-SEARCH * HTTP/1.1', f'HOST: {self.host}:{self.port}',
f'MAN: \"ssdp:discover\"', f'ST: {self.st}'
])
s = Socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 2)
logger.log('Now searching for devices...')
counter = 0
while True:
s.sendto(msg.encode(), (self.host, self.port))
logger.log('M-Search sent, awaiting response...')
s.settimeout(1)
while True:
try:
if self.killswitch:
logger.log('Killswitch activated. Stop searching...')
break
res = s.recv(2048)
logger.log('Response received.')
self.response = True
self._handleResponse(res)
except socket.timeout:
break
counter += 1
if counter > retries or self.response or self.killswitch:
break
if self.response:
return self.discovered.copy()
else:
return {}
def bind_reuse(ip, port):
sock = Socket()
sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
sock.bind((ip, port))
return sock
