def custom_socket(socket_config):
if socket_config.bind_family == 4:
ip = ipaddress.ip_address('224.0.0.252')
sock = setup_base_socket(
socket_config,
bind_ip_override=ipaddress.ip_address(
'0.0.0.0'
) #if socket_config.platform != ResponderPlatform.WINDOWS else None
)
sock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 255)
mreq = struct.pack("=4sl", ip.packed, socket.INADDR_ANY)
sock.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq)
else:
ip = ipaddress.ip_address('FF02:0:0:0:0:0:1:3')
sock = setup_base_socket(
socket_config,
bind_ip_override=ipaddress.ip_address('::') if
socket_config.platform != ResponderPlatform.WINDOWS else None)
sock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 255)
sock.setsockopt(
41 if socket_config.platform == ResponderPlatform.WINDOWS else
socket.IPPROTO_IPV6, socket.IPV6_JOIN_GROUP,
struct.pack('16sI', ip.packed, socket_config.bind_iface_idx))
return sock
def echo_server(ip, port, protocol, is_ssl=None):
server_socket = setup_base_socket(
interfaces.get_socketconfig_from_ip('127.0.0.1', port, protocol))
server_socket.setblocking(True)
if protocol == socket.SOCK_STREAM:
if is_ssl:
context = ssl.SSLContext()
context.verify_mode = ssl.CERT_NONE
context.load_cert_chain(certfile='../testcert/responder3.crt',
keyfile='../testcert/responder3.key')
server_socket = context.wrap_socket(server_socket,
server_side=True)
server_socket.listen(5)
while True:
# accept connections from outside
(clientsocket, address) = server_socket.accept()
# now do something with the clientsocket
# in this case, we'll pretend this is a threaded server
data = clientsocket.recv(1024)
print(data)
clientsocket.sendall(data)
else:
while True:
data, addr = server_socket.recvfrom(1024)
print(data)
server_socket.sendto(data, addr)
async def serve_forever(self):
if self._socket is None:
self._socket = setup_base_socket(self.listener_socket_config)
while True:
data, addr = await recvfrom(self._loop, self._socket, 65536)
reader = UDPReader(data, addr)
writer = UDPWriter(self._loop, self._socket, addr, self._laddr)
await self._callback(reader, writer)
def create_server_coro(self, server_task_config):
self.server_config = server_task_config
if 'listener_socket_config' in server_task_config and server_task_config['listener_socket_config'] is not None:
self.listener_socket_config = server_task_config['listener_socket_config']
else:
raise Exception('Server listener socket MUST be defined!')
if 'settings' in server_task_config:
self.server_handler_settings = copy.deepcopy(server_task_config['settings'])
if 'handler' in server_task_config and server_task_config['handler'] is not None:
server_module = Responder3ServerTask.import_template(
server_task_config['handler'],
)
self.server_handler = getattr(server_module, server_task_config['handler'])
self.server_handler_session = getattr(server_module, '%s%s' % (server_task_config['handler'], 'Session'))
# global session object will be immediately instantiated, as it is global for ALL clients
gs = getattr(server_module, '%s%s' % (server_task_config['handler'], 'GlobalSession'), None)
if gs is not None:
self.server_handler_global_session = gs(self.listener_socket_config, self.server_handler_settings, self.log_queue)
else:
raise Exception('Server Handler MUST be specified!')
if 'bind_sslctx' in server_task_config:
self.listener_socket_config.is_ssl_wrapped = True
self.listener_socket_ssl_context = SSLContextBuilder.from_dict(server_task_config['bind_sslctx'], server_side=True)
self.server_name = '%s-%s' % (self.server_handler.__name__, self.listener_socket_config.get_protocolname())
if self.listener_socket_ssl_context is not None:
self.server_name += '-SSL'
self.server_coro = None
if self.listener_socket_config.bind_protocol == socket.SOCK_STREAM:
sock = None
if getattr(self.server_handler, "custom_socket", None) is not None and callable(
getattr(self.server_handler, "custom_socket", None)):
sock = self.server_handler.custom_socket(self.listener_socket_config)
else:
sock = setup_base_socket(self.listener_socket_config)
self.server_coro = asyncio.start_server(self.accept_client, sock=sock, ssl=self.listener_socket_ssl_context)
elif self.listener_socket_config.bind_protocol == socket.SOCK_DGRAM:
udpserver_obj = getattr(importlib.import_module('responder3.core.udpwrapper'), 'UDPServer')
sock = None
if getattr(self.server_handler, "custom_socket", None) is not None and callable(
getattr(self.server_handler, "custom_socket", None)):
sock = self.server_handler.custom_socket(self.listener_socket_config)
udpserver = udpserver_obj(self.accept_client, self.listener_socket_config, sock=sock)
self.server_coro = udpserver.run()
else:
raise Exception('Unknown protocol type!')
return self.server_coro
def custom_socket(socket_config):
if socket_config.bind_family == 6:
raise Exception(
'DHCP server should not be run on IPv6 (requires a different protocol)'
)
sock = setup_base_socket(
socket_config, bind_ip_override=ipaddress.ip_address('0.0.0.0'))
sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
return sock
def custom_socket(socket_config):
if socket_config.bind_family == 6:
raise Exception(
'DHCP server should not be run on IPv6 (requires a different protocol)'
)
sock = setup_base_socket(socket_config)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
sock.setsockopt(
socket.SOL_SOCKET, socket.SO_REUSEADDR,
0) #important to turn off reuse address (at least on windows!!!)
return sock
def setup(self):
"""
Upsets the server. :)
Imports necessary modules, parses configuration dict, creates session obj...
:return: None
"""
self.import_packages()
self.server_properties = ServerProperties.from_dict(self.serverentry)
self.loop = asyncio.get_event_loop()
self.clients = {}
self.server = self.server_properties.serverhandler
self.session = self.server_properties.serversession
self.globalsession = self.server_properties.serverglobalsession
if self.server_properties.serverglobalsession is not None:
self.globalsession = self.server_properties.serverglobalsession(self.server_properties)
self.logQ = self.server_properties.shared_logQ
self.rdnsd = self.server_properties.shared_rdns
self.connectionFactory = ConnectionFactory(self.rdnsd)
self.modulename = '%s-%s' % (self.server_properties.serverhandler.__name__, str(self.server_properties.listener_socket_config.get_print_address()))
self.serverCoro = None
self.server_stop_event = asyncio.Event()
if self.server_properties.listener_socket_config.bind_protocol == socket.SOCK_STREAM:
sock = None
if getattr(self.server_properties.serverhandler, "custom_socket", None) is not None and callable(getattr(self.server_properties.serverhandler, "custom_socket", None)):
sock = self.server_properties.serverhandler.custom_socket(self.server_properties.listener_socket_config)
else:
sock = setup_base_socket(self.server_properties.listener_socket_config)
self.serverCoro = asyncio.start_server(self.accept_client, sock = sock, ssl=self.server_properties.sslcontext)
elif self.server_properties.listener_socket_config.bind_protocol == socket.SOCK_DGRAM:
sock = None
if getattr(self.server_properties.serverhandler, "custom_socket", None) is not None and callable(getattr(self.server_properties.serverhandler, "custom_socket", None)):
sock = self.server_properties.serverhandler.custom_socket(self.server_properties.listener_socket_config)
udpserver = self.udpserver(self.accept_client, self.server_properties, sock = sock)
self.serverCoro = udpserver.run()
else:
raise Exception('Unknown protocol type!')
def create_listener_socket_config(self): try: self.listener_socket_config = setup_base_socket(self.server_props) #self.listener_socket_config.listen(500) except Exception as e: raise e
def custom_socket(server_properties):
sock = setup_base_socket(
server_properties,
bind_ip_override=ipaddress.ip_address('0.0.0.0'))
sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
return sock
