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', )
...	...	@@ -166,11 +166,6 @@ MESSAGE_TAGS = {
166	166	}
167	167
168	168
169		-### Proxy configuration
170		-SOCKS_SERVER = None
171		-SOCKS_PORT = None
172		-
173		-
174	169	### Feedzilla (planet)
175	170	from feedzilla.settings import *
176	171	FEEDZILLA_PAGE_SIZE = 5
...	...
...	...	@@ -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]))
...	...	@@ -13,10 +13,6 @@ from dateutil.parser import parse as parse_timestamp
13	13	from django.conf import settings
14	14
15	15	from super_archives.models import EmailAddress
16		-from . import socks
17		-
18		-
19		-DEFAULT_SOCKET = socket.socket
20	16
21	17
22	18	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
141	137
142	138	"""
143	139
144		- if not settings.SOLR_HOSTNAME and not settings.SOCKS_PORT:
	140	+ if not settings.SOLR_HOSTNAME:
145	141	return {}
146	142
147	143	data = {
...	...	@@ -180,18 +176,6 @@ def select(query, results_per_page=None, page_number=None, sort=None, fields=Non
180	176	settings.SOLR_PORT)
181	177	query_params = urllib.urlencode(data)
182	178	solr_select_uri = settings.SOLR_SELECT_PATH + '?' + query_params
183		-
184		- # Socks proxy configuration. Only required for development
185		- # if the solr server is behind a firewall.
186		- socks_server = getattr(settings, "SOCKS_SERVER", None)
187		- if socks_server:
188		- logging.debug('Socks enabled: %s:%s', settings.SOCKS_SERVER,
189		- settings.SOCKS_PORT)
190		-
191		- socks.setdefaultproxy(settings.SOCKS_TYPE,
192		- settings.SOCKS_SERVER,
193		- settings.SOCKS_PORT)
194		- socket.socket = socks.socksocket
195	179
196	180	try:
197	181	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
199	183	except socket.error as err:
200	184	solr_response = None
201	185	logging.exception(err)
202		- finally:
203		- reset_defaultproxy()
204	186
205	187	if solr_response and solr_response.status == 200:
206	188	#TODO: Log error connecting to solr
...	...	@@ -270,8 +252,3 @@ def count_types(sample=100, filters=None):
270	252	type_count.update({doc_type: count})
271	253
272	254	return type_count
273		-
274		-
275		-def reset_defaultproxy():
276		- socket.socket = DEFAULT_SOCKET
277		- socks._defaultproxy = None
...	...
...	...	@@ -15,11 +15,6 @@ SOLR_HOSTNAME = None
15	15	# Make this unique, and don't share it with anybody.
16	16	SECRET_KEY = ')(jksdfhsjkadfhjkh234ns!8fqu-1186h$vuj'
17	17
18		-#from .deprecated import socks
19		-#SOCKS_TYPE = socks.PROXY_TYPE_SOCKS5
20		-#SOCKS_SERVER = '127.0.0.1'
21		-#SOCKS_PORT = 9050
22		-
23	18	SITE_URL = 'http://localhost:8000'
24	19
25	20	INTERNAL_IPS = ('127.0.0.1', )
...	...