def testHmacMethod(self):
data = Message(Pyro4.message.MSG_RESULT, b"test", 42, 0, 1, hmac_key=b"test key")
digest = data.hmac()
self.assertTrue(len(digest) > 10)
data = Message(Pyro4.message.MSG_RESULT, b"test", 42, 0, 1)
with self.assertRaises(TypeError):
data.hmac()
def _sendExceptionResponse(self, connection, seq, serializer_id, exc_value,
tbinfo):
"""send an exception back including the local traceback info"""
exc_value._pyroTraceback = tbinfo
if sys.platform == "cli":
util.fixIronPythonExceptionForPickle(exc_value,
True) # piggyback attributes
serializer = util.get_serializer_by_id(serializer_id)
try:
data, compressed = serializer.serializeData(exc_value)
except:
# the exception object couldn't be serialized, use a generic PyroError instead
xt, xv, tb = sys.exc_info()
msg = "Error serializing exception: %s. Original exception: %s: %s" % (
str(xv), type(exc_value), str(exc_value))
exc_value = errors.PyroError(msg)
exc_value._pyroTraceback = tbinfo
if sys.platform == "cli":
util.fixIronPythonExceptionForPickle(
exc_value, True) # piggyback attributes
data, compressed = serializer.serializeData(exc_value)
flags = Pyro4.message.FLAGS_EXCEPTION
if compressed:
flags |= Pyro4.message.FLAGS_COMPRESSED
if Pyro4.config.LOGWIRE:
log.debug(
"daemon wiredata sending (error response): msgtype=%d flags=0x%x ser=%d seq=%d data=%r"
% (Pyro4.message.MSG_RESULT, flags, serializer.serializer_id,
seq, data))
msg = Message(Pyro4.message.MSG_RESULT, data, serializer.serializer_id,
flags, seq)
connection.send(msg.to_bytes())
def testRecvNoAnnotations(self):
msg = Message(Pyro4.message.MSG_CONNECT, b"hello", 42, 0, 0)
c = ConnectionMock()
c.send(msg.to_bytes())
msg = Message.recv(c)
self.assertEqual(0, len(c.received))
self.assertEqual(5, msg.data_size)
self.assertEqual(b"hello", msg.data)
self.assertEqual(0, msg.annotations_size)
self.assertEqual(0, len(msg.annotations))
def testMessageHeaderDatasize(self):
msg = Message(Pyro4.message.MSG_RESULT, b"hello", 12345, 60006, 30003, hmac_key=b"secret")
msg.data_size = 0x12345678 # hack it to a large value to see if it comes back ok
hdr = msg.to_bytes()[:24]
msg = Message.from_header(hdr)
self.assertEqual(Pyro4.message.MSG_RESULT, msg.type)
self.assertEqual(60006, msg.flags)
self.assertEqual(0x12345678, msg.data_size)
self.assertEqual(12345, msg.serializer_id)
self.assertEqual(30003, msg.seq)
def testRecvNoAnnotations(self):
msg = Message(Pyro4.message.MSG_CONNECT, b"hello", 42, 0, 0)
c = ConnectionMock()
c.send(msg.to_bytes())
msg = Message.recv(c)
self.assertEqual(0, len(c.received))
self.assertEqual(5, msg.data_size)
self.assertEqual(b"hello", msg.data)
self.assertEqual(0, msg.annotations_size)
self.assertEqual(0, len(msg.annotations))
def testMessageHeaderDatasize(self):
msg = Message(Pyro4.message.MSG_RESULT, b"hello", 12345, 60006, 30003)
msg.data_size = 0x12345678 # hack it to a large value to see if it comes back ok
hdr = msg.to_bytes()[:24]
msg = Message.from_header(hdr)
self.assertEqual(Pyro4.message.MSG_RESULT, msg.type)
self.assertEqual(60006, msg.flags)
self.assertEqual(0x12345678, msg.data_size)
self.assertEqual(12345, msg.serializer_id)
self.assertEqual(30003, msg.seq)
def testRecvAnnotations(self):
annotations = {"TEST": b"abcde"}
msg = Message(Pyro4.message.MSG_CONNECT, b"hello", self.ser.serializer_id, 0, 0, annotations, b"secret")
c = ConnectionMock()
c.send(msg.to_bytes())
msg = Message.recv(c, hmac_key=b"secret")
self.assertEqual(0, len(c.received))
self.assertEqual(5, msg.data_size)
self.assertEqual(b"hello", msg.data)
self.assertEqual(b"abcde", msg.annotations["TEST"])
self.assertIn("HMAC", msg.annotations)
def testAnnotations(self):
annotations = {"TEST": b"abcde"}
msg = Message(Pyro4.message.MSG_CONNECT, b"hello", self.ser.serializer_id, 0, 0, annotations, b"secret")
data = msg.to_bytes()
annotations_size = 4 + 2 + 20 + 4 + 2 + 5
self.assertEqual(msg.header_size + 5 + annotations_size, len(data))
self.assertEqual(annotations_size, msg.annotations_size)
self.assertEqual(2, len(msg.annotations))
self.assertEqual(b"abcde", msg.annotations["TEST"])
mac = pyrohmac(b"hello", b"secret", annotations)
self.assertEqual(mac, msg.annotations["HMAC"])
def testRecvAnnotations(self):
annotations = { b"TEST": b"abcde" }
msg = Message(Pyro4.message.MSG_CONNECT, b"hello", self.ser.serializer_id, 0, 0, annotations)
c = ConnectionMock()
c.send(msg.to_bytes())
msg = Message.recv(c)
self.assertEquals(0, len(c.received))
self.assertEquals(5, msg.data_size)
self.assertEquals(b"hello", msg.data)
self.assertEquals(b"abcde", msg.annotations[b"TEST"])
self.assertTrue(b"HMAC" in msg.annotations)
def testMaxDataSize(self):
msg = Message(Pyro4.message.MSG_CONNECT, b"hello", 42, 0, 0)
msg.data_size = 0x7fffffff # still within 32 bits signed limits
msg.to_bytes()
msg.data_size = 0x80000000 # overflow, Pyro has a 2 gigabyte message size limitation
with self.assertRaises(ValueError) as ex:
msg.to_bytes()
self.assertEqual("invalid message size (outside range 0..2Gb)", str(ex.exception))
msg.data_size = -42
with self.assertRaises(ValueError) as ex:
msg.to_bytes()
self.assertEqual("invalid message size (outside range 0..2Gb)", str(ex.exception))
def testAnnotations(self):
annotations = {"TEST": b"abcde"}
msg = Message(Pyro4.message.MSG_CONNECT, b"hello",
self.ser.serializer_id, 0, 0, annotations)
data = msg.to_bytes()
annotations_size = 4 + 2 + 20 + 4 + 2 + 5
self.assertEqual(msg.header_size + 5 + annotations_size, len(data))
self.assertEqual(annotations_size, msg.annotations_size)
self.assertEqual(2, len(msg.annotations))
self.assertEqual(b"abcde", msg.annotations["TEST"])
mac = pyrohmac(b"hello", annotations)
self.assertEqual(mac, msg.annotations["HMAC"])
def _handshake(self, conn):
"""Perform connection handshake with new clients"""
# For now, client is not sending anything. Just respond with a CONNECT_OK.
# We need a minimal amount of data or the socket will remain blocked
# on some systems... (messages smaller than 40 bytes)
# Return True for successful handshake, False if something was wrong.
# We default to the marshal serializer to send message payload of "ok"
ser = util.get_serializer("marshal")
data = ser.dumps("ok")
msg = Message(Pyro4.message.MSG_CONNECTOK, data, ser.serializer_id, 0, 1)
conn.send(msg.to_bytes())
return True
def testRecvAnnotations(self):
annotations = {"TEST": b"abcde"}
msg = Message(Pyro4.message.MSG_CONNECT, b"hello",
self.ser.serializer_id, 0, 0, annotations)
c = ConnectionMock()
c.send(msg.to_bytes())
msg = Message.recv(c)
self.assertEqual(0, len(c.received))
self.assertEqual(5, msg.data_size)
self.assertEqual(b"hello", msg.data)
self.assertEqual(b"abcde", msg.annotations["TEST"])
self.assertTrue("HMAC" in msg.annotations)
def testCompression(self):
data = b"The quick brown fox jumps over the lazy dog."*10
compressed_data = zlib.compress(data)
flags = Pyro4.message.FLAGS_COMPRESSED
msg = Message(Pyro4.message.MSG_INVOKE, compressed_data, 42, flags, 1, hmac_key=b"secret")
self.assertNotEqual(data, msg.data)
data_size = msg.data_size
self.assertLess(data_size, len(data))
msg.decompress_if_needed()
self.assertEqual(data, msg.data)
self.assertEqual(0, msg.flags)
self.assertGreater(msg.data_size, data_size)
def testChecksum(self):
msg = Message(Pyro4.message.MSG_RESULT, b"test", 42, 0, 1, hmac_key=b"secret")
c = ConnectionMock()
c.send(msg.to_bytes())
# corrupt the checksum bytes
data = c.received
data = data[:msg.header_size - 2] + b'\x00\x00' + data[msg.header_size:]
c = ConnectionMock(data)
try:
Message.recv(c)
self.fail("crash expected")
except Pyro4.errors.ProtocolError as x:
self.assertIn("checksum", str(x))
def connectionMade(self):
"""
Handshake - should replicate Pyro4.Daemon._handshake()
"""
log = logger.debug
if self.state == "server":
log("Connection made with Pyro4Protocol")
log("... attempting handshake")
ser = util.get_serializer("marshal")
data = ser.dumps("ok")
msg = Message(Pyro4.message.MSG_CONNECTOK, data, ser.serializer_id, 0, 1)
self.transport.write(msg.to_bytes())
self.state = "header"
def testAnnotationsIdLength4(self):
try:
msg = Message(Pyro4.message.MSG_CONNECT, b"hello", self.ser.serializer_id, 0, 0, {"TOOLONG": b"abcde"}, b"secret")
_ = msg.to_bytes()
self.fail("should fail, too long")
except Pyro4.errors.ProtocolError:
pass
try:
msg = Message(Pyro4.message.MSG_CONNECT, b"hello", self.ser.serializer_id, 0, 0, {"QQ": b"abcde"}, b"secret")
_ = msg.to_bytes()
self.fail("should fail, too short")
except Pyro4.errors.ProtocolError:
pass
def testChecksum(self):
msg = Message(Pyro4.message.MSG_RESULT, b"test", 42, 0, 1)
c = ConnectionMock()
c.send(msg.to_bytes())
# corrupt the checksum bytes
data = c.received
data = data[:msg.header_size -
2] + b'\x00\x00' + data[msg.header_size:]
c = ConnectionMock(data)
try:
Message.recv(c)
self.fail("crash expected")
except Pyro4.errors.ProtocolError as x:
self.assertTrue("checksum" in str(x))
def _pyroInvoke(self, methodname, vargs, kwargs, flags=0):
"""perform the remote method call communication"""
if self._pyroConnection is None:
# rebind here, don't do it from inside the invoke because deadlock will occur
self.__pyroCreateConnection()
serializer = util.get_serializer(Pyro4.config.SERIALIZER)
data, compressed = serializer.serializeCall(
self._pyroConnection.objectId, methodname, vargs, kwargs,
compress=Pyro4.config.COMPRESSION)
if compressed:
flags |= Pyro4.message.FLAGS_COMPRESSED
if methodname in self._pyroOneway:
flags |= Pyro4.message.FLAGS_ONEWAY
with self.__pyroLock:
self._pyroSeq=(self._pyroSeq+1)&0xffff
if Pyro4.config.LOGWIRE:
log.debug("proxy wiredata sending: msgtype=%d flags=0x%x ser=%d seq=%d data=%r" % (Pyro4.message.MSG_INVOKE, flags, serializer.serializer_id, self._pyroSeq, data))
msg = Message(Pyro4.message.MSG_INVOKE, data, serializer.serializer_id, flags, self._pyroSeq)
try:
self._pyroConnection.send(msg.to_bytes())
del msg # invite GC to collect the object, don't wait for out-of-scope
if flags & Pyro4.message.FLAGS_ONEWAY:
return None # oneway call, no response data
else:
msg = Message.recv(self._pyroConnection, [Pyro4.message.MSG_RESULT])
if Pyro4.config.LOGWIRE:
log.debug("proxy wiredata received: msgtype=%d flags=0x%x ser=%d seq=%d data=%r" % (msg.type, msg.flags, msg.serializer_id, msg.seq, msg.data))
self.__pyroCheckSequence(msg.seq)
if msg.serializer_id != serializer.serializer_id:
error = "invalid serializer in response: %d" % msg.serializer_id
log.error(error)
raise errors.ProtocolError(error)
data = serializer.deserializeData(msg.data, compressed=msg.flags & Pyro4.message.FLAGS_COMPRESSED)
if msg.flags & Pyro4.message.FLAGS_EXCEPTION:
if sys.platform=="cli":
util.fixIronPythonExceptionForPickle(data, False)
raise data
else:
return data
except (errors.CommunicationError, KeyboardInterrupt):
# Communication error during read. To avoid corrupt transfers, we close the connection.
# Otherwise we might receive the previous reply as a result of a new methodcall!
# Special case for keyboardinterrupt: people pressing ^C to abort the client
# may be catching the keyboardinterrupt in their code. We should probably be on the
# safe side and release the proxy connection in this case too, because they might
# be reusing the proxy object after catching the exception...
self._pyroRelease()
raise
def testProtocolVersion(self):
version = Pyro4.constants.PROTOCOL_VERSION
Pyro4.constants.PROTOCOL_VERSION = 0 # fake invalid protocol version number
msg = Message(Pyro4.message.MSG_RESULT, b"", self.ser.serializer_id, 0,
1).to_bytes()
Pyro4.constants.PROTOCOL_VERSION = version
self.assertRaises(Pyro4.errors.ProtocolError, Message.from_header, msg)
def testCompression(self):
data = b"The quick brown fox jumps over the lazy dog." * 10
compressed_data = zlib.compress(data)
flags = Pyro4.message.FLAGS_COMPRESSED
msg = Message(Pyro4.message.MSG_INVOKE,
compressed_data,
42,
flags,
1,
hmac_key=b"secret")
self.assertNotEqual(data, msg.data)
data_size = msg.data_size
self.assertLess(data_size, len(data))
msg.decompress_if_needed()
self.assertEqual(data, msg.data)
self.assertEqual(0, msg.flags)
self.assertGreater(msg.data_size, data_size)
def testMessage(self):
Message(99, b"", self.ser.serializer_id, 0, 0, hmac_key=b"secret") # doesn't check msg type here
self.assertRaises(Pyro4.errors.ProtocolError, Message.from_header, "FOOBAR")
msg = Message(Pyro4.message.MSG_CONNECT, b"hello", self.ser.serializer_id, 0, 0, hmac_key=b"secret")
self.assertEqual(Pyro4.message.MSG_CONNECT, msg.type)
self.assertEqual(5, msg.data_size)
self.assertEqual(b"hello", msg.data)
self.assertEqual(4 + 2 + 20, msg.annotations_size)
mac = pyrohmac(b"hello", b"secret", msg.annotations)
self.assertDictEqual({"HMAC": mac}, msg.annotations)
hdr = msg.to_bytes()[:24]
msg = Message.from_header(hdr)
self.assertEqual(Pyro4.message.MSG_CONNECT, msg.type)
self.assertEqual(4 + 2 + 20, msg.annotations_size)
self.assertEqual(5, msg.data_size)
hdr = Message(Pyro4.message.MSG_RESULT, b"", self.ser.serializer_id, 0, 0, hmac_key=b"secret").to_bytes()[:24]
msg = Message.from_header(hdr)
self.assertEqual(Pyro4.message.MSG_RESULT, msg.type)
self.assertEqual(4 + 2 + 20, msg.annotations_size)
self.assertEqual(0, msg.data_size)
hdr = Message(Pyro4.message.MSG_RESULT, b"hello", 12345, 60006, 30003, hmac_key=b"secret").to_bytes()[:24]
msg = Message.from_header(hdr)
self.assertEqual(Pyro4.message.MSG_RESULT, msg.type)
self.assertEqual(60006, msg.flags)
self.assertEqual(5, msg.data_size)
self.assertEqual(12345, msg.serializer_id)
self.assertEqual(30003, msg.seq)
msg = Message(255, b"", self.ser.serializer_id, 0, 255, hmac_key=b"secret").to_bytes()
self.assertEqual(50, len(msg))
msg = Message(1, b"", self.ser.serializer_id, 0, 255, hmac_key=b"secret").to_bytes()
self.assertEqual(50, len(msg))
msg = Message(1, b"", self.ser.serializer_id, flags=253, seq=254, hmac_key=b"secret").to_bytes()
self.assertEqual(50, len(msg))
# compression is a job of the code supplying the data, so the messagefactory should leave it untouched
data = b"x" * 1000
msg = Message(Pyro4.message.MSG_INVOKE, data, self.ser.serializer_id, 0, 0, hmac_key=b"secret").to_bytes()
msg2 = Message(
Pyro4.message.MSG_INVOKE,
data,
self.ser.serializer_id,
Pyro4.message.FLAGS_COMPRESSED,
0,
hmac_key=b"secret",
).to_bytes()
self.assertEqual(len(msg), len(msg2))
def testHmac(self):
try:
hk = Pyro4.config.HMAC_KEY
Pyro4.config.HMAC_KEY = b"test key"
data = Message(Pyro4.message.MSG_RESULT, b"test", 42, 0,
1).to_bytes()
c = ConnectionMock(data)
finally:
Pyro4.config.HMAC_KEY = hk
# test checking of different hmacs
try:
Message.recv(c)
self.fail("crash expected")
except Pyro4.errors.SecurityError as x:
self.assertTrue("hmac" in str(x))
c = ConnectionMock(data)
# test that it works again when resetting the key
try:
hk = Pyro4.config.HMAC_KEY
Pyro4.config.HMAC_KEY = b"test key"
Message.recv(c)
finally:
Pyro4.config.HMAC_KEY = hk
c = ConnectionMock(data)
# test that it doesn't work when no key is set
try:
hk = Pyro4.config.HMAC_KEY
Pyro4.config.HMAC_KEY = b""
Message.recv(c)
self.fail("crash expected")
except Pyro4.errors.SecurityError as x:
self.assertTrue("hmac key config" in str(x))
finally:
Pyro4.config.HMAC_KEY = hk
def __pyroCreateConnection(self, replaceUri=False):
"""
Connects this proxy to the remote Pyro daemon. Does connection handshake.
Returns true if a new connection was made, false if an existing one was already present.
"""
with self.__pyroConnLock:
if self._pyroConnection is not None:
return False # already connected
from Pyro4.naming import resolve # don't import this globally because of cyclic dependancy
uri=resolve(self._pyroUri)
# socket connection (normal or Unix domain socket)
conn=None
log.debug("connecting to %s", uri)
connect_location=uri.sockname if uri.sockname else (uri.host, uri.port)
with self.__pyroLock:
try:
if self._pyroConnection is not None:
return False # already connected
sock=socketutil.createSocket(connect=connect_location, reuseaddr=Pyro4.config.SOCK_REUSE, timeout=self.__pyroTimeout)
conn=socketutil.SocketConnection(sock, uri.object)
# Do handshake. For now, no need to send anything. (message type CONNECT is not yet used)
msg = Message.recv(conn, None)
# any trailing data (dataLen>0) is an error message, if any
except Exception:
x=sys.exc_info()[1]
if conn:
conn.close()
err="cannot connect: %s" % x
log.error(err)
if isinstance(x, errors.CommunicationError):
raise
else:
ce = errors.CommunicationError(err)
ce.__cause__ = x
raise ce
else:
if msg.type==Pyro4.message.MSG_CONNECTFAIL:
error="connection rejected"
if msg.data:
serializer = util.get_serializer_by_id(msg.serializer_id)
data = serializer.deserializeData(msg.data, compressed=msg.flags & Pyro4.message.FLAGS_COMPRESSED)
error += ", reason: " + data
conn.close()
log.error(error)
raise errors.CommunicationError(error)
elif msg.type==Pyro4.message.MSG_CONNECTOK:
self._pyroConnection=conn
if replaceUri:
self._pyroUri=uri
log.debug("connected to %s", self._pyroUri)
return True
else:
conn.close()
err="connect: invalid msg type %d received" % msg.type
log.error(err)
raise errors.ProtocolError(err)
def testHmac(self):
data = Message(Pyro4.message.MSG_RESULT, b"test", 42, 0, 1, hmac_key=b"test key").to_bytes()
c = ConnectionMock(data)
# test checking of different hmacs
try:
Message.recv(c, hmac_key=None)
self.fail("crash expected")
except Pyro4.errors.SecurityError as x:
self.assertIn("hmac key config", str(x))
c = ConnectionMock(data)
try:
Message.recv(c, hmac_key=b"T3ST-K3Y")
self.fail("crash expected")
except Pyro4.errors.SecurityError as x:
self.assertIn("hmac", str(x))
# test that it works again when providing the correct key
c = ConnectionMock(data)
msg = Message.recv(c, hmac_key=b"test key")
self.assertEqual(b"test key", msg.hmac_key)
def testHmac(self):
try:
hk = Pyro4.config.HMAC_KEY
Pyro4.config.HMAC_KEY = b"test key"
data = Message(Pyro4.message.MSG_RESULT, b"test", 42, 0, 1).to_bytes()
c = ConnectionMock(data)
finally:
Pyro4.config.HMAC_KEY = hk
# test checking of different hmacs
try:
Message.recv(c)
self.fail("crash expected")
except Pyro4.errors.SecurityError as x:
self.assertIn("hmac", str(x))
c = ConnectionMock(data)
# test that it works again when resetting the key
try:
hk = Pyro4.config.HMAC_KEY
Pyro4.config.HMAC_KEY = b"test key"
Message.recv(c)
finally:
Pyro4.config.HMAC_KEY = hk
c = ConnectionMock(data)
# test that it doesn't work when no key is set
try:
hk = Pyro4.config.HMAC_KEY
Pyro4.config.HMAC_KEY = b""
Message.recv(c)
self.fail("crash expected")
except Pyro4.errors.SecurityError as x:
self.assertIn("hmac key config", str(x))
finally:
Pyro4.config.HMAC_KEY = hk
def testHmacMethod(self):
data = Message(Pyro4.message.MSG_RESULT,
b"test",
42,
0,
1,
hmac_key=b"test key")
digest = data.hmac()
self.assertTrue(len(digest) > 10)
data = Message(Pyro4.message.MSG_RESULT, b"test", 42, 0, 1)
with self.assertRaises(TypeError):
data.hmac()
def testAnnotationsIdLength4(self):
try:
msg = Message(Pyro4.message.MSG_CONNECT, b"hello",
self.ser.serializer_id, 0, 0, {"TOOLONG": b"abcde"})
data = msg.to_bytes()
self.fail("should fail, too long")
except Pyro4.errors.ProtocolError:
pass
try:
msg = Message(Pyro4.message.MSG_CONNECT, b"hello",
self.ser.serializer_id, 0, 0, {"QQ": b"abcde"})
data = msg.to_bytes()
self.fail("should fail, too short")
except Pyro4.errors.ProtocolError:
pass
def testHmac(self):
data = Message(Pyro4.message.MSG_RESULT,
b"test",
42,
0,
1,
hmac_key=b"test key").to_bytes()
c = ConnectionMock(data)
# test checking of different hmacs
try:
Message.recv(c, hmac_key=None)
self.fail("crash expected")
except Pyro4.errors.SecurityError as x:
self.assertIn("hmac key config", str(x))
c = ConnectionMock(data)
try:
Message.recv(c, hmac_key=b"T3ST-K3Y")
self.fail("crash expected")
except Pyro4.errors.SecurityError as x:
self.assertIn("hmac", str(x))
# test that it works again when providing the correct key
c = ConnectionMock(data)
msg = Message.recv(c, hmac_key=b"test key")
self.assertEqual(b"test key", msg.hmac_key)
def testMessage(self):
Message(99, b"", self.ser.serializer_id, 0,
0) # doesn't check msg type here
self.assertRaises(Pyro4.errors.ProtocolError, Message.from_header,
"FOOBAR")
msg = Message(Pyro4.message.MSG_CONNECT, b"hello",
self.ser.serializer_id, 0, 0)
self.assertEqual(Pyro4.message.MSG_CONNECT, msg.type)
self.assertEqual(5, msg.data_size)
self.assertEqual(b"hello", msg.data)
self.assertEqual(4 + 2 + 20, msg.annotations_size)
mac = pyrohmac(b"hello", msg.annotations)
self.assertDictEqual({"HMAC": mac}, msg.annotations)
hdr = msg.to_bytes()[:24]
msg = Message.from_header(hdr)
self.assertEqual(Pyro4.message.MSG_CONNECT, msg.type)
self.assertEqual(4 + 2 + 20, msg.annotations_size)
self.assertEqual(5, msg.data_size)
hdr = Message(Pyro4.message.MSG_RESULT, b"", self.ser.serializer_id, 0,
0).to_bytes()[:24]
msg = Message.from_header(hdr)
self.assertEqual(Pyro4.message.MSG_RESULT, msg.type)
self.assertEqual(4 + 2 + 20, msg.annotations_size)
self.assertEqual(0, msg.data_size)
hdr = Message(Pyro4.message.MSG_RESULT, b"hello", 12345, 60006,
30003).to_bytes()[:24]
msg = Message.from_header(hdr)
self.assertEqual(Pyro4.message.MSG_RESULT, msg.type)
self.assertEqual(60006, msg.flags)
self.assertEqual(5, msg.data_size)
self.assertEqual(12345, msg.serializer_id)
self.assertEqual(30003, msg.seq)
msg = Message(255, b"", self.ser.serializer_id, 0, 255).to_bytes()
self.assertEqual(50, len(msg))
msg = Message(1, b"", self.ser.serializer_id, 0, 255).to_bytes()
self.assertEqual(50, len(msg))
msg = Message(1, b"", self.ser.serializer_id, flags=253,
seq=254).to_bytes()
self.assertEqual(50, len(msg))
# compression is a job of the code supplying the data, so the messagefactory should leave it untouched
data = b"x" * 1000
msg = Message(Pyro4.message.MSG_INVOKE, data, self.ser.serializer_id,
0, 0).to_bytes()
msg2 = Message(Pyro4.message.MSG_INVOKE, data, self.ser.serializer_id,
Pyro4.message.FLAGS_COMPRESSED, 0).to_bytes()
self.assertEqual(len(msg), len(msg2))
def dataReceived(self, data):
"""
This function must aggregate and standardize the I/O behavior of several Pyro4 functions:
- Daemon.handleRequest
- Message.recv
- Protocol._pyroInvoke
Due to differences between synchronous and asynchronous approaches, twisted-pyro uses states to determine how
to route received data. Because state data need not persist across connections (unlike state information in
many applications), it is attached to the Protocol. These states are:
- server: indicates that a handshake will be required upon connection
- header: waiting on enough data to parse a message header and respond accordingly (idle state for servers)
- annotations: header parsed, waiting on amount of annotation data requested in header
- data: header parsed, waiting on amount of data requested in header
- response: the other end is waiting for data from us (idle state for clients)
"""
log = logger.debug
log("Handling %d bytes of data" % len(data))
self.data += data
if self.state == "header" and len(self.data) >= Message.header_size:
log("... enough data received to process header.")
# Have enough data to process headers
self.request = Message.from_header(self.data[:Message.header_size])
if Pyro4.config.LOGWIRE:
log("wiredata received: msgtype=%d flags=0x%x ser=%d seq=%d data=%r" %
(self.request.type, self.request.flags, self.request.serializer_id, self.request.seq, self.request.data))
if self.required_message_types and self.request.type not in self.required_message_types:
err = "invalid msg type %d received" % self.request.type
logger.error(err)
self._return_error(errors.ProtocolError(err))
if self.request.serializer_id not in \
set([util.get_serializer(ser_name).serializer_id
for ser_name in Pyro4.config.SERIALIZERS_ACCEPTED]):
self._return_error(errors.ProtocolError("message used serializer that is not accepted: %d" % self.request.serializer_id))
self.data = self.data[Message.header_size:]
if self.request.annotations_size:
self.state = "annotations"
else:
self.state = "data"
if self.state == "annotations" and len(self.data) >= self.request.annotations_size:
log("... enough data received to process annotation.")
self.request.annotations = {}
annotations_data = self.data[:self.request.annotations_size]
self.data = self.data[self.request.annotations_size:]
i = 0
while i < self.request.annotations_size:
anno, length = struct.unpack("!4sH", annotations_data[i:i+6])
self.request.annotations[anno] = annotations_data[i+6:i+6+length]
i += 6+length
if b"HMAC" in self.request.annotations and Pyro4.config.HMAC_KEY:
if self.request.annotations[b"HMAC"] != self.request.hmac():
self._return_error(errors.SecurityError("message hmac mismatch"))
elif (b"HMAC" in self.request.annotations) != bool(Pyro4.config.HMAC_KEY):
# Message contains hmac and local HMAC_KEY not set, or vice versa. This is not allowed.
err = "hmac key config not symmetric"
logger.warning(err)
self._return_error(errors.SecurityError(err))
self.state = "data"
if self.state == "data" and len(self.data) >= self.request.data_size:
log("... enough data received to process data.")
# A oneway call can be immediately followed by another call. Otherwise, we should not receive any
# additional data until we have sent a response
if self.request.flags & Pyro4.message.FLAGS_ONEWAY:
if self.request.type == message.MSG_PING:
error_msg = "ONEWAY ping doesn't make sense"
self._return_error(errors.ProtocolError(error_msg))
else:
if len(self.data) > self.request.data_size:
self.transport.loseConnection()
error_msg = "max message size exceeded (%d where max=%d)" % \
(self.request.data_size + self.request.annotations_size, Pyro4.config.MAX_MESSAGE_SIZE)
self._return_error(errors.ProtocolError(error_msg))
# Transfer data to message
self.request.data = self.data[:self.request.data_size]
self.data = self.data[self.request.data_size:]
# Execute message
d = Deferred()
if self.request.type == message.MSG_CONNECT:
raise NotImplementedError("No action provided for MSG_CONNECT")
elif self.request.type == message.MSG_CONNECTOK:
# We only reach this spot if it is a valid message type so we're in client handshake mode. Update
# protocol to support client __call__ execution (i.e. invocation)
self.required_message_types = [message.MSG_CONNECTOK]
raise NotImplementedError("No action provided for MSG_CONNECTOK")
elif self.request.type == message.MSG_CONNECTFAIL:
raise NotImplementedError("No action provided for MSG_CONNECTFAIL")
elif self.request.type == message.MSG_INVOKE:
log("Responding to invoke request.")
# Must be a static method so the Protocol can reset after oneway messages
d.addCallback(self._pyro_remote_call)
reactor.callLater(0, d.callback, self.request)
elif self.request.type == message.MSG_PING:
log("Responding to ping request.")
reactor.callLater(0, d.callback, b"pong")
elif self.request.type == message.MSG_RESULT:
# Trigger callback with data or raise exception
raise NotImplementedError("No action provided for MSG_RESULT")
if self.request.flags & Pyro4.message.FLAGS_ONEWAY:
log("... ONEWAY request, not building response.")
def reraise(response):
if isinstance(response, Exception):
log.exception("ONEWAY call resulted in an exception: %s" % str(response))
return Failure(response)
d.addCallback(reraise)
# In Pyro4 core, the ONEWAY_THREADED option determines whether or not the execution order of ONEWAY
# calls is guaranteed. To replicate this behavior, we reference the same flag.
if Pyro4.config.ONEWAY_THREADED:
self.reset()
else:
self.state = "blocked"
def process_next_message(response):
self.reset()
return response
d.addBoth(process_next_message)
else:
log("... appending response callbacks.")
# If the previous call was not oneway, we maintain state on the protocol
log("... setting state to 'response'")
self.state = "response"
log("... adding build/send callbacks")
d.addCallback(self._build_response)
d.addCallback(self._send_response)
if self.state == "response" and len(self.data) > 0:
error_msg = "data received while in response state" % \
(self.request.data_size + self.request.annotations_size, Pyro4.config.MAX_MESSAGE_SIZE)
self._return_error(errors.ProtocolError(error_msg))
if self.state == "blocked":
# Waiting on a ONEWAY call (with guaranteed execution order) to complete. When it completes, the system
# will reset itself to accept the next call.
pass
def testMaxDataSize(self):
msg = Message(Pyro4.message.MSG_CONNECT, b"hello", 42, 0, 0)
msg.data_size = 0x7fffffff # still within 32 bits signed limits
msg.to_bytes()
msg.data_size = 0x80000000 # overflow, Pyro has a 2 gigabyte message size limitation
with self.assertRaises(ValueError) as ex:
msg.to_bytes()
self.assertEqual("invalid message size (outside range 0..2Gb)",
str(ex.exception))
msg.data_size = -42
with self.assertRaises(ValueError) as ex:
msg.to_bytes()
self.assertEqual("invalid message size (outside range 0..2Gb)",
str(ex.exception))
def handleRequest(self, conn):
"""
Handle incoming Pyro request. Catches any exception that may occur and
wraps it in a reply to the calling side, as to not make this server side loop
terminate due to exceptions caused by remote invocations.
"""
request_flags = 0
request_seq = 0
request_serializer_id = util.MarshalSerializer.serializer_id
wasBatched = False
isCallback = False
try:
msg = Message.recv(
conn, [Pyro4.message.MSG_INVOKE, Pyro4.message.MSG_PING])
request_flags = msg.flags
request_seq = msg.seq
request_serializer_id = msg.serializer_id
if Pyro4.config.LOGWIRE:
log.debug(
"daemon wiredata received: msgtype=%d flags=0x%x ser=%d seq=%d data=%r"
% (msg.type, msg.flags, msg.serializer_id, msg.seq,
msg.data))
if msg.type == Pyro4.message.MSG_PING:
# return same seq, but ignore any data (it's a ping, not an echo). Nothing is deserialized.
msg = Message(Pyro4.message.MSG_PING, b"pong",
msg.serializer_id, 0, msg.seq)
if Pyro4.config.LOGWIRE:
log.debug(
"daemon wiredata sending: msgtype=%d flags=0x%x ser=%d seq=%d data=%r"
% (msg.type, msg.flags, msg.serializer_id, msg.seq,
msg.data))
conn.send(msg.to_bytes())
return
if msg.serializer_id not in self.__serializer_ids:
raise errors.ProtocolError(
"message used serializer that is not accepted: %d" %
msg.serializer_id)
serializer = util.get_serializer_by_id(msg.serializer_id)
objId, method, vargs, kwargs = serializer.deserializeCall(
msg.data,
compressed=msg.flags & Pyro4.message.FLAGS_COMPRESSED)
del msg # invite GC to collect the object, don't wait for out-of-scope
obj = self.objectsById.get(objId)
if obj is not None:
if kwargs and sys.version_info < (2, 6,
5) and os.name != "java":
# Python before 2.6.5 doesn't accept unicode keyword arguments
kwargs = dict((str(k), kwargs[k]) for k in kwargs)
if request_flags & Pyro4.message.FLAGS_BATCH:
# batched method calls, loop over them all and collect all results
data = []
for method, vargs, kwargs in vargs:
method = util.resolveDottedAttribute(
obj, method, Pyro4.config.DOTTEDNAMES)
try:
result = method(
*vargs, **kwargs
) # this is the actual method call to the Pyro object
except Exception:
xt, xv = sys.exc_info()[0:2]
log.debug(
"Exception occurred while handling batched request: %s",
xv)
xv._pyroTraceback = util.formatTraceback(
detailed=Pyro4.config.DETAILED_TRACEBACK)
if sys.platform == "cli":
util.fixIronPythonExceptionForPickle(
xv, True) # piggyback attributes
data.append(futures._ExceptionWrapper(xv))
break # stop processing the rest of the batch
else:
data.append(result)
wasBatched = True
else:
# normal single method call
method = util.resolveDottedAttribute(
obj, method, Pyro4.config.DOTTEDNAMES)
if request_flags & Pyro4.message.FLAGS_ONEWAY and Pyro4.config.ONEWAY_THREADED:
# oneway call to be run inside its own thread
thread = threadutil.Thread(target=method,
args=vargs,
kwargs=kwargs)
thread.setDaemon(True)
thread.start()
else:
isCallback = getattr(method, "_pyroCallback", False)
data = method(
*vargs, **kwargs
) # this is the actual method call to the Pyro object
else:
log.debug("unknown object requested: %s", objId)
raise errors.DaemonError("unknown object")
if request_flags & Pyro4.message.FLAGS_ONEWAY:
return # oneway call, don't send a response
else:
data, compressed = serializer.serializeData(
data, compress=Pyro4.config.COMPRESSION)
response_flags = 0
if compressed:
response_flags |= Pyro4.message.FLAGS_COMPRESSED
if wasBatched:
response_flags |= Pyro4.message.FLAGS_BATCH
if Pyro4.config.LOGWIRE:
log.debug(
"daemon wiredata sending: msgtype=%d flags=0x%x ser=%d seq=%d data=%r"
% (Pyro4.message.MSG_RESULT, response_flags,
serializer.serializer_id, request_seq, data))
msg = Message(Pyro4.message.MSG_RESULT, data,
serializer.serializer_id, response_flags,
request_seq)
conn.send(msg.to_bytes())
except Exception:
xt, xv = sys.exc_info()[0:2]
if xt is not errors.ConnectionClosedError:
log.debug("Exception occurred while handling request: %r", xv)
if not request_flags & Pyro4.message.FLAGS_ONEWAY:
# only return the error to the client if it wasn't a oneway call
tblines = util.formatTraceback(
detailed=Pyro4.config.DETAILED_TRACEBACK)
self._sendExceptionResponse(conn, request_seq,
request_serializer_id, xv,
tblines)
if isCallback or isinstance(
xv, (errors.CommunicationError, errors.SecurityError)):
raise # re-raise if flagged as callback, communication or security error.