meshcore 2.3.4__tar.gz → 2.3.6__tar.gz

{meshcore-2.3.4 → meshcore-2.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcore
-Version: 2.3.4
+Version: 2.3.6
 Summary: Base classes for communicating with meshcore companion radios
 Project-URL: Homepage, https://github.com/fdlamotte/meshcore_py
 Project-URL: Issues, https://github.com/fdlamotte/meshcore_py/issues

{meshcore-2.3.4 → meshcore-2.3.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "meshcore"
-version = "2.3.4"
+version = "2.3.6"
 authors = [
   { name="Florent de Lamotte", email="florent@frizoncorrea.fr" },
   { name="Alex Wolden", email="awolden@gmail.com" },

{meshcore-2.3.4 → meshcore-2.3.6}/src/meshcore/commands/base.py

@@ -64,6 +64,7 @@ class CommandHandlerBase:
         self._sender_func: Optional[Callable[[bytes], Coroutine[Any, Any, None]]] = None
         self._reader: Optional[MessageReader] = None
         self.dispatcher: Optional[EventDispatcher] = None
+        self._mesh_request_lock = asyncio.Lock()
         self.default_timeout = (
             default_timeout if default_timeout is not None else self.DEFAULT_TIMEOUT
         )

meshcore-2.3.6/src/meshcore/commands/binary.py

@@ -0,0 +1,357 @@
+import asyncio
+import logging
+import random
+import io
+
+from .base import CommandHandlerBase
+from ..events import EventType
+from ..packets import BinaryReqType
+from ..packets import AnonReqType
+
+logger = logging.getLogger("meshcore")
+
+
+class BinaryCommandHandler(CommandHandlerBase):
+    """Helper functions to handle binary requests through binary commands"""
+
+    async def req_status(self, contact, timeout=0, min_timeout=0):
+        logger.error("*** please consider using req_status_sync instead of req_status") 
+        return await self.req_status_sync(contact, timeout, min_timeout)
+
+    async def req_status_sync(self, contact, timeout=0, min_timeout=0):
+        async with self._mesh_request_lock:
+            res = await self.send_binary_req(
+                contact,
+                BinaryReqType.STATUS,
+                timeout=timeout,
+                min_timeout=min_timeout
+            )
+            if res.type == EventType.ERROR:
+                return None
+
+            exp_tag = res.payload["expected_ack"].hex()
+            timeout = res.payload["suggested_timeout"] / 800 if timeout == 0 else timeout
+            timeout = timeout if min_timeout < timeout else min_timeout
+
+            if self.dispatcher is None:
+                return None
+
+            status_event = await self.dispatcher.wait_for_event(
+                EventType.STATUS_RESPONSE,
+                attribute_filters={"tag": exp_tag},
+                timeout=timeout,
+            )
+
+            return status_event.payload if status_event else None
+
+    async def req_telemetry(self, contact, timeout=0, min_timeout=0):
+        logger.error("*** please consider using req_telemetry_sync instead of req_telemetry") 
+        return await self.req_telemetry_sync(contact, timeout, min_timeout)
+
+    async def req_telemetry_sync(self, contact, timeout=0, min_timeout=0):
+        async with self._mesh_request_lock:
+            res = await self.send_binary_req(
+                contact,
+                BinaryReqType.TELEMETRY,
+                timeout=timeout,
+                min_timeout=min_timeout
+            )
+            if res.type == EventType.ERROR:
+                return None
+
+            timeout = res.payload["suggested_timeout"] / 800 if timeout == 0 else timeout
+            timeout = timeout if min_timeout < timeout else min_timeout
+
+            if self.dispatcher is None:
+                return None
+
+            telem_event = await self.dispatcher.wait_for_event(
+                EventType.TELEMETRY_RESPONSE,
+                attribute_filters={"tag": res.payload["expected_ack"].hex()},
+                timeout=timeout,
+            )
+
+            return telem_event.payload["lpp"] if telem_event else None
+
+    async def req_mma(self, contact, timeout=0, min_timeout=0):
+        logger.error("*** please consider using req_mma_sync instead of req_mma") 
+        return await self.req_mma_sync(contact, start, end, timeout,min_timeout)
+
+    async def req_mma_sync(self, contact, start, end, timeout=0,min_timeout=0):
+        async with self._mesh_request_lock:
+            req = (
+                start.to_bytes(4, "little", signed=False)
+                + end.to_bytes(4, "little", signed=False)
+                + b"\0\0"
+            )
+            res = await self.send_binary_req(
+                contact,
+                BinaryReqType.MMA,
+                data=req,
+                timeout=timeout
+            )
+            if res.type == EventType.ERROR:
+                return None
+
+            timeout = res.payload["suggested_timeout"] / 800 if timeout == 0 else timeout
+            timeout = timeout if min_timeout < timeout else min_timeout
+
+            if self.dispatcher is None:
+                return None
+
+            mma_event = await self.dispatcher.wait_for_event(
+                EventType.MMA_RESPONSE,
+                attribute_filters={"tag": res.payload["expected_ack"].hex()},
+                timeout=timeout,
+            )
+
+            return mma_event.payload["mma_data"] if mma_event else None
+
+    async def req_acl(self, contact, timeout=0, min_timeout=0):
+        logger.error("*** please consider using req_acl_sync instead of req_acl") 
+        return await self.req_acl_sync(contact, timeout, min_timeout)
+
+    async def req_acl_sync(self, contact, timeout=0, min_timeout=0):
+        async with self._mesh_request_lock:
+            req = b"\0\0"
+            res = await self.send_binary_req(
+                contact,
+                BinaryReqType.ACL,
+                data=req,
+                timeout=timeout
+            )
+            if res.type == EventType.ERROR:
+                return None
+
+            timeout = res.payload["suggested_timeout"] / 800 if timeout == 0 else timeout
+            timeout = timeout if timeout > min_timeout else min_timeout
+
+            if self.dispatcher is None:
+                return None
+
+            acl_event = await self.dispatcher.wait_for_event(
+                EventType.ACL_RESPONSE,
+                attribute_filters={"tag": res.payload["expected_ack"].hex()},
+                timeout=timeout,
+            )
+
+            return acl_event.payload["acl_data"] if acl_event else None
+
+    async def req_neighbours_async(self,
+        contact,
+        count=255,
+        offset=0,
+        order_by=0,
+        pubkey_prefix_length=4,
+        timeout=0,
+        min_timeout=0
+    ):
+        req = (b"\x00" # version : 0
+            + count.to_bytes(1, "little", signed=False)
+            + offset.to_bytes(2, "little", signed=False)
+            + order_by.to_bytes(1, "little", signed=False)
+            + pubkey_prefix_length.to_bytes(1, "little", signed=False)
+            + random.randint(1, 0xFFFFFFFF).to_bytes(4, "little", signed=False)
+        )
+
+        logger.debug(f"Sending binary neighbours req, count: {count}, offset: {offset} {req.hex()}")
+
+        return await self.send_binary_req (
+            contact,
+            BinaryReqType.NEIGHBOURS,
+            data=req,
+            timeout=timeout,
+            context={"pubkey_prefix_length": pubkey_prefix_length}
+        )
+
+    async def req_neighbours_sync(self,
+        contact,
+        count=255,
+        offset=0,
+        order_by=0,
+        pubkey_prefix_length=4,
+        timeout=0,
+        min_timeout=0
+    ):
+        async with self._mesh_request_lock:
+            res = await self.req_neighbours_async(contact,
+                    count=count,
+                    offset=offset,
+                    order_by=order_by,
+                    pubkey_prefix_length=pubkey_prefix_length,
+                    timeout=timeout,
+                    min_timeout=min_timeout)
+
+            if res is None or res.type == EventType.ERROR:
+                return None
+
+            timeout = res.payload["suggested_timeout"] / 800 if timeout == 0 else timeout
+            timeout = timeout if min_timeout < timeout else min_timeout
+
+            if self.dispatcher is None:
+                return None
+
+            neighbours_event = await self.dispatcher.wait_for_event(
+                EventType.NEIGHBOURS_RESPONSE,
+                attribute_filters={"tag": res.payload["expected_ack"].hex()},
+                timeout=timeout,
+            )
+
+            return neighbours_event.payload if neighbours_event else None
+
+    # do several queries if not all neighbours have been obtained
+    async def fetch_all_neighbours(self,
+        contact,
+        order_by=0,
+        pubkey_prefix_length=4,
+        timeout=0,
+        min_timeout=0
+    ):
+
+        # Initial request
+        res = await self.req_neighbours_sync(contact,
+            count=255,
+            offset=0,
+            order_by=order_by,
+            pubkey_prefix_length=pubkey_prefix_length,
+            timeout=timeout,
+            min_timeout=min_timeout)
+
+        if res is None:
+            return None
+
+        neighbours_count = res["neighbours_count"] # total neighbours 
+        results_count = res["results_count"]       # obtained neighbours
+
+        del res["tag"]
+
+        tries = 0
+        while results_count < neighbours_count:
+            #await asyncio.sleep(2) # wait 2s before next fetch
+            next_res = await self.req_neighbours_sync(contact,
+                count=255,
+                offset=results_count,
+                order_by=order_by,
+                pubkey_prefix_length=pubkey_prefix_length,
+                timeout=timeout,
+                min_timeout=min_timeout+25) # requests are close and responses big, 
+                                            #so let's have some more timeout for duty cycle
+            if next_res is None :
+                if tries > 0:
+                    return res # caller should check it has everything
+                else:
+                    tries += 1
+            else:
+                tries = 0
+                results_count += next_res["results_count"]
+                res["results_count"] = results_count
+                res["neighbours"] += next_res["neighbours"]
+
+        return res
+
+    async def req_regions_async(self, contact, timeout=0, min_timeout=0):
+        req = b"\0" # The return path, I currently do nothing with, so direct only
+        return await self.send_anon_req(
+            contact,
+            AnonReqType.REGIONS,
+            data=req,
+            timeout=timeout
+        )
+        
+    async def req_regions_sync(self, contact, timeout=0, min_timeout=0):
+        async with self._mesh_request_lock:
+            res = await self.req_regions_async(contact, timeout, min_timeout)
+
+            if res.type == EventType.ERROR:
+                return None
+
+            timeout = res.payload["suggested_timeout"] / 800 if timeout == 0 else timeout
+            timeout = timeout if timeout > min_timeout else min_timeout
+
+            if self.dispatcher is None:
+                return None
+
+            region_event = await self.dispatcher.wait_for_event(
+                EventType.BINARY_RESPONSE,
+                attribute_filters={"tag": res.payload["expected_ack"].hex()},
+                timeout=timeout,
+            )
+
+            if region_event is None:
+                return None
+
+            pkt = bytes().fromhex(region_event.payload["data"])
+            pbuf = io.BytesIO(pkt)
+            tag_again = pbuf.read(4)
+            return pbuf.read().decode("utf-8", "ignore").strip("\x00")
+
+    async def req_owner_async(self, contact, timeout=0, min_timeout=0):
+        req = b"\0"
+        return await self.send_anon_req(
+            contact,
+            AnonReqType.OWNER,
+            data=req,
+            timeout=timeout
+        )
+
+    async def req_owner_sync(self, contact, timeout=0, min_timeout=0):
+        async with self._mesh_request_lock:
+            res = await self.req_owner_async(contact, timeout, min_timeout)
+
+            if res.type == EventType.ERROR:
+                return None
+
+            timeout = res.payload["suggested_timeout"] / 800 if timeout == 0 else timeout
+            timeout = timeout if timeout > min_timeout else min_timeout
+
+            if self.dispatcher is None:
+                return None
+
+            owner_event = await self.dispatcher.wait_for_event(
+                EventType.BINARY_RESPONSE,
+                attribute_filters={"tag": res.payload["expected_ack"].hex()},
+                timeout=timeout,
+            )
+
+            if owner_event is None:
+                return None
+
+            pkt = bytes().fromhex(owner_event.payload["data"])
+            pbuf = io.BytesIO(pkt)
+            tag_again = pbuf.read(4)
+            strings = pbuf.read().decode("utf-8", "ignore").split("\n", 1)
+
+            return dict(name=strings[0], owner=strings[1].strip("\x00"))
+
+    async def req_basic_async(self, contact, timeout=0, min_timeout=0):
+        req = b"\0"
+        return await self.send_anon_req(
+            contact,
+            AnonReqType.BASIC,
+            data=req,
+            timeout=timeout
+        )
+
+    async def req_basic_sync(self, contact, timeout=0, min_timeout=0):
+        async with self._mesh_request_lock:
+            res = await self.req_basic_async(contact, timeout, min_timeout)
+
+            if res.type == EventType.ERROR:
+                return None
+
+            timeout = res.payload["suggested_timeout"] / 800 if timeout == 0 else timeout
+            timeout = timeout if timeout > min_timeout else min_timeout
+
+            if self.dispatcher is None:
+                return None
+
+            basic_event = await self.dispatcher.wait_for_event(
+                EventType.BINARY_RESPONSE,
+                attribute_filters={"tag": res.payload["expected_ack"].hex()},
+                timeout=timeout,
+            )
+
+            if basic_event is None:
+                return None
+
+            return basic_event.payload

{meshcore-2.3.4 → meshcore-2.3.6}/src/meshcore/commands/messaging.py

@@ -24,18 +24,37 @@ class MessagingCommands(CommandHandlerBase):
             timeout,
         )
 
-    async def send_login(self, dst: DestinationType, pwd: str) -> Event:
+    async def _send_login_raw(self, dst: DestinationType, pwd: str) -> Event:
         dst_bytes = _validate_destination(dst, prefix_length=32)
         logger.debug(f"Sending login request to: {dst_bytes.hex()}")
         data = b"\x1a" + dst_bytes + pwd.encode("utf-8")
         return await self.send(data, [EventType.MSG_SENT, EventType.ERROR])
 
+    async def send_login(self, dst: DestinationType, pwd: str) -> Event:
+        logger.warning("*** please consider using send_login_sync instead of send_login")
+        return await self._send_login_raw(dst, pwd)
+
+    async def send_login_sync(self, dst: DestinationType, pwd: str, timeout=0, min_timeout=0) -> Optional[Event]:
+        """Send login to a remote node and wait for the response."""
+        async with self._mesh_request_lock:
+            result = await self._send_login_raw(dst, pwd)
+            if result is None or result.type == EventType.ERROR:
+                return None
+            timeout = result.payload["suggested_timeout"] / 800 if timeout == 0 else timeout
+            timeout = timeout if timeout > min_timeout else min_timeout
+            login_event = await self.dispatcher.wait_for_event(
+                EventType.LOGIN_SUCCESS,
+                timeout=timeout,
+            )
+            return login_event
+
     async def send_logout(self, dst: DestinationType) -> Event:
         dst_bytes = _validate_destination(dst, prefix_length=32)
         data = b"\x1d" + dst_bytes
         return await self.send(data, [EventType.OK, EventType.ERROR])
 
     async def send_statusreq(self, dst: DestinationType) -> Event:
+        logger.warning("*** please consider using req_status_sync instead of send_statusreq")
         dst_bytes = _validate_destination(dst, prefix_length=32)
         logger.debug(f"Sending status request to: {dst_bytes.hex()}")
         data = b"\x1b" + dst_bytes
@@ -85,7 +104,7 @@ class MessagingCommands(CommandHandlerBase):
         self, dst: DestinationType, msg: str, timestamp: Optional[int] = None,
         max_attempts=3, max_flood_attempts=2, flood_after=2, timeout=0, min_timeout=0
     ) -> Event:
-        
+
         try:
             dst_bytes = _validate_destination(dst, prefix_length=32)
             # with 32 bytes we can reset to flood
@@ -105,8 +124,8 @@ class MessagingCommands(CommandHandlerBase):
             # we can't know if we're flood without fetching all contacts
             # if we have a full key (meaning we can reset path) consider direct
             # else consider flood
-            flood = len(dst_bytes) < 32 
-            logger.info(f"send_msg_with_retry: can't determine if flood, assume {flood}")
+            flood = len(dst_bytes) < 32
+            logger.info(f"send_msg_with_retry: can't determine if flood, assume {flood}")
         res = None
         while attempts < max_attempts and res is None \
                     and (not flood or flood_attempts < max_flood_attempts):
@@ -122,8 +141,8 @@ class MessagingCommands(CommandHandlerBase):
                         contact["out_path_len"] = -1
 
             if attempts > 0:
-                logger.info(f"Retry sending msg: {attempts + 1}")
-                
+                logger.info(f"Retry sending msg: {attempts + 1}")
+
             result = await self.send_msg(dst, msg, timestamp, attempt=attempts)
             if result.type == EventType.ERROR:
                 logger.error(f"⚠️ Failed to send message: {result.payload}")
@@ -131,14 +150,14 @@ class MessagingCommands(CommandHandlerBase):
             exp_ack = result.payload["expected_ack"].hex()
             timeout = result.payload["suggested_timeout"] / 1000 * 1.2 if timeout==0 else timeout
             timeout = timeout if timeout > min_timeout else min_timeout
-            res = await self.dispatcher.wait_for_event(EventType.ACK, 
-                        attribute_filters={"code": exp_ack}, 
+            res = await self.dispatcher.wait_for_event(EventType.ACK,
+                        attribute_filters={"code": exp_ack},
                         timeout=timeout)
 
             attempts = attempts + 1
             if flood :
                 flood_attempts = flood_attempts + 1
-    
+
         return None if res is None else result
 
     async def send_chan_msg(self, chan: int, msg: str, timestamp: Optional[int|bytes] = None) -> Event:
@@ -166,17 +185,36 @@ class MessagingCommands(CommandHandlerBase):
         return await self.send(data, [EventType.OK, EventType.ERROR])
 
     async def send_telemetry_req(self, dst: DestinationType) -> Event:
+        logger.warning("*** please consider using req_telemetry_sync instead of send_telemetry_req")
         dst_bytes = _validate_destination(dst, prefix_length=32)
         logger.debug(f"Asking telemetry to {dst_bytes.hex()}")
         data = b"\x27\x00\x00\x00" + dst_bytes
         return await self.send(data, [EventType.MSG_SENT, EventType.ERROR])
 
-    async def send_path_discovery(self, dst: DestinationType) -> Event:
+    async def _send_path_discovery_raw(self, dst: DestinationType) -> Event:
         dst_bytes = _validate_destination(dst, prefix_length=32)
         logger.debug(f"Path discovery request for {dst_bytes.hex()}")
         data = b"\x34\x00" + dst_bytes
         return await self.send(data, [EventType.MSG_SENT, EventType.ERROR])
 
+    async def send_path_discovery(self, dst: DestinationType) -> Event:
+        logger.warning("*** please consider using send_path_discovery_sync instead of send_path_discovery")
+        return await self._send_path_discovery_raw(dst)
+
+    async def send_path_discovery_sync(self, dst: DestinationType, timeout=0, min_timeout=0) -> Optional[Event]:
+        """Send path discovery request and wait for the response."""
+        async with self._mesh_request_lock:
+            result = await self._send_path_discovery_raw(dst)
+            if result is None or result.type == EventType.ERROR:
+                return None
+            timeout = result.payload["suggested_timeout"] / 800 if timeout == 0 else timeout
+            timeout = timeout if timeout > min_timeout else min_timeout
+            path_event = await self.dispatcher.wait_for_event(
+                EventType.PATH_RESPONSE,
+                timeout=timeout,
+            )
+            return path_event
+
     async def send_trace(
         self,
         auth_code: int = 0,

{meshcore-2.3.4 → meshcore-2.3.6}/src/meshcore/meshcore_parser.py

@@ -108,17 +108,14 @@ class MeshcorePacketParser:
                         channel = c
                         break
 
-            chan_name = ""
-
-            if channel is None :
-                chan_name = chan_hash
-            else:
-                chan_name = channel["channel_name"]
-
             log_data["chan_hash"] = chan_hash
             log_data["cipher_mac"] = cipher_mac.hex()
             log_data["crypted"] = msg.hex()
-            log_data["chan_name"] = chan_name
+
+            chan_name = ""
+            if not channel is None :
+                chan_name = channel["channel_name"]
+                log_data["chan_name"] = chan_name
 
             if not channel is None and self.decrypt_channels: