Skip to content
This repository was archived by the owner on Jan 13, 2021. It is now read-only.

Commit 0f0d2a8

Browse files
KOLANICHKOLANICH
committed
Implemented SOCKS5 proxies and fixed h2.settings.ENABLE_PUSH to h2.settings.SettingCodes.ENABLE_PUSH. The code was taken from urllib3 and adapted to hyper.
1 parent 18b629b commit 0f0d2a8

5 files changed

Lines changed: 162 additions & 57 deletions

File tree

‎LICENSE‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,7 @@
11
The MIT License (MIT)
22

33
Copyright (c) 2014 Cory Benfield, Google Inc
4+
Copyright (c) 2008-2020 Andrey Petrov and urllib3 contributors (see https://github.com/urllib3/urllib3/blob/master/CONTRIBUTORS.txt) (socks5 code was borrowed from there)
45

56
Permission is hereby granted, free of charge, to any person obtaining a copy
67
of this software and associated documentation files (the "Software"), to deal

‎hyper/common/connection.py‎

Lines changed: 15 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -46,6 +46,7 @@ class HTTPConnection(object):
4646
:param proxy_port: (optional) The proxy port to connect to. If not provided
4747
and one also isn't provided in the ``proxy_host`` parameter, defaults
4848
to 8080.
49+
:param proxy_type: (optional) type of the proxy to use. Allows usage of socks proxies
4950
:param proxy_headers: (optional) The headers to send to a proxy.
5051
"""
5152
def __init__(self,
@@ -57,6 +58,7 @@ def __init__(self,
5758
ssl_context=None,
5859
proxy_host=None,
5960
proxy_port=None,
61+
proxy_type=None,
6062
proxy_headers=None,
6163
timeout=None,
6264
**kwargs):
@@ -66,14 +68,14 @@ def __init__(self,
6668
self._h1_kwargs = {
6769
'secure': secure, 'ssl_context': ssl_context,
6870
'proxy_host': proxy_host, 'proxy_port': proxy_port,
69-
'proxy_headers': proxy_headers, 'enable_push': enable_push,
71+
'proxy_headers': proxy_headers, "proxy_type": proxy_type, 'enable_push': enable_push,
7072
'timeout': timeout
7173
}
7274
self._h2_kwargs = {
7375
'window_manager': window_manager, 'enable_push': enable_push,
7476
'secure': secure, 'ssl_context': ssl_context,
7577
'proxy_host': proxy_host, 'proxy_port': proxy_port,
76-
'proxy_headers': proxy_headers,
78+
'proxy_headers': proxy_headers, "proxy_type": proxy_type,
7779
'timeout': timeout
7880
}
7981

@@ -150,6 +152,17 @@ def get_response(self, *args, **kwargs):
150152

151153
return self._conn.get_response(1)
152154

155+
def reanimate(self):
156+
"""Reanimate connection reset because of proxy"""
157+
if hasattr(self, "streams"):
158+
for stream in list(self.streams.values()):
159+
stream.remote_closed = True
160+
stream.local_closed = True
161+
self._conn.close()
162+
self._conn = HTTP11Connection(
163+
self._host, self._port, **self._h1_kwargs,
164+
)
165+
153166
# The following two methods are the implementation of the context manager
154167
# protocol.
155168
def __enter__(self): # pragma: no cover

‎hyper/contrib.py‎

Lines changed: 49 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -56,19 +56,32 @@ def get_connection(self, host, port, scheme, cert=None, verify=True,
5656
ssl_context = init_context(cert_path=verify, cert=cert)
5757

5858
if proxy:
59+
proxy = prepend_scheme_if_needed(proxy, 'http')
5960
proxy_headers = self.proxy_headers(proxy)
60-
proxy_netloc = urlparse(proxy).netloc
61+
parsed = urlparse(proxy)
62+
proxy_netloc = parsed.netloc
63+
proxy_host_port = proxy_netloc.split(":")
64+
if len(proxy_host_port) == 2:
65+
proxy_host, proxy_port = proxy_host_port
66+
proxy_port = int(proxy_port)
67+
elif len(proxy_port_host) == 1:
68+
raise ValueError("Specify proxy port!")
69+
else:
70+
raise ValueError("Invalid proxy netloc: ", repr(proxy_netloc))
71+
proxy_type = parsed.scheme
6172
else:
6273
proxy_headers = None
63-
proxy_netloc = None
74+
proxy_host = None
75+
proxy_port = None
76+
proxy_type = None
6477

6578
# We put proxy headers in the connection_key, because
6679
# ``proxy_headers`` method might be overridden, so we can't
6780
# rely on proxy headers being the same for the same proxies.
6881
proxy_headers_key = (frozenset(proxy_headers.items())
6982
if proxy_headers else None)
7083
connection_key = (host, port, scheme, cert, verify,
71-
proxy_netloc, proxy_headers_key)
84+
proxy_host, proxy_port, proxy_type, proxy_headers_key)
7285
try:
7386
conn = self.connections[connection_key]
7487
except KeyError:
@@ -78,9 +91,13 @@ def get_connection(self, host, port, scheme, cert=None, verify=True,
7891
secure=secure,
7992
window_manager=self.window_manager,
8093
ssl_context=ssl_context,
81-
proxy_host=proxy_netloc,
94+
proxy_host=proxy_host,
95+
proxy_port=proxy_port,
8296
proxy_headers=proxy_headers,
83-
timeout=timeout)
97+
proxy_type=proxy_type,
98+
timeout=timeout,
99+
enable_push=self.enable_push
100+
)
84101
self.connections[connection_key] = conn
85102

86103
return conn
@@ -95,6 +112,12 @@ def send(self, request, stream=False, cert=None, verify=True, proxies=None,
95112
proxy = prepend_scheme_if_needed(proxy, 'http')
96113

97114
parsed = urlparse(request.url)
115+
116+
# Build the selector.
117+
selector = parsed.path
118+
selector += '?' + parsed.query if parsed.query else ''
119+
selector += '#' + parsed.fragment if parsed.fragment else ''
120+
98121
conn = self.get_connection(
99122
parsed.hostname,
100123
parsed.port,
@@ -104,18 +127,27 @@ def send(self, request, stream=False, cert=None, verify=True, proxies=None,
104127
proxy=proxy,
105128
timeout=timeout)
106129

107-
# Build the selector.
108-
selector = parsed.path
109-
selector += '?' + parsed.query if parsed.query else ''
110-
selector += '#' + parsed.fragment if parsed.fragment else ''
111-
112-
conn.request(
113-
request.method,
114-
selector,
115-
request.body,
116-
request.headers
117-
)
118-
resp = conn.get_response()
130+
def do_req():
131+
conn.request(
132+
request.method,
133+
selector,
134+
request.body,
135+
request.headers
136+
)
137+
resp = conn.get_response()
138+
return conn, resp
139+
140+
retried = 0
141+
max_retries = 1
142+
while True:
143+
try:
144+
conn, resp = do_req()
145+
break
146+
except ConnectionAbortedError as e:
147+
if retried < max_retries:
148+
conn.reanimate()
149+
else:
150+
raise
119151

120152
r = self.build_response(request, resp)
121153

‎hyper/http11/connection.py‎

Lines changed: 48 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -101,7 +101,7 @@ class HTTP11Connection(object):
101101

102102
def __init__(self, host, port=None, secure=None, ssl_context=None,
103103
proxy_host=None, proxy_port=None, proxy_headers=None,
104-
timeout=None, **kwargs):
104+
proxy_type=None, timeout=None, **kwargs):
105105
if port is None:
106106
self.host, self.port = to_host_port_tuple(host, default_port=80)
107107
else:
@@ -133,11 +133,14 @@ def __init__(self, host, port=None, secure=None, ssl_context=None,
133133
self.proxy_host, self.proxy_port = to_host_port_tuple(
134134
proxy_host, default_port=8080
135135
)
136+
self.proxy_type = proxy_type
136137
elif proxy_host:
137-
self.proxy_host, self.proxy_port = proxy_host, proxy_port
138+
self.proxy_host, self.proxy_port, self.proxy_type = proxy_host, proxy_port, proxy_type
138139
else:
139140
self.proxy_host = None
140141
self.proxy_port = None
142+
self.proxy_type = None
143+
raise ValueError("No proxy was set!")
141144
self.proxy_headers = proxy_headers
142145

143146
#: The size of the in-memory buffer used to store data from the
@@ -169,22 +172,48 @@ def connect(self):
169172
connect_timeout = self._timeout
170173
read_timeout = self._timeout
171174

172-
if self.proxy_host and self.secure:
173-
# Send http CONNECT method to a proxy and acquire the socket
174-
sock = _create_tunnel(
175-
self.proxy_host,
176-
self.proxy_port,
177-
self.host,
178-
self.port,
179-
proxy_headers=self.proxy_headers,
180-
timeout=self._timeout
181-
)
182-
elif self.proxy_host:
183-
# Simple http proxy
184-
sock = socket.create_connection(
185-
(self.proxy_host, self.proxy_port),
186-
timeout=connect_timeout
187-
)
175+
if self.proxy_host:
176+
if self.proxy_type.startswith("socks"):
177+
import socks
178+
rdns = (self.proxy_type[-1]=="h")
179+
# any error will result in silently connecting without a proxy.
180+
# IDK why it is done this way
181+
if not rdns:
182+
raise ValueError("RDNS is disabled. Proxying dns queries is disabled. NSA is spying you.")
183+
if rdns and self.proxy_type.startswith("socks4"):
184+
raise ValueError("RDNS is not supported for socks4. socks.create_connection ignores it silently.")
185+
if not isinstance(self.proxy_host, str):
186+
raise ValueError("self.proxy_host", repr(self.proxy_host), "is not str")
187+
if not isinstance(self.proxy_port, int):
188+
raise ValueError("self.proxy_port", repr(self.proxy_port), "is not int")
189+
socks_version_char = self.proxy_type[5]
190+
sock = socks.create_connection(
191+
(self.host, self.port),
192+
proxy_type=getattr(socks, "PROXY_TYPE_SOCKS" + socks_version_char),
193+
proxy_addr=self.proxy_host,
194+
proxy_port=self.proxy_port,
195+
#proxy_username=username,
196+
#proxy_password=password,
197+
proxy_rdns=rdns,
198+
)
199+
elif self.proxy_host and self.secure:
200+
# Send http CONNECT method to a proxy and acquire the socket
201+
sock = _create_tunnel(
202+
self.proxy_host,
203+
self.proxy_port,
204+
self.host,
205+
self.port,
206+
proxy_headers=self.proxy_headers,
207+
timeout=self._timeout
208+
)
209+
elif self.proxy_host:
210+
# Simple http proxy
211+
sock = socket.create_connection(
212+
(self.proxy_host, self.proxy_port),
213+
timeout=connect_timeout
214+
)
215+
else:
216+
raise Exception("Unsupported proxy type: "+repr(proxy_type))
188217
else:
189218
sock = socket.create_connection((self.host, self.port),
190219
timeout=connect_timeout)
@@ -454,6 +483,7 @@ def _send_file_like_obj(self, fobj):
454483

455484
return
456485

486+
457487
def close(self):
458488
"""
459489
Closes the connection. This closes the socket and then abandons the

‎hyper/http20/connection.py‎

Lines changed: 49 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -101,7 +101,7 @@ class HTTP20Connection(object):
101101

102102
def __init__(self, host, port=None, secure=None, window_manager=None,
103103
enable_push=False, ssl_context=None, proxy_host=None,
104-
proxy_port=None, force_proto=None, proxy_headers=None,
104+
proxy_port=None, proxy_type=None, force_proto=None, proxy_headers=None,
105105
timeout=None, **kwargs):
106106
"""
107107
Creates an HTTP/2 connection to a specific server.
@@ -126,11 +126,13 @@ def __init__(self, host, port=None, secure=None, window_manager=None,
126126
self.proxy_host, self.proxy_port = to_host_port_tuple(
127127
proxy_host, default_port=8080
128128
)
129+
self.proxy_type = proxy_type
129130
elif proxy_host:
130-
self.proxy_host, self.proxy_port = proxy_host, proxy_port
131+
self.proxy_host, self.proxy_port, self.proxy_type = proxy_host, proxy_port, proxy_type
131132
else:
132133
self.proxy_host = None
133134
self.proxy_port = None
135+
self.proxy_type = None
134136
self.proxy_headers = proxy_headers
135137

136138
#: The size of the in-memory buffer used to store data from the
@@ -353,22 +355,49 @@ def connect(self):
353355
connect_timeout = self._timeout
354356
read_timeout = self._timeout
355357

356-
if self.proxy_host and self.secure:
357-
# Send http CONNECT method to a proxy and acquire the socket
358-
sock = _create_tunnel(
359-
self.proxy_host,
360-
self.proxy_port,
361-
self.host,
362-
self.port,
363-
proxy_headers=self.proxy_headers,
364-
timeout=self._timeout
365-
)
366-
elif self.proxy_host:
367-
# Simple http proxy
368-
sock = socket.create_connection(
369-
(self.proxy_host, self.proxy_port),
370-
timeout=connect_timeout
371-
)
358+
if self.proxy_host:
359+
if self.proxy_type.startswith("socks"):
360+
import socks
361+
rdns = (self.proxy_type[-1]=="h")
362+
# any error will result in silently connecting without a proxy.
363+
# IDK why it is done this way.
364+
if not rdns:
365+
raise ValueError("RDNS is disabled. Proxying dns queries is disabled. NSA is spying you.")
366+
if rdns and self.proxy_type.startswith("socks4"):
367+
raise ValueError("RDNS is not supported for socks4. socks.create_connection ignores it silently.")
368+
if not isinstance(self.proxy_host, str):
369+
raise ValueError("self.proxy_host", repr(self.proxy_host), "is not str")
370+
if not isinstance(self.proxy_port, int):
371+
raise ValueError("self.proxy_port", repr(self.proxy_port), "is not int")
372+
socks_version_char = self.proxy_type[5]
373+
sock = socks.create_connection(
374+
(self.host, self.port),
375+
proxy_type=getattr(socks, "PROXY_TYPE_SOCKS" + socks_version_char),
376+
proxy_addr=self.proxy_host,
377+
proxy_port=self.proxy_port,
378+
#proxy_username=username,
379+
#proxy_password=password,
380+
proxy_rdns=rdns,
381+
)
382+
#sock.getsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
383+
elif self.proxy_host and self.secure:
384+
# Send http CONNECT method to a proxy and acquire the socket
385+
sock = _create_tunnel(
386+
self.proxy_host,
387+
self.proxy_port,
388+
self.host,
389+
self.port,
390+
proxy_headers=self.proxy_headers,
391+
timeout=self._timeout
392+
)
393+
elif self.proxy_host:
394+
# Simple http proxy
395+
sock = socket.create_connection(
396+
(self.proxy_host, self.proxy_port),
397+
timeout=connect_timeout
398+
)
399+
else:
400+
raise Exception("Unsupported proxy type: "+repr(proxy_type))
372401
else:
373402
sock = socket.create_connection((self.host, self.port),
374403
timeout=connect_timeout)
@@ -403,7 +432,7 @@ def _connect_upgrade(self, sock):
403432
with self._conn as conn:
404433
conn.initiate_upgrade_connection()
405434
conn.update_settings(
406-
{h2.settings.ENABLE_PUSH: int(self._enable_push)}
435+
{h2.settings.SettingCodes.ENABLE_PUSH: int(self._enable_push)}
407436
)
408437
self._send_outstanding_data()
409438

@@ -424,7 +453,7 @@ def _send_preamble(self):
424453
with self._conn as conn:
425454
conn.initiate_connection()
426455
conn.update_settings(
427-
{h2.settings.ENABLE_PUSH: int(self._enable_push)}
456+
{h2.settings.SettingCodes.ENABLE_PUSH: int(self._enable_push)}
428457
)
429458
self._send_outstanding_data()
430459

0 commit comments

Comments
 (0)