ASIO Proxy (Python recipe) by Aaron Riekenberg

ActiveState Code (http://code.activestate.com/recipes/577663/)

#!/usr/bin/env python

import asio
import logging
import os
import sys

MAX_READ_BYTES = 2 ** 16

def createLogger():
  logger = logging.getLogger('proxy')
  logger.setLevel(logging.INFO)

  consoleHandler = logging.StreamHandler()
  consoleHandler.setLevel(logging.DEBUG)

  formatter = logging.Formatter(
    '%(asctime)s - %(name)s - %(levelname)s - %(message)s')
  consoleHandler.setFormatter(formatter)

  logger.addHandler(consoleHandler)

  return logger

logger = createLogger()

class Connection(object):

  def __init__(self, ioService, clientToProxySocket,
               remoteAddress, remotePort):
    self.__dataFromClient = ''
    self.__dataFromRemote = ''
    self.__writingToClient = False
    self.__writingToRemote = False
    self.__clientToProxySocket = clientToProxySocket
    self.__clientToProxyString = ('%s -> %s' %
      (clientToProxySocket.getpeername(),
       clientToProxySocket.getsockname()))
    self.__proxyToRemoteSocket = ioService.createAsyncSocket()
    self.__proxyToRemoteString = ''
    self.__proxyToRemoteSocket.asyncConnect(
      (remoteAddress, remotePort), 
      self.__connectCallback)

  def close(self):
    if not self.__writingToClient:
      if ((not self.__clientToProxySocket.closed()) and
          (len(self.__clientToProxyString) > 0)):
        logger.info('disconnect %s' % self.__clientToProxyString)
      self.__clientToProxySocket.close()
    if not self.__writingToRemote:
      if ((not self.__proxyToRemoteSocket.closed()) and
          (len(self.__proxyToRemoteString) > 0)):
        logger.info('disconnect %s' % self.__proxyToRemoteString)
      self.__proxyToRemoteSocket.close()

  def __connectCallback(self, err):
    if (err != 0):
      logger.info('connect error \'%s\'' % (os.strerror(err)))
      self.close()
    else:
      self.__proxyToRemoteString = ('%s -> %s' %
        (self.__proxyToRemoteSocket.getpeername(),
         self.__proxyToRemoteSocket.getsockname()))
      logger.info('connect %s' % self.__proxyToRemoteString)
      self.__clientToProxySocket.asyncRead(
        MAX_READ_BYTES,
        self.__readFromClientCallback)
      self.__proxyToRemoteSocket.asyncRead(
        MAX_READ_BYTES,
        self.__readFromRemoteCallback)

  def __readFromClientCallback(self, data, err):
    if self.__proxyToRemoteSocket.closed():
      self.close()
    elif (err != 0):
      self.close()
    elif not data:
      self.close()
    else:
      self.__writingToRemote = True
      self.__proxyToRemoteSocket.asyncWriteAll(data, self.__writeToRemoteCallback)

  def __readFromRemoteCallback(self, data, err):
    if self.__clientToProxySocket.closed():
      self.close()
    elif (err != 0):
      self.close()
    elif not data:
      self.close()
    else:
      self.__writingToClient = True
      self.__clientToProxySocket.asyncWriteAll(data, self.__writeToClientCallback)

  def __writeToRemoteCallback(self, err):
    self.__writingToRemote = False
    if self.__clientToProxySocket.closed():
      self.close()
    elif (err != 0):
      self.close()
    else:
      self.__clientToProxySocket.asyncRead(MAX_READ_BYTES, self.__readFromClientCallback)

  def __writeToClientCallback(self, err):
    self.__writingToClient = False
    if self.__proxyToRemoteSocket.closed():
      self.close()
    elif (err != 0):
      self.close()
    else:
      self.__proxyToRemoteSocket.asyncRead(MAX_READ_BYTES, self.__readFromRemoteCallback)

class Acceptor(object):

  def __init__(self, ioService,
               localAddress, localPort,
               remoteAddress, remotePort):
    self.__ioService = ioService
    self.__remoteAddress = remoteAddress
    self.__remotePort = remotePort
    self.__asyncSocket = ioService.createAsyncSocket();
    self.__asyncSocket.setReuseAddress()
    self.__asyncSocket.bind((localAddress, localPort))
    self.__asyncSocket.listen()
    self.__asyncSocket.asyncAccept(self.__acceptCallback)
    logger.info('listening on %s' % str(self.__asyncSocket.getsockname()))

  def __acceptCallback(self, sock, err):
    if ((err == 0) and (sock != None)):
      logger.info('accept %s -> %s' % (sock.getpeername(), sock.getsockname()))
      Connection(self.__ioService, sock, self.__remoteAddress, self.__remotePort)
    self.__asyncSocket.asyncAccept(self.__acceptCallback)

def parseAddrPortString(addrPortString):
  addrPortList = addrPortString.split(':', 1)
  return (addrPortList[0], int(addrPortList[1]))

def printUsage():
  logger.error(
    'Usage: %s <listen addr> [<listen addr> ...] <remote addr>' %
    sys.argv[0])

def main():
  if (len(sys.argv) < 3):
    printUsage()
    sys.exit(1)

  localAddressPortList = map(parseAddrPortString, sys.argv[1:-1])
  (remoteAddress, remotePort) = parseAddrPortString(sys.argv[-1])

  ioService = asio.createAsyncIOService()
  logger.info('ioService = ' + str(ioService))
  for (localAddress, localPort) in localAddressPortList:
    Acceptor(ioService,
             localAddress = localAddress,
             localPort = localPort,
             remoteAddress = remoteAddress,
             remotePort = remotePort)
  logger.info('remote address %s' % str((remoteAddress, remotePort)))
  ioService.run()

if __name__ == '__main__':
  try:
    main()
  except KeyboardInterrupt:
    pass