def connectionMade(self):
WebSocketServerProtocol.connectionMade(self)
self.LisaProtocolfactory = LisaProtocolFactory(self)
if configuration['enable_secure_mode']:
self.conn = reactor.connectSSL(configuration['lisa_url'], configuration['lisa_port'], self.LisaProtocolfactory, ClientAuthContextFactory())
else:
self.conn = reactor.connectTCP(configuration['lisa_url'], configuration['lisa_port'], self.LisaProtocolfactory)
def onMessage(self, payload, isBinary):
WebSocketServerProtocol.onMessage(self, payload, isBinary)
if not isBinary:
payload = payload.decode('string_escape')
log.msg(payload, system="WebSocket DEBUG")
msg = json.loads(payload)
msg_type = msg['type']
if msg_type == 'auth': # В случае, если аутентифицируемся токеном вручную
self.token = msg['token']
if not self.token:
self.sendMessageJson({'exception': 'Not authorized', })
return
if msg_type == 'call':
self.process_call(msg)
elif msg_type == 'broadcast':
self.process_broadcast(msg)
elif msg_type == 'sub':
self.process_subscribe(msg)
elif msg_type == 'unsub':
self.process_unsubscribe(msg)
else:
self.sendMessageJson({
'exception': 'Unknown message type: %s' % msg_type,
'object': msg,
})
def onConnect(self, request):
self.sendMessage("Server socket established")
# Push an update for the new user.
# This is inefficient so fix it if it becomes a problem.
self.factory.pushUpdate()
WebSocketServerProtocol.onConnect(self, request)
def connectionLost(self, reason):
"""
Programmed by: David Williams
Description: Closes the connection when the connection is lost
"""
WebSocketServerProtocol.connectionLost(self, reason)
print("Connection was closed.")
def connectionLost(self, reason):
if DEBUG >= 1:
print("WebSocket connection closed: {0}".format(reason))
WebSocketServerProtocol.connectionLost(self, reason)
self.factory.unregister(self)
name.pop(self.peer, None)
self.sendUsers()
def sendMessage(self, payload, *args, **kwargs):
"""
Logs message
"""
logger.debug("Outgoing message for ({peer}) : {message}".format(
peer=self.peer, message=payload))
WebSocketServerProtocol.sendMessage(self, payload, *args, **kwargs)
def connectionLost(self, reason):
WebSocketServerProtocol.connectionLost(self, reason)
self.factory.stats.trackOctetsWireIn(self.trafficStats.preopenIncomingOctetsWireLevel + \
self.trafficStats.incomingOctetsWireLevel)
self.factory.stats.trackOctetsWireOut(self.trafficStats.preopenOutgoingOctetsWireLevel + \
self.trafficStats.outgoingOctetsWireLevel)
def connectionLost(self, reason):
WebSocketServerProtocol.connectionLost(self, reason)
self.factory.stats.trackOctetsWireIn(self.trafficStats.preopenIncomingOctetsWireLevel + \
self.trafficStats.incomingOctetsWireLevel)
self.factory.stats.trackOctetsWireOut(self.trafficStats.preopenOutgoingOctetsWireLevel + \
self.trafficStats.outgoingOctetsWireLevel)
def setUp(self):
self.factory = WebSocketServerFactory()
self.factory.setProtocolOptions(trustXForwardedFor=2)
self.proto = WebSocketServerProtocol()
self.proto.transport = StringTransport()
self.proto.factory = self.factory
self.proto.failHandshake = Mock()
self.proto._connectionMade()
def __init__(self, consumer=None):
WebSocketServerProtocol.__init__(self)
self.connected = False
self.producer = None
self.streaming = True
self.consumer = consumer
self.paused = False
def __init__(self, server):
WebSocketServerProtocol.__init__(self)
self.server = server
self.recv = str()
self.stat = str()
self.player = None
def connectionLost(self, reason):
WebSocketServerProtocol.connectionLost(self, reason)
try:
namespace = self.getNamespace()
except NamespaceNotFound:
pass
else:
namespace.client_disconnected(self)
def onOpen(self):
print 'open:', self.user
WebSocketServerProtocol.onOpen(self)
self.factory.associate(self)
if not self.user[fixed.detect_agent]:
agents = [a.user[fixed.agent] for a in self.factory.agents()]
print 'agents:', agents
self.sendMessage(json.dumps({ fixed.agents: agents }))
def setUp(self):
self.factory = WebSocketServerFactory()
self.factory.setProtocolOptions(
allowedOrigins=[u'127.0.0.1:*', u'*.example.com:*'])
self.proto = WebSocketServerProtocol()
self.proto.transport = StringTransport()
self.proto.factory = self.factory
self.proto.failHandshake = Mock()
self.proto._connectionMade()
def onClose(self, wasClean, code, reason):
"""
Connect closed, cleanup
"""
# base logs
WebSocketServerProtocol.onClose(self, wasClean, code, reason)
if self.client is None:
if self.debug:
log.msg("RPIServerProtocol.onClose - No Client type")
return
self.client.onClose(wasClean, code, reason)
def __init__(self, board):
WebSocketServerProtocol.__init__(self)
self.log.debug = lambda *a, **kw: None
self.board = board
self.gpio_buffers = {}
self.streaming = False
self.inputs = []
self.active = []
self.start_time = time.time()*1000000
self.t = None
self.base = 100000
self.window = 5000000
def __init__(self):
global server, channels
WebSocketServerProtocol.__init__(self)
server = {
"name": args["name"],
"channels": channels
}
self.port = 0
self.plugged = False
self.channel = ""
self.creator = False
self.maxclients = int(args["max_clients"])
self.protected = args["protected"]
def __init__(self, server):
WebSocketServerProtocol.__init__(self)
self.server = server
self.address = str()
self.recv = bytes()
self.pendingStat = None
self.stat = str()
self.player = None
self.blocked = bool()
self.dcTimer = None
def __init__(self, server):
WebSocketServerProtocol.__init__(self)
self.server = server
self.address = str()
self.recv = bytearray()
self.pendingStat = None
self.stat = str()
self.username = str()
self.session = str()
self.player = None
self.blocked = bool()
self.dcTimer = None
self.maxConLifeTimer = None
def connectionLost(self, reason):
global serial_port
global serial_device
global serial_baudrate
if not self.connection_invalid:
print "Disconnect Message Received"
if serial_port != None:
oldserial = serial_port
serial_port = None
serial_device = None
serial_baudrate = None
self.read_thread.stop()
self.read_thread.join()
oldserial.close()
WebSocketServerProtocol.connectionLost(self, reason)
def __init__(self, server):
WebSocketServerProtocol.__init__(self)
self.server = server
self.address = str()
self.recv = str()
self.pendingStat = None
self.stat = str()
self.player = None
self.trustCount = int()
self.blocked = bool()
self.lastX = int()
self.lastXOk = True
self.dcTimer = None
def __init__(self,
ws_endpoint_str,
target_url,
origin=None, headers=None, verbose=False, reactor=None):
"""
ws_endpoint_str: The proxied websocket endpoint string.
target_url: should be a websocket URL, e.g. 'ws://127.0.0.1:9000'
"""
WebSocketServerProtocol.__init__(self)
self.verbose = verbose
self.ws_endpoint_str = ws_endpoint_str
self.target_url = target_url
self.origin = origin
self.headers = headers
self._queue = []
if self.reactor is None:
from twisted.internet import reactor
self.reactor = reactor
class WebSocketXForwardedFor(unittest.TestCase):
"""
Test that (only) a trusted X-Forwarded-For can replace the peer address.
"""
def setUp(self):
self.factory = WebSocketServerFactory()
self.factory.setProtocolOptions(
trustXForwardedFor=2
)
self.proto = WebSocketServerProtocol()
self.proto.transport = StringTransport()
self.proto.factory = self.factory
self.proto.failHandshake = Mock()
self.proto._connectionMade()
def tearDown(self):
for call in [
self.proto.autoPingPendingCall,
self.proto.autoPingTimeoutCall,
self.proto.openHandshakeTimeoutCall,
self.proto.closeHandshakeTimeoutCall,
]:
if call is not None:
call.cancel()
def test_trusted_addresses(self):
self.proto.data = b"\r\n".join([
b'GET /ws HTTP/1.1',
b'Host: www.example.com',
b'Origin: http://www.example.com',
b'Sec-WebSocket-Version: 13',
b'Sec-WebSocket-Extensions: permessage-deflate',
b'Sec-WebSocket-Key: tXAxWFUqnhi86Ajj7dRY5g==',
b'Connection: keep-alive, Upgrade',
b'Upgrade: websocket',
b'X-Forwarded-For: 1.2.3.4, 2.3.4.5, 111.222.33.44',
b'\r\n', # last string doesn't get a \r\n from join()
])
self.proto.consumeData()
self.assertEquals(
self.proto.peer, "2.3.4.5",
"The second address in X-Forwarded-For should have been picked as the peer address")
def __init__(self, server):
WebSocketServerProtocol.__init__(self)
self.server = server
self.address = str()
self.recv = bytearray()
self.pendingStat = None
self.stat = str()
self.username = str()
self.session = str()
self.player = None
self.blocked = bool()
self.account = {}
self.accountPriv = {}
self.dcTimer = None
#self.maxConLifeTimer = None
self.dbSession = datastore.getDbSession()
def setUp(self):
self.factory = WebSocketServerFactory()
self.factory.setProtocolOptions(
trustXForwardedFor=2
)
self.proto = WebSocketServerProtocol()
self.proto.transport = StringTransport()
self.proto.factory = self.factory
self.proto.failHandshake = Mock()
self.proto._connectionMade()
def test_handshake_fails(self):
"""
A handshake from a client only supporting Hixie-76 will fail.
"""
t = FakeTransport()
f = WebSocketServerFactory()
p = WebSocketServerProtocol()
p.factory = f
p.transport = t
# from http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76
http_request = b"GET /demo HTTP/1.1\r\nHost: example.com\r\nConnection: Upgrade\r\nSec-WebSocket-Key2: 12998 5 Y3 1 .P00\r\nSec-WebSocket-Protocol: sample\r\nUpgrade: WebSocket\r\nSec-WebSocket-Key1: 4 @1 46546xW%0l 1 5\r\nOrigin: http://example.com\r\n\r\n^n:ds[4U"
p.openHandshakeTimeout = 0
p._connectionMade()
p.data = http_request
p.processHandshake()
self.assertIn(b"HTTP/1.1 400", t._written)
self.assertIn(b"Hixie76 protocol not supported", t._written)
def setUp(self):
self.factory = WebSocketServerFactory()
self.factory.setProtocolOptions(
allowedOrigins=[u'127.0.0.1:*', u'*.example.com:*']
)
self.proto = WebSocketServerProtocol()
self.proto.transport = StringTransport()
self.proto.factory = self.factory
self.proto.failHandshake = Mock()
self.proto._connectionMade()
def _sendAutoPing(self):
"""Override for sanity checking during auto-ping interval"""
if not self.ps.uaid:
# No uaid yet, drop the connection
self.ps.metrics.increment("client.autoping.no_uaid", tags=self.base_tags)
self.sendClose()
elif self.ap_settings.clients.get(self.ps.uaid) != self:
# UAID, but we're not in clients anymore for some reason
self.ps.metrics.increment("client.autoping.invalid_client", tags=self.base_tags)
self.sendClose()
return WebSocketServerProtocol._sendAutoPing(self)
def onConnect(self, request):
"""
Обработчик соединения по WebSocket-протоколу. Нужен для того, чтобы вытащить печеньку 'authToken'
:param request: Request
:type request: autobahn.websocket.protocol.ConnectionRequest
:return:
"""
log.msg('Achtung! Connection! %s', request.peer)
self.process_cookies(request)
self.token = self.cookies.get(self.cookie_name)
return WebSocketServerProtocol.onConnect(self, request)
def connectionLost(self, reason):
"""
При аварийном завершении коннекта
:param reason:
:return:
"""
#проверяется список приконекченных клиентов,
#каждый клиент - одна вкладка
if self.factory.clients[self] != '':
#если не пуст список
#json с новым списком клиентов и инфой, что один отдисконнектился
disconnect_msg = json.dumps({'user_disconnect':
self.factory.clients[self]})
#возвращаем инфу клиенту о дисконекте
self.factory.broadcast(disconnect_msg, self)
#удаляем объект, чистим следы
self.factory.remove_game(self)
self.factory.unregister(self)
#посылаем общее сообщение, что коннект завершен с причиной
WebSocketServerProtocol.connectionLost(self, reason)
def __init__(self,
ws_endpoint_str,
target_url,
origin=None,
headers=None,
verbose=False,
reactor=None):
"""
ws_endpoint_str: The proxied websocket endpoint string.
target_url: should be a websocket URL, e.g. 'ws://127.0.0.1:9000'
"""
WebSocketServerProtocol.__init__(self)
self.verbose = verbose
self.ws_endpoint_str = ws_endpoint_str
self.target_url = target_url
self.origin = origin
self.headers = headers
self._queue = []
if self.reactor is None:
from twisted.internet import reactor
self.reactor = reactor
def _sendAutoPing(self):
"""Override for sanity checking during auto-ping interval"""
if not self.ps.uaid:
# No uaid yet, drop the connection
self.ps.metrics.increment("client.autoping.no_uaid",
tags=self.base_tags)
self.sendClose()
elif self.ap_settings.clients.get(self.ps.uaid) != self:
# UAID, but we're not in clients anymore for some reason
self.ps.metrics.increment("client.autoping.invalid_client",
tags=self.base_tags)
self.sendClose()
return WebSocketServerProtocol._sendAutoPing(self)
class WebSocketOriginMatching(unittest.TestCase):
"""
Test that we match Origin: headers properly, when asked to
"""
def setUp(self):
self.factory = WebSocketServerFactory()
self.factory.setProtocolOptions(
allowedOrigins=[u'127.0.0.1:*', u'*.example.com:*']
)
self.proto = WebSocketServerProtocol()
self.proto.transport = StringTransport()
self.proto.factory = self.factory
self.proto.failHandshake = Mock()
self.proto._connectionMade()
def tearDown(self):
for call in [
self.proto.autoPingPendingCall,
self.proto.autoPingTimeoutCall,
self.proto.openHandshakeTimeoutCall,
self.proto.closeHandshakeTimeoutCall,
]:
if call is not None:
call.cancel()
def test_match_full_origin(self):
self.proto.data = b"\r\n".join([
b'GET /ws HTTP/1.1',
b'Host: www.example.com',
b'Sec-WebSocket-Version: 13',
b'Origin: http://www.example.com.malicious.com',
b'Sec-WebSocket-Extensions: permessage-deflate',
b'Sec-WebSocket-Key: tXAxWFUqnhi86Ajj7dRY5g==',
b'Connection: keep-alive, Upgrade',
b'Upgrade: websocket',
b'\r\n', # last string doesn't get a \r\n from join()
])
self.proto.consumeData()
self.assertTrue(self.proto.failHandshake.called, "Handshake should have failed")
arg = self.proto.failHandshake.mock_calls[0][1][0]
self.assertTrue('not allowed' in arg)
def test_match_wrong_scheme_origin(self):
# some monkey-business since we already did this in setUp, but
# we want a different set of matching origins
self.factory.setProtocolOptions(
allowedOrigins=[u'http://*.example.com:*']
)
self.proto.allowedOriginsPatterns = self.factory.allowedOriginsPatterns
self.proto.allowedOrigins = self.factory.allowedOrigins
# the actual test
self.factory.isSecure = False
self.proto.data = b"\r\n".join([
b'GET /ws HTTP/1.1',
b'Host: www.example.com',
b'Sec-WebSocket-Version: 13',
b'Origin: https://www.example.com',
b'Sec-WebSocket-Extensions: permessage-deflate',
b'Sec-WebSocket-Key: tXAxWFUqnhi86Ajj7dRY5g==',
b'Connection: keep-alive, Upgrade',
b'Upgrade: websocket',
b'\r\n', # last string doesn't get a \r\n from join()
])
self.proto.consumeData()
self.assertTrue(self.proto.failHandshake.called, "Handshake should have failed")
arg = self.proto.failHandshake.mock_calls[0][1][0]
self.assertTrue('not allowed' in arg)
def test_match_origin_secure_scheme(self):
self.factory.isSecure = True
self.factory.port = 443
self.proto.data = b"\r\n".join([
b'GET /ws HTTP/1.1',
b'Host: www.example.com',
b'Sec-WebSocket-Version: 13',
b'Origin: https://www.example.com',
b'Sec-WebSocket-Extensions: permessage-deflate',
b'Sec-WebSocket-Key: tXAxWFUqnhi86Ajj7dRY5g==',
b'Connection: keep-alive, Upgrade',
b'Upgrade: websocket',
b'\r\n', # last string doesn't get a \r\n from join()
])
self.proto.consumeData()
self.assertFalse(self.proto.failHandshake.called, "Handshake should have succeeded")
def test_match_origin_documentation_example(self):
"""
Test the examples from the docs
"""
self.factory.setProtocolOptions(
allowedOrigins=['*://*.example.com:*']
)
self.factory.isSecure = True
self.factory.port = 443
self.proto.data = b"\r\n".join([
b'GET /ws HTTP/1.1',
b'Host: www.example.com',
b'Sec-WebSocket-Version: 13',
b'Origin: http://www.example.com',
b'Sec-WebSocket-Extensions: permessage-deflate',
b'Sec-WebSocket-Key: tXAxWFUqnhi86Ajj7dRY5g==',
b'Connection: keep-alive, Upgrade',
b'Upgrade: websocket',
b'\r\n', # last string doesn't get a \r\n from join()
])
self.proto.consumeData()
self.assertFalse(self.proto.failHandshake.called, "Handshake should have succeeded")
def test_match_origin_examples(self):
"""
All the example origins from RFC6454 (3.2.1)
"""
# we're just testing the low-level function here...
from autobahn.websocket.protocol import _is_same_origin, _url_to_origin
policy = wildcards2patterns(['*example.com:*'])
# should parametrize test ...
for url in ['http://example.com/', 'http://example.com:80/',
'http://example.com/path/file',
'http://example.com/;semi=true',
# 'http://example.com./',
'//example.com/',
'http://@example.com']:
self.assertTrue(_is_same_origin(_url_to_origin(url), 'http', 80, policy), url)
def test_match_origin_counter_examples(self):
"""
All the example 'not-same' origins from RFC6454 (3.2.1)
"""
# we're just testing the low-level function here...
from autobahn.websocket.protocol import _is_same_origin, _url_to_origin
policy = wildcards2patterns(['example.com'])
for url in ['http://ietf.org/', 'http://example.org/',
'https://example.com/', 'http://example.com:8080/',
'http://www.example.com/']:
self.assertFalse(_is_same_origin(_url_to_origin(url), 'http', 80, policy))
def test_match_origin_edge(self):
# we're just testing the low-level function here...
from autobahn.websocket.protocol import _is_same_origin, _url_to_origin
policy = wildcards2patterns(['http://*example.com:80'])
self.assertTrue(
_is_same_origin(_url_to_origin('http://example.com:80'), 'http', 80, policy)
)
self.assertFalse(
_is_same_origin(_url_to_origin('http://example.com:81'), 'http', 81, policy)
)
self.assertFalse(
_is_same_origin(_url_to_origin('https://example.com:80'), 'http', 80, policy)
)
def test_origin_from_url(self):
from autobahn.websocket.protocol import _url_to_origin
# basic function
self.assertEqual(
_url_to_origin('http://example.com'),
('http', 'example.com', 80)
)
# should lower-case scheme
self.assertEqual(
_url_to_origin('hTTp://example.com'),
('http', 'example.com', 80)
)
def test_origin_file(self):
from autobahn.websocket.protocol import _url_to_origin
self.assertEqual('null', _url_to_origin('file:///etc/passwd'))
def test_origin_null(self):
from autobahn.websocket.protocol import _is_same_origin, _url_to_origin
self.assertEqual('null', _url_to_origin('null'))
self.assertFalse(
_is_same_origin(_url_to_origin('null'), 'http', 80, [])
)
self.assertFalse(
_is_same_origin(_url_to_origin('null'), 'https', 80, [])
)
self.assertFalse(
_is_same_origin(_url_to_origin('null'), '', 80, [])
)
self.assertFalse(
_is_same_origin(_url_to_origin('null'), None, 80, [])
)
def connectionLost(self, reason): WebSocketServerProtocol.connectionLost(self, reason) self.factory.unregister(self)
class ExceptionHandlingTests(unittest.TestCase):
"""
Tests that we format various exception variations properly during
connectionLost
"""
def setUp(self):
self.factory = WebSocketServerFactory()
self.proto = WebSocketServerProtocol()
self.proto.factory = self.factory
self.proto.log = Mock()
def tearDown(self):
for call in [
self.proto.autoPingPendingCall,
self.proto.autoPingTimeoutCall,
self.proto.openHandshakeTimeoutCall,
self.proto.closeHandshakeTimeoutCall,
]:
if call is not None:
call.cancel()
def test_connection_done(self):
# pretend we connected
self.proto._connectionMade()
self.proto.connectionLost(Failure(ConnectionDone()))
messages = ' '.join([str(x[1]) for x in self.proto.log.mock_calls])
self.assertTrue('closed cleanly' in messages)
def test_connection_aborted(self):
# pretend we connected
self.proto._connectionMade()
self.proto.connectionLost(Failure(ConnectionAborted()))
messages = ' '.join([str(x[1]) for x in self.proto.log.mock_calls])
self.assertTrue(' aborted ' in messages)
def test_connection_lost(self):
# pretend we connected
self.proto._connectionMade()
self.proto.connectionLost(Failure(ConnectionLost()))
messages = ' '.join([str(x[1]) for x in self.proto.log.mock_calls])
self.assertTrue(' was lost ' in messages)
def test_connection_lost_arg(self):
# pretend we connected
self.proto._connectionMade()
self.proto.connectionLost(Failure(ConnectionLost("greetings")))
messages = ' '.join([str(x[1]) + str(x[2]) for x in self.proto.log.mock_calls])
self.assertTrue(' was lost ' in messages)
self.assertTrue('greetings' in messages)
def __init__(self, factory):
WebSocketServerProtocol.__init__(self)
self.factory = factory
def onMessageBegin(self, isBinary):
WebSocketServerProtocol.onMessageBegin(self, isBinary)
self.sha256 = hashlib.sha256()
def __init__(self, master):
WebSocketServerProtocol.__init__(self)
self.master = master
self.qrefs = {}
self.debug = self.master.config.www.get('debug', False)
def connectionLost(self, reason):
WebSocketServerProtocol.connectionLost(self, reason)
self.factory.unregister(self)
def __init__(self, master):
WebSocketServerProtocol.__init__(self)
self.master = master
self.qrefs = {}
self.debug = self.master.config.www.get('debug', False)
def connectionLost(self, reason):
WebSocketServerProtocol.connectionLost(self, reason)
BroadcastServerFactory.unregister(self)
def __init__(self, broker=None):
WebSocketServerProtocol.__init__(self)
self._discovery_response_defer = None
self._protocol_response_defer = None
self._open_protocol_response_defer = None
def onMessageFrameBegin(self, length):
WebSocketServerProtocol.onMessageFrameBegin(self, length)
self.beginMessageFrame(length)
def onMessageBegin(self, isBinary):
WebSocketServerProtocol.onMessageBegin(self, isBinary)
self.beginMessage(isBinary=isBinary)
def __init__(self):
self.settings = spec.supervisor.get_settings_object()
WebSocketServerProtocol.__init__(self)
def onMessageBegin(self, isBinary):
#print "onMessageBegin"
WebSocketServerProtocol.onMessageBegin(self, isBinary)
self.beginMessage(isBinary = isBinary)
def connectionLost(self, reason):
WebSocketServerProtocol.connectionLost(self, reason)
self.factory.unregister(self)
bridge.socketIn.close()
bridge.socketOut.close()
def setUp(self):
self.factory = WebSocketServerFactory()
self.proto = WebSocketServerProtocol()
self.proto.factory = self.factory
self.proto.log = Mock()
def onMessageFrameBegin(self, length):
#print "onMessageFrameBegin"
WebSocketServerProtocol.onMessageFrameBegin(self, length)
self.beginMessageFrame(length)
