#!/usr/bin/python

from sys import argv, exit

from asyncore import dispatcher, loop, ExitNow
from socket import *
import socket

recvsize = 63*1024

proxy_connection_count = 1

class proxy(dispatcher):
	def __init__(self, proxy_port, host, port):
		dispatcher.__init__(self)
		self.create_socket(AF_INET, SOCK_STREAM)
		self.set_reuse_addr()
		self.bind(("", proxy_port))
		self.listen(10)
	def handle_accept(self):
		global proxy_connection_count
		client_sock, addr = self.accept()
		print "accepted from", addr
		server_sock = socket.socket(AF_INET, SOCK_STREAM)
		n = str(proxy_connection_count)
		client = connection(client_sock, "client "+n)
		server = connection(server_sock, "server "+n)
		client.set_peer(server)
		server.set_peer(client)
		server.connect_to(host, port)
		proxy_connection_count = proxy_connection_count + 1

class connection(dispatcher):
	def __init__(self, sock, name):
		dispatcher.__init__(self, sock)
		self.close_after_data = 0
		self.data = ""
		self.peer = None
		self.name = name
	def set_peer(self, peer):
		self.peer = peer
	def handle_read(self):
		try:
			data = self.recv(recvsize)
			self.peer.forward(data)
		except socket.error, e:
			self.abort(e)
	def writable(self):
		return len(self.data) > 0
	def handle_write(self):
		try:
			sent = self.send(self.data)
			self.data = self.data[sent:]
			if len(self.data) == 0 and self.close_after_data:
				self.do_close()
		except socket.error, e:
			self.abort(e)
	def handle_close(self):
		self.do_close()
		if self.peer:
			self.peer.peer_closing()
	def do_close(self):
		print "socket", self.name, "closed"
		self.close()
	def forward(self, data):
		self.data = self.data + data
	def peer_closing(self):
		if len(self.data) == 0:
			self.do_close()
		else:
			self.close_after_data = 1
	def connect_to(self, host, port):
		print "socket", self.name, "connecting"
		try:
			self.connect((host, port))
		except socket.error, e:
			self.abort(e)
	def handle_connect(self):
		print "socket", self.name, "connected"
		pass
	def abort(self, e):
		print "socket", self.name, "abort:", e
		self.do_close()
		if self.peer:
			self.peer.peer_closing()

if (len(argv) - 1) % 3 != 0:
	print "syntax: incoming.py (proxy-port host port) ..."
	exit(1)

del argv[0];

while argv:
	proxy_port, host, port = argv[:3]
	del argv[:3];
	proxy_port = int(proxy_port) ; port = int(port)
	proxy(proxy_port, host, port)

loop()