def process_handshake_header(self, headers):
protocols = []
extensions = []
headers = headers.strip()
for header_line in headers.split(enc('\r\n')):
header, value = header_line.split(enc(':'), 1)
header = header.strip().lower()
value = value.strip().lower()
if header == 'upgrade' and value != 'websocket':
raise HandshakeError("Invalid Upgrade header: %s" % value)
elif header == 'connection' and value != 'upgrade':
raise HandshakeError("Invalid Connection header: %s" % value)
elif header == 'sec-websocket-accept':
match = b64encode(sha1(enc(self.key + WS_KEY)).digest())
if value != match.lower():
raise HandshakeError("Invalid challenge response: %s" % value)
elif header == 'sec-websocket-protocol':
protocols = ','.join(value)
elif header == 'sec-websocket-extensions':
extensions = ','.join(value)
return protocols, extensions
def process_handshake_header(self, headers):
"""
Read the upgrade handshake's response headers and
validate them against :rfc:`6455`.
"""
protocols = []
extensions = []
headers = headers.strip()
for header_line in headers.split(enc('\r\n')):
header, value = header_line.split(enc(':'), 1)
header = header.strip().lower()
value = value.strip().lower()
if header == 'upgrade' and value != 'websocket':
raise HandshakeError("Invalid Upgrade header: %s" % value)
elif header == 'connection' and value != 'upgrade':
raise HandshakeError("Invalid Connection header: %s" % value)
elif header == 'sec-websocket-accept':
match = b64encode(sha1(enc(self.key + WS_KEY)).digest())
if value != match.lower():
raise HandshakeError("Invalid challenge response: %s" %
value)
elif header == 'sec-websocket-protocol':
protocols = ','.join(value)
elif header == 'sec-websocket-extensions':
extensions = ','.join(value)
return protocols, extensions
def build(self):
"""
Builds a frame from the instance's attributes and returns
its bytes representation.
"""
header = enc('')
if self.fin > 0x1:
raise ValueError('FIN bit parameter must be 0 or 1')
if 0x3 <= self.opcode <= 0x7 or 0xB <= self.opcode:
raise ValueError('Opcode cannot be a reserved opcode')
## +-+-+-+-+-------+
## |F|R|R|R| opcode|
## |I|S|S|S| (4) |
## |N|V|V|V| |
## | |1|2|3| |
## +-+-+-+-+-------+
header = pack('!B', ((self.fin << 7)
| (self.rsv1 << 6)
| (self.rsv2 << 5)
| (self.rsv3 << 4)
| self.opcode))
## +-+-------------+-------------------------------+
## |M| Payload len | Extended payload length |
## |A| (7) | (16/63) |
## |S| | (if payload len==126/127) |
## |K| | |
## +-+-+-+-+-------+-+-------------+ - - - - - - - - - - - - - - - +
## | Extended payload length continued, if payload len == 127 |
## + - - - - - - - - - - - - - - - +-------------------------------+
if self.masking_key: mask_bit = 1 << 7
else: mask_bit = 0
length = self.payload_length
if length < 126:
header += pack('!B', (mask_bit | length))
elif length < (1 << 16):
header += pack('!B', (mask_bit | 126)) + pack('!H', length)
elif length < (1 << 63):
header += pack('!B', (mask_bit | 127)) + pack('!Q', length)
else:
raise FrameTooLargeException()
## + - - - - - - - - - - - - - - - +-------------------------------+
## | |Masking-key, if MASK set to 1 |
## +-------------------------------+-------------------------------+
## | Masking-key (continued) | Payload Data |
## +-------------------------------- - - - - - - - - - - - - - - - +
## : Payload Data continued ... :
## + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
## | Payload Data continued ... |
## +---------------------------------------------------------------+
if not self.masking_key:
return header + enc(self.body)
return header + self.masking_key + self.mask(enc(self.body))
def build(self):
"""
Builds a frame from the instance's attributes and returns
its bytes representation.
"""
header = enc('')
if self.fin > 0x1:
raise ValueError('FIN bit parameter must be 0 or 1')
if 0x3 <= self.opcode <= 0x7 or 0xB <= self.opcode:
raise ValueError('Opcode cannot be a reserved opcode')
## +-+-+-+-+-------+
## |F|R|R|R| opcode|
## |I|S|S|S| (4) |
## |N|V|V|V| |
## | |1|2|3| |
## +-+-+-+-+-------+
header = pack('!B', ((self.fin << 7)
| (self.rsv1 << 6)
| (self.rsv2 << 5)
| (self.rsv3 << 4)
| self.opcode))
## +-+-------------+-------------------------------+
## |M| Payload len | Extended payload length |
## |A| (7) | (16/63) |
## |S| | (if payload len==126/127) |
## |K| | |
## +-+-+-+-+-------+-+-------------+ - - - - - - - - - - - - - - - +
## | Extended payload length continued, if payload len == 127 |
## + - - - - - - - - - - - - - - - +-------------------------------+
if self.masking_key: mask_bit = 1 << 7
else: mask_bit = 0
length = self.payload_length
if length < 126:
header += pack('!B', (mask_bit | length))
elif length < (1 << 16):
header += pack('!B', (mask_bit | 126)) + pack('!H', length)
elif length < (1 << 63):
header += pack('!B', (mask_bit | 127)) + pack('!Q', length)
else:
raise FrameTooLargeException()
## + - - - - - - - - - - - - - - - +-------------------------------+
## | |Masking-key, if MASK set to 1 |
## +-------------------------------+-------------------------------+
## | Masking-key (continued) | Payload Data |
## +-------------------------------- - - - - - - - - - - - - - - - +
## : Payload Data continued ... :
## + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
## | Payload Data continued ... |
## +---------------------------------------------------------------+
if not self.masking_key:
return header + enc(self.body)
return header + self.masking_key + self.mask(enc(self.body))
def process_response_line(self, response_line):
"""
Ensure that we received a HTTP `101` status code in
response to our request and if not raises :exc:`HandshakeError`.
"""
protocol, code, status = response_line.split(enc(' '), 2)
if code != enc('101'):
raise HandshakeError("Invalid response status: %s %s" % (code, status))
def process_response_line(self, response_line):
"""
Ensure that we received a HTTP `101` status code in
response to our request and if not raises :exc:`HandshakeError`.
"""
protocol, code, status = response_line.split(enc(' '), 2)
if code != enc('101'):
raise HandshakeError("Invalid response status: %s %s" %
(code, status))
def __init__(self, code=1000, reason=''):
data = enc("")
if code:
data += struct.pack("!H", code)
if reason:
data += enc(reason, 'utf-8')
Message.__init__(self, OPCODE_CLOSE, data, 'utf-8')
self.code = code
self.reason = enc(reason, self.encoding)
def __init__(self, code=1000, reason=''):
data = enc("")
if code:
data += struct.pack("!H", code)
if reason:
data += enc(reason, 'utf-8')
Message.__init__(self, OPCODE_CLOSE, data, 'utf-8')
self.code = code
self.reason = enc(reason, self.encoding)
def handshake_request(self):
headers = self.handshake_headers
request = ["GET %s HTTP/1.1" % self.resource]
for header, value in headers:
request.append("%s: %s" % (header, value))
request.append('\r\n')
return enc('\r\n'.join(request))
def handshake_request(self):
headers = self.handshake_headers
request = ["GET %s HTTP/1.1" % self.resource]
for header, value in headers:
request.append("%s: %s" % (header, value))
request.append('\r\n')
return enc('\r\n'.join(request))
def handshake_request(self):
"""
Prepare the request to be sent for the upgrade handshake.
"""
headers = self.handshake_headers
request = ["GET %s HTTP/1.1" % self.resource]
for header, value in headers:
request.append("%s: %s" % (header, value))
request.append('\r\n')
return enc('\r\n'.join(request))
def handshake_request(self):
"""
Prepare the request to be sent for the upgrade handshake.
"""
headers = self.handshake_headers
request = ["GET %s HTTP/1.1" % self.resource]
for header, value in headers:
request.append("%s: %s" % (header, value))
request.append('\r\n')
return enc('\r\n'.join(request))
def connect(self):
"""
Connects this websocket and starts the upgrade handshake
with the remote endpoint.
"""
if self.scheme == "wss":
# default port is now 443; upgrade self.sender to send ssl
self.sock = ssl.wrap_socket(self.sock)
self.sock.connect((self.host, self.port))
self._write(self.handshake_request)
response = enc('')
doubleCLRF = enc('\r\n\r\n')
while True:
bytes = self.sock.recv(128)
if not bytes:
break
response += bytes
if doubleCLRF in response:
break
if not response:
self.close_connection()
raise HandshakeError("Invalid response")
headers, _, body = response.partition(doubleCLRF)
response_line, _, headers = headers.partition(enc('\r\n'))
try:
self.process_response_line(response_line)
self.protocols, self.extensions = self.process_handshake_header(
headers)
except HandshakeError:
self.close_connection()
raise
self.handshake_ok()
if body:
self.process(body)
def connect(self):
#self.sock.settimeout(3)
if self.scheme == "wss":
self.ssl_options = {"server_hostname": self.host}
# default port is now 443; upgrade self.sender to send ssl
self.sock = ssl.SSLSocket(self.sock, **self.ssl_options)
# self.sock = ssl.wrap_socket(self.sock) # altered by tectract
self.sender = self.sock.sendall
self.sock.connect((self.host, int(self.port)))
self.sender(self.handshake_request)
response = enc('')
doubleCLRF = enc('\r\n\r\n')
while True:
bytes = self.sock.recv(128)
if not bytes:
break
response += bytes
if doubleCLRF in response:
break
if not response:
self.close_connection()
raise HandshakeError("Invalid response")
headers, _, body = response.partition(doubleCLRF)
response_line, _, headers = headers.partition(enc('\r\n'))
try:
self.process_response_line(response_line)
self.protocols, self.extensions = self.process_handshake_header(
headers)
except HandshakeError:
self.close_connection()
raise
self.handshake_ok()
if body:
self.process(body)
def connect(self):
"""
Connects this websocket and starts the upgrade handshake
with the remote endpoint.
"""
if self.scheme == "wss":
# default port is now 443; upgrade self.sender to send ssl
self.sock = ssl.wrap_socket(self.sock)
self.sock.connect((self.host, int(self.port)))
self.sock.sendall(self.handshake_request)
response = enc('')
doubleCLRF = enc('\r\n\r\n')
while True:
bytes = self.sock.recv(128)
if not bytes:
break
response += bytes
if doubleCLRF in response:
break
if not response:
self.close_connection()
raise HandshakeError("Invalid response")
headers, _, body = response.partition(doubleCLRF)
response_line, _, headers = headers.partition(enc('\r\n'))
try:
self.process_response_line(response_line)
self.protocols, self.extensions = self.process_handshake_header(headers)
except HandshakeError:
self.close_connection()
raise
self.handshake_ok()
if body:
self.process(body)
def __init__(self, opcode, data='', encoding='utf-8'):
"""
A message is a application level entity. It's usually built
from one or many frames. The protocol defines several kind
of messages which are grouped into two sets:
* data messages which can be text or binary typed
* control messages which provide a mechanism to perform
in-band control communication between peers
The ``opcode`` indicates the message type and ``data`` is
the possible message payload.
The payload is held internally as a a :func:`bytearray` as they are
faster than pure strings for append operations.
Unicode data will be encoded using the provided ``encoding``.
"""
self.opcode = opcode
self._completed = False
self.encoding = encoding
self.data = enc(data, encoding)
def __init__(self, opcode, data='', encoding='utf-8'):
"""
A message is a application level entity. It's usually built
from one or many frames. The protocol defines several kind
of messages which are grouped into two sets:
* data messages which can be text or binary typed
* control messages which provide a mechanism to perform
in-band control communication between peers
The ``opcode`` indicates the message type and ``data`` is
the possible message payload.
The payload is held internally as a a :func:`bytearray` as they are
faster than pure strings for append operations.
Unicode data will be encoded using the provided ``encoding``.
"""
self.opcode = opcode
self._completed = False
self.encoding = encoding
self.data = enc(data, encoding)
def __call__(self, environ, start_response):
if environ.get('REQUEST_METHOD') != 'GET':
raise HandshakeError('HTTP method must be a GET')
for key, expected_value in [('HTTP_UPGRADE', 'websocket'),
('HTTP_CONNECTION', 'upgrade')]:
actual_value = environ.get(key, '').lower()
if not actual_value:
raise HandshakeError('Header %s is not defined' % key)
if expected_value not in actual_value:
raise HandshakeError('Illegal value for header %s: %s' %
(key, actual_value))
key = environ.get('HTTP_SEC_WEBSOCKET_KEY')
if key:
ws_key = base64.b64decode(enc(key))
if len(ws_key) != 16:
raise HandshakeError("WebSocket key's length is invalid")
version = environ.get('HTTP_SEC_WEBSOCKET_VERSION')
supported_versions = ', '.join([str(v) for v in WS_VERSION])
version_is_valid = False
if version:
try: version = int(version)
except: pass
else: version_is_valid = version in WS_VERSION
if not version_is_valid:
environ['websocket.version'] = str(version)
raise HandshakeError('Unhandled or missing WebSocket version')
ws_protocols = []
protocols = self.protocols or []
subprotocols = environ.get('HTTP_SEC_WEBSOCKET_PROTOCOL')
if subprotocols:
for s in subprotocols.split(','):
s = s.strip()
if s in protocols:
ws_protocols.append(s)
ws_extensions = []
exts = self.extensions or []
extensions = environ.get('HTTP_SEC_WEBSOCKET_EXTENSIONS')
if extensions:
for ext in extensions.split(','):
ext = ext.strip()
if ext in exts:
ws_extensions.append(ext)
upgrade_headers = [
('Upgrade', 'websocket'),
('Connection', 'Upgrade'),
('Sec-WebSocket-Version', str(version)),
('Sec-WebSocket-Accept', base64.b64encode(sha1(key + WS_KEY).digest())),
]
if ws_protocols:
upgrade_headers.append(('Sec-WebSocket-Protocol', ', '.join(ws_protocols)))
if ws_extensions:
upgrade_headers.append(('Sec-WebSocket-Extensions', ','.join(ws_extensions)))
start_response("101 Switching Protocols", upgrade_headers)
self.make_websocket(environ['ws4py.socket'],
ws_protocols,
ws_extensions,
environ)
return []
def extend(self, data):
"""
Add more ``data`` to the message.
"""
self.data += enc(data, self.encoding)
def process_response_line(self, response_line):
protocol, code, status = response_line.split(enc(' '), 2)
if code != enc('101'):
raise HandshakeError("Invalid response status: %s %s" % (code, status))
def receiver(self):
"""
Parser that keeps trying to interpret bytes it is fed with as
incoming frames part of a message.
Control message are single frames only while data messages, like text
and binary, may be fragmented accross frames.
The way it works is by instanciating a :class:`wspy.framing.Frame` object,
then running its parser generator which yields how much bytes
it requires to performs its task. The stream parser yields this value
to its caller and feeds the frame parser.
When the frame parser raises :exc:`StopIteration`, the stream parser
tries to make sense of the parsed frame. It dispatches the frame's bytes
to the most appropriate message type based on the frame's opcode.
Overall this makes the stream parser totally agonstic to
the data provider.
"""
utf8validator = Utf8Validator()
running = True
frame = None
while running:
frame = Frame()
while 1:
try:
bytes = (yield next(frame.parser))
frame.parser.send(bytes)
except StopIteration:
frame._cleanup()
bytes = frame.body
# Let's avoid unmasking when there is no payload
if bytes:
if frame.masking_key and self.expect_masking:
bytes = frame.unmask(bytes)
elif not frame.masking_key and self.expect_masking:
msg = CloseControlMessage(code=1002, reason='Missing masking when expected')
self.errors.append(msg)
break
elif frame.masking_key and not self.expect_masking:
msg = CloseControlMessage(code=1002, reason='Masked when not expected')
self.errors.append(msg)
break
else:
bytes = bytearray(bytes)
if frame.opcode == OPCODE_TEXT:
if self.message and not self.message.completed:
# We got a text frame before we completed the previous one
msg = CloseControlMessage(code=1002, reason='Received a new message before completing previous')
self.errors.append(msg)
break
m = TextMessage(bytes)
m.completed = (frame.fin == 1)
self.message = m
if bytes:
is_valid, end_on_code_point, _, _ = utf8validator.validate(bytes)
if not is_valid or (m.completed and not end_on_code_point):
self.errors.append(CloseControlMessage(code=1007, reason='Invalid UTF-8 bytes'))
break
elif frame.opcode == OPCODE_BINARY:
m = BinaryMessage(bytes)
m.completed = (frame.fin == 1)
self.message = m
elif frame.opcode == OPCODE_CONTINUATION:
m = self.message
if m is None:
self.errors.append(CloseControlMessage(code=1002, reason='Message not started yet'))
break
m.extend(bytes)
m.completed = (frame.fin == 1)
if m.opcode == OPCODE_TEXT:
if bytes:
is_valid, end_on_code_point, _, _ = utf8validator.validate(bytes)
if not is_valid or (m.completed and not end_on_code_point):
self.errors.append(CloseControlMessage(code=1007, reason='Invalid UTF-8 bytes'))
break
elif frame.opcode == OPCODE_CLOSE:
code = 1000
reason = ""
if frame.payload_length == 0:
self.closing = CloseControlMessage(code=1000)
elif frame.payload_length == 1:
self.closing = CloseControlMessage(code=1002, reason='Payload has invalid length')
else:
try:
code = int(unpack("!H", enc(bytes[0:2]))[0])
except TypeError:
code = 1002
reason = 'Invalid Closing Frame Code Type'
except struct.error as sr:
code = 1002
reason = 'Failed at decoding closing code'
else:
# Those codes are reserved or plainly forbidden
if code not in VALID_CLOSING_CODES and not (2999 < code < 5000):
reason = 'Invalid Closing Frame Code: %d' % code
code = 1002
elif frame.payload_length > 1:
reason = bytes[2:] if frame.masking_key else bytearray(frame.body[2:])
is_valid, end_on_code_point, _, _ = utf8validator.validate(reason)
if not is_valid or not end_on_code_point:
self.errors.append(CloseControlMessage(code=1007, reason='Invalid UTF-8 bytes'))
break
self.closing = CloseControlMessage(code=code, reason=reason)
elif frame.opcode == OPCODE_PING:
self.pings.append(PingControlMessage(bytes))
elif frame.opcode == OPCODE_PONG:
self.pongs.append(PongControlMessage(bytes))
else:
self.errors.append(CloseControlMessage(code=1003))
break
except ProtocolException:
self.errors.append(CloseControlMessage(code=1002))
break
except FrameTooLargeException:
self.errors.append(CloseControlMessage(code=1002, reason="Frame was too large"))
break
except StreamClosed:
running = False
break
frame.body = None
frame = None
if self.message is not None and self.message.completed:
utf8validator.reset()
if frame:
frame._cleanup()
frame = None
utf8validator.reset()
utf8validator = None
self._cleanup()
def _parsing(self):
"""
Generator to parse bytes into a frame. Yields until
enough bytes have been read or an error is met.
"""
buf = enc('')
bytes = enc('')
# yield until we get the first header's byte
while not bytes:
bytes = (yield 1)
first_byte = ord(bytes[0])
self.fin = (first_byte >> 7) & 1
self.rsv1 = (first_byte >> 6) & 1
self.rsv2 = (first_byte >> 5) & 1
self.rsv3 = (first_byte >> 4) & 1
self.opcode = first_byte & 0xf
# frame-fin = %x0 ; more frames of this message follow
# / %x1 ; final frame of this message
if self.fin not in [0, 1]:
raise ProtocolException()
# frame-rsv1 = %x0 ; 1 bit, MUST be 0 unless negotiated otherwise
# frame-rsv2 = %x0 ; 1 bit, MUST be 0 unless negotiated otherwise
# frame-rsv3 = %x0 ; 1 bit, MUST be 0 unless negotiated otherwise
if self.rsv1 or self.rsv2 or self.rsv3:
raise ProtocolException()
# control frames between 3 and 7 as well as above 0xA are currently reserved
if 2 < self.opcode < 8 or self.opcode > 0xA:
raise ProtocolException()
# control frames cannot be fragmented
if self.opcode > 0x7 and self.fin == 0:
raise ProtocolException()
# do we already have enough bytes to continue?
bytes = bytes[1:] if bytes and len(bytes) > 1 else enc('')
# Yield until we get the second header's byte
while not bytes:
bytes = (yield 1)
second_byte = ord(bytes[0])
mask = (second_byte >> 7) & 1
self.payload_length = second_byte & 0x7f
# All control frames MUST have a payload length of 125 bytes or less
if self.opcode > 0x7 and self.payload_length > 125:
raise FrameTooLargeException()
if bytes and len(bytes) > 1:
buf = bytes[1:]
bytes = buf
else:
buf = enc('')
bytes = enc('')
if self.payload_length == 127:
if len(buf) < 8:
nxt_buf_size = 8 - len(buf)
bytes = (yield nxt_buf_size)
bytes = buf + (bytes or enc(''))
while len(bytes) < 8:
b = (yield 8 - len(bytes))
if b is not None:
bytes = bytes + b
if len(bytes) > 8:
buf = bytes[8:]
else:
bytes = buf[:8]
buf = buf[8:]
extended_payload_length = bytes
self.payload_length = unpack(
'!Q', extended_payload_length)[0]
if self.payload_length > 0x7FFFFFFFFFFFFFFF:
raise FrameTooLargeException()
elif self.payload_length == 126:
if len(buf) < 2:
nxt_buf_size = 2 - len(buf)
bytes = (yield nxt_buf_size)
bytes = buf + (bytes or enc(''))
while len(bytes) < 2:
b = (yield 2 - len(bytes))
if b is not None:
bytes = bytes + b
if len(bytes) > 2:
buf = bytes[2:]
else:
bytes = buf[:2]
buf = buf[2:]
extended_payload_length = bytes
self.payload_length = unpack(
'!H', extended_payload_length)[0]
if mask:
if len(buf) < 4:
nxt_buf_size = 4 - len(buf)
bytes = (yield nxt_buf_size)
bytes = buf + (bytes or enc(''))
while not bytes or len(bytes) < 4:
b = (yield 4 - len(bytes))
if b is not None:
bytes = bytes + b
if len(bytes) > 4:
buf = bytes[4:]
else:
bytes = buf[:4]
buf = buf[4:]
self.masking_key = bytes
if len(buf) < self.payload_length:
nxt_buf_size = self.payload_length - len(buf)
bytes = (yield nxt_buf_size)
bytes = buf + (bytes or enc(''))
while len(bytes) < self.payload_length:
l = self.payload_length - len(bytes)
b = (yield l)
if b is not None:
bytes = bytes + b
else:
if self.payload_length == len(buf):
bytes = buf
else:
bytes = buf[:self.payload_length]
self.body = bytes
yield
def __call__(self, environ, start_response):
if environ.get("REQUEST_METHOD") != "GET":
raise HandshakeError("HTTP method must be a GET")
for key, expected_value in [("HTTP_UPGRADE", "websocket"), ("HTTP_CONNECTION", "upgrade")]:
actual_value = environ.get(key, "").lower()
if not actual_value:
raise HandshakeError("Header %s is not defined" % key)
if expected_value not in actual_value:
raise HandshakeError("Illegal value for header %s: %s" % (key, actual_value))
key = environ.get("HTTP_SEC_WEBSOCKET_KEY")
if key:
ws_key = base64.b64decode(enc(key))
if len(ws_key) != 16:
raise HandshakeError("WebSocket key's length is invalid")
version = environ.get("HTTP_SEC_WEBSOCKET_VERSION")
supported_versions = ", ".join([str(v) for v in WS_VERSION])
version_is_valid = False
if version:
try:
version = int(version)
except:
pass
else:
version_is_valid = version in WS_VERSION
if not version_is_valid:
environ["websocket.version"] = str(version)
raise HandshakeError("Unhandled or missing WebSocket version")
ws_protocols = []
protocols = self.protocols or []
subprotocols = environ.get("HTTP_SEC_WEBSOCKET_PROTOCOL")
if subprotocols:
for s in subprotocols.split(","):
s = s.strip()
if s in protocols:
ws_protocols.append(s)
ws_extensions = []
exts = self.extensions or []
extensions = environ.get("HTTP_SEC_WEBSOCKET_EXTENSIONS")
if extensions:
for ext in extensions.split(","):
ext = ext.strip()
if ext in exts:
ws_extensions.append(ext)
upgrade_headers = [
("Upgrade", "websocket"),
("Connection", "Upgrade"),
("Sec-WebSocket-Version", str(version)),
("Sec-WebSocket-Accept", base64.b64encode(sha1(key + WS_KEY).digest())),
]
if ws_protocols:
upgrade_headers.append(("Sec-WebSocket-Protocol", ", ".join(ws_protocols)))
if ws_extensions:
upgrade_headers.append(("Sec-WebSocket-Extensions", ",".join(ws_extensions)))
start_response("101 Switching Protocols", upgrade_headers)
self.make_websocket(environ["ws4py.socket"], ws_protocols, ws_extensions, environ)
return []
def receiver(self):
"""
Parser that keeps trying to interpret bytes it is fed with as
incoming frames part of a message.
Control message are single frames only while data messages, like text
and binary, may be fragmented accross frames.
The way it works is by instanciating a :class:`wspy.framing.Frame` object,
then running its parser generator which yields how much bytes
it requires to performs its task. The stream parser yields this value
to its caller and feeds the frame parser.
When the frame parser raises :exc:`StopIteration`, the stream parser
tries to make sense of the parsed frame. It dispatches the frame's bytes
to the most appropriate message type based on the frame's opcode.
Overall this makes the stream parser totally agonstic to
the data provider.
"""
utf8validator = Utf8Validator()
running = True
frame = None
while running:
frame = Frame()
while 1:
try:
bytes = (yield next(frame.parser))
frame.parser.send(bytes)
except StopIteration:
frame._cleanup()
bytes = frame.body
# Let's avoid unmasking when there is no payload
if bytes:
if frame.masking_key and self.expect_masking:
bytes = frame.unmask(bytes)
elif not frame.masking_key and self.expect_masking:
msg = CloseControlMessage(
code=1002,
reason='Missing masking when expected')
self.errors.append(msg)
break
elif frame.masking_key and not self.expect_masking:
msg = CloseControlMessage(
code=1002, reason='Masked when not expected')
self.errors.append(msg)
break
else:
bytes = bytearray(bytes)
if frame.opcode == OPCODE_TEXT:
if self.message and not self.message.completed:
# We got a text frame before we completed the previous one
msg = CloseControlMessage(
code=1002,
reason=
'Received a new message before completing previous'
)
self.errors.append(msg)
break
m = TextMessage(bytes)
m.completed = (frame.fin == 1)
self.message = m
if bytes:
is_valid, end_on_code_point, _, _ = utf8validator.validate(
bytes)
if not is_valid or (m.completed
and not end_on_code_point):
self.errors.append(
CloseControlMessage(
code=1007,
reason='Invalid UTF-8 bytes'))
break
elif frame.opcode == OPCODE_BINARY:
m = BinaryMessage(bytes)
m.completed = (frame.fin == 1)
self.message = m
elif frame.opcode == OPCODE_CONTINUATION:
m = self.message
if m is None:
self.errors.append(
CloseControlMessage(
code=1002,
reason='Message not started yet'))
break
m.extend(bytes)
m.completed = (frame.fin == 1)
if m.opcode == OPCODE_TEXT:
if bytes:
is_valid, end_on_code_point, _, _ = utf8validator.validate(
bytes)
if not is_valid or (m.completed
and not end_on_code_point):
self.errors.append(
CloseControlMessage(
code=1007,
reason='Invalid UTF-8 bytes'))
break
elif frame.opcode == OPCODE_CLOSE:
code = 1000
reason = ""
if frame.payload_length == 0:
self.closing = CloseControlMessage(code=1000)
elif frame.payload_length == 1:
self.closing = CloseControlMessage(
code=1002, reason='Payload has invalid length')
else:
try:
code = int(unpack("!H", enc(bytes[0:2]))[0])
except TypeError:
code = 1002
reason = 'Invalid Closing Frame Code Type'
except struct.error as sr:
code = 1002
reason = 'Failed at decoding closing code'
else:
# Those codes are reserved or plainly forbidden
if code not in VALID_CLOSING_CODES and not (
2999 < code < 5000):
reason = 'Invalid Closing Frame Code: %d' % code
code = 1002
elif frame.payload_length > 1:
reason = bytes[
2:] if frame.masking_key else bytearray(
frame.body[2:])
is_valid, end_on_code_point, _, _ = utf8validator.validate(
reason)
if not is_valid or not end_on_code_point:
self.errors.append(
CloseControlMessage(
code=1007,
reason='Invalid UTF-8 bytes'))
break
self.closing = CloseControlMessage(code=code,
reason=reason)
elif frame.opcode == OPCODE_PING:
self.pings.append(PingControlMessage(bytes))
elif frame.opcode == OPCODE_PONG:
self.pongs.append(PongControlMessage(bytes))
else:
self.errors.append(CloseControlMessage(code=1003))
break
except ProtocolException:
self.errors.append(CloseControlMessage(code=1002))
break
except FrameTooLargeException:
self.errors.append(
CloseControlMessage(code=1002,
reason="Frame was too large"))
break
except StreamClosed:
running = False
break
frame.body = None
frame = None
if self.message is not None and self.message.completed:
utf8validator.reset()
if frame:
frame._cleanup()
frame = None
utf8validator.reset()
utf8validator = None
self._cleanup()
def _parsing(self):
"""
Generator to parse bytes into a frame. Yields until
enough bytes have been read or an error is met.
"""
buf = enc('')
bytes = enc('')
# yield until we get the first header's byte
while not bytes:
bytes = (yield 1)
first_byte = ord(bytes[0])
self.fin = (first_byte >> 7) & 1
self.rsv1 = (first_byte >> 6) & 1
self.rsv2 = (first_byte >> 5) & 1
self.rsv3 = (first_byte >> 4) & 1
self.opcode = first_byte & 0xf
# frame-fin = %x0 ; more frames of this message follow
# / %x1 ; final frame of this message
if self.fin not in [0, 1]:
raise ProtocolException()
# frame-rsv1 = %x0 ; 1 bit, MUST be 0 unless negotiated otherwise
# frame-rsv2 = %x0 ; 1 bit, MUST be 0 unless negotiated otherwise
# frame-rsv3 = %x0 ; 1 bit, MUST be 0 unless negotiated otherwise
if self.rsv1 or self.rsv2 or self.rsv3:
raise ProtocolException()
# control frames between 3 and 7 as well as above 0xA are currently reserved
if 2 < self.opcode < 8 or self.opcode > 0xA:
raise ProtocolException()
# control frames cannot be fragmented
if self.opcode > 0x7 and self.fin == 0:
raise ProtocolException()
# do we already have enough bytes to continue?
bytes = bytes[1:] if bytes and len(bytes) > 1 else enc('')
# Yield until we get the second header's byte
while not bytes:
bytes = (yield 1)
second_byte = ord(bytes[0])
mask = (second_byte >> 7) & 1
self.payload_length = second_byte & 0x7f
# All control frames MUST have a payload length of 125 bytes or less
if self.opcode > 0x7 and self.payload_length > 125:
raise FrameTooLargeException()
if bytes and len(bytes) > 1:
buf = bytes[1:]
bytes = buf
else:
buf = enc('')
bytes = enc('')
if self.payload_length == 127:
if len(buf) < 8:
nxt_buf_size = 8 - len(buf)
bytes = (yield nxt_buf_size)
bytes = buf + (bytes or enc(''))
while len(bytes) < 8:
b = (yield 8 - len(bytes))
if b is not None:
bytes = bytes + b
if len(bytes) > 8:
buf = bytes[8:]
else:
bytes = buf[:8]
buf = buf[8:]
extended_payload_length = bytes
self.payload_length = unpack('!Q', extended_payload_length)[0]
if self.payload_length > 0x7FFFFFFFFFFFFFFF:
raise FrameTooLargeException()
elif self.payload_length == 126:
if len(buf) < 2:
nxt_buf_size = 2 - len(buf)
bytes = (yield nxt_buf_size)
bytes = buf + (bytes or enc(''))
while len(bytes) < 2:
b = (yield 2 - len(bytes))
if b is not None:
bytes = bytes + b
if len(bytes) > 2:
buf = bytes[2:]
else:
bytes = buf[:2]
buf = buf[2:]
extended_payload_length = bytes
self.payload_length = unpack('!H', extended_payload_length)[0]
if mask:
if len(buf) < 4:
nxt_buf_size = 4 - len(buf)
bytes = (yield nxt_buf_size)
bytes = buf + (bytes or enc(''))
while not bytes or len(bytes) < 4:
b = (yield 4 - len(bytes))
if b is not None:
bytes = bytes + b
if len(bytes) > 4:
buf = bytes[4:]
else:
bytes = buf[:4]
buf = buf[4:]
self.masking_key = bytes
if len(buf) < self.payload_length:
nxt_buf_size = self.payload_length - len(buf)
bytes = (yield nxt_buf_size)
bytes = buf + (bytes or enc(''))
while len(bytes) < self.payload_length:
l = self.payload_length - len(bytes)
b = (yield l)
if b is not None:
bytes = bytes + b
else:
if self.payload_length == len(buf):
bytes = buf
else:
bytes = buf[:self.payload_length]
self.body = bytes
yield
def process_response_line(self, response_line):
protocol, code, status = response_line.split(enc(' '), 2)
if code != enc('101'):
raise HandshakeError("Invalid response status: %s %s" % (code, status))
def extend(self, data):
"""
Add more ``data`` to the message.
"""
self.data += enc(data, self.encoding)
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above
# copyright notice, this list of conditions and the following disclaimer
# in the documentation and/or other materials provided with the
# distribution.
# * Neither the name of ws4py nor the names of its
# contributors may be used to endorse or promote products derived from
# this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
from ws4py.compat import enc
__author__ = "Sylvain Hellegouarch"
__version__ = "0.2.5"
__all__ = ['WS_KEY', 'WS_VERSION']
WS_KEY = enc("258EAFA5-E914-47DA-95CA-C5AB0DC85B11")
WS_VERSION = (8, 13)
def upgrade(self, protocols=None, extensions=None, version=WS_VERSION,
handler_cls=WebSocket, heartbeat_freq=None):
"""
Performs the upgrade of the connection to the WebSocket
protocol.
The provided protocols may be a list of WebSocket
protocols supported by the instance of the tool.
When no list is provided and no protocol is either
during the upgrade, then the protocol parameter is
not taken into account. On the other hand,
if the protocol from the handshake isn't part
of the provided list, the upgrade fails immediatly.
"""
request = cherrypy.serving.request
request.process_request_body = False
ws_protocols = None
ws_location = None
ws_version = version
ws_key = None
ws_extensions = []
if request.method != 'GET':
raise HandshakeError('HTTP method must be a GET')
for key, expected_value in [('Upgrade', 'websocket'),
('Connection', 'upgrade')]:
actual_value = request.headers.get(key, '').lower()
if not actual_value:
raise HandshakeError('Header %s is not defined' % key)
if expected_value not in actual_value:
raise HandshakeError('Illegal value for header %s: %s' %
(key, actual_value))
version = request.headers.get('Sec-WebSocket-Version')
supported_versions = ', '.join([str(v) for v in ws_version])
version_is_valid = False
if version:
try: version = int(version)
except: pass
else: version_is_valid = version in ws_version
if not version_is_valid:
cherrypy.response.headers['Sec-WebSocket-Version'] = supported_versions
raise HandshakeError('Unhandled or missing WebSocket version')
key = request.headers.get('Sec-WebSocket-Key')
if key:
ws_key = base64.b64decode(enc(key))
if len(ws_key) != 16:
raise HandshakeError("WebSocket key's length is invalid")
protocols = protocols or []
subprotocols = request.headers.get('Sec-WebSocket-Protocol')
if subprotocols:
ws_protocols = []
for s in subprotocols.split(','):
s = s.strip()
if s in protocols:
ws_protocols.append(s)
exts = extensions or []
extensions = request.headers.get('Sec-WebSocket-Extensions')
if extensions:
for ext in extensions.split(','):
ext = ext.strip()
if ext in exts:
ws_extensions.append(ext)
location = []
include_port = False
if request.scheme == "https":
location.append("wss://")
include_port = request.local.port != 443
else:
location.append("ws://")
include_port = request.local.port != 80
location.append('localhost')
if include_port:
location.append(":%d" % request.local.port)
location.append(request.path_info)
if request.query_string != "":
location.append("?%s" % request.query_string)
ws_location = ''.join(location)
response = cherrypy.serving.response
response.stream = True
response.status = '101 Switching Protocols'
response.headers['Content-Type'] = 'text/plain'
response.headers['Upgrade'] = 'websocket'
response.headers['Connection'] = 'Upgrade'
response.headers['Sec-WebSocket-Version'] = str(version)
response.headers['Sec-WebSocket-Accept'] = base64.b64encode(sha1(enc(key) + WS_KEY).digest())
if ws_protocols:
response.headers['Sec-WebSocket-Protocol'] = ', '.join(ws_protocols)
if ws_extensions:
response.headers['Sec-WebSocket-Extensions'] = ','.join(ws_extensions)
addr = (request.remote.ip, request.remote.port)
ws_conn = get_connection(request.rfile.rfile)
request.ws_handler = handler_cls(ws_conn, ws_protocols, ws_extensions,
request.wsgi_environ.copy(),
heartbeat_freq=heartbeat_freq)