Add anonymous region request

[Beanow]

Feature added in meshcore-dev/MeshCore@3af2549
Now in 1.12.0 release.

[fdlamotte]

right, did not follow this one due to my moving ...

I'll take care of it (after all meshcore_py was first to implement regions ;))

[Beanow]

I was able to somewhat hack the requests together. But the binding doesn't seem to offer it yet.

The flow is comparable to send_binary_req
But starting the packet with b"\x39"

    async def send_anon_req(self, dst: DestinationType, request_type: AnonReqType, data: Optional[bytes] = None, context={}, timeout=None, min_timeout=0) -> Event:
        dst_bytes = _validate_destination(dst, prefix_length=32)
        pubkey_prefix = _validate_destination(dst, prefix_length=6)
        logger.debug(f"Binary request to {dst_bytes.hex()}")
        data = b"\x39" + dst_bytes + request_type.value.to_bytes(1, "little", signed=False) + (data if data else b"")

        result = await self.send(data, [EventType.MSG_SENT, EventType.ERROR])
        
        # Register the request with the reader if we have both reader and request_type
        if (result.type == EventType.MSG_SENT and 
            self._reader is not None and 
            request_type is not None):
            
            exp_tag = result.payload["expected_ack"].hex()
            # Use provided timeout or fallback to suggested timeout (with 5s default)
            actual_timeout = timeout if timeout is not None and timeout > 0 else result.payload.get("suggested_timeout", 4000) / 800.0
            actual_timeout = min_timeout if actual_timeout < min_timeout else actual_timeout
            self._reader.register_binary_request(pubkey_prefix.hex(), exp_tag, request_type, actual_timeout, context=context)

        return result

Then allows a command something like

    async def req_regions_sync(self, contact, timeout=0, min_timeout=0):
        req = b"\0" # The return path, I currently do nothing with, so direct only
        res = await self.send_anon_req(
            contact,
            AnonReqType.REGIONS,
            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
            
        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")

[Beanow]

And the other anon requests seem missing too.

class AnonReqType(Enum):
    REGIONS = 0x01
    OWNER = 0x02
    BASIC = 0x03 # just remote clock

[Beanow]

Parsing the owner response seems along these lines.

        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])

[fdlamotte]

I've uploaded a first implementation, mostly using your code @Beanow seems to be working mostly

[Beanow]

Yeah the main parts I didn't get around to figuring out were:

For the _sync functie there's this listener for pending binary responses. But the AnonReqType enum starts from 0 again, so the parsing logic may need some massaging in order to match different responses.

Also the return path. For a request several hops away you'd have to discover a path first.
https://github.com/meshcore-dev/MeshCore/blob/main/docs/payloads.md#repeater---regions-request

[fdlamotte]

Thanks for the feedback

I'll probably use the path from the contact if available, and try 0 hop (with a warning) if not set

for the listener, I'll investigate ...

Edit: I've understood the issue with AnonReqType ... you're right there will be issues with request_type and the reader might generate unwanted events (and there might even be parsing errors) these events will be catch by nobody. Events will not mix as they are tracked with their tag ... so there might be some issues, and I'll find a way ;)

[fdlamotte]

I got the idea behind the return path thing ...

I'll reflect on how to handle this best, at first I'll use path in contact, maybe if there is no path set, I'll try a discover path