def open_proxy_backend(backend, target, name, client, use_ssl=False, ssl_opts=None): proxy = eventlet.connect(backend) if use_ssl: ssl_opts = ssl_opts or {} proxy = eventlet.wrap_ssl(proxy, server_side=False, **ssl_opts) proxy.sendall(protocol.version) protocol.send_message(proxy, protocol.proxy_request( name=name, client=client, )) reply = protocol.recv_message(proxy) if reply and 'proxy' in reply: try: local = eventlet.connect(target) util.join_sockets(proxy, local) except IOError: proxy.close() elif reply and 'error' in reply: print " ERROR: {0}".format(reply['error']) return else: pass
def test_two_servers(self): def test_app(env, start_response): start_response('200 OK', {}) return ['PONG'] fake_ssl_server = nova.wsgi.Server("fake_ssl", test_app, host="127.0.0.1", port=0, use_ssl=True) fake_ssl_server.start() self.assertNotEqual(0, fake_ssl_server.port) fake_server = nova.wsgi.Server("fake", test_app, host="127.0.0.1", port=0) fake_server.start() self.assertNotEqual(0, fake_server.port) cli = eventlet.connect(("localhost", fake_ssl_server.port)) cli = eventlet.wrap_ssl(cli, ca_certs=os.path.join(SSL_CERT_DIR, 'ca.crt')) cli.write('POST / HTTP/1.1\r\nHost: localhost\r\n' 'Connection: close\r\nContent-length:4\r\n\r\nPING') response = cli.read(8192) self.assertEqual(response[-4:], "PONG") cli = eventlet.connect(("localhost", fake_server.port)) cli.sendall('POST / HTTP/1.1\r\nHost: localhost\r\n' 'Connection: close\r\nContent-length:4\r\n\r\nPING') response = cli.recv(8192) self.assertEqual(response[-4:], "PONG") fake_ssl_server.stop() fake_ssl_server.wait()
def close(self): if self.accepting: self.accepting = False try: connect(self.getsockname()) except: pass super(_socket, self).close()
def test_large_frame_size_compressed_13(self): # Test fix for GHSA-9p9m-jm8w-94p2 extensions_string = 'permessage-deflate' extensions = { 'permessage-deflate': { 'client_no_context_takeover': False, 'server_no_context_takeover': False } } sock = eventlet.connect(self.server_addr) sock.sendall(six.b(self.connect % extensions_string)) sock.recv(1024) ws = websocket.RFC6455WebSocket(sock, {}, client=True, extensions=extensions) should_still_fit = b"x" * TEST_MAX_FRAME_LENGTH one_too_much = should_still_fit + b"x" # send just fitting frame twice to make sure they are fine independently ws.send(should_still_fit) assert ws.wait() == should_still_fit ws.send(should_still_fit) assert ws.wait() == should_still_fit ws.send(one_too_much) res = ws.wait() assert res is None # socket closed # TODO: The websocket currently sents compressed control frames, which contradicts RFC7692. # Renable the following assert after that has been fixed. # assert ws._remote_close_data == b"\x03\xf1Incoming compressed frame is above length limit." eventlet.sleep(0.01)
def test_accept_deflate_ext_window_max_bits_13(self): for extension_string, vals in [ ('permessage-deflate; client_max_window_bits', [15]), ('permessage-deflate; Server_Max_Window_Bits = 11', [11]), ('permessage-deflate; server_max_window_bits; ' 'client_max_window_bits=9', [15, 9]) ]: sock = eventlet.connect(self.server_addr) sock.sendall(six.b(self.connect % extension_string)) result = sock.recv(1024) # The server responds the correct Websocket handshake # print('Extension offer: %r' % extension_string) match = re.match(self.handshake_re, result) assert match is not None assert len(match.groups()) == 1 offered_parts = [ part.strip().lower() for part in extension_string.split(';') ] offered_parts_names = [ part.split('=')[0].strip() for part in offered_parts ] offered_parts_dict = dict(zip(offered_parts_names[1:], vals)) accepted_ext_parts = match.groups()[0].decode().split('; ') assert accepted_ext_parts[0] == 'permessage-deflate' for param, val in (part.split('=') for part in accepted_ext_parts[1:]): assert int(val) == offered_parts_dict[param]
def test_server_compress_no_context_takeover_13(self): extensions_string = 'permessage-deflate; server_no_context_takeover;' extensions = { 'permessage-deflate': { 'client_no_context_takeover': False, 'server_no_context_takeover': True } } sock = eventlet.connect(self.server_addr) sock.sendall(six.b(self.connect % extensions_string)) sock.recv(1024) ws = websocket.RFC6455WebSocket(sock, {}, client=True, extensions=extensions) masked_msg1 = ws._pack_message(b'Hello', masked=True) ws._send(masked_msg1) masked_msg2 = ws._pack_message(b'Hello', masked=True) ws._send(masked_msg2) # Verify that client uses context takeover by checking # that the second message assert len(masked_msg2) < len(masked_msg1) # Verify that server drops context between messages # Deflated values taken from Section 7.2.3 of RFC 7692 # https://tools.ietf.org/html/rfc7692#section-7.2.3 reply_msg1 = self.get_deflated_reply(ws) assert reply_msg1 == b'\xf2\x48\xcd\xc9\xc9\x07\x00' reply_msg2 = self.get_deflated_reply(ws) assert reply_msg2 == b'\xf2\x48\xcd\xc9\xc9\x07\x00'
def test_empty_query_string(self): # verify that a single trailing ? doesn't get nuked connect = [ "GET /echo? HTTP/1.1", "Upgrade: WebSocket", "Connection: Upgrade", "Host: localhost:%s" % self.port, "Origin: http://localhost:%s" % self.port, "Sec-WebSocket-Protocol: ws", "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5", "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00", ] sock = eventlet.connect( ('localhost', self.port)) sock.sendall(six.b('\r\n'.join(connect) + '\r\n\r\n^n:ds[4U')) result = sock.recv(1024) self.assertEqual(result, '\r\n'.join([ 'HTTP/1.1 101 WebSocket Protocol Handshake', 'Upgrade: WebSocket', 'Connection: Upgrade', 'Sec-WebSocket-Origin: http://localhost:%s' % self.port, 'Sec-WebSocket-Protocol: ws', 'Sec-WebSocket-Location: ws://localhost:%s/echo?\r\n\r\n8jKS\'y:G*Co,Wxa-' % self.port, ]))
def test_connect_ssl(self): def accept_once(listenfd): try: conn, addr = listenfd.accept() conn.write(b'hello\r\n') greenio.shutdown_safe(conn) conn.close() finally: greenio.shutdown_safe(listenfd) listenfd.close() server = api.ssl_listener(('0.0.0.0', 0), self.certificate_file, self.private_key_file) api.spawn(accept_once, server) raw_client = eventlet.connect(('127.0.0.1', server.getsockname()[1])) client = util.wrap_ssl(raw_client) fd = socket._fileobject(client, 'rb', 8192) assert fd.readline() == b'hello\r\n' try: self.assertEqual(b'', fd.read(10)) except greenio.SSL.ZeroReturnError: # if it's a GreenSSL object it'll do this pass greenio.shutdown_safe(client) client.close() check_hub()
def test_wrapped_wsgi(self): site = self.site def wrapper(environ, start_response): for chunk in site(environ, start_response): yield chunk self.site = wrapper self.spawn_server() connect = [ "GET /range HTTP/1.1", "Upgrade: WebSocket", "Connection: Upgrade", "Host: %s:%s" % self.server_addr, "Origin: http://%s:%s" % self.server_addr, "WebSocket-Protocol: ws", ] sock = eventlet.connect(self.server_addr) sock.sendall(six.b('\r\n'.join(connect) + '\r\n\r\n')) resp = sock.recv(1024) headers, result = resp.split(b'\r\n\r\n') msgs = [result.strip(b'\x00\xff')] cnt = 9 while cnt: msgs.append(sock.recv(20).strip(b'\x00\xff')) cnt -= 1 self.assertEqual(msgs, [six.b('msg %d' % i) for i in range(10)]) # In case of server error, server will write HTTP 500 response to the socket msg = sock.recv(20) assert not msg sock.close() eventlet.sleep(0.01)
def test_partial_write_295(): # https://github.com/eventlet/eventlet/issues/295 # `socket.makefile('w').writelines()` must send all # despite partial writes by underlying socket listen_socket = eventlet.listen(('localhost', 0)) original_accept = listen_socket.accept def talk(conn): f = conn.makefile('wb') line = b'*' * 2140 f.writelines([line] * 10000) conn.close() def accept(): connection, address = original_accept() original_send = connection.send def slow_send(b, *args): b = b[:1031] return original_send(b, *args) connection.send = slow_send eventlet.spawn(talk, connection) return connection, address listen_socket.accept = accept eventlet.spawn(listen_socket.accept) sock = eventlet.connect(listen_socket.getsockname()) with eventlet.Timeout(10): bs = sock.makefile('rb').read() assert len(bs) == 21400000 assert bs == (b'*' * 21400000)
def test_sending_messages_to_websocket_76(self): connect = [ "GET /echo HTTP/1.1", "Upgrade: WebSocket", "Connection: Upgrade", "Host: %s:%s" % self.server_addr, "Origin: http://%s:%s" % self.server_addr, "Sec-WebSocket-Protocol: ws", "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5", "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00", ] sock = eventlet.connect(self.server_addr) sock.sendall(six.b("\r\n".join(connect) + "\r\n\r\n^n:ds[4U")) sock.recv(1024) sock.sendall(b"\x00hello\xFF") result = sock.recv(1024) self.assertEqual(result, b"\x00hello\xff") sock.sendall(b"\x00start") eventlet.sleep(0.001) sock.sendall(b" end\xff") result = sock.recv(1024) self.assertEqual(result, b"\x00start end\xff") sock.shutdown(socket.SHUT_RDWR) sock.close() eventlet.sleep(0.01)
def test_breaking_the_connection_76(self): error_detected = [False] done_with_request = event.Event() site = self.site def error_detector(environ, start_response): try: try: return site(environ, start_response) except: error_detected[0] = True raise finally: done_with_request.send(True) self.site = error_detector self.spawn_server() connect = [ "GET /range HTTP/1.1", "Upgrade: WebSocket", "Connection: Upgrade", "Host: %s:%s" % self.server_addr, "Origin: http://%s:%s" % self.server_addr, "Sec-WebSocket-Protocol: ws", "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5", "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00", ] sock = eventlet.connect(self.server_addr) sock.sendall(six.b("\r\n".join(connect) + "\r\n\r\n^n:ds[4U")) sock.recv(1024) # get the headers sock.close() # close while the app is running done_with_request.wait() assert not error_detected[0]
def test_correct_upgrade_request_76(self): connect = [ "GET /echo HTTP/1.1", "Upgrade: WebSocket", "Connection: Upgrade", "Host: %s:%s" % self.server_addr, "Origin: http://%s:%s" % self.server_addr, "Sec-WebSocket-Protocol: ws", "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5", "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00", ] sock = eventlet.connect(self.server_addr) sock.sendall(six.b("\r\n".join(connect) + "\r\n\r\n^n:ds[4U")) result = sock.recv(1024) # The server responds the correct Websocket handshake self.assertEqual( result, six.b( "\r\n".join( [ "HTTP/1.1 101 WebSocket Protocol Handshake", "Upgrade: WebSocket", "Connection: Upgrade", "Sec-WebSocket-Origin: http://%s:%s" % self.server_addr, "Sec-WebSocket-Protocol: ws", "Sec-WebSocket-Location: ws://%s:%s/echo\r\n\r\n8jKS'y:G*Co,Wxa-" % self.server_addr, ] ) ), )
def test_empty_query_string(self): # verify that a single trailing ? doesn't get nuked connect = [ "GET /echo? HTTP/1.1", "Upgrade: WebSocket", "Connection: Upgrade", "Host: %s:%s" % self.server_addr, "Origin: http://%s:%s" % self.server_addr, "Sec-WebSocket-Protocol: ws", "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5", "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00", ] sock = eventlet.connect(self.server_addr) sock.sendall(six.b("\r\n".join(connect) + "\r\n\r\n^n:ds[4U")) result = sock.recv(1024) self.assertEqual( result, six.b( "\r\n".join( [ "HTTP/1.1 101 WebSocket Protocol Handshake", "Upgrade: WebSocket", "Connection: Upgrade", "Sec-WebSocket-Origin: http://%s:%s" % self.server_addr, "Sec-WebSocket-Protocol: ws", "Sec-WebSocket-Location: ws://%s:%s/echo?\r\n\r\n8jKS'y:G*Co,Wxa-" % self.server_addr, ] ) ), )
def _handle(client): server = eventlet.connect((client.environ['vnc_host'], client.environ['vnc_port'])) t1 = eventlet.spawn(self.ws2sock, client, server) t2 = eventlet.spawn(self.sock2ws, server, client) t1.wait() t2.wait()
def test_client_closing_connection_76(self): error_detected = [False] done_with_request = event.Event() site = self.site def error_detector(environ, start_response): try: try: return site(environ, start_response) except: error_detected[0] = True raise finally: done_with_request.send(True) self.site = error_detector self.spawn_server() connect = [ "GET /echo HTTP/1.1", "Upgrade: WebSocket", "Connection: Upgrade", "Host: localhost:%s" % self.port, "Origin: http://localhost:%s" % self.port, "Sec-WebSocket-Protocol: ws", "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5", "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00", ] sock = eventlet.connect( ('localhost', self.port)) sock.sendall('\r\n'.join(connect) + '\r\n\r\n^n:ds[4U') resp = sock.recv(1024) # get the headers sock.sendall('\xff\x00') # "Close the connection" packet. done_with_request.wait() self.assert_(not error_detected[0])
def test_sending_messages_to_websocket_75(self): connect = [ "GET /echo HTTP/1.1", "Upgrade: WebSocket", "Connection: Upgrade", "Host: localhost:%s" % self.port, "Origin: http://localhost:%s" % self.port, "WebSocket-Protocol: ws", ] sock = eventlet.connect( ('localhost', self.port)) sock.sendall('\r\n'.join(connect) + '\r\n\r\n') first_resp = sock.recv(1024) sock.sendall('\x00hello\xFF') result = sock.recv(1024) self.assertEqual(result, '\x00hello\xff') sock.sendall('\x00start') eventlet.sleep(0.001) sock.sendall(' end\xff') result = sock.recv(1024) self.assertEqual(result, '\x00start end\xff') sock.shutdown(socket.SHUT_RDWR) sock.close() eventlet.sleep(0.01)
def test_query_string(self): # verify that the query string comes out the other side unscathed connect = [ "GET /echo?query_string HTTP/1.1", "Upgrade: WebSocket", "Connection: Upgrade", "Host: %s:%s" % self.server_addr, "Origin: http://%s:%s" % self.server_addr, "Sec-WebSocket-Protocol: ws", "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5", "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00", ] sock = eventlet.connect(self.server_addr) sock.sendall(six.b('\r\n'.join(connect) + '\r\n\r\n^n:ds[4U')) result = sock.recv(1024) self.assertEqual(result, six.b('\r\n'.join([ 'HTTP/1.1 101 WebSocket Protocol Handshake', 'Upgrade: WebSocket', 'Connection: Upgrade', 'Sec-WebSocket-Origin: http://%s:%s' % self.server_addr, 'Sec-WebSocket-Protocol: ws', 'Sec-WebSocket-Location: ' 'ws://%s:%s/echo?query_string\r\n\r\n8jKS\'y:G*Co,Wxa-' % self.server_addr, ])))
def _check_ds(self, ds_ip, ds_port): """check ds status and change the meta data""" state = DS_CONNECTED try: eventlet.connect((ds_ip, ds_port)) except socket.error: logging.exception('can not connet to ds') state = DS_BROKEN # update ds state value = self.mds.getds(ds_ip, ds_port) value['status'] = state ret = self.mds.updateds(ds_ip, ds_port, value) return ret
def test_breaking_the_connection_75(self): error_detected = [False] done_with_request = event.Event() site = self.site def error_detector(environ, start_response): try: try: return site(environ, start_response) except: error_detected[0] = True raise finally: done_with_request.send(True) self.site = error_detector self.spawn_server() connect = [ "GET /range HTTP/1.1", "Upgrade: WebSocket", "Connection: Upgrade", "Host: %s:%s" % self.server_addr, "Origin: http://%s:%s" % self.server_addr, "WebSocket-Protocol: ws", ] sock = eventlet.connect(self.server_addr) sock.sendall(six.b('\r\n'.join(connect) + '\r\n\r\n')) sock.recv(1024) # get the headers sock.close() # close while the app is running done_with_request.wait() assert not error_detected[0]
def test_breaking_the_connection_13(self): error_detected = [False] done_with_request = event.Event() site = self.site def error_detector(environ, start_response): try: try: return site(environ, start_response) except: error_detected[0] = True raise finally: done_with_request.send(True) self.site = error_detector self.spawn_server() connect = [ "GET /echo HTTP/1.1", "Upgrade: websocket", "Connection: Upgrade", "Host: %s:%s" % self.server_addr, "Origin: http://%s:%s" % self.server_addr, "Sec-WebSocket-Version: 13", "Sec-WebSocket-Key: d9MXuOzlVQ0h+qRllvSCIg==", ] sock = eventlet.connect(self.server_addr) sock.sendall(six.b('\r\n'.join(connect) + '\r\n\r\n')) sock.recv(1024) # get the headers sock.close() # close while the app is running done_with_request.wait() assert not error_detected[0]
def test_sending_messages_to_websocket(self): connect = [ "GET /echo HTTP/1.1", "Upgrade: WebSocket", "Connection: Upgrade", "Host: 127.0.0.1:%s" % self.port, "Origin: http://127.0.0.1:%s" % self.port, "WebSocket-Protocol: ws", ] sock = eventlet.connect( ('127.0.0.1', self.port)) fd = sock.makefile('rw', close=True) fd.write('\r\n'.join(connect) + '\r\n\r\n') fd.flush() first_resp = sock.recv(1024) fd.write('\x00hello\xFF') fd.flush() result = sock.recv(1024) eq_(result, '\x00http://127.0.0.1:%s says hello\xff' % self.port) fd.write('\x00start') fd.flush() fd.write(' end\xff') fd.flush() result = sock.recv(1024) eq_(result, '\x00http://127.0.0.1:%s says start end\xff' % self.port) fd.write('') fd.flush()
def test_hub_exceptions(self): debug.hub_exceptions(True) server = eventlet.listen(('0.0.0.0', 0)) client = eventlet.connect(('127.0.0.1', server.getsockname()[1])) client_2, addr = server.accept() def hurl(s): s.recv(1) {}[1] # keyerror fake = six.StringIO() orig = sys.stderr sys.stderr = fake try: gt = eventlet.spawn(hurl, client_2) eventlet.sleep(0) client.send(b' ') eventlet.sleep(0) # allow the "hurl" greenlet to trigger the KeyError # not sure why the extra context switch is needed eventlet.sleep(0) finally: sys.stderr = orig self.assertRaises(KeyError, gt.wait) debug.hub_exceptions(False) # look for the KeyError exception in the traceback self.assert_('KeyError: 1' in fake.getvalue(), "Traceback not in:\n" + fake.getvalue())
def _add_ds(self, mds_ip='127.0.0.1', mds_port=8000): """register ds to mds""" logging.info('add ds to mds') rack_id = self._config.getint('dataserver', 'rack_id') ds_ip = self._config.get('dataserver', 'ds_ip') ds_port = self._config.getint('dataserver', 'ds_port') packet = AddDSPacket(rack_id, ds_ip, ds_port) msg = packet.get_message() try: sock = eventlet.connect((mds_ip, mds_port)) except socket.error: logging.error('can not connect to mds %s:%d', mds_ip, mds_port) sys.exit( 'can not connect to mds, start mds and set the conf file!') sock_fd = sock.makefile('rw') logging.info('add ds msg: %s', msg) send_command(sock_fd, msg) recv = recv_command(sock_fd) state = recv['state'] if state == RET_FAILURE: logging.error('add ds error, return :%s', recv) sys.exit('add ds error, mds return ' + recv) sock_fd.close() return state
def test_correct_upgrade_request_76(self): connect = [ "GET /echo HTTP/1.1", "Upgrade: WebSocket", "Connection: Upgrade", "Host: localhost:%s" % self.port, "Origin: http://localhost:%s" % self.port, "Sec-WebSocket-Protocol: ws", "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5", "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00", ] sock = eventlet.connect(('localhost', self.port)) sock.sendall('\r\n'.join(connect) + '\r\n\r\n^n:ds[4U') result = sock.recv(1024) # The server responds the correct Websocket handshake self.assertEqual( result, '\r\n'.join([ 'HTTP/1.1 101 WebSocket Protocol Handshake', 'Upgrade: WebSocket', 'Connection: Upgrade', 'Sec-WebSocket-Origin: http://localhost:%s' % self.port, 'Sec-WebSocket-Protocol: ws', 'Sec-WebSocket-Location: ws://localhost:%s/echo\r\n\r\n8jKS\'y:G*Co,Wxa-' % self.port ]))
def test_breaking_the_connection_75(self): error_detected = [False] done_with_request = event.Event() site = self.site def error_detector(environ, start_response): try: try: return site(environ, start_response) except: error_detected[0] = True raise finally: done_with_request.send(True) self.site = error_detector self.spawn_server() connect = [ "GET /range HTTP/1.1", "Upgrade: WebSocket", "Connection: Upgrade", "Host: localhost:%s" % self.port, "Origin: http://localhost:%s" % self.port, "WebSocket-Protocol: ws", ] sock = eventlet.connect( ('localhost', self.port)) sock.sendall(six.b('\r\n'.join(connect) + '\r\n\r\n')) sock.recv(1024) # get the headers sock.close() # close while the app is running done_with_request.wait() assert not error_detected[0]
def test_empty_query_string(self): # verify that a single trailing ? doesn't get nuked connect = [ "GET /echo? HTTP/1.1", "Upgrade: WebSocket", "Connection: Upgrade", "Host: localhost:%s" % self.port, "Origin: http://localhost:%s" % self.port, "Sec-WebSocket-Protocol: ws", "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5", "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00", ] sock = eventlet.connect(('localhost', self.port)) sock.sendall('\r\n'.join(connect) + '\r\n\r\n^n:ds[4U') result = sock.recv(1024) self.assertEqual( result, '\r\n'.join([ 'HTTP/1.1 101 WebSocket Protocol Handshake', 'Upgrade: WebSocket', 'Connection: Upgrade', 'Sec-WebSocket-Origin: http://localhost:%s' % self.port, 'Sec-WebSocket-Protocol: ws', 'Sec-WebSocket-Location: ws://localhost:%s/echo?\r\n\r\n8jKS\'y:G*Co,Wxa-' % self.port, ]))
def _add_ds(self, mds_ip='127.0.0.1', mds_port=8000): """register ds to mds""" logging.info('add ds to mds') rack_id = self._config.getint('dataserver', 'rack_id') ds_ip = self._config.get('dataserver', 'ds_ip') ds_port = self._config.getint('dataserver', 'ds_port') packet = AddDSPacket(rack_id, ds_ip, ds_port) msg = packet.get_message() try: sock = eventlet.connect((mds_ip, mds_port)) except socket.error: logging.error('can not connect to mds %s:%d', mds_ip, mds_port) sys.exit('can not connect to mds, start mds and set the conf file!') sock_fd = sock.makefile('rw') logging.info('add ds msg: %s', msg) send_command(sock_fd, msg) recv = recv_command(sock_fd) state = recv['state'] if state == RET_FAILURE: logging.error('add ds error, return :%s', recv) sys.exit('add ds error, mds return ' + recv) sock_fd.close() return state
def test_client_invalid_packet_76(self): error_detected = [False] done_with_request = event.Event() site = self.site def error_detector(environ, start_response): try: try: return site(environ, start_response) except: error_detected[0] = True raise finally: done_with_request.send(True) self.site = error_detector self.spawn_server() connect = [ "GET /echo HTTP/1.1", "Upgrade: WebSocket", "Connection: Upgrade", "Host: localhost:%s" % self.port, "Origin: http://localhost:%s" % self.port, "Sec-WebSocket-Protocol: ws", "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5", "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00", ] sock = eventlet.connect(('localhost', self.port)) sock.sendall('\r\n'.join(connect) + '\r\n\r\n^n:ds[4U') resp = sock.recv(1024) # get the headers sock.sendall('\xef\x00') # Weird packet. done_with_request.wait() assert error_detected[0]
def test_server_compress_with_context_takeover_13(self): extensions_string = 'permessage-deflate; client_no_context_takeover;' extensions = { 'permessage-deflate': { 'client_no_context_takeover': True, 'server_no_context_takeover': False } } sock = eventlet.connect(self.server_addr) sock.sendall(six.b(self.connect % extensions_string)) sock.recv(1024) ws = websocket.RFC6455WebSocket(sock, {}, client=True, extensions=extensions) # Deflated values taken from Section 7.2.3 of RFC 7692 # https://tools.ietf.org/html/rfc7692#section-7.2.3 ws.send(b'Hello') msg1 = self.get_deflated_reply(ws) assert msg1 == b'\xf2\x48\xcd\xc9\xc9\x07\x00' ws.send(b'Hello') msg2 = self.get_deflated_reply(ws) assert msg2 == b'\xf2\x00\x11\x00\x00' ws.close() eventlet.sleep(0.01)
def test_app_socket_errors_75(self): error_detected = [False] done_with_request = event.Event() site = self.site def error_detector(environ, start_response): try: try: return site(environ, start_response) except: error_detected[0] = True raise finally: done_with_request.send(True) self.site = error_detector self.spawn_server() connect = [ "GET /error HTTP/1.1", "Upgrade: WebSocket", "Connection: Upgrade", "Host: localhost:%s" % self.port, "Origin: http://localhost:%s" % self.port, "WebSocket-Protocol: ws", ] sock = eventlet.connect(('localhost', self.port)) sock.sendall('\r\n'.join(connect) + '\r\n\r\n') resp = sock.recv(1024) done_with_request.wait() assert error_detected[0]
def test_compressed_send_recv_both_no_context_13(self): extensions_string = ( 'permessage-deflate;' ' server_no_context_takeover; client_no_context_takeover') extensions = { 'permessage-deflate': { 'client_no_context_takeover': True, 'server_no_context_takeover': True } } sock = eventlet.connect(self.server_addr) sock.sendall(six.b(self.connect % extensions_string)) sock.recv(1024) ws = websocket.RFC6455WebSocket(sock, {}, client=True, extensions=extensions) ws.send(b'hello') assert ws.wait() == b'hello' ws.send(b'hello world!') ws.send(u'hello world again!') assert ws.wait() == b'hello world!' assert ws.wait() == u'hello world again!' ws.close() eventlet.sleep(0.01)
def _connect(self, host, port, ev): try: sock = eventlet.connect((host, port)) self._addr = (host, port) self._make_connection(sock) except Exception, e: ev.send_exception(e)
def test_correct_upgrade_request_13(self): for http_connection in ['Upgrade', 'UpGrAdE', 'keep-alive, Upgrade']: connect = [ "GET /echo HTTP/1.1", "Upgrade: websocket", "Connection: %s" % http_connection, "Host: %s:%s" % self.server_addr, "Origin: http://%s:%s" % self.server_addr, "Sec-WebSocket-Version: 13", "Sec-WebSocket-Key: d9MXuOzlVQ0h+qRllvSCIg==", ] sock = eventlet.connect(self.server_addr) sock.sendall(six.b('\r\n'.join(connect) + '\r\n\r\n')) result = sock.recv(1024) # The server responds the correct Websocket handshake print('Connection string: %r' % http_connection) self.assertEqual( result, six.b('\r\n'.join([ 'HTTP/1.1 101 Switching Protocols', 'Upgrade: websocket', 'Connection: Upgrade', 'Sec-WebSocket-Accept: ywSyWXCPNsDxLrQdQrn5RFNRfBU=\r\n\r\n', ])))
def test_sending_messages_to_websocket_76(self): connect = [ "GET /echo HTTP/1.1", "Upgrade: WebSocket", "Connection: Upgrade", "Host: %s:%s" % self.server_addr, "Origin: http://%s:%s" % self.server_addr, "Sec-WebSocket-Protocol: ws", "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5", "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00", ] sock = eventlet.connect(self.server_addr) sock.sendall(six.b('\r\n'.join(connect) + '\r\n\r\n^n:ds[4U')) sock.recv(1024) sock.sendall(b'\x00hello\xFF') result = sock.recv(1024) self.assertEqual(result, b'\x00hello\xff') sock.sendall(b'\x00start') eventlet.sleep(0.001) sock.sendall(b' end\xff') result = sock.recv(1024) self.assertEqual(result, b'\x00start end\xff') sock.shutdown(socket.SHUT_RDWR) sock.close() eventlet.sleep(0.01)
def _handle(client): server = eventlet.connect( (client.environ['vnc_host'], client.environ['vnc_port'])) t1 = eventlet.spawn(self.ws2sock, client, server) t2 = eventlet.spawn(self.sock2ws, server, client) t1.wait() t2.wait()
def test_app_socket_errors_76(self): error_detected = [False] done_with_request = event.Event() site = self.site def error_detector(environ, start_response): try: try: return site(environ, start_response) except: error_detected[0] = True raise finally: done_with_request.send(True) self.site = error_detector self.spawn_server() connect = [ "GET /error HTTP/1.1", "Upgrade: WebSocket", "Connection: Upgrade", "Host: %s:%s" % self.server_addr, "Origin: http://%s:%s" % self.server_addr, "Sec-WebSocket-Protocol: ws", "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5", "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00", ] sock = eventlet.connect(self.server_addr) sock.sendall(six.b('\r\n'.join(connect) + '\r\n\r\n^n:ds[4U')) sock.recv(1024) done_with_request.wait() assert error_detected[0]
def test_sending_messages_to_websocket(self): connect = [ "GET /ec HTTP/1.1", "Upgrade: WebSocket", "Connection: Upgrade", "Host: localhost:%s" % self.port, "Origin: http://localhost:%s" % self.port, "WebSocket-Protocol: ws", ] sock = eventlet.connect( ('localhost', self.port)) fd = sock.makefile('rw', close=True) fd.write('\r\n'.join(connect) + '\r\n\r\n') fd.flush() first_resp = sock.recv(1024) fd.write('\x00hello\xFF') fd.flush() result = sock.recv(1024) eq_(result, '\x00http://localhost:%s says hello\xff' % self.port) fd.write('\x00start') fd.flush() fd.write(' end\xff') fd.flush() result = sock.recv(1024) eq_(result, '\x00http://localhost:%s says start end\xff' % self.port) fd.write('') fd.flush()
def test_correct_upgrade_request_75(self): connect = [ "GET /echo HTTP/1.1", "Upgrade: WebSocket", "Connection: Upgrade", "Host: localhost:%s" % self.port, "Origin: http://localhost:%s" % self.port, "WebSocket-Protocol: ws", ] sock = eventlet.connect(("localhost", self.port)) sock.sendall(six.b("\r\n".join(connect) + "\r\n\r\n")) result = sock.recv(1024) # The server responds the correct Websocket handshake self.assertEqual( result, six.b( "\r\n".join( [ "HTTP/1.1 101 Web Socket Protocol Handshake", "Upgrade: WebSocket", "Connection: Upgrade", "WebSocket-Origin: http://localhost:%s" % self.port, "WebSocket-Location: ws://localhost:%s/echo\r\n\r\n" % self.port, ] ) ), )
def test_ssl_sending_messages(self): s = eventlet.wrap_ssl( eventlet.listen(("localhost", 0)), certfile=certificate_file, keyfile=private_key_file, server_side=True ) self.spawn_server(sock=s) connect = [ "GET /echo HTTP/1.1", "Upgrade: WebSocket", "Connection: Upgrade", "Host: localhost:%s" % self.port, "Origin: http://localhost:%s" % self.port, "Sec-WebSocket-Protocol: ws", "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5", "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00", ] sock = eventlet.wrap_ssl(eventlet.connect(("localhost", self.port))) sock.sendall("\r\n".join(connect) + "\r\n\r\n^n:ds[4U") first_resp = sock.recv(1024) # make sure it sets the wss: protocol on the location header loc_line = [x for x in first_resp.split("\r\n") if x.lower().startswith("sec-websocket-location")][0] self.assert_("wss://localhost" in loc_line, "Expecting wss protocol in location: %s" % loc_line) sock.sendall("\x00hello\xFF") result = sock.recv(1024) self.assertEqual(result, "\x00hello\xff") sock.sendall("\x00start") eventlet.sleep(0.001) sock.sendall(" end\xff") result = sock.recv(1024) self.assertEqual(result, "\x00start end\xff") greenio.shutdown_safe(sock) sock.close() eventlet.sleep(0.01)
def test_query_string(self): # verify that the query string comes out the other side unscathed connect = [ "GET /echo?query_string HTTP/1.1", "Upgrade: WebSocket", "Connection: Upgrade", "Host: localhost:%s" % self.port, "Origin: http://localhost:%s" % self.port, "Sec-WebSocket-Protocol: ws", "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5", "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00", ] sock = eventlet.connect(("localhost", self.port)) sock.sendall(six.b("\r\n".join(connect) + "\r\n\r\n^n:ds[4U")) result = sock.recv(1024) self.assertEqual( result, six.b( "\r\n".join( [ "HTTP/1.1 101 WebSocket Protocol Handshake", "Upgrade: WebSocket", "Connection: Upgrade", "Sec-WebSocket-Origin: http://localhost:%s" % self.port, "Sec-WebSocket-Protocol: ws", "Sec-WebSocket-Location: " "ws://localhost:%s/echo?query_string\r\n\r\n8jKS'y:G*Co,Wxa-" % self.port, ] ) ), )
def test_client_invalid_packet_13(self): error_detected = [False] done_with_request = event.Event() site = self.site def error_detector(environ, start_response): try: try: return site(environ, start_response) except: error_detected[0] = True raise finally: done_with_request.send(True) self.site = error_detector self.spawn_server() connect = [ "GET /echo HTTP/1.1", "Upgrade: websocket", "Connection: Upgrade", "Host: localhost:%s" % self.port, "Origin: http://localhost:%s" % self.port, "Sec-WebSocket-Version: 13", "Sec-WebSocket-Key: d9MXuOzlVQ0h+qRllvSCIg==", ] sock = eventlet.connect( ('localhost', self.port)) sock.sendall('\r\n'.join(connect) + '\r\n\r\n') resp = sock.recv(1024) # get the headers sock.sendall('\x07\xff') # Weird packet. done_with_request.wait() self.assert_(not error_detected[0])
def test_client_invalid_packet_76(self): error_detected = [False] done_with_request = event.Event() site = self.site def error_detector(environ, start_response): try: try: return site(environ, start_response) except: error_detected[0] = True raise finally: done_with_request.send(True) self.site = error_detector self.spawn_server() connect = [ "GET /echo HTTP/1.1", "Upgrade: WebSocket", "Connection: Upgrade", "Host: localhost:%s" % self.port, "Origin: http://localhost:%s" % self.port, "Sec-WebSocket-Protocol: ws", "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5", "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00", ] sock = eventlet.connect(("localhost", self.port)) sock.sendall(six.b("\r\n".join(connect) + "\r\n\r\n^n:ds[4U")) sock.recv(1024) # get the headers sock.sendall(b"\xef\x00") # Weird packet. done_with_request.wait() assert error_detected[0]
def test_hub_exceptions(self): debug.hub_exceptions(True) server = eventlet.listen(('0.0.0.0', 0)) client = eventlet.connect(('127.0.0.1', server.getsockname()[1])) client_2, addr = server.accept() def hurl(s): s.recv(1) {}[1] # keyerror fake = six.StringIO() orig = sys.stderr sys.stderr = fake try: gt = eventlet.spawn(hurl, client_2) eventlet.sleep(0) client.send(b' ') eventlet.sleep(0) # allow the "hurl" greenlet to trigger the KeyError # not sure why the extra context switch is needed eventlet.sleep(0) finally: sys.stderr = orig self.assertRaises(KeyError, gt.wait) debug.hub_exceptions(False) # look for the KeyError exception in the traceback assert 'KeyError: 1' in fake.getvalue(), "Traceback not in:\n" + fake.getvalue()
def test_app_socket_errors_75(self): error_detected = [False] done_with_request = event.Event() site = self.site def error_detector(environ, start_response): try: try: return site(environ, start_response) except: error_detected[0] = True raise finally: done_with_request.send(True) self.site = error_detector self.spawn_server() connect = [ "GET /error HTTP/1.1", "Upgrade: WebSocket", "Connection: Upgrade", "Host: localhost:%s" % self.port, "Origin: http://localhost:%s" % self.port, "WebSocket-Protocol: ws", ] sock = eventlet.connect(("localhost", self.port)) sock.sendall(six.b("\r\n".join(connect) + "\r\n\r\n")) sock.recv(1024) done_with_request.wait() assert error_detected[0]
def handshake(self, req, connect_info, sockets): """Execute hypervisor-specific vnc auth handshaking (if needed).""" host = connect_info['host'] port = int(connect_info['port']) server = eventlet.connect((host, port)) # Handshake as necessary if connect_info.get('internal_access_path'): server.sendall("CONNECT %s HTTP/1.1\r\n\r\n" % connect_info['internal_access_path']) data = "" while True: b = server.recv(1) if b: data += b if data.find("\r\n\r\n") != -1: if not data.split("\r\n")[0].find("200"): LOG.info(_LI("Error in handshake format: %s"), data) return break if not b or len(data) > 4096: LOG.info(_LI("Error in handshake: %s"), data) return client = req.environ['eventlet.input'].get_socket() client.sendall("HTTP/1.1 200 OK\r\n\r\n") sockets['client'] = client sockets['server'] = server
def test_correct_upgrade_request_76(self): connect = [ "GET /echo HTTP/1.1", "Upgrade: WebSocket", "Connection: Upgrade", "Host: localhost:%s" % self.port, "Origin: http://localhost:%s" % self.port, "Sec-WebSocket-Protocol: ws", "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5", "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00", ] sock = eventlet.connect( ('localhost', self.port)) sock.sendall(six.b('\r\n'.join(connect) + '\r\n\r\n^n:ds[4U')) result = sock.recv(1024) # The server responds the correct Websocket handshake self.assertEqual(result, '\r\n'.join([ 'HTTP/1.1 101 WebSocket Protocol Handshake', 'Upgrade: WebSocket', 'Connection: Upgrade', 'Sec-WebSocket-Origin: http://localhost:%s' % self.port, 'Sec-WebSocket-Protocol: ws', 'Sec-WebSocket-Location: ws://localhost:%s/echo\r\n\r\n8jKS\'y:G*Co,Wxa-' % self.port, ]))
def get_blocks_from_ds(ds_id, chunk_id, blist, block_num, need_data, index): """get @blist form a chunk, chunk contain block_num blocks return a block list store in @need_data """ data_list = [] packet = GetChunkPacket(chunk_id, block_num, blist) msg = packet.get_message() sock = eventlet.connect((ds_id.split(':')[0], int(ds_id.split(':')[1]))) sock = sock.makefile('rw') send_command(sock, msg) recv = recv_command(sock) if recv['state'] != RET_SUCCESS: logging.error('get chunk from ds error: %s', recv['info']) else: data = recv_data(sock) sock.close() size = len(data)/len(blist) data_list = [data[i*size:(i+1)*size] for i in range(len(blist))] for i in range(len(blist)): need_data[index+i] = data_list[i] return data_list
def test_sending_messages_to_websocket_76(self): connect = [ "GET /echo HTTP/1.1", "Upgrade: WebSocket", "Connection: Upgrade", "Host: localhost:%s" % self.port, "Origin: http://localhost:%s" % self.port, "Sec-WebSocket-Protocol: ws", "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5", "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00", ] sock = eventlet.connect( ('localhost', self.port)) sock.sendall(six.b('\r\n'.join(connect) + '\r\n\r\n^n:ds[4U')) sock.recv(1024) sock.sendall(b'\x00hello\xFF') result = sock.recv(1024) self.assertEqual(result, b'\x00hello\xff') sock.sendall(b'\x00start') eventlet.sleep(0.001) sock.sendall(b' end\xff') result = sock.recv(1024) self.assertEqual(result, b'\x00start end\xff') sock.shutdown(socket.SHUT_RDWR) sock.close() eventlet.sleep(0.01)
def test_breaking_the_connection_13(self): error_detected = [False] done_with_request = event.Event() site = self.site def error_detector(environ, start_response): try: try: return site(environ, start_response) except: error_detected[0] = True raise finally: done_with_request.send(True) self.site = error_detector self.spawn_server() connect = [ "GET /echo HTTP/1.1", "Upgrade: websocket", "Connection: Upgrade", "Host: localhost:%s" % self.port, "Origin: http://localhost:%s" % self.port, "Sec-WebSocket-Version: 13", "Sec-WebSocket-Key: d9MXuOzlVQ0h+qRllvSCIg==", ] sock = eventlet.connect( ('localhost', self.port)) sock.sendall('\r\n'.join(connect) + '\r\n\r\n') sock.recv(1024) # get the headers sock.close() # close while the app is running done_with_request.wait() assert not error_detected[0]
def test_app_socket_errors_76(self): error_detected = [False] done_with_request = event.Event() site = self.site def error_detector(environ, start_response): try: try: return site(environ, start_response) except: error_detected[0] = True raise finally: done_with_request.send(True) self.site = error_detector self.spawn_server() connect = [ "GET /error HTTP/1.1", "Upgrade: WebSocket", "Connection: Upgrade", "Host: localhost:%s" % self.port, "Origin: http://localhost:%s" % self.port, "Sec-WebSocket-Protocol: ws", "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5", "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00", ] sock = eventlet.connect( ('localhost', self.port)) sock.sendall(six.b('\r\n'.join(connect) + '\r\n\r\n^n:ds[4U')) sock.recv(1024) done_with_request.wait() assert error_detected[0]
def test_client_closing_connection_13(self): error_detected = [False] done_with_request = event.Event() site = self.site def error_detector(environ, start_response): try: try: return site(environ, start_response) except: error_detected[0] = True raise finally: done_with_request.send(True) self.site = error_detector self.spawn_server() connect = [ "GET /echo HTTP/1.1", "Upgrade: websocket", "Connection: Upgrade", "Host: localhost:%s" % self.port, "Origin: http://localhost:%s" % self.port, "Sec-WebSocket-Version: 13", "Sec-WebSocket-Key: d9MXuOzlVQ0h+qRllvSCIg==", ] sock = eventlet.connect( ('localhost', self.port)) sock.sendall('\r\n'.join(connect) + '\r\n\r\n') sock.recv(1024) # get the headers closeframe = struct.pack('!BBIH', 1 << 7 | 8, 1 << 7 | 2, 0, 1000) sock.sendall(closeframe) # "Close the connection" packet. done_with_request.wait() assert not error_detected[0]
def handshake(self, req, connect_info, sockets): """Execute hypervisor-specific vnc auth handshaking (if needed).""" host = connect_info['host'] port = int(connect_info['port']) server = eventlet.connect((host, port)) # Handshake as necessary if connect_info.get('internal_access_path'): server.sendall("CONNECT %s HTTP/1.1\r\n\r\n" % connect_info['internal_access_path']) data = "" while True: b = server.recv(1) if b: data += b if data.find("\r\n\r\n") != -1: if not data.split("\r\n")[0].find("200"): LOG.audit(_("Error in handshake: %s"), data) return break if not b or len(data) > 4096: LOG.audit(_("Error in handshake: %s"), data) return client = req.environ['eventlet.input'].get_socket() client.sendall("HTTP/1.1 200 OK\r\n\r\n") socketsserver = None sockets['client'] = client sockets['server'] = server
def test_client_invalid_packet_13(self): error_detected = [False] done_with_request = event.Event() site = self.site def error_detector(environ, start_response): try: try: return site(environ, start_response) except: error_detected[0] = True raise finally: done_with_request.send(True) self.site = error_detector self.spawn_server() connect = [ "GET /echo HTTP/1.1", "Upgrade: websocket", "Connection: Upgrade", "Host: %s:%s" % self.server_addr, "Origin: http://%s:%s" % self.server_addr, "Sec-WebSocket-Version: 13", "Sec-WebSocket-Key: d9MXuOzlVQ0h+qRllvSCIg==", ] sock = eventlet.connect(self.server_addr) sock.sendall(six.b('\r\n'.join(connect) + '\r\n\r\n')) sock.recv(1024) # get the headers sock.sendall(b'\x07\xff') # Weird packet. done_with_request.wait() assert not error_detected[0]