Revision e6daa90e share/websockify/websocket.py
| share/websockify/websocket.py | ||
|---|---|---|
| 6 | 6 |
Licensed under LGPL version 3 (see docs/LICENSE.LGPL-3) |
| 7 | 7 |
|
| 8 | 8 |
Supports following protocol versions: |
| 9 |
- http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-75 |
|
| 10 |
- http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76 |
|
| 9 |
- http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-07 |
|
| 11 | 10 |
- http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-10 |
| 11 |
- http://tools.ietf.org/html/rfc6455 |
|
| 12 | 12 |
|
| 13 | 13 |
You can make a cert/key with openssl using: |
| 14 | 14 |
openssl req -new -x509 -days 365 -nodes -out self.pem -keyout self.pem |
| ... | ... | |
| 16 | 16 |
|
| 17 | 17 |
''' |
| 18 | 18 |
|
| 19 |
import os, sys, time, errno, signal, socket, traceback, select
|
|
| 19 |
import os, sys, time, errno, signal, socket, select, logging
|
|
| 20 | 20 |
import array, struct |
| 21 | 21 |
from base64 import b64encode, b64decode |
| 22 | 22 |
|
| ... | ... | |
| 37 | 37 |
except: from SimpleHTTPServer import SimpleHTTPRequestHandler |
| 38 | 38 |
|
| 39 | 39 |
# python 2.6 differences |
| 40 |
try: from hashlib import md5, sha1
|
|
| 41 |
except: from md5 import md5; from sha import sha as sha1
|
|
| 40 |
try: from hashlib import sha1 |
|
| 41 |
except: from sha import sha as sha1 |
|
| 42 | 42 |
|
| 43 | 43 |
# python 2.5 differences |
| 44 | 44 |
try: |
| ... | ... | |
| 50 | 50 |
return struct.unpack(fmt, slice) |
| 51 | 51 |
|
| 52 | 52 |
# Degraded functionality if these imports are missing |
| 53 |
for mod, sup in [('numpy', 'HyBi protocol'), ('ssl', 'TLS/SSL/wss'),
|
|
| 54 |
('multiprocessing', 'Multi-Processing'),
|
|
| 55 |
('resource', 'daemonizing')]:
|
|
| 53 |
for mod, msg in [('numpy', 'HyBi protocol will be slower'),
|
|
| 54 |
('ssl', 'TLS/SSL/wss is disabled'),
|
|
| 55 |
('multiprocessing', 'Multi-Processing is disabled'),
|
|
| 56 |
('resource', 'daemonizing is disabled')]:
|
|
| 56 | 57 |
try: |
| 57 | 58 |
globals()[mod] = __import__(mod) |
| 58 | 59 |
except ImportError: |
| 59 | 60 |
globals()[mod] = None |
| 60 |
print("WARNING: no '%s' module, %s is slower or disabled" % (
|
|
| 61 |
mod, sup)) |
|
| 61 |
print("WARNING: no '%s' module, %s" % (mod, msg))
|
|
| 62 |
|
|
| 62 | 63 |
if multiprocessing and sys.platform == 'win32': |
| 63 | 64 |
# make sockets pickle-able/inheritable |
| 64 | 65 |
import multiprocessing.reduction |
| 65 | 66 |
|
| 66 | 67 |
|
| 67 |
class WebSocketServer(object): |
|
| 68 |
# HTTP handler with WebSocket upgrade support |
|
| 69 |
class WebSocketRequestHandler(SimpleHTTPRequestHandler): |
|
| 68 | 70 |
""" |
| 69 |
WebSockets server class. |
|
| 70 |
Must be sub-classed with new_client method definition. |
|
| 71 |
WebSocket Request Handler Class, derived from SimpleHTTPRequestHandler. |
|
| 72 |
Must be sub-classed with new_websocket_client method definition. |
|
| 73 |
The request handler can be configured by setting optional |
|
| 74 |
attributes on the server object: |
|
| 75 |
|
|
| 76 |
* only_upgrade: If true, SimpleHTTPRequestHandler will not be enabled, |
|
| 77 |
only websocket is allowed. |
|
| 78 |
* verbose: If true, verbose logging is activated. |
|
| 79 |
* daemon: Running as daemon, do not write to console etc |
|
| 80 |
* record: Record raw frame data as JavaScript array into specified filename |
|
| 81 |
* run_once: Handle a single request |
|
| 82 |
* handler_id: A sequence number for this connection, appended to record filename |
|
| 71 | 83 |
""" |
| 72 |
|
|
| 73 | 84 |
buffer_size = 65536 |
| 74 | 85 |
|
| 75 |
|
|
| 76 |
server_handshake_hixie = """HTTP/1.1 101 Web Socket Protocol Handshake\r |
|
| 77 |
Upgrade: WebSocket\r |
|
| 78 |
Connection: Upgrade\r |
|
| 79 |
%sWebSocket-Origin: %s\r |
|
| 80 |
%sWebSocket-Location: %s://%s%s\r |
|
| 81 |
""" |
|
| 82 |
|
|
| 83 |
server_handshake_hybi = """HTTP/1.1 101 Switching Protocols\r |
|
| 84 |
Upgrade: websocket\r |
|
| 85 |
Connection: Upgrade\r |
|
| 86 |
Sec-WebSocket-Accept: %s\r |
|
| 87 |
""" |
|
| 88 |
|
|
| 89 | 86 |
GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11" |
| 90 | 87 |
|
| 91 |
policy_response = """<cross-domain-policy><allow-access-from domain="*" to-ports="*" /></cross-domain-policy>\n"""
|
|
| 88 |
server_version = "WebSockify"
|
|
| 92 | 89 |
|
| 93 |
# An exception before the WebSocket connection was established |
|
| 94 |
class EClose(Exception): |
|
| 95 |
pass |
|
| 90 |
protocol_version = "HTTP/1.1" |
|
| 96 | 91 |
|
| 97 | 92 |
# An exception while the WebSocket client was connected |
| 98 | 93 |
class CClose(Exception): |
| 99 | 94 |
pass |
| 100 | 95 |
|
| 101 |
def __init__(self, listen_host='', listen_port=None, source_is_ipv6=False, |
|
| 102 |
verbose=False, cert='', key='', ssl_only=None, |
|
| 103 |
daemon=False, record='', web='', |
|
| 104 |
run_once=False, timeout=0, idle_timeout=0): |
|
| 105 |
|
|
| 106 |
# settings |
|
| 107 |
self.verbose = verbose |
|
| 108 |
self.listen_host = listen_host |
|
| 109 |
self.listen_port = listen_port |
|
| 110 |
self.prefer_ipv6 = source_is_ipv6 |
|
| 111 |
self.ssl_only = ssl_only |
|
| 112 |
self.daemon = daemon |
|
| 113 |
self.run_once = run_once |
|
| 114 |
self.timeout = timeout |
|
| 115 |
self.idle_timeout = idle_timeout |
|
| 116 |
|
|
| 117 |
self.launch_time = time.time() |
|
| 118 |
self.ws_connection = False |
|
| 119 |
self.handler_id = 1 |
|
| 120 |
|
|
| 121 |
# Make paths settings absolute |
|
| 122 |
self.cert = os.path.abspath(cert) |
|
| 123 |
self.key = self.web = self.record = '' |
|
| 124 |
if key: |
|
| 125 |
self.key = os.path.abspath(key) |
|
| 126 |
if web: |
|
| 127 |
self.web = os.path.abspath(web) |
|
| 128 |
if record: |
|
| 129 |
self.record = os.path.abspath(record) |
|
| 130 |
|
|
| 131 |
if self.web: |
|
| 132 |
os.chdir(self.web) |
|
| 133 |
|
|
| 134 |
# Sanity checks |
|
| 135 |
if not ssl and self.ssl_only: |
|
| 136 |
raise Exception("No 'ssl' module and SSL-only specified")
|
|
| 137 |
if self.daemon and not resource: |
|
| 138 |
raise Exception("Module 'resource' required to daemonize")
|
|
| 139 |
|
|
| 140 |
# Show configuration |
|
| 141 |
print("WebSocket server settings:")
|
|
| 142 |
print(" - Listen on %s:%s" % (
|
|
| 143 |
self.listen_host, self.listen_port)) |
|
| 144 |
print(" - Flash security policy server")
|
|
| 145 |
if self.web: |
|
| 146 |
print(" - Web server. Web root: %s" % self.web)
|
|
| 147 |
if ssl: |
|
| 148 |
if os.path.exists(self.cert): |
|
| 149 |
print(" - SSL/TLS support")
|
|
| 150 |
if self.ssl_only: |
|
| 151 |
print(" - Deny non-SSL/TLS connections")
|
|
| 152 |
else: |
|
| 153 |
print(" - No SSL/TLS support (no cert file)")
|
|
| 154 |
else: |
|
| 155 |
print(" - No SSL/TLS support (no 'ssl' module)")
|
|
| 156 |
if self.daemon: |
|
| 157 |
print(" - Backgrounding (daemon)")
|
|
| 158 |
if self.record: |
|
| 159 |
print(" - Recording to '%s.*'" % self.record)
|
|
| 160 |
|
|
| 161 |
# |
|
| 162 |
# WebSocketServer static methods |
|
| 163 |
# |
|
| 164 |
|
|
| 165 |
@staticmethod |
|
| 166 |
def socket(host, port=None, connect=False, prefer_ipv6=False, unix_socket=None, use_ssl=False): |
|
| 167 |
""" Resolve a host (and optional port) to an IPv4 or IPv6 |
|
| 168 |
address. Create a socket. Bind to it if listen is set, |
|
| 169 |
otherwise connect to it. Return the socket. |
|
| 170 |
""" |
|
| 171 |
flags = 0 |
|
| 172 |
if host == '': |
|
| 173 |
host = None |
|
| 174 |
if connect and not (port or unix_socket): |
|
| 175 |
raise Exception("Connect mode requires a port")
|
|
| 176 |
if use_ssl and not ssl: |
|
| 177 |
raise Exception("SSL socket requested but Python SSL module not loaded.");
|
|
| 178 |
if not connect and use_ssl: |
|
| 179 |
raise Exception("SSL only supported in connect mode (for now)")
|
|
| 180 |
if not connect: |
|
| 181 |
flags = flags | socket.AI_PASSIVE |
|
| 182 |
|
|
| 183 |
if not unix_socket: |
|
| 184 |
addrs = socket.getaddrinfo(host, port, 0, socket.SOCK_STREAM, |
|
| 185 |
socket.IPPROTO_TCP, flags) |
|
| 186 |
if not addrs: |
|
| 187 |
raise Exception("Could not resolve host '%s'" % host)
|
|
| 188 |
addrs.sort(key=lambda x: x[0]) |
|
| 189 |
if prefer_ipv6: |
|
| 190 |
addrs.reverse() |
|
| 191 |
sock = socket.socket(addrs[0][0], addrs[0][1]) |
|
| 192 |
if connect: |
|
| 193 |
sock.connect(addrs[0][4]) |
|
| 194 |
if use_ssl: |
|
| 195 |
sock = ssl.wrap_socket(sock) |
|
| 196 |
else: |
|
| 197 |
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) |
|
| 198 |
sock.bind(addrs[0][4]) |
|
| 199 |
sock.listen(100) |
|
| 200 |
else: |
|
| 201 |
sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) |
|
| 202 |
sock.connect(unix_socket) |
|
| 203 |
|
|
| 204 |
return sock |
|
| 205 |
|
|
| 206 |
@staticmethod |
|
| 207 |
def daemonize(keepfd=None, chdir='/'): |
|
| 208 |
os.umask(0) |
|
| 209 |
if chdir: |
|
| 210 |
os.chdir(chdir) |
|
| 211 |
else: |
|
| 212 |
os.chdir('/')
|
|
| 213 |
os.setgid(os.getgid()) # relinquish elevations |
|
| 214 |
os.setuid(os.getuid()) # relinquish elevations |
|
| 215 |
|
|
| 216 |
# Double fork to daemonize |
|
| 217 |
if os.fork() > 0: os._exit(0) # Parent exits |
|
| 218 |
os.setsid() # Obtain new process group |
|
| 219 |
if os.fork() > 0: os._exit(0) # Parent exits |
|
| 220 |
|
|
| 221 |
# Signal handling |
|
| 222 |
def terminate(a,b): os._exit(0) |
|
| 223 |
signal.signal(signal.SIGTERM, terminate) |
|
| 224 |
signal.signal(signal.SIGINT, signal.SIG_IGN) |
|
| 96 |
def __init__(self, req, addr, server): |
|
| 97 |
# Retrieve a few configuration variables from the server |
|
| 98 |
self.only_upgrade = getattr(server, "only_upgrade", False) |
|
| 99 |
self.verbose = getattr(server, "verbose", False) |
|
| 100 |
self.daemon = getattr(server, "daemon", False) |
|
| 101 |
self.record = getattr(server, "record", False) |
|
| 102 |
self.run_once = getattr(server, "run_once", False) |
|
| 103 |
self.rec = None |
|
| 104 |
self.handler_id = getattr(server, "handler_id", False) |
|
| 105 |
self.file_only = getattr(server, "file_only", False) |
|
| 106 |
self.traffic = getattr(server, "traffic", False) |
|
| 225 | 107 |
|
| 226 |
# Close open files |
|
| 227 |
maxfd = resource.getrlimit(resource.RLIMIT_NOFILE)[1] |
|
| 228 |
if maxfd == resource.RLIM_INFINITY: maxfd = 256 |
|
| 229 |
for fd in reversed(range(maxfd)): |
|
| 230 |
try: |
|
| 231 |
if fd != keepfd: |
|
| 232 |
os.close(fd) |
|
| 233 |
except OSError: |
|
| 234 |
_, exc, _ = sys.exc_info() |
|
| 235 |
if exc.errno != errno.EBADF: raise |
|
| 108 |
self.logger = getattr(server, "logger", None) |
|
| 109 |
if self.logger is None: |
|
| 110 |
self.logger = WebSocketServer.get_logger() |
|
| 236 | 111 |
|
| 237 |
# Redirect I/O to /dev/null |
|
| 238 |
os.dup2(os.open(os.devnull, os.O_RDWR), sys.stdin.fileno()) |
|
| 239 |
os.dup2(os.open(os.devnull, os.O_RDWR), sys.stdout.fileno()) |
|
| 240 |
os.dup2(os.open(os.devnull, os.O_RDWR), sys.stderr.fileno()) |
|
| 112 |
SimpleHTTPRequestHandler.__init__(self, req, addr, server) |
|
| 241 | 113 |
|
| 242 | 114 |
@staticmethod |
| 243 | 115 |
def unmask(buf, hlen, plen): |
| ... | ... | |
| 254 | 126 |
b = numpy.bitwise_xor(data, mask).tostring() |
| 255 | 127 |
|
| 256 | 128 |
if plen % 4: |
| 257 |
#print("Partial unmask")
|
|
| 129 |
#self.msg("Partial unmask")
|
|
| 258 | 130 |
mask = numpy.frombuffer(buf, dtype=numpy.dtype('B'),
|
| 259 | 131 |
offset=hlen, count=(plen % 4)) |
| 260 | 132 |
data = numpy.frombuffer(buf, dtype=numpy.dtype('B'),
|
| ... | ... | |
| 295 | 167 |
elif payload_len >= 65536: |
| 296 | 168 |
header = pack('>BBQ', b1, 127, payload_len)
|
| 297 | 169 |
|
| 298 |
#print("Encoded: %s" % repr(header + buf))
|
|
| 170 |
#self.msg("Encoded: %s", repr(header + buf))
|
|
| 299 | 171 |
|
| 300 | 172 |
return header + buf, len(header), 0 |
| 301 | 173 |
|
| 302 | 174 |
@staticmethod |
| 303 |
def decode_hybi(buf, base64=False): |
|
| 175 |
def decode_hybi(buf, base64=False, logger=None):
|
|
| 304 | 176 |
""" Decode HyBi style WebSocket packets. |
| 305 | 177 |
Returns: |
| 306 | 178 |
{'fin' : 0_or_1,
|
| ... | ... | |
| 324 | 196 |
'close_code' : 1000, |
| 325 | 197 |
'close_reason' : ''} |
| 326 | 198 |
|
| 199 |
if logger is None: |
|
| 200 |
logger = WebSocketServer.get_logger() |
|
| 201 |
|
|
| 327 | 202 |
blen = len(buf) |
| 328 | 203 |
f['left'] = blen |
| 329 | 204 |
|
| ... | ... | |
| 359 | 234 |
# Process 1 frame |
| 360 | 235 |
if f['masked']: |
| 361 | 236 |
# unmask payload |
| 362 |
f['payload'] = WebSocketServer.unmask(buf, f['hlen'],
|
|
| 237 |
f['payload'] = WebSocketRequestHandler.unmask(buf, f['hlen'],
|
|
| 363 | 238 |
f['length']) |
| 364 | 239 |
else: |
| 365 |
print("Unmasked frame: %s" % repr(buf))
|
|
| 240 |
logger.debug("Unmasked frame: %s" % repr(buf))
|
|
| 366 | 241 |
f['payload'] = buf[(f['hlen'] + f['masked'] * 4):full_len] |
| 367 | 242 |
|
| 368 | 243 |
if base64 and f['opcode'] in [1, 2]: |
| 369 | 244 |
try: |
| 370 | 245 |
f['payload'] = b64decode(f['payload']) |
| 371 | 246 |
except: |
| 372 |
print("Exception while b64decoding buffer: %s" %
|
|
| 373 |
repr(buf))
|
|
| 247 |
logger.exception("Exception while b64decoding buffer: %s" %
|
|
| 248 |
(repr(buf)))
|
|
| 374 | 249 |
raise |
| 375 | 250 |
|
| 376 | 251 |
if f['opcode'] == 0x08: |
| ... | ... | |
| 381 | 256 |
|
| 382 | 257 |
return f |
| 383 | 258 |
|
| 384 |
@staticmethod |
|
| 385 |
def encode_hixie(buf): |
|
| 386 |
return s2b("\x00" + b2s(b64encode(buf)) + "\xff"), 1, 1
|
|
| 387 |
|
|
| 388 |
@staticmethod |
|
| 389 |
def decode_hixie(buf): |
|
| 390 |
end = buf.find(s2b('\xff'))
|
|
| 391 |
return {'payload': b64decode(buf[1:end]),
|
|
| 392 |
'hlen': 1, |
|
| 393 |
'masked': False, |
|
| 394 |
'length': end - 1, |
|
| 395 |
'left': len(buf) - (end + 1)} |
|
| 396 |
|
|
| 397 |
|
|
| 398 |
@staticmethod |
|
| 399 |
def gen_md5(keys): |
|
| 400 |
""" Generate hash value for WebSockets hixie-76. """ |
|
| 401 |
key1 = keys['Sec-WebSocket-Key1'] |
|
| 402 |
key2 = keys['Sec-WebSocket-Key2'] |
|
| 403 |
key3 = keys['key3'] |
|
| 404 |
spaces1 = key1.count(" ")
|
|
| 405 |
spaces2 = key2.count(" ")
|
|
| 406 |
num1 = int("".join([c for c in key1 if c.isdigit()])) / spaces1
|
|
| 407 |
num2 = int("".join([c for c in key2 if c.isdigit()])) / spaces2
|
|
| 408 |
|
|
| 409 |
return b2s(md5(pack('>II8s',
|
|
| 410 |
int(num1), int(num2), key3)).digest()) |
|
| 411 | 259 |
|
| 412 | 260 |
# |
| 413 |
# WebSocketServer logging/output functions
|
|
| 261 |
# WebSocketRequestHandler logging/output functions
|
|
| 414 | 262 |
# |
| 415 | 263 |
|
| 416 |
def traffic(self, token="."): |
|
| 417 |
""" Show traffic flow in verbose mode. """
|
|
| 418 |
if self.verbose and not self.daemon:
|
|
| 264 |
def print_traffic(self, token="."):
|
|
| 265 |
""" Show traffic flow mode. """ |
|
| 266 |
if self.traffic:
|
|
| 419 | 267 |
sys.stdout.write(token) |
| 420 | 268 |
sys.stdout.flush() |
| 421 | 269 |
|
| 422 |
def msg(self, msg): |
|
| 270 |
def msg(self, msg, *args, **kwargs):
|
|
| 423 | 271 |
""" Output message with handler_id prefix. """ |
| 424 |
if not self.daemon:
|
|
| 425 |
print("% 3d: %s" % (self.handler_id, msg))
|
|
| 272 |
prefix = "% 3d: " % self.handler_id
|
|
| 273 |
self.logger.log(logging.INFO, "%s%s" % (prefix, msg), *args, **kwargs)
|
|
| 426 | 274 |
|
| 427 |
def vmsg(self, msg): |
|
| 428 |
""" Same as msg() but only if verbose. """ |
|
| 429 |
if self.verbose: |
|
| 430 |
self.msg(msg) |
|
| 275 |
def vmsg(self, msg, *args, **kwargs): |
|
| 276 |
""" Same as msg() but as debug. """ |
|
| 277 |
prefix = "% 3d: " % self.handler_id |
|
| 278 |
self.logger.log(logging.DEBUG, "%s%s" % (prefix, msg), *args, **kwargs) |
|
| 279 |
|
|
| 280 |
def warn(self, msg, *args, **kwargs): |
|
| 281 |
""" Same as msg() but as warning. """ |
|
| 282 |
prefix = "% 3d: " % self.handler_id |
|
| 283 |
self.logger.log(logging.WARN, "%s%s" % (prefix, msg), *args, **kwargs) |
|
| 431 | 284 |
|
| 432 | 285 |
# |
| 433 |
# Main WebSocketServer methods
|
|
| 286 |
# Main WebSocketRequestHandler methods
|
|
| 434 | 287 |
# |
| 435 | 288 |
def send_frames(self, bufs=None): |
| 436 | 289 |
""" Encode and send WebSocket frames. Any frames already |
| ... | ... | |
| 444 | 297 |
|
| 445 | 298 |
if bufs: |
| 446 | 299 |
for buf in bufs: |
| 447 |
if self.version.startswith("hybi"):
|
|
| 448 |
if self.base64: |
|
| 449 |
encbuf, lenhead, lentail = self.encode_hybi( |
|
| 450 |
buf, opcode=1, base64=True) |
|
| 451 |
else: |
|
| 452 |
encbuf, lenhead, lentail = self.encode_hybi( |
|
| 453 |
buf, opcode=2, base64=False) |
|
| 454 |
|
|
| 300 |
if self.base64: |
|
| 301 |
encbuf, lenhead, lentail = self.encode_hybi(buf, opcode=1, base64=True) |
|
| 455 | 302 |
else: |
| 456 |
encbuf, lenhead, lentail = self.encode_hixie(buf)
|
|
| 303 |
encbuf, lenhead, lentail = self.encode_hybi(buf, opcode=2, base64=False)
|
|
| 457 | 304 |
|
| 458 | 305 |
if self.rec: |
| 459 | 306 |
self.rec.write("%s,\n" %
|
| ... | ... | |
| 465 | 312 |
while self.send_parts: |
| 466 | 313 |
# Send pending frames |
| 467 | 314 |
buf = self.send_parts.pop(0) |
| 468 |
sent = self.client.send(buf)
|
|
| 315 |
sent = self.request.send(buf)
|
|
| 469 | 316 |
|
| 470 | 317 |
if sent == len(buf): |
| 471 |
self.traffic("<")
|
|
| 318 |
self.print_traffic("<")
|
|
| 472 | 319 |
else: |
| 473 |
self.traffic("<.")
|
|
| 320 |
self.print_traffic("<.")
|
|
| 474 | 321 |
self.send_parts.insert(0, buf[sent:]) |
| 475 | 322 |
break |
| 476 | 323 |
|
| ... | ... | |
| 487 | 334 |
bufs = [] |
| 488 | 335 |
tdelta = int(time.time()*1000) - self.start_time |
| 489 | 336 |
|
| 490 |
buf = self.client.recv(self.buffer_size)
|
|
| 337 |
buf = self.request.recv(self.buffer_size)
|
|
| 491 | 338 |
if len(buf) == 0: |
| 492 | 339 |
closed = {'code': 1000, 'reason': "Client closed abruptly"}
|
| 493 | 340 |
return bufs, closed |
| ... | ... | |
| 498 | 345 |
self.recv_part = None |
| 499 | 346 |
|
| 500 | 347 |
while buf: |
| 501 |
if self.version.startswith("hybi"):
|
|
| 502 |
|
|
| 503 |
frame = self.decode_hybi(buf, base64=self.base64) |
|
| 504 |
#print("Received buf: %s, frame: %s" % (repr(buf), frame))
|
|
| 505 |
|
|
| 506 |
if frame['payload'] == None: |
|
| 507 |
# Incomplete/partial frame |
|
| 508 |
self.traffic("}.")
|
|
| 509 |
if frame['left'] > 0: |
|
| 510 |
self.recv_part = buf[-frame['left']:] |
|
| 511 |
break |
|
| 512 |
else: |
|
| 513 |
if frame['opcode'] == 0x8: # connection close |
|
| 514 |
closed = {'code': frame['close_code'],
|
|
| 515 |
'reason': frame['close_reason']} |
|
| 516 |
break |
|
| 517 |
|
|
| 348 |
frame = self.decode_hybi(buf, base64=self.base64, |
|
| 349 |
logger=self.logger) |
|
| 350 |
#self.msg("Received buf: %s, frame: %s", repr(buf), frame)
|
|
| 351 |
|
|
| 352 |
if frame['payload'] == None: |
|
| 353 |
# Incomplete/partial frame |
|
| 354 |
self.print_traffic("}.")
|
|
| 355 |
if frame['left'] > 0: |
|
| 356 |
self.recv_part = buf[-frame['left']:] |
|
| 357 |
break |
|
| 518 | 358 |
else: |
| 519 |
if buf[0:2] == s2b('\xff\x00'):
|
|
| 520 |
closed = {'code': 1000,
|
|
| 521 |
'reason': "Client sent orderly close frame"}
|
|
| 359 |
if frame['opcode'] == 0x8: # connection close
|
|
| 360 |
closed = {'code': frame['close_code'],
|
|
| 361 |
'reason': frame['close_reason']}
|
|
| 522 | 362 |
break |
| 523 | 363 |
|
| 524 |
elif buf[0:2] == s2b('\x00\xff'):
|
|
| 525 |
buf = buf[2:] |
|
| 526 |
continue # No-op |
|
| 527 |
|
|
| 528 |
elif buf.count(s2b('\xff')) == 0:
|
|
| 529 |
# Partial frame |
|
| 530 |
self.traffic("}.")
|
|
| 531 |
self.recv_part = buf |
|
| 532 |
break |
|
| 533 |
|
|
| 534 |
frame = self.decode_hixie(buf) |
|
| 535 |
|
|
| 536 |
self.traffic("}")
|
|
| 364 |
self.print_traffic("}")
|
|
| 537 | 365 |
|
| 538 | 366 |
if self.rec: |
| 539 | 367 |
start = frame['hlen'] |
| 540 | 368 |
end = frame['hlen'] + frame['length'] |
| 541 | 369 |
if frame['masked']: |
| 542 |
recbuf = WebSocketServer.unmask(buf, frame['hlen'],
|
|
| 370 |
recbuf = WebSocketRequestHandler.unmask(buf, frame['hlen'],
|
|
| 543 | 371 |
frame['length']) |
| 544 | 372 |
else: |
| 545 | 373 |
recbuf = buf[frame['hlen']:frame['hlen'] + |
| ... | ... | |
| 560 | 388 |
def send_close(self, code=1000, reason=''): |
| 561 | 389 |
""" Send a WebSocket orderly close frame. """ |
| 562 | 390 |
|
| 563 |
if self.version.startswith("hybi"):
|
|
| 564 |
msg = pack(">H%ds" % len(reason), code, reason)
|
|
| 565 |
|
|
| 566 |
buf, h, t = self.encode_hybi(msg, opcode=0x08, base64=False) |
|
| 567 |
self.client.send(buf) |
|
| 568 |
|
|
| 569 |
elif self.version == "hixie-76": |
|
| 570 |
buf = s2b('\xff\x00')
|
|
| 571 |
self.client.send(buf) |
|
| 572 |
|
|
| 573 |
# No orderly close for 75 |
|
| 391 |
msg = pack(">H%ds" % len(reason), code, reason)
|
|
| 392 |
buf, h, t = self.encode_hybi(msg, opcode=0x08, base64=False) |
|
| 393 |
self.request.send(buf) |
|
| 574 | 394 |
|
| 575 |
def do_websocket_handshake(self, headers, path): |
|
| 576 |
h = self.headers = headers |
|
| 577 |
self.path = path |
|
| 395 |
def do_websocket_handshake(self): |
|
| 396 |
h = self.headers |
|
| 578 | 397 |
|
| 579 | 398 |
prot = 'WebSocket-Protocol' |
| 580 | 399 |
protocols = h.get('Sec-'+prot, h.get(prot, '')).split(',')
|
| ... | ... | |
| 589 | 408 |
if ver in ['7', '8', '13']: |
| 590 | 409 |
self.version = "hybi-%02d" % int(ver) |
| 591 | 410 |
else: |
| 592 |
raise self.EClose('Unsupported protocol version %s' % ver)
|
|
| 411 |
self.send_error(400, "Unsupported protocol version %s" % ver) |
|
| 412 |
return False |
|
| 593 | 413 |
|
| 594 | 414 |
key = h['Sec-WebSocket-Key'] |
| 595 | 415 |
|
| ... | ... | |
| 599 | 419 |
elif 'base64' in protocols: |
| 600 | 420 |
self.base64 = True |
| 601 | 421 |
else: |
| 602 |
raise self.EClose("Client must support 'binary' or 'base64' protocol")
|
|
| 422 |
self.send_error(400, "Client must support 'binary' or 'base64' protocol") |
|
| 423 |
return False |
|
| 603 | 424 |
|
| 604 | 425 |
# Generate the hash value for the accept header |
| 605 | 426 |
accept = b64encode(sha1(s2b(key + self.GUID)).digest()) |
| 606 | 427 |
|
| 607 |
response = self.server_handshake_hybi % b2s(accept) |
|
| 428 |
self.send_response(101, "Switching Protocols") |
|
| 429 |
self.send_header("Upgrade", "websocket")
|
|
| 430 |
self.send_header("Connection", "Upgrade")
|
|
| 431 |
self.send_header("Sec-WebSocket-Accept", b2s(accept))
|
|
| 608 | 432 |
if self.base64: |
| 609 |
response += "Sec-WebSocket-Protocol: base64\r\n" |
|
| 433 |
self.send_header("Sec-WebSocket-Protocol", "base64")
|
|
| 434 |
else: |
|
| 435 |
self.send_header("Sec-WebSocket-Protocol", "binary")
|
|
| 436 |
self.end_headers() |
|
| 437 |
return True |
|
| 438 |
else: |
|
| 439 |
self.send_error(400, "Missing Sec-WebSocket-Version header. Hixie protocols not supported.") |
|
| 440 |
|
|
| 441 |
return False |
|
| 442 |
|
|
| 443 |
def handle_websocket(self): |
|
| 444 |
"""Upgrade a connection to Websocket, if requested. If this succeeds, |
|
| 445 |
new_websocket_client() will be called. Otherwise, False is returned. |
|
| 446 |
""" |
|
| 447 |
if (self.headers.get('upgrade') and
|
|
| 448 |
self.headers.get('upgrade').lower() == 'websocket'):
|
|
| 449 |
|
|
| 450 |
if not self.do_websocket_handshake(): |
|
| 451 |
return False |
|
| 452 |
|
|
| 453 |
# Indicate to server that a Websocket upgrade was done |
|
| 454 |
self.server.ws_connection = True |
|
| 455 |
# Initialize per client settings |
|
| 456 |
self.send_parts = [] |
|
| 457 |
self.recv_part = None |
|
| 458 |
self.start_time = int(time.time()*1000) |
|
| 459 |
|
|
| 460 |
# client_address is empty with, say, UNIX domain sockets |
|
| 461 |
client_addr = "" |
|
| 462 |
is_ssl = False |
|
| 463 |
try: |
|
| 464 |
client_addr = self.client_address[0] |
|
| 465 |
is_ssl = self.client_address[2] |
|
| 466 |
except IndexError: |
|
| 467 |
pass |
|
| 468 |
|
|
| 469 |
if is_ssl: |
|
| 470 |
self.stype = "SSL/TLS (wss://)" |
|
| 610 | 471 |
else: |
| 611 |
response += "Sec-WebSocket-Protocol: binary\r\n" |
|
| 612 |
response += "\r\n" |
|
| 472 |
self.stype = "Plain non-SSL (ws://)" |
|
| 473 |
|
|
| 474 |
self.log_message("%s: %s WebSocket connection", client_addr,
|
|
| 475 |
self.stype) |
|
| 476 |
self.log_message("%s: Version %s, base64: '%s'", client_addr,
|
|
| 477 |
self.version, self.base64) |
|
| 478 |
if self.path != '/': |
|
| 479 |
self.log_message("%s: Path: '%s'", client_addr, self.path)
|
|
| 480 |
|
|
| 481 |
if self.record: |
|
| 482 |
# Record raw frame data as JavaScript array |
|
| 483 |
fname = "%s.%s" % (self.record, |
|
| 484 |
self.handler_id) |
|
| 485 |
self.log_message("opening record file: %s", fname)
|
|
| 486 |
self.rec = open(fname, 'w+') |
|
| 487 |
encoding = "binary" |
|
| 488 |
if self.base64: encoding = "base64" |
|
| 489 |
self.rec.write("var VNC_frame_encoding = '%s';\n"
|
|
| 490 |
% encoding) |
|
| 491 |
self.rec.write("var VNC_frame_data = [\n")
|
|
| 613 | 492 |
|
| 493 |
try: |
|
| 494 |
self.new_websocket_client() |
|
| 495 |
except self.CClose: |
|
| 496 |
# Close the client |
|
| 497 |
_, exc, _ = sys.exc_info() |
|
| 498 |
self.send_close(exc.args[0], exc.args[1]) |
|
| 499 |
return True |
|
| 614 | 500 |
else: |
| 615 |
# Hixie version of the protocol (75 or 76) |
|
| 501 |
return False |
|
| 502 |
|
|
| 503 |
def do_GET(self): |
|
| 504 |
"""Handle GET request. Calls handle_websocket(). If unsuccessful, |
|
| 505 |
and web server is enabled, SimpleHTTPRequestHandler.do_GET will be called.""" |
|
| 506 |
if not self.handle_websocket(): |
|
| 507 |
if self.only_upgrade: |
|
| 508 |
self.send_error(405, "Method Not Allowed") |
|
| 509 |
else: |
|
| 510 |
SimpleHTTPRequestHandler.do_GET(self) |
|
| 511 |
|
|
| 512 |
def list_directory(self, path): |
|
| 513 |
if self.file_only: |
|
| 514 |
self.send_error(404, "No such file") |
|
| 515 |
else: |
|
| 516 |
return SimpleHTTPRequestHandler.list_directory(self, path) |
|
| 517 |
|
|
| 518 |
def new_websocket_client(self): |
|
| 519 |
""" Do something with a WebSockets client connection. """ |
|
| 520 |
raise Exception("WebSocketRequestHandler.new_websocket_client() must be overloaded")
|
|
| 521 |
|
|
| 522 |
def do_HEAD(self): |
|
| 523 |
if self.only_upgrade: |
|
| 524 |
self.send_error(405, "Method Not Allowed") |
|
| 525 |
else: |
|
| 526 |
SimpleHTTPRequestHandler.do_HEAD(self) |
|
| 527 |
|
|
| 528 |
def finish(self): |
|
| 529 |
if self.rec: |
|
| 530 |
self.rec.write("'EOF'];\n")
|
|
| 531 |
self.rec.close() |
|
| 532 |
|
|
| 533 |
def handle(self): |
|
| 534 |
# When using run_once, we have a single process, so |
|
| 535 |
# we cannot loop in BaseHTTPRequestHandler.handle; we |
|
| 536 |
# must return and handle new connections |
|
| 537 |
if self.run_once: |
|
| 538 |
self.handle_one_request() |
|
| 539 |
else: |
|
| 540 |
SimpleHTTPRequestHandler.handle(self) |
|
| 541 |
|
|
| 542 |
def log_request(self, code='-', size='-'): |
|
| 543 |
if self.verbose: |
|
| 544 |
SimpleHTTPRequestHandler.log_request(self, code, size) |
|
| 545 |
|
|
| 616 | 546 |
|
| 617 |
if h.get('key3'):
|
|
| 618 |
trailer = self.gen_md5(h) |
|
| 619 |
pre = "Sec-" |
|
| 620 |
self.version = "hixie-76" |
|
| 547 |
class WebSocketServer(object): |
|
| 548 |
""" |
|
| 549 |
WebSockets server class. |
|
| 550 |
As an alternative, the standard library SocketServer can be used |
|
| 551 |
""" |
|
| 552 |
|
|
| 553 |
policy_response = """<cross-domain-policy><allow-access-from domain="*" to-ports="*" /></cross-domain-policy>\n""" |
|
| 554 |
log_prefix = "websocket" |
|
| 555 |
|
|
| 556 |
# An exception before the WebSocket connection was established |
|
| 557 |
class EClose(Exception): |
|
| 558 |
pass |
|
| 559 |
|
|
| 560 |
class Terminate(Exception): |
|
| 561 |
pass |
|
| 562 |
|
|
| 563 |
def __init__(self, RequestHandlerClass, listen_host='', |
|
| 564 |
listen_port=None, source_is_ipv6=False, |
|
| 565 |
verbose=False, cert='', key='', ssl_only=None, |
|
| 566 |
daemon=False, record='', web='', |
|
| 567 |
file_only=False, |
|
| 568 |
run_once=False, timeout=0, idle_timeout=0, traffic=False, |
|
| 569 |
tcp_keepalive=True, tcp_keepcnt=None, tcp_keepidle=None, |
|
| 570 |
tcp_keepintvl=None): |
|
| 571 |
|
|
| 572 |
# settings |
|
| 573 |
self.RequestHandlerClass = RequestHandlerClass |
|
| 574 |
self.verbose = verbose |
|
| 575 |
self.listen_host = listen_host |
|
| 576 |
self.listen_port = listen_port |
|
| 577 |
self.prefer_ipv6 = source_is_ipv6 |
|
| 578 |
self.ssl_only = ssl_only |
|
| 579 |
self.daemon = daemon |
|
| 580 |
self.run_once = run_once |
|
| 581 |
self.timeout = timeout |
|
| 582 |
self.idle_timeout = idle_timeout |
|
| 583 |
self.traffic = traffic |
|
| 584 |
|
|
| 585 |
self.launch_time = time.time() |
|
| 586 |
self.ws_connection = False |
|
| 587 |
self.handler_id = 1 |
|
| 588 |
|
|
| 589 |
self.logger = self.get_logger() |
|
| 590 |
self.tcp_keepalive = tcp_keepalive |
|
| 591 |
self.tcp_keepcnt = tcp_keepcnt |
|
| 592 |
self.tcp_keepidle = tcp_keepidle |
|
| 593 |
self.tcp_keepintvl = tcp_keepintvl |
|
| 594 |
|
|
| 595 |
# Make paths settings absolute |
|
| 596 |
self.cert = os.path.abspath(cert) |
|
| 597 |
self.key = self.web = self.record = '' |
|
| 598 |
if key: |
|
| 599 |
self.key = os.path.abspath(key) |
|
| 600 |
if web: |
|
| 601 |
self.web = os.path.abspath(web) |
|
| 602 |
if record: |
|
| 603 |
self.record = os.path.abspath(record) |
|
| 604 |
|
|
| 605 |
if self.web: |
|
| 606 |
os.chdir(self.web) |
|
| 607 |
self.only_upgrade = not self.web |
|
| 608 |
|
|
| 609 |
# Sanity checks |
|
| 610 |
if not ssl and self.ssl_only: |
|
| 611 |
raise Exception("No 'ssl' module and SSL-only specified")
|
|
| 612 |
if self.daemon and not resource: |
|
| 613 |
raise Exception("Module 'resource' required to daemonize")
|
|
| 614 |
|
|
| 615 |
# Show configuration |
|
| 616 |
self.msg("WebSocket server settings:")
|
|
| 617 |
self.msg(" - Listen on %s:%s",
|
|
| 618 |
self.listen_host, self.listen_port) |
|
| 619 |
self.msg(" - Flash security policy server")
|
|
| 620 |
if self.web: |
|
| 621 |
self.msg(" - Web server. Web root: %s", self.web)
|
|
| 622 |
if ssl: |
|
| 623 |
if os.path.exists(self.cert): |
|
| 624 |
self.msg(" - SSL/TLS support")
|
|
| 625 |
if self.ssl_only: |
|
| 626 |
self.msg(" - Deny non-SSL/TLS connections")
|
|
| 621 | 627 |
else: |
| 622 |
trailer = "" |
|
| 623 |
pre = "" |
|
| 624 |
self.version = "hixie-75" |
|
| 628 |
self.msg(" - No SSL/TLS support (no cert file)")
|
|
| 629 |
else: |
|
| 630 |
self.msg(" - No SSL/TLS support (no 'ssl' module)")
|
|
| 631 |
if self.daemon: |
|
| 632 |
self.msg(" - Backgrounding (daemon)")
|
|
| 633 |
if self.record: |
|
| 634 |
self.msg(" - Recording to '%s.*'", self.record)
|
|
| 625 | 635 |
|
| 626 |
# We only support base64 in Hixie era |
|
| 627 |
self.base64 = True |
|
| 636 |
# |
|
| 637 |
# WebSocketServer static methods |
|
| 638 |
# |
|
| 628 | 639 |
|
| 629 |
response = self.server_handshake_hixie % (pre, |
|
| 630 |
h['Origin'], pre, self.scheme, h['Host'], path) |
|
| 640 |
@staticmethod |
|
| 641 |
def get_logger(): |
|
| 642 |
return logging.getLogger("%s.%s" % (
|
|
| 643 |
WebSocketServer.log_prefix, |
|
| 644 |
WebSocketServer.__class__.__name__)) |
|
| 631 | 645 |
|
| 632 |
if 'base64' in protocols: |
|
| 633 |
response += "%sWebSocket-Protocol: base64\r\n" % pre |
|
| 646 |
@staticmethod |
|
| 647 |
def socket(host, port=None, connect=False, prefer_ipv6=False, |
|
| 648 |
unix_socket=None, use_ssl=False, tcp_keepalive=True, |
|
| 649 |
tcp_keepcnt=None, tcp_keepidle=None, tcp_keepintvl=None): |
|
| 650 |
""" Resolve a host (and optional port) to an IPv4 or IPv6 |
|
| 651 |
address. Create a socket. Bind to it if listen is set, |
|
| 652 |
otherwise connect to it. Return the socket. |
|
| 653 |
""" |
|
| 654 |
flags = 0 |
|
| 655 |
if host == '': |
|
| 656 |
host = None |
|
| 657 |
if connect and not (port or unix_socket): |
|
| 658 |
raise Exception("Connect mode requires a port")
|
|
| 659 |
if use_ssl and not ssl: |
|
| 660 |
raise Exception("SSL socket requested but Python SSL module not loaded.");
|
|
| 661 |
if not connect and use_ssl: |
|
| 662 |
raise Exception("SSL only supported in connect mode (for now)")
|
|
| 663 |
if not connect: |
|
| 664 |
flags = flags | socket.AI_PASSIVE |
|
| 665 |
|
|
| 666 |
if not unix_socket: |
|
| 667 |
addrs = socket.getaddrinfo(host, port, 0, socket.SOCK_STREAM, |
|
| 668 |
socket.IPPROTO_TCP, flags) |
|
| 669 |
if not addrs: |
|
| 670 |
raise Exception("Could not resolve host '%s'" % host)
|
|
| 671 |
addrs.sort(key=lambda x: x[0]) |
|
| 672 |
if prefer_ipv6: |
|
| 673 |
addrs.reverse() |
|
| 674 |
sock = socket.socket(addrs[0][0], addrs[0][1]) |
|
| 675 |
|
|
| 676 |
if tcp_keepalive: |
|
| 677 |
sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1) |
|
| 678 |
if tcp_keepcnt: |
|
| 679 |
sock.setsockopt(socket.SOL_TCP, socket.TCP_KEEPCNT, |
|
| 680 |
tcp_keepcnt) |
|
| 681 |
if tcp_keepidle: |
|
| 682 |
sock.setsockopt(socket.SOL_TCP, socket.TCP_KEEPIDLE, |
|
| 683 |
tcp_keepidle) |
|
| 684 |
if tcp_keepintvl: |
|
| 685 |
sock.setsockopt(socket.SOL_TCP, socket.TCP_KEEPINTVL, |
|
| 686 |
tcp_keepintvl) |
|
| 687 |
|
|
| 688 |
if connect: |
|
| 689 |
sock.connect(addrs[0][4]) |
|
| 690 |
if use_ssl: |
|
| 691 |
sock = ssl.wrap_socket(sock) |
|
| 634 | 692 |
else: |
| 635 |
self.msg("Warning: client does not report 'base64' protocol support")
|
|
| 636 |
response += "\r\n" + trailer |
|
| 693 |
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) |
|
| 694 |
sock.bind(addrs[0][4]) |
|
| 695 |
sock.listen(100) |
|
| 696 |
else: |
|
| 697 |
sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) |
|
| 698 |
sock.connect(unix_socket) |
|
| 699 |
|
|
| 700 |
return sock |
|
| 637 | 701 |
|
| 638 |
return response |
|
| 702 |
@staticmethod |
|
| 703 |
def daemonize(keepfd=None, chdir='/'): |
|
| 704 |
os.umask(0) |
|
| 705 |
if chdir: |
|
| 706 |
os.chdir(chdir) |
|
| 707 |
else: |
|
| 708 |
os.chdir('/')
|
|
| 709 |
os.setgid(os.getgid()) # relinquish elevations |
|
| 710 |
os.setuid(os.getuid()) # relinquish elevations |
|
| 639 | 711 |
|
| 712 |
# Double fork to daemonize |
|
| 713 |
if os.fork() > 0: os._exit(0) # Parent exits |
|
| 714 |
os.setsid() # Obtain new process group |
|
| 715 |
if os.fork() > 0: os._exit(0) # Parent exits |
|
| 716 |
|
|
| 717 |
# Signal handling |
|
| 718 |
signal.signal(signal.SIGTERM, signal.SIG_IGN) |
|
| 719 |
signal.signal(signal.SIGINT, signal.SIG_IGN) |
|
| 720 |
|
|
| 721 |
# Close open files |
|
| 722 |
maxfd = resource.getrlimit(resource.RLIMIT_NOFILE)[1] |
|
| 723 |
if maxfd == resource.RLIM_INFINITY: maxfd = 256 |
|
| 724 |
for fd in reversed(range(maxfd)): |
|
| 725 |
try: |
|
| 726 |
if fd != keepfd: |
|
| 727 |
os.close(fd) |
|
| 728 |
except OSError: |
|
| 729 |
_, exc, _ = sys.exc_info() |
|
| 730 |
if exc.errno != errno.EBADF: raise |
|
| 731 |
|
|
| 732 |
# Redirect I/O to /dev/null |
|
| 733 |
os.dup2(os.open(os.devnull, os.O_RDWR), sys.stdin.fileno()) |
|
| 734 |
os.dup2(os.open(os.devnull, os.O_RDWR), sys.stdout.fileno()) |
|
| 735 |
os.dup2(os.open(os.devnull, os.O_RDWR), sys.stderr.fileno()) |
|
| 640 | 736 |
|
| 641 | 737 |
def do_handshake(self, sock, address): |
| 642 | 738 |
""" |
| ... | ... | |
| 655 | 751 |
- Send a WebSockets handshake server response. |
| 656 | 752 |
- Return the socket for this WebSocket client. |
| 657 | 753 |
""" |
| 658 |
stype = "" |
|
| 659 | 754 |
ready = select.select([sock], [], [], 3)[0] |
| 660 | 755 |
|
| 661 | 756 |
|
| ... | ... | |
| 699 | 794 |
else: |
| 700 | 795 |
raise |
| 701 | 796 |
|
| 702 |
self.scheme = "wss" |
|
| 703 |
stype = "SSL/TLS (wss://)" |
|
| 704 |
|
|
| 705 | 797 |
elif self.ssl_only: |
| 706 | 798 |
raise self.EClose("non-SSL connection received but disallowed")
|
| 707 | 799 |
|
| 708 | 800 |
else: |
| 709 | 801 |
retsock = sock |
| 710 |
self.scheme = "ws" |
|
| 711 |
stype = "Plain non-SSL (ws://)" |
|
| 712 | 802 |
|
| 713 |
wsh = WSRequestHandler(retsock, address, not self.web) |
|
| 714 |
if wsh.last_code == 101: |
|
| 715 |
# Continue on to handle WebSocket upgrade |
|
| 716 |
pass |
|
| 717 |
elif wsh.last_code == 405: |
|
| 718 |
raise self.EClose("Normal web request received but disallowed")
|
|
| 719 |
elif wsh.last_code < 200 or wsh.last_code >= 300: |
|
| 720 |
raise self.EClose(wsh.last_message) |
|
| 721 |
elif self.verbose: |
|
| 722 |
raise self.EClose(wsh.last_message) |
|
| 723 |
else: |
|
| 724 |
raise self.EClose("")
|
|
| 803 |
# If the address is like (host, port), we are extending it |
|
| 804 |
# with a flag indicating SSL. Not many other options |
|
| 805 |
# available... |
|
| 806 |
if len(address) == 2: |
|
| 807 |
address = (address[0], address[1], (retsock != sock)) |
|
| 725 | 808 |
|
| 726 |
response = self.do_websocket_handshake(wsh.headers, wsh.path)
|
|
| 809 |
self.RequestHandlerClass(retsock, address, self)
|
|
| 727 | 810 |
|
| 728 |
self.msg("%s: %s WebSocket connection" % (address[0], stype))
|
|
| 729 |
self.msg("%s: Version %s, base64: '%s'" % (address[0],
|
|
| 730 |
self.version, self.base64)) |
|
| 731 |
if self.path != '/': |
|
| 732 |
self.msg("%s: Path: '%s'" % (address[0], self.path))
|
|
| 811 |
# Return the WebSockets socket which may be SSL wrapped |
|
| 812 |
return retsock |
|
| 733 | 813 |
|
| 814 |
# |
|
| 815 |
# WebSocketServer logging/output functions |
|
| 816 |
# |
|
| 734 | 817 |
|
| 735 |
# Send server WebSockets handshake response
|
|
| 736 |
#self.msg("sending response [%s]" % response)
|
|
| 737 |
retsock.send(s2b(response))
|
|
| 818 |
def msg(self, *args, **kwargs):
|
|
| 819 |
""" Output message as info """
|
|
| 820 |
self.logger.log(logging.INFO, *args, **kwargs)
|
|
| 738 | 821 |
|
| 739 |
# Return the WebSockets socket which may be SSL wrapped |
|
| 740 |
return retsock |
|
| 822 |
def vmsg(self, *args, **kwargs): |
|
| 823 |
""" Same as msg() but as debug. """ |
|
| 824 |
self.logger.log(logging.DEBUG, *args, **kwargs) |
|
| 825 |
|
|
| 826 |
def warn(self, *args, **kwargs): |
|
| 827 |
""" Same as msg() but as warning. """ |
|
| 828 |
self.logger.log(logging.WARN, *args, **kwargs) |
|
| 741 | 829 |
|
| 742 | 830 |
|
| 743 | 831 |
# |
| ... | ... | |
| 752 | 840 |
#self.vmsg("Running poll()")
|
| 753 | 841 |
pass |
| 754 | 842 |
|
| 843 |
def terminate(self): |
|
| 844 |
raise self.Terminate() |
|
| 845 |
|
|
| 846 |
def multiprocessing_SIGCHLD(self, sig, stack): |
|
| 847 |
self.vmsg('Reaping zombies, active child count is %s', len(multiprocessing.active_children()))
|
|
| 848 |
|
|
| 755 | 849 |
def fallback_SIGCHLD(self, sig, stack): |
| 756 | 850 |
# Reap zombies when using os.fork() (python 2.4) |
| 757 | 851 |
self.vmsg("Got SIGCHLD, reaping zombies")
|
| ... | ... | |
| 765 | 859 |
|
| 766 | 860 |
def do_SIGINT(self, sig, stack): |
| 767 | 861 |
self.msg("Got SIGINT, exiting")
|
| 768 |
sys.exit(0) |
|
| 862 |
self.terminate() |
|
| 863 |
|
|
| 864 |
def do_SIGTERM(self, sig, stack): |
|
| 865 |
self.msg("Got SIGTERM, exiting")
|
|
| 866 |
self.terminate() |
|
| 769 | 867 |
|
| 770 | 868 |
def top_new_client(self, startsock, address): |
| 771 | 869 |
""" Do something with a WebSockets client connection. """ |
| 772 |
# Initialize per client settings |
|
| 773 |
self.send_parts = [] |
|
| 774 |
self.recv_part = None |
|
| 775 |
self.base64 = False |
|
| 776 |
self.rec = None |
|
| 777 |
self.start_time = int(time.time()*1000) |
|
| 778 |
|
|
| 779 | 870 |
# handler process |
| 871 |
client = None |
|
| 780 | 872 |
try: |
| 781 | 873 |
try: |
| 782 |
self.client = self.do_handshake(startsock, address) |
|
| 783 |
|
|
| 784 |
if self.record: |
|
| 785 |
# Record raw frame data as JavaScript array |
|
| 786 |
fname = "%s.%s" % (self.record, |
|
| 787 |
self.handler_id) |
|
| 788 |
self.msg("opening record file: %s" % fname)
|
|
| 789 |
self.rec = open(fname, 'w+') |
|
| 790 |
encoding = "binary" |
|
| 791 |
if self.base64: encoding = "base64" |
|
| 792 |
self.rec.write("var VNC_frame_encoding = '%s';\n"
|
|
| 793 |
% encoding) |
|
| 794 |
self.rec.write("var VNC_frame_data = [\n")
|
|
| 795 |
|
|
| 796 |
self.ws_connection = True |
|
| 797 |
self.new_client() |
|
| 798 |
except self.CClose: |
|
| 799 |
# Close the client |
|
| 800 |
_, exc, _ = sys.exc_info() |
|
| 801 |
if self.client: |
|
| 802 |
self.send_close(exc.args[0], exc.args[1]) |
|
| 874 |
client = self.do_handshake(startsock, address) |
|
| 803 | 875 |
except self.EClose: |
| 804 | 876 |
_, exc, _ = sys.exc_info() |
| 805 | 877 |
# Connection was not a WebSockets connection |
| 806 | 878 |
if exc.args[0]: |
| 807 | 879 |
self.msg("%s: %s" % (address[0], exc.args[0]))
|
| 880 |
except WebSocketServer.Terminate: |
|
| 881 |
raise |
|
| 808 | 882 |
except Exception: |
| 809 | 883 |
_, exc, _ = sys.exc_info() |
| 810 | 884 |
self.msg("handler exception: %s" % str(exc))
|
| 811 |
if self.verbose: |
|
| 812 |
self.msg(traceback.format_exc()) |
|
| 885 |
self.vmsg("exception", exc_info=True)
|
|
| 813 | 886 |
finally: |
| 814 |
if self.rec: |
|
| 815 |
self.rec.write("'EOF'];\n")
|
|
| 816 |
self.rec.close() |
|
| 817 | 887 |
|
| 818 |
if self.client and self.client != startsock:
|
|
| 888 |
if client and client != startsock:
|
|
| 819 | 889 |
# Close the SSL wrapped socket |
| 820 | 890 |
# Original socket closed by caller |
| 821 |
self.client.close() |
|
| 822 |
|
|
| 823 |
def new_client(self): |
|
| 824 |
""" Do something with a WebSockets client connection. """ |
|
| 825 |
raise("WebSocketServer.new_client() must be overloaded")
|
|
| 891 |
client.close() |
|
| 826 | 892 |
|
| 827 | 893 |
def start_server(self): |
| 828 | 894 |
""" |
| 829 | 895 |
Daemonize if requested. Listen for for connections. Run |
| 830 | 896 |
do_handshake() method for each connection. If the connection |
| 831 |
is a WebSockets client then call new_client() method (which must |
|
| 897 |
is a WebSockets client then call new_websocket_client() method (which must
|
|
| 832 | 898 |
be overridden) for each new client connection. |
| 833 | 899 |
""" |
| 834 |
lsock = self.socket(self.listen_host, self.listen_port, False, self.prefer_ipv6) |
|
| 900 |
lsock = self.socket(self.listen_host, self.listen_port, False, |
|
| 901 |
self.prefer_ipv6, |
|
| 902 |
tcp_keepalive=self.tcp_keepalive, |
|
| 903 |
tcp_keepcnt=self.tcp_keepcnt, |
|
| 904 |
tcp_keepidle=self.tcp_keepidle, |
|
| 905 |
tcp_keepintvl=self.tcp_keepintvl) |
|
| 835 | 906 |
|
| 836 | 907 |
if self.daemon: |
| 837 | 908 |
self.daemonize(keepfd=lsock.fileno(), chdir=self.web) |
| 838 | 909 |
|
| 839 | 910 |
self.started() # Some things need to happen after daemonizing |
| 840 | 911 |
|
| 841 |
# Allow override of SIGINT |
|
| 912 |
# Allow override of signals |
|
| 913 |
original_signals = {
|
|
| 914 |
signal.SIGINT: signal.getsignal(signal.SIGINT), |
|
| 915 |
signal.SIGTERM: signal.getsignal(signal.SIGTERM), |
|
| 916 |
signal.SIGCHLD: signal.getsignal(signal.SIGCHLD), |
|
| 917 |
} |
|
| 842 | 918 |
signal.signal(signal.SIGINT, self.do_SIGINT) |
| 919 |
signal.signal(signal.SIGTERM, self.do_SIGTERM) |
|
| 843 | 920 |
if not multiprocessing: |
| 844 | 921 |
# os.fork() (python 2.4) child reaper |
| 845 | 922 |
signal.signal(signal.SIGCHLD, self.fallback_SIGCHLD) |
| 923 |
else: |
|
| 924 |
# make sure that _cleanup is called when children die |
|
| 925 |
# by calling active_children on SIGCHLD |
|
| 926 |
signal.signal(signal.SIGCHLD, self.multiprocessing_SIGCHLD) |
|
| 846 | 927 |
|
| 847 | 928 |
last_active_time = self.launch_time |
| 848 |
while True:
|
|
| 849 |
try:
|
|
| 929 |
try:
|
|
| 930 |
while True:
|
|
| 850 | 931 |
try: |
| 851 |
self.client = None |
|
| 852 |
startsock = None |
|
| 853 |
pid = err = 0 |
|
| 854 |
child_count = 0 |
|
| 855 |
|
|
| 856 |
if multiprocessing and self.idle_timeout: |
|
| 857 |
child_count = len(multiprocessing.active_children()) |
|
| 858 |
|
|
| 859 |
time_elapsed = time.time() - self.launch_time |
|
| 860 |
if self.timeout and time_elapsed > self.timeout: |
|
| 861 |
self.msg('listener exit due to --timeout %s'
|
|
| 862 |
% self.timeout) |
|
| 863 |
break |
|
| 864 |
|
|
| 865 |
if self.idle_timeout: |
|
| 866 |
idle_time = 0 |
|
| 867 |
if child_count == 0: |
|
| 868 |
idle_time = time.time() - last_active_time |
|
| 869 |
else: |
|
| 870 |
idle_time = 0 |
|
| 871 |
last_active_time = time.time() |
|
| 872 |
|
|
| 873 |
if idle_time > self.idle_timeout and child_count == 0: |
|
| 874 |
self.msg('listener exit due to --idle-timeout %s'
|
|
| 875 |
% self.idle_timeout) |
|
| 876 |
break |
|
| 877 |
|
|
| 878 | 932 |
try: |
| 879 |
self.poll() |
|
| 933 |
startsock = None |
|
| 934 |
pid = err = 0 |
|
| 935 |
child_count = 0 |
|
| 936 |
|
|
| 937 |
if multiprocessing: |
|
| 938 |
# Collect zombie child processes |
|
| 939 |
child_count = len(multiprocessing.active_children()) |
|
| 940 |
|
|
| 941 |
time_elapsed = time.time() - self.launch_time |
|
| 942 |
if self.timeout and time_elapsed > self.timeout: |
|
| 943 |
self.msg('listener exit due to --timeout %s'
|
|
| 944 |
% self.timeout) |
|
| 945 |
break |
|
| 880 | 946 |
|
| 881 |
ready = select.select([lsock], [], [], 1)[0] |
|
| 882 |
if lsock in ready: |
|
| 883 |
startsock, address = lsock.accept() |
|
| 884 |
else: |
|
| 885 |
continue |
|
| 886 |
except Exception: |
|
| 887 |
_, exc, _ = sys.exc_info() |
|
| 888 |
if hasattr(exc, 'errno'): |
|
| 889 |
err = exc.errno |
|
| 890 |
elif hasattr(exc, 'args'): |
|
| 891 |
err = exc.args[0] |
|
| 892 |
else: |
|
| 893 |
err = exc[0] |
|
| 894 |
if err == errno.EINTR: |
|
| 895 |
self.vmsg("Ignoring interrupted syscall")
|
|
| 896 |
continue |
|
| 897 |
else: |
|
| 947 |
if self.idle_timeout: |
|
| 948 |
idle_time = 0 |
|
| 949 |
if child_count == 0: |
|
| 950 |
idle_time = time.time() - last_active_time |
|
| 951 |
else: |
|
| 952 |
idle_time = 0 |
|
| 953 |
last_active_time = time.time() |
|
| 954 |
|
|
| 955 |
if idle_time > self.idle_timeout and child_count == 0: |
|
| 956 |
self.msg('listener exit due to --idle-timeout %s'
|
|
| 957 |
% self.idle_timeout) |
|
| 958 |
break |
|
| 959 |
|
|
| 960 |
try: |
|
| 961 |
self.poll() |
|
| 962 |
|
|
| 963 |
ready = select.select([lsock], [], [], 1)[0] |
|
| 964 |
if lsock in ready: |
|
| 965 |
startsock, address = lsock.accept() |
|
| 966 |
else: |
|
| 967 |
continue |
|
| 968 |
except self.Terminate: |
|
| 898 | 969 |
raise |
| 899 |
|
|
| 900 |
if self.run_once: |
|
| 901 |
# Run in same process if run_once |
|
| 902 |
self.top_new_client(startsock, address) |
|
| 903 |
if self.ws_connection : |
|
| 904 |
self.msg('%s: exiting due to --run-once'
|
|
| 905 |
% address[0]) |
|
| 906 |
break |
|
| 907 |
elif multiprocessing: |
|
| 908 |
self.vmsg('%s: new handler Process' % address[0])
|
|
| 909 |
p = multiprocessing.Process( |
|
| 910 |
target=self.top_new_client, |
|
| 911 |
args=(startsock, address)) |
|
| 912 |
p.start() |
|
| 913 |
# child will not return |
|
| 914 |
else: |
|
| 915 |
# python 2.4 |
|
| 916 |
self.vmsg('%s: forking handler' % address[0])
|
|
| 917 |
pid = os.fork() |
|
| 918 |
if pid == 0: |
|
| 919 |
# child handler process |
|
| 970 |
except Exception: |
|
| 971 |
_, exc, _ = sys.exc_info() |
|
| 972 |
if hasattr(exc, 'errno'): |
|
| 973 |
err = exc.errno |
|
| 974 |
elif hasattr(exc, 'args'): |
|
| 975 |
err = exc.args[0] |
|
| 976 |
else: |
|
| 977 |
err = exc[0] |
|
| 978 |
if err == errno.EINTR: |
|
| 979 |
self.vmsg("Ignoring interrupted syscall")
|
|
| 980 |
continue |
|
| 981 |
else: |
|
| 982 |
raise |
|
| 983 |
|
|
| 984 |
if self.run_once: |
|
| 985 |
# Run in same process if run_once |
|
| 920 | 986 |
self.top_new_client(startsock, address) |
| 921 |
break # child process exits |
|
| 922 |
|
|
| 923 |
# parent process |
|
| 924 |
self.handler_id += 1 |
|
| 925 |
|
|
| 926 |
except KeyboardInterrupt: |
|
| 927 |
_, exc, _ = sys.exc_info() |
|
| 928 |
print("In KeyboardInterrupt")
|
|
| 929 |
pass |
|
| 930 |
except SystemExit: |
|
| 931 |
_, exc, _ = sys.exc_info() |
|
| 932 |
print("In SystemExit")
|
|
| 933 |
break |
|
| 934 |
except Exception: |
|
| 935 |
_, exc, _ = sys.exc_info() |
|
| 936 |
self.msg("handler exception: %s" % str(exc))
|
|
| 937 |
if self.verbose: |
|
| 938 |
self.msg(traceback.format_exc()) |
|
| 939 |
|
|
| 940 |
finally: |
|
| 941 |
if startsock: |
|
| 942 |
startsock.close() |
|
| 943 |
|
|
| 987 |
if self.ws_connection : |
|
| 988 |
self.msg('%s: exiting due to --run-once'
|
|
| 989 |
% address[0]) |
|
| 990 |
break |
|
| 991 |
elif multiprocessing: |
|
| 992 |
self.vmsg('%s: new handler Process' % address[0])
|
|
| 993 |
p = multiprocessing.Process( |
|
| 994 |
target=self.top_new_client, |
|
| 995 |
args=(startsock, address)) |
|
| 996 |
p.start() |
|
| 997 |
# child will not return |
|
| 998 |
else: |
|
| 999 |
# python 2.4 |
|
| 1000 |
self.vmsg('%s: forking handler' % address[0])
|
|
| 1001 |
pid = os.fork() |
|
| 1002 |
if pid == 0: |
|
| 1003 |
# child handler process |
|
| 1004 |
self.top_new_client(startsock, address) |
|
| 1005 |
break # child process exits |
|
| 1006 |
|
|
| 1007 |
# parent process |
|
| 1008 |
self.handler_id += 1 |
|
| 1009 |
|
|
| 1010 |
except (self.Terminate, SystemExit, KeyboardInterrupt): |
|
| 1011 |
self.msg("In exit")
|
|
| 1012 |
break |
|
| 1013 |
except Exception: |
|
| 1014 |
self.msg("handler exception: %s", str(exc))
|
|
| 1015 |
self.vmsg("exception", exc_info=True)
|
|
| 944 | 1016 |
|
| 945 |
# HTTP handler with WebSocket upgrade support |
|
| 946 |
class WSRequestHandler(SimpleHTTPRequestHandler): |
|
| 947 |
def __init__(self, req, addr, only_upgrade=False): |
|
| 948 |
self.only_upgrade = only_upgrade # only allow upgrades |
|
| 949 |
SimpleHTTPRequestHandler.__init__(self, req, addr, object()) |
|
| 1017 |
finally: |
|
| 1018 |
if startsock: |
|
| 1019 |
startsock.close() |
|
| 1020 |
finally: |
|
| 1021 |
# Close listen port |
|
| 1022 |
self.vmsg("Closing socket listening at %s:%s",
|
|
| 1023 |
self.listen_host, self.listen_port) |
|
| 1024 |
lsock.close() |
|
| 950 | 1025 |
|
| 951 |
def do_GET(self): |
|
| 952 |
if (self.headers.get('upgrade') and
|
|
| 953 |
self.headers.get('upgrade').lower() == 'websocket'):
|
|
| 954 |
|
|
| 955 |
if (self.headers.get('sec-websocket-key1') or
|
|
| 956 |
self.headers.get('websocket-key1')):
|
|
| 957 |
# For Hixie-76 read out the key hash |
|
| 958 |
self.headers.__setitem__('key3', self.rfile.read(8))
|
|
| 959 |
|
|
| 960 |
# Just indicate that an WebSocket upgrade is needed |
|
| 961 |
self.last_code = 101 |
|
| 962 |
self.last_message = "101 Switching Protocols" |
|
| 963 |
elif self.only_upgrade: |
|
| 964 |
# Normal web request responses are disabled |
|
| 965 |
self.last_code = 405 |
|
| 966 |
self.last_message = "405 Method Not Allowed" |
|
| 967 |
else: |
|
| 968 |
SimpleHTTPRequestHandler.do_GET(self) |
|
| 1026 |
# Restore signals |
|
| 1027 |
for sig, func in original_signals.items(): |
|
| 1028 |
signal.signal(sig, func) |
|
| 969 | 1029 |
|
| 970 |
def send_response(self, code, message=None): |
|
| 971 |
# Save the status code |
|
| 972 |
self.last_code = code |
|
| 973 |
SimpleHTTPRequestHandler.send_response(self, code, message) |
|
| 974 | 1030 |
|
| 975 |
def log_message(self, f, *args): |
|
| 976 |
# Save instead of printing |
|
| 977 |
self.last_message = f % args |
|
Also available in: Unified diff