def connect(host, port, path='/'):
try:
try:
ws = WebSocketClient("ws://{}:{}{}".format(host, port, path))
ws.connect()
def outgoing():
fcntl.fcntl(sys.stdin, fcntl.F_SETFL, os.O_NONBLOCK)
while True:
wait_read(sys.stdin.fileno())
line = sys.stdin.readline()
ws.send(line.strip())
def incoming():
while True:
print ws.receive()
gevent.joinall([
gevent.spawn(outgoing),
gevent.spawn(incoming),
])
except (IOError, HandshakeError), e:
print e
sys.exit(1)
except KeyboardInterrupt:
ws.close()
def test_secure_websocket_connection(self):
ws = WebSocketClient('wss://127.0.0.1:5443/ws')
ws.connect()
print("Sending: 'Hello, World'...")
ws.send("Hello, World")
print("Sent")
print("Receiving...")
result = ws.receive()
print("Received: {}".format(result))
ws.close()
self.assertEqual("Hello, World", str(result))
def publish(self, data, parsed_data):
payload = parsed_data
parsed = json.dumps(payload)
evald = payload
try:
ws = WebSocketClient(socket_config['baseUrl'] +
str(evald['pipelineId']),
protocols=['http-only', 'chat'])
ws.connect()
ws.send(str(parsed))
ws.close()
return True
except Exception as e:
print e
return False
def connect(host, port, path='/'):
try:
try:
ws = WebSocketClient("ws://{}:{}{}".format(
host, port, path))
ws.connect()
def outgoing():
fcntl.fcntl(sys.stdin, fcntl.F_SETFL, os.O_NONBLOCK)
while True:
wait_read(sys.stdin.fileno())
line = sys.stdin.readline()
ws.send(line.strip())
def incoming():
while True:
print ws.receive()
gevent.joinall([
gevent.spawn(outgoing),
gevent.spawn(incoming),
])
except (IOError, HandshakeError), e:
print e
sys.exit(1)
except KeyboardInterrupt:
ws.close()
class WebSocketTransport(object):
def __init__(self):
self.__connected = False
self.__pool = Pool(1)
self.__on_messsage = None
self.__connection = None
def set_on_message(self, func):
def wrapper():
while True:
m = self.__connection.receive()
if m is not None:
func(m.data)
else:
break
self.__on_message = wrapper
#TODO: Flag to make sure only one connection
def connect(self, url):
if self.__connected == True:
raise RuntimeError("Connect twice")
self.__connection = WebSocketClient(url)
self.__connection.connect()
#self.__connected = True
if self.__on_message is not None:
self.__pool.spawn(self.__on_message)
self.__connected == True
def send(self, msg, is_binary=False):
self.__connection.send(msg, is_binary)
def close(self):
self.__pool.join(timeout=0)
self.__connection.close()
self.__connected = False
ws.close()
break
else:
break
print("Connection closed!")
def outgoing(ws):
for i in range(0, 40, 5):
ws.send("*" * i)
# We won't get this back
ws.send("Foobar")
if __name__ == '__main__':
ws = WebSocketClient('ws://127.0.0.1:8080/websocket', protocols=['http-only', 'chat'])
ws.connect()
for n in range(50):
msg = json.dumps(dict(msg="Hello world", no=n))
ws.send(msg)
resp = str(ws.receive())
print json.loads(resp)
ws.close()
# greenlets = [
# gevent.spawn(incoming, ws),
# gevent.spawn(outgoing, ws),
# ]
# gevent.joinall(greenlets)
def handle(self, source, address):
'''
1. parse browser socks5 message
2. establishes WebSocket connection to a remote server
3. encrypt data using RC4
4. forward with both the local and remote server
'''
log('New connection from %s:%s' % address)
log('greenlet is %r', gevent.getcurrent())
rfile = source.makefile('rb', -1)
try:
recvcount = source.recv(262)
log("recv count: %r: %r " % (recvcount, type(recvcount)))
source.send(b'\x05\x00')
wsdata = ''
data = rfile.read(4)
log('second pack %r: %r' % (type(data), data))
cmd = ord(data[1]) # CMD
addrtype = ord(data[3]) # ADDR type 0x01 Ipv4 address
wsdata = data[3] # append type of address
if addrtype == 1: # IPv4
addrStr = rfile.read(4)
addr = socket.inet_ntoa(addrStr)
wsdata += addrStr
elif addrtype == 3: # Domain name
domainlen = ord(rfile.read(1)[0])
domain = rfile.read(domainlen)
log('domain len and name: %d %s' % (domainlen, domain))
# addr = handle_dns(domain)
addr = socket.inet_ntoa('\x00\x00\x00\x00') # 16777343
wsdata += chr(domainlen)
wsdata += domain
portstr = rfile.read(2)
port = struct.unpack('>H', portstr)
wsdata += portstr # append port
if cmd == 1:
reply = b"\x05\x00\x00\x01" + socket.inet_aton(
addr) + struct.pack(">H", port[0])
log("send replay %r" % reply)
source.send(reply)
log('Begin data, %s:%s' % (addr, port[0]))
ws = WebSocketClient(self.remotehost, protocols=['binary'])
try:
# gevent.monkey 阻塞
ws.connect()
log("connect remote websocket server!")
log('send data %r:%r:%r' %
(wsdata, type(wsdata), len(wsdata)))
encryptor = RC4(self.key)
generator = encryptor.encrypter()
out = ''
for wc in wsdata:
out += chr((ord(wc) ^ generator.next()))
# send socks5 message
ws.send(out, True)
l1 = gevent.spawn(self.forward, source, ws, generator)
l2 = gevent.spawn(self.incoming, ws, source)
gevent.joinall([l1, l2])
except socket.error as e:
log('Conn refused, %s:%s:%s' % (addr, port[0], e.message))
# Connection refused
reply = b'\x05\x05\x00\x01\x00\x00\x00\x00\x00\x00'
source.send(reply)
raise e
finally:
log('close websocket: ---------------------------')
ws.close()
else:
log('Unsupported cmd: %r' % cmd)
reply = b"\x05\0x07\0x00\0x01"
source.send(reply)
except socket.error, (value, message):
log('socks_handle socket error, %s' % (message))
