Removing proxy

Sergio Oliveira
1 parent d1e1273e
Showing 4 changed files with 1 additions and 421 deletions Show diff stats
src/colab/custom_settings.py
src/colab/deprecated/socks.py
src/colab/deprecated/solrutils.py
src/colab/local_settings-dev.py
@@ -166,11 +166,6 @@ MESSAGE_TAGS = {
 }
-### Proxy configuration
-SOCKS_SERVER = None
-SOCKS_PORT = None
-
-
 ### Feedzilla  (planet)
 from feedzilla.settings import *
 FEEDZILLA_PAGE_SIZE = 5
@@ -1,387 +0,0 @@
-"""SocksiPy - Python SOCKS module.
-Version 1.00
-
-Copyright 2006 Dan-Haim. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-1. Redistributions of source code must retain the above copyright notice, this
-   list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright notice,
-   this list of conditions and the following disclaimer in the documentation
-   and/or other materials provided with the distribution.
-3. Neither the name of Dan Haim nor the names of his contributors may be used
-   to endorse or promote products derived from this software without specific
-   prior written permission.
-   
-THIS SOFTWARE IS PROVIDED BY DAN HAIM "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
-EVENT SHALL DAN HAIM OR HIS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA
-OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
-OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMANGE.
-
-
-This module provides a standard socket-like interface for Python
-for tunneling connections through SOCKS proxies.
-
-"""
-
-import socket
-import struct
-
-PROXY_TYPE_SOCKS4 = 1
-PROXY_TYPE_SOCKS5 = 2
-PROXY_TYPE_HTTP = 3
-
-_defaultproxy = None
-_orgsocket = socket.socket
-
-class ProxyError(Exception):
-	def __init__(self, value):
-		self.value = value
-	def __str__(self):
-		return repr(self.value)
-
-class GeneralProxyError(ProxyError):
-	def __init__(self, value):
-		self.value = value
-	def __str__(self):
-		return repr(self.value)
-
-class Socks5AuthError(ProxyError):
-	def __init__(self, value):
-		self.value = value
-	def __str__(self):
-		return repr(self.value)
-
-class Socks5Error(ProxyError):
-	def __init__(self, value):
-		self.value = value
-	def __str__(self):
-		return repr(self.value)
-
-class Socks4Error(ProxyError):
-	def __init__(self, value):
-		self.value = value
-	def __str__(self):
-		return repr(self.value)
-
-class HTTPError(ProxyError):
-	def __init__(self, value):
-		self.value = value
-	def __str__(self):
-		return repr(self.value)
-
-_generalerrors = ("success",
-		   "invalid data",
-		   "not connected",
-		   "not available",
-		   "bad proxy type",
-		   "bad input")
-
-_socks5errors = ("succeeded",
-		  "general SOCKS server failure",
-		  "connection not allowed by ruleset",
-		  "Network unreachable",
-		  "Host unreachable",
-		  "Connection refused",
-		  "TTL expired",
-		  "Command not supported",
-		  "Address type not supported",
-		  "Unknown error")
-
-_socks5autherrors = ("succeeded",
-		      "authentication is required",
-		      "all offered authentication methods were rejected",
-		      "unknown username or invalid password",
-		      "unknown error")
-
-_socks4errors = ("request granted",
-		  "request rejected or failed",
-		  "request rejected because SOCKS server cannot connect to identd on the client",
-		  "request rejected because the client program and identd report different user-ids",
-		  "unknown error")
-
-def setdefaultproxy(proxytype=None,addr=None,port=None,rdns=True,username=None,password=None):
-	"""setdefaultproxy(proxytype, addr[, port[, rdns[, username[, password]]]])
-	Sets a default proxy which all further socksocket objects will use,
-	unless explicitly changed.
-	"""
-	global _defaultproxy
-	_defaultproxy = (proxytype,addr,port,rdns,username,password)
-	
-class socksocket(socket.socket):
-	"""socksocket([family[, type[, proto]]]) -> socket object
-	
-	Open a SOCKS enabled socket. The parameters are the same as
-	those of the standard socket init. In order for SOCKS to work,
-	you must specify family=AF_INET, type=SOCK_STREAM and proto=0.
-	"""
-	
-	def __init__(self, family=socket.AF_INET, type=socket.SOCK_STREAM, proto=0, _sock=None):
-		_orgsocket.__init__(self,family,type,proto,_sock)
-		if _defaultproxy != None:
-			self.__proxy = _defaultproxy
-		else:
-			self.__proxy = (None, None, None, None, None, None)
-		self.__proxysockname = None
-		self.__proxypeername = None
-	
-	def __recvall(self, bytes):
-		"""__recvall(bytes) -> data
-		Receive EXACTLY the number of bytes requested from the socket.
-		Blocks until the required number of bytes have been received.
-		"""
-		data = ""
-		while len(data) < bytes:
-			data = data + self.recv(bytes-len(data))
-		return data
-	
-	def setproxy(self,proxytype=None,addr=None,port=None,rdns=True,username=None,password=None):
-		"""setproxy(proxytype, addr[, port[, rdns[, username[, password]]]])
-		Sets the proxy to be used.
-		proxytype -	The type of the proxy to be used. Three types
-				are supported: PROXY_TYPE_SOCKS4 (including socks4a),
-				PROXY_TYPE_SOCKS5 and PROXY_TYPE_HTTP
-		addr -		The address of the server (IP or DNS).
-		port -		The port of the server. Defaults to 1080 for SOCKS
-				servers and 8080 for HTTP proxy servers.
-		rdns -		Should DNS queries be preformed on the remote side
-				(rather than the local side). The default is True.
-				Note: This has no effect with SOCKS4 servers.
-		username -	Username to authenticate with to the server.
-				The default is no authentication.
-		password -	Password to authenticate with to the server.
-				Only relevant when username is also provided.
-		"""
-		self.__proxy = (proxytype,addr,port,rdns,username,password)
-	
-	def __negotiatesocks5(self,destaddr,destport):
-		"""__negotiatesocks5(self,destaddr,destport)
-		Negotiates a connection through a SOCKS5 server.
-		"""
-		# First we'll send the authentication packages we support.
-		if (self.__proxy[4]!=None) and (self.__proxy[5]!=None):
-			# The username/password details were supplied to the
-			# setproxy method so we support the USERNAME/PASSWORD
-			# authentication (in addition to the standard none).
-			self.sendall("\x05\x02\x00\x02")
-		else:
-			# No username/password were entered, therefore we
-			# only support connections with no authentication.
-			self.sendall("\x05\x01\x00")
-		# We'll receive the server's response to determine which
-		# method was selected
-		chosenauth = self.__recvall(2)
-		if chosenauth[0] != "\x05":
-			self.close()
-			raise GeneralProxyError((1,_generalerrors[1]))
-		# Check the chosen authentication method
-		if chosenauth[1] == "\x00":
-			# No authentication is required
-			pass
-		elif chosenauth[1] == "\x02":
-			# Okay, we need to perform a basic username/password
-			# authentication.
-			self.sendall("\x01" + chr(len(self.__proxy[4])) + self.__proxy[4] + chr(len(self.proxy[5])) + self.__proxy[5])
-			authstat = self.__recvall(2)
-			if authstat[0] != "\x01":
-				# Bad response
-				self.close()
-				raise GeneralProxyError((1,_generalerrors[1]))
-			if authstat[1] != "\x00":
-				# Authentication failed
-				self.close()
-				raise Socks5AuthError,((3,_socks5autherrors[3]))
-			# Authentication succeeded
-		else:
-			# Reaching here is always bad
-			self.close()
-			if chosenauth[1] == "\xFF":
-				raise Socks5AuthError((2,_socks5autherrors[2]))
-			else:
-				raise GeneralProxyError((1,_generalerrors[1]))
-		# Now we can request the actual connection
-		req = "\x05\x01\x00"
-		# If the given destination address is an IP address, we'll
-		# use the IPv4 address request even if remote resolving was specified.
-		try:
-			ipaddr = socket.inet_aton(destaddr)
-			req = req + "\x01" + ipaddr
-		except socket.error:
-			# Well it's not an IP number,  so it's probably a DNS name.
-			if self.__proxy[3]==True:
-				# Resolve remotely
-				ipaddr = None
-				req = req + "\x03" + chr(len(destaddr)) + destaddr
-			else:
-				# Resolve locally
-				ipaddr = socket.inet_aton(socket.gethostbyname(destaddr))
-				req = req + "\x01" + ipaddr
-		req = req + struct.pack(">H",destport)
-		self.sendall(req)
-		# Get the response
-		resp = self.__recvall(4)
-		if resp[0] != "\x05":
-			self.close()
-			raise GeneralProxyError((1,_generalerrors[1]))
-		elif resp[1] != "\x00":
-			# Connection failed
-			self.close()
-			if ord(resp[1])<=8:
-				raise Socks5Error(ord(resp[1]),_generalerrors[ord(resp[1])])
-			else:
-				raise Socks5Error(9,_generalerrors[9])
-		# Get the bound address/port
-		elif resp[3] == "\x01":
-			boundaddr = self.__recvall(4)
-		elif resp[3] == "\x03":
-			resp = resp + self.recv(1)
-			boundaddr = self.__recvall(resp[4])
-		else:
-			self.close()
-			raise GeneralProxyError((1,_generalerrors[1]))
-		boundport = struct.unpack(">H",self.__recvall(2))[0]
-		self.__proxysockname = (boundaddr,boundport)
-		if ipaddr != None:
-			self.__proxypeername = (socket.inet_ntoa(ipaddr),destport)
-		else:
-			self.__proxypeername = (destaddr,destport)
-	
-	def getproxysockname(self):
-		"""getsockname() -> address info
-		Returns the bound IP address and port number at the proxy.
-		"""
-		return self.__proxysockname
-	
-	def getproxypeername(self):
-		"""getproxypeername() -> address info
-		Returns the IP and port number of the proxy.
-		"""
-		return _orgsocket.getpeername(self)
-	
-	def getpeername(self):
-		"""getpeername() -> address info
-		Returns the IP address and port number of the destination
-		machine (note: getproxypeername returns the proxy)
-		"""
-		return self.__proxypeername
-	
-	def __negotiatesocks4(self,destaddr,destport):
-		"""__negotiatesocks4(self,destaddr,destport)
-		Negotiates a connection through a SOCKS4 server.
-		"""
-		# Check if the destination address provided is an IP address
-		rmtrslv = False
-		try:
-			ipaddr = socket.inet_aton(destaddr)
-		except socket.error:
-			# It's a DNS name. Check where it should be resolved.
-			if self.__proxy[3]==True:
-				ipaddr = "\x00\x00\x00\x01"
-				rmtrslv = True
-			else:
-				ipaddr = socket.inet_aton(socket.gethostbyname(destaddr))
-		# Construct the request packet
-		req = "\x04\x01" + struct.pack(">H",destport) + ipaddr
-		# The username parameter is considered userid for SOCKS4
-		if self.__proxy[4] != None:
-			req = req + self.__proxy[4]
-		req = req + "\x00"
-		# DNS name if remote resolving is required
-		# NOTE: This is actually an extension to the SOCKS4 protocol
-		# called SOCKS4A and may not be supported in all cases.
-		if rmtrslv==True:
-			req = req + destaddr + "\x00"
-		self.sendall(req)
-		# Get the response from the server
-		resp = self.__recvall(8)
-		if resp[0] != "\x00":
-			# Bad data
-			self.close()
-			raise GeneralProxyError((1,_generalerrors[1]))
-		if resp[1] != "\x5A":
-			# Server returned an error
-			self.close()
-			if ord(resp[1]) in (91,92,93):
-				self.close()
-				raise Socks4Error((ord(resp[1]),_socks4errors[ord(resp[1])-90]))
-			else:
-				raise Socks4Error((94,_socks4errors[4]))
-		# Get the bound address/port
-		self.__proxysockname = (socket.inet_ntoa(resp[4:]),struct.unpack(">H",resp[2:4])[0])
-		if rmtrslv != None:
-			self.__proxypeername = (socket.inet_ntoa(ipaddr),destport)
-		else:
-			self.__proxypeername = (destaddr,destport)
-	
-	def __negotiatehttp(self,destaddr,destport):
-		"""__negotiatehttp(self,destaddr,destport)
-		Negotiates a connection through an HTTP server.
-		"""
-		# If we need to resolve locally, we do this now
-		if self.__proxy[3] == False:
-			addr = socket.gethostbyname(destaddr)
-		else:
-			addr = destaddr
-		self.sendall("CONNECT " + addr + ":" + str(destport) + " HTTP/1.1\r\n" + "Host: " + destaddr + "\r\n\r\n")
-		# We read the response until we get the string "\r\n\r\n"
-		resp = self.recv(1)
-		while resp.find("\r\n\r\n")==-1:
-			resp = resp + self.recv(1)
-		# We just need the first line to check if the connection
-		# was successful
-		statusline = resp.splitlines()[0].split(" ",2)
-		if statusline[0] not in ("HTTP/1.0","HTTP/1.1"):
-			self.close()
-			raise GeneralProxyError((1,_generalerrors[1]))
-		try:
-			statuscode = int(statusline[1])
-		except ValueError:
-			self.close()
-			raise GeneralProxyError((1,_generalerrors[1]))
-		if statuscode != 200:
-			self.close()
-			raise HTTPError((statuscode,statusline[2]))
-		self.__proxysockname = ("0.0.0.0",0)
-		self.__proxypeername = (addr,destport)
-	
-	def connect(self,destpair):
-		"""connect(self,despair)
-		Connects to the specified destination through a proxy.
-		destpar - A tuple of the IP/DNS address and the port number.
-		(identical to socket's connect).
-		To select the proxy server use setproxy().
-		"""
-		# Do a minimal input check first
-		if (type(destpair) in (list,tuple)==False) or (len(destpair)<2) or (type(destpair[0])!=str) or (type(destpair[1])!=int):
-			raise GeneralProxyError((5,_generalerrors[5]))
-		if self.__proxy[0] == PROXY_TYPE_SOCKS5:
-			if self.__proxy[2] != None:
-				portnum = self.__proxy[2]
-			else:
-				portnum = 1080
-			_orgsocket.connect(self,(self.__proxy[1],portnum))
-			self.__negotiatesocks5(destpair[0],destpair[1])
-		elif self.__proxy[0] == PROXY_TYPE_SOCKS4:
-			if self.__proxy[2] != None:
-				portnum = self.__proxy[2]
-			else:
-				portnum = 1080
-			_orgsocket.connect(self,(self.__proxy[1],portnum))
-			self.__negotiatesocks4(destpair[0],destpair[1])
-		elif self.__proxy[0] == PROXY_TYPE_HTTP:
-			if self.__proxy[2] != None:
-				portnum = self.__proxy[2]
-			else:
-				portnum = 8080
-			_orgsocket.connect(self,(self.__proxy[1],portnum))
-			self.__negotiatehttp(destpair[0],destpair[1])
-		elif self.__proxy[0] == None:
-			_orgsocket.connect(self,(destpair[0],destpair[1]))
-		else:
-			raise GeneralProxyError((4,_generalerrors[4]))
@@ -13,10 +13,6 @@ from dateutil.parser import parse as parse_timestamp
 from django.conf import settings
 from super_archives.models import EmailAddress
-from . import socks
-
-
-DEFAULT_SOCKET = socket.socket
 def build_query(user_query, filters=None):
@@ -141,7 +137,7 @@ def select(query, results_per_page=None, page_number=None, sort=None, fields=Non
     """
-    if not settings.SOLR_HOSTNAME and not settings.SOCKS_PORT:
+    if not settings.SOLR_HOSTNAME:
         return {}
     data = {
@@ -180,18 +176,6 @@ def select(query, results_per_page=None, page_number=None, sort=None, fields=Non
                                        settings.SOLR_PORT)
     query_params = urllib.urlencode(data)
     solr_select_uri = settings.SOLR_SELECT_PATH + '?' + query_params
-   
-    # Socks proxy configuration. Only required for development
-    #   if the solr server is behind a firewall. 
-    socks_server = getattr(settings, "SOCKS_SERVER", None)
-    if socks_server: 
-        logging.debug('Socks enabled: %s:%s', settings.SOCKS_SERVER,
-                                              settings.SOCKS_PORT)
-
-        socks.setdefaultproxy(settings.SOCKS_TYPE, 
-                              settings.SOCKS_SERVER,
-                              settings.SOCKS_PORT)
-        socket.socket = socks.socksocket
     try:
         solr_conn.request('GET', solr_select_uri)
@@ -199,8 +183,6 @@ def select(query, results_per_page=None, page_number=None, sort=None, fields=Non
     except socket.error as err: 
         solr_response = None
         logging.exception(err)
-    finally:
-        reset_defaultproxy()
     if solr_response and solr_response.status == 200:
         #TODO: Log error connecting to solr
@@ -270,8 +252,3 @@ def count_types(sample=100, filters=None):
         type_count.update({doc_type: count})
     return type_count
-    
-
-def reset_defaultproxy():
-    socket.socket = DEFAULT_SOCKET
-    socks._defaultproxy = None
@@ -15,11 +15,6 @@ SOLR_HOSTNAME = None
 # Make this unique, and don't share it with anybody.
 SECRET_KEY = ')(jksdfhsjkadfhjkh234ns!8fqu-1186h$vuj'
-#from .deprecated import socks
-#SOCKS_TYPE = socks.PROXY_TYPE_SOCKS5
-#SOCKS_SERVER = '127.0.0.1'
-#SOCKS_PORT = 9050
-
 SITE_URL = 'http://localhost:8000'
 INTERNAL_IPS = ('127.0.0.1', )
	@@ -1,387 +0,0 @@	@@ -1,387 +0,0 @@
1	-"""SocksiPy - Python SOCKS module.
2	-Version 1.00
3	-
4	-Copyright 2006 Dan-Haim. All rights reserved.
5	-
6	-Redistribution and use in source and binary forms, with or without modification,
7	-are permitted provided that the following conditions are met:
8	-1. Redistributions of source code must retain the above copyright notice, this
9	- list of conditions and the following disclaimer.
10	-2. Redistributions in binary form must reproduce the above copyright notice,
11	- this list of conditions and the following disclaimer in the documentation
12	- and/or other materials provided with the distribution.
13	-3. Neither the name of Dan Haim nor the names of his contributors may be used
14	- to endorse or promote products derived from this software without specific
15	- prior written permission.
16	-
17	-THIS SOFTWARE IS PROVIDED BY DAN HAIM "AS IS" AND ANY EXPRESS OR IMPLIED
18	-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
19	-MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
20	-EVENT SHALL DAN HAIM OR HIS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
21	-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22	-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA
23	-OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
24	-LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
25	-OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMANGE.
26	-
27	-
28	-This module provides a standard socket-like interface for Python
29	-for tunneling connections through SOCKS proxies.
30	-
31	-"""
32	-
33	-import socket
34	-import struct
35	-
36	-PROXY_TYPE_SOCKS4 = 1
37	-PROXY_TYPE_SOCKS5 = 2
38	-PROXY_TYPE_HTTP = 3
39	-
40	-_defaultproxy = None
41	-_orgsocket = socket.socket
42	-
43	-class ProxyError(Exception):
44	- def __init__(self, value):
45	- self.value = value
46	- def __str__(self):
47	- return repr(self.value)
48	-
49	-class GeneralProxyError(ProxyError):
50	- def __init__(self, value):
51	- self.value = value
52	- def __str__(self):
53	- return repr(self.value)
54	-
55	-class Socks5AuthError(ProxyError):
56	- def __init__(self, value):
57	- self.value = value
58	- def __str__(self):
59	- return repr(self.value)
60	-
61	-class Socks5Error(ProxyError):
62	- def __init__(self, value):
63	- self.value = value
64	- def __str__(self):
65	- return repr(self.value)
66	-
67	-class Socks4Error(ProxyError):
68	- def __init__(self, value):
69	- self.value = value
70	- def __str__(self):
71	- return repr(self.value)
72	-
73	-class HTTPError(ProxyError):
74	- def __init__(self, value):
75	- self.value = value
76	- def __str__(self):
77	- return repr(self.value)
78	-
79	-_generalerrors = ("success",
80	- "invalid data",
81	- "not connected",
82	- "not available",
83	- "bad proxy type",
84	- "bad input")
85	-
86	-_socks5errors = ("succeeded",
87	- "general SOCKS server failure",
88	- "connection not allowed by ruleset",
89	- "Network unreachable",
90	- "Host unreachable",
91	- "Connection refused",
92	- "TTL expired",
93	- "Command not supported",
94	- "Address type not supported",
95	- "Unknown error")
96	-
97	-_socks5autherrors = ("succeeded",
98	- "authentication is required",
99	- "all offered authentication methods were rejected",
100	- "unknown username or invalid password",
101	- "unknown error")
102	-
103	-_socks4errors = ("request granted",
104	- "request rejected or failed",
105	- "request rejected because SOCKS server cannot connect to identd on the client",
106	- "request rejected because the client program and identd report different user-ids",
107	- "unknown error")
108	-
109	-def setdefaultproxy(proxytype=None,addr=None,port=None,rdns=True,username=None,password=None):
110	- """setdefaultproxy(proxytype, addr[, port[, rdns[, username[, password]]]])
111	- Sets a default proxy which all further socksocket objects will use,
112	- unless explicitly changed.
113	- """
114	- global _defaultproxy
115	- _defaultproxy = (proxytype,addr,port,rdns,username,password)
116	-
117	-class socksocket(socket.socket):
118	- """socksocket([family[, type[, proto]]]) -> socket object
119	-
120	- Open a SOCKS enabled socket. The parameters are the same as
121	- those of the standard socket init. In order for SOCKS to work,
122	- you must specify family=AF_INET, type=SOCK_STREAM and proto=0.
123	- """
124	-
125	- def __init__(self, family=socket.AF_INET, type=socket.SOCK_STREAM, proto=0, _sock=None):
126	- _orgsocket.__init__(self,family,type,proto,_sock)
127	- if _defaultproxy != None:
128	- self.__proxy = _defaultproxy
129	- else:
130	- self.__proxy = (None, None, None, None, None, None)
131	- self.__proxysockname = None
132	- self.__proxypeername = None
133	-
134	- def __recvall(self, bytes):
135	- """__recvall(bytes) -> data
136	- Receive EXACTLY the number of bytes requested from the socket.
137	- Blocks until the required number of bytes have been received.
138	- """
139	- data = ""
140	- while len(data) < bytes:
141	- data = data + self.recv(bytes-len(data))
142	- return data
143	-
144	- def setproxy(self,proxytype=None,addr=None,port=None,rdns=True,username=None,password=None):
145	- """setproxy(proxytype, addr[, port[, rdns[, username[, password]]]])
146	- Sets the proxy to be used.
147	- proxytype - The type of the proxy to be used. Three types
148	- are supported: PROXY_TYPE_SOCKS4 (including socks4a),
149	- PROXY_TYPE_SOCKS5 and PROXY_TYPE_HTTP
150	- addr - The address of the server (IP or DNS).
151	- port - The port of the server. Defaults to 1080 for SOCKS
152	- servers and 8080 for HTTP proxy servers.
153	- rdns - Should DNS queries be preformed on the remote side
154	- (rather than the local side). The default is True.
155	- Note: This has no effect with SOCKS4 servers.
156	- username - Username to authenticate with to the server.
157	- The default is no authentication.
158	- password - Password to authenticate with to the server.
159	- Only relevant when username is also provided.
160	- """
161	- self.__proxy = (proxytype,addr,port,rdns,username,password)
162	-
163	- def __negotiatesocks5(self,destaddr,destport):
164	- """__negotiatesocks5(self,destaddr,destport)
165	- Negotiates a connection through a SOCKS5 server.
166	- """
167	- # First we'll send the authentication packages we support.
168	- if (self.__proxy[4]!=None) and (self.__proxy[5]!=None):
169	- # The username/password details were supplied to the
170	- # setproxy method so we support the USERNAME/PASSWORD
171	- # authentication (in addition to the standard none).
172	- self.sendall("\x05\x02\x00\x02")
173	- else:
174	- # No username/password were entered, therefore we
175	- # only support connections with no authentication.
176	- self.sendall("\x05\x01\x00")
177	- # We'll receive the server's response to determine which
178	- # method was selected
179	- chosenauth = self.__recvall(2)
180	- if chosenauth[0] != "\x05":
181	- self.close()
182	- raise GeneralProxyError((1,_generalerrors[1]))
183	- # Check the chosen authentication method
184	- if chosenauth[1] == "\x00":
185	- # No authentication is required
186	- pass
187	- elif chosenauth[1] == "\x02":
188	- # Okay, we need to perform a basic username/password
189	- # authentication.
190	- self.sendall("\x01" + chr(len(self.__proxy[4])) + self.__proxy[4] + chr(len(self.proxy[5])) + self.__proxy[5])
191	- authstat = self.__recvall(2)
192	- if authstat[0] != "\x01":
193	- # Bad response
194	- self.close()
195	- raise GeneralProxyError((1,_generalerrors[1]))
196	- if authstat[1] != "\x00":
197	- # Authentication failed
198	- self.close()
199	- raise Socks5AuthError,((3,_socks5autherrors[3]))
200	- # Authentication succeeded
201	- else:
202	- # Reaching here is always bad
203	- self.close()
204	- if chosenauth[1] == "\xFF":
205	- raise Socks5AuthError((2,_socks5autherrors[2]))
206	- else:
207	- raise GeneralProxyError((1,_generalerrors[1]))
208	- # Now we can request the actual connection
209	- req = "\x05\x01\x00"
210	- # If the given destination address is an IP address, we'll
211	- # use the IPv4 address request even if remote resolving was specified.
212	- try:
213	- ipaddr = socket.inet_aton(destaddr)
214	- req = req + "\x01" + ipaddr
215	- except socket.error:
216	- # Well it's not an IP number, so it's probably a DNS name.
217	- if self.__proxy[3]==True:
218	- # Resolve remotely
219	- ipaddr = None
220	- req = req + "\x03" + chr(len(destaddr)) + destaddr
221	- else:
222	- # Resolve locally
223	- ipaddr = socket.inet_aton(socket.gethostbyname(destaddr))
224	- req = req + "\x01" + ipaddr
225	- req = req + struct.pack(">H",destport)
226	- self.sendall(req)
227	- # Get the response
228	- resp = self.__recvall(4)
229	- if resp[0] != "\x05":
230	- self.close()
231	- raise GeneralProxyError((1,_generalerrors[1]))
232	- elif resp[1] != "\x00":
233	- # Connection failed
234	- self.close()
235	- if ord(resp[1])<=8:
236	- raise Socks5Error(ord(resp[1]),_generalerrors[ord(resp[1])])
237	- else:
238	- raise Socks5Error(9,_generalerrors[9])
239	- # Get the bound address/port
240	- elif resp[3] == "\x01":
241	- boundaddr = self.__recvall(4)
242	- elif resp[3] == "\x03":
243	- resp = resp + self.recv(1)
244	- boundaddr = self.__recvall(resp[4])
245	- else:
246	- self.close()
247	- raise GeneralProxyError((1,_generalerrors[1]))
248	- boundport = struct.unpack(">H",self.__recvall(2))[0]
249	- self.__proxysockname = (boundaddr,boundport)
250	- if ipaddr != None:
251	- self.__proxypeername = (socket.inet_ntoa(ipaddr),destport)
252	- else:
253	- self.__proxypeername = (destaddr,destport)
254	-
255	- def getproxysockname(self):
256	- """getsockname() -> address info
257	- Returns the bound IP address and port number at the proxy.
258	- """
259	- return self.__proxysockname
260	-
261	- def getproxypeername(self):
262	- """getproxypeername() -> address info
263	- Returns the IP and port number of the proxy.
264	- """
265	- return _orgsocket.getpeername(self)
266	-
267	- def getpeername(self):
268	- """getpeername() -> address info
269	- Returns the IP address and port number of the destination
270	- machine (note: getproxypeername returns the proxy)
271	- """
272	- return self.__proxypeername
273	-
274	- def __negotiatesocks4(self,destaddr,destport):
275	- """__negotiatesocks4(self,destaddr,destport)
276	- Negotiates a connection through a SOCKS4 server.
277	- """
278	- # Check if the destination address provided is an IP address
279	- rmtrslv = False
280	- try:
281	- ipaddr = socket.inet_aton(destaddr)
282	- except socket.error:
283	- # It's a DNS name. Check where it should be resolved.
284	- if self.__proxy[3]==True:
285	- ipaddr = "\x00\x00\x00\x01"
286	- rmtrslv = True
287	- else:
288	- ipaddr = socket.inet_aton(socket.gethostbyname(destaddr))
289	- # Construct the request packet
290	- req = "\x04\x01" + struct.pack(">H",destport) + ipaddr
291	- # The username parameter is considered userid for SOCKS4
292	- if self.__proxy[4] != None:
293	- req = req + self.__proxy[4]
294	- req = req + "\x00"
295	- # DNS name if remote resolving is required
296	- # NOTE: This is actually an extension to the SOCKS4 protocol
297	- # called SOCKS4A and may not be supported in all cases.
298	- if rmtrslv==True:
299	- req = req + destaddr + "\x00"
300	- self.sendall(req)
301	- # Get the response from the server
302	- resp = self.__recvall(8)
303	- if resp[0] != "\x00":
304	- # Bad data
305	- self.close()
306	- raise GeneralProxyError((1,_generalerrors[1]))
307	- if resp[1] != "\x5A":
308	- # Server returned an error
309	- self.close()
310	- if ord(resp[1]) in (91,92,93):
311	- self.close()
312	- raise Socks4Error((ord(resp[1]),_socks4errors[ord(resp[1])-90]))
313	- else:
314	- raise Socks4Error((94,_socks4errors[4]))
315	- # Get the bound address/port
316	- self.__proxysockname = (socket.inet_ntoa(resp[4:]),struct.unpack(">H",resp[2:4])[0])
317	- if rmtrslv != None:
318	- self.__proxypeername = (socket.inet_ntoa(ipaddr),destport)
319	- else:
320	- self.__proxypeername = (destaddr,destport)
321	-
322	- def __negotiatehttp(self,destaddr,destport):
323	- """__negotiatehttp(self,destaddr,destport)
324	- Negotiates a connection through an HTTP server.
325	- """
326	- # If we need to resolve locally, we do this now
327	- if self.__proxy[3] == False:
328	- addr = socket.gethostbyname(destaddr)
329	- else:
330	- addr = destaddr
331	- self.sendall("CONNECT " + addr + ":" + str(destport) + " HTTP/1.1\r\n" + "Host: " + destaddr + "\r\n\r\n")
332	- # We read the response until we get the string "\r\n\r\n"
333	- resp = self.recv(1)
334	- while resp.find("\r\n\r\n")==-1:
335	- resp = resp + self.recv(1)
336	- # We just need the first line to check if the connection
337	- # was successful
338	- statusline = resp.splitlines()[0].split(" ",2)
339	- if statusline[0] not in ("HTTP/1.0","HTTP/1.1"):
340	- self.close()
341	- raise GeneralProxyError((1,_generalerrors[1]))
342	- try:
343	- statuscode = int(statusline[1])
344	- except ValueError:
345	- self.close()
346	- raise GeneralProxyError((1,_generalerrors[1]))
347	- if statuscode != 200:
348	- self.close()
349	- raise HTTPError((statuscode,statusline[2]))
350	- self.__proxysockname = ("0.0.0.0",0)
351	- self.__proxypeername = (addr,destport)
352	-
353	- def connect(self,destpair):
354	- """connect(self,despair)
355	- Connects to the specified destination through a proxy.
356	- destpar - A tuple of the IP/DNS address and the port number.
357	- (identical to socket's connect).
358	- To select the proxy server use setproxy().
359	- """
360	- # Do a minimal input check first
361	- if (type(destpair) in (list,tuple)==False) or (len(destpair)<2) or (type(destpair[0])!=str) or (type(destpair[1])!=int):
362	- raise GeneralProxyError((5,_generalerrors[5]))
363	- if self.__proxy[0] == PROXY_TYPE_SOCKS5:
364	- if self.__proxy[2] != None:
365	- portnum = self.__proxy[2]
366	- else:
367	- portnum = 1080
368	- _orgsocket.connect(self,(self.__proxy[1],portnum))
369	- self.__negotiatesocks5(destpair[0],destpair[1])
370	- elif self.__proxy[0] == PROXY_TYPE_SOCKS4:
371	- if self.__proxy[2] != None:
372	- portnum = self.__proxy[2]
373	- else:
374	- portnum = 1080
375	- _orgsocket.connect(self,(self.__proxy[1],portnum))
376	- self.__negotiatesocks4(destpair[0],destpair[1])
377	- elif self.__proxy[0] == PROXY_TYPE_HTTP:
378	- if self.__proxy[2] != None:
379	- portnum = self.__proxy[2]
380	- else:
381	- portnum = 8080
382	- _orgsocket.connect(self,(self.__proxy[1],portnum))
383	- self.__negotiatehttp(destpair[0],destpair[1])
384	- elif self.__proxy[0] == None:
385	- _orgsocket.connect(self,(destpair[0],destpair[1]))
386	- else:
387	- raise GeneralProxyError((4,_generalerrors[4]))