proxyer for connect to any backend host throw Http-proxy use CONNECT method

proxyer.pyw

#!/usr/bin/python
# -*- coding: UTF-8 -*-
# Author : yunxing.cyx@taobao.com
# Date : 2014-06-09

import sys,socket,select
import Tkinter
from threading import Thread

proxy_server = "11.11.22.33"
proxy_port = 80
target_port = 8752
local_port = 9876

proxy_socket = None
client_socket = None

thread_need_reap = []
def reap_tread():
	global thread_need_reap
	for t in thread_need_reap:
		t.interrupt()
		t.join()
	thread_need_reap = []

class MyProxyThread(Thread):
	def __init__(self, proxy_server, proxy_port, target_host, target_port, local_port):
		super(MyProxyThread, self).__init__()
		self.interrupted = False
		self.proxy_server = proxy_server
		self.proxy_port = proxy_port
		self.target_host = target_host
		self.target_port = target_port
		self.local_port = local_port
		self.client_socket = None
		self.proxy_socket = None
		self.outputSockets = []
		self.inputSockets = []
		self.bufferClient = ""
		self.bufferProxy = ""

	def run(self):
		self.do_proxy()

	def interrupt(self):
		print str(self.ident) + " was interrupted !"
		self.interrupted = True

	def check_interrupt(self):
		return self.interrupted

	def get_proxy_connection(self, proxy_server, proxy_port, target_host, target_port):
		print proxy_server, proxy_port, target_host, target_port
		ps = socket.socket()
		ps.connect((proxy_server, proxy_port))
		command = "CONNECT " + target_host + ":" + str(target_port) + " HTTP/1.1\n"
		command = command + "Host: " + target_host + ":" + str(target_port) + "\n\n"
		ps.send(command)
		Str = ps.recv(1024)
		print "proxy response with : \n" + Str 
		return ps

	def shutdown_proxy(self):
		print "Shutdown the proxy :)"
		if self.proxy_socket: self.proxy_socket.close()
		if self.client_socket: self.client_socket.close()


	def readSocket(self, sck):
		if sck is self.client_socket:   
			print "loop => recv from client"
			bufferTemp = self.client_socket.recv(1024)
			if bufferTemp:
				print "client recv size not zero"
				self.bufferClient = self.bufferClient + bufferTemp
				self.outputSockets.append(self.proxy_socket)
			else:
				self.shutdown_proxy()
				return False
		elif sck is self.proxy_socket:
			print "loop => recv from proxy"
			bufferTemp = self.proxy_socket.recv(1024)
			if bufferTemp:
				print "proxy recv size not zero"
				self.bufferProxy = self.bufferProxy + bufferTemp
				self.outputSockets.append(self.client_socket)
			else:
				self.shutdown_proxy()
				return False
		else:
			print "invalid socket !"
		return True

	def writeSocket(self, sck):
		if sck is self.client_socket:
			print "loop => send to client"
			if len(self.bufferProxy) > 0:
				print "send to client size >0"
				self.client_socket.send(bufferProxy)
				self.bufferProxy = ""
				if self.outputSockets.count(sck) > 0: self.outputSockets.remove(sck) 
		elif sck is self.proxy_socket:
			print "loop => send to proxy"
			if len(self.bufferClient) > 0:
				print "send to proxy size >0"
				self.proxy_socket.send(self.bufferClient)
				self.bufferClient = ""
				if self.outputSockets.count(sck) > 0: self.outputSockets.remove(sck)
		else:
			print "invalid socket !"
		return True

	def do_proxy(self):
		s = socket.socket(socket.AF_INET,socket.SOCK_STREAM,0)
		s.bind(("127.0.0.1", self.local_port))
		s.listen(5)
		s.setblocking(False)

		while not self.client_socket :
			t = self.check_interrupt()
			if t : return
			print "Accepting ..."
			r,w,e = select.select([s],[],[s], 5)
			for ss in r:
				if ss is s:
					self.client_socket, addr = s.accept()
					print "Got connection from ",addr
					break

		self.proxy_socket = self.get_proxy_connection(self.proxy_server, self.proxy_port, self.target_host, self.target_port)
		self.proxy_socket.setblocking(False)
		self.client_socket.setblocking(False)

		self.inputSockets = [self.proxy_socket, self.client_socket]
		timeout = 5
		try:
			while True :
				t = self.check_interrupt()
				if t : return
				print "event loop"
				readable,writable,exceptional = select.select(self.inputSockets, self.outputSockets, self.inputSockets, timeout)
				if not (readable or writable or exceptional) :
					print "Time out !"
					continue
				if exceptional: 
					self.shutdown_proxy()
					return
				print "io ready"
				self.outputSockets = []
				for s in readable:
					t = self.readSocket(s)
					if not t : return
				for s in writable:
					t = self.writeSocket(s)
					if not t : return
		except :
			self.shutdown_proxy()
			return


class simpleapp_tk(Tkinter.Tk):
	def __init__(self, parent):
		Tkinter.Tk.__init__(self, parent)
		self.parent = parent
		self.initialize()

	def initialize(self):
		self.grid()

		# listen port
		label0 = Tkinter.Label(self, text = u"Listen port",
							  anchor = "w", fg = "black", padx = 5)
		label0.grid(column = 0, row = 0)

		self.entryVariable0 = Tkinter.IntVar()
		self.entry0 = Tkinter.Entry(self, textvariable=self.entryVariable0)
		self.entry0.grid(column = 1, row = 0, sticky = 'EW')
		self.entry0.bind("<Return>", self.OnButtonClick)
		self.entryVariable0.set(local_port)

		# target host
		label1 = Tkinter.Label(self, text = u"Target host",
							  anchor = "w", fg = "black", padx = 5)
		label1.grid(column = 2, row = 0)

		self.entryVariable1 = Tkinter.StringVar()
		self.entry1 = Tkinter.Entry(self, textvariable=self.entryVariable1)
		self.entry1.grid(column = 3, row = 0, sticky = 'EW')
		self.entryVariable1.set(u"")

		# target port
		labelx = Tkinter.Label(self, text = u"Target port",
							  anchor = "w", fg = "black", padx = 5)
		labelx.grid(column = 4, row = 0,sticky = 'EW')

		self.radioVariable = Tkinter.IntVar()
		self.radioVariable.set(8000)
		self.readio1 = Tkinter.Radiobutton(self, text = "8000", variable = self.radioVariable, value = 8000)
		self.readio1.grid(column = 5, row = 0, sticky = 'EW')
		self.readio2 = Tkinter.Radiobutton(self, text = "443", variable = self.radioVariable, value = 443)
		self.readio2.grid(column = 6, row = 0, sticky = 'EW')

		# proxy server 
		label2 = Tkinter.Label(self, text = u"Proxy server",
							  anchor = "w", fg = "black", padx = 5)
		label2.grid(column = 0, row = 1)

		self.entryVariable2 = Tkinter.StringVar()
		self.entry2 = Tkinter.Entry(self, textvariable=self.entryVariable2)
		self.entry2.grid(column = 1, row = 1, sticky = 'EW')
		self.entryVariable2.set(proxy_server)

		 # proxy port
		label3 = Tkinter.Label(self, text = u"Proxy port",
							  anchor = "w", fg = "black", padx = 5)
		label3.grid(column = 2, row = 1)

		self.entryVariable3 = Tkinter.IntVar()
		self.entry3 = Tkinter.Entry(self, textvariable=self.entryVariable3)
		self.entry3.grid(column = 3, row = 1, sticky = 'EW')
		self.entryVariable3.set(proxy_port)

		# button
		button = Tkinter.Button(self, text = u"Start proxy", bg = "red", fg = "white",
								command = self.OnButtonClick, padx = 5)
		button.grid(column = 4, row = 1, columnspan = 3, padx = 5)



		self.labelVariable = Tkinter.StringVar()
		label = Tkinter.Label(self, textvariable = self.labelVariable,
							  anchor = "w", fg = "black")
		label.grid(column = 0, row = 2, columnspan = 7, sticky = 'EW')
		
		labelAuthor = Tkinter.Label(self, text = u"Create By ChinaXing",
							  anchor = "se", fg = "white", bg = "black")
		labelAuthor.grid(column = 0, row = 3, columnspan = 7, sticky = 'EW')
		self.grid_columnconfigure(2,weight = 1)

		self.resizable(False,False)
		self.update()
		self.geometry(self.geometry())
		self.entry1.focus_set()
		self.entry1.selection_range(0, Tkinter.END)

	def OnButtonClick(self):
		target_host = self.entryVariable1.get()
		target_port = self.radioVariable.get()
		local_port = self.entryVariable0.get()
		proxy_server = self.entryVariable2.get()
		proxy_port = self.entryVariable3.get()
		if not ( target_host and local_port and proxy_server and proxy_port ):
			self.labelVariable.set( "pls set correct option")
			return
		self.labelVariable.set( "reap other threading ...")
		reap_tread()
		self.labelVariable.set( "reap other threading ... " + " Done.")

		self.labelVariable.set( "Target : " + target_host + ":" + str(target_port)) 
		t = MyProxyThread(proxy_server, proxy_port, target_host, target_port, local_port)
		thread_need_reap.append(t)
		t.start()


if __name__ == "__main__":
	app = simpleapp_tk(None)
	app.title("Proxyer")

	def destroy():
		reap_tread()
		app.destroy()

	app.protocol("WM_DELETE_WINDOW", destroy)
	app.mainloop()