From 2f71915faa875fddc29ff54426461a2d768f3fc6 Mon Sep 17 00:00:00 2001 From: Hiroki Ohtani Date: Thu, 19 Mar 2015 14:03:19 +0900 Subject: [PATCH] add "__all__" --- websocket/_app.py | 2 + websocket/_handshake.py | 143 +++++++++++++++++++++++++++++++ websocket/_http.py | 185 ++++++++++++++++++++++++++++++++++++++++ websocket/_logging.py | 3 + websocket/_socket.py | 7 +- websocket/_url.py | 26 ++++-- websocket/_utils.py | 2 + 7 files changed, 358 insertions(+), 10 deletions(-) create mode 100644 websocket/_handshake.py create mode 100644 websocket/_http.py diff --git a/websocket/_app.py b/websocket/_app.py index 6d378f7..1ee0577 100644 --- a/websocket/_app.py +++ b/websocket/_app.py @@ -35,6 +35,8 @@ from ._exceptions import * from ._logging import * from websocket._abnf import ABNF +__all__ = ["WebSocketApp"] + class WebSocketApp(object): """ diff --git a/websocket/_handshake.py b/websocket/_handshake.py new file mode 100644 index 0000000..efaa8fa --- /dev/null +++ b/websocket/_handshake.py @@ -0,0 +1,143 @@ +""" +websocket - WebSocket client library for Python + +Copyright (C) 2010 Hiroki Ohtani(liris) + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1335 USA + +""" + +import six +if six.PY3: + from base64 import encodebytes as base64encode +else: + from base64 import encodestring as base64encode + +import uuid +import hashlib + +from ._logging import * +from ._url import * +from ._socket import* +from ._http import * + +__all__ = ["handshake"] + +# websocket supported version. +VERSION = 13 + + +def handshake(sock, host, port, resource, **options): + headers, key = _get_handshake_headers(resource, host, port, options) + + header_str = "\r\n".join(headers) + send(sock, header_str) + dump("request header", header_str) + + resp = _get_resp_headers(sock) + success, subproto = _validate(resp, key, options.get("subprotocols")) + if not success: + raise WebSocketException("Invalid WebSocket Header") + + return subproto + + +def _get_handshake_headers(resource, host, port, options): + headers = [] + headers.append("GET %s HTTP/1.1" % resource) + headers.append("Upgrade: websocket") + headers.append("Connection: Upgrade") + if port == 80: + hostport = host + else: + hostport = "%s:%d" % (host, port) + headers.append("Host: %s" % hostport) + + if "origin" in options: + headers.append("Origin: %s" % options["origin"]) + else: + headers.append("Origin: http://%s" % hostport) + + key = _create_sec_websocket_key() + headers.append("Sec-WebSocket-Key: %s" % key) + headers.append("Sec-WebSocket-Version: %s" % VERSION) + + subprotocols = options.get("subprotocols") + if subprotocols: + headers.append("Sec-WebSocket-Protocol: %s" % ",".join(subprotocols)) + + if "header" in options: + headers.extend(options["header"]) + + cookie = options.get("cookie", None) + + if cookie: + headers.append("Cookie: %s" % cookie) + + headers.append("") + headers.append("") + + return headers, key + + +def _get_resp_headers(sock, success_status=101): + status, resp_headers = read_headers(sock) + if status != success_status: + raise WebSocketException("Handshake status %d" % status) + return resp_headers + +_HEADERS_TO_CHECK = { + "upgrade": "websocket", + "connection": "upgrade", + } + + +def _validate(headers, key, subprotocols): + subproto = None + for k, v in _HEADERS_TO_CHECK.items(): + r = headers.get(k, None) + if not r: + return False, None + r = r.lower() + if v != r: + return False, None + + if subprotocols: + subproto = headers.get("sec-websocket-protocol", None) + if not subproto or subproto not in subprotocols: + error("Invalid subprotocol: " + str(subprotocols)) + return False, None + + result = headers.get("sec-websocket-accept", None) + if not result: + return False, None + result = result.lower() + + if isinstance(result, six.text_type): + result = result.encode('utf-8') + + value = (key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11").encode('utf-8') + hashed = base64encode(hashlib.sha1(value).digest()).strip().lower() + success = (hashed == result) + if success: + return True, subproto + else: + return False, None + + +def _create_sec_websocket_key(): + uid = uuid.uuid4() + return base64encode(uid.bytes).decode('utf-8').strip() diff --git a/websocket/_http.py b/websocket/_http.py new file mode 100644 index 0000000..6cba5e7 --- /dev/null +++ b/websocket/_http.py @@ -0,0 +1,185 @@ +""" +websocket - WebSocket client library for Python + +Copyright (C) 2010 Hiroki Ohtani(liris) + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1335 USA + +""" + +import six +import socket + +try: + import ssl + from ssl import SSLError + if hasattr(ssl, "match_hostname"): + from ssl import match_hostname + else: + from backports.ssl_match_hostname import match_hostname + + HAVE_SSL = True +except ImportError: + # dummy class of SSLError for ssl none-support environment. + class SSLError(Exception): + pass + + HAVE_SSL = False + +if six.PY3: + from base64 import encodebytes as base64encode +else: + from base64 import encodestring as base64encode + +from ._logging import * +from ._url import * +from ._socket import* +from ._exceptions import * + +__all__ = ["connect", "read_headers"] + + +def connect(url, sockopt, sslopt, timeout, **options): + hostname, port, resource, is_secure = parse_url(url) + addrinfo_list, need_tunnel, auth = _get_addrinfo_list(hostname, port, is_secure, **options) + if not addrinfo_list: + raise WebSocketException( + "Host not found.: " + hostname + ":" + str(port)) + + sock = None + try: + sock = _open_socket(addrinfo_list, sockopt, timeout) + if need_tunnel: + sock = _tunnel(sock, hostname, port, auth) + + if is_secure: + if HAVE_SSL: + sock = _ssl_socket(sock, sslopt) + else: + raise WebSocketException("SSL not available.") + + return sock, (hostname, port, resource) + except: + if sock: + sock.close() + raise + + +def _get_addrinfo_list(hostname, port, is_secure, **options): + phost, pport, pauth = get_proxy_info(hostname, is_secure, **options) + if not phost: + addrinfo_list = socket.getaddrinfo(hostname, port, 0, 0, socket.SOL_TCP) + return addrinfo_list, False, None + else: + pport = pport and pport or 80 + addrinfo_list = socket.getaddrinfo(phost, pport, 0, 0, socket.SOL_TCP) + return addrinfo_list, True, pauth + + +def _open_socket(addrinfo_list, sockopt, timeout): + err = None + for addrinfo in addrinfo_list: + family = addrinfo[0] + sock = socket.socket(family) + sock.settimeout(timeout) + for opts in DEFAULT_SOCKET_OPTION: + sock.setsockopt(*opts) + for opts in sockopt: + sock.setsockopt(*opts) + + address = addrinfo[4] + try: + sock.connect(address) + except socket.error as error: + error.remote_ip = str(address[0]) + if error.errno in (errno.ECONNREFUSED, ): + err = error + continue + else: + raise + else: + break + else: + raise err + + return sock + + +def _ssl_socket(sock, sslopt): + sslopt = dict(cert_reqs=ssl.CERT_REQUIRED) + certPath = os.path.join( + os.path.dirname(__file__), "cacert.pem") + if os.path.isfile(certPath): + sslopt['ca_certs'] = certPath + sslopt.update(sslopt) + check_hostname = sslopt.pop('check_hostname', True) + sock = ssl.wrap_socket(sock, **sslopt) + if (sslopt["cert_reqs"] != ssl.CERT_NONE + and check_hostname): + match_hostname(sock.getpeercert(), hostname) + + +def _tunnel(sock, host, port, auth): + debug("Connecting proxy...") + connect_header = "CONNECT %s:%d HTTP/1.0\r\n" % (host, port) + # TODO: support digest auth. + if auth and auth[0]: + auth_str = auth[0] + if auth[1]: + auth_str += ":" + auth[1] + encoded_str = base64encode(auth_str.encode()).strip().decode() + connect_header += "Proxy-Authorization: Basic %s\r\n" % encoded_str + connect_header += "\r\n" + dump("request header", connect_header) + + send(sock, connect_header) + + try: + status, resp_headers = read_headers() + except Exepiton as e: + raise WebSocketProxyException(str(e)) + + if status != 200: + raise WebSocketProxyException( + "failed CONNECT via proxy status: " + str(status)) + + +def read_headers(sock): + status = None + headers = {} + trace("--- response header ---") + + while True: + line = recv_line(sock) + line = line.decode('utf-8').strip() + if not line: + break + trace(line) + if not status: + + status_info = line.split(" ", 2) + status = int(status_info[1]) + else: + kv = line.split(":", 1) + if len(kv) == 2: + key, value = kv + headers[key.lower()] = value.strip().lower() + else: + raise WebSocketException("Invalid header") + + trace("-----------------------") + + return status, headers diff --git a/websocket/_logging.py b/websocket/_logging.py index df8b139..ede5a32 100644 --- a/websocket/_logging.py +++ b/websocket/_logging.py @@ -25,6 +25,9 @@ import logging _logger = logging.getLogger() _traceEnabled = False +__all__ = ["enableTrace", "dump", "error", "debug", "trace", + "isEnableForError", "isEnableForDebug"] + def enableTrace(tracable): """ diff --git a/websocket/_socket.py b/websocket/_socket.py index b835130..1abf834 100644 --- a/websocket/_socket.py +++ b/websocket/_socket.py @@ -26,7 +26,7 @@ import six from ._exceptions import * from ._utils import * -DEFAULT_SOCKET_OPTION = [(socket.SOL_TCP, socket.TCP_NODELAY, 1),] +DEFAULT_SOCKET_OPTION = [(socket.SOL_TCP, socket.TCP_NODELAY, 1)] if hasattr(socket, "SO_KEEPALIVE"): DEFAULT_SOCKET_OPTION.append((socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)) if hasattr(socket, "TCP_KEEPIDLE"): @@ -38,6 +38,10 @@ if hasattr(socket, "TCP_KEEPCNT"): _default_timeout = None +__all__ = ["DEFAULT_SOCKET_OPTION", "setdefaulttimeout", "getdefaulttimeout", + "recv", "recv_line", "send"] + + def setdefaulttimeout(timeout): """ Set the global timeout setting to connect. @@ -76,6 +80,7 @@ def recv(sock, bufsize): return bytes + def recv_line(sock): line = [] while True: diff --git a/websocket/_url.py b/websocket/_url.py index 6a1adda..a8a5127 100644 --- a/websocket/_url.py +++ b/websocket/_url.py @@ -23,6 +23,9 @@ Copyright (C) 2010 Hiroki Ohtani(liris) from six.moves.urllib.parse import urlparse import os +__all__ = ["parse_url", "get_proxy_info"] + + def parse_url(url): """ parse url and the result is tuple of @@ -68,6 +71,7 @@ def parse_url(url): DEFAULT_NO_PROXY_HOST = ["localhost", "127.0.0.1"] + def _is_no_proxy_host(hostname, no_proxy): if not no_proxy: v = os.environ.get("no_proxy", "").replace(" ", "") @@ -77,21 +81,26 @@ def _is_no_proxy_host(hostname, no_proxy): return hostname in no_proxy + def get_proxy_info(hostname, is_secure, **options): """ - try to retrieve proxy host and port from environment if not provided in options. + try to retrieve proxy host and port from environment + if not provided in options. result is (proxy_host, proxy_port, proxy_auth). - proxy_auth is tuple of username and password of proxy authentication information. - + proxy_auth is tuple of username and password + of proxy authentication information. + hostname: websocket server name. is_secure: is the connection secure? (wss) - looks for "https_proxy" in env before falling back to "http_proxy" + looks for "https_proxy" in env + before falling back to "http_proxy" options: "http_proxy_host" - http proxy host name. "http_proxy_port" - http proxy port. "http_no_proxy" - host names, which doesn't use proxy. - "http_proxy_auth" - http proxy auth infomation. tuple of username and password. + "http_proxy_auth" - http proxy auth infomation. + tuple of username and password. defualt is None """ if _is_no_proxy_host(hostname, options.get("http_no_proxy", None)): @@ -99,7 +108,9 @@ def get_proxy_info(hostname, is_secure, **options): http_proxy_host = options.get("http_proxy_host", None) if http_proxy_host: - return http_proxy_host, options.get("http_proxy_port", 0), options.get("http_proxy_auth", None) + port = options.get("http_proxy_port", 0) + auth = options.get("http_proxy_auth", None) + return http_proxy_host, port, auth env_keys = ["http_proxy"] if is_secure: @@ -113,6 +124,3 @@ def get_proxy_info(hostname, is_secure, **options): return proxy.hostname, proxy.port, auth return None, 0, None - - - diff --git a/websocket/_utils.py b/websocket/_utils.py index dd4ff43..3369379 100644 --- a/websocket/_utils.py +++ b/websocket/_utils.py @@ -22,6 +22,8 @@ Copyright (C) 2010 Hiroki Ohtani(liris) import six +__all__ = ["NoLock", "validate_utf8", "extract_err_message"] + class NoLock(object): def __enter__(self): pass