updates

komrade/backend/messages.py

@@ -26,12 +26,16 @@ class Message(Logger):
         self.from_name=msg_d.get('_from_name')
         self.from_pubkey=msg_d.get('_from_pub')
         self.msg=msg_d.get('_msg')
+        self.embedded_msg=None  # only if this message has an embedded one
+        self._route=msg_d.get(ROUTE_KEYNAME)
         self.caller=caller
         self.callee=callee
         # get operators straight away?
         if not self.caller or not self.callee:
             self.get_callers()
 
+
+    ## loading messages
     def get_callers(self,msg_d):
         if self.caller is not None and self.callee is not None:
             return (self.caller,self.callee) 
@@ -65,6 +69,7 @@ class Message(Logger):
     def decrypt(self,recursive=True):
         # get callers
         caller,callee = self.get_callers()
+        self.log(f'attempting to decrypt msg {self.msg}' from {caller} to {caller}'')
         # decrypt msg
         decr_msg = caller.unpackage_msg_from(
             self.msg,
@@ -76,7 +81,24 @@ class Message(Logger):
         
         # now, is the decrypted message itself a message?
         if recursive and is_valid_msg_d(decr_msg):
-            # then ... make that, a message object, and decrypt it too!
-            self.msg_obj = decr_msg
-            self.msg_obj.decrypt()
+            # then ... make that, a message object and decrypt it too!
+            self.embedded_msg = Message(decr_msg)
+            self.embedded_msg.decrypt()
         return decr_msg
+
+
+
+    ## msg properties
+    def has_embedded_msg(self):
+        return self.embedded_msg is not None
+
+    @property
+    def messages(self):
+        # move through msgs recursively
+        msgs = [self] if not self.has_embedded_msg else [self] + self.embedded_msg.messages
+        return msgs
+
+    @property
+    def route(self):
+        for msg in self.messages:
+            if msg._route: return msg._route 

komrade/backend/the_operator.py

@@ -72,51 +72,12 @@ class TheOperator(Operator):
         self.log('msg_encr_caller2caller_caller2phone_phone2phone incoming',msg_encr_caller2caller_caller2phone_phone2phone)
 
         # make top-level message object, addressed to me the operator
-        msg = Message(msg_d,caller=self.phone,callee=self)
-        msg.decrypt()
+        from komrade.backend.messages import Message
+        msg_obj = Message(msg_d,caller=self.phone,callee=self)
+        msg_obj.decrypt()
 
-
-
-        # TOTAL_MSG_CHAIN = {}
-        # TOTAL_DECR_MSG
-
-        # # top layer: phone -> me, the op
-        # msg_d = msg_encr_caller2caller_caller2phone = self.unpackage_msg_from(
-        #     msg_encr_caller2caller_caller2phone_phone2phone,
-        #     self.phone
-        # )
-        # self.log('Operator unrolled the first layer of encryption:',msg_encr_caller2caller_caller2phone)
-        # assert type(msg_encr_caller2caller_caller2phone)==dict
-        
-        # # is there another layer, encrypted caller2phone ?
-        # msg_d['_msg'] = self.unpackage_msg_dict(msg_d)
-
-        # # merge unencrypted messages
-
-
-
-        # route=None
-        # if _msg and type(_msg)==bytes:
-        #     alleged_name = msg_d.get('_from_name')
-        #     alleged_pubkey = msg_d.get('_from_pub')
-        #     if alleged_pubkey and alleged_name:
-        #         alleged_caller = Caller(alleged_name)
-        #         assert alleged_caller.pubkey == alleged_pubkey
-
-        #         msg_d2 = self.unpackage_msg_from(
-        #             _msg,
-        #             caller
-        #         )
-        #         assert type(msg_d2)==dict
-        #         _msg2 = msg_d2.get('_msg')
-        #         route = msg_d2.get('_msg',{}).get('_please')
-        #         dict_merge(_msg,_msg2)
-        #         msg_d['_msg'] = msg_d2
-        
-        # if not route:
-        #     route = msg_d.get('_msg',{}).get('_please',None)
-        
-        # return self.route(msg_d,_msg,route)
+        # route msg back to caller
+        return self.route(msg_obj)
 
 
 
@@ -126,16 +87,25 @@ class TheOperator(Operator):
         return encr_data_b
 
 
-    def route(self, msg_d, _msg, route=None):
-        if not route: route=_msg.get('_please')
-        if not route: raise KomradeException('no route!')
-        if '_please' in _msg: del _msg['_please']
+    def route(self, msg_obj):
+        # get route from msg
+        route = msg_obj.route
+
+        # no route?
+        if not msg_obj.route: raise KomradeException('no route!')
+        
+        # what we working with?
         self.log(f'route() got incoming msg_d = {msg_d}, _msg = {_msg}, and route = {route}')
+        
+        # hard code the acceptable routes
         if route == 'forge_new_keys':
-            return self.forge_new_keys(**_msg)
+            return self.forge_new_keys(msg)
+        
+        # otherwise, hang up and try again
         return OPERATOR_INTERCEPT_MESSAGE
 
-    def forge_new_keys(self,**data):
+    def forge_new_keys(self,msg_obj):
+        data = msg_obj.msg
         self.log('about to make some new keys!',data)
         
         # get keys

komrade/constants.py

@@ -150,4 +150,7 @@ PATH_OPERATOR_WEB_CONTACT_PH_URL = f'http://{KOMRADE_URL}/.contacts/TheTelephone
 ALLOW_CLEARNET = True
 
 
-DEBUG_DEFAULT_PASSPHRASE = 'all your base are belong to us'
+DEBUG_DEFAULT_PASSPHRASE = 'all your base are belong to us'
+
+
+ROUTE_KEYNAME = '_please'