def __init__(self, client, proxy_infos):
assert(proxy_infos.type in ('http', 'https')), "HTTPConnectProxy expects an http(s) proxy description"
assert(client.domain == AF_INET), "HTTP CONNECT only handles INET address family"
assert(client.type == SOCK_STREAM), "HTTP CONNECT only handles SOCK_STREAM"
assert(client.status == IoStatus.CLOSED), "HTTPConnectProxy expects a closed client"
AbstractProxy.__init__(self, client, proxy_infos)
self._transport = TCPClient(self._proxy.host, self._proxy.port)
self._transport.connect("notify::status", self._on_transport_status)
self._transport.connect("error", self._on_transport_error)
self._http_parser = HTTPParser(self._transport)
self._http_parser.connect("received", self._on_proxy_response)
def _post_open(self):
AbstractProxy._post_open(self)
proxy_protocol = 'CONNECT %s:%s HTTP/1.1\r\n' % (self.host, self.port)
proxy_protocol += 'Proxy-Connection: Keep-Alive\r\n'
proxy_protocol += 'Pragma: no-cache\r\n'
proxy_protocol += 'User-Agent: %s/%s\r\n' % (GNet.NAME, GNet.VERSION)
if self._proxy.user:
auth = base64.encodestring(self._proxy.user + ':' + self._proxy.password).strip()
proxy_protocol += 'Proxy-authorization: Basic ' + auth + '\r\n'
proxy_protocol += '\r\n'
self._http_parser.enable()
self._transport.send(proxy_protocol)
def _post_open(self):
AbstractProxy._post_open(self)
proxy_protocol = 'CONNECT %s:%s HTTP/1.1\r\n' % (self.host, self.port)
proxy_protocol += 'Proxy-Connection: Keep-Alive\r\n'
proxy_protocol += 'Pragma: no-cache\r\n'
proxy_protocol += 'User-Agent: %s/%s\r\n' % (GNet.NAME, GNet.VERSION)
if self._proxy.user:
auth = base64.encodestring(self._proxy.user + ':' +
self._proxy.password).strip()
proxy_protocol += 'Proxy-authorization: Basic ' + auth + '\r\n'
proxy_protocol += '\r\n'
self._http_parser.enable()
self._transport.send(proxy_protocol)
def _post_open(self):
AbstractProxy._post_open(self)
user = self._proxy.user
proxy_protocol = struct.pack('!BBH', SOCKS4Proxy.PROTOCOL_VERSION,
SOCKS4Proxy.CONNECT_COMMAND, self.port)
for part in self.host.split('.'):
proxy_protocol += struct.pack('B', int(part))
proxy_protocol += user
proxy_protocol += struct.pack('B', 0)
self._delimiter_parser.enable()
self._transport.send(proxy_protocol)
def _post_open(self):
AbstractProxy._post_open(self)
host = self._client.get_property("host")
port = self._client.get_property("port")
user = self._proxy.user
proxy_protocol = struct.pack('!BBH', SOCKS4Proxy.PROTOCOL_VERSION,
SOCKS4Proxy.CONNECT_COMMAND, port)
for part in host.split('.'):
proxy_protocol += struct.pack('B', int(part))
proxy_protocol += user
proxy_protocol += struct.pack('B', 0)
self._transport.send(proxy_protocol)
def _post_open(self):
AbstractProxy._post_open(self)
host = self._client.get_property("host")
port = self._client.get_property("port")
user = self._proxy.user
proxy_protocol = struct.pack('!BBH', SOCKS4Proxy.PROTOCOL_VERSION,
SOCKS4Proxy.CONNECT_COMMAND, port)
for part in host.split('.'):
proxy_protocol += struct.pack('B', int(part))
proxy_protocol += user
proxy_protocol += struct.pack('B', 0)
self._transport.send(proxy_protocol)
def __init__(self, client, proxy_infos):
assert (proxy_infos.type in (
'http',
'https')), "HTTPConnectProxy expects an http(s) proxy description"
assert (client.domain == AF_INET
), "HTTP CONNECT only handles INET address family"
assert (client.type == SOCK_STREAM
), "HTTP CONNECT only handles SOCK_STREAM"
assert (client.status == IoStatus.CLOSED
), "HTTPConnectProxy expects a closed client"
AbstractProxy.__init__(self, client, proxy_infos)
self._transport = TCPClient(self._proxy.host, self._proxy.port)
self._transport.connect("notify::status", self._on_transport_status)
self._transport.connect("error", self._on_transport_error)
self._http_parser = HTTPParser(self._transport)
self._http_parser.connect("received", self._on_proxy_response)
def __init__(self, client, proxy_infos):
assert(proxy_infos.type == 'socks4'), \
"SOCKS4Proxy expects a socks4 proxy description"
# TODO : implement version 4a of the protocol to allow proxy-side name resolution
assert(client.domain == AF_INET), \
"SOCKS4 CONNECT only handles INET address family"
assert(client.type == SOCK_STREAM), \
"SOCKS4 CONNECT only handles SOCK_STREAM"
assert(client.status == IoStatus.CLOSED), \
"SOCKS4Proxy expects a closed client"
AbstractProxy.__init__(self, client, proxy_infos)
self._transport = TCPClient(self._proxy.host, self._proxy.port)
self._transport.connect("notify::status", self._on_transport_status)
self._transport.connect("error", self._on_transport_error)
self._delimiter_parser = DelimiterParser(self._transport)
self._delimiter_parser.delimiter = 8
self._delimiter_parser.connect("received", self._on_proxy_response)
def __init__(self, client, proxy):
assert(proxy.type in ('socks', 'socks5')), \
"SOCKS5Proxy expects a socks5 proxy description"
assert(client.domain == AF_INET), \
"SOCKS5 CONNECT only handles INET address family"
assert(client.type == SOCK_STREAM), \
"SOCKS5 CONNECT only handles SOCK_STREAM"
assert(client.status == IoStatus.CLOSED), \
"SOCKS5Proxy expects a closed client"
AbstractProxy.__init__(self, client, proxy)
self._transport = TCPClient(self._proxy.host, self._proxy.port)
self._transport.connect("notify::status", self._on_transport_status)
self._transport.connect("error", self._on_transport_error)
self._delimiter_parser = DelimiterParser(self._transport)
self._delimiter_parser.connect("received", self._on_proxy_response)
self._state = None
self._must_auth = False
def _pre_open(self, io_object=None):
AbstractProxy._pre_open(self)
def _post_open(self):
AbstractProxy._post_open(self)
self._delimiter_parser.enable()
self._send_nego_msg()
