diff --git a/pyogp/lib/base/message/udpdeserializer.py b/pyogp/lib/base/message/udpdeserializer.py index 09c5bbc..228fe0f 100644 --- a/pyogp/lib/base/message/udpdeserializer.py +++ b/pyogp/lib/base/message/udpdeserializer.py @@ -132,7 +132,11 @@ class UDPMessageDeserializer(object): else: - if self.settings.LOG_VERBOSE and self.settings.ENABLE_UDP_LOGGING and self.settings.LOG_SKIPPED_PACKETS: logger.debug('Received packet : %s (Skipping)' % (self.current_template.name)) + if self.settings.LOG_VERBOSE \ + and self.settings.ENABLE_UDP_LOGGING \ + and self.settings.LOG_SKIPPED_PACKETS \ + and not self.settings.PROXY_LOGGING: + logger.debug('Received packet : %s (Skipping)' % (self.current_template.name)) return None diff --git a/pyogp/lib/base/message/udpdispatcher.py b/pyogp/lib/base/message/udpdispatcher.py index 4535dbd..2113d12 100644 --- a/pyogp/lib/base/message/udpdispatcher.py +++ b/pyogp/lib/base/message/udpdispatcher.py @@ -162,7 +162,8 @@ class UDPDispatcher(object): host_string = ' (%s)' % (host) else: host_string = '' - logger.debug('Received packet%s : %s (%s)%s' % (host_string, recv_packet.name, recv_packet.packet_id, hex_string)) + if not self.settings.PROXY_LOGGING: + logger.debug('Received packet%s : %s (%s)%s' % (host_string, recv_packet.name, recv_packet.packet_id, hex_string)) if self.settings.HANDLE_PACKETS: self.message_handler.handle(recv_packet) diff --git a/pyogp/lib/base/message/udpproxy.py b/pyogp/lib/base/message/udpproxy.py index 40d887e..0a791dc 100644 --- a/pyogp/lib/base/message/udpproxy.py +++ b/pyogp/lib/base/message/udpproxy.py @@ -16,9 +16,16 @@ $/LicenseInfo$ """ # standard python libs from logging import getLogger +import socket +import traceback + +# related +from eventlet import api # pyogp -from pyogp.lib.base.udpdispatcher import UDPDispatcher +from pyogp.lib.base.message.circuit import Host +from pyogp.lib.base.message.udpdispatcher import UDPDispatcher +from pyogp.lib.base.network.net import NetUDPClient # initialize logging logger = getLogger('message.udpproxy') @@ -26,93 +33,117 @@ logger = getLogger('message.udpproxy') class UDPProxy(UDPDispatcher): """ proxies a Second Life viewer's UDP connection to a region """ - def __init__(self, sim_ip, sim_port, udp_client = None, settings = None, message_handler = None, message_template = None, message_xml = None): - """ initialize a UDP proxy, mapping 2 ports to a single outbound port """ + def __init__(self, sim_ip, sim_port, viewer_facing_port, target_facing_port, udp_client = None, settings = None, message_handler = None, message_template = None, message_xml = None): + """ initialize a UDP proxy, extending the UDPDispatcher """ super(UDPProxy, self).__init__(udp_client, settings, message_handler, message_template, message_xml) + + self.settings.PROXY_LOGGING = True + self.settings.ENABLE_DEFERRED_PACKET_PARSING = False # ToDo: remove this self.target_host = Host((sim_ip, sim_port)) + self.local_host = None - # ToDo: change all this crap below! + self.target_udp_client = self.udp_client # region facing + self.target_socket = self.socket # already spun up as part of the parent UDPDispatcher class instance + self.target_socket.bind((socket.gethostname(), target_facing_port)) # bind it to a port + self.target_socket.setblocking(0) # set the socket to nonblocking - # the outgoing connection to the grid - self.server_facing_udp_client = NetUDPClient() # the sender, what we are proxying the target to - #self.server_facing_socket = self.server_facing_udp_client.start_udp_connection() - self.server_facing_udp_dispatcher = UDPDispatcher(udp_client=self.server_facing_udp_client) + self.proxy_udp_client = NetUDPClient() # the viewer's socket + self.proxy_socket = self.proxy_udp_client.start_udp_connection() # grab a socket! + self.proxy_socket.bind((socket.gethostname(), viewer_facing_port)) # bind it to a port + self.proxy_socket.setblocking(0) # set the socket to nonblocking + + # the viewer needs a local hostname to connect to, as well as a port + self.hostname = self.proxy_socket.getsockname()[0] - # the local connection for the client - self.viewer_facing_udp_client = NetUDPClient() # the sender, what we are proxying the target to - #self.viewer_facing_socket = self.viewer_facing_udp_client.start_udp_connection() - self.viewer_facing_udp_dispatcher = UDPDispatcher(udp_client=self.viewer_facing_udp_client) + self.local_host = Host((self.hostname, viewer_facing_port)) # populate this convenience reference - logger.debug("Building socket pair for %s udp proxy" % (self.target_host)) + logger.debug("Bound proxy for region %s to %s" % (self.target_host, self.target_socket.getsockname())) + logger.debug("Bound proxy for viewer (%s) to %s" % (self.local_host, self.proxy_socket.getsockname())) - def pin_udp_proxy_ports(self, viewer_facing_port, server_facing_port): + ''' + logger.debug("Initialized the UDPProxy for %s, located at %s" % ( + self.target_host, + self.local_host)) - try: - - # tell the sim_socket to be on a specific port - logger.debug("Binding server_facing_socket to port %s" % (server_facing_port)) - self.server_facing_udp_dispatcher.socket.bind((socket.gethostname(), server_facing_port)) - - # tell the local_socket to be on a specific port - logger.debug("Binding viewer_facing_socket to port %s" % (viewer_facing_port)) - self.viewer_facing_udp_dispatcher.socket.bind((socket.gethostname(), viewer_facing_port)) - - hostname = self.viewer_facing_udp_dispatcher.socket.getsockname()[0] - - self.local_host = Host((hostname, viewer_facing_port)) - - return hostname - - except Exception, e: - raise + for item in self.settings.__dict__: + logger.debug("Setting %s = %s" % (item, self.settings.__dict__[item])) + ''' def start_proxy(self): logger.debug("Starting proxies in UDPProxy") + + api.sleep(2) self._is_running = True + api.spawn(self._send_viewer_to_sim) + api.spawn(self._receive_sim_to_viewer) + while self._is_running: - try: - api.sleep(0) + api.sleep(0) - self._send_viewer_to_sim() - self._receive_sim_to_viewer() - except KeyboardInterrupt: - logger.INFO("Stopping UDP proxy for %s" % (self.target_host)) - break - except: - traceback.print_exc() def _send_viewer_to_sim(self): - logger.debug("Checking for msgs from viewer") + # todo: find a way to not try and send data we just received + self.proxy_socket_is_locked = False - msg_buf, msg_size = self.viewer_facing_udp_client.receive_packet(self.viewer_facing_udp_dispatcher.socket) - recv_packet = self.viewer_facing_udp_dispatcher.receive_check(self.viewer_facing_udp_dispatcher.udp_client.get_sender(), + while self._is_running: + if self.proxy_socket_is_locked: + msg_buf, msg_size = self.proxy_udp_client.receive_packet(self.proxy_socket) + + if msg_size > 0: + recv_packet = self.receive_check(self.proxy_udp_client.get_sender(), + msg_buf, + msg_size) + + logger.debug("Sending message:%s ID:%s" % (recv_packet.name, recv_packet.packet_id)) + + ''' + logger.debug("Proxying from viewer writing to %s to %s via %s! Data: len(%s)" % ( + self.proxy_socket.getsockname(), + self.target_host, + self.target_socket.getsockname(), + len(msg_buf))) + ''' + + self.target_udp_client.send_packet(self.target_socket, msg_buf, - msg_size) - - #logger.debug("viewer_facing_udp_client.receive_packet got %s:%s" % (msg_buf, msg_size)) + self.target_host) - if msg_size > 0: - logger.debug("Sending from %s to %s! Data: len(%s) Host: %s" % (self.viewer_facing_udp_dispatcher.socket.getsockname(), self.server_facing_udp_dispatcher.socket.getsockname(), len(msg_buf), self.target_host)) - self.server_facing_udp_client.send_packet(self.server_facing_udp_dispatcher.socket, msg_buf, self.target_host) + api.sleep(0) def _receive_sim_to_viewer(self): - logger.debug("Checking for msgs from server") + while self._is_running: - msg_buf, msg_size = self.server_facing_udp_client.receive_packet(self.server_facing_udp_dispatcher.socket) - recv_packet = self.server_facing_udp_dispatcher.receive_check(self.server_facing_udp_dispatcher.udp_client.get_sender(), - msg_buf, - msg_size) + self.proxy_socket_is_locked = True - #logger.debug("server_facing_udp_client.receive_packet got %s:%s" % (msg_buf, msg_size)) + msg_buf, msg_size = self.target_udp_client.receive_packet(self.target_socket) - if msg_size > 0: - logger.debug("Sending from %s to %s! Data: len(%s) Host: %s" % (self.server_facing_udp_dispatcher.socket.getsockname(), self.viewer_facing_udp_dispatcher.socket.getsockname(), len(msg_buf), self.target_host)) - self.viewer_facing_udp_client.send_packet(self.viewer_facing_udp_dispatcher.socket, msg_buf, self.local_host) \ No newline at end of file + if msg_size > 0: + recv_packet = self.receive_check(self.target_udp_client.get_sender(), + msg_buf, + msg_size) + + logger.debug("Receiving message:%s ID:%s" % (recv_packet.name, recv_packet.packet_id)) + + ''' + logger.debug("Proxing from %s to viewer listening on %s via %s! Data: len(%s)" % ( + self.target_host, + self.proxy_socket.getsockname(), + self.target_socket.getsockname(), + len(msg_buf))) + ''' + + self.proxy_udp_client.send_packet(self.proxy_socket, + msg_buf, + self.local_host) + + api.sleep(2) + + self.proxy_socket_is_locked = False \ No newline at end of file diff --git a/pyogp/lib/base/network/net.py b/pyogp/lib/base/network/net.py index 5480320..0f017b7 100644 --- a/pyogp/lib/base/network/net.py +++ b/pyogp/lib/base/network/net.py @@ -18,9 +18,12 @@ $/LicenseInfo$ # std python libs import socket +from logging import getLogger from pyogp.lib.base.message.circuit import Host +logger = getLogger('net.net') + #returns true if packet was sent successfully class NetUDPClient(object): @@ -32,12 +35,14 @@ class NetUDPClient(object): def send_packet(self, sock, send_buffer, host): #print "Sending to " + str(host.ip) + ":" + str(host.port) + ":" + send_buffer + #logger.debug("In send_packet") if send_buffer == None: raise Exception("No data specified") bytes = sock.sendto(send_buffer, (host.ip, host.port)) def receive_packet(self, sock): + #logger.debug("in receive packet") buf = 10000 try: data, addr = sock.recvfrom(buf) @@ -47,6 +52,7 @@ class NetUDPClient(object): #print self.sender self.sender.ip = addr[0] self.sender.port = addr[1] + #logger.debug("leaving receive packet") return data, len(data) def start_udp_connection(self): diff --git a/pyogp/lib/base/settings.py b/pyogp/lib/base/settings.py index 9339249..00bb422 100644 --- a/pyogp/lib/base/settings.py +++ b/pyogp/lib/base/settings.py @@ -54,6 +54,7 @@ class Settings(object): self.LOG_SKIPPED_PACKETS = True self.ENABLE_HOST_LOGGING = True self.LOG_COROUTINE_SPAWNS = True + self.PROXY_LOGGING = False # allow disabling logging of certain packets self.DISABLE_SPAMMERS = True