Recover from no session/ no prekey exceptions

Fixes #939 Echo Client crash new number
Fixes #961 Exception: No such signedprekeyrecord!
Fixes #869 No such signedprekeyrecord! 1040
Fixes #593 axolotl: NoSessionException
Fixes #683 Message decrypt error

Author: tgalal

yowsup/layers/axolotl/layer.py

@@ -15,10 +15,12 @@
 from yowsup.structs import ProtocolTreeNode
 from .protocolentities import GetKeysIqProtocolEntity, ResultGetKeysIqProtocolEntity
 from axolotl.util.hexutil import HexUtil
-from yowsup.env import CURRENT_ENV
 from axolotl.invalidmessageexception import InvalidMessageException
 from .protocolentities import EncryptNotification
 from yowsup.layers.protocol_acks.protocolentities import OutgoingAckProtocolEntity
+from axolotl.invalidkeyidexception import InvalidKeyIdException
+from axolotl.nosessionexception import NoSessionException
+from .protocolentities.receipt_outgoing_retry import RetryOutgoingReceiptProtocolEntity
 import binascii
 import sys
 
@@ -40,6 +42,7 @@ def __init__(self):
 
         self.sessionCiphers = {}
         self.pendingMessages = {}
+        self.pendingIncomingMessages = {}
         self.skipEncJids = []
 
     def __str__(self):
@@ -101,6 +104,10 @@ def receive(self, protocolTreeNode):
             elif protocolTreeNode.tag == "notification" and protocolTreeNode["type"] == "encrypt":
                 self.onEncryptNotification(protocolTreeNode)
                 return
+            elif protocolTreeNode.tag == "receipt" and protocolTreeNode["type"] == "retry":
+                # should bring up that message, resend it, but in upper layer?
+                # as it might have to be fetched from a persistent storage
+                pass
             self.toUpper(protocolTreeNode)
     ######
 
@@ -130,6 +137,13 @@ def processPendingMessages(self, jid):
 
             del self.pendingMessages[jid]
 
+    def processPendingIncomingMessages(self, jid):
+        if jid in self.pendingIncomingMessages:
+            for messageNode in self.pendingIncomingMessages[jid]:
+                self.onMessage(messageNode)
+
+            del self.pendingIncomingMessages[jid]
+
     #### handling message types
 
     def handlePlaintextNode(self, node):
@@ -143,7 +157,7 @@ def handlePlaintextNode(self, node):
                 self.pendingMessages[node["to"]] = []
             self.pendingMessages[node["to"]].append(node)
 
-            self._sendIq(entity, self.onGetKeysResult, self.onGetKeysError)
+            self._sendIq(entity, lambda a, b: self.onGetKeysResult(a, b, self.processPendingMessages), self.onGetKeysError)
         else:
 
             sessionCipher = self.getSessionCipher(recipient_id)
@@ -172,9 +186,29 @@ def handleEncMessage(self, node):
                 self.handlePreKeyWhisperMessage(node)
             else:
                 self.handleWhisperMessage(node)
-        except InvalidMessageException:
-            logger.error("Invalid message from %s!! Your axololtl database data might be inconsistent with WhatsApp, or with what that contact has" % node["from"])
-            sys.exit(1)
+        except InvalidMessageException as e:
+            # logger.error("Invalid message from %s!! Your axololtl database data might be inconsistent with WhatsApp, or with what that contact has" % node["from"])
+            # sys.exit(1)
+            logger.error(e)
+            retry = RetryOutgoingReceiptProtocolEntity.fromMesageNode(node)
+            retry.setRegData(self.store.getLocalRegistrationId())
+            self.toLower(retry.toProtocolTreeNode())
+        except InvalidKeyIdException as e:
+            logger.error(e)
+            retry = RetryOutgoingReceiptProtocolEntity.fromMesageNode(node)
+            retry.setRegData(self.store.getLocalRegistrationId())
+            self.toLower(retry.toProtocolTreeNode())
+        except NoSessionException as e:
+            logger.error(e)
+            entity = GetKeysIqProtocolEntity([node["from"]])
+            if node["from"] not in self.pendingIncomingMessages:
+                self.pendingIncomingMessages[node["from"]] = []
+            self.pendingIncomingMessages[node["from"]].append(node)
+
+            self._sendIq(entity, lambda a, b: self.onGetKeysResult(a, b, self.processPendingIncomingMessages), self.onGetKeysError)
+
+
+
     def handlePreKeyWhisperMessage(self, node):
         pkMessageProtocolEntity = EncryptedMessageProtocolEntity.fromProtocolTreeNode(node)
 
@@ -243,7 +277,7 @@ def persistKeys(self, registrationId, identityKeyPair, preKeys, signedPreKey, fr
     def onSentKeysError(self, errorNode, keysEntity):
         raise Exception("Sent keys were not accepted")
 
-    def onGetKeysResult(self, resultNode, getKeysEntity):
+    def onGetKeysResult(self, resultNode, getKeysEntity, processPendingFn):
         entity = ResultGetKeysIqProtocolEntity.fromProtocolTreeNode(resultNode)
 
         resultJids = entity.getJids()
@@ -261,7 +295,7 @@ def onGetKeysResult(self, resultNode, getKeysEntity):
                                                self.store, recipient_id, 1)
             sessionBuilder.processPreKeyBundle(preKeyBundle)
 
-            self.processPendingMessages(jid)
+            processPendingFn(jid)
 
     def onGetKeysError(self, errorNode, getKeysEntity):
         pass

yowsup/layers/axolotl/protocolentities/receipt_outgoing_retry.py

@@ -0,0 +1,62 @@
+from yowsup.structs import ProtocolEntity, ProtocolTreeNode
+from yowsup.layers.protocol_receipts.protocolentities import OutgoingReceiptProtocolEntity
+from yowsup.layers.axolotl.protocolentities.iq_keys_get_result import ResultGetKeysIqProtocolEntity
+class RetryOutgoingReceiptProtocolEntity(OutgoingReceiptProtocolEntity):
+
+    '''
+    <receipt type="retry" to="xxxxxxxxxxx@s.whatsapp.net" id="1415389947-12" t="1432833777">
+        <retry count="1" t="1432833266" id="1415389947-12" v="1">
+        </retry>
+        <registration>
+            HEX:xxxxxxxxx
+        </registration>
+    </receipt>
+
+    '''
+
+    def __init__(self, _id, to, t, v = "1", count = "1",regData = ""):
+        super(RetryOutgoingReceiptProtocolEntity, self).__init__(_id,to)
+        self.setRetryData(t,v,count,regData)
+
+    def setRetryData(self, t,v,count,regData):
+        self.t = int(t)
+        self.v = int(v)
+        self.count = int(count)
+        self.regData = regData
+
+    def setRegData(self,regData):
+        '''
+        In axolotl layer:
+        regData = self.store.getLocalRegistrationId()
+        '''
+        self.regData = ResultGetKeysIqProtocolEntity._intToBytes(regData)
+
+    def toProtocolTreeNode(self):
+        node = super(RetryOutgoingReceiptProtocolEntity, self).toProtocolTreeNode()
+        node.setAttribute("type", "retry")
+        retry = ProtocolTreeNode("retry", {"count": str(self.count),"t":str(self.t),"id":self.getId(),"v":str(self.v)})
+        node.addChild(retry)
+        registration = ProtocolTreeNode("registration",data=self.regData)
+        node.addChild(registration)
+        return node
+
+    def __str__(self):
+        out = super(RetryOutgoingReceiptProtocolEntity, self).__str__()
+        return out
+
+    @staticmethod
+    def fromProtocolTreeNode(node):
+        entity = OutgoingReceiptProtocolEntity.fromProtocolTreeNode(node)
+        entity.__class__ = RetryOutgoingReceiptProtocolEntity
+        retryNode = node.getChild("retry")
+        entity.setRetryData(retryNode["t"], retryNode["v"], retryNode["count"], node.getChild("registration").data)
+
+
+    @staticmethod
+    def fromMesageNode(MessageNodeToBeRetried):
+        return RetryOutgoingReceiptProtocolEntity(
+            MessageNodeToBeRetried.getAttributeValue("id"),
+            MessageNodeToBeRetried.getAttributeValue("from"),
+            MessageNodeToBeRetried.getAttributeValue("t"),
+            MessageNodeToBeRetried.getChild("enc").getAttributeValue("v")
+        )

yowsup/layers/axolotl/store/sqlite/litesignedprekeystore.py

@@ -1,5 +1,6 @@
 from axolotl.state.signedprekeystore import SignedPreKeyStore
 from axolotl.state.signedprekeyrecord import SignedPreKeyRecord
+from axolotl.invalidkeyidexception import InvalidKeyIdException
 class LiteSignedPreKeyStore(SignedPreKeyStore):
     def __init__(self, dbConn):
         """
@@ -18,7 +19,7 @@ def loadSignedPreKey(self, signedPreKeyId):
 
         result = cursor.fetchone()
         if not result:
-            raise Exception("No such signedprekeyrecord! %s " % signedPreKeyId)
+            raise InvalidKeyIdException("No such signedprekeyrecord! %s " % signedPreKeyId)
 
         return SignedPreKeyRecord(serialized=result[0])