def dataReceived(self, data): if self._handshake_complete: WampRawSocketProtocol.dataReceived(self, data) else: remaining = 4 - len(self._handshake_bytes) self._handshake_bytes += data[:remaining] if len(self._handshake_bytes) == 4: self.log.debug( "WampRawSocketProtocol: opening handshake received - {handshake}", handshake=_LazyHexFormatter(self._handshake_bytes), ) if ord(self._handshake_bytes[0:1]) != 0x7f: self.log.debug( "WampRawSocketProtocol: invalid magic byte (octet 1) in opening handshake: was 0x{magic}, but expected 0x7f", magic=_LazyHexFormatter(self._handshake_bytes[0]), ) self.abort() # peer requests us to send messages of maximum length 2**max_len_exp # self._max_len_send = 2**( 9 + (ord(self._handshake_bytes[1:2]) >> 4)) self.log.debug( "WampRawSocketProtocol: server requests us to send out most {max} bytes per message", max=self._max_len_send, ) # client wants to speak this serialization format # ser_id = ord(self._handshake_bytes[1:2]) & 0x0F if ser_id != self._serializer.RAWSOCKET_SERIALIZER_ID: self.log.error( "WampRawSocketProtocol: opening handshake - no suitable serializer found (server replied {serializer}, and we requested {serializers})", serializer=ser_id, serializers=self._serializer.RAWSOCKET_SERIALIZER_ID, ) self.abort() self._handshake_complete = True self._on_handshake_complete() self.log.debug( "WampRawSocketProtocol: opening handshake completed (using serializer {serializer})", serializer=self._serializer, ) # consume any remaining data received already .. # data = data[remaining:] if data: self.dataReceived(data)
def dataReceived(self, data): if self._handshake_complete: WampRawSocketProtocol.dataReceived(self, data) else: remaining = 4 - len(self._handshake_bytes) self._handshake_bytes += data[:remaining] if len(self._handshake_bytes) == 4: self.log.debug( "WampRawSocketProtocol: opening handshake received - {handshake}", handshake=_LazyHexFormatter(self._handshake_bytes), ) if ord(self._handshake_bytes[0:1]) != 0x7f: self.log.debug( "WampRawSocketProtocol: invalid magic byte (octet 1) in opening handshake: was 0x{magic}, but expected 0x7f", magic=_LazyHexFormatter(self._handshake_bytes[0]), ) self.abort() # peer requests us to send messages of maximum length 2**max_len_exp # self._max_len_send = 2 ** (9 + (ord(self._handshake_bytes[1:2]) >> 4)) self.log.debug( "WampRawSocketProtocol: server requests us to send out most {max} bytes per message", max=self._max_len_send, ) # client wants to speak this serialization format # ser_id = ord(self._handshake_bytes[1:2]) & 0x0F if ser_id != self._serializer.RAWSOCKET_SERIALIZER_ID: self.log.error( "WampRawSocketProtocol: opening handshake - no suitable serializer found (server replied {serializer}, and we requested {serializers})", serializer=ser_id, serializers=self._serializer.RAWSOCKET_SERIALIZER_ID, ) self.abort() self._handshake_complete = True self._on_handshake_complete() self.log.debug( "WampRawSocketProtocol: opening handshake completed (using serializer {serializer})", serializer=self._serializer, ) # consume any remaining data received already .. # data = data[remaining:] if data: self.dataReceived(data)
def render_POST(self, request): """ A client sends a message via WAMP-over-Longpoll by HTTP/POSTing to this Web resource. The body of the POST should contain a batch of WAMP messages which are serialized according to the selected serializer, and delimited by a single ``\0`` byte in between two WAMP messages in the batch. """ payload = request.content.read() self.log.debug( "WampLongPoll: receiving data for transport '{tid}'\n{octets}", tid=self._parent._transport_id, octets=_LazyHexFormatter(payload), ) try: # process (batch of) WAMP message(s) self._parent.onMessage(payload, None) except Exception: f = create_failure() self.log.error( "Could not unserialize WAMP message: {msg}", msg=failure_message(f), ) self.log.debug("{tb}", tb=failure_format_traceback(f)) return self._parent._parent._fail_request( request, b"could not unserialize WAMP message.") else: request.setResponseCode(http.NO_CONTENT) self._parent._parent._set_standard_headers(request) self._parent._isalive = True return b""
def send(self, msg): """ Implements :func:`autobahn.wamp.interfaces.ITransport.send` """ if self.isOpen(): try: self.log.debug( "WampLongPoll: TX {octets}", octets=_LazyHexFormatter(msg), ) payload, isBinary = self._serializer.serialize(msg) except Exception as e: # all exceptions raised from above should be serialization errors .. f = create_failure() self.log.error( "Unable to serialize WAMP application payload: {msg}", msg=failure_message(f), ) self.log.debug("{tb}", tb=failure_format_traceback(f)) raise SerializationError( "unable to serialize WAMP application payload ({0})". format(e)) else: self._receive.queue(payload) else: raise TransportLost()
def send(self, msg): """ Implements :func:`autobahn.wamp.interfaces.ITransport.send` """ if self.isOpen(): self.log.trace('{klass}.send() (serializer={serializer}): TX WAMP message: "{msg}"', klass=self.__class__.__name__, msg=msg, serializer=self._serializer) try: payload, _ = self._serializer.serialize(msg) except SerializationError as e: # all exceptions raised from above should be serialization errors .. raise SerializationError("WampRawSocketProtocol: unable to serialize WAMP application payload ({0})".format(e)) else: payload_len = len(payload) if 0 < self._max_len_send < payload_len: emsg = 'tried to send RawSocket message with size {} exceeding payload limit of {} octets'.format( payload_len, self._max_len_send) self.log.warn(emsg) raise PayloadExceededError(emsg) else: self.sendString(payload) self.log.trace('{klass}.send(): TX {octets} octets', klass=self.__class__.__name__, octets=_LazyHexFormatter(payload)) else: raise TransportLost()
def onMessage(self, payload, isBinary): """ Callback from :func:`autobahn.websocket.interfaces.IWebSocketChannel.onMessage` """ for msg in self._serializer.unserialize(payload, isBinary): self.log.debug( "WampLongPoll: RX {octets}", octets=_LazyHexFormatter(msg), ) self._session.onMessage(msg)
def stringReceived(self, payload): self.log.trace('{klass}.stringReceived(): RX {octets} octets', klass=self.__class__.__name__, octets=_LazyHexFormatter(payload)) try: for msg in self._serializer.unserialize(payload): self.log.trace( "{klass}.stringReceived: RX WAMP message: {msg}", klass=self.__class__.__name__, msg=msg) self._session.onMessage(msg) except CancelledError as e: self.log.debug( "{klass}.stringReceived: WAMP CancelledError - connection will continue!\n{err}", klass=self.__class__.__name__, err=e) except InvalidUriError as e: self.log.warn( "{klass}.stringReceived: WAMP InvalidUriError - aborting connection!\n{err}", klass=self.__class__.__name__, err=e) self.abort() except ProtocolError as e: self.log.warn( "{klass}.stringReceived: WAMP ProtocolError - aborting connection!\n{err}", klass=self.__class__.__name__, err=e) self.abort() except PayloadExceededError as e: self.log.warn( "{klass}.stringReceived: WAMP PayloadExceededError - aborting connection!\n{err}", klass=self.__class__.__name__, err=e) self.abort() except SerializationError as e: self.log.warn( "{klass}.stringReceived: WAMP SerializationError - aborting connection!\n{err}", klass=self.__class__.__name__, err=e) self.abort() except Exception as e: self.log.failure() self.log.warn( "{klass}.stringReceived: WAMP Exception - aborting connection!\n{err}", klass=self.__class__.__name__, err=e) self.abort()
def stringReceived(self, payload): self.log.debug("WampRawSocketProtocol: RX octets: {octets}", octets=_LazyHexFormatter(payload)) try: for msg in self._serializer.unserialize(payload): self.log.debug("WampRawSocketProtocol: RX WAMP message: {msg}", msg=msg) self._session.onMessage(msg) except ProtocolError as e: self.log.warn("WampRawSocketProtocol: WAMP Protocol Error ({err}) - aborting connection", err=e) self.abort() except Exception as e: self.log.warn("WampRawSocketProtocol: WAMP Internal Error ({err}) - aborting connection", err=e) self.abort()
def send(self, msg): """ Implements :func:`autobahn.wamp.interfaces.ITransport.send` """ if self.isOpen(): self.log.trace("WampRawSocketProtocol (serializer={serializer}): TX WAMP message: {msg}", msg=msg, serializer=self._serializer) try: payload, _ = self._serializer.serialize(msg) except Exception as e: # all exceptions raised from above should be serialization errors .. raise SerializationError("WampRawSocketProtocol: unable to serialize WAMP application payload ({0})".format(e)) else: self.sendString(payload) self.log.trace("WampRawSocketProtocol: TX octets: {octets}", octets=_LazyHexFormatter(payload)) else: raise TransportLost()
def send(self, msg): """ Implements :func:`autobahn.wamp.interfaces.ITransport.send` """ if self.isOpen(): self.log.trace("WampRawSocketProtocol: TX WAMP message: {msg}", msg=msg) try: payload, _ = self._serializer.serialize(msg) except Exception as e: # all exceptions raised from above should be serialization errors .. raise SerializationError("WampRawSocketProtocol: unable to serialize WAMP application payload ({0})".format(e)) else: self.sendString(payload) self.log.trace("WampRawSocketProtocol: TX octets: {octets}", octets=_LazyHexFormatter(payload)) else: raise TransportLost()
def data_received(self, data): self.log.debug('RawSocker Asyncio: data received {data}', data=_LazyHexFormatter(data)) if self._handshake_done: return PrefixProtocol.data_received(self, data) else: self._buffer += data if len(self._buffer) >= 4: try: self.process_handshake() except HandshakeError as e: self.protocol_error('Handshake error : {err}'.format(err=e)) return self._handshake_done = True self._on_handshake_complete() data = self._buffer[4:] self._buffer = b'' if data: PrefixProtocol.data_received(self, data)
def stringReceived(self, payload): self.log.trace("WampRawSocketProtocol: RX octets: {octets}", octets=_LazyHexFormatter(payload)) try: for msg in self._serializer.unserialize(payload): self.log.trace("WampRawSocketProtocol: RX WAMP message: {msg}", msg=msg) self._session.onMessage(msg) except CancelledError as e: self.log.warn("{klass}.stringReceived: WAMP CancelledError - connection will continue\n{err}", klass=self.__class__.__name__, err=e) except ProtocolError as e: self.log.warn("{klass}.stringReceived: WAMP ProtocolError - aborting connection\n{err}", klass=self.__class__.__name__, err=e) self.abort() except Exception as e: self.log.warn("{klass}.stringReceived: WAMP Exception - aborting connection\n{err}", klass=self.__class__.__name__, err=e) self.abort()
def render_POST(self, request): """ A client sends a message via WAMP-over-Longpoll by HTTP/POSTing to this Web resource. The body of the POST should contain a batch of WAMP messages which are serialized according to the selected serializer, and delimited by a single ``\0`` byte in between two WAMP messages in the batch. """ payload = request.content.read() self.log.debug( "WampLongPoll: receiving data for transport '{tid}'\n{octets}", tid=self._parent._transport_id, octets=_LazyHexFormatter(payload), ) try: # process (batch of) WAMP message(s) self._parent.onMessage(payload, None) except Exception: f = create_failure() self.log.error( "Could not unserialize WAMP message: {msg}", msg=failure_message(f), ) self.log.debug("{tb}", tb=failure_format_traceback(f)) return self._parent._parent._fail_request( request, b"could not unserialize WAMP message." ) else: request.setResponseCode(http.NO_CONTENT) self._parent._parent._set_standard_headers(request) self._parent._isalive = True return b""
def send(self, msg): """ Implements :func:`autobahn.wamp.interfaces.ITransport.send` """ if self.isOpen(): try: self.log.debug( "WampLongPoll: TX {octets}", octets=_LazyHexFormatter(msg), ) payload, isBinary = self._serializer.serialize(msg) except Exception as e: # all exceptions raised from above should be serialization errors .. f = create_failure() self.log.error( "Unable to serialize WAMP application payload: {msg}", msg=failure_message(f), ) self.log.debug("{tb}", tb=failure_format_traceback(f)) raise SerializationError("unable to serialize WAMP application payload ({0})".format(e)) else: self._receive.queue(payload) else: raise TransportLost()
def dataReceived(self, data): if self._handshake_complete: WampRawSocketProtocol.dataReceived(self, data) else: remaining = 4 - len(self._handshake_bytes) self._handshake_bytes += data[:remaining] if len(self._handshake_bytes) == 4: self.log.debug( "WampRawSocketProtocol: opening handshake received - {octets}", octets=_LazyHexFormatter(self._handshake_bytes), ) if ord(self._handshake_bytes[0:1]) != 0x7f: self.log.error( "WampRawSocketProtocol: invalid magic byte (octet 1) in" " opening handshake: was 0x{magic}, but expected 0x7f", magic=_LazyHexFormatter(self._handshake_bytes[0]), ) self.abort() # peer requests us to send messages of maximum length 2**max_len_exp # self._max_len_send = 2**( 9 + (ord(self._handshake_bytes[1:2]) >> 4)) self.log.debug( "WampRawSocketProtocol: client requests us to send out most {max_bytes} bytes per message", max_bytes=self._max_len_send, ) # client wants to speak this serialization format # ser_id = ord(self._handshake_bytes[1:2]) & 0x0F if ser_id in self.factory._serializers: self._serializer = self.factory._serializers[ser_id] self.log.debug( "WampRawSocketProtocol: client wants to use serializer '{serializer}'", serializer=ser_id, ) else: self.log.debug( "WampRawSocketProtocol: opening handshake - no suitable serializer found (client requested {serializer}, and we have {serializers}", serializer=ser_id, serializers=self.factory._serializers.keys(), ) self.abort() # we request the peer to send message of maximum length 2**reply_max_len_exp # reply_max_len_exp = 24 # send out handshake reply # reply_octet2 = bytes( bytearray([((reply_max_len_exp - 9) << 4) | self._serializer.RAWSOCKET_SERIALIZER_ID])) self.transport.write(b'\x7F') # magic byte self.transport.write(reply_octet2) # max length / serializer self.transport.write(b'\x00\x00') # reserved octets self._handshake_complete = True self._on_handshake_complete() self.log.debug( "WampRawSocketProtocol: opening handshake completed: {serializer}", serializer=self._serializer, ) # consume any remaining data received already .. # data = data[remaining:] if data: self.dataReceived(data)
def dataReceived(self, data): if self._handshake_complete: WampRawSocketProtocol.dataReceived(self, data) else: remaining = 4 - len(self._handshake_bytes) self._handshake_bytes += data[:remaining] if len(self._handshake_bytes) == 4: self.log.debug( "WampRawSocketProtocol: opening handshake received - {octets}", octets=_LazyHexFormatter(self._handshake_bytes), ) if ord(self._handshake_bytes[0:1]) != 0x7f: self.log.error( "WampRawSocketProtocol: invalid magic byte (octet 1) in" " opening handshake: was 0x{magic}, but expected 0x7f", magic=_LazyHexFormatter(self._handshake_bytes[0]), ) self.abort() # peer requests us to send messages of maximum length 2**max_len_exp # self._max_len_send = 2 ** (9 + (ord(self._handshake_bytes[1:2]) >> 4)) self.log.debug( "WampRawSocketProtocol: client requests us to send out most {max_bytes} bytes per message", max_bytes=self._max_len_send, ) # client wants to speak this serialization format # ser_id = ord(self._handshake_bytes[1:2]) & 0x0F if ser_id in self.factory._serializers: self._serializer = self.factory._serializers[ser_id] self.log.debug( "WampRawSocketProtocol: client wants to use serializer '{serializer}'", serializer=ser_id, ) else: self.log.debug( "WampRawSocketProtocol: opening handshake - no suitable serializer found (client requested {serializer}, and we have {serializers}", serializer=ser_id, serializers=self.factory._serializers.keys(), ) self.abort() # we request the peer to send message of maximum length 2**reply_max_len_exp # reply_max_len_exp = 24 # send out handshake reply # reply_octet2 = bytes(bytearray([ ((reply_max_len_exp - 9) << 4) | self._serializer.RAWSOCKET_SERIALIZER_ID])) self.transport.write(b'\x7F') # magic byte self.transport.write(reply_octet2) # max length / serializer self.transport.write(b'\x00\x00') # reserved octets self._handshake_complete = True self._on_handshake_complete() self.log.debug( "WampRawSocketProtocol: opening handshake completed: {serializer}", serializer=self._serializer, ) # consume any remaining data received already .. # data = data[remaining:] if data: self.dataReceived(data)
def dataReceived(self, data): if self._handshake_complete: WampRawSocketProtocol.dataReceived(self, data) else: remaining = 4 - len(self._handshake_bytes) self._handshake_bytes += data[:remaining] if len(self._handshake_bytes) == 4: self.log.debug( "WampRawSocketServerProtocol: opening handshake received - 0x{octets}", octets=_LazyHexFormatter(self._handshake_bytes), ) # first octet must be magic octet 0x7f # _magic = ord(self._handshake_bytes[0:1]) if _magic != 127: self.log.warn( "WampRawSocketServerProtocol: invalid magic byte (octet 1) in" " opening handshake: was {magic}, but expected 127", magic=_magic, ) self.abort() else: self.log.debug('WampRawSocketServerProtocol: correct magic byte received') # peer requests us to send messages of maximum length 2**max_len_exp # self._max_len_send = 2 ** (9 + (ord(self._handshake_bytes[1:2]) >> 4)) self.log.debug( "WampRawSocketServerProtocol: client requests us to send out most {max_bytes} bytes per message", max_bytes=self._max_len_send, ) # client wants to speak this serialization format # ser_id = ord(self._handshake_bytes[1:2]) & 0x0F if ser_id in self.factory._serializers: self._serializer = copy.copy(self.factory._serializers[ser_id]) self.log.debug( "WampRawSocketServerProtocol: client wants to use serializer '{serializer}'", serializer=ser_id, ) else: self.log.warn( "WampRawSocketServerProtocol: opening handshake - no suitable serializer found (client requested {serializer}, and we have {serializers}", serializer=ser_id, serializers=self.factory._serializers.keys(), ) self.abort() # we request the client to send message of maximum length 2**reply_max_len_exp # reply_max_len_exp = int(math.ceil(math.log(self._max_message_size, 2))) # this is an instance attribute on the Twisted base class for maximum size # of _received_ messages self.MAX_LENGTH = 2**reply_max_len_exp # send out handshake reply # reply_octet2 = bytes(bytearray([ ((reply_max_len_exp - 9) << 4) | self._serializer.RAWSOCKET_SERIALIZER_ID])) self.transport.write(b'\x7F') # magic byte self.transport.write(reply_octet2) # max length / serializer self.transport.write(b'\x00\x00') # reserved octets self._handshake_complete = True self._on_handshake_complete() self.log.debug( "WampRawSocketServerProtocol: opening handshake completed: {serializer}", serializer=self._serializer, ) # consume any remaining data received already .. # data = data[remaining:] if data: self.dataReceived(data)