Miko/Hippolyzer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

modifying extant code to support the proxy, getting the udp proxy a bit closer to completion. still need to ignore data we send to the viewer

Browse Source
This commit is contained in:
Aaron Terrell (Enus)
2010-01-02 04:41:59 -08:00
committed by Salad Dais
parent 7651b054f6
commit f14cb07465
5 changed files with 104 additions and 61 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
pyogp/lib/base/message/udpdeserializer.py
View File

@@ -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

3
pyogp/lib/base/message/udpdispatcher.py
View File

@@ -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)

149
pyogp/lib/base/message/udpproxy.py
View File

@@ -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)
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

6
pyogp/lib/base/network/net.py
View File

@@ -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):

1
pyogp/lib/base/settings.py
View File

@@ -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