[Python-modules-commits] [python-socksipy] 01/10: import 1.02 from Debian package
Wolfgang Borgert
debacle at moszumanska.debian.org
Fri Jan 8 00:26:33 UTC 2016
This is an automated email from the git hooks/post-receive script.
debacle pushed a commit to branch master
in repository python-socksipy.
commit 7270a5c1727d757b2123042f043ab7fd789371d7
Author: W. Martin Borgert <debacle at debian.org>
Date: Mon Dec 28 00:21:23 2015 +0100
import 1.02 from Debian package
---
BUGS | 25 +++++
LICENSE | 22 ++++
PKG-INFO | 10 ++
README | 201 +++++++++++++++++++++++++++++++++
setup.py | 17 +++
socks.py | 387 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
6 files changed, 662 insertions(+)
diff --git a/BUGS b/BUGS
new file mode 100644
index 0000000..2412351
--- /dev/null
+++ b/BUGS
@@ -0,0 +1,25 @@
+SocksiPy version 1.00
+A Python SOCKS module.
+(C) 2006 Dan-Haim. All rights reserved.
+See LICENSE file for details.
+
+
+KNOWN BUGS AND ISSUES
+----------------------
+
+There are no currently known bugs in this module.
+There are some limits though:
+
+1) Only outgoing connections are supported - This module currently only supports
+outgoing TCP connections, though some servers may support incoming connections
+as well. UDP is not supported either.
+
+2) GSSAPI Socks5 authenticaion is not supported.
+
+
+If you find any new bugs, please contact the author at:
+
+negativeiq at users.sourceforge.net
+
+
+Thank you!
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..fc33078
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,22 @@
+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.
diff --git a/PKG-INFO b/PKG-INFO
new file mode 100644
index 0000000..e24da45
--- /dev/null
+++ b/PKG-INFO
@@ -0,0 +1,10 @@
+Metadata-Version: 1.0
+Name: SocksiPy-branch
+Version: 1.02
+Summary: A Python SOCKS module
+Home-page: http://socksipy.sourceforge.net/
+Author: Dan-Haim
+Author-email: negativeiq at users.sourceforge.net
+License: BSD
+Description: This Python module allows you to create TCP connections through a SOCKS proxy without any special effort.
+Platform: UNKNOWN
diff --git a/README b/README
new file mode 100644
index 0000000..deae6f6
--- /dev/null
+++ b/README
@@ -0,0 +1,201 @@
+SocksiPy version 1.00
+A Python SOCKS module.
+(C) 2006 Dan-Haim. All rights reserved.
+See LICENSE file for details.
+
+
+WHAT IS A SOCKS PROXY?
+A SOCKS proxy is a proxy server at the TCP level. In other words, it acts as
+a tunnel, relaying all traffic going through it without modifying it.
+SOCKS proxies can be used to relay traffic using any network protocol that
+uses TCP.
+
+WHAT IS SOCKSIPY?
+This Python module allows you to create TCP connections through a SOCKS
+proxy without any special effort.
+
+PROXY COMPATIBILITY
+SocksiPy is compatible with three different types of proxies:
+1. SOCKS Version 4 (Socks4), including the Socks4a extension.
+2. SOCKS Version 5 (Socks5).
+3. HTTP Proxies which support tunneling using the CONNECT method.
+
+SYSTEM REQUIREMENTS
+Being written in Python, SocksiPy can run on any platform that has a Python
+interpreter and TCP/IP support.
+This module has been tested with Python 2.3 and should work with greater versions
+just as well.
+
+
+INSTALLATION
+-------------
+
+Simply copy the file "socks.py" to your Python's lib/site-packages directory,
+and you're ready to go.
+
+
+USAGE
+------
+
+First load the socks module with the command:
+
+>>> import socks
+>>>
+
+The socks module provides a class called "socksocket", which is the base to
+all of the module's functionality.
+The socksocket object has the same initialization parameters as the normal socket
+object to ensure maximal compatibility, however it should be noted that socksocket
+will only function with family being AF_INET and type being SOCK_STREAM.
+Generally, it is best to initialize the socksocket object with no parameters
+
+>>> s = socks.socksocket()
+>>>
+
+The socksocket object has an interface which is very similiar to socket's (in fact
+the socksocket class is derived from socket) with a few extra methods.
+To select the proxy server you would like to use, use the setproxy method, whose
+syntax is:
+
+setproxy(proxytype, addr[, port[, rdns[, username[, password]]]])
+
+Explaination of the parameters:
+
+proxytype - The type of the proxy server. This can be one of three possible
+choices: PROXY_TYPE_SOCKS4, PROXY_TYPE_SOCKS5 and PROXY_TYPE_HTTP for Socks4,
+Socks5 and HTTP servers respectively.
+
+addr - The IP address or DNS name of the proxy server.
+
+port - The port of the proxy server. Defaults to 1080 for socks and 8080 for http.
+
+rdns - This is a boolean flag than modifies the behavior regarding DNS resolving.
+If it is set to True, DNS resolving will be preformed remotely, on the server.
+If it is set to False, DNS resolving will be preformed locally. Please note that
+setting this to True with Socks4 servers actually use an extension to the protocol,
+called Socks4a, which may not be supported on all servers (Socks5 and http servers
+always support DNS). The default is True.
+
+username - For Socks5 servers, this allows simple username / password authentication
+with the server. For Socks4 servers, this parameter will be sent as the userid.
+This parameter is ignored if an HTTP server is being used. If it is not provided,
+authentication will not be used (servers may accept unauthentication requests).
+
+password - This parameter is valid only for Socks5 servers and specifies the
+respective password for the username provided.
+
+Example of usage:
+
+>>> s.setproxy(socks.PROXY_TYPE_SOCKS5,"socks.example.com")
+>>>
+
+After the setproxy method has been called, simply call the connect method with the
+traditional parameters to establish a connection through the proxy:
+
+>>> s.connect(("www.sourceforge.net",80))
+>>>
+
+Connection will take a bit longer to allow negotiation with the proxy server.
+Please note that calling connect without calling setproxy earlier will connect
+without a proxy (just like a regular socket).
+
+Errors: Any errors in the connection process will trigger exceptions. The exception
+may either be generated by the underlying socket layer or may be custom module
+exceptions, whose details follow:
+
+class ProxyError - This is a base exception class. It is not raised directly but
+rather all other exception classes raised by this module are derived from it.
+This allows an easy way to catch all proxy-related errors.
+
+class GeneralProxyError - When thrown, it indicates a problem which does not fall
+into another category. The parameter is a tuple containing an error code and a
+description of the error, from the following list:
+1 - invalid data - This error means that unexpected data has been received from
+the server. The most common reason is that the server specified as the proxy is
+not really a Socks4/Socks5/HTTP proxy, or maybe the proxy type specified is wrong.
+4 - bad proxy type - This will be raised if the type of the proxy supplied to the
+setproxy function was not PROXY_TYPE_SOCKS4/PROXY_TYPE_SOCKS5/PROXY_TYPE_HTTP.
+5 - bad input - This will be raised if the connect method is called with bad input
+parameters.
+
+class Socks5AuthError - This indicates that the connection through a Socks5 server
+failed due to an authentication problem. The parameter is a tuple containing a
+code and a description message according to the following list:
+
+1 - authentication is required - This will happen if you use a Socks5 server which
+requires authentication without providing a username / password at all.
+2 - all offered authentication methods were rejected - This will happen if the proxy
+requires a special authentication method which is not supported by this module.
+3 - unknown username or invalid password - Self descriptive.
+
+class Socks5Error - This will be raised for Socks5 errors which are not related to
+authentication. The parameter is a tuple containing a code and a description of the
+error, as given by the server. The possible errors, according to the RFC are:
+
+1 - General SOCKS server failure - If for any reason the proxy server is unable to
+fulfill your request (internal server error).
+2 - connection not allowed by ruleset - If the address you're trying to connect to
+is blacklisted on the server or requires authentication.
+3 - Network unreachable - The target could not be contacted. A router on the network
+had replied with a destination net unreachable error.
+4 - Host unreachable - The target could not be contacted. A router on the network
+had replied with a destination host unreachable error.
+5 - Connection refused - The target server has actively refused the connection
+(the requested port is closed).
+6 - TTL expired - The TTL value of the SYN packet from the proxy to the target server
+has expired. This usually means that there are network problems causing the packet
+to be caught in a router-to-router "ping-pong".
+7 - Command not supported - The client has issued an invalid command. When using this
+module, this error should not occur.
+8 - Address type not supported - The client has provided an invalid address type.
+When using this module, this error should not occur.
+
+class Socks4Error - This will be raised for Socks4 errors. The parameter is a tuple
+containing a code and a description of the error, as given by the server. The
+possible error, according to the specification are:
+
+1 - Request rejected or failed - Will be raised in the event of an failure for any
+reason other then the two mentioned next.
+2 - request rejected because SOCKS server cannot connect to identd on the client -
+The Socks server had tried an ident lookup on your computer and has failed. In this
+case you should run an identd server and/or configure your firewall to allow incoming
+connections to local port 113 from the remote server.
+3 - request rejected because the client program and identd report different user-ids -
+The Socks server had performed an ident lookup on your computer and has received a
+different userid than the one you have provided. Change your userid (through the
+username parameter of the setproxy method) to match and try again.
+
+class HTTPError - This will be raised for HTTP errors. The parameter is a tuple
+containing the HTTP status code and the description of the server.
+
+
+After establishing the connection, the object behaves like a standard socket.
+Call the close method to close the connection.
+
+In addition to the socksocket class, an additional function worth mentioning is the
+setdefaultproxy function. The parameters are the same as the setproxy method.
+This function will set default proxy settings for newly created socksocket objects,
+in which the proxy settings haven't been changed via the setproxy method.
+This is quite useful if you wish to force 3rd party modules to use a socks proxy,
+by overriding the socket object.
+For example:
+
+>>> socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS5,"socks.example.com")
+>>> socket.socket = socks.socksocket
+>>> urllib.urlopen("http://www.sourceforge.net/")
+
+
+PROBLEMS
+---------
+
+If you have any problems using this module, please first refer to the BUGS file
+(containing current bugs and issues). If your problem is not mentioned you may
+contact the author at the following E-Mail address:
+
+negativeiq at users.sourceforge.net
+
+Please allow some time for your question to be received and handled.
+
+
+Dan-Haim,
+Author.
diff --git a/setup.py b/setup.py
new file mode 100644
index 0000000..abc6867
--- /dev/null
+++ b/setup.py
@@ -0,0 +1,17 @@
+#!/usr/bin/env python
+from distutils.core import setup
+
+VERSION = "1.02"
+
+setup(
+name = "SocksiPy-branch",
+version = VERSION,
+description = "A Python SOCKS module",
+long_description = "This Python module allows you to create TCP connections through a SOCKS proxy without any special effort.",
+url = "http://socksipy.sourceforge.net/",
+author = "Dan-Haim",
+author_email="negativeiq at users.sourceforge.net",
+license = "BSD",
+py_modules=["socks"]
+)
+
diff --git a/socks.py b/socks.py
new file mode 100644
index 0000000..4e513fe
--- /dev/null
+++ b/socks.py
@@ -0,0 +1,387 @@
+"""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.
+
+"""
+
+"""
+
+Minor modifications made by Christopher Gilbert (http://motomastyle.com/)
+for use in PyLoris (http://pyloris.sourceforge.net/)
+
+Minor modifications made by Mario Vilas (http://breakingcode.wordpress.com/)
+mainly to merge bug fixes found in Sourceforge
+
+"""
+
+import socket
+import struct
+import sys
+
+PROXY_TYPE_SOCKS4 = 1
+PROXY_TYPE_SOCKS5 = 2
+PROXY_TYPE_HTTP = 3
+
+_defaultproxy = None
+_orgsocket = socket.socket
+
+class ProxyError(Exception): pass
+class GeneralProxyError(ProxyError): pass
+class Socks5AuthError(ProxyError): pass
+class Socks5Error(ProxyError): pass
+class Socks4Error(ProxyError): pass
+class HTTPError(ProxyError): pass
+
+_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)
+
+def wrapmodule(module):
+ """wrapmodule(module)
+ Attempts to replace a module's socket library with a SOCKS socket. Must set
+ a default proxy using setdefaultproxy(...) first.
+ This will only work on modules that import socket directly into the namespace;
+ most of the Python Standard Library falls into this category.
+ """
+ if _defaultproxy != None:
+ module.socket.socket = socksocket
+ else:
+ raise GeneralProxyError((4, "no proxy specified"))
+
+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, count):
+ """__recvall(count) -> data
+ Receive EXACTLY the number of bytes requested from the socket.
+ Blocks until the required number of bytes have been received.
+ """
+ data = self.recv(count)
+ while len(data) < count:
+ d = self.recv(count-len(data))
+ if not d: raise GeneralProxyError((0, "connection closed unexpectedly"))
+ data = data + d
+ 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(struct.pack('BBBB', 0x05, 0x02, 0x00, 0x02))
+ else:
+ # No username/password were entered, therefore we
+ # only support connections with no authentication.
+ self.sendall(struct.pack('BBB', 0x05, 0x01, 0x00))
+ # We'll receive the server's response to determine which
+ # method was selected
+ chosenauth = self.__recvall(2)
+ if chosenauth[0:1] != chr(0x05).encode():
+ self.close()
+ raise GeneralProxyError((1, _generalerrors[1]))
+ # Check the chosen authentication method
+ if chosenauth[1:2] == chr(0x00).encode():
+ # No authentication is required
+ pass
+ elif chosenauth[1:2] == chr(0x02).encode():
+ # Okay, we need to perform a basic username/password
+ # authentication.
+ self.sendall(chr(0x01).encode() + chr(len(self.__proxy[4])) + self.__proxy[4] + chr(len(self.__proxy[5])) + self.__proxy[5])
+ authstat = self.__recvall(2)
+ if authstat[0:1] != chr(0x01).encode():
+ # Bad response
+ self.close()
+ raise GeneralProxyError((1, _generalerrors[1]))
+ if authstat[1:2] != chr(0x00).encode():
+ # Authentication failed
+ self.close()
+ raise Socks5AuthError((3, _socks5autherrors[3]))
+ # Authentication succeeded
+ else:
+ # Reaching here is always bad
+ self.close()
+ if chosenauth[1] == chr(0xFF).encode():
+ raise Socks5AuthError((2, _socks5autherrors[2]))
+ else:
+ raise GeneralProxyError((1, _generalerrors[1]))
+ # Now we can request the actual connection
+ req = struct.pack('BBB', 0x05, 0x01, 0x00)
+ # 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 + chr(0x01).encode() + ipaddr
+ except socket.error:
+ # Well it's not an IP number, so it's probably a DNS name.
+ if self.__proxy[3]:
+ # Resolve remotely
+ ipaddr = None
+ if type(destaddr) != type(b''): # python3
+ destaddr_bytes = destaddr.encode()
+ # TODO: support "xn--" prefixes as defined by RFC 3490
+ else:
+ destaddr_bytes = destaddr
+ req = req + chr(0x03).encode() + chr(len(destaddr_bytes)).encode() + destaddr_bytes
+ else:
+ # Resolve locally
+ ipaddr = socket.inet_aton(socket.gethostbyname(destaddr))
+ req = req + chr(0x01).encode() + ipaddr
+ req = req + struct.pack(">H", destport)
+ self.sendall(req)
+ # Get the response
+ resp = self.__recvall(4)
+ if resp[0:1] != chr(0x05).encode():
+ self.close()
+ raise GeneralProxyError((1, _generalerrors[1]))
+ elif resp[1:2] != chr(0x00).encode():
+ # Connection failed
+ self.close()
+ if ord(resp[1:2])<=8:
+ raise Socks5Error((ord(resp[1:2]), _socks5errors[ord(resp[1:2])]))
+ else:
+ raise Socks5Error((9, _socks5errors[9]))
+ # Get the bound address/port
+ elif resp[3:4] == chr(0x01).encode():
+ boundaddr = self.__recvall(4)
+ elif resp[3:4] == chr(0x03).encode():
+ resp = resp + self.recv(1)
+ boundaddr = self.__recvall(ord(resp[4:5]))
+ 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]:
+ ipaddr = struct.pack("BBBB", 0x00, 0x00, 0x00, 0x01)
+ rmtrslv = True
+ else:
+ ipaddr = socket.inet_aton(socket.gethostbyname(destaddr))
+ # Construct the request packet
+ req = struct.pack(">BBH", 0x04, 0x01, destport) + ipaddr
+ # The username parameter is considered userid for SOCKS4
+ if self.__proxy[4] != None:
+ req = req + self.__proxy[4]
+ req = req + chr(0x00).encode()
+ # 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:
+ req = req + destaddr + chr(0x00).encode()
+ self.sendall(req)
+ # Get the response from the server
+ resp = self.__recvall(8)
+ if resp[0:1] != chr(0x00).encode():
+ # Bad data
+ self.close()
+ raise GeneralProxyError((1,_generalerrors[1]))
+ if resp[1:2] != chr(0x5A).encode():
+ # Server returned an error
+ self.close()
+ if ord(resp[1:2]) in (91, 92, 93):
+ self.close()
+ raise Socks4Error((ord(resp[1:2]), _socks4errors[ord(resp[1:2]) - 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 not self.__proxy[3]:
+ addr = socket.gethostbyname(destaddr)
+ else:
+ addr = destaddr
+ self.sendall(("CONNECT " + addr + ":" + str(destport) + " HTTP/1.1\r\n" + "Host: " + destaddr + "\r\n\r\n").encode())
+ # We read the response until we get the string "\r\n\r\n"
+ resp = self.recv(1)
+ while resp.find("\r\n\r\n".encode()) == -1:
+ resp = resp + self.recv(1)
+ # We just need the first line to check if the connection
+ # was successful
+ statusline = resp.splitlines()[0].split(" ".encode(), 2)
+ if statusline[0] not in ("HTTP/1.0".encode(), "HTTP/1.1".encode()):
+ 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 (not type(destpair) in (list,tuple)) or (len(destpair) < 2) or (type(destpair[0]) != type('')) 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]))
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/python-modules/packages/python-socksipy.git
More information about the Python-modules-commits
mailing list