def handle(self, conn):
""" handle is called by the framework to establish a new connection to the proxy server and start processing when an incoming SOCKS client connection is established. """
logging.info('handle_socks')
yield readHandshake(conn)
logging.error('read handshake')
yield sendHandshake(conn)
logging.error('send handshake')
dest = (yield readRequest(conn))
# logging.error('read request: %s' % str(dest))
yield sendResponse(dest, conn)
logging.error('sent response')
(addr, port) = uncompact(dest)
logging.error('connecting %s:%d' % (addr, port))
logging.info(addr)
logging.info(port)
client = Client()
yield client.connect(addr, port)
logging.info('connected %s:%d' % (addr, port))
self.pump = Pump(conn, client, self.transport)
yield self.pump.run()
def handle_socksDust(conn):
print('connection')
client = Client()
yield client.connect('blanu.net', 7051)
coder = yield handshake(client)
monocle.launch(pump, conn, client, coder.encrypt)
yield pump(client, conn, coder.decrypt)
def handle_dust(conn):
print('handle_dust')
coder = yield handshake(conn)
client = Client()
yield client.connect('localhost', 9050)
monocle.launch(pump, conn, client, coder.decrypt)
yield pump(client, conn, coder.encrypt)
def _subproc_wrapper(port, target, *args, **kwargs):
try:
client = Client()
while True:
try:
yield client.connect('127.0.0.1', port)
break
except Exception, e:
print "failed to connect to monocle multiprocess parent on port", port, type(
e), str(e)
yield sleep(1)
chan = SocketChannel(client)
yield target(chan, *args, **kwargs)
def do_echos():
try:
client = Client()
yield client.connect('localhost', 8000)
t = time.time()
for x in xrange(10000):
msg = "hello, world #%s!" % x
yield client.write(msg + '\r\n')
echo_result = yield client.read_until("\r\n")
assert echo_result.strip() == "you said: %s" % msg
print('10000 loops in %.2fs' % (time.time() - t))
finally:
client.close()
def test_lots_of_messages():
add_service(Service(handle_echo, port=8000))
try:
client = Client()
yield client.connect('localhost', 8000)
t = time.time()
for x in xrange(10000):
msg = "hello, world #%s!" % x
yield client.write(msg + '\r\n')
echo_result = yield client.read_until("\r\n")
assert echo_result.strip() == "you said: %s" % msg
print '10000 loops in %.2fs' % (time.time() - t)
finally:
client.close()
def handle_socks(conn):
yield readHandshake(conn)
yield sendHandshake(conn)
dest = yield readRequest(conn)
yield sendResponse(dest, conn)
addr, port = uncompact(dest)
print(addr)
print(port)
client = Client()
yield client.connect(addr, port)
yield handle_socksDust(conn, client)
def handle_socks(conn):
print('connection')
yield readHandshake(conn)
yield sendHandshake(conn)
dest=yield readRequest(conn)
yield sendResponse(dest, conn)
addr, port=uncompact(dest)
print(addr)
print(port)
client = Client()
yield client.connect(addr, port)
monocle.launch(pump, conn, client)
yield pump(client, conn)
def main():
c = Client()
"""
yield c.connect('google.com', 80)
yield c.write("GET / HTTP/1.0\r\n\r\n")
x = None
c.timeout = 0
try:
x = yield c.read(40000)
except Exception, e:
print str(e)
print x
"""
c.timeout = 1
yield c.connect('google.com', 80)
c.timeout = 0
x = yield c.read(40000)
print x
def connect(self, host, port, scheme='http', timeout=None):
if timeout is not None:
# this parameter is deprecated
self.timeout = None
if self.client and not self.client.is_closed():
self.client.close()
if scheme == 'http':
self.client = Client()
elif scheme == 'https':
self.client = SSLClient()
else:
raise HttpException('unsupported url scheme %s' % scheme)
self.scheme = scheme
self.host = host
self.port = port
self.client.timeout = self._timeout
yield self.client.connect(self.host, self.port)
def handle(self, conn):
""" handle is called by the framework to establish a new proxy connection to the Tor server and start processing when an incoming client connection is established. """
logging.error('connection')
logging.error('connecting %s:%d' % (self.addr, self.port))
client = Client()
try:
yield client.connect(self.addr, self.port)
except Exception as e:
logging.error('Error connecting to destination')
return
try:
self.pump = Pump(conn, client, self.transport)
yield self.pump.run()
except Exception as e:
logging.error('Exception pumping')
logging.error(e)
def handle_socks(conn):
print('handle_socks')
yield readHandshake(conn)
print('read handshake')
yield sendHandshake(conn)
print('send handshake')
dest = yield readRequest(conn)
print('read request: ' + str(dest))
yield sendResponse(dest, conn)
print('sent response')
addr, port = uncompact(dest)
print(addr)
print(port)
client = Client()
yield client.connect(addr, port)
print('connected ' + str(addr) + ', ' + str(port))
monocle.launch(pump, conn, client, None)
yield pump(client, conn, None)
def handle_socks(conn):
client = Client()
yield client.connect('localhost', 8050)
monocle.launch(pump, conn, client)
yield pump(client, conn)
