From 3939c188b0f9d594ed7e1e6e3707a2f594c42a55 Mon Sep 17 00:00:00 2001
From: Timm Fitschen <timm.fitschen@ds.mpg.de>
Date: Mon, 19 Nov 2018 17:12:18 +0100
Subject: [PATCH] ADD SocksiPy modules
---
setup.py | 2 +-
src/caosdb/connection/BUGS | 25 ++
src/caosdb/connection/LICENSE | 22 ++
src/caosdb/connection/README | 201 +++++++++++++
src/caosdb/connection/SocksiPy.zip | Bin 0 -> 9266 bytes
src/caosdb/connection/connection.py | 7 +-
src/caosdb/connection/socks.py | 387 +++++++++++++++++++++++++
src/caosdb/connection/streaminghttp.py | 16 +-
8 files changed, 656 insertions(+), 4 deletions(-)
create mode 100644 src/caosdb/connection/BUGS
create mode 100644 src/caosdb/connection/LICENSE
create mode 100644 src/caosdb/connection/README
create mode 100644 src/caosdb/connection/SocksiPy.zip
create mode 100644 src/caosdb/connection/socks.py
diff --git a/setup.py b/setup.py
index f80c6195..6adefd59 100755
--- a/setup.py
+++ b/setup.py
@@ -26,7 +26,7 @@
from setuptools import setup, find_packages
setup(name='PyCaosDB',
- version='0.1.0',
+ version='0.2.0',
description='Python Interface for CaosDB',
author='Timm Fitschen',
author_email='timm.fitschen@ds.mpg.de',
diff --git a/src/caosdb/connection/BUGS b/src/caosdb/connection/BUGS
new file mode 100644
index 00000000..2412351a
--- /dev/null
+++ b/src/caosdb/connection/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@users.sourceforge.net
+
+
+Thank you!
diff --git a/src/caosdb/connection/LICENSE b/src/caosdb/connection/LICENSE
new file mode 100644
index 00000000..fc330787
--- /dev/null
+++ b/src/caosdb/connection/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/src/caosdb/connection/README b/src/caosdb/connection/README
new file mode 100644
index 00000000..deae6f6d
--- /dev/null
+++ b/src/caosdb/connection/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@users.sourceforge.net
+
+Please allow some time for your question to be received and handled.
+
+
+Dan-Haim,
+Author.
diff --git a/src/caosdb/connection/SocksiPy.zip b/src/caosdb/connection/SocksiPy.zip
new file mode 100644
index 0000000000000000000000000000000000000000..e81f1f9393c766a3acd41b44245f9e17f090cbe5
GIT binary patch
literal 9266
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
RurRPNTx4Ki@Ky$?0|3F`cBcRU
literal 0
HcmV?d00001
diff --git a/src/caosdb/connection/connection.py b/src/caosdb/connection/connection.py
index 10674e71..d7a98b6f 100644
--- a/src/caosdb/connection/connection.py
+++ b/src/caosdb/connection/connection.py
@@ -112,10 +112,15 @@ class _DefaultCaosDBServerConnection(CaosDBServerConnection):
"No connection url specified. Please "
"do so via caosdb.configure_connection(...) or in a config "
"file.")
+
+ socket_proxy = None
+ if "socket_proxy" in config:
+ socket_proxy = config["socket_proxy"]
self._http_con = StreamingHTTPSConnection(
host=host,
timeout=int(config.get("timeout")),
- context=context)
+ context=context,
+ socket_proxy=socket_proxy)
def _make_conf(*conf):
diff --git a/src/caosdb/connection/socks.py b/src/caosdb/connection/socks.py
new file mode 100644
index 00000000..c41b1ec9
--- /dev/null
+++ b/src/caosdb/connection/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.
+
+"""
+
+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]))
diff --git a/src/caosdb/connection/streaminghttp.py b/src/caosdb/connection/streaminghttp.py
index fa97a964..55f5ba3a 100644
--- a/src/caosdb/connection/streaminghttp.py
+++ b/src/caosdb/connection/streaminghttp.py
@@ -51,7 +51,8 @@ since there is no way to determine in advance the total size that will be
yielded, and there is no way to reset an interator.
"""
-from __future__ import unicode_literals, print_function
+from __future__ import unicode_literals, print_function, absolute_import
+from . import socks
import socket
try:
# python3
@@ -69,6 +70,17 @@ class StreamingHTTPSConnection(client.HTTPSConnection, object):
that overrides the `send()` method to support iterable body objects."""
# pylint: disable=unused-argument, arguments-differ
+ def __init__(self, socket_proxy=None, **kwargs):
+ if socket_proxy is not None:
+ print("socket_proxy:" + socket_proxy)
+ host, port = socket_proxy.split(":")
+ socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS5, host,
+ int(port))
+ socket.socket = socks.socksocket
+ else:
+ print("no socket_proxy")
+ super(StreamingHTTPSConnection, self).__init__(**kwargs)
+
def _send_output(self, body, **kwargs):
"""Send the currently buffered request and clear the buffer.
@@ -87,7 +99,7 @@ class StreamingHTTPSConnection(client.HTTPSConnection, object):
if body is not None:
self.send(body)
- # pylint: disable=too-complex, too-many-branches
+ # pylint: disable=too-many-branches
def send(self, value):
"""Send ``value`` to the server.
--
GitLab