DaaS-IoT builds a logical network on top of heterogeneous communication technologies. Ethernet, Wi-Fi, BLE, and the ability to integrate additional drivers provide connectivity between devices; the DaaS-IoT overlay adds identities independent of physical addresses, segment membership, DDO exchange, multi-hop routing, and a shared time reference.
The application operates on SIDs, DINs, typesets, and DDOs. libdaas maintains node state and implements the protocol; drivers adapt the core to the available links. A change in address, technology, or path does not alter the identity through which the application recognizes a peer.
The node is the operational unit
A node is an instance of the DaaS-IoT runtime. It may be hosted on a microcontroller, a gateway, a server process, or a mobile application. Multiple nodes may run on the same host, provided that they maintain separate identities and resources.
Each node manages:
- its own SID/DIN pair;
- local drivers and endpoints;
- mappings to directly reachable peers;
- local knowledge of nodes and paths;
- RX, TX, and real-time queues;
- acceptance and delivery policies;
- discovery and routing state;
- the offset and validity of dATS synchronization.
State is local. There is no global table read by all participants at the same instant: each node updates its own view through configuration, discovery, traffic, mappings, and route discovery.
SID, DIN, and logical segment
The SID identifies the DaaS-IoT segment. The DIN identifies a node within the network's operational context. The SID/DIN pair belongs to the overlay and remains distinct from the address used by the driver.
| Overlay identity | Underlay adaptation |
|---|---|
SID + DIN | link + URI |
100 + 42 | INET4 + 192.0.2.10:4000 |
A segment is therefore a logical domain, not an IP subnet and not a single physical link. It may include nodes distributed across multiple IP networks, radio connections, and serial buses. Likewise, the same physical infrastructure may carry distinct segments.
Bootstrap and network formation
Bootstrap begins with the node identity. SID and DIN are defined first; the runtime is then initialized and at least one driver is configured with its local endpoint. From this foundation, the network can be formed manually or through discovery.
Manual configuration
When identities and endpoints are known, each node receives explicit SID and DIN values. A mapping then associates the remote DIN with the peer's link and URI.
The mapping creates a concrete adjacency in the overlay. Two nodes form the smallest possible network; additional mappings and forwarding functions extend the topology.
Formation through discovery
Discovery removes the need to know the ingress endpoint in advance. SID and DIN are still defined before the driver: they may be preassigned values or 0 when they must be acquired or confirmed during join.
A node with an available segment responds with the ingress node, SID, and link. The joining node selects the result and performs the join. The protocol completes dATS synchronization, determines the effective SID and DIN, and creates the first mapping.
The node exposing the segment may limit itself to responding to requests; a joining node may limit itself to searching. Participants authorized for both roles can detect existing networks while also providing an ingress point for their own segment.
Control plane and data plane
The overlay separates operations that maintain the network from the transfer of application data.
The control plane manages identities, discovery, join, mappings, policies, route discovery, driver state, and dATS synchronization. Its messages update the local knowledge required to decide how traffic should be handled.
The data plane carries DDOs and streams. It uses mappings and routes produced by the control plane, applies delivery policies, and maintains the queues needed to absorb speed differences between the application and the transports.
The separation does not imply two different networks. The control plane and data plane share the same nodes and drivers, but serve different responsibilities.
From DDO to physical transfer
The DDO is the application's data unit. It identifies the typeset and contains the payload, origin, and timestamp. The typeset defines how to interpret the payload without binding it to the language or transport being used.
To cross the network, the DDO is carried by the DME, which contains the protocol information required for delivery. The driver receives the DaaS-IoT frame and transfers it over the physical medium without reinterpreting the application payload.
An intermediate node examines the information required for forwarding and delegates the DME to the next hop. The new hop may use a different driver. Origin, logical destination, typeset, timestamp, and payload remain unchanged along the path.
Drivers and adjacencies
A driver connects libdaas to an underlay technology. It manages endpoints, channel opening and closing, reads and writes, MTU, link state, and link errors. DriverKit makes it possible to implement the same contract for proprietary technologies.
A node may have multiple active drivers at the same time. Each usable relationship with a peer forms an overlay adjacency associated with a specific link and endpoint.
The two adjacencies between A and B are alternative channels to the same DIN. The adjacency to C may instead become the first hop of a route used to reach other nodes.
Failover and routing are different decisions
Failover selects another channel to a peer when the current link is no longer usable or does not satisfy policy. For example, the same logical mapping may first be reached over Ethernet, then over Wi-Fi, and finally over BLE.
Routing instead selects a sequence of intermediate nodes when the destination is not directly reachable or when an alternative path provides better conditions.
The two decisions may be combined: a route selects the next hop, while failover determines which driver to use to reach it.
Distributed routing
Each node makes its next-hop decision using its own view of the topology. If it does not know a path to the destination DIN, it starts a search bounded by a timeout and TTL. A valid route is retained temporarily and reevaluated when it expires or when a transfer reports that it is no longer usable.
The best path is not necessarily the one with the fewest hops. Availability, observed latency, errors, retries, and channel state may favor a more reliable or faster route.
In this case, A may delegate the DME to C. Each node resolves only its own next hop; no central controller is required to make continuous decisions for the entire mesh.
dATS and temporal consensus
Each participant has a local clock subject to offset and drift. dATS brings these clocks onto a segment-wide shared reference without requiring a central time server.
The first DDO-ATS exchange calculates the correction required by the node joining the network. Once the offset has been acquired, shared time is produced locally:
T_shared = T_local + offset
Subsequent exchanges compensate for drift. Temporal state includes both the corrected value and an indication that the residual error remains within the configured tolerance. If the reference changes, the threshold is exceeded, or a partition is rejoined, the node repeats synchronization before considering shared time valid again.
The timestamp assigned to a DDO at its origin is not rewritten by intermediate hops. The destination can therefore distinguish production time from its own reception time and measure end-to-end delay even across a multi-hop route.
Policies and trust boundaries
Reachability and authorization are separate properties. A node may know a route but reject traffic because the origin does not satisfy its local policy.
Policies distinguish mapped peers, nodes in the same segment, routed traffic, and unknown origins. During bootstrap, discovery temporarily requires accepting messages from nodes that have not yet been mapped; once the procedure completes, the normal policy becomes effective again.
Routing does not bypass these controls. Each hop applies its own rules before accepting or forwarding the DME.
Adapting to change
The topology changes when a node joins or leaves, a driver loses connectivity, or a mapping becomes stale. The core reacts at multiple levels:
- the driver updates channel state;
- failover attempts an alternative link to the same peer;
- routing invalidates an unusable path and searches for another one;
- queues apply retry, backoff, or failure handling according to the configured policy;
- dATS restores temporal consensus when the reachable reference changes;
- the local view is updated with new mappings and paths.
During a partition, nodes with the same SID may remain in temporarily isolated components. They retain their identities and prior knowledge, but reachability is limited to paths that still exist. When connectivity returns, routes, mappings, and temporal state are validated against the current topology.
Architectural invariants
The architecture preserves several principles independently of platform and release:
- the node is the operational unit; the segment is the logical domain identified by the SID;
- SID and DIN belong to the overlay, while links and URIs belong to the underlay;
- membership, knowledge, reachability, and authorization remain distinct properties;
- the application addresses a DIN, not a physical endpoint;
- the DDO does not change when the driver, next hop, or hop count changes;
- each node makes decisions using its own local knowledge;
- link failover and multi-hop routing may cooperate, but they solve different problems;
- dATS makes timestamps comparable without introducing a central clock;
- transport heterogeneity remains confined to drivers.
These invariants allow the mesh to change topology and technology while keeping the application model based on nodes, identities, and DDOs stable.