This commit implements delay-aware queue management. When enabled the
device will monitor time-in-queue of messages in the direct tx queue
and if it is lager than specified thresholds it updates ECN flag
(if message indicates it is ECN-capable) and/or drop the message. This
mechanism is applied to IPv6 messages on the first device that sends
the message into Thread mesh and also on intermediate routers that are
forwarding the message (e.g., as a "mesh lowpan fragment" frame). On an
intermediate router when forwarding the fragments of a message, if any
fragment is dropped by the queue management policy, all subsequent
fragments will also be dropped.
In particular, this commit contains the following:
- Adds `DecompressEcn()` and `MarkCompressedEcn()` in `Lowpan` class
to decompress or update the ECN field in a compressed IPHC header
(unit test `test_lowpan` is also updated to test the new methods).
- Adds `UpdateEcnOrDrop()` which implements the main queue management
logic. This method is used when preparing next direct tx message. It
decides whether to keep the message as is, update ECN on it or drop
it.
- Updates `EvictMessage()` to first apply the queue management rule
to see if any message can be dropped before using the eviction
logic based on message priority.
- Updates and reuses the `FragmentPriorityList` to track whether
queue management dropped any of the fragments of same message so
to also drop any subsequent ones.
- Updates `LogMessage()` to log when a message is dropped by
queue-management or when ECN is marked on a message.
This commit updates the MLE attach process so that in the first attach
cycle device tries a total of six MLE Parent Requests, the first two
to routers only followed by four to routers and REEDs. For example,
the six Parent Request message will be used before device can decide
to act the leader. An MTD in the next attach attempt (if cannot find a
parent in first attempt cycle), will go to the model of two Parent
Requests (first to routers, then to routers/REEDs).
This change impacts the time it takes for a device to start as leader
(due to increased number of Parent Request and wait time). This commit
updates different test scripts to address the change in the wait
time. It adds a new `config.LEADER_STARTUP_DELAY` constants which is
used for wait time for leader to start.
This commit contain smaller enhancements related to managing the
local OMR prefix:
- It adds a new class to encapsulate all the related data and
methods.
- We directly track whether or not the prefix is added to the local
Network Data (using a boolean)
- The methods are renamed to use the terms "add/remove" instead of
"publish/unpublish" since the Network data publisher is not used
for OMR prefix and it is directly added or removed.
This commit adds `Ip6::Headers` class which represents IPv6 header
along with related transport layer header (UDP, TCP or ICMP6). It
provides helper methods to parse all headers from an IPv6 message or
decompress and read them from a lowpan frame.
This helps simplify the code and allows us to remove multiple similar
methods in `MeshForwarder` performing decompression/parsing.
This commit adds a call to `Get<Mac::Mac>().UpdateCsl()` when there
is role change from `SetStateLeader()` or `SetStateRouter()`. This
ensures to disable CSL at `SubMac` and radio platform.
When the RCP is not stable, it causes the Thread stack to crash. To
better know the stability of the RCP, this commit adds an API to
return the radio spinel metrics.
After enabling the scheduling of delayed reception slots in #7677
they would be configured even when the device switched to MED mode.
This commit introduces some simplifications around the CSL states
and scheduling:
- Maintain the CSL timer stopped if not in CSL Receiver mode.
- Keep the CSL Period and Channel values in the MAC in order to use
them as an indication of CSL Receiver mode in the Sub-Mac.
- Simplify CSL states with `mIsCslSampling` variable.
- Use a simplified interaction between MAC and SubMac:
- `SubMac::UpdateCsl` for CSL config or stopping CSL sampling.
- `SubMac::CslSample` for start/maintain CSL sampling.
This commit adds a helper method `ParsePreference()` to parse a given
CLI argument string as a route preference comparing it against "high",
"med", or "low". This commit also moves the `PreferenceToString()`
method from `Cli::NetworkData` to `Cli::Interpreter` class.
This commit adds new mechanism in `RoutingManager` to allow user to
get or set the preference level to use when advertising Rout Info
Options (e.g., for discovered OMR prefixes) in RA messages sent on
infra netif. By default 'medium' preference is used. As an example,
user can choose to set the preference to 'low' when the device is
acting as a temporary BR (a mobile or battery-powered BR) to indicate
that other BRs should be preferred over this BR on the infra link.
This commit also adds CLI sub-commands for newly added APIs and
updates the documentation.
This commit updates how `RoutingManager` learns the RA header from
host daemons. It adds a new method to determine whether a received RA
message is prepared by the `RoutingManager` itself by checking the
options (PIO and RIO) from the RA message. When learning/updating the
host RA header, we check and skip over such self-prepared RA
messages.
This commit adds a new mechanism related to Network Data recovery on
leader after restart. We determine whether device is starting normally
as leader or restoring its role as leader after restart. In the
latter case, we do not allow the device to accept any new Network Data
registrations until it has successfully recovered the Network Data
(received MLE Data Response).
This change help address situation where Network Data entries
registered with leader before it syncs and restores the Network Data
can be removed and then take a while to be re-registered.
This commit updates `RoutingManager` to discover and publish default
route entries. It updates `DiscoveredPrefixTable` to track which
routers provide default route when processing the received RA
messages. A router can indicate that it provides default route in the
RA message header and it can also include an RIO for "::/0". When
processing the RA message, the preference and lifetime values in a
"::/0" RIO override the preference and lifetime values in the RA
header.
While `DiscoveredPrefixTable` will always track default routes, only
if we see an OMR prefix with default route flag in the Network Data,
we allow it to publish the discovered default route (as "::/0"
external route) in the Network Data. Finding such an OMR prefix
indicates that this prefix is routable beyond the infra link and
therefore default routes can be published and used within Thread
mesh.
Adding support for 1.3 style border router configurations which are
different from the 1.2 style border router configurations. The
'device capabilities' is used to differentiate between these 2 device
types to assign them their needed configuration parameters.
Also moving restartAgentService to the proper class.
This commit updates the data model used by `DiscoveredPrefixTable` in
`RoutingManager` to track the router which added each prefix entry.
This change ensures correct behavior when multiple routers on the
infra link advertise the same set of prefixes. The routers can
potentially advertise the same prefixes (in RIOs) with different
preference levels and/or stop/start advertising the prefixes
independently of each other. We publish the prefixes in Network Data
with highest seen preference. The published entries in Network Data
are also updated as the table entries changes.
This commit implements new mechanism in `Mle` related to key sequence
update when an MLE message is received with a larger key sequence
compared to the one being used by `KeyManager`. The MLE messages are
categorized into classes of Authoritative, or Peer depending on the
MLE command type and included TLVs. The class determines different
actions: Authoritative indicates sender is confident that its key seq
is in sync, so receiver will adopt the larger key seq. Peer class is
used when both sender and receiver think they are in sync. In this
case, if the MLE message is from a known neighbor, receiver will
adopt the larger key seq if the difference is one, otherwise it will
try to re-establish link with the neighbor using Authoritative
message exchanges (e.g. sending Link Request or Child Update
Request).
This commit moves the definitions of constants related to min/max
number of IPv6 addresses that can be included in an IP6 Addresses TLV
to `Ip6AddressesTlv` class. It also adds a public OT constant in
`ip6.h` related to this for MLR feature which is then used in `cli`
and `ncp` modules so to avoid the use of OT core internal constant
from CLI/NCP.
This commit updates `check-simulation-build-autotools` to use the
`LOG_OUTPUT` switch directly. This addresses an issue where
we could end up with multiple `OPENTHREAD_CONFIG_LOG_OUTPUT`
definitions in the `CPPFLAGS`.
This commit adds a new method in `Array` to remove all elements
in the array matching a given indicator.
This commit also updates `test_array.cpp` unit test to validate
the behavior of the newly added method.
This commit updates `NetworkData::Publisher` so that a call to
`PublishOnMeshPrefix()` or `PublishExternalRoute()` replaces a
previous request for the same prefix. In particular, if the new call
only changes the flags (e.g., preference level) and the prefix is
already added in the Network Data, the change to flags is immediately
reflected in the Network Data. This ensures that existing entries in
the Network Data are not abruptly removed. Note that a change in the
preference level can potentially later cause the entry to be removed
from the Network Data after determining there are other nodes that
are publishing the same prefix with the same or higher preference.
This commit also updates `test_netdata_publisher.py` to test the newly
added behavior.
This commit adds a new mechanism to allow border routers to request
router role upgrade.
A border router which provides IP connectivity (either adding an
external route prefix or an on-mesh prefix with default route flag)
and is acting as a REED is eligible to request a router role upgrade
by sending an "Address Solicit" request to leader with status reason
`BorderRouterRequest`. This reason is used when the number of active
routers in the Thread mesh is above the threshold, and only if the
number of existing eligible BRs (determined from the network data)
that are acting as router is less than two. This mechanism allows up
to two eligible border routers to request router role upgrade when
the number of routers is already above the threshold.
This commit also adds a new test-case `test_br_upgrade_router_role`
which validates the behavior of the new mechanism.
This commit introduces `DiscoveredPrefixTable` class as a nested type
in `RoutingManager`. This class maintains the on-link and route
prefixes which are discovered by processing the received Router
Advertisement messages. It manages the lifetime of the discovered
prefixes (running a timer and removing entries when they expire). It
also handles publishing and unpublishing the prefixes in the Thread
Network Data as they are added and removed.
When there is any change in the table (an entry is added, removed,
or modified), it signals this through a callback to `RoutingManager`
which can then take action and decide whether or not to re-evaluate
the routing policy. A `Tasklet` is used for signalling which ensures
that if there are multiple changes within the same flow of execution,
the callback is invoked after all the changes are processed.
The change in this commit simplifies the overall `RoutingManager`
code by abstracting away the prefix table management into its own
class and allows us to hide the internal data model used for storing
the discovered prefixes.
This commit simplifies `NetworkData::Publisher` to rely and use the
new `HandleServerDataUpdated()` behavior which uses a `Tasklet` to
start the registration with leader. With this, we can directly call
`HandleServerDataUpdated()` whenever there is a change and even
multiple times during processing from `Publisher` while ensuring that
all changes are still registered together.
This commit adds a `Taskelt` in `NetworkData::Notifier` to perform
`SynchronizeServerData()` and post this tasklet when there is a
change and `HandleServerDataUpdated()` is called. This ensures that
if there are multiple changes triggered within the same flow of
execution, they are all synchronized together and included in the
same message to register with leader.
This commit updates `Ip6::Prefix` comparison (overload of `<`
operator). If the two prefixes have same length N, then the bytes are
compared directly (as two big-endian N-bit numbers). If the two
prefix have different lengths, the shorter prefix is padded by `0`
bit up to the longer prefix length N before the bytes are compared
(as big-endian N-bit numbers). If all bytes are equal, the prefix
with shorter length is considered smaller.
This commit also updates `test_ip_address` unit test to validate
the new comparison behavior.
This commit adds `Remove/RemoveMatching()` in `Array` class which
remove a given or a matched element from the array. To remove the
element, it is replaced by the last element from array, so the order
of items in the array can change after call to these method.
This commit also updated unit test `test_array` to verify the behavior
of newly added methods.
This commit updates the calculation of the next stale time in
`ResetDiscoveredPrefixStaleTimer()` in (unlikely) cases where the
stale time of a discovered prefix or RA header happens to be in past
(compared to `GetNow()`). In such a case, we use `now` as the stale
time of the entry. This then ensures that the we can correctly
compare the stale time with `now.GetDistantFuture()`.
This commit is a cosmetic change and contains no change in the code
logic. It is a follow-up from #7689 which added `Mle::Tx/RxMessage`
types. This commit moves all `TxMessage` and `RxMessage` method
definitions close to one another (at the end of `mle.cpp`).
This commit adds a new class `RouterAdvertMessage` representing an RA
message. It provides methods to append options (PIO or RIO) to the RA
message or parse and iterate over the options in the RA message
(using newly added `Option::Iterator` which allows use of range-based
`for` loop). These method are used by `RoutingManager` and help
simplify the code.
A BR with `BORDER_ROUTING` feature may add OMR prefix and external
routes to the network data when Thread is started. The network data
changes may incur additional Thread communications that may interfere
with certification traffic.
This commit enhances THCI to wait for the network data to stabilize
after the BR is started.
This commit uses `Ip6::Nd` namespace for IPv6 Neighbor Discovery
definitions (used for border router). It also renames and moves
the source files to `net/nd6.*`.
This commit updates `Srp::Server` to treat the update instructions in
a received SRP message for a service and all its sub-types as atomic.
It adds a new method `ValidateServiceSubTypes()` which performs two
checks. First, it verifies that there is a matching base service for
all sub-type services in a received SRP Update message. Second, it
treats the sub-types in the message as atomic, i.e., whatever
information appears in the message is considered the entirety of
information about the service and its sub-types. In particular, any
previously registered service sub-type that does not appear in a new
SRP Update is removed (marked as deleted).
This commit updates `test_srp_sub_type.py` test-case to validate the
behavior of newly added mechanism (i.e. removal of older sub-types
when not present in the new SRP update message).
This commit adds a new mechanism in `Srp::Client`: When preparing an
update message, client will check whether the prepared message fits
in an IPv6 MTU (1280 bytes). If it does not, the SRP client would
temporarily enable "single service mode" which ensures only a single
service (along with its sub-types) to be appended in the SRP update
message. After the message is sent SRP client would switch back to
normal behavior and disables the single service mode.
This change addresses situation where user may register many services
(with multiple sub-types and long TXT data) which then may not fit
in a single UDP message payload.
This commit also adds `test_srp_many_services_mtu_check` test which
verifies the newly added behavior.
Time delay between MLE Advertisements after reset can be up to 3.5
seconds. For example:
- 0.0s: Reset Interval, reset interval to 1 seconds, random interval
at 0.5 second
- 0.5s: Transmit MLE Advertisement
- 1.0s: Set interval to 2 seconds, random interval at 2 seconds
- 3.0s: Receive MLE Advertisement, reset interval to 1 second, random
interval at 1.0 second
- 4.0s: Transmit MLE Advertisement
MLE Orphan Announce messages include a timestamp value that has both
seconds and ticks set to zero, but authoritative bit set. However, the
default Active Timestamp value is all zeros. As a result, an MLE
Orphan Announce timestamp can appear to be greater than the default
Active Timestamp value and cause a device to detach.
This commit adds a special case to check for the Orphan Announce
timestamp.
The `otOperationalDataset#mActiveTimestamp` should represent the full
Active Timestamp TLV value but not only the seconds. The same for
`otOperationalDataset#mPendingTimestamp`.
This commit enables a different mbedtls library to be used for RCP
builds. This will make it possible to use a PSA Crypto mbedtls library
for FTD/MTD images while using a non-PSA crypto library on RCPs.
This commit updates `RoutingManager` to track the preference of the
discovered OMR prefixes from Thread Network Data and advertise the
OMR prefixes with the same preference in Route Info Options in the
emitted Router Advertisements.
This commit adds `OmrPrefix` class (which tracks an OMR prefix along
with its preference) and provides helpers method (e.g., method to
compare two OMR prefixes to determine which one is favored, `ToString
()` method). The `EvaluateOmrPrefix()` is updated to use the new
`OmrPrefix` class.
This commit adds a "auto host address mode" in SRP client. When
enabled, host IPv6 addresses are automatically set by SRP client
using all the unicast addresses on Thread netif excluding the
link-local and mesh-local addresses. If there is no valid address,
then Mesh Local EID address is added. The SRP client will
automatically re-register when/if addresses on Thread netif are
updated (e.g., new addresses are added or existing addresses are
removed).
This commit updates CLI to add support for new SRP client APIs related
to the new feature. It also adds `test_srp_auto_host_address` test to
cover the behavior of this feature.
This commit adds an API `otThreadDetachGracefully` to notify other
nodes in the network (if any) and then stop Thread protocol
operation. It sends an Address Release if it's a router, or sets its
child timeout to 0 if it's a child.
This commit changes `EvaluteOnLinkPrefix()` so that when we decide to
start advertising the local on-link prefix, we go through the list of
discovered prefixes to check if the local prefix was previously discovered
and included in the list, and remove it from the list (without
unpublishing it from Thread Network Data). This change allows us to
simplify `InvalidateDiscoveredPrefixes()` which was earlier called and
was in charge of removing the local prefix.
This helps align the logic that when we are advertising the on-link
prefix, we do not allow it to be added in the discovered prefix list
from `UpdateDiscoveredOnLinkPrefix()`.
OpenThread only etablishes links when the link margin is above a
certain threshold, to help ensure that links in the routing topology
are stable. However, if a device has no existing links to neighboring
routers above threshold, then upgrading to a router is useless and
disruptive.
This commit adds a check to ensure there is at least one neighbor
above the link margin threshold before upgrading to a router.
Disable steps 32, 33, and 34 until a solution is found. Depending on
timing, there may be one MLE Data Request/Response exchange for both
Active and Pending Operational Datasets or individual MLE Data
Request/Response exchange for each Active and Pending Operational
Dataset separately.
Some of the current implementations of thread stack use active scans
to find out the joining network name and extended panids. These
details are then used as part of commissioning process.
So at the very minimum we will need processing the incoming beacons to
extract these information.
This commit updates `InvalidateDiscoveredPrefixes()` to remove
invalidated entries from the array directly. This is done by
replacing the invalidated prefix entry in array with the last entry
in list and popping the last entry. This helps simplify the code and
avoid the need to create a separate copy of the list.
This commit also makes other smaller enhancements in this method:
Tracking the `nextExpireTime` to avoid multiple calls to
`FireAtIfEarlier()` from the same method (avoid re-arranging the full
timer linked-list). Also using a boolean `containsOnLinkPrefix` to
track whether we have seen any on-link prefix in the discovered
prefix list (instead of keeping track of the number of such
entries).
A device sends a multicast Link Request message after becoming a
router to quickly and efficiently establish links with neighboring
routers. However, sending a Link Request too quickly can fail in cases
where the neighboring router(s) have not yet received the updated
Router ID set from the Leader.
This commit delays sending the Link Request to allow time for
neighboring routers to receive the updated Router ID from the Leader.
`mcast6.py` is used by GitHub Actions CI to send or receive UDP
messages in multicast groups.
This commit adds a `-u` argument to allow `mcast6.py` to receive UDP
messages without joining a multicast group.
This commit simplifies the mechanism to invalidate/remove a specific
prefix entry in `mDiscoveredPrefixes` list. Instead of passing the
prefix to invalidate as an input to `InvalidateDiscoveredPrefixes()`
method, we directly set the valid lifetime to zero on the entry in
the list before calling the `InvalidateDiscoveredPrefixes()` to then
remove all expired entries.
This change addresses an issue in `HandleRouterSolicitTimer()` where
while iterating over the `mDiscoveredPrefixes` list we could call
`InvalidateDiscoveredPrefixes()` which then removed an entry from the
list (thus changing the list).
This commit changes `EvaluateOnLinkPrefix()` to directly update
`mIsAdvertisingLocalOnLinkPrefix`. The `SendRouterAdvertisement()` is
also simplified to directly use this boolean variable (instead of
a pointer to prefix being passed as input parameter) to determine
whether or not to include a PIO with the local on-link prefix.
This commit contains smaller enhancement in `RoutingManager` related
to `ExternalPrefix` class (which represents a prefix discovered from
processing Router Advertisements from infrastructure netif). This
commit also uses `Array::Find()` methods when searching in the
`mDiscoveredPrefixes` array.
The vicarious router discovery feature depends on the ability to
receive Router Advertisement messages sent in response to Router
Solicitation messages from other hosts. However, this does not work
since Router Advertisement messages are often sent unicast in
response.
This commit enhances routing-manager to avoid using deprecated
(i.e. P_preferred=false) OMR prefixes as the winning OMR prefix, but
still sends RA RIO for the deprecating OMR prefixes.
This commit fixes a bug that BR could incorrectly remove the route of
the local on-link prefix in Network Data when it's still advertising
the local on-link prefix.
This is a short-term fix because in the long term we want to refactor
how `RoutingManager` manages external routes and the default route.
This commit updates and simplifies `RouterAdvMessage`:
- Adds new method to get and set the "default router preference"
- Removes custom overloads of operator `=` and `==` (which
excluded the checksum field). Instead when we save a received RA
in `RoutingManager` we directly set the checksum to zero so the
normal (byte by byte) comparison would properly check all fields.
This commit adds `InfraIf` class which represents an infrastructure
network interface on a border router providing methods & definitions
mirroring the platform APIs `otPlatInfraIf{}`. This commit also
updates the `RoutingManager` to to use the `InfraIf` class.
This commit updates `Tcp::Endpoint` and `Tcp::Listener` types to
inherit from `GetProvider` (which provides `Get<Type>()` methods
allowing them to directly access different components in an
OpenThread `Instance`).
Cert_5_5_05_SplitMergeREED.py was intermittently failing to find an
MLE Advertisement that had a Route TLV with 15 entries. However, the
test topology has 16 routers in steady state. Update packet filter to
look for 16 routers.
This commit adds some wait time before connectivity
validation to mitigate the impact of #7660 which
introduces some random delay before publishing
external route into network data.
This commit changes `RoutingManager::PublishExternalRoute()` method
to return `kErrorAlready` as `kErrorNone` (i.e., if the prefix to be
published was previously published). This commit keeps the logging
the same (i.e. we still log on `Already` error so we can see when/if
this happens).
This commit increases the wait time in `nat64_multi_border_routers`
test to accommodate for the fact that prefixes are added and removed
using `NetworkData::Publisher` which can add additional initial
random wait time (before adding the prefix into network data).
This commit updates `RoutingManager` to use `NetData::Publisher` for
external routes. This ensures to limit the number of similar entries
added in Network Data if there are many BRs within Thread mesh
discovering same set of prefixes and adding them to Thread Network
Data (avoid overflow of Thread Network Data).
This commit contains smaller enhancements in `RoutingManager `
and `Prefix/RouteInfoOption`.
This commit changes how the options are added in a message so that we
directly construct the option in the message buffer (instead of
creating it separately and then copying the bytes).
It also changes `RouteInfoOption::IsValid()` to validate that the
option length can fit the specified prefix length.
This commit adds new `Mle::TxMessage` and `Mle::RxMessage` classes
(as sub-classes of `Message`). `TxMessage` represents an MLE message
to be sent out providing `Append{Some}Tlv()` methods and `RxMessage`
represent a received MLE message providing helper methods `Read
{Some}Tlv()`.
While using sizeof(*icmp6Header) before it is initialized to something
is not wrong, it is possible this will be flagged by some code checker
tools. Lets check using direct type.
This commit adds `OT_THREAD_VERSION_1_3` constant (equal to `4`)
and change=s the `OPENTHREAD_CONFIG_THREAD_VERSION` default value
to be the 1.3 version number.
It also updates the build switch option (Cmake and autoconf)
to support 1.3 and use 1.3 as default version value (when not
explicitly specified).
This commit introduces a base class `GetProvider` which provides
`Get<Type>()` methods using `GetInstance()` (which is expected to be
provided by the derived class in a CRTP style inheritance). The class
`GetProvider` is used as base class of `InstanceLocator`.
This model allows us to provide `Get<Type>()` methods on types that
may not be directly an `InstanceLocator`. For example, this commit
uses this model on `Message` class. `Message` always retains the
`MessagePool` which can be used to get to the `Instance` that owns
the `Message`. Note that it is not straight-forward to to have
`Message` directly inherit from `InstanceLocator` (due to way
`Message` is built from `Buffer` and uses `Metadata` header and that
`InstanceLocator` behaves differently under single vs multi instance
configs).
Deriving the Mesh Local Prefix from the Extended PAN ID was carried
forward from legacy implementations. Removing this coupling to conform
to the existing Thread Specification.
This commit adds a small wait time between steps in the toranj
`test-018-child-supervision` to help make the test more robust. The
test adds some extra time for child to finish the "child update
request/response" exchange with the parent before enabling MAC
filter.
When radio supports receive timing it makes no sense to restrict
scheduling future reception slots while the radio state is for
instance transmitting or receiving, as long as CSL parameters are
properly configured.
Coverage upload can fail intermittently for various reasons. Do not
delete coverage artifacts if upload fails to avoid needing to re-run
the entire workflow.
Return different output of `ValidateDeviceFirmware` depending on the
device's capabilities. This allows to have a single THCI file for the
same vendor for different device's versions.
This commit updates `MleRouter::ProcessRouteTlv()` to not only read
and process Route TLV from a received MLE message but also to update
the `mNeighbor` pointer (in `RxInfo`) which indicates the neighbor
from which the MLE message was received.
During processing of Route TLV, the entries in the router table may
shuffle. If the `mNeighbor` was pointing to an entry in `RouterTable`
it may be invalid afterwards. The new implementation ensures that
`mNeighbor` is correctly updated to point the same entry.
This change addresses a scenario where in `Mle::HandleAdvertisement()`
a potentially invalid (or set to null) `mNeighbor` may be checked
after Route TLV is processed from `MleRouter::HandleAdvertisement()`
call.
This commit adds new helper methods in `Coap` to allocate a new
message and initialize it as a confirmable or non-confirmable post to
a given URI path. It also adds a new helper method to allocate a CoAP
response message for a given request. These methods help simplify the
preparation of CoAP and TMF messages.
Remove excesive logging redundancy:
- `API` decorator is enough to show test script calls with arguments
- `__executeCommand` already prints all OT commands and arguments
- Command timestamp is irrelevant in most cases
- Some extra detail logging lines are left commented in case they
are needed for some debugging
As a result test logs are much easier to follow and resulting files
are much smaller.
The current implementation attempts to remove existing on-mesh prefix
entry when adding an on-mesh prefix entry with the same prefix. The
same logic exists for external routes. However, the existing code does
not work properly when both on-mesh prefixes and external routes exist
with the same prefix.
This commit simply updates the logic to always remove existing entries
with the same prefix, regardless of whether they are on-mesh prefix or
external route. This is in contrast to trying to keep both on-mesh
prefix and external route with the same prefix simultaneously. There
is no obvious use case for having both the on-mesh prefix and external
route exist at the same time.
This commit removes the `#if OPENTHREAD_CONFIG_BORDER_ROUTER_ENABLE`
around the call to `IsConsistent()` which checks whether there is any
difference between local network entries and ones from leader network
data and decide to send a "Server Data Notification" message to
leader. This change ensures that services are updated correctly under
the uncommon config combination where `TMF_NETDATA_SERVICE_ENABLE` is
enabled without `BORDER_ROUTER_ENABLE`.
This commit adds `Mle::ProcessMessageSecurity()`. Based on the `aMode`
input, it can be used to encrypt and append tag to a message (which
will be sent) or to decrypt and validate the tag in a received
message. The common method handles the generation of nonce and
preparation of AES-CCM header.
This commit adds a new struct `RxInfo` which includes a received
MLE `Message` along with additional info about it such as the
`Ip6::MessageInfo` and key sequence from security header and
pointer to `Neighbor` from which the message was received.
The `RxInfo` is used as the input parameter in different MLE
`Handle{MleMsg}`()` methods.
`IFA_RT_PRIORITY` not defined basically means that the feature is not
present. Defining it to 9 does not make it effective.
This commit removes the `IFA_RT_PRIORITY` definition so that it would
not compile on platforms that do not support `IFA_RT_PRIORITY`.
This commit simplifies the MLE header processing. It defines
the `SecurityHeader` to represent the aux security header used
by MLE messages (when security suite is set to `k154Security`).
With this change the initial `SecuitySuite` and the MLE `Command`
fields are parsed and appended separately.
This commit adds a new method in `AesCcm` to encrypt/decrypt the
payload content in place within a given `Message`. This is then used
in `Mle` for processing MLE messages. This commit also updates unit
test `test_aes.cpp` to validate the new method.
The `routerCount` value was being reset to zero with each iteration
over the router table. As a result, the comparisons were only
happening on the first entry in the received Route64 TLV.
This commit introduces an API for the circular buffer library. While
we ultimately converged on the linked-buffer-based API that has been
merged into OpenThread, it was also discussed that we should provide a
circular buffer library that is implemented on top of the linked
buffer API, to support applications that find a circular-buffer-based
interface easier to use.
This commit adds support for the remaining TCP callback, which was not
yet supported.
Originally, the unimplemented callback was otTcpSendReady, which would
indicate to the application when new data added to the TCP send buffer
would be sent out immediately. There was also discussion of adding an
otTcpBytesAcked callback, which, together with the
otTcpSendByExtension() call, would allow a circular buffer to be
implemented efficiently on top of the otLinkedBuffer API.
Ultimately, it seemed best to generalize the otTcpSendReady callback
to include both cases where bytes are acked by the connection peer,
and where the send buffer drains, allowing new data to be sent
immediately. The reasoning behind this decision is that both the
otTcpSendReady and otTcpBytesAcked callbacks are triggered by the same
event --- an ACK received from the connection peer --- and that it may
require the application to have to "coordinate state" across
callbacks. Having a single callback function to indicate both
conditions seemed like it could simplify applications significantly.
The new, combined, callback is otTcpForwardProgress. This commit
implements support and documentation for this callback function.
This commit adds a new feature in `MeshForwarder` to add wait delay
after a successful frame tx to a neighbor which is expected to
forward the frame. This wait time applies before the next direct tx
to any neighbor on an FTD. This mechanism is intended to help prevent
self-interference when messages are sent to a destination that is
at least 2-hops away. This commit adds new OT build configs to
enable/disable this behavior and specify the wait interval
(default is set to 8 msec).
This commit allows configuring route metric for the prefix routes of
IPv6 addresses added to the Thread network interface.
This commit also simplifies `UpdateUnicastLinux` by using `AddRtAttr`.
This commit updates the `otMessageGetBufferInfo()` and its related
types. In particular, this commit adds `otMessageQueueInfo` to
indicate number of messages, number of data buffers, and total
message length (number of bytes) for all messages in the queue.
This commit moves and renames the `Random::Manager` class to
the `random.hpp` header file (deleting the `random_manager.hpp`).
It also moves the implementation of some the `Random` functions
e.g. `GetUint8InRange()` or `FillBuffer()` (which are more complex)
to the `cpp` file (instead of defined as `inline`)
This commit contains the following changes:
- The `Dataset` method which reads the dataset TLVs from a message
is renamed to `ReadFromMessage()` and after reading the TLVs, it
also checks that the TLVs in the Dataset are valid (well-formed).
- The `Active/PendingDataset::Save()` methods are updated to return
error in the case the parsed dataset is not well-formed.
- The `Mle::HandleChildIdRequest()` rejects the response if the
included dataset is not well-formed. This ensures that device
stays detached if it cannot accept and save the dataset it gets
from the parent candidate.
This commit enhances the selection algorithm for the preferred entry
when there are multiple "DNS/SRP Service Anycast" entries in the
Thread Network Data. The sequence number (which is `uint8_t`) is used
for selecting the preferred entry and the larger value is preferred.
The seq numbers are compared using "serial number arithmetic"
(RFC-1982) but if we have 3 or more entries the notion of a largest
seq number may not be well-defined under the "serial number
arithmetic" comparison (e.g., for `{10, 130, 250}` there is no
largest seq number since `130 > 10`, `250 > 130` and `10 > 250`). In
such a case the algorithm selects the entry with largest seq number
in normal sense.
This commit updates `FindPreferredDnsSrpAnycastInfo()` to implement
the new algorithm. It also updates `test_network_data` unit test to
add many test cases related to the selection algorithm.
This commit updates the auto-start behavior in `Srp::Client` which
monitors the Thread Network Data entries to discover and select SRP
sever to register with. There are three types of entries in Network
Data and are selected in the order below:
1) Preferred unicast entries with address in service data,
2) Anycast entries (each having a seq number,
3) Unicast entries with address info included in server data.
This commit also defines `AutoStart` class which includes all the
state and data variables related to auto-start feature. It also
updates `test_srp_auto_start_mode` test to cover the newly added
behaviors.
This commit updates how the `MessageInfo` for a "GetQuery" response
is prepared so that we use link-local source if the destination of
response is also using link-local.
This commit adds support for new Status TLV values and updates
the processing of Address Solicit request messages on leader.
The new status `kBorderRouterRequest` can be used by a BR to request to
upgrade to router role. If there are fewer routers than "router
upgrade threshold" leader will accept the request. If the number of
routers is more than the threshold but less than max, the leader will
accept the BR request only if the number of current Border Routers
(as indicated by Network Data) that are acting as router is less than
two (thus allowing up to two BRs to use this status reason to become
router when already above the threshold).
The other change in this PR, is that when processing Address Solicit
request if the included status value is not known or invalid, a
response with `kUnrecognizedStatus` status is sent.
This commit adds `Tmf::MessageInfo` which is a sub-class of the
`Ip6::MessageInfo` class intended for use when sending TMF messages.
The peer port number is by default set to the TMF port from the
constructor. This class also provides helper methods for commonly
used patterns, e.g., source or `SockAddr` set to device's RLOC
address and/or the destination or `PeerAddr` set to leader ALOC or
RLOC, or a given address.
There is no command that can generate different sizes of Spinel frames
for testing the SPI/UART interface. This commit adds a diag command
`diag rcp echo` to RCP for testing SPI/UART interface.
This commit adds a new method in `NetworkData` to find the list of
RLOC16 of all border routers providing external IP connectivity. A
border router is considered to provide external IP connectivity if it
has added at least one external route entry, or an on-mesh prefix
with default-route and on-mesh flags set. It also adds a method to
count the number of border routers. The methods allow filtering based
on the border router device role, including devices in any role, or
in router role only, or in child role only. This commit also updates
`test_network_data` unit test to validate the behavior of the newly
added methods.
The current implementation does not differentiate the max spinel frame
size that is used to pack a spinel command and the radio spinel RX
frame buffer size which could contain multiple frames. In
radio_spinel_impl.hpp, only one spinel frame can be written when
calling function `SendCommand` or `SendReset`.
Therefore the aim of this commit is to allocate, in such a context,
only a buffer of one frame instead of a buffer that could contain
multiple frames.
Signed-off-by: Gatien Chapon <gatien.chapon@nxp.com>
EmplaceSecurelyStoredKeys tries to read the network key and PSKc from
secure storage to update the TLVs and asserts if the read fails. But
if the device was previously running a non-PSA application, it won't
have the keys in secure storage, and the device asserts.
This commit provides a way to move the the keys to secure storage, if
the ExportKey fails. Once it is moved to secure storage, literal key
stored in the settings is cleared.
This commit updates `test_srp_name_conflicts.py` to cover the
situation where different clients try to register services with the
same service instance label but under different services.
This commit updates how the messages waiting for address query
resolution are processed and queued. It adds a boolean flag in
`Message` metadata to indicate whether or not a message is waiting
for an address query resolution. Messages that require address query are
marked and kept in `mSendQueue` instead of being placed in a
different queue `mResolvingQueue`. When the address is resolved the
messages are updated accordingly. This ensures that the order of
messages in `mSendQueue` are preserved.
This commit add more error tracing logs to help identify where a
SRP service registration fails. The log format is also updated to
capitalize the first char to align with rest of the codebase.
This commit updates `Cert_9_2_17_Orphan` packet verification to check
that the two leaders are sending MLE advertisement before checking
for child attach (Child ID response). The current test checked this
after the child attach but leader 1 is turned off 5 seconds after
the child is attached which may not be enough time to ensure rx
of an advertisement (which every 30 seconds on average).
Before starting a test case, our test script calls the `factoryreset`
to make the device enters a known state . But the previous test case
may fail to call the `diag stop` before exiting. This case the next
test case failed to call the `factoryreset `.
This commit allows the users to call `factoryreset` under the diag
mode.
This commit adds new methods in `Ip6::Header` to get and set Traffic
Class, Flow fields. It also updates and renames some of the existing
methods. This commit also adds a unit test `test_ip6_header` to
validate the IPv6 header parsing and preparation.
The test failed when verifying that HOST sends a ping packet to BR
while the destination is a link local address. That requires adding a
route on HOST before the ping. In this specific step, HOST added a
route to link local prefix going to BR. However, HOST failed to send
the echo request to BR using this newly added route. Since the impact
of disabling this step is small, I'll skip this step as for now and
look for a long term fix in the future.
This commit adds a `TimeMilli mTimestamp` field in `Message` metadata.
This replaces the `mTimeout` which was used during lowpan and/or IPv6
fragment reassembly to drop the message if the next fragment is not
received within a time window.
This commit updates `LogMessage()` in `MeshForwarder`:
- Fixes `MessageActionToString()` so when there is a passed-in error
it correctly returns the related action string (and only when
`aAction == kMessageTransmit` it returned "Failed to send").
- Changes the order of parameters in `LogMessage()` and uses default
value for parameters to simplify its use.
This commit updates `Ip6::FragmentDatagram()` to set the priority on
every fragment message to match the original IPv6 message. This
ensures that as fragments are enqueued in the priority queue they
follow the same priority as the original IPv6 message.
This commit changes `Ip6::HandleDatagram()` so to copy the ECN value
parsed from IPv6 header of the message in the accompanying
`MessageInfo` data structure.
This commit adds new header file `ip6_types.hpp` which include
common IPv6 related types (enumerations) and constants. It also
moves the `Ecn` constants and define them as an `enum`.
This commit contains smaller enhancements in `MleRouter` related to
preparation and handling address solicit request/response:
- Simplify router id allocation logic (if RLOC16 is requested
in the address solicit message).
- Simplify `SendAddressSolicitResponse()` (remove `error`).
- Update logs.
- Remove simple comments.
This commit enables defining
OPENTHREAD_CONFIG_PLATFORM_RADIO_COEX_ENABLE, which can be used by
external build system (i.e. Matter) to override the platform
defaults. This is useful for platforms having transceivers that also
support coexistence between multiple protocols (WiFi/BLE etc.)`
This commit adds a new enumerator `kBetterParent` in `AttachMode`
enumeration. This new value is used by periodic parent search
feature only when searching for a better parent to help make
it explicit that attach process is started for this purpose.
This commit contains small changes in `Mle`:
- Renames `mParentRequestMode` to `mAttachMode` (to match its type).
- Shortens `ParentRequestType` enumerator names.
- Changes `SendParentRequest()` to return `void`.
- Adds a protected method `Mle::Attach()` (which replaces
the `BecomeChild()`).
- Moves `AttachMode` enum as a protected definition in `Mle`
class itself and renames the `AttachMode` constants.
This commit adds the `src/posix/platform/settings.hpp` file to make
other components able to access the POSIX data file, so that secure
settings implementation can use the same file as platform settings.
This commit makes the core pass the sensitive keys to the platform
settings initialization, so that the platform settings implementation
can know which keys are sensitive keys during the initializing and do
the migration when needed.
This commit updates `GetNextTid()` in `RadioSpinel` so that it
searches for the next unused TID. The current implementation only
checked the `mCmdNextTid` and assumed that if it was in-use, then all
other TIDs were also in-use. This may not be valid since a TID may be
in-use for a pending radio tx in `mTxRadioTid` while TIDs after that
are still available.
This should help address the situation where while waiting for a
pending radio tx (holding on to `mTxRadioTid`) 15 other radio API
calls happen (each consuming a TID) causing the `mCmdNextTid` to wrap
around back to `mTxRadioTid`.
This commit changes the log level used by `Mac` to log frame rx error
when error is `kErrorAddressFiltered` (from "info" to "debug" log
level). This error is used when the frame is filtered `Mac::Filter`.
This helps reduce the logs during simulation/testing when allow-list
or deny-list are used to form specific network topology.
This commit updates `NetworkData::Service::DnsSrpUnicast` to indicate
`Origin` of the entry, whether the server IPv6 address and port
number is included as part of service data or server data. This will
be used by clients to prefer entries with the info in service data
(which coveys the infra-structure provided (authoritative) server)
over the ones in server data (which are used by Thread BRs).
This commit also updates the unit test `test_network_data` to validate
the new behavior.
This commit renames the method `MeshForwarder::GetDirectTransmission`
to `PrepareNextDirectTransmission()`. This is to help make this method
different from `Message::GetDirectTransmission()` (which indicate if a
`Message` is marked for direct tx).
This commit updates `toranj` test framework to add support for writing
CLI based test-cases (in addition to existing model which uses OT NCP
build along with `wpantund`/`wpanctl`).
Current `Routing Manager` implementation will try to send the failed
RS messages in 60 seconds. RS failures happen often when the infra
interface is re-enabled which is the case of rebooting, and it could
not be acceptable for the border router to take 1 minute to recover
the IPv6 connectivity after reboot.
To resolve this issue, this commit changes the delay to
`kRtrSolicitationInterval` (4 seconds) which is the interval between
two successful RS messages.
This commit adds support for range-based `for` loop iteration over
`MessageQueue` and `PriorityQueue`. It adds `ConstIterator` and
`Iterator` in `Message` class. The non-const `for` loop iteration
(which uses `Message::Iterator`) works properly and is safe to use
even when the entry is removed from the queue during iteration. This
commit updates other core modules to use the new `for` loop iteration
model which helps simplify the code. It also updates the unit tests
to validate the behavior of the newly added iteration mechanisms.
Deleting a copy constructor without specifying an explicit assignment
operator causes an error in clang10 (-Wdeprecated-copy). Since
explicit assignment operator defined in
OPENTHREAD_CONFIG_PLATFORM_KEY_REFERENCES_ENABLE case, added the copy
constructor deletion also under the same. If the macro is not enabled,
implicit copy constructor and assignment operator would take effect.
This commit sets `fail-fast: false` for matrix in GitHub Actions so
that tests in a matrix do not fail all at once. It's more convenient
now that we can re-run failed tests.
This commit adds `Mle::HasAcceptableParentCandidate()` method
which is used to during attach process after sending an MLE Parent
Request message and waiting for the proper delay (i.e., when attach
timer fires) to determine whether or not we have found an acceptable
parent candidate.
This is a refactor of the existing code with no change in behavior
with goal of making the code easier to read (all the conditions that
are checked when deciding to accept a parent candidate).
This commit adds `Mle::RemoveDelayedMessage()` helper method which
removes messages with a given sub-type and an optional destination
IPv6 address from the `mDelayedResponses` message queue.
Thread Certification Harness makes use of CSL Timeout configurations
as low as 10 seconds, with the expectation that the SSED will try to
autosync very near to the end of the CSL Timeout.
However, the default configuration is to send a Data Request 4 secs
before, which makes several certification tests to fail due to
unexpected polling.
This commit sets the default `pollAhead` to 1 second, aligning better
with the certification testing expectations.
For the on field deployments it shouldn't be an issue that the Data
Request does not reach the parent exactly before the CSL Timeout
expiration since it will resynchronize anyway once one of the
retransmissions reaches the parent.
This commit adds a new mechanism in `Neighbor` to timeout the last
received fragment tag being tracked per neighbor. The fragment tag is
used when `MULTI_RADIO` is enabled to suppress duplicate received
frames (over different radios).
This commit updates the local NAT64 prefix and OMR prefix to be
allocated from the same /48 BR ULA prefix. The /48 prefix is generated
randomly and is saved in Settings for recovery. The subnet id of
prefixes are statically assigned to avoid conflict with each other in
a simple way.
This commit adds new helper macro `OT_SHOULD_LOG_AT(aLevel)` which
indicates whether logging is enabled at a given log level. This helps
simplify the code and makes sure the the condition used for enabling
logging related functions/methods is consistent across all the core
modules.
With this change, when `OPENTHREAD_CONFIG_LOG_OUTPUT` is set to
`LOG_OUTPUT_NONE` (which practically disables all logging), all the
related code/methods that are used to prepare the log line
(e.g. `Mac::OperationToString()`) are excluded from the build
(become empty functions/methods). This way, under `LOG_OUTPUT = NONE`
instead of preparing the log line and then passing it to an empty
`otPlatLog()` implementation to be dropped, the code is optimized to
not prepare the log line in first place.
Test L5.3.5 is failing sometimes because there are unwanted data
requests during the second ping round. This can be mitigated by
finishing earlier with this round so there is no need for children
to synchronize CSL.
This commit adds a new feature in `SubMac` to add random delay before
frame retransmissions. The delay is added only if the previous tx
resulted in `kErrorNoAck`. A backoff algorithm similar to one used
for CSMA is used to determine the random delay, i.e., starting with a
min backoff exponent (BE) which is incremented each time delay is
added up to a max backoff exponent. The backoff interval is derived by
selecting a random value from `[0, 2^BE]` range multiplied by
`kUnitBackoffPeriod=20` times radio symbol time (20x16=320 usec).
The `OPENTHREAD_CONFIG_MAC_ADD_DELAY_ON_NO_ACK_ERROR_BEFORE_RETRY`
is added to enable this behavior (which is enabled by default).
This commit also adds other configs for this feature including
minimum and maximum backoff exponents (the values are from Thread
1.3 spec recommendations).
This commit changes the `Srp::Server` definition to use `Heap::Array`
to store the list of IPv6 addresses associated with a given `Host`.
This makes the array length dynamic and removes the need for
specifying a hard limit on the number of addresses and allow us to
remove `OPENTHREAD_CONFIG_SRP_SERVER_MAX_ADDRESSES_NUM` config.
This commit adds `Heap::Array<Type>` class which allocates the
buffer to store array elements from the heap. The `Array`
implementation automatically grows the buffer when new entries
are added. It also provides optional method `ReserveCapacity()`
to allow user to allocate and reserve a certain capacity
(number of elements user expects to add).
The `Array` can safely be used with element `Type`s that are
themselves heap allocated (manage allocated items). The `Array`
implementation uses the move constructor and destructor of the
`Type` class to ensure that copying the entries when growing the
array is performed efficiently and that the removed entries are
properly deleted.
The `Array` implementation also provides helper methods to search
in the array, e.g., `Find()`, `FindMatching()`, `Contains()`, and
`ContainsMatching()`. It also supports range-based `for` loop
iteration.
This commit also adds a detailed unit test `test_heap_array` which
covers behavior of `Array` with a simple `uint16_t` entry type and
a more complex entry type (validating the constructors and destructor
of entry are properly invoked by `Array` implementation).
This commit adds a new mechanism in `Dns::Client` along with a new
public OT API `otDnsClientResolveIp4Address()` and its related CLI
sub-command to allow a user to request an address resolution DNS
query specifically for A records or IPv4 addresses for a given host
name.
This API requires `OPENTHREAD_CONFIG_DNS_CLIENT_NAT64_ENABLE` to be
enabled. Upon receiving a successful query response the addresses are
reported to user (in callback) as NAT64 IPv6 translated version of
the IPv4 addresses from the received query response.
The new API is added in addition to the existing behavior where address
resolution query from `otDnsClientResolveAddress()` first queries for
IPv6 addresses and only if no IPv6 address is found and NAT64 is
enabled and allowed by the query config, `Dns::Client` implementation
tries to perform an IPv4 query. The new API directly starts with IPv4
query and can be useful in situations where Thread devices are
connected through BRs to a network without global IPv6 connectivity.
IPv6 fragments are unconditionally forwarded to the host even if the
option: OT_IP6_FRAGM for internal reassembling is enabled. It results
with e.g. for RCP echo request are handled twice, by the OpenThread
and by the host.
This commit changes it in this way that when OT_IP6_FRAGM is enabled
IPv6 fragments are not forwarded to the host any more but handled
internally only. When OT_IP6_FRAGM is disabled the IPv6 fragments are
always forwarded to the host. This case is especially important for
NCP architecture with spinel maximum frame size limitation (1500B).
Now the option: OT_IP6_FRAGM should be disabled for NCP to allow
forwarding IPv6 fragments to the host.
I just found that we don't have a test case covers the scenario of
DNS-SD when there are multiple BRs. Specially, one of the BRs starts
with no mDNS cache.
There was a time that our mDNS publisher answered the queries
correctly, even when there was a bug in mDNS publisher that it
cancelled resolving/browsing too early (was fixed in
https://github.com/openthread/ot-br-posix/pull/1120). That bug was
hidden because mDNS cache already contained the needed information.
This commit fixes two small issues regarding OMR prefix election:
- This commit handles the case where `mLocalOmrPrefix` is already in
Leader's Network Data, but not locally added. It is possible when
the BR restores the Network Data from Leader. In such case the BR
should re-add `mLocalOmrPrefix` to local Network Data so that it
keeps advertising OMR Prefix. Otherwise, the OMR Prefix will be
removed from Leader's Network Data because of Network Data
inconsistentency, and then all BRs start to re-elect OMR Prefix. So,
the change will make the OMR Prefix more stable in some corner
cases.
- The change here checks if `mLocalOmrPrefix` was added to the Local
Network Data, instead of checking if `mLocalOmrPrefix` is added to
the Leader's Network Data. Here the BR has already decided that it
should not be advertising `mLocalOmrPrefix`. Whether or not
`mLocalOmrPrefix` is in Leader's Network Data is relevant. The BR
only needs to remove `mLocalOmrPrefix` from Local Network Data and
eventually Local Network Data will synchronize with Leader's Network
Data. The original code also has a potential issue that the BR may
send `NET_DATA.ntf` to Leader indefinitely when these conditions are
met:
- `mLocalOmrPrefix` was added to Local Network Data
- `mLocalOmrPrefix` is not added to Leader' Network Data because
there is no more space in Leader's Network Data
This commit updates `kMessage` in `test_ecdsa.cpp` function which
verifies the signature generation to be an array of char instead of a
`char *`. This ensures that the use of `sizeof(kMessage)` correctly
gives the length of the message string (which is used during hash
calculation).
This commit updates `Dns::Client` such that when parsing a query
response we allow and accept a message with empty question section if
the response code in header indicates an error. This ensures that the
`Dns::Client` can work with DNS name resolvers that may not echo back
the question section in case of an error response.
This commit updates how the CLI command handlers are defined. A
template `Process<CommandId>()` method is now used to process a CLI
command where the `CommandId` is a `uint64` hash ID derived from
the command string itself.
This model helps simplify the CLI modules. With this change, there is
no need to declare different process methods for every CLI command in
the header files. It also makes the association between a CLI command
and its command string explicit and simple (e.g., `"state"` command
with `Process<Cmd("state")>` method).
This commit updates the `SpiInterface` implementation to send any
pending tx SPI frame from `WaitForFrame()` while waiting for a
response frame from RCP. This should help address rare RCP response
timeout which can potentially happen if RCP is not yet ready to
accept a frame in a first SPI transaction from a `SendFrame()` call
followed by a call to `WaitForFrame()`.
This commit updates the `WaitForFrame()` to reuse `UpdateFdset()` and
`Process()` methods which in turn handle the situation that central
is being rate-limited by the peripheral.
The Child ID Response message contains the RLOC16 that the Parent
assigns to the Child. Add a check to ensure that Parent's and Child's
Router IDs match. If the Router IDs do not match, drop the Child ID
Response message.
The commit updates the `mbedtls_ssl_conf_curves` with the new
alternative - `mbedtls_ssl_conf_groups`. The API has been deprecated
in `mbedtls-3.1` and will be removed in a future release. The code is
also kept backward compatible to support older versions.
This commit updates the `SendChildIdResponse()` to check in the case
that the child already has a previously assigned RLOC16 that it
matches the current router ID of the parent and if not we assign a
new RLOC16 to it in the "Child ID response".
This commit implements new logging model in OpenThread. Each core
module can specify its own module name using `RegisterLogModule()`.
The registered log module name is then included in the all the log
messages emitted from the specific file. This model replaces and
enhances the log region model.
Thread Conformance document requires a Link Metrics Subject to
support at least one Link Metrics series (forward or enhanced ACK)
per connected SED.
Make sure this is the default configuration.
This commit adds two inline template functions to get the length of an
array and a pointer to the end of the array. These functions replace
similar macros that were used with OT core modules. The template
functions are safer to use since they would perform type checking at
compile time. The functions validate that the input variable is
indeed an array and unlike the macros they will not work with a
pointer variable.
This commit adds tests for NAT64 prefix
advertisement. BORDER_ROUTING_NAT64 is set to 1 to enable the feature
in tests.
It also adjusted some util functions for prefixes and routes in
netdata.
Testing outbound connectivity to IPv4 hosts is not covered yet. It
will be added after we update OTBR.
If `OPENTHREAD_BUILD_DATETIME` is defined by the build system, the
version string would be something like:
OPENTHREAD/20191113-03303-gbdeacdc55-dirty; NRF52840DK-engFeb 08 2022 13:05:38
^^
We shouldn't put the separator in the macro, but put it in the version
string instead.
This commit adds a flag in Thread link info to indicate whether
destination PAN ID is broadcast.
Verified by running two simulation nodes (modified announce sender
interval) of different Thread networks and make sure there are no
logs of `[WARN]-MLE-----: Failed to process UDP: Security` when
receiving MLE Announce messages.
* Avoid printf, and omit newline at end of tcplp_sys_log calls
* Add new tcplp_sys_panic call to use for assertion failures
* Fix code in "#ifdef INSTRUMENT_TCP" so that it can be used
- Adds platform API `trelDnssdInitialize` to initialize TREL
DNS-SD module.
- Adds `test_trel_connectivity.py` test.
- Fixed `Border Router` TREL test to really use TREL.
This commit implements the new TREL model which uses DNS-SD to
discover TREL peers on the network. This implementation replaces the
previous model which relied on link-local multicast.
This commit adds a new set of `otPlatTrel` APIs and callbacks that are
then used by an updated `Trel::Interface` implementation. The
`Trel::Interface` maintains a TREL peer table which is populated from
DNS-SD discovered services. A device supporting TREL registers a new
service to be advertised using DNS-SD with the service name
`_trel._udp`. It also initiates an ongoing DNS-SD browse for the same
service name within the local browsing domain to discover other
devices supporting TREL. `Trel::Interface` encapsulates and send
unicast frames as a unicast UDP message between TREL peers. Broadcast
frames are sent as a group of UDP unicast transmission to a sub-set
of TREL peers.
This commit also adds a new set of public APIs for TREL along with
support for them in CLI:
- APIs for enabling/disabling of TREL operation at run-time.
- Filter mode API which when enabled temporarily drops all the traffic
on the TREL interface (is mainly intended for testing).
- APIs to get the TREL peer table entries.
This commit adds an implementation of the new `otPlatTrel` APIs under
`simulation` platform. This is used for testing. This implementation
emulates a simplified version of DNS-SD mechanism.
A basic implementation of the `otPlatTrel` is also provided under
`posix` platform. However certain functions are tied to mDNS or
DNS-SD library being used on a device and need to be implemented per
project/platform. A set of weak empty functions `trelDnssd{}` are
defined (along with a description of the their expected behavior)
which can be overridden during project/platform integration.
This commit provides the following changes:
* Introduce a new `otPlatCryptoRandom*` API
* Move usage of `mbedtls_entropy_*` and `mbedtls_ctr_drbg_*` out of
ARM PSA enabled platforms
* Stop exposing internal mbedtls contextes for entropy and CTR DRBG
in OpenThread API
Signed-off-by: Lukasz Duda <lukasz.duda@nordicsemi.no>
THCI used to catch Exceptions and print errors using
`ModuleHelper.WriteIntoDebugLogger`. However, in most of time it just
help hide the actual issue and make it harder to debug.
Re-raising the exceptions should be a better approach:
- @API decorator will print the full exception Traceback via
`ModuleHelper.WriteIntoDebugLogger` and then re-raise.
* update TCPlp #include guards to be TCPlp-specific
* do not use sys/queue.h in tcp_var.h, to avoid polluting global namespace
* avoid bitfields in TCP header structure
* use int32_t instead of int in tcpcb and reorder fields to eliminate padding
This commit removes the `otLogResult{Bbr/Platform}()` macros from
`logging.hpp` and instead have each module implement `LogError()`
method. The main goal behind this change to simplify the logging
module and reduce number of macros/definitions in it (to prepare for
new logging model to be introduced).
Provide a setter for the message code to change it after
initialization of the message.
This complements the existing getter function `otCoapMessageGetCode`.
This commit enables BR to withdraw its local NAT64 prefix if a smaller
one is found in network data.
It might happen when two BRs join the Thread network at merely the
same time and thus both advertise its local NAT64 prefix. The BR with
numerically greater prefix will withdraw its NAT64 prefix.
This commit adds `Commissioner::Dataset` class which mirrors the
public `otCommissioningDataset`. It also adds `ResignMode` enum
which is used as input to `Stop()` method to indicate whether or
not to resign from being the commissioner.
This commit adds `AddressResolver::LookUp()` method which resolves
an EID to an RLOC17 by checking if an existing entry already exists
in the address cache table.
- THCI changes for bbr reset procedure to make a better effort to
reset and to also make sure to restart the otbr-agent prior to
attempting a factoryreset to cover the case where the agent cannot
currently communicate to the rcp.
- THCI change to move from sudo service restart otbr-agent to sudo
systemctl restart otbr-agent, which is more comprehensive.
- THCI changes for multicast to use ipmaddr in both soc and bbr cases.
This commit adds `SerialNumber` class which provides `static` methods
`IsGeater<UintType>()` and `IsLess<UintType()` to compare two serial
numbers, taking into account the wrapping of serial number values
(similar to RFC-1982). This is then used in `MleRouter` and other
modules. This helps us avoid casting of `uint` to `int` for the
comparison (such a casting is undefined behavior in C++11 though
toolchains often implement it as expected). This commit also adds a
unit test `test_serial_number` to validate the new methods.
This commit adds `NetworkData::Type` enumeration to indicate full set
or stable subset. It also adds helper method `GetNetworkDataType()`
in `Neighbor` and `Mle` to indicate what type of Network Data device
requests.
This commit fixes minor bugs in TCP.
1. The first change fixes a bug where the TCP CLI prints out an
incorrect message when a connection is terminated. This appears to
have been introduced in #7279.
2. The second change fixes a null pointer dereference when accepting a
TCP connection. This issue is purely theoretical at the moment,
because in the case where the dereferenced pointer is NULL, the
dereferenced value is not used, and so the compiler optimizes out the
memory access (so it seems). As a result, TCP actually runs without
issues. But I've fixed it anyway, to avoid depending on that behavior.
This commit adds a mechanism in `HistoryTracker` to track changes in
Thread Network Data maintaining a history of on-mesh prefix and
external route entries as they are added or removed by different
nodes in Network Data. This commit also adds new `cli history`
commands to retrieve the Network Data prefix/route history list and
updates the documentation in `cli/README_HISTORY.md`.
This commit generates a random NAT64 prefix and adds the prefix to
NetworkData if none exits. The prefix will be saved in Settings for
recovery.
It also adds a new CLI command `br nat64prefix` to show the local
nat64 prefix.
A new config OPENTHREAD_CONFIG_BORDER_ROUTING_NAT64_ENABLE is defined
and used to guard the change.
This initial implementation only supports a single BR.
This commit updates the handling of service ALOCs in `Mle` by adding a
new class `ServiceAloc` (subclass of `Ip6::Netif::UnicastAddress`)
which provides some simple helper methods (e.g., `IsInUse()` to
indicate whether the entry is currently added to `ThreadNetif`). It
also simplifies `UpdateServiceAlocs()` which adds and removes ALOCs
based on the service entries in the Thread Network Data. These changes
allow us to remove some service related methods from `NetworkData`
which are no longer needed or used (harmonizing how we iterate over
service entries in Network Data).
This commit enables `OT_BORDER_ROUTING` feature in some of the
build scripts (e.g., `script/check-scan-build` or `make-pretty`) so
that it is covered by github actions workflow CI.
Existing deployed networks may have Operational Datasets where the
Security Policy TLV includes a Rotation Time value of 0. Not accepting
such datasets does not allow a Thread device to attach properly.
This commit removes the requirement that the Rotation Time value must
be greater than the minimum value of one hour.
This commit fixex the wrong commissioner mgmt cli args which uses
"binary" to indicate following binary args in HEX string - the format
has been changed to "-x" in #5549.
The reason why cli-commissioner.exp doesn't fail consistently is not
fixed by this commit.
This commit adds support for DNS Stateful Operations (DSO) as
specified in RFC 8490.
It adds `platform/dso_transport.hpp` header file which defines the
platform APIs/callbacks for DSO transport layer (e.g., DSN-over-TLS
or DNS-over-TCP).
The `Dso` module handles establishing connection with a peer, acting
either as a DSO client or server, establishing a DSO session over a
connection, and then sending and processing DSO request, response,
and unidirectional messages (including support for DSO TLV formats).
The `Dso` module also manages the session life cycle and timeouts,
namely the "Inactivity" and "Keep Alive" timeouts (including sending
and processing of Keep Alive messages when needed). It also handles
adding encryption padding before sending a message. It implements the
padding policy "Random-Block-Length Padding" from RFC 8467.
This commit also adds a detailed unit test `test_dso` covering the
behavior (including corner cases) of the `Dso` implementation. The
unit test provides an implementation of the DSO platform APIs which
emulate the DSO transport layer. It also includes a simplified alarm
platform implementation (emulating timers and allowing time to
advance in the unit test). These allow the unit test to cover more
complicated situations and behaviors (timeouts, failures, etc).
The `aFrame.IsDataRequestCommand()` call was checking the frame that
had been already encrypted.
This commit fixes that by using `aIsDataPoll` parameter instead.
This commit adds new methods in `NetworkData` to indicate whether or
not it contains a given on mesh prefix, external route, or service
entry. It also adds a new method to check whether it contains all
entries as in another given Network Data all associated with a given
RLOC16. This is then used to simplify comparison between `Local` and
`Leader` network data.
MATN test cases often takes long time. We'd better move them to a
separate job so that we don't have to rerun MATN cases every time a
border router test fails.
During running T.1.1 tests with the T.1.2 capable sample it turned out
that 9.2.4 commissioner TC is not working when using the device that
is T.1.2 capable. The reason is that in MGMT_ACTIVE_SET
listSecurityPolicy list has only two elements and we are entering the
code, where we assume it is three element, which raises IndexError.
This commit removes the extra `#if` config checks in core files before
`#include` of different headers. Such a check is not necessary since
the OT core headers all start with any related `#if` config check.
This commit caches Border Router test results so that success BR tests
will be skipped when re-running the workflow.
The cache keys are chosen in a way that:
- Each new PR push will trigger cache miss and run the tests
- Each ot-br-posix change will trigger cache miss and run the tests
This commit introduces a number of enhancements to `thread-cert`
Border Router tests to improve reliability:
- Checks `ot-rcp` process status for OTBR tests to help catch errors
earlier
- Make sure `ot-rcp` processes are terminated after one test to avoid
corrupting subsequent tests
- Upload core dump as artifacts if otbr-agent crashed
The firewall feature should not be enabled on some targets,
e.g. ot-daemon. Although leaving it enabled does not break the
behavior, it creates confusing logs.
When setting the IP forwarding rule on Android platform, it needs to
specify the two interfaces between which IP forwarding is enabled.
This commit adds a method to get the infra interface name for setting
IP forwarding rule.
This commit sets `MAX_JOBS` to 3 for Border Router tests (using OTBR
Docker) to improve reliability.
The original `MAX_JOBS` value is 10.
Related metrics:
- Border Router tests takes 12 minutes with MAX_JOBS=10
- Border Router tests takes 24 minutes with MAX_JOBS=3
This commit adds set of generic binary search related functions in
OpenThread core under `BinarySearch` module. The binary search module
replaces and enhances the existing `Lookup` table module (which was
limited to search based on strings and mainly used by CLI to map from
command string to a handler function).
This commit also adds a new class `Stringfy` in `string.hpp` to help
convert from a set of `uint16_t` values (e.g., a non-sequential
`enum`) to strings using binary search in a table. The new methods are
used for converting `Coap::Code` and `IpProto` enumerations to
corresponding strings.
Do all the calculations on uint32_t to prevent bad wraparound check
due to mixing uint32_t with uint64_t.
Signed-off-by: George Stefan <george.stefan@nxp.com>
The RX window when not using RX AT mode is much larger than the
correct time and what is reported by the Open Thread log.
In the case of "receive at" we want the timer to fire before the next
RX window to program the exact RX activity in the radio and in the
other case, the timer will fire when the current RX window will end to
close the receiver and go to sleep.
This commit fixes the issue by increasing the sample time with the CSL
period before starting the timer in the case of RX AT and after in the
normal RX case.
In some build systems, source files is passed as absolute path, log
messages may be truncated. This commit makes VerifyOrDie only prints
basename of the source file.
Current `Srp::Server` is comparing the entire KEY RRs to determine if
the two SRP messages are using the same signing key. But the TTL in
the KEY RR can change even between two SRP messages of the same client
and this will result in false name conflicts.
This commit fixes this issue by changing to compare only the rdata of
the KEY RR.
Some platform diag commands (those not in factory_diags module) will
also do repeat sending and the same callback (Diags::TransmitDone)
will be called. However, in those cases, `mRepeatActive` won't be set.
And if some error (like `CHANNEL_ACCESS_FAILURE`) happened,
`TransmitPacket` will be called then, which makes the channel even
more busy, causing more `CHANNEL_ACCESS_FAILURE`, and so on. This PR
ensures that `TransmitPacket` will only be called again when using
`diag send`.
This commit updates how `Mac` tracks the pending operations by using
a bitset `mPendingOperations` replacing the current model using a
set of `bool` variables per operation.
Because the 2 addresses are registered sequentially from the same
method call, the OpenThread stack will not have had the opportunity to
send out MLR.req with a single address. So this should result in
sending out one MLR.req with two addresses inside, if 2 addresses are
provided. Without changes in the APIs.
This commit removes `OPENTHREAD_CONFIG_LOG_DEFINE_AS_MACRO_ONLY`.
which helps simplify the logging implementation. This feature enabled
all logging including the platform API to be defined as macros and
was intended for certain restricted platforms. With the new logging
model, OpenThread core itself will prepare the entire log line
instead of platform layer, so this feature is no longer applicable or
useful.
This commit helps reduce posix-netif WARN logs when transmitting
messages to Thread.
There are certain ICMPv6 messages (e.g. MLDv2) that OpenThread will
filter when transmitting, so the error `OT_ERROR_DROP` is expected.
This commit also assumes that OpenThread knows what it's doing when it
choose to drop a message, thus using lower log level for
`OT_ERROR_DROP`.
This commit unifies how immediate or delayed routing policy evaluation
is initiated.
This commit also removes `mRouterAdvertisementTimer` to reduce memory
footprint.
This commit enhances Border Routing to ignore discovered OMR Prefixes
when Network Data change. It's possible that a BR may learn an OMR
prefix from RA, and later learn the same OMR Prefix from Network Data.
In such case, the BR should remove the discovered OMR Prefix.
This commit adds new CLI command `joiner state` to get the current
state of `Joiner`. It also adds new public OT API to convert a given
`otJoinerState` to a string.
This commit removes the function `MeshCoP::NewMeshCoPMessage()` and
uses `NewPriorityMessage()` method directly on `Coap::CoapSecure` or
`Tmf::Agent`. This helps harmonize the message allocation model by
MeshCoP modules.
This commit changes `AddressOriginToString()` to a public `static`
method of `Cli::Interpreter` so we can reuse it in `Cli::History`
module and potentially other modules in future. It also removes
similar method from `Cli::History`.
This commit adds a set of `As<TlvType>()` methods which cast from base
`Tlv` pointer or reference to a specific sub-class `TlvType` while
preserving whether the input parameter is `const` or not. This
basically acts as a syntax sugar for this commonly used pattern in the
code.
In PR #7128, the `DefineCoreType()` & `DefineMapEnum()` definitions
(which map the public and core types) were moved to header files
that define the corresponding core type. This allows us to use the
`AsCoreType()` in header files. This commit changes some of inline
methods in the core headers to use it.
Thread specification defines `MLR_TIMEOUT_MIN` as the minimum value of
the MLR Timeout in the BBR Dataset, but this does not affect to the
Timeout TLV in the Multicast Registration Request messages.
Current implementation will reschedule the Stale Timer when discovered
on-link or OMR prefixes or RA messages are updated, but it has a few
issues:
1. It's counting the maximum stale time of all on-link prefixes so
that we will schedule Router Solicitation when all on-link
prefixes become stale. But it failed to filter out OMR prefixes in
the `mDiscoveredPrefixes` list. This results in incorrect stale
time calculation.
2. A deprecated on-link-prefix is not removed from
`mDiscoveredPrefixes` directly but the preferred lifetime is set
to zero. We are not filtering out deprecated on-link prefixes when
calculating stale time and this results in zero stale timer delay
if there are no non-deprecated on-link prefixes.
This commit fixes those issues by having a dedicated
`ResetDiscoveredPrefixStaleTimer` to reschedule the stale timer with
following rules whenever discovered prefixes or learnt RA messages are
updated:
1. If BR learns RA header from Host daemons, it should send RS when
the RA header is stale.
2. If BR discovered any on-link prefix, it should send RS when all
on-link prefixes are stale.
3. If BR discovered any OMR prefix, it should send RS when the first
OMR prefix is stale.
`ResetDiscoveredPrefixStaleTimer` is supposed to correctly calculate
stale timer timeout whenever it's called.
We should reevaluate routing policy only when a discovered on-link
prefix becomes deprecated or preferred. This change reduces sending RA
messages when another peer is keep advertising deprecated (preferred
lifetime is zero) on-link prefix.
This commit fixes the bug that BR may not respond to a Router Solicit
with a Router Advertisement when the BR itself is Router Soliciting.
This bug may cause Vicarious Router Solicitation more likely to fail
because BRs may failed to send RA for vicarious RS.
Previous approach with `dig` was not enough because it was only
parsing one mDNS response and not taking account that the response
could be from an inactive Border Router.
Use Python Zeroconf to properly parse all services.
Currently, we will start routing policy evaluation when new OMR
prefixes are received as RIO options in RA messages. But it's not
necessary to do so because whether we need to advertise our own OMR
prefix is not depending on the discovered OMR prefixes from Wi-Fi link
but the OMR prefixes in Thread network data.
In some cases the first element from the output from __executeCommand
might be empty line, which casues command failures like on below
trace:
__executeCommand('extaddr',) returns ['', '166e0a0000000001', '', 'Done']
FUNC getMAC failed: invalid literal for int() with base 16: ''
This commit filters out empty string from the result of
__executeCommand.
This commit adds `OPENTHREAD_CONFIG_RADIO_LINK_IEEE_802_15_4_ENABLE`
check to CLI processing methods related to `radiofilter` command which
ensures that this is only available when 15.4 radio is enabled. This
allows us to build CLI app successfully with TREL radio only.
This commit fixes the `OwningList::RemoveAllMatching()` to use the
`LinkedList` one. It also updates unit test `test_linked_list` to
cover this method.
The Backbone Router and Border Routing feature will be silently
disabled when the infra/backbone interface is not provided. We should
at least print a warning log in this case since it may not be
intentional.
This commit implements OTBR firewall. This implementation focuses on
ingress filtering. We may also introduce egress filtering when
necessary.
For security purpose, there are some packet forwarding rules to
follow, which were originally introduced in the spec.
- Inbound packets initiated with On-Link addresses source (OMR and
mesh local prefix based addresses) should be blocked.
- Inbound unicast packets whose destination address is not OMR address
or DUA should be blocked.
- Inbound unicast packets whose source address or destination address
is link-local should be blocked. Note that we don’t need to
explicitly add rules for link-local addresses since this should
already be handled by the kernel.
These rules can be easily implemented by iptables and ipset.
Before otbr-agent starts, there is a script creating the iptables
rules. The rules themselves are constant so we don't need to change
them dynamically. During the runtime of otbr-agent, otbr-agent updates
ipsets accordingly whenever there's a change of on-link prefixes.
The current priority of the added routes too high so it may get
preferred over routes learned from RA. Hence we increase the metric to
deprioritize the added routes.
This commit adds a new method `LinkedList::RemoveAllMatching()` which
removes all entries in the list matching a given entry indicator from
the list and adds them to a new "removed" list. A similar method is
also added in `OwningList`. This commit also updates the unit test
`test_linked_list` to validate the behavior of the new method.
This commit updates `Srp::Client` to skip appending services when the
host is being removed. On the first attempt the `mHostInfo.GetState()`
will be `kToRemove` but on the retries it will be `kRemoving`.
When OPENTHREAD_CONFIG_PLATFORM_KEY_REFERENCES_ENABLE is
set, make sure that sensitive dataset items, such as the
network key or PSKC, are persisted using the secure
Crypto::Storage API (which should encrypt the stored data,
or use secure hardware units) instead of settings.
This commit updates `Timer` class constructor to be `protected` which
ensures that instances of `Timer` can not be created and only
instances of its sub-classes `TimerMilli` or `TimerMicro` can be
used. This helps avoid potential incorrect use of `Timer` class
directly.
Thread harness requires to create thread network without checking the
if the thread protocol version is correct. This commit adds capability
to disable this check.
This commit removes different `MessagePool` methods that can be used
to allocate a new message and combines them into one `Allocate()`
method which uses `Message::Settings`. The `Message::Settings` is
also updated to provide new constructor initializing it with a given
message priority only.
This commit implements new radio filter mechanism in OpenThread. The
radio filter is mainly intended for testing. It can be used to
temporarily block all tx/rx on the IEEE 802.15.4 radio. When radio
filter is enabled, radio is put to sleep instead of receive (to
ensure that the device does not receive any frame and/or potentially
send ack). Also the frame transmission requests return immediately
without sending the frame over the air (return "no ack" error if ack
is requested, otherwise return success). This commit also add CLI
command `radiofilter` for this feature. It also adds test-case
`test_radio_filter` to validate the behavior of the new feature.
This feature requires `OPENTHREAD_CONFIG_MAC_FILTER_ENABLE`.
When running OT CLI in Zephyr, it's not desired to print a prompt
after executing a command, as OT CLI is tightly integrated with Zephyr
shell module which provides its own prompt.
Add a config option which allows to disable CLI prompt on the output.
Signed-off-by: Robert Lubos <robert.lubos@nordicsemi.no>
This commit fixes the incorrect call to `MessagePool::New()` to
allocate a message in `MeshForwarder::HandleMesh()` method. The
existing code calls `New(Message::kType6lowpan, priority)` with two
parameters which maps to the flavor `New()` method with three
parameters with last one (`Message::Settings`) being optional
(having a default value). Basically, the existing code treats the
`priority` (second argument) as `aReserveHeader` parameter in the
`New()` instead of the message priority.
This commit adds a new static method in `Heap::Allocatable` to
allocate a new object and initialize it using the underlying `Type`
constructor (passing all the parameters to the constructor). This is
in addition to the existing mechanism to use an `Init()` method to
initialize the allocated object. The `Init()` method returns an
`Error` allowing the initialization itself to potentially fail. This
commit also updates `Srp::Server` types `Host` and `UpdateMetadata`
to use the new method.
This commit updates `Srp::Server` such that `Service` instances keep a
`RetainPtr` to a `Service::Description`. This allows a service and
all its sub-types to share the same `Description` instance and helps
simplify the management of the `Description` instances. When the last
`Service` that has a pointer to a shared `Description` is removed and
freed, the `Description` instance will be automatically freed as
well.
This commit adds a new class `Ptr<Type>` which represents a wrapper
over a raw pointer. This is then used as the base class of `OwnedPtr`
and `RetainPtr` providing the common simple methods (avoiding repeating
the same code in each smart pointter). The new `Ptr` class also adds
overloads of `==` and `!=` allowing `Ptr` to be compared with a given
raw pointer or another `Ptr` instance.
This is a workaround that disables the scenario of verifying the
meshcop service when thread is disabled. This scenario sometimes
doesn't work well with mDNSResponder publisher because of the renaming
logic. We are expecting a refactor of advertising proxy & mdns and
this issue should be fixed at that time.
The spec asks border router to publish meshcop service even when
thread interface is inactive. This commit adds test case to verify the
feature.
This commit also introduces boot_delay to add delays between booting
nodes. In this way we can let border routers not starting at the same
time, so that there will be fewer renaming conflicts. This can make
the test more stable.
This commit updates `Dns::ServiceDiscovery::Server` to use
case-insensitive string match when comparing DNS names. It also
updates `test_dnssd.py` to use mixed case names when browsing for or
resolving services. This validates the case-insensitive treatment
of names by SRP client and server and DNS-SD server (resolver) and
DNS client.
This commit changes the `Dns::Name::CompareName/Label()` methods to
perform case-insensitive string comparison. This is realized by
adding a new flavor of `Data::MatchesBytesIn()` which accepts a
`ByteMatcher` function pointer. This allows the caller to relax the
definition of a match and how the bytes are compared. `Message` class
methods that compare bytes are also updated to allow `ByteMatcher` as
an input parameter. This commit also updates the unit test `test_dns`
to cover the new method and behaviors.
This commit adds new string helper functions to convert between
lowercase and uppercase letters. It also adds new function
`StringStartsWith()` which determines whether the string starts with
a given prefix string and `StringMatch()` which compares and matches
two strings.
This commit also adds a new mechanism in all string helper functions
allowing the caller to specify the match mode to be used when
comparing strings: Either an exact match of characters, or a
case-insensitive match where uppercase and lowercase characters are
treated as equal.
This commit also updates `test_string` unit test to validate the new
functions and behaviors.
When the GRL starts, it calls initialize() reset() method on each
device. Reset method call fails due to missing (uninitialized)
attribute `isPowerDown`.
This commit adds `OwningList<Type>`, a singly linked list which owns
its entries and frees them upon destruction of the list. This commit
also updates `test_linked_list` to validate the behavior of the new
class.
This commit adds new flavor of `Dns::TxtEntry::AppendEntries()` to
encode and append TXT record entries in a data buffer (in addition to
existing one which appends to a `Message`). `Appender` class is used
in the underlying implementation . This commit also updates
`test_dns` unit test to validate newly added method.
This commit adds a `Appender` class which acts as a wrapper over
either a `Message` or a data buffer (e.g., `MutableData`) and
provides different flavors of `Append()` method. This class helps in
construction of message content where the destination can be either a
`Message` or a buffer. This commit also adds a unit test for the new
class.
This commit adds two smart pointer types `OwnedPtr` and `RetainPtr`.
`OwnedPtr` acts as the sole owner of the object it manages. It is
non-copyable but the ownership can be transferred from one `OwnedPtr`
to another using move semantics.
`RetainPtr` is an intrusive reference counted smart pointer allowing
multiple pointers to share management of the same object. It requires
the underlying `Type` object to provide mechanism to track the
current retain count. This may be realized by the `Type` itself
providing this or by having it be a sub-class of the newly added
`RetainCountable` class.
This commit also add a unit test `test_smart_ptr` validating the
behavior of newly added classes.
This commit adds a new class `Heap::Allocatable<Type>` which provides
`New()` and `Free()` methods to allocate and free instances of a
template `Type` on heap. The static `New()` method requires the
`Type` class to provide a method `Error Init(Args...)` to initialize
the allocated object as `Type`. The initialization itself can fail
(return `Error`) in which case `New()` will release any allocated
buffer and return `nullptr`. The `Free()` method invokes the `Type`
class's destructor before releasing the heap pointer. This ensures
that any heap allocated member variables in `Type` (e.g., any
`Heap::String` or `Heap::Data`) are freed before the `Type` instance
itself is freed.
Add the following options `-Wno-sign-compare` and
`-Wno-unused-parameter` with target_compile_options to suppress
warnings. These options will be appended to the end of options
inherited from COMPILE_OPTIONS and CMAKE_C_FLAGS.
This commit adds TCPlp's TCP protocol logic, which is derived from the
TCP protocol logic in the FreeBSD Operating System. The FreeBSD code
had to be refactored to work for TCPlp, and I have added extensive
comments explaining the code that was deleted and changed. The changes
are primarily modifications to work with TCPlp's data buffering (see
#6926), removal of features that depend on dynamic memory allocation
to save memory (SYN cache, compressed TIME-WAIT state) and removal of
features that aren't relevant in this setting (e.g., TCP Segmentation
Offloading, IPv4 support).
Some certification tests are failing because otbr-agent service is not
started back after calling powerDown (isPowerDown flag is kept False
and reset function fails on checking thread state - since the service
is stopped, we can't return status).
Also minor fixes for printing logs, disabling paramiko DEBUG level.
Avoid parsing responses for not expected cases.
Fixes some issues with Thread 1.2 certification test cases in which
it's not required to parse the mDNS response.
This commit removes incorrect calls to UpdateMldReport.
- UpdateMldReport(MA, true) should be called when a MA is registered,
thus in MulticastRoutingManager::Add.
- UpdateMldReport(MA, false) should be called when a MA is expired,
thus in MulticastRoutingManager::Remove.
Note that removing an Multicast Forwarding Cache (MFC) does not mean
the MA is expired. The MFCs can be freely removed even when the MA is
still registered and being renewed.
This commit updates the `Srp::Server` to use the `Heap::Data` class
for storing the TXT record data bytes. This helps simplify the code.
This commit also adds a new helper method in `Heap::Data` to set
the data from a given number of bytes read from a `Message` at a
given offset. It also updates the unit test to cover the behavior
the new method.
We added a dry run option. So it is possible that the settings fd is
-1 when de-initialization. The assert here makes the program
crash. This commit updates it to a `VerifyOrExit` to avoid crashing.
This commit fixes the potential memory leak of `mTxtData` when a
`Description` instance is freed. Also addresses similar situation
with `mServiceName` when `Service` instance is freed.
Some certification tests are failing because not enough delay is
applied after a Linux ping command is sent and the capture misses the
ICMP transaction.
Also removing unneeded check for Thread 1.2 harness version when
reconnecting to the serial port after a reset.
HostNode is based on OtbrDocker, which has otbr-agent service started
by default. We should disable this service on HostNode otherwise the
border router test cases won't have the exact expected topology.
Thread Specification allows a parent to update child network data by
sending a unicast MLE Data Response. Receiving the child's Leader Data
in a MLE Child Update Request message should serve as an
acknowledgment when the network data is received.
This commit updates `Srp::Server` adding a new type `MessageMetadata`
which is used during processing of a received SRP Update message.
This class serves two purposes: (1) It helps simplify the code by
combining all related parameters (current offset in the message, DNS
`Header` and `Zone`, and `Ip6::MessageInfo`) into a single `struct`
which is then passed to different `Process{}()` methods. (2) It
defines new fields to represent the time when the message was
received (allowing us to process the message as if it was received
earlier than the current time) and the lease interval values to be
granted during processing of the message. These are added in
preparation for enabling SRP Replication (SRPL). With SRPL we can
receive an SRP Update message from an SRPL partner (i.e., another SRP
server) and then need to process it as if we received it on this
device at the same time as the original SRPL partner processed it and
with the same lease config values.
This commit moves the heap functions `CAlloc` and `Free` from
`instance.hpp` header to a separate `heap.hpp` header file. The main
reason is to make it easier to include this header file from other
modules (avoid the header dependency/loop issues by requiring to
include `instance.hpp` to get access to heap functions). This commit
also defines a `Heap` namespace and moves other heap allocated types
under this namespace (`Heap::String` and `Heap::Data`).
This commit adds new class `HeapData` which represents a heap
allocated data buffer of a given variable length. This class provides
methods to set/copy the `HeapData` from/to a buffer or a `Message.
This commit also adds unit test for the new class.
Modify `mdns_query` to accept a list of reference devices link local
addresses in order to discard their mDNS responses.
Also accept a service string to be used for the Thread 1.3
Certification program.
Return the DUT's Border Agent address and port.
Existing IPv6 implementations may not implement DHCPv6 to acquire an
IPv6 address. As a result, a Thread Border Router must advertise a ULA
if there is no existing prefix that supports SLAAC (i.e. has A flag
set).
This commit adds `enum` types to use as arguments `aRetainName`
and `aNotifyServiceHandler` in the calls to method `RemoveHost()`
and `Host::RemoveService()`.
`otDump` will currently always dump to string and use the log level to
decide whether to print it. Since this function is in the key path of
packet handling, this behavior reduces network throughput. This commit
adds a log level check to fix the issue.
This commit moves the `DefineCoreType()` & `DefineMapEnum()`
definitions (which map the public and core types) to the related
headers where the core type is defined, e.g., `otIp6Address` to
`Ip6::Address` map is now defined in `net/ip6_address.hpp`. This
allows us to use `AsCoreType()` in more places (avoid the header
file dependency/loop).
This commit allows `mParentChanges` counter which tracks the number
of times device (as a child) switches its parent to be used without
`INFORM_PREVIOUS_PARENT` feature.
This commit fixes a bug that PBBR does not send Address Query and
Backbone Query on behalf of MED Children, and add a test to make sure
DUA forwarding works on PBBR:
- Make sure PBBR sends Address Query and Backbone Query on behalf of
MED Child
- Make sure PBBR does not send Address Query when the destination is
MED Child
- Make sure MED Children do not send Address Query by itself
- Verifiy DUA reachability between PBBR and MED Child
- Make sure PBBR reduce IPv6 TTL by 1 when forwarding DUA destined
messages
This commit adds missing `#if` check in `network_data_publisher.cpp`
to ensure it can be built when `CONFIG_BORDER_ROUTER_ENABLE` is
disabled (i.e., with `CONFIG_TMF_NETDATA_SERVICE_ENABLE` only).
Added new API/CLI for reference devices to set allowed ranges of
router IDs. When the allowed ID range is set, the leader will only
assign router IDs in the range. In this way, we can assign
non-overlapping router ID ranges to different thread networks so that
no RLOC16s will collide across multiple thread networks.
Apply all CSL accuracy rules from latest spec draft:
- If the Mode TLV in the Parent Request had the 'R' flag set to zero
AND the Version TLV indicates that the version of the attaching
device is Thread 1.2 or greater, the Parent SHOULD include the CSL
Accuracy TLV in the Parent Response.
- A Parent that receives a Child Update Request which includes the CSL
Synchronized Timeout TLV MUST include the CSL Accuracy TLV in the
response.
- A Child that receives a Child Update Request which includes the CSL
Accuracy TLV MUST include the CSL Synchronized Timeout TLV in the
response if the Child is currently acting as a CSL receiver.
- double wait time for advertising proxy top update and multicast the
SRP updates
- adjust waiting time to avoid collision with lease time schedule
- fully remove the service before starting next test case
- add debug logging
This commit adds support for joining and leaving multicast group in
order to send proper Multicast Listener Reports from thread network to
backbone link.
This commit adds two simulation tests to verify that SRP clients can
register 500 services to one SRP server:
- Virtual time simulation test with one SRP server and 25 SRP clients,
each client registering 20 SRP services.
- OTBR simulation test same as above, but run SRP server on OTBR
(Docker).
This commit uses `AsCoreType()` and other functions from header
`as_core_types.hpp` to cast between public OT C style definitions to
the related C++ core types in the core modules.
In the previous version of this test case, the ED node was actually a
REED, where the test plan asks it to be a ED. Changing the node to ED
makes the topology more stable. I've run the test case 50 times
locally and none of them failed.
If we configure CSL parameters before a command to attach, then the
child has configured valid CSL state, but when trying to configure the
auto-sync CSL poll timeout, the check to IsCslEnabled->IsCslCapable
fails because IsChild() fails.
When handling the child ID response success, we now trigger
poll-sender's recalculation, and rx-on-idle states, after role change
to child.
This commit exports private spinel utility functions to access vendor
implemented properties from the host.
The commit also reserves the vendor property range for Espressif to
avoid collision.
This commit implements part of the OTBR firewall. This implementation
focuses on the ingress filtering part. We may also introduce egress
filtering part when necessary.
For security purpose, there are some packet forwarding rules to
follow, which were originally introduced in the spec.
- Inbound packets initiated with On-Link addresses source (OMR and
mesh local prefix based addresses) should be blocked.
- Inbound unicast packets whose destination address is not OMR address
or DUA should be blocked.
- Inbound unicast packets whose source address or destination address
is link-local should be blocked. Note that we don’t need to
explicitly add rules for link-local addresses since this should
already be handled by the kernel.
These rules can be easily implemented by iptables and ipset.
- Before otbr-agent starts, there is a script creating the iptables
rules. The rules themselves are constant so we don't need to change
them dynamically.
- During the runtime of otbr-agent, otbr-agent updates ipsets
accordingly whenever there's a change of on-link prefixes.
This commit adds a new macro `SuccessOrAssert()` which checks a given
status value against zero (zero status indicates success or no error)
and `OT_ASSERT()` if it is not. This helper macro is then used by
other modules where we want to assert that some method/function is
not returning an error.
This commit uses a longer duration (10s) to make the test more
reliable.
The root cause why LEADER does not become Leader within 4s is still
unknown and to be investigated.
Thread Test Harness requires devices to operate as if they were
commissioned using CCM. This commit adds the ability to configure the
device to behave as if it was commissioned using CCM. This
functionality requires `OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE` to
be enabled.
Problem:
I have encountered CslTxScheduler entering the incorrect state causing
the device to be unable to perform csl transmission. The state is
when mCslTxChild is null but mCslTxMessage is not null. As a result
Update() call does not have any effect.
I think that we enter the incorrect state when the following happens:
1. CSL transmission on mac is requested (mCslTxChild is set to the
best child found in RescheduleCslTx(), mCslTxMessage is set to the
child's IndirectMessage in HandleFrameRequest())
2. During the ongoing mac CSL transmission, Update() is called (this
method can be called from multiple places)
3. The mCslTxChild's IndirectMessage differs from the mCslTxMessage
==> mCslTxChild is set to nullptr
4. After the finished csl transmission on mac, the HandleSentFrame()
is called but it does not call RescheduleCslTx() so the mCslTxChild
remains nullptr
Then every Update() call does not have any effect. To change that we
would have to call RescheduleCslTx() or set the mCslTxMessage to null
but there is no way of doing that.
Solution:
I believe that mCslTxMessage is "tracking" the mac transmission - it
is to be set when transmission is requested, and to be cleared when
the transmission ends. In this commit we are doing it in a clear way.
This commit adds a member mDryRun in otPlatformConfig, allowing the
app to initialize in 'DryRun' mode. In this mode, many modules won't
be initialized. For example, the settings file and the tun device.
Background:
The otbr-agent provides a way to query the RCP version in a single run
which we call as 'DryRun'. During this process, the full posix daemon
initialization will be done (including initialization of the settings
file, access the tun device, create the sock file, etc). This will
cause such problem - In production, otbr-agent usually runs as a
service in some non-root user and is granted with the capability and
access it requires. But otbr-agent could sometimes also run by other
users to query the RCP version. For example, developers do that from
the console with the root user. In such case, otbr-agent will create
some files owned by the root user first. And then when the service
tries to start (with a non-root user), otbr-agent will find that it
doesn't have enough permission to open the file.
So in this commit, we try to prevent otbr-agent from touching any
files and other permission related stuffs if the DryRun option is set.
However it still needs to access the radio device (for example, the
'spi') since it needs to get the radio version. But accessing the
radio device with the root user doesn't affect the upcoming usage by
other non-root users.
Some enhancements for cert test run:
- Use a different log name for every test run. With the help of this
we can get all logs & pcaps after running a test case when MULTIPLY
> MAX_JOBS.
- While running test cases, print a line showing the test case being
run.
This commit adds a new common `Timestamp::Compare()` methods which
compares two given `Timestamp` pointers (determines whether they are
equal or one is ahead or behind the other one). The new method allows
either input (or even both) to be `nullptr`. A null timestamp is used
to indicate when there is no timestamp. In terms of comparison
result, a non-null timestamp is considered to be ahead of (or larger
then) a null one and two null timestamps are considered equal. The
new method is used in all different places where the `Timestamp`s are
compared.
This commit also adds a unit test to verify the `Timestamp` class (the
existing `test_steering_data` is renamed to `test_meshcop` which is now
used to include unit tests for all MeshCoP related definitions).
Add steps which verify the bug fix contributed to OTBR:
https://github.com/openthread/ot-br-posix/pull/1020
That is, verify that SRP updates which modify both a host
and a service can be successfully completed.
Current implement will start evaluating on-link prefix before
successfully sending kMaxRtrSolicitations=3 RS messages. This commit
fixes this issue by retrying sending failed RS messages in
kRtrSolicitationRetryFailDelay=60 seconds.
tcplp uses stdio.h which, for some libc implementations, can depend on
Kconfig defines.
These Kconfig defines can be included through compile options in
ot-config.
Link with ot-config to get the compile options.
Signed-off-by: Sebastian Bøe <sebastian.boe@nordicsemi.no>
This commit addresses an issue when forwarding received messages under
`MUTI_RADIO` config. We clear the radio type (which indicates the
radio on which the `Message` is received) when the same `Message`
instance is forwarded back to the Thread mesh to be sent out to a
neighbor. This then ensures that `RadioSelector` picks the radio to
send deadpanning on the neighbor's supported radios and their
preference.
This commit also updates `test-703-multi-radio-mesh-header-msg.py` to
verify and cover this situation.
This commit updates some of the `SpinelDecoder::Read{Item}()` methods
to initialize their local pointer variables to `nullptr`. Though we
technically do not need this change (since the call to `Read(aPtr)`
will set the pointer value on success), some toolchains cannot infer
this from the code and generate error/warning of "pointer may be
used uninitialized".
This commit changes `KeyManager` to use `SetAllMacFrameCounter(0)` to
reset the frame counter(s). This would then ensure that the new
counter value is also set on `SubMac` and radio platform layer
(which can handle the 15.4 frame counter assignments). This addresses
an issue where on Key Sequence update the frame counter values on
`SubMac` and radio platform can remain unchanged.
This commit updates CLI to not include the CLI prompt string "> " when
emitting the command's input and output to the logs under the config
`OPENTHREAD_CONFIG_CLI_LOG_INPUT_OUTPUT_ENABLE`. It also changes how
the input command is logged to avoid logging empty lines or extra
spaces in between the args.
This commit adds a check in `SignalFrameCounterUsedOnTxDone()` to
ensure that radio platform did indeed update the header (i.e.,
assigned a frame counter) before reading the counter value from the
frame and signaling its use.
This commit fixes two related aspects of updating of the frame counter
in `SubMac` and synchronizing the value with `KeyManager`.
It fixes an issue (when radio platform handles tx security and frame
counter management) where the counter value in `SubMac` and
`KeyManager` were set to old value used in the last transmission
(from `TxDone` callback). This would then lead to an already used
frame counter value to be included in MLE Link Frame Counter TLV.
Under `MULTI_RADIO` this could cause more harm since when appending
MLE Link Frame Counter TLV we move all counters for each radio link
up to max value among them and set the counter value on all radio
links(which would then cause the counter on radio platform to be set
to an older value).
This commit also updates the code to handle the case where the counter
value updates may be signaled out of order. This may happen due to a
new counter value being used for an enhanced-ack by radio platform
during tx of a frame. Note that the newer counter used for
enhanced-ack is processed from `SubMac::HandleReceiveDone()` which
can happen before processing of the older counter value from
`HandleTransmitDone()`.
This commit the libraries that I wrote as part of TCPlp to handle data
buffering. These libraries are intended to replace the mbuf-based data
buffering in the FreeBSD TCP implementation. They implement the send
buffer as a linked buffer chain (consistent with otLinkedBuffer in
OpenThread's TCP API) and the receive buffer as a circular buffer and
bitmap (used to keep track of which bytes were received out-of-order).
This commit updates and simplifies processing of Active/Pending
Timestamp TLVs (in MeshCoP and MLE) by using TLV helper methods
that read/write the TLV's timestamp value from/in a message.
This commit removes the `OT_TOOL_PACKED` requirement from types
`otMacKeyMaterial` and `Mac::KeyMaterial`. Generally, we define a
type as "packed" if it may be embedded in a message/buffer (e.g. a
TLV) and/or may be cast from a buffer pointer. Neither case applies
to `KeyMaterial`.
For certain external mbedTLS configurations, there is no much sense to
define MBEDTLS_SSL_EXPORT_KEYS when OT has Joiner || Commissioner ||
DTLS functionalities disabled.
This commit only ensures that such builds don't fail. The
mbedtls_ssl_key_export_type type is defined only when
MBEDTLS_SSL_EXPORT_KEYS is defined, while dtls.hpp is always taken
into the build process.
This commit fixes `DatasetManager::HandleSet()` to add a check to
ensure that the message contains `PendingTimestampTlv` when the
Pending Dataset is being updated.
This commit fixes the `NetworkName` check (for its length to be larger
than zero) which was recently added in commit e2f0afab5d. This commit
moves the name length check to method `Set(const NameData &aNameData)`
and after the `newLen` is calculated.
This commit also updates `TestMacNetworkName()` in unit test to verify
that setting the network name to an empty string correctly fails with
`kErrorInvalidArgs`.
This commit adds a new class `Cli::Output` which now includes all the
simple `Output{Item}()` methods that are used by CLI and its
sub-modules. It also adds new `Output` method flavors that output an
item (e.g., an IPv6 address) with an appended newline at the end.
These patterns are often used by CLI modules so having such new
methods help simplify the code.
The commit also adds `OutputWrapper` which is a wrapper over an
`Output` instance providing similar methods. This class is used as
the base class of different CLI sub-modules (e.g., `Cli::Dataset` or
`Cli::Joiner`, etc.) which helps simplify their implementation
(allow them to use the same set of `Output` helper methods as the
ones used by the `Cli::Interpreter` class).
This commit updates the `NetworkData` implementation to simplify it
and make it more flexible. It changes `NetworkData` class such that
it delegates providing the buffer space to store the TLVs to its
sub-classes (`Local`/`Leader`) or its users. This allow us to remove
many `static` methods that expect inputs of `(aTlvs, aTlvsLength)`
and instead the use the `NetworkData` methods directly. Basically,
the `NetworkData` class can now be considered as a wrapper over a
pointer to a buffer containing a sequence of TLVs which provides
methods to parse and process the TLVs. `NetworkData` class assumes
that the TLVs (buffer content) is immutable and we have a new class
`MutableNetworkData` which provides methods to update (add, remove,
or modify) the TLVs.
This commit updates the `Message::Chunk` type to use `Data` as its
base class (thus inheriting the common helper methods from it) which
helps simplify its use. This commit also adds couple of new methods in
`Data` class (method `SetLength()` to change the `Data` length, and
`MatchesBytesIn()` to compare the `Data` content with bytes from a
given buffer). The `test_data` unit test is also updated to check the
newly added `Data` methods.
This commit updates and simplifies the `alarm` platform implementation
under simulation by adding new functions to determine whether a timer
is expired and calculate the remaining time. The new code does not
use casting a `uint32_t` value to an `int32_t` (since its behavior is
toolchain/compiler dependent and it is not defined by the C++
standard).
This commit adds forward compatibility with mbedTLS 3.0.
Changes that affected OpenThread implementation:
- Rename mbedtls_*_ret() cryptography functions whose deprecated
variants have been removed (migration guide)
- Replace MBEDTLS_SSL_MAX_CONTENT_LEN with MBEDTLS_SSL_IN_CONTENT_LEN
and MBEDTLS_SSL_OUT_CONTENT_LEN options (migration guide)
- Signature functions now require the hash length to match the
expected value (migration guide)
- SSL key export interface change (migration guide) - this change
affected us a little bit more, since Key Block for KEK generation is
not part of mbedTLS callback anymore. I was able, however, to
retrieve it from Master secret (did successfully commissioning
between 2.2x vs 3.0). By the way, I clean up the code for KEK
generation - I don't know why we also executed it for application
CoAP secure?
- Separated MBEDTLS_SHA224_C and MBEDTLS_SHA256_C (migration guide)
- Most structure fields are now private (migration guide) - we use
private fields just in two files in dtls.cpp and ecdsa.cpp. For now,
I used a workaround by defining MBEDTLS_PRIVATE macro but we should
request the mbedTLS team to provide us support for public
getters.
Background:
In an early stage of developing a new product, developers may want to
verify the Thread related hardware functionality, for example, send,
receive, etc. However if the product uses the posix <-> RCP mode,
it's hard to verify it before the posix daemon can run on the
host. cli-ftd and cli-mtd could be an alternative. However, if the
product uses the posix <-> RCP mode, the space of the 802.15.4 radio
chip will be very small. For example, nRF52811 doesn't have enough
space to flash cli-ftd or cli-mtd firmware. So this PR creates a new
firmware ot-cli-radio which has very limited functionality for
verifying the hardware.
Basically, the ot-cli-radio consists of openthread-radio and
libopenthread-cli-radio.a. It supports very few cli commands. The most
important command is diag. Currently, there are: diag, help, reset,
version.
Currently, the diag commands have different implementation on RCP:
- For commands like diag start, the process function
(Diags::ProcessStart) is first called on host. Then host sends an
SPI frame to the RCP and Diags::ProcessStart (different
implementation) is called again on RCP.
- For commands like diag send, Diags::ProcessSend is first called on
host. Then host sends an SPI frame to the RCP, directly calling
send API. And there is no Diags::ProcessSend implemented on RCP.
Let's call the implementation of Diags::Process* currently on host as
native diag commands. When we run ot-cli-radio, we should use the
native diag commands because it won't interact with a posix daemon and
it processes the diag commands through the whole process. So this PR
adds a new option OPENTHREAD_CONFIG_DIAG_NATIVE_CMDS_ON_RCP to control
whether to use the native diag implementation on RCP. When we use a
normal RCP, the option should be disabled. While when use
ot-cli-radio, the option should be enabled.
This commit adds support in `HistoryTracker` to record the history of
changes to the Thread interface's unicast and multicast IPv6 addresses.
An entry is recorded when an address is added or removed. For unicast
addresses, each entry provides:
- Timestamp
- Event: Added or Removed
- Address : Unicast address along with its prefix length (in bits).
- Origin: Thread, SLAAC, DHCPv6, or Manual.
- Address Scope.
- Flags: Preferred, Valid, and RLOC (whether the address is RLOC).
For multicast address history, each entry provides:
- Timestamp
- Event: Subscribed or Unsubscribed.
- Address : Multicast address.
- Origin: Thread or Manual.
This commit also updates CLI and adds `history ipaddr` and
`history ipmaddr` commands to get the lists. It also updates the
documentation in `README_HISTORY.md`.
This commit adds a new class `AnycastLocator` which can be used to
locate the closest destination of an anycast IPv6 address (i.e., find
the related mesh local EID and RLOC16). The closest destination is
determined based on the the current routing table and path costs
within the Thread mesh.
The implementation uses a CoAP confirmable post request to a newly
added URI path ("a/yl"). The destination IPv6 address of such as
request message is set to the anycast address to be located. The
receiver of the request message sends a CoAP response which includes
the "Mesh Local EID" and "Thread RLOC16" TLVs.
This commit also adds support this new feature in CLI (adding a new
`locate <anycast-addr>` command).
Finally this commit adds `test_anycast_locator.py` to test behavior of
the new feature.
This commit adds header file `common/as_core_type.hpp` which adds
helper functions `AsCoreType()` which help convert from a
public C OpenThread type to its corresponding C++ core type (e.g.,
`otIp6Address` to `Ip6::Address`). This commit also adds `MapEnum()`
function to convert between public and core `enum` definitions (e.g.,
`otMacFilterAddressMode` and `Mac::Filter::Mode`). These helper
function act as syntactic sugar helping simplify the implementations
of OT API functions (in `api/{module}_api.cpp` files).
This commit adds new types `NetworkData::ServiceData/ServerData`
(which use the `ot::Data` class) which help simplify different
`NetworkData` methods dealing with Service and Server TLVs.
This commit adds two new generic types `Data` and `MutableData` which
are simply wrappers over a pointer to a buffer and a given data
length. The data length can be either `uint8_t` or `uint16_t` which
is determined by a template parameter. The `Data` treats the content
of the buffer as immutable whereas `MutableData` allows it to be
changed. This commit also adds a unit test `tes_data` to verify the
behavior of newly added types.
This commit ensures to call `UpdateRoutes()` on rx of a first lowpan
fragment frame. `UpdateRoutes()` can then update the snooped address
cache entries and check if the message is from a previous child (which
indicates that the child has switched to a new parent). This change
should help address an issue with "inform previous parent" behavior
not removing the child when `MULTI_RADIO` is enabled (due to frag
header added to the frames for duplication detection under
multi-radio).
This commit fixes a potential bug that delayed Data Requests may use
wrong Active and Pending Timestamps because the Active & Pending
Timestamps may change while a Data Request is being delayed.
This commit disallows concurrent commands.
With this commit, the CLI only execute a new command after it complete
the previous command. CLI can also prompt properly after the command
execution is done.
Other fixes and enhancements:
- Fixes premature command prompt
- Add ping async command for ping in async mode: output Done
immediately but print ping responses later on.
- Fixes networkdiagnostic get outputs multiple Done by always waiting
for 5 seconds.
This commit updates `Start()`, `Stop()` and `SendAnnounce()` in `Mle`
to remove the extra parameters from the `public` versions of these
methods (adding a `private` version with extra parameter for use by
`Mle` class itself). It also adds `StartMode`, `StopMode`, and
`AnnounceMode` enumerations to use as parameter type (instead of
`bool`) in these methods which helps with code readability.
This commit updates the `Message::Settings` such that it directly
inherits from the `otMessageSettings` C struct definition. This helps
simplify the initialization of the constant default `Settings`
instance (from `GetDefault()`) to avoid calling object constructor.
It also simplifies the conversion from an `otMessageSettings *` to
a `Settings` (if the pointer is not NULL, the `otMessageSettings`
instance itself can be directly used instead of creating a copy).
According to SPEC-981, we need to verify 3 more things while setting a
network name:
- The name length >= 1.
- There are no UTF control characters in the name.
- There are no UTF NUL characters in the name. This is covered by the
second rule.
This commit updates `Srp::Server` to add support for selecting its
address mode (unicast or anycast). The address mode specifies how the
SRP server determines its address and port number and how this info
is published in Thread Network Data.
In anycast address mode, the SRP server will use port number 53 which
is also used by DNS resolver/server. So if both `Srp::Server` and
`Dns::ServiceDiscovery::Server` are enabled on a device, they both
need to listen on the same port number and share the same UDP socket
instance. This commit adds the mechanism in the code to realize this.
The `Srp::Server` will monitor when/if DNS-SD is active and checks
whether the port numbers match and if so it will close its own socket
and re-use the one from DNS-SD. In this case, an incoming UDP message
is first given to `Srp::Server` to process and if it fails to process
it then the message is given to DNS-SD.
This commit also adds CLI commands under `srp server` to get/set the
address mode (and update the `README_SRP_SERVER.md` documentation).
It also adds a new test `test_srp_server_anycast_mode` which covers
the SRP server address mode and the newly added behaviors.
- New format for MAC keys, as a union between literal key and keyrefs.
- Modified key_manager to handle both literal keys or keyrefs.
- Modified MAC and sub_mac modules to handle both Literal Keys or keyrefs.
- Updated Crypto Modules to use abstracted APIs.
- New CLIs to handle networkkey and pskc references.
When brew install ninja, python 3.9 is being installed as a
dependency. However, the installation failed because there is a
conflict on binary /usr/local/bin/2to3.
This commit simplifies the `Metadata` definition in `Message` by
rearranging the member variables (to avoid alignment gaps). It moves
the definition to be sub-type of `Buffer`. It also removes the
doxygen documentation for `private` or `protected` definitions
(mainly for simple getters/setters).
This commit adds `OPENTHREAD_CONFIG_LOG_PREPEND_UPTIME` config to
prepend the current uptime (as "[x days] hh::mm::ss.mmmm") to the
OpenThread log messages.
This commit adds a new module `Uptime` which tracks the number of
milliseconds since OpenThread stack initialization as an `uint64_t`
value. It also adds public OT APIs to get the current uptime value
(either as the number of milliseconds or in human-readable string
format like "2 days 12:45:12.762"). A CLI `uptime` command is also
added. This feature can be enabled using the newly added config
option `OPENTHREAD_CONFIG_UPTIME_ENABLE` (or the related CMake
`OT_UPTIME` option).
This commit adds a new header `common/const_cast.hpp` which provides
template functions `AsConst()` and `AsNonConst()` to cast between
const and non-const references or pointers. The template functions
simplify the code (act as syntactic sugar) by allowing the compiler
to infer the underlying reference/pointer types.
This commit simplifies the `NetworkData` class by removing the `mType`
Instead we add a new parameter in `SendServerDataNotification()` which
indicates whether to append the Network Data TLV to the message or
not (which was previously determined by `mType`).
This commit simplifies USB connection handling after resetting (hard reset)
RCP device with USB transport.
It drops udev dependency making the new approach generic for USB CDC ACM
across all platform.
It is working also on dockers.
The feature is enabled by new radio Url parameter: 'uart-reset'.
Radio url example:
spinel+hdlc+uart:///dev/serial/by-id/SYMLINK_TO_RCP_DEVICE?uart-reset
It is meant only for connection with RCP devices working with USB
transport and performing hard reset on host reset command.
This commit simplifies `test_platform` module which defines the
platform APIs used by unit tests. It removes the unused global
variables and the function pointer mechanism to override platform
APIs. Instead the platform APIs in `test_platform` are defined as
`OT_TOOL_WEAK` allowing individual tests to override any of the
default implementation with their own version (e.g. `test_timer`
provides its own alarm platform APIs).
This commit updates `platformAlarmGetNext()` in `alarm-sim` in
virtual-time simulation platform to return the remaining duration
to the next alarm as `uint64_t` (in microseconds). This fixes the
issue with potential overflow in calculating the next alarm time.
RFC 6763 Section 6.1 states the following:
An empty TXT record containing zero strings is not allowed [RFC1035].
DNS-SD implementations MUST NOT emit empty TXT records. DNS-SD
clients MUST treat the following as equivalent:
o A TXT record containing a single zero byte.
(i.e., a single empty string.)
o An empty (zero-length) TXT record.
(This is not strictly legal, but should one be received, it should
be interpreted as the same as a single empty string.)
o No TXT record.
(i.e., an NXDOMAIN or no-error-no-answer response.)
This commit reflects the second requirement.
This commit changes `radio_platform.cpp` to use `otError` in the
function definitions (weak/default implementations of) radio
platform APIs. This ensures the definitions are consistent with
their declarations in `radio.h`.
This commit updates `RouterTable` to ensure signalling removal of
neighbor routers when router table is fully cleared or when a
`Router` with a specific released router ID is cleared.
This commit adds support in `HistoryTracker` to record the history of
changes to the neighbor table. An entry is recorded when a child or
router neighbor is added, removed, changed, or being restored (the
restored entries are only used for the previous children list
retrieved from non-volatile settings on the device (re)start). Each
entry provides:
- Timestamp
- Type: Child or Router
- Event: Added, Removed, Changed
- Extended Address
- RLOC16
- MLE Link Mode (rx-on-when-idle, FTD/MDT, full-netdata).
- Average RSS (in dBm) of received frames from the neighbor at
the time the entry was recorded.
This commit also updates CLI and adds `history neighbor` command
to get the neighbor history. It also updates the documentation.
This commit fix addresses few problems:
- Method ScheduleMessageTransmissionTimer at first call after CSL is
enabled calculated interval incorrectly.
- Data Polls after transition from MED to SED were triggered with
incorrect interval.
This commit fixes the test by removing the unnecessary argument
in the call to `srp_client_remove_host()`. Removing the host on
SRP client also removed all previously registered service so
we can remove the call to `client.srp_client_remove_service(...)`.
This commit adds a new parameter `aSendUnregToServer` to SRP client's
`RemoveHostAndServices()` API. This parameter determines the behavior
when the host info is not yet registered with the server. If it is
set to `false` (which is the default/expected value) then the SRP
client will immediately remove the host info and services without
sending an update message to server (no need to update the server if
nothing is yet registered with it). If it is set to `true` then the
SRP client will send an update message to the server. Note that if
the host info is registered then the value of `aSendUnregToServer`
does not matter and the SRP client will always send an update message
to the server requesting removal of all info.
One situation where this parameter can be useful is on a device
reset/reboot where the caller may want to remove any previously
registered services with the server. In this case, caller can
`SetHostName()` and then request `RemoveHostAndServices()` with
`aSendUnregToServer` as `true`.
This commit also adds `test_srp_client_remove_host.py` which
verifies the behavior the newly added mechanism between client and
server.
This commit changes the check for the number of host addresses in
a newly received SRP update message such that if we have a non-zero
lease, we ensure that there is at least one valid address. It also
moves this check from `ProcessHostDescriptionInstruction()` to
after the Lease Option in the Additional Section is parsed (in
`ProcessAdditionalSection()`) so that we check after we determine
the host lease interval and whether the host is being removed or
registered.
This commit enables use of range-based `for` loop for iterating over
all the entries in a `LinkedList`. It adds private implementations of
`Iterator` and `ConstIterator` which inherit from `ItemPtrIterator`
and use the `GetNext()` to go to the next entry. The range-based
`for` loop practically acts as a syntactic sugar helping simplify the
code and does not add any code size (or any expected run-time)
overhead.
We discovered that dns resolve takes a little longer i.e. 15sec to
finish (rather than default timeout of 10s). Thus using a larger
timeout for dns resolve (and other dns commands), e.g. 30s has helped.
Currently, we disable retries on radio/submac of data polls with CSL
IE (I believe to avoid sending outdated CSL IE). To compensate for
this, we use kMaxCslPollRetxAttempts (default 15) instead of
kMaxPollRetxAttempts (default 4), which gives us more possible retx on
mac.
Assuming we get NoAck error, depending on the presence of CSL IE,
there will be:
a) 4 attempts (on mac) with up to 15 retries on radio/submac (if no
CSL IE)
b) 4 attempts on mac (if CSL IE present) because child is considered
detached from parent after 4 data poll transmissions that returned
NoAck error.
So in the end, the increased number of RetxAttempts does not have a
full effect - we start to reattach after 4 retx while having 15 retx
allowed.
This commit adds kFailedCslDataPollTransmissions constant that will be
used instead of kFailedRouterTransmissions in case of data poll with
CSL IE on Child-Parent link.
This commit removes the PACKAGE_VERSION definition from the global
config target so that when the git commit id is changed, only a few
sources will be re-compiled.
MIC is a part of data payload, so if it's present, data payload is not
empty even if the data message is empty (ieee802154-2020 7.2.1 -
General MAC frame format). If so according to Termination IE
inclusion rules (ieee802154-2020 7.4.2.1 Table 7-6) Header Termination
IE2 need to be applied.
This commits adds a new `otNeighborTableEvent` which indicates that a
child's Device Mode is changed (in addition to existing events which
indicate that a child or a router neighbor is being added or
removed).
This commit renames and moves the related types in `Netif` module like
`UnicastAddress`, `MulticastAddress`, etc. under `Netif` class (as a
nested type). It also moves iterator types under the related type
(for example, `ExternalMulticastAddressIteratorBuilder` becomes
`Iterator::Builder` under `ExternalMulticastAddress` class. These
changes help simplify the code (allow us to use shorter names in the
`Netif` implementation).
This commit updates `Mle::SetRloc16()` to skip removing and re-adding
of the `mMeshLocal16` IPv6 address when it does not change.
It also updates how the cached CoAP messages are cleared such that
they are cleared only if the address gets changed.
This commit changes the Makefiles so that the TCPlp module is linked
in to the code when building OpenThread using CMake. This is necessary
when script/build or script/cmake-build is used to build OpenThread.
This commit updates `Mac` under `MULTI_RADIO` config to limit the
radio links used when sending a MAC Beacon frame (which uses
broadcast destination and therefore by default would be sent on all
radios) to the same radio links from which the triggering Beacon
Request frame(s) were received. This ensures that when a multi-radio
node scans another multi-radio node we get one Beacon response on
each radio link.
This commit updates the `test_netdata_publisher` to add extra wait
time between adds (where the same on-mesh prefix is published on all
routers). This should help make the test robust and avoid the
situation where publishing the same prefix on all routers all
together could cause the number of entries in the Network Data to
temporarily go above the desired number. This can happen (though not
often) due to the randomness in how/when nodes using `Publisher` add
their entry in the Network Data.
This commit updates `Mle::DiscoverScanner` to check that IPv6
interface is enabled from `Discover()` (returns `kErrorInvalidState`
if netif is not up).
This commit adds History Tracker feature and its CLI support. This
feature records history of different events as the Thread network
operates (e.g., history of RX and TX IPv6 messages or network info
changes).
Recorded entries are timestamped. When the history list is read, the
timestamps are given as the entry age relative to the time the list
is being read. For example in CLI a timestamp can be shown as
`02:31:50.628 ago` indicating the entry was recorded 2 hours, 31 min,
50 sec, and 628 msec ago. Number of days is added for events that are
older than 24 hours, e.g., `31 days 03:00:23.931 ago`. Timestamps use
millisecond accuracy and are tacked up to 49 days. If an event is
older than 49 days, the entry is still tracked in the list but the
timestamp is shown as old or `more than 49 days ago`.
The `HistoryTracker` currently maintains 3 lists. The Network Info
history tracks changes to Device Role, Mode, RLOC16 and Partition ID.
The RX/TX history list records information about the received/sent
IPv6 messages:
- Message type (UDP, TCP, ICMP6 (and its subtype), etc.)
- Source and destination IPv6 addresses and port numbers
- IPv6 payload length
- The message checksum (for UDP, TCP, or ICMP6).
- Whether or not the link-layer security was used
- Message priority: low, norm, high, net (for control messages)
- Short address (RLOC16) of neighbor who send/received the msg
- Received Signal Strength (in dBm) for RX only
- Radio link info (15.4/TREL) on which msg was sent/received
(useful when `OPENTHREAD_CONFIG_MULTI_RADIO` is enabled)
Config `HISTORY_TRACKER_EXCLUDE_THREAD_CONTROL_MESSAGES` can be used
to configure `HistoryTracker` to exclude Thread Control message
(e.g., MLE, TMF) from TX and RX history.
The number of entries recorded for each history list is configurable
through a set of OpenThread config options, e.g., number of entries
in Network Info history list is specified by OpenThread config option
`OPENTHREAD_CONFIG_HISTORY_TRACKER_NET_INFO_LIST_SIZE`. The
`HistoryTracker` will keep the most recent entries overwriting oldest
ones when the list gets full.
This commit also adds support for `HistoryTracker` in CLI. The CLI
commands provide two style for printing the history information: A
table format (more human-readable) and list style (better suited for
parsing by machine/code). `README_HISTORY.md` is added to document
the commands and the info provided by each history list entry.
This commit also adds `test_history_tracker.py` test-case which
covers the behavior of `HistoryTracker`.
This commit refines system initialization and de-initialization by
separating the process before and after OpenThread instance creation
and destruction:
otSysInit():
Call platformInit()
Create OpenThread Instance as `gInstance`
Call platformSetUp()
otSysDeinit():
Call platformTearDown()
Destroy OpenThread Instance `gInstance`
Call platformDeinit()
This commit should help fix the issue that platform UDP sockets can
not be created when constructing OpenThread instance.
This commit contains other related changes:
- otSysDeinit now destroys the OpenThread instance
- posix/platform code use a global variable gInstance to track the
single global OpenThread instance, instead of using multiple
pointers in multiple files.
This commit adds helper functions to convert a `RoutePreference`
to/from a 2-bit unsigned encoded value. These are used in
`NetworkData` (for on-mesh prefix or external route) and also in
`RoutingManager` and `RouterAdv`. This change ensures that we do not
use bitwise shift of a signed and potentially negative value (`a >> b`
where `a` is negative). Note that the behavior of right bitwise shift
of a negative value is not specified by C++ standard and it is
implementation/toolchain dependent.
Per RFC 4862 section 5.5.3, the SLAAC address of a on-link prefix
will not immediately be invalidated even if the on-link prefix is
sent with zero PIO valid lifetime but we currently removes the
external route for the on-link prefix when we see zero valid lifetime.
This results in an error case that a Thread device can not reach
a valid SLAAC address of a Wi-Fi host on the same infra link because
there is no routes for this address.
This commit fixes this issue by delay removing the external route
for the discovered on-link prefix untill its valid lifetime expires.
Meanwhile, the Border Router now considers a deprecated (zero preferred
lifetime) on-link prefix not usable. Thus, the Border Router will
start advertising its own on-link prefix when current on-link prefix
is deprecated.
There is a potential bug in
DuaManager::ProcessDuaResponse(Coap::Message &aMessage).
The original code finds the Child by Child *child =
Get<ChildTable>().GetChildAtIndex(mChildIndexDuaRegistering);, which
assumes that the DUA.rsp must be targeting the current registering
Child. This is true for DUA.rsp, but not correct for DUA.ntf because
BBR may send DUA.ntf at any time to any device.
So, this commit changes DuaManager::ProcessDuaResponse code to search
for the correct Child with the target DUA instead of using
mChildIndexDuaRegistering.
This commit also contains other refactoring on
mChildIndexDuaRegistering usage.
This commit implements a new feature "Network Data Publisher" which
provides mechanisms to limit the number of similar entries (service
and/or prefix) in the Thread Network Data by monitoring the Network
Data and managing if or when to add or remove entries. This feature is
enabled using `OPENTHREAD_CONFIG_NETDATA_PUBLISHER_ENABLE` config, or
`NETDATA_PUBLISHER` in autoconf, or `OT_NETDATA_PUBLISHER` cmake
option.
This commit adds support for publishing DNS/SRP anycast/unicast
service, on-mesh prefix, and external route prefix entries.
When there is a request to publish an entry, the `Publisher` monitors
the Network Data and counts the number of similar entries. If there
are fewer entries than a desired target number, the entry is added
after a short random delay.
If there are too many similar entries, `Publisher` starts the process
of removing its own entry (again after some random wait time). When
removing entries, certain entries are preferred over others (e.g., an
entry from a router over one from an end-device or if they are from
the same type of node, the one with smaller RLOC16). If `Publisher`
determines that its own entry is a preferred one, it adds an extra
wait time before removing its entry. This gives higher chance for a
non-preferred entry from another device to be removed before removing
a preferred entry which helps towards quicker convergence of the
process to the desired number of entries.
On-mesh prefix and external route entries have a "preference" field.
When publishing such an entry, a matching entry in the network data is
counted only if its preference is same or higher than the entry's
preference. This ensures that a device with a higher preference entry
publishes its entry even when there are many lower preference similar
entries in the network data (potentially causing a lower preference
entry to be removed).
This commit also adds `test_netdata_publisher.py` to verify the
behavior of the `Publisher`.
This commit replaces the `enum` constants with `constexpr` definitions
in all the modules under `core/utils`. This commit also contains
some smaller changes: typo fixes in the comments, removal of unused
constants, and adding `uint` type to the named `enum` definitions.
This commit replaces the `enum` constants with `constexpr` definitions
in all the modules under `core/meshcop`. This commit also contains
some smaller changes: removal of unused constants, and adding `uint`
type to the named `enum` definitions.
The compile-time log level definition is the lowest log level
that can be set by `otLoggingSetLevel`. This is useful for
dumping more logs for testing.
This commit adds two new helper methods in `MessageQueue` and
`PriorityQueue` which provide functionality that is commonly used in
other modules: `DequeueAndFree()` which dequeues and frees a message
from the queue), and `DequeueAndFreeAll()` which removes and frees
all messages in the queue).
When a platform provides `OT_RADIO_CAPS_TRANSMIT_SEC` capability,
it updates the frame header with the dynamic data (frame counter,
key id...) and returns it back to MAC together with the transmission
result.
So far the `mIsARetx` flag was being used to instruct the radio
whether to update the header or not, but there was no mean to know
if the radio was able to do so.
This commit introduces the `mIsHeaderUpdated` flag which is used in
both directions, so the MAC layer can react to cases in which the
frame header was not properly updated by the radio platform.
The usage of mIsARetx remains restricted now to two cases:
- When a SSED decides to re-synchronize CSL parameters after a
retransmission.
- To check if sequence number was set for CSL/indirect retransmissions.
This commit includes a test case to verify that multiple border
routers can publish their meshcop services successfully without
instance name conflicts.
This commit changes MLE module such that during an attach attempt in
the third phase where we send MLE Announce on all channels we wait
till the end of the phase (i.e., after MLE Announce tx on all
channels and transition from `kAttachStateAnnounce`) to process any
received "Parent Response" and try to attach to a parent. This
ensures that we wait long enough to receive "Parent Response" from
all potential parents during this phase. Note that at the start this
phase we send an extra "Parent Request to routers/REEDs" to have
another chance to find a parent.
This commit simplifies the logging macros by removing the input
string parameter `aRegionPrefix` in the call to the underlying log
function and instead converts the `aLogRegion` to the proper string
from the private `Log()` function. The removal of the additional
argument in the call to the logging functions helps reduce the
overall code size. This is applicable to the default and commonly
used configuration where logging uses functions. In the case where
logging is fully implemented as macros the `aRegionPrefix` is still
needed and used.
This commit adds a new config in `Srp::Client` which specifies whether
the SRP client is allowed to switch server (when auto-start feature
is enabled) on timeouts when host or service info were previously
successfully registered with the currently selected server. Note that
independent of this config, auto-start will always switch and select
a new server when the entry in the Network Data corresponding to the
currently selected server gets removed.
When a new service with subtypes is added to an existing
host, the SRP server incorrectly merges the subtype service
copies so that the TXT information is lost, i.e. 0-length
TXT record is created.
Moreover, the OT DNS client cannot parse services with
0-length TXT record (instead of ignoring the TXT record
itself) causing that such a service cannot be examined
at all.
The problem is caused by incorrect merging of the service
description structure which is shared across all services
with the same instance name (i.e. among the base type
service and its subtypes).
Signed-off-by: Damian Krolik <damian.krolik@nordicsemi.no>
This commit replaces the `enum` constants with `constexpr` definitions
in all the modules under `core/thread`. This commit also contains
some smaller changes: typo fixes in the comments, removal of unused
constants, and adding `uint` type to the named `enum`s.
This commit introduces two changes. First is adding capability to turn
off CSL, by implementing missing 0 value handling.
Secondly adds proper transition between SSED (CSL on) and MED states
(CSL off).
This commit aims to update the meshcop service instance name in
test_publish_meshcop_service.py to make it consistent with the change
on ot-br-posix side.
This commit fixes methods `SendLinkMetricsManagementResponse()`,
`SendLinkMetricsManagementRequest()` and `SendLinkProbe()` in `Mle`
to ensure that the allocated MLE message is freed on an error. Note
that on success the `Mle::SendMessage()` will take the ownership of
the allocated `Message`.
This allows for registering a callback on all lines read from a
device, making it possible to react to output from asynchronous cli
commands while concurrently executing new commands on the same
device. Normally, executing those new commands would result in the
async command output being lost.
Known caveats:
1. The same limitations as with wait apply to OtbrSshCommandRunner
(you can't get async output).
2. For OtCliCommandRunner, any commands sent to the device in the
callback need to be offloaded to another thread. Otherwise the read
routine thread will be blocked, and the command will timeout.
This commit fixes reporting expect failures by adding fail on error
flag to the ot_exec_expect_script function in script/test script.
This commit also fixes failing expect tests and removes expect tests
on macOS for unstable issues.
This commit fixes an issue in `CoapSecure::Stop()` accessing an
already dequeued and freed `Message` instance (from the `for` loop
iteration trying to `GetNext()` message). The code in this commit
removes the head element one by one (`MessageQueue::GetHead()`)
until the queue becomes empty.
This commit fixes a bug in `RemoveDataResponseMessages()` where
`GetNext()` method may be called on an already dequeued and freed
`Message` instance (within the `for` loop iteration). The change in
this commit ensures to get and retain the `next` message before
potentially removing the message from the `mSendQueue` and freeing
it.
This commit adds template `Find/ContainsMatching<Indicator>()` methods
which search in the array to find the first element matching a given
indicator. Unit test `test_array` is also updated to check the
behavior of newly added methods.
This commit enhances the template `Array` class implementation to
allow the `uint` type used for array size (which is also used for
length and index) to be specified as a template type parameter. If
not explicitly specified, a default `uint` type is selected based on
the array size `kMaxSize`, i.e., if `kMaxSize <= 255` then `uint8_t`
will be used, otherwise `uint16_t` will be used.
This commit replaces the `enum` constants with `constexpr` definitions
in all the modules under `core/net`. This commit also contains some
smaller changes: typo fixes in the comments, removal of unused
constants, and adding `uint` type to the named `enum` definitions.
When compiling OpenThread public header files independently, the
compiller generates errors, such as `unknown type name "size_t"`
and 'unknown type name "otLogLevel"'.
This commit adds the corresponding header files to the public
headers to resolve this issue.
This commit adds a generic `Array<Type, kMaxSize>` class which
represents a fixed size array of elements of template `Type` which
tracks its current length. Entries can be appended to the array
(`PushBack()`) and removed from the end of array (`PopBack()`). This
simple data model is used in some other modules, so having a generic
version can help simplify the code. This commit also adds a unit test
to verify `Array` methods.
This commit replaces the `enum` constants with `constexpr` definitions
in all the modules under `core/common`. It also adds type to the
names `enum` definitions.
This commit contains style changes, simplifications, and renames in
Link Metrics modules. It moves all the definitions under a new
namespace `LinkMetrics` which allows the use of shorter and simpler
names for types, methods, and constants (omit the `LinkMetrics`
prefix from names). For example, `LinkMetricsTypeIdFlags` and
`LinkMetricsSeriesInfo` are renamed to simpler `TypeIdFlags` and
`SeriesInfo` respectively.
This commit replaces the `enum` constants with `constexpr` definitions
in all the modules under `core/mac`. The `constexpr` constants have
the advantage that they are explicitly typed while still being
compile-time constants with no code size overhead.
This commit also contains some smaller changes: typo fixes in the
comments, removal of unused constants, and adding type to the named
`enum` definitions.
The OpenThread instance has already been deinitialized before the
platform MulticastRoutingManager is deinitialized. We can never
reference to mInstance in Deinit.
This commit adds empty implementations of `otPlatInfraIf` platform
APIs under simulation. It also adds `otPlatInfraIfHasAddress()` in
`test_platform`. This allows the unit tests and simulation platform
builds to succeed when `OPENTHREAD_CONFIG_BORDER_ROUTING_ENABLE` is
enabled.
This commit fixes a bug in `RadioSpinel` platform implementation where
the request from OT core stack to enter RX mode may be ignored
causing the RCP/radio to stay in RX mode on an incorrect channel.
This situation can happen after a frame TX request on a different
channel (note that the `otRadioFrame` struct specifies the channel on
which the frame should be transmitted). After frame TX, radio driver
is expected to enter RX mode on the same channel on which the frame
TX happened. The OpenThread MAC layer always explicitly instructs the
radio to enter RX mode on the PAN channel (from `Mac::UpdateIdleMode()`
which in turn calls the radio platform API `otPlatRadioRecive()` with
the channel passed in as a parameter). The earlier `RadioSpinel`
platform implementation did not update `mChannel` on a tx request
which caused the subsequent `Receive()` to skip setting the channel on
RCP if the channel was same as before.
Dump the RA messages sent/received on infra if for testing scripts.
This commit removes the requirement of OT_REFERENCE_DEVICE but always
dump the RA messages at log level DEBG.
In the issue, compiler complained we were copying 16 bytes to a
location of 12 bytes. This was because in the check, the compiler
thought we are going to copy data to a nlmsghdr which is 12 bytes. The
reality is that we're copying data to a place behind nlmsghdr in req
struct.
This commit relaxes BBR dataset matching to only compare the first
byte of Service Data (i.e. 0x01).
This commit also requires all Service TLV searching methods to
explicitly specify aExactServiceDataMatch argument, helping to reduce
unconscious mistakes.
This commit adds `OPENTHREAD_CONFIG_CLI_LOG_INPUT_OUTPUT_ENABLE`
option which configures the CLI module to log its input command
string and the resulting output. This is done in addition to emitting
the output string to the console. By default this config is enabled
on all POSIX based platforms and when `LOG_OUTPUT` is not set to use
CLI console itself.
OpenThread uses the compile option
-DOPENTHREAD_PROJECT_CORE_CONFIG_FILE=openthread-core-posix-config.h
to specify the OpenThread configuration file. Some build systems do
not support this usage.
This commit includes the default user implemented configuration header
file to avoid specifying the configuration file.
This commits updates `thread-cert/Makefile.am` adding some existing
tests that were not included in the Makefile when the tests were
added. It also sorts the entries to be in alphabetical order.
This commit also updates the access control mode for all script files
to be executable by all (`chmod 755` or "-rwxr-xr-x").
This commit updates the logging in `netif` module under posix platform
code. It adds a prefix `[netif]` to the log line to help distinguish
the logs from this module from other platform layer logs.
It also removes some of the extra logs (e.g., logging `processTx: OK`
or `processRx: OK` on every rx and tx) and only logs failures
(at warning log level).
This commit updates the logs in `RoutingManager` so that the log
messages start with capital letter (making them consistent with
logs in other modules).
This commit adds a new static method `Timer::RemoveAll()` which
removes all running timers from the `Scheduler`. This method is only
intended for use by by `test_timer` unit test, allowing it to remove
any timers that may be started from constructors of different objects
in an OT instance before starting the unit test. With this change, we
can have timers started from constructors.
To ensure that the `RemoveAll()` is only used by the unit test, it is
defined as a `protected` method which can still be used in the test
which defines and uses `TestTimer` as a sub-class of `Timer`.
This commit refactors and simplifies the `Timer` module, mainly
declaring the corresponding `Scheduler` as a nested type of `Timer`,
`TimerMilli` or `TimerMicro` classes. It also changes the `Scheduler`
methods to be `protected` or `private` limiting access to them.
This commit fixes a couple issues with sending MGMT_SET.req to udpate
the leader with a new operational datset.
- When handling an MLE Child ID Response message,
DatasetManager::Save() is called before the role is updated to
child. As a result, a device with a newer dataset prior to attaching
the network will not send a MGMT_SET.req message. This commit adds a
delay to allow the role to change to child.
- When receiving a MGMT_SET.rsp, the device will immediately check if
it should send a MGMT_SET.req message again. However, the
operational dataset may not have had a chance to propagate from the
leader. This commit adds additional delay to allow the new
operational dataset to propagate.
This commit allows a zero-len prefix `::/0` to be added as an external
route in Network Data. Such a prefix can act as a default route. This
commit also adds `test_zero_len_external_route.py` testcase to verify
the network's behavior using a zero-len external route.
This commit adds a new feature in DNS client to automatically set and
update the server's IPv6 address in the default config. This is done
only when user does not explicitly set or specify the server address.
This behavior requires SRP client and its auto-start feature to be
enabled. SRP client will then monitor the Thread Network Data for
DNS/SRP Service entries to select an SRP server. The selected SRP
server address is also set as the DNS server address in the default
config.
This commit also adds `test_dns_client_config_auto_start.py` which
verifies the behavior of the new feature. In particular, that the DNS
client's default config gets changed and mirrors the SRP client
selected server address (when not set by user) and that it remains
unchanged if user explicitly sets the address in the default config.
This commit updates `AddressResponse::GetNat64Prefix()` to search in
Network Data to find NAT64 prefixes added by BRs. Prefixes with
higher preference are selected first.
Verified that this commit fixes the infinite DUA.req loop.
This is a quick fix. We still need to reactor
mChildIndexDuaRegistering because there are still potential issues.
The default Thread version has been set to 1.2 when building. Our test
script which checks building hasn't been updated accordingly. This
commit fixes this error.
We should remove the UpdateMetadata before committing the SRP update
to ensure that the same UpdateMetadata (and the Host object) can never
be touched again.
This commit updates `Dns::ServiceDiscovery::Server` to add support for
browsing a service subtype. In particular, it updates the code which
breaks a DNS name into its components such that it can correctly
parse and accept a service subtype name. It also updates how the
service name compression is done to handle the subtype names.
This commit also updates `Dns::Client` to remove the extra check of
service name (which is already verified) when trying to find a PTR
record for a given service instance name. This change enables browse
for service subtype (parsing the browse response).
This commit also updates and enhances the `test_dnssd.py` script
adding test-cases for browsing for service subtype.
This commit adds support for service subtypes in SRP server. It
updates the internal data model to store services in `Srp::Server`.
Every `Host` now has a list of `Service` entries along with a list of
`Service::Description` entries. These types mirror the SRP update
message format and the set of instructions that form the SRP message.
The `Service` entries represent the "Service Discovery Instructions",
i.e., the PTR records mapping a service name or a subtype name to a
service instance. A `Service::Description` entry represents the the
SRV and TXT records. A `Service` entry is always associated with a
`Service::Description` and the subtypes of the same service instance
all share the same `Service::Description` entry.
This commit also adds a new method `Host::FindNextService()` and the
public API `otSrpServerHostFindNextService()` which is very flexible
and can be used in different ways. It can be used to iterate over the
full list of services, or over a specific subset of services matching
certain conditions, e.g., iterate over all base services excluding
subtypes, or over all subtypes of an instance, or over all deleted
services, etc. It can also be used to find a specific service with a
given instance and service names.
This commit also simplifies and enhances the logging in `Srp::Server`.
In particular, when a new host is added, we now also log the list of
services being added along with it. Also a change to a `Service` is
only logged if the `Service` is marked as committed. This ensures
that temporary `Service` entries associated with a newly received SRP
update message are not logged (e.g., when an associated temporary
`Host` object is being freed after its content is merged with an
existing `Host` entry).
Finally, this commit adds a test `test_srp_sub_type.py` to cover the
subtype service registration on SRP client and server.
This commit adds support for service subtype in `Srp::Client`. The
`otSrpClientService` now includes a pointer to an array of service
subtype labels (which can be set to `NULL` if there is no subtype).
Each subtype is appended as a PTR record (i.e., a Service Discovery
Instruction) in the SRP update message.
This commit also updates The `Utils::SrpClientBuffers` to provide an
array for the subtype labels (pointers). The default size of the
service name buffer is also incremented so that it can be used for
saving subtype label strings.
The CLI `srp client` implementation is also updated to support service
subtypes where the `<servicename>` can optionally include a list of
subtype labels separated by comma (e.g., `_ser._udp,_s1,_s2`).
This commit removes the API to enqueue an out of band frame for
transmission by MAC layer. This API was added as a work-around to
enable legacy (non-Thread based) frames to be sent along with Thread
frames. This model is no longer used and generally not recommended.
The preferred way to handle multi-radio/multi-protocol is to add
support for it in radio platform layer.
In wait, match_line is called with the arguments flipped. The first
argument is supposed to the be the line being checked, and the second
is supposed to be the pattern to match. The reason this still works
for strings is because output is treated as a list of lines to expect,
and each is just compared with == to the actual expected line
This commit changes `ParseCmd()` such that as `aArgs` array entries
are populated with parsed arguments from a command line string, the
remaining unused `aArgs` entries in the array are marked as "empty".
We also ensure that the `aArgs[]` array always end with an "empty"
`Arg` which indicates end of the list (this is similar to how C
string ends with a null '\0' character). This commit also changes
different methods of `Arg` class (`Arg::ParseAs{Type}()` or overload
of operator `==`, etc) to check and handle when `Arg` is marked
as "empty".
These changes help simplify how the arguments are processed in CLI
modules. In `Cli::Process{Command}()` methods we can just pass the
`aArgs[]` array and do not need to pass a separate args length
parameter. In many cases the args length checks can be removed since
it will be checked from `ParseAs{Type}()` call.
This commit updates `VerifyOrQuit()` and `SuccessOrQuit()` macros to
include the failed condition in the error message that is printed on
a failure (in addition to function name and line number where the
error happened). This commit also changes the second parameter
(`aMessage`) to in these macros to be optional.
This commit also updates unit tests to remove the second `aMessage`
string in cases where the failure can be inferred from the condition
itself.
This commit updates the `simulation/radio.c` and removes the uses of
core internal macro `VerifyOfExit()` and replaces them with
`otEXPECT_ACTION()`. This ensures that radio platform layer does not
include the internal OT header like "common/code_utils.hpp".
This commit implements the boilerplate code for implementing the TCP
API in #6491. It creates a TCP class in src/core/net, and implements
the functions needed to transfer control there when a TCP API function
is called.
This commit updates `Srp::Server` to clear `mHasRegisteredAnyService`
when server is stopped and all the hosts and services are deleted.
This boolean flag is used to save the port number in non-volatile
settings so that we can ensure to pick a different port number the
next time the server starts.
This change addresses an issue where the port number may not be saved
and therefore not changed if the server is stopped and restarted
two times in a row.
This commit updates `test_srp_server_reboot_port` to restart the SRP
sever instead of performing a full device reset. The SRP restart will
trigger the port number change by the server which is the behavior
this test is intended to verify. This change should help address
intermittent failures on this test.
This commit splits OPENTHREAD_CONFIG_MLE_LINK_METRICS_ENABLE macro
into two subsequent ones:
- OPENTHREAD_CONFIG_MLE_LINK_METRICS_SUBJECT_ENABLE
- OPENTHREAD_CONFIG_MLE_LINK_METRICS_INITIATOR_ENABLE
This commit adds new feature in SRP client to switch server on failure
(when auto-start feature is used). When enabled, the client will try
to select the next server from entries in Thread Network Data when
the current server rejects an SRP update or there are timeouts
(no response) after multiple attempts.
This commit contains misc enhancements to OTCI:
- Allow connecting to OTBR without password
- Allow not using sudo for ot-ctl commands
- Use -- to separate OT-CLI commands.
This addresses `clang-tidy` warning for unused `using` statement. This
commit also ensures `OT_DNSSD_SERVER` is enabled in `make-pretty`
script and therefore covered by github action `build pretty`
workflow.
This commit ensures that in `Srp::Server::CommitSrpUpdate()` the
`aHost` parameter is correctly freed in case of an error and an early
jump to exit (e.g., from `SuccessOrExit(aError)` at the start of this
method). The `aHost` is now freed at the `exit` label and a boolean
`shouldFreeHost` tracks whether or not it needs to be freed. The
boolean variable is set to `false` when the ownership of `aHost` is
taken over (e.g., from the call to `AddHost(aHost)`).
This commit changes the `Srp::Server` to take ownership of resources
(e.g., heap allocated buffer for TXT data) when updating an existing
`Service` entry (instead of copying the data). With this change, the
method `Service::SetTxtData()` is no longer needed and is removed.
This commit enhances `CmdLineParser` methods that parse a hex string
adding a new version which allows a (longer) hex string to be parsed
in short segments sequentially. The unit test `test_cmd_line_parser`
is also updated to verify the behavior of the newly added method.
This commit also updates CLI `UdpExample` implementation to use the
new method for parsing message payload data from input hex string and
simplifies how `ProcessSend()` parses different arguments indicating
message payload options.
This commit adds a new flavor of function `StringFind()` which finds
the first occurrence of a given sub-string within a string. It also
adds `StringEndsWith()` function that works with a sub-string. The
unit test `test_string` is also updated to cover the new behavior of
the newly added function.
Regarding:
semiWindow = elapsed * (Get<Radio>().GetCslAccuracy() + mCslParentDrift) / 1000000;
Consider that the worst Get<Radio>().GetCslAccuracy() and
mCslParentDrift are both 255, the max of uint32 is 4294967295, so when
elapsed is about 8500000(just 8.5s elapsed since the last CSL sync),
the product of elapsed and (Get<Radio>().GetCslAccuracy() +
mCslParentDrift) will overflow.
This commit changes the type to uint64_t from uint32_t to avoid the
overflow.
This commit adds a new class `HeapString` as heap allocated string.
The buffer to store the string is allocated from heap and is manged
by the `HeapString` class itself, e.g., it may be reused and/or freed
and reallocated when the string is set. The `HeapString` destructor
will always free the allocated buffer.
This commit also adds a unit test `test_heap_string` for the new
class.
Having this value sufficiently large is important to reduce latency
when multiple simultaneous requests come in to a BR for many if not
all the nodes on the network. This could happen when a client
reconnects on Wifi and needs to query and/or update the state for many
nodes at the same time.
MLE Announce messages are sent with link security enabled. This commit
ensures that REEDs always send MLE Announce messages to the broadcast
destination address.
This commit relaxes the condition for invoking the callback from SRP
client allowing it to be invoked when client is stopped.
Note that the user can call SRP client APIs to add or remove services
while it is stopped. A remove request may be processed immediately
(if the service has not yet been registered) and then the callback is
invoked to notify the caller to reclaim the service entry.
This commit enhances THCI for 1.2 Certification:
- OpenThread.py: 1.2 non-BR
- OpenThread_BR.py: 1.2 BR and Host (otbr-agent solution)
This commit should also make THCI work for both TH1.1 and TH1.2.
If OpenThread is part of an OS with it's own IP stack filtering only
control messages is insufficient. Example could be that if application
is using OpenThread API to listen for CoAP messages received messages
are passed also to the IP callback. The message then is delivered to
the OS IP stack and generates error response: "ICMPv6 Destination
Unreachable (Port unreachable)" as the port is not open on the OS
side. OS IP stack is unaware of the OpenThread existence so it can not
be filtered on that level and the shim layer does not receive port, or
protocol information from OT so it can not filter out a frame without
parsing it first. Extended filtering also to ports originating from
OpenThread.
The assertion is verifying the (linux) host SLAAC behavior which is
not guaranteed on different platform and linux
distributions. Moreover, it is required for testing the BR behavior.
This commit updates how the arguments are passed to different CLI
command handles such that the same model is now used by all CLI
modules where all the previously parsed and consumed arguments are
removed and only the remaining un-parsed arguments are passed to the
next handler.
This commit simplifies the handling of request commands (get, post,
put, delete, and observe) in `Cli::Coap` and `Cli:CoapSecure`
classes. It also updates parsing and processing of arguments for
`CoapSecure` request command by removing the optional and actually
unused dest IPv6 address argument. Finally, it removes the use of
OT core headers/types (mainly the `ot:Coap::Message::BlockType`
enumeration) in CLI CoAP modules.
This commit implements a mechanism to let an SRP server listen to a
different UDP port on a reboot.
- When an SRP server starts, it reads the UDP port used in the last
time from Settings. Then the SRP server listens to the next port in
the reserved range.
- When SRP server successfully starts, store its UDP port in Settings.
This commit reverts the change from PR #6639 which added logging
of the CLI output. Note that the CLI output can be generated and
outputted in smaller pieces (not as a whole line) so the model
from PR #6639 would emit each piece as a different log line which
is not desirable.
This commit adds a new public API `otNetworkNameFromString()` to set
an `otNetworkName` instance from a given null terminated C string. The
new API will also validate that the given name string follows UTF-8
encoding and its length is not longer than max network name size.
This commit also simplifies the UTF-8 validation of `NetworkName` by
moving the check from `Mac::SetNetworkName()` to a newly added method
in `Mac::NetworkName` to set it from a C string.
It also defines `DomainName` as a `typedef` of `NetworkName` which
helps simplify its use and remove repeated code.
Finally, it updates the `Cli::Dataset` to use the new public API for
validating `otNetworkName`.
This commit adds a set of helper methods in `Cli` to process simple
commands where we are getting and/or setting a single integral value.
This replaces common pattern in processing of commands where if there
are no arguments, we output the value we retrieve by calling a related
getter OT API, otherwise we parse the argument (to get the proper
`int` value) and call a related setter OT API. For example, for
"channel" command, we use the `otLinkGetChannel()` as the getter and
`otLinkSetChannel()` as setter.
This commit adds a helper method `OutputTableHeader()` that can be
used to print a table header from a given array of column widths and
title strings. This is then used in CLI module for different tables
(child/neighbor/router table, active/energy scan result, etc).
This commit adds public API `otIp6SockAddrToString()` which converts
an IPv6 socket address (`otSockAddr`) to human-readable string. The
CLI modules (e.g. `ProcessNetStat()`) are then updated to use the new
API.
The current implementation will go into an infinite loop when
mEphemeralPort == Tmf::kUdpPort, since rval is never updated in the
loop. This commit fixes this issue.
This commit updates the `Settings` implementation. It adds template
versions of methods `Read<EntryType>()`, `Save<EntryType>()`, and
`Delete<EntryType>()` which make it easier for other modules to use,
while ensuing to share a common underlying implementation for all
entry types.
The settings entry types (e.g., `NetworkInfo`, `ParentInfo`, etc.) are
changed in this commit to provide a constant `kKey` specifying the
associated setting key with the entry. For simple entries, a related
class is added to define the `kKey` constant and the associated value
type (e.g., `OmrPrefix` defines `Ip6::Prefix` as its `ValueType`).
This model makes it easier to add new setting keys and entries in
future.
This commit also simplifies the logging in `Settings`. The entry types
now provide `Log()` method to log their data and a common
`Settings::Log()` method is added which handles all logging (on
success or in case of an error).
Finally, this commit moves the `SettingsDriver` definition to its own
`common/settings_driver.hpp` header file and and ensures that its
methods are defined as inline.
When using platform TCP, `Ip6::HandlePayload()` will be called with
`aIpProto = kProtoTcp` and `aMessageOwnerShip =
kTakeCustody`. `FreeMessage()` will be called with `message =
nullptr`, causing the message to leak. This commit fixes this issue.
This method clears a service from SRP client, immediately removing it
from the list. Unlike `RemoveService()` which sends an update message
to server to remove/unregister the service, this method clears the
service from client list without any interaction with server. On a
successful call to this method, the `Callback` will NOT be called and
service entry can be reclaimed and re-used by the caller immediately.
This method can be used along with a subsequent call to `AddService()`
(potentially reusing the same service entry with the same service and
instance names) to update some of the parameters in an existing
service.
This commit adds `otSrpClientClearService()` as a related public OT
API and support for this in CLI (command `service delete`). It also
adds support for the deleting service in `NcpBase` and spinel.
For multi-layer application, the radio requires from the upper layer
to provide information for security processing like Key Identifier,
in the Auxiliary Security Header according to IEEE802.15.4-2015.
This change matters for handling security processing by radio only.
This commit adds support for a new feature in SRP client which allows
it to save the selected server info (by the auto-start feature) in
non-volatile settings. On SRP client restart (e.g., due to a device
reset) the client will select the same server when searching to
discover and pick one from the Thread Network Data service entries.
Config `OPENTHREAD_CONFIG_SRP_CLIENT_SAVE_SELECTED_SERVER_ENABLE` can
be used to enable/disable this feature.
The server info is saved only after the host info is successfully
registered with the server and if it is selected by auto-start from a
network data SRP *unicast* service entry.
This commit also adds `test_srp_client_save_server_info.py` test-case
which verifies the behavior of the new feature.
We have run the static code analyser on the OpenThread code and some
issues were discovered.
This commit addresses those that were marked as High impact and were not
marked false positive after the inspection.
Signed-off-by: Marek Porwisz <marek.porwisz@nordicsemi.no>
This commit changes the `String<kSize>` class to inherit from
`StringWriter` class. It helps simplify their use allowing
`StringWriter` methods to be directly called on an `String` instance
while ensuring the implementation is still shared among all template
variants of `String<kSize>` class. This change also ensures that
`String<kSize>` is always initialized and set to an empty string from
its constructor.
This commit allows the platform implementations to access the name and
the type of the queries, thus reducing the memory overhead of extra
bookkeeping.
This commit modifies the (<=) usage in two ‘if’ conditions as these
operations as written today (with constants), are resulting in the
compile time warnings (and cmake errors) specifically when working
with proprietary radio configurations and setting Channel Min to 0.
Updated the radio header to get rid of OT_RADIO_CHANNEL_PAGE_MAX. Also
adds a compile-time error, if a user sets the proprietary channel page
to a value greater than 31, as it is currently not supported.
The SRP server tries to notify the advertising proxy when a service is
expired. The expired service is firstly removed from the service list
and later added back to the head of the service list if the service
name should be retailed. This will result in deadloop when there are
two or more services on the same host.
This commit fixes this issue by keeping the expired service in the
service list by simply mark the service deleted and pass all services
of the host to the advertising proxy. The advertising proxy will
republish those services that are not expired but this should be fine
since service expiration is not a common case.
Also update the advertising proxy test case to cover multiple
services.
This commit adds new public OpenThread APIs to convert an IPv6 address
or an IPv6 prefix to a human-readable string representation. The
implementation is shared with the `Address/Prefix::ToString()` used by
core modules (through adding a private `ToString(StringWriter &)`
method which can then be used with a `String<kSize>` or a char
buffer).
Summary of changes:
- Enable building OpenThread RCP image on the Raspberry Pi (aarch64)
directly (using Ubuntu)
- Fix problem with not having access to the /opt folder as a user
This commit enhances DUA response handling for ST_DUA_REREGISTER:
- Parent will stop registering DUA for MTD Child until the next Child
Update Request.
- MTD Child will re-register its DUA by Child Update Request or
DUA.req.
This commit contains the following changes:
- It adds `TlvIterator` to help iterate over TLVs of a given type
in a given sequence of TLVs or sub-TLVs of another TLV.
- It adds helper method `PrefixTlv::FindSubTlv<TlvType>()` to
search within the sub-TLVs for a specific one.
- It moves the `static` helper methods which find a TLV (with a
given type) to `NetworkDataTlv` (from `NetworkData`).
This commit allows launching an OpenThread daemon which was built with
backbone-router and border-routing support but disabling them at runtime
by not specifying the `-B` option.
This commit removes dummy implementation of ChildSupervisor and
SupervisionListener. And add macro to ensure that these data members
only exist in ThreadNetif when child supervisor option is enabled. In
particular, ChildSupervisor only exists when child supervisor option
is enabled and it is FTD.
This commit handles the situation when RCP(USB CDC) performs hard
reset. This commit brings an alternative to pseudo reset by handling
the connection with RCP(USB CDC ACM) by reset the socket connection
after the device is reset.
When RCP is connected by USB CDC and we reset it, the RCP device is
numerated in host operating system. So far for RCP(USB CDC) pseudo
reset has been performing meaning only specific parts of firmware were
reset thanks to results the connection hasn't been broken. For hard
resetting RCP(USB CDC) device the host needs to handle the connection
properly.
It uses udev library to check if device enumeration has ended if
libudev-dev package is present in the host system otherwise it waits
few seconds.
It works based on symlink to the RCP device created by udev in
/dev/serial/by-id/ directory.
This commit allows Reference Devices to send UDP messages to TMF port,
which was prohibited by #5911 .
Background: TestHarness sends constructed TMF messages in many TCs to
validate the behavior of nodes on receiving these TMF messages.
Fixes DUA-TC-09
This commit makes the CLI command output consistent under all cases:
- Output Error 6: Parse when the command line is too long (no output
originally).
- Output Error 7: InvalidArgs when the command line has too many
arguments. The original output is Error: too many args (max %d),
which does not strictly follow the Error <code>: <msg> pattern.
- Output Error 13: InvalidState for running non-diag command in
diagnosis mode to follow Error <code>: <msg> pattern.
This commit adds a new header file `networks_data_type.hpp` and its
related `cpp` file which now contain all the Network Data related
types and config definitions (for on-mesh prefix, external route,
service, and server entries) and their implementation (moved from
`network_data.hpp`).
It adds `IsValid()`, `ConvertToTlvFlags()`, and `SetFromTlvFlags()` in
`OnMeshPrefixConfig` and `ExternalRouteConfig` to validate the config
and convert it to/from the corresponding TLV bitmask flags. These
changes help simplify the use of the configs by other classes.
This commit updates `UpdateSnoopedCacheEntry()` to perform the
common checks before adding a snooped entry (e.g., ensuring the
snooped entry source is not an MTD child of the device).
If a device is a REED and waiting the random delay to upgrade to a
router, the device will wait to register its network data, since it
will have to register again after upgrading to a router. However, the
maximum delay for becoming a router is up to 2 minutes, which is a
long time to wait.
This commit limits the delay that a device will wait to register its
network data.
This commit adds new network data service entry definitions to
indicate presence of DNS/SRP servers within the Thread mesh and
provide info about them. Two service TLV formats are added:
`NetworkData::Service::DnsSrpAnycast` indicates that DNS/SRP client on
a device can use the associated anycast address with this service TLV
to reach the DNS/SRP server. The use of anycast address ensures that
the messages are routed to the nearest node which has added such a
service entry in the network data. The service TLV data in this model
contains a one byte sequence number which is used to notify the SRP
clients if they need to re-register with the server(s) (e.g., due
server reset/reboot and/or loss of previous registrations).
`NetworkData::Service::DnsSrpUnicast` directly provides the IPv6
address and port info for a DNS/SRP server which can be included as
part of the service TLV data and/or the server TLV data. Using service
TLV data allows the info about a common infrastructure SRP/DNS server
to be added by multiple BRs. In the case of server TLV, the IPv6
address info can be optionally omitted (i.e. just a port number is
provided) which then causes the associated RLOC/ALOC address of the
node who added the service entry to be used as the server's IPv6
address.
This commit updates the `Srp::Client` to use the new service entries
to discover/select the SRP sever when auto-start mode is enabled. The
client prefers and uses a `DnsSrpAnycast` over `DnsSrpUnicast`
entries. The `Srp::Server` is also updated to publish its info as
`DnsSrpAnycast` entry (using mesh-local address).
This commit also updates the `test_network_data` unit test to cover
the behavior of newly methods which iterate and parse different
service entry formats.
The test case failed because pktverify failed to find an ACK packet
sent to TD. However, TD_RLOC has changed during the test while we were
using the latter RLOC to verify the packet. Therefore it wasn't able
to find the packet.
For this test case, we can verify the existence of that ACK packet
using the source address of its according CON packet.
The exit command should only exit ot-ctl itself in daemon mode. This
commit adds processing exit command in the ot-ctl.
This commit also moves the exit command implementation out from core
as a user command on simulation and posix cli mode.
This commit updates `Srp::Client::AddService()` to reject and return
`kErrorAlready` if the caller tries to add duplicate service entries
(services with matching service and instance names).
This commit updates `MleRouter::HandleChildUpdateRequest()` related to
how a "Child Update Request" message from a child is processed on a
parent. If the child is present in the parent's child table but it is
not yet in valid state, the parent ignores the received "Child Update
Request". This applies to a child being restored due to parent's reset
(child is in `kStateRestored`) or a child which is in the middle of
attach process (e.g., child is in `kStateParentRequest`). If a
matching child entry cannot be found in the parent's child table, the
behavior remains as before (i.e., parent sends a response with an
error Status TLV to notify the child to re-attach).
This change ensures that after a parent reset to restore a child, the
parent node is the one initiating and sending a "Child Update Request"
to the child and then receives a "Child Update Response" from it. Such
an exchange between the parent and the child will then include a
random challenge and response (authenticating the child and providing
replay protection). Also in this exchange the "Child Update Response"
from the child will include the the child's current MAC and MLE frame
counters, therefore ensuring that the parent correctly learns and
tracks the frame counters being used by the child.
List of changes:
- modified Autotools, CMake and Android build systems
- increased heap size as new version requires additional 64B
- replaced deprecated API (mbedtls_ecdsa_sign_det)
- removed workaround with defining mbedtls_ecp_restart_ctx
This commit adds single-band proprietary radio support for
OpenThread. This feature will enable users to configure OpenThread
stack with proprietary radio parameters and use a PHY as defined by
the Platform.
More specifically:
1. Introduced the following platform configuration options:
- OPENTHREAD_CONFIG_PLATFORM_RADIO_PROPRIETARY_SUPPORT
- OPENTHREAD_CONFIG_PLATFORM_RADIO_PROPRIETARY_CHANNEL_MIN
- OPENTHREAD_CONFIG_PLATFORM_RADIO_PROPRIETARY_CHANNEL_MAX
- OPENTHREAD_CONFIG_PLATFORM_RADIO_PROPRIETARY_CHANNEL_MASK
- OPENTHREAD_CONFIG_PLATFORM_RADIO_PROPRIETARY_CHANNEL_PAGE
2. Updated the radio and meshcop tlv implementation to incorporate the
proprietary radio configurations
3. Updated the network diagnostics code to support channel page mask
value up to 32.
This commit fixes an issue with some of the log related methods where
`String` object may be used without being initialized (this was added
from commit b39f5b6dd and PR #6564).
This commit ensures that `String` variable definitions are always
immediately followed by a `StringWriter()` definition which then
initializes the string buffer (sets it as empty).
This commit also updates `test_string` unit test.
The second to the last packet verification statement expects a ping
request sent by Router_1 after BR_2 becomes the PBBR. However, this
statement wrongly matches a ping request sent by Router_1 before BR_2
becomes the PBBR. Added a restriction of the echo identifier to make
sure the packet verification statement doesn't match the previous ping
request.
This commit moves methods of String out of the header file to save code
size.
Since most use cases of String writers ignores errors, this commit
changes the return of writers to the Writer object itself for chained
writes.
This commit adds native commissioner support with the following changes:
* Accept unsecure traffic when Thread is not enabled.
* Accept traffic to border agent service when native commissioner is
allowed.
This commit changes the `MleRouter::HandleChildUpdateRequest()` to
clear the "last rx fragment tag" only if the "Child Update Request" is
from a detached child trying to restore its link with its parent. This
is indicated by the presence of Challenge TLV in the received message.
The "last rx fragment tag" is used for duplicate frame detection when
`MULTI_RADIO` is enabled.
This commit adds a new `Arg` class in `parse_cmdline` which represents
a single argument (wrapper over a C string). The `Arg` class is then
used in CLI modules. This helps simplify the CLI code mainly using
simpler syntax, e.g., using an overload of `==` operator to compare an
argument with a C string, or calling `ParseAs{Type}()` methods
directly on an `Arg` instance.
The commit enhances the Routing Manager to learn RA header and
parameters from RA messages initiated from infra interface. This
addresses the issue that the BR may be using different RA header
against another RA daemon which is working on the same infra interface
(Have BR and another RA daemon working on the same interface is common
for Wi-Fi + Thread routers).
We also changed to accept RS messages initiated from the infra
interface: this is for case that multiple Border Routers run on the
same host (as we are trying to support multiple ot-daemons on the same
host).
This commit updates `toranj/build.sh` script for posix based builds to
generate CLI executable. It also updates the posix platform to provide
log functionality when `LOG_OUTPUT` is set to `LOG_OUTPUT_APP`.
This commit also adds CI build checks for multi-radio and TREL build
configurations under posix platform.
This commit updates `Coap::Message` to check and remove the payload
marker byte which is added at the end of header options in the case
that the message contains no payload. This check is performed in
`Finish()` method which finalizes the message for transmission. Note
that the presence of a marker followed by a zero-length payload is
processed as a message format error by receivers.
This change helps simplify the preparation of CoAP message by other
modules (i.e., they no longer need to check for empty payload to
remove the marker themselves and can rely on common code in
`Coap::Message`).
This commit updates and enhances the `AnnounceSender` feature. When
this feature is enabled, routers and REEDs periodically send MLE
Announcements (on all channels from the channel mask in the current
Active Operational Dataset). This commit updates the implementation to
use `TrickleTimer` such that a device monitors the number of received
Announce messages within a cycle and if the number is above a
redundancy threshold, the device skips sending Announcement in that
cycle itself. This helps limit the number of Announcement tx in cycle
in a dense network. The same mechanism is used by both routers and
REEDs.
This commit includes several small changes:
- Add logs for Border Agent Start and Stop events to help analysis
commissioning issues such as openthread/ot-commissioner#193
(comment).
- Start Border Agent when the native commissioner is stopped.
- Add CLI command ba state to get current Border Agent state.
This commit changes `DuaManager::HandleDuaResponse()` to use a pointer
to `aMessage` and `aMessageInfo` (instead of reference) Note that in
case of a failure, the `Coap` module may invoke the response handler
with `nullptr` for these parameters.
This commit adds APIs to get Link/Realm Local All Thread Nodes
multicast addresses. This commit also adds cli command to get
meshlocal prefix alone for writing tests.
This commit uses the receive timing capability from the radio to
schedule CSL receive operations with a higher precision, allowing for
shorter receive windows.
This commit adds a new flag in `NetworkData::HasRouteEntry` to
indicate that an off-mesh route prefix in the Network Data is also a
NAT64 prefix. It updates the public `otExternalRouteConfig` structure
to include `mNat64` bit flag and adds support for it in the core
modules.
It also updates `test_network_data` unit test to cover the new flag
and also adds some smaller style changes in this test.
This commit updates the CLI modules to add support for the new
flag. It also adds smaller enhancements in CLI related to network
data, adding methods `NetworkData::OutputPreference()` and
`OutputIp6Prefix()` to output common info (shared between on-mesh
prefixes and off-mesh routes), also simplifying how the flags are
mapped to char array string (avoiding extra space char in the output
string).
This commit also updates spinel and NCP code to add support for the
new NAT64 flag.
Since OT_TREL is going to be set to ON in OTBR, this commit makes sure
we test OTBR with TREL off.
Also removed -DOTBR_DNSSD_DISCOVERY_PROXY=ON since it's now ON by
default.
This commit changes border agent service to use ephemeral port by
default. This change makes it easier to support multiple Thread
interfaces on a single host.
This commit removes the need of getting LLA of infra interface but
adds a new platform API otPlatInfraIfHasAddress which matches the
infra interface and a given address.
Background:
The infra interface LLA is used in the Routing Manager for only
testing if RA/RS message is initiated from the infra interface.
This commit adds a new method in `NetworkData` class to find and
iterate over all Service TLVs that start with a given Service Data.
Unlike the existing `FindService()` method which searches for a
Service TLV with an exact match with the given Service Data, this
method performs a relaxed check allowing a matching Service TLV to
contain additional bytes after given data bytes to search for.
This commit also updates `test_network_data` unit test to add new
test to cover the behavior of newly added method.
This commit updates `NetworkData::Iterate()` to check that an entire
TLV (or sub-TLV) is contained within the Network Data (up to its
length) and skips over TLVs that are incomplete. It also updates
`FindTlv()` methods to directly use the stricter check in the
`for()` loop used to iterate over all TLVs.
Currently, if using FindNeighbor(const Ip6::Address &aIp6Address,
Neighbor::StateFilter aFilter) when the aIp6Address is the device's
parent's link local address, it cannot be found. This commit fixes
this issue.
The POSIX NCP app(ot-ncp) is simulating of NCP with an RCP. With the
latest otbr-agent, this is not needed any more. It is only used in CI
tests. This commit removes the app to save maintenance efforts.
Sometimes CSL cannot be sent out at the sample windows following the
ping command and may need to wait for one or more CSL periods. Use the
default ping timeout which covers several CSL periods.
This change tackles both problems resolved and introduced by #6427.
For direct transmissions, if the first frame transmission fails,
e.g. due to a CCA failure then retransmissions will contain an invalid
frame counter. It causes problems especially for long IP packets - the
receiver drops a fragment but the transmitter will flood it with the
next fragments since it is not aware that the other party dropped a
fragment. We have identified that it's a root cause of the problem
reported in #6337.
Previous solution (remove the check if a frame is retransmitted) may
cause problems with indirect transmissions where radio frames are
created from scratch and then their frame counter would be
overridden. That is why the best place for setting frame counter and
key index in otPlatRadioTransmit().
This commit updates documentations in `radio.h` and adds more detail
on expected behavior on assigning of the frame counter (on retx or
first attempt frame) when radio provides `OT_RADIO_CAPS_TRANSMIT_SEC`
capability (i.e., radio platform layer handles the tx security and
frame counter management).
For nRF52 platforms in order to achieve the best CSL accuracy frame
security processing was moved to the nrf_802154_tx_started() radio
driver callback which is called from the interrupt context when frame
transmission is started by the hardware peripheral.
There is a possibility that a requested transmission will be aborted
before nrf_802154_tx_started() is called. The frame can be then
retransmitted and if nrf_802154_tx_started() is called it will skip
setting key index and frame counter (so they will remain unchanged
with a value equal to whatever is present in RAM).
It seems that we should always set these fields. Moreover, security is
processed only once which is controlled by
mTxInfo.mIsSecurityProcessed member so checking for retransmission is
redundant.
This commit adds support for NAT64 address translation (from IPv4 to
IPv6) during address resolution in `Dns::Client`. This feature is
enabled using `OPENTHREAD_CONFIG_DNS_CLIENT_NAT64_ENABLE` config
option. When enabled, the caller can specify in the address query
configuration whether to allow or disallow NAT64 address translation
for a specific query. The default behavior can also be set using the
default DNS client config.
When the NAT64 is allowed, if the response from server does not
provide an IPv6 address for the host name, we first check if the
server has provided IPv4 address information in the response, and if
not, start a new query for the IPv4 address. Once the IPv4 address(es)
of the host name are resolved, they are translated to IPv6 address(es)
and reported to the user in the query callback function.
Per 15.4 spec, transmitter cannot modify frame content in
retransmission which will leads to out-of-date CSL IE being sent to
CSL transmitter. This commit fixes this issue by,
1. Send a follow up data poll with CSL IE to resync the CSL
transmitter.
2. Send periodic data poll with CSL IE to keep SSED's parent in sync.
3. Move PrepareDataRequest to data_poll_sender.
4. Add test cases to cover.
* [nrf528xx] ensure HWFC is triggered when SW buffer is full
* [nrf528xx] use UARTE peripheral for TX path
Co-authored-by: Łukasz Duda <lukasz.duda@nordicsemi.no>
This commit adds a helper method `Cli::ParseEnableOrDisable()` which
checks a given string against two common commands "enable" or
"disable". This method is then used in CLI modules.
We are using the SRP Host pointer for indexing an outstanding SRP
update when the Advertising Proxy result is passed back with
otSrpServerHandleServiceUpdateResult. There are chances that an old,
freed Host object may be matched again with a newly allocated Host
object which coincidentally has the same address with the old Host
object.
This commit solves this issue by using a random generated uint32_t SRP
service update ID for indexing outstanding updates.
This commit updates `toranj/build.sh` script to skip over empty ""
arguments at the start. This addresses an issue introduced in commit
531cb3484 (PR #6421) where the `start.sh` adds an empty arg when
invoking `build.sh` when coverage is not enabled.
This commit adds validation of the on mesh prefixes.
With this change, the domain on mesh prefix can be directly configured
after successful verification.
This commit implements DNS-SD Discovery Proxy.
- Implemented DNS-SD Discovery Proxy functionalities - OT part
- Fixed an memory issue of NameCompressInfo (introduced in #6155 , but
somehow revealed by this commit)
Some implementation details:
- Discovery Proxy subscribes to services/service instances/hosts
through callbacks set by a public OT API. It is up to the platform
mDNS implementation to collect service instance/host information and
notify OT via a public OT API.
- Discovery Proxy can handle DNS browsing of one service or DNS
resolving of one service instance/host. We leave browsing multiple
services or resolving multiple service instances/hosts for future
enhancements if necessary.
I have found that the default channel manager CCA failure rate
threshold is not necessarily ideal, and some experimentation is
required to determine a good threshold depending on network
characteristics and packet size/periodicity.
For example, I have a network that experiences ~40% packet loss, yet
only ever reports a maximum 4% CCA failure rate, well below the
default of 10%.
This commit adds functions to get/set the threshold, the API layer,
CLI hooks, and CLI documentation.
Accept RA initiated from the infra interface so that we can detect the
existence of another RA daemon which is working on the same infra
interface.
Also enhance the test_single_border_router.py test script to make it
more readable.
- Ping command in CLI will print Done in the end, after printing
replies and statistics. The old behavior is, ping command prints
Done before any replies.
- In OTCI, let ping function return statistics.
- Support timeout parameter in ping command.
- Fix a bug that the arguments are not properly passed to ping in
node.py.
- Adjust timeouts in tests.
This commit allows the spinel interface to deal with link metrics.
There are 7 new properties introduced:
- THREAD_LINK_METRICS_QUERY
- THREAD_LINK_METRICS_QUERY_RESULT
- THREAD_LINK_METRICS_PROBE
- THREAD_LINK_METRICS_MGMT_ENH_ACK
- THREAD_LINK_METRICS_MGMT_ENH_ACK_IE
- THREAD_LINK_METRICS_MGMT_FORWARD
- THREAD_LINK_METRICS_MGMT_RESPONSE
This commit harmonizes how the feature config checks are done within
OT core modules. In header `.hpp` files, any related `#if` config
check is done immediately after the `"openthread-core-config.h"` is
included. This way the rest of definitions are skipped over if the
feature is not being used. In `cpp` source files the `#if` check is
done immediately after including the related header file.
This commit adds support for "DNS name compression" mode. By default
the DNS name compression is enabled. When disabled, DNS names are
appended as full and never compressed. This is applicable to
OpenThread's DNS and SRP client/server modules. This is intended for
testing only and available when config option
`OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE` is enabled.
This commit also add a CLI command for this feature as `dns
compression [enable|disable]` and updates the CLI's `README.md`.
In BMLR test, the commissioner may fail to start because the /c/ps
COAP message failed to reach Leader due to unstable links. This
commit makes sure the links are established before starting the
commissioner.
This commit replaces some enum definition with constexpr since these
enum are used for comparing. The compiler would always give warnings
when comparing enum with other non-enum values. With this change, we
can directly compare the consts with other values. And this commit
replaces UpdateIfLarger with OT_MIN.
This commit changes the string lookup tables used in `spinel.c` to
convert the property/command definitions to string to use the full
enum names in the table.
This makes the names "search/grep"-able which is helpful during
renaming/refactoring or when adding a new property (by searching and
copying code for an existing one).
This commit adds support for "service key record inclusion" mode in
SRP client. When enabled, SRP client will include KEY record in
Service Description Instructions in the SRP update messages that it
sends. KEY record is optional in Service Description Instruction (it
is required and always included in the Host Description Instruction).
The default behavior of SRP client is to not include it. This feature
is intended to override the default behavior for testing only and is
is available under the reference device configuration build (i.e.,
when `OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE` is enabled).
This commit also add a CLI command for this feature as `srp client
service key [enable/disable]` and updates the `README_SRP_CLIENT.md`.
Finally, this commit adds new spinel property for SRP client "service
key record inclusion" mode along with its get/set handlers in NCP
build.
In tests/scripts/thread-cert/node.py, the timeout parameter of ping()
function is in seconds. However, in some test cases they called ping()
with a timeout in milliseconds.
I used the following command to list ping() usages with a specified
timeout: grep -rn "ping.*timeout=" tests/scripts/thread-cert/*
This commit contains a small fix in `Mac::ChannelMask::ToString()`
string output (e.g, return `{ 11-26 }` instead of `{ 11-26}`). This
commit also updates the unit test to follow naming style and verify
the `ToString()` behavior.
This commit adds `AppendTo()` method in `Dns::Name` class. This method
allows appending an already encoded name from one message to another.
This is performed by directly copying labels one by one between the
messages and does not require an intermediate buffer to read and store
the labels or the full name. This commit also updates `test_dns` unit
test to cover the behavior of the newly added method.
Make CSL receive window dependent on the accuracy of the crystals
used for scheduling and on the elapsed time since last synchronization.
CSL Receive window scheduling
=============================
a b c d e f g
| | | | | | |
-------------------------------------------------------------------->
a-b: kCslReceiveTimeAhead
b-c: -mCslParentUncert
c-d: -(mCslParentDrift + otPlatRadioGetCslAccuracy)
d: mCslSampleTime
d-e: kMinCslWindow
e-f: +(mCslParentDrift + otPlatRadioGetCslAccuracy)
f-g: +mCslParentUncert
This commit adds `Message::AppendBytesFromMessage()` which appends
bytes to a message read from another or potentially the same message
at a given offset. The bytes are read and copied directly (chunk by
chunk) without requiring an intermediate buffer. This commit also
updates `test_message` unit test to cover the behavior of the newly
added method (for both cases where the source and the destination
messages are the same or different).
This commit adds a new module `Utils::SrpClientBuffers` which provides
string/data buffers and a pool of service entries for use for SRP
client. OpenThread SRP client implementation requires that the
service, string/data buffers passed as parameters to its API to
persist. This allows flexibility in how the SRP client can be used
(users of API can decide on how to manage the memory). The new module
provides an option to OT API user to use the buffer and service pool
to allocate/free items (e.g., service entries). The new module is
enabled by `OPENTHREAD_CONFIG_SRP_CLIENT_BUFFERS_ENABLE`. A set of new
configs specifies the number of service entries in the pool, number of
host address entries, and the size of different string buffers (e.g,
size of service instance string, etc).
This commit also updates CLI and NCP implementations to use the new
common service pool for SRP client commands.
This commit adds `Ip6::Address::SetFromTranslatedIp4Address()` method
performing NAT64 address translation from an IPv4 address and a NAT64
prefix to construct a corresponding IPv6 address as specified in RFC
6052. This commit also updates the unit test `test_ip6_address.cpp` to
cover the behavior of the newly added method.
This commit updates the implementation `Ip6::Address::FromString()`
simplifying it and handling more special cases where address starts
or ends with `::`. The unit test `test_ip6_address` is also updated
to cover some new test cases.
This commit contains two small changes in `Dns::Client`: simplifying
the `SendQuery()` call and adding a comment about reason for parsing
the response in a separate method.
This commit adds IPv4 address definitions in OpenThread:
- Adds `Ip4::Address` class.
- Adds methods to convert IPv4 address to/from string.
- Updates the `Ip6::Address::FromString()` to use the IPv4
`FromString()` for the case where the IPv6 address contains
an embedded IPv4 address.
- Renames unit test to `test_ip_address` and updates it to
cover the behavior of newly added IPv4 definitions in addition
to IPv6 related tests.
This commit addresses the header file include loop between
the `link_metrics.hpp` and `topology.hpp` by forward declaring
`Neighbor` in `link_metrics` header. It also removes some of the
unnecessary header includes and contains smaller style fixes.
Calling write multiple times may casing different arguments of a
command line reach to the daemon at different times. This commit
composes arguments into a full command line and sends it at once.
This commit adds `Unequatable<Type>` class which adds an overload of
operator `!=` using an existing `==` overload provided by the `Type`
class. The `Unequatable` should follow CRTP-style inheritance, i.e.,
the `Type` class should publicly inherit from `Unequatable<Type>`.
This provides a solution to avoid repeating the simple implementation
of `operator!=()` overload in different classes.
- OPENTHREAD_CONFIG_NCP_UART_ENABLE is now OPENTHREAD_CONFIG_NCP_HDLC_ENABLE
- Pull in cli_uart.cpp UART API interface for sleepy-demo apps.
- Fix some erroneous ifdefs that affect 1.2 SoC builds and 1.1 builds.
- Add OT_RADIO_CAPS_SLEEP_TO_TX to radio capabilities (fixes#5819).
NAME_WLE was added in CMake 3.14 and isn't available in 3.10, which is
the default requirement for openthread.
This switches imported_libs.cmake to NAME_WL, which is in 3.10.
This commit simplifies and enhances the `TrickleTimer` class. It adds
support for suppression behavior and removes unused `Mode` and unused
end of interval callback. It changes the `Handler` function pointer
to be similar to `Timer` callback.
This commit adds CMake support for the efr32 platforms and Silicon
Labs gecko_sdk_suite. It also adds the option to build the efr32
sleepy-demo apps.
Other changes:
- jlinkrtt: remove NordicSemi specific options/definitions/includes
from default build
- Remove old include dirs that don't exist anymore from efr32 automake
files
This commit removes application library CLI/NCP dependency on platform
layer UART APIs. Instead, application layer provides callbacks sending
CLI/NCP data.
With this change, platforms with native support for formatted output
can simply implement the CLI output callback with something like
`vprintf()`.
In Thread v1.2, we enable
OPENTHREAD_CONFIG_MAC_SOFTWARE_TX_SECURITY_ENABLE on the RCP, since we
have to modify the MAC-layer packet for outgoing transmissions in some
cases (adding IEs for enhanced ACKs, including CSL sync info etc).
For this purpose, we define otPlatRadioSetMacKey and
otPlatRadioSetMacFrameCounter to store the latest security material
for AES-CCM encryption.
However, the bug was that this info was not being inserted and
transmit security not processed on the outgoing packet, since the
mac_fr expects calls to otMacFrameSetKeyId, otMacFrameSetFrameCounter,
and otMacFrameProcessTransmitAesCcm from the user. Included this
piece of code to fix the Thread v1.2 RCP bug.
Other changes:
1. Moved a few pieces of helper code to better organize various 1.2
sections in radio.c, and fix some compilation errors.
2. Added some more clarifying comments in some places.
3. Re-enabled some CSL code which was commented out by accident.
This commit adds an overload of operator `<` in `Ip6::Prefix` class. A
prefix with shorter length is considered smaller than the one with
longer length. If the prefix lengths are equal, then the prefix bytes
are compared directly to determine the smaller prefix. This commit
then changes `RoutingManager` to use the newly added operator `<`
overload.
Unit test `test_ip6_address.cpp` is updated to cover the behavior of
the new operator.
This commit updates `IndirectSender` to check exit quickly from the
`HandleSentFrameToChild()` callback if the sent frame is an empty
frame. `PrepareFrameForChild()` prepares an empty frame when there is
no indirect message in the send queue for the child. This can happen
in the (not common) situation where the radio platform does not
support the "source address match" feature and always include "frame
pending" flag in acks to data poll frames. The change in this commit
address a potential issue in this situation and ensures that the "send
done" is not incorrectly processed for any newly added indirect
message after preparing the empty frame (which would cause the message
to be assumed sent and removed without actual tx).
For the case when otInstanceReset returns during pseudo reset action
setting here SPINEL_STATUS_RESET_SOFTWARE is useless as line below
the current sNcpInstance is cleared. The new status never gets
a chance to be transmitted to the host.
This commit changes the `RestoreDatasetFromNcp()` to be performed on
single OT instance config and to be skipped when multiple OT instance
config is enabled. This change ensures that the `RadioSpinel` module
can be compiled with `MULTIPLE_INSTANCE_ENABLE` config. Note that the
"restore data set from NCP" mechanism is performed during platform
initialization from `RadioSpinel::Init()` which happens before
any OT instance is allocated or initialized (all platform layer
components/drivers should be initialized before OT instance). So the
"restore dataset from NCP" feature only makes sense under since OT
instance case.
This commit adds a new core header files `common/error.hpp` which
defines `ot::Error` (mirroring `otError`) and `kError{Name}` constants
(mirroring the public `OT_ERROR_{NAME}` definitions). The new (C++
style) definitions are used by core modules. This commit also moves
`otThreadErrorToString()` (from `logging.hpp` to `error.hpp`) and
renames it to `ErrorToString()` which is used as the internal (to
core) function to covert an `Error` to a string.
There is an issue that the SRP host or service are not deregistered by
the Advertising Proxy when the host or service is expired. This is
because we didn't notifies the Advertising Proxy of the host/service
expiration. This commit fixes this issue and adds tests for it.
When using newer versions of mbed TLS, two issues appear when using
`OPENTHREAD_ECDSA`:
- An empty list of configuration hashes is treated as a configuration
error: DTLS fails.
- Identifiers with double underscore are not used anymore: signature
hashes configuration is not included.
This commit addresses both issues.
This commit adds spinel properties for Backbone Router:
- SPINEL_PROP_THREAD_BACKBONE_ROUTER_PRIMARY
- SPINEL_PROP_THREAD_BACKBONE_ROUTER_LOCAL_STATE
- SPINEL_PROP_THREAD_BACKBONE_ROUTER_LOCAL_CONFIG
- SPINEL_PROP_THREAD_BACKBONE_ROUTER_LOCAL_REGISTER
- SPINEL_PROP_THREAD_BACKBONE_ROUTER_LOCAL_REGISTRATION_JITTER
Property numbers have been adjusted to match the ones from #6228 and
#6231.
This commit adds `OT_TREL` as a CMake option and 'TREL' as an autoconf
switch option to enable support for TREL radio link for Thread over
Infrastructure feature.
This commit changes the dataset updater implementation to leverage
MeshCoP::DatasetManager, which already provides a mechanism to
communicate Pending Dataset updates with the Leader. The
DatasetManager implementation ensures that only one CoAP transaction
is outstanding at a time.
This commit also ensures that any unspecified values are copied from
the Active Dataset.
On systems where OpenThread share mbedtls configuration with HTTPS and
other TLS based protocols. The TLS max content length can be way larger
than OpenThread requires. Add an OpenThread config macro to reduce stack
consumption under such circumstance.
This commit tests if a host is still reachable after leaving and
rejoining the infrastructure network. This makes sure that the routing
manager handles router solicitations.
This commit defines `otMessage` to be an opaque public `struct`. This
change ensures users of OpenThread APIs can only get `otMessage`
instances through OpenThread public APIs and callbacks. It also hides
the `mNext` field which is not intended for use/access by OT API users
(OT users may assume `mNext` is pointing to the next message when the
message is placed in an `otMessageQueue` which is not correct since
`mNext` is used to chain the fixed-size `Buffer` instances of the same
`Message` instance).
This commit adds `otMessageBuffer` in `platform/messagepool.h` which
is then used when the platform is configured to manage the buffer pool.
The `otMessageBuffer` struct defines `mNext` to ensure the returned
`otMessageBuffer` instances from platform layer are aligned correctly
in memory (i.e., they can be safely cast to `ot::Buffer`).
This commit adds the checking of the OT config options directly in the
header files of the related module, e.g., the check for DUA feature
being used along with Thread 1.2 is now done in `dua_manager.hpp`. The
`openthread-core-config-check.h` is now used to track the list of
removed, renamed, or replaced configs. This change makes it easier to
find and maintain the dependency/relationship between OT configs
(easier to find them in the related header file than within the list
in `openthread-core-config-check.h`).
This commit adds `update-makefiles.py` script which helps update
different make/build files supported by OpenThread project including
`CMakeList.txt`, `BUILD.gn`, `Android.mk`, `Andriod.bp`, and
`Makefile.am` based on the source (`cpp`, `hpp`, and `h`) files in
`./src/core` and `./include/openthread` folders. This script is
intended to make it easier for developer when adding/removing/renaming
source files within OT core to help update all the make/build files.
This commit also updates `Makefile.am` ensuring the list are sorted
alphabetically (this is generated by running the script).
This commit renames *Advertising* to *ServiceUpdate* to keep
consistent with public APIs. For example, change
HandleAdvertisingResult to HandleServiceUpdateResult.
This commit adds a helper method `RemoveMessageIfNoPendingTx()` in
`MeshForwarder` which removes (dequeues from `mSendQueue` and frees
it) if there is no pending direct or indirect transmission.
This commit also changes `UpdateSendMessage()` to exit early when
there are remaining fragments of the message to be sent.
This commit fixes an issue with removal of supervision message
for child when another message is queued for the same child.
This fixes an issue added by PR#5638 (which itself addresses
an issue that if the supervision message was removed while MAC
was busy sending the message, the MAC layer would not be
notified of the removal).
In #6154, the radio.c changes included the removal of a lot of code
wrapped in #if RADIO_CONFIG_915MHZ_OQPSK_SUPPORT macros. The problem
is there was still one section of code which was not removed.
This caused the 2.4GHz sBandConfig to be overwritten with sub-GHz
config, ultimately causing the efr32mg12 BRD4170A to assert somewhere
in radio initialization.
This commit reverts the removal of support for multiple
efr32BandConfigs.
This commit changes `ToString()` methods in MLE module which convert
from a given `enum` value to a string to use string array tables. It
also adds `statci_assert` checks to verify the values of `enum`
maps correctly to the array indexes.
The ECDSA signing of the SRP client requires additional internal heap.
This commit enlarges the internal heap size to 4000 bytes. The last value
I tried but failed is 3800.
This commit includes below changes:
- handles dynamic infrastructure interface status changes. The Routing
Manager will be started if the infra interface status turns to be
RUNNING and a valid link-local address is present. Otherwise, the
Routing Manager will be stopped.
- changes the default status of the Routing Manager from enabled to
disabled and it is initially enabled for the posix platform.
- the posix implementation now doesn't require the presence of the
link-local address at initialization stage. In this case, the
Routing Manager will not be started before a link-local address is
added to the infra interface.
- add CI tests for the new behavior.
This commit adds a new behavior related to MLE attach backoff feature.
It adds a configurable delay wait interval before resetting the attach
backoff interval to its minimum value upon a successful attach.
`OPENTHREAD_CONFIG_MLE_ATTACH_BACKOFF_DELAY_TO_RESET_BACKOFF_INTERVAL`
specifies the delay interval.
If it is set to zero then the device resets its backoff attach
interval immediately after a successful attach. With a non-zero value,
if after a successful attach, the device happens to detach within the
delay interval, the reattach process resumes with the previous backoff
interval (as if the attach did not happen).
This behavior is helpful in the situation where a battery-powered
device has poor link quality to its parent and therefore attaches and
detaches frequently from its parent. Using a non-zero wait interval
ensures that the attach backoff does not reset on each attach and that
the device does not drain its battery quickly trying to re-attach too
frequently.
This commit refactors the code to set frame version, IE present field
in frame control field and to append Header IE.
- Split UpdateFrameControlField into two methods: CalcIePresent and
CalcFrameVersion. Currently UpdateFrameControlField` is not
easy-to-read and hard to extend the method to handle more cases.
- Move this code from Mac to MeshForwarder. I think it should be
MeshForwarder's responsibility (PrepareDataFrame) to prepare the
frame (though Mac sometimes prepare data frames itself). Since when
preparing the frame, most information comes from the Message which
is only in MeshForwarder, we can put this code for preparing frame
in MeshForwarder.
- Enhance the way to append Header IEs to the frame. Currently in
Mac::AppendHeaderIe, it generates a list of HeaderIe first and then
call Frame::AppendHeaderIe. There are two problems here: 1. it uses
another copy (copy HeaderIe to the frame's buffer). 2. it has to
initialize Vendor IE (e.g. TimeSync IE) after Vendor IE header has
been copied to the buffer. Currently it directly finds the first
Vendor IE in the buffer and initialize it as TimeSync IE, which is
not extensible. This commit shifts the responsibility of 'how to
append the IE' to Frame, by providing AppendHeaderIeAt method. And
MeshForwarder can decide which IEs to append and directly call the
method to append IEs to the frame.
spinel.c provides functions to convert spinel values to printable
strings. These functions are written using huge switch case statements.
This patch replaces these statements with simple loops over arrays
containing the strings.
Thus, the new code takes 3 time less code than the previous. In add, the
value and the string are no more repeated so the new is less error
prone.
Note: I have used the following commands for the conversion:
sed -nre 's/case SPINEL_CMD_(.*):/SPINEL_COMMAND_CSTR(\1),/p' spinel.c
sed -nre 's/case SPINEL_PROP_(.*):/SPINEL_PROP_CSTR(\1),/p' spinel.c
...
This commit sets the DIAG_GET response callback every time the
otThreadSendDiagnosticGet is called. This is because the callback may
be changed to other modules (e,g. OTBR_REST, OTBR_UBUS).
The otPlatSettings api isn't necessarily supported on every platform.
Replace with ot::SettingsDriver which supports both the settings and the
flash platform api.
This commit fixes and simplifies the `OptRecord` implementation. The
OPT RR re-purposes the existing TTL field (which is a `uint32_t`) and
uses it for Extended Response Code (`uint8_t`), Version (`uint8_t`),
and flags. The new implementation treats the `mTtl` as a byte array
and directly reads/writes bytes at different indexes corresponding to
different re-purposed data fields. This ensures that the fields are
encoded correctly independent of the endianness of the platform.
UDP buffer size was increased to 10M so as to avoid potential UDP
packet loss. However the buffer size is too large to run thread-cert
tests on macOS.
This commit reduces the UDP buffer size to 2M.
This commit adds a new public `ot` API for parsing an encoded DNS TXT
record data into `TxtEntry` key/value pairs. It also updates the TXT
data iterator model used for going through all TXT entries. The new
iterator definition provides a small buffer to store the key string.
This helps simplify the definition of `otDnsTxtEntry` to use
null-terminated C string for the key. The new parsing APIs are used in
CLI module.
This commit also fixes an issue with `TxtEntry::AppendEntries()` using
incorrect value for the key length.
Finally, this commit adds a test covering the behavior of all
`TxtEntry` related methods (encoding and parsing TXT data) in the unit
test `test_dns`.
This commit adds a new structure `otDnsQueryConfig` which represents a
DNS query configuration defining a set of parameters:
- The DNS server socket address (IPv6 address and port number).
- Response timeout interval (in msec).
- Maximum number of transmit attempts before reporting failure.
- "Recursion desired" flag (if server can resolve recursively).
There is a default query config used by DNS client. When OpenThread
stack starts, the default DNS query config is determined from a set of
OpenThread config options defined in `config/dns_clinet.h` such as
`OPENTHREAD_CONFIG_DNS_CLIENT_DEFAULT_SERVER_IP6_ADDRESS`, etc. New
APIs `otDnsClient{Get}/{Set}DefaultConfig()` are added to allow user
to get/set the current default config during operation.
When issuing a browse, address, or service resolution query, the user
can choose not to provide a query config in which case the current
default config will be used. The user can also provide a full or
partially specified `otDnsQueryConfig` instance, e.g., some of some of
the fields may be left unspecified (value zero). The corresponding
value from the current default config is then used for any unspecified
field in the given config.
This commit also updates the CLI to add `dns config` sub-command and
update other `dns` commands to follow the new API model.
This commit adds auto-start SRP client feature. Config option
`OPENTHREAD_CONFIG_SRP_CLIENT_AUTO_START_API_ENABLE` adds support for
this feature in SRP client allowing auto-start mode to be enabled or
disabled. When enabled, the SRP client will monitor the Thread Network
Data for SRP Server Service entries and automatically start and stop
the client when an SRP server is detected. If multiple SRP servers are
found, a random one will be selected. If the selected SRP server is no
longer detected (not longer present in the Thread Network Data), the
SRP client will be stopped and then it may switch to another SRP
server (if available).
This commit also adds support for the new feature in CLI and adds a
new test `test_srp_auto_start_mode.py` covering the behavior of this
feature.
This commit enhances the DNS-SD server to handle multiple questions.
Specifically for DNS service resolving query with SRV+TXT questions,
this commit would reply with SRV+TXT+AAAA RRs, so that the service
instance can be fully resolved with one query.
More implementation details:
- This commit enhances NameCompressInfo so that question names can be
compressed together with RR names.
- Full compression is limited to only one instance / service / host
name.
- For any RR type in the question, this commit will exclude it in
additional RRs. For example, if the query contains a AAAA question,
the response won't include any additional AAAA RR, but will only
have AAAA answer(s). The purpose is to avoid duplicate RRs in answer
section and additional section.
This commit adds new CLI command `multiradio` to get the list of
supported radio types by device and `multiradio neighbor` sub-command
to get the radio info (supported radios and the their preference) for
specific neighbor or for all neighbors.
Qorvo has restructured its third_party/Qorvo/repo submodule.
The linkerscripts for the embedded platforms qpg6095 and qpg6100 have
also been moved to this submodule.
This change:
1. Adds new github action to verify posix app for OT 1.2.
2. Only enable compile flag OT_SIMULATION_VIRTUAL_TIME_UART in
script/test for ot-rcp build target.
3. Allow mix use of posix node and ot-cli-mtd node by changing python
test script to accept node type as parameter.
4. Remove CSL test from expect as it is covered by thread-1-2-posix
tests.
This changes the sleepy-demo-mtd app's startup behavior. Prior to the
change, the MTD would go to sleep immediately. Instead, the MTD will
not sleep until the button is pressed.
The echo command of the host system may have slight variations between
shell built-in echo and the echo command provided by the OS.
Especially the Windows OS echo command is different from practical any
other echo command.
This means that the currently used `COMMAND echo -e "<text>"` does not
work universally.
This commit introduces `etc/cmake/print.cmake` which allow to print a
CMake list where each item is printed on a new line, to get the desired
behavior on the `print-ot-config` target.
Using `cmake -E echo <text>` ensures identical behaviour across
different systems.
Signed-off-by: Torsten Rasmussen <Torsten.Rasmussen@nordicsemi.no>
This commit updates the trel simulation platform implementation to
include the src/dst IPv6 addresses and port number (as part of new
simulation-specific packet header) in the exchanged message. It also
verifies the port and dest address (against the expected trel
interface unicast or multicast IPv6 addresses) on the received
message. This helps enhance the simulation platform implementation to
cover the behavior if/when the unicast address used by trel changes.
This commiit implements otPlatUartFlush() for EFR32 with a
configurable timeout, defaulting to 500ms. It also allows multiple
buffers to be sent to the UARTDRV transmit FIFO queue.
This commit re-designs the `Dns::Client` module enhancing the address
resolution implementation and also adding support for DNS-Based
Service Discovery (DNS-SD).
With regards to address resolution query the new model relaxes the
requirements of the public OT APIs such that caller does not need to
persist the query info (e.g., the host name string buffer can be a
temporary variable and does not need to persist during the query) and
it is all managed by the `Dns::Client` core implementation itself. The
new model also supports the case where the response contains multiple
IPv6 addresses providing new APIs to allow the user to iterate through
the list of addresses and retrieve them one by one.
The implementation also handles the case where the DNS query response
contains CNAME record mapping the queried host name to a canonical
name for which a list of addresses are then provided.
The core implementation is also simplified, instead of cloning a query
message and saving it for possible retx, the new code saves the query
related info from which it can re-construct the query message for retx
if/when needed.
This commit also adds support for DNS-SD in `Dns::Client`. The config
`OPENTHREAD_CONFIG_DNS_CLIENT_SERVICE_DISCOVERY_ENABLE` can be used to
disable service discovery feature. The implementation supports
"service instance enumeration" which is referred to as "browsing" and
"service instance resolution". Callbacks are used to notify the user
when a response is received. In the callback a pointer to an opaque
response object is given to the user which can then be used with the
new set of APIs to get more info about the response, such as the list
of discovered service instances or more details about a specific
service instance (e.g., port number, host name and its address) or
iterate through address lists. This provides a flexible and scalable
solution to handle larger lists in the response without adding memory
overhead in the implementation.
Issue:
Information regarding a neighbor's Thread version is lost.
Context:
This problem can be observed during playing with Link Metrics - few
methods check whenever chosen neighbor supports Thread 1.2. This
information is preserved when a child is promoted to the router role,
but after the reset and Link Request - Link Accept sequence it is not
stored in the neighbor table.
This commit updates the wrapper for CSL code, updating most
occurrences !OPENTHREAD_MTD to OPENTHREAD_FTD.
We used !OPENTHREAD_MTD because we think both FTD and RCP need that
code. But that actually means host side of RCP (posix) need that code
and posix host is always FTD. The radio part itself don't need those
code. The radio part doesn't even contain most of those source files
that has CSL logic (except for sub_mac.cpp).
This commit also adds missing initialization for data field in Mac.
This commit updates the EFR32 platform-abstraction layer to work with
GSDK 3.1.1.
- memory.c
- Implemented otPlatCAlloc() and otPlatFree() to handle #6123
- GSDK mbedtls was updated and moved to
util/third_party/crypto/mbedtls
- mbedtls_config_autogen.h was regenerated
- system.c
- NVIC initialization is now done via a simple call to
sl_device_init_nvic()
- alarm.c
- Stubs for 1.2 related platform timing functions in alarm.c
- ieee802154mac.h
- Standardization of 802.15.4 header values and constants
- uart.c
- Reduce the number of vulnerable windows where interrupts disabled
by RAIL will cause dropped characters. The OpenThread task now
polls the UART buffer for arrived data and reads it out. The
USART0 IRQ handler takes care of waking up the task when data has
arrived.
- radio.c
- Implementation of Wi-Fi coexistence and antenna diversity
features, and corresponding updates to run-time phy select
configurations.
- Support for enhanced frame pending and early frame pending for
Thread 1.2 low power features (temporarily disabled until 1.2
support is available)
- Implementation of enhanced ACKs with IEs for CSL.
- Remove FIFO queue that was maintaining unique identifiers
(contents of received packet: PHR+MAC header) This was being used
to tell the upper MAC whether the frame pending bit was set in an
ACK for a received packet. Changed the implementation so we save
the state to a reserved bit in the held packet (in the MAC header)
within the receive completion ISR, and retrieve the value in
processNextRxPacket() to pass to where the upper MAC expects it.
This commit implements the DNS-SD server:
- Handle Standard DNS Query from clients
- Supported resource records: PTR, SRV, TXT, AAAA
- Query services from SRP server
- Add tests
- simulation test using DNS client (only test AAAA query)
- OTBR test using dig command to verify all resource records can be
queried successfully
All the settings are written into a local file on the posix platform.
It is easy for others to get the critical information, such as master
key, from the local file. This commit adds new APIs to allow the
vendor to store the critical settings to a secure area.
This commit includes basic service registration & advertising function
verification. More tests including name conflicts and multiple devices
cases will be in future commits.
We changed the border_routing test scripts directory to border_router
as there will be more tests about Thread border router but not only
the routing feature.
The Instance::HeapCAlloc() method can not be used in constructors when
EXTERNAL_HEAP is enabled but works well when internal heap is
used. This is because the external heap methods are set by public
otHeapSetCAllocFree API after the OT instance is constructed.
This commit fixes this issue by having Instance::HeapCAlloc() using
otPlatCAlloc when EXTERNAL_HEAP is enabled. It also fixes build issues
when MULTIPLE_INSTANCE and EXTERNAL_HEAP are used together.
This commit removes the OwnerLocator class since it's actually
useless.
Timer and Tasklet inherited from OwnerLocator to so that they can use
GetOwner<Type>() to find the owner object. However, these two classes
already inherited from InstanceLocator, thus can use Get<Type>() to
get any component of the OT instance.
This commit adds some new methods/APIs in `Srp::Client` class:
`GetServerAddress()` to get the SRP server's socket address that is
being used by the client, `IsRunning()` to check whether the SRP
client is started and running or not, and `SetCallback()` to allow
user to set the callback at any point (before/after call to
`Start()`). It also adds a new `srp client` sub-command to get the
server address and/or its port number.
This commit adds spinel properties for NCP built with
OPENTHREAD_CONFIG_MAC_CSL_RECEIVER_ENABLE.
Such NCP will have also a new capability
SPINEL_CAP_THREAD_CSL_RECEIVER.
This commit adds a new module `network_data_service` which includes
the "Thread Network Data Service" entry definitions (e.g., service
number and the associated server data format for each service type).
It also adds `NetworkData::Service::Manager` which manages the Network
Data Service entries and provides helper methods to other core modules
to easily add/remove and/or parse/find info about specific services.
For example, this commit adds a method to get info about the
list of SRP servers (their IPv6 address and port number) from the
"SRP Server Service" entries in the Thread Network Data.
This commit updates `AddServcie()` and `RemoveService()` in
`BackboneRouter::Local` class such that the methods themselves
after adding/removing the service entry in local network data
inform `NetworkData::Notifier` to send the update to leader.
This helps simplify their use.
This commit enables expect tests on macOS, also includes the following
required changes:
* Fixed bound to interface issue on macOS.
* Added ability to configure scan period, because macOS environment on
GitHub Actions is much slower.
This commit changes the order of member variable in `Cli` class
ensuring `mInstance` is initialized before other member variables.
This then allows the `mInstance` to be safely used from the
constructor of other `Cli` sub-types.
This commit updates the trel platform posix implementation to use
linux netlink socket (instead of `ioctl()` command) to add/remove
unicast (link-local) address on the netif used by trel . When netlink
socket is used "Duplicate Address Detection" (DAD) is explicitly
disabled when the address is added. This helps speed up the start time
of OpenThread stack when using TREL.
The `OPENTHREAD_CONFIG_POSIX_TREL_USE_NETLINK_SOCKET` config option
can be used to enable/disable the use of netlink socket by trel
platform layer implementation. By default it is enabled on all
linux-based platforms (determined by `__linux__` macro being
defined).
This commit adds a new template helper method in `ResoureRecord` to
search in a given message starting from a given offset and up to a
maximum given number of records, for the i-th occurrence of a specific
record (of given type with a matching record name). If found, it reads
the record from the message into a given record object.
This commit also updates the unit test `test_dns` to cover the behavior of
newly added helper method.
This commit changes these methods to return corresponding entries from
Thread Network Data rather than local network data.
- get_prefixes
- get_routes
- get_services
Added local version to retrieve entries from local network data.
- get_local_prefixes
- get_local_routes
This commit adds:
- a new method Dns::Name::IsSubDomainOf that matches a DNS name with
given domain. This is useful for SRP and DNS-SD server to verify if a
RR is in our authorized domain.
- domain checks for names in a SRP update to the SRP server.
This commit returns parsed TXT entries for service from the SRP
server, it enables prettier CLI output and easier Advertising Proxy
processing. We moved the otSrpTxtEntry to include/openthread/dns.h
because this structure can ( and will) also be used by DNS-SD
client. We also added one more mKeyLength field in otDnsTxtEntry for
saving length of the TXT key so that we can iterate over the encoded
TXT data without dynamically allocating memory for each entry.
This commit allows `Dns::Name` instances to be created which can be
empty or given as a string (a dot '.' separated sequence of labels) or
from a message at a given offset (i.e., name is already encoded in a
message). `CompareName` and `FindRecord()` helper methods are updated
to allow the new `Dns::Name` type to be used when comparing/ searching
for a name.
This commit adds new spinel definitions for SRP client support
(mirroring the public OT APIs of SRP client) and implements get, set,
add, and remove handlers in `Ncp` for the new spinel properties.
This commit makes sure that UDP servers are accessible via all IPv6
addresses when PLAT_UDP is on.
We still need to pass the messages with ALOC/RLOC destinations to the
tun interface when PLAT_UDP is used. Otherwise, UDP servers can not
receive any message when PLAT_UDP is enabled.
Implemented CoAP/-s block-wise transfer according to RFC 7959. The
implementation includes methods and functions available to the
application layer to add Block1 and Block2 option values to a coap
message and an automatic block-wise transfer enabled by the compile
switch "COAP_BLOCK".
This commits refine the FULL_LOGS option (OT_FULL_LOGS for cmake):
- remove configuration of log regions since they should be 1 by
default
- set PLATFORM log region to ON by default
This commit adds new helper methods in `ResourceRecord` class.
`ParseRecords()` parses and skips over a given number of resource
records in a message. `FindRecord()` searches in a given message to
find the first resource record matching a given record name. And
`ReadRecord<RecordType>()` tries to read a matching resource record
(of a given type) from a message. If the record type does not match
the type, it skips over the record. This commit also adds methods in
`PtrRecord`, `SrvRecord`, `SigRecord` and `TxtRecord` to parse and
read the data fields such as PTR name, host name, signer name and
TXT data.
This commit updates the DNS unit test to add a detailed new test
constructing and parsing a DNS message (covering the behavior of
the newly added and some of the existing methods).
This commit adds new helper methods in `Dns::Name` to parse and
compare a single name label `CompareLabel()` or an entire name
`ComapareName()` from a given message with a given string. Another
flavor of `CompareName()` compares the names read from two different
messages (or same message at different offsets). The name checks are
performed in place (without reading/copying the content from the
messages) and the implementation handles compressed names.
Unit test `test_dns` is updated to verify behavior of newly added
methods.
This commit contains two changes in `Dns::Name` class. When reading or
parsing names/labels from a `Message`, we require that the message
offset (i.e., `aMessage.GetOffset()`) to be set by the caller to point
to the start of the DNS header in the message. This is then used to
decode compressed DNS names. This change helps simplify the code and
removes the need to pass `aHeaderOffset` as a separate parameter. The
second change is to the `ParseName()` implementation which now always
goes through and parses the entire compressed name before returning.
This ensures that we correctly detect invalid compressed names when
parsing the name in a message.
This PR includes the initial implementation of the SRP server
defined in https://tools.ietf.org/html/draft-ietf-dnssd-srp-07.
- SRP server Service TLV propagation: Includes only the 2-bytes
dynamic listening port in the Server TLV.
- SRP request processing (parsing & validation)
- LEASE & KEY-LEASE management
- SIG(0) verification
- Interface for advertising proxy
- CLI commands for testing
- Support removing indivitual SRP service
This commit adds support for SRP (Service Registration Protocol)
client in OpenThread. The implementation allows a user to provide host
info (host name and a list of host IPv6 addresses) along with a list
of services to be registered with an SRP server. Services and/or host
addresses can be added or removed during operation of client.
Users can get the list of services and host info and their current
state (indicating, for example, if service is registered with server,
being registered or being removed, etc). Users can also provide a
callback to get notified whenever there is change or an error.
When there is a new request (e.g., a new service is added/removed)
that requires an update, the SRP client will wait for a short delay
before preparing and sending an SRP update message to server. This
allows user to provide more changes that are then all sent in the same
update message. The implementation handles retries in case of
different errors and failures. An exponentially increasing retry wait
interval (with configurable min, max, and growth factor) is
implemented.
The implementation also manages the lease renew time for each service
and refreshes (re-registers) services with server before lease is
expired. It supports "opportunistic early refresh" mechanism such that
when sending an SRP update, the services that are not yet expired but
are close, are allowed to refresh early and are included in the SRP
update. This helps place more services on the same lease refresh
schedule reducing number of messages sent to the SRP server. This
behavior (whether to allow early refresh or not, and its related
parameters) can be controlled through a set of OT config definitions.
When compiling ot-cli and ot-ncp, the Android.mk will compile
the function `property_get` in `src/core/api/instance_api.cpp`.
The function `property_get` is provided by the library `libcutils`.
GitHub Action uses Android NDK to compile Android.mk, Android NDK
only allows adding the shared library `libcutils` for the library
`ot-core`. However, Android requires to add the shared library
`libutils` for the binary `ot-cli` and `ot-ncp`. Therefore, this PR
uses the macro `ANDROID_NDK` to distinguish these two cases.
This commit includes two small enhancements to the posix infra if
module:
- simplify logging of socket errors since the VerifyOrDie macro
already prints the line number and strerror().
- suppress "drop ICMPv6 message" debug logs when there is no input
data to be read on the socket.
This commit includes the enhancement that
1. Adds non-default external route for on-link prefixes.
2. Add external route for OMR prefixes advertised by BRs in other
Thread Networks.
3. A new API to disable/enable the Border Routing manager at run
time. CLI commands are added for testing.
4. A new platform API to get the link-local address of the infra
interface so that we can filter out the ICMPv6 packets from myself
by the Border Routing Manager rather than the platform
implementation.
This commit allows specifying multiple arguments for script/test cert
path/to/script.py.
This is useful for running a selected test case when the test script
contains multiple test cases.
This commit removes QuestionAaaa class.
Since the format of each question type is exactly same, it seems
unnecessary to define a dozen of QuestionXxx classes for different
resource record types just with different kType.
This commit adds new helper `Compare` methods in `Message` class to
compare the bytes from the message (at a given offset) with a byte
array or bytes from a (template) object or bytes read from another
message.
This commit also updates the message unit test to cover the behavior
of the newly added methods.
Currently when a test fails, the core dump uploading action would be
executed. (Even when there's no core dump, the binaries and so libs
would be uploaded, which is a waste.)
This commit uses env variables of github actions to only execute the
uploading action when crash actually happens.
This commit fixes some typos in the documentation/comments and
renames some of methods getting number of RRs in a DNS header
section (`Get{Section}RecordCount` <- `Get{Section}RecordsCount`).
This commit adds a check in `GetBackboneRouterPrimary()` to verify
that the server sub-TLV data length is larger than a expected minimum
before casting it to `BackboneRouterServerData` and parsing/reading the
info.
Many Iterators have the same pattern in our code: they have ++,
deference, equal operators, IsDone method and hold a pointer to the an
object. This commit extracts the common pattern into a template class
ItemPtrIterator and use it as a base class for those similar Iterator
classes.
This commit fixes the assert check on MPI encoded size. Note that
`mbedtls_mpi_write_binary()` would fill the entire given buffer
(adding zero bytes if the MPI encoded size requires less bytes than
the given buffer size).
When obtaining entropy data, trng_get_random checks the status for any
noise, and if so, cleans its queues and keeps the entropy accumulator
of mbedtls running.
In the process, TRNG might not have any new samples available, so a
zero length output is valid, and we should keep running rather than
exit fatally.
Expect sometimes matches the pattern before a line is fully printed to
TTY. As a result, the address returned may not be accurate. This commit
fixes this issue by matching line breaks.
This commit adds new option to skip RCP API version and capability
compatibility check during initialization. The radio URL key
`skip-rcp-compatibility-check` can be used to enable this behavior.
This is only intended for situations where RCP won't be operating as a
radio (e.g., host trying to perform an RCP firmware update).
This commit enables unused-parameter warning for NRF driver code
except for soft-device.
Currently this warning is disabled for all NRF driver code, which
makes OT_UNUSED_VARIABLE in driver code useless. We only need to
suppress the warning for soft-device code because only that part
includes some headers in third_party/NordicSemiconductor that have
unused parameters.
It seems to be unnecessary to install these format dependencies when
setting up OpenThread on a Raspbian (Mostly people don't develop or
submit PR from a Raspberry pi). So by default don't install these
format dependencies on Raspbian to save time.
This commit introduces the Proof of Concept implementation of the
OpenThread Controller Interface (OTCI) which can be used to connect
and manage various kinds of OT devices.
This commit also adds the tests to verify that OTCI works for both
simulation and real OT devices.
- Device Connectors
- CLI Virtual Time Simulation
- CLI Real Time Simulation
- CLI SOC Device
- NCP Virtual Time Simulation (not all APIs work)
- Real device via SSH
- OTCI tests of simulation devices are executed in Github Actions
- OTCI tests of real devices can be executed like below:
# Install otci python library
cd tests/scripts/thread-cert/otci && python3 setup.py install --user
# Test OT CLI SOC device at /dev/ttyACM0
REAL_DEVICE=1 OT_CLI_SERIAL=/dev/ttyACM0 python3 tests/test_otci.py
# Test OTBR device via SSH
REAL_DEVICE=1 OTBR_SSH=172.16.243.151 python3 tests/test_otci.py
When initializing, we should use randomly generated network parameters
instead of default ones, to eliminate the possibility of unintentional
use of default credentials.
CoAP requires that the source address of a response must match the
destination addresses of the request. So, if a device sends a TMF
request using ALOC as destination address, the TMF response SHOULD use
the ALOC as source address. Otherwise, CoAP implementations (beside
OpenThread) may fail to match the request and response.
This is the initial implementation of Thread Border Router
prefix/route management with:
- Create & publish off-mesh routable (OMR) prefix for Thread network
- configure the BR as default route.
- converge to the smallest OMR prefix if multiple prefixes are
present at the same time.
- Create & advertise on-link prefix for infrastructure network
- monitor RA messages on infra link and stops myself if there is
someone else advertising an on-link prefix.
It currently supports single infrastructure link with possibly
multiple BRs. Support for multiple infrastructure links is left for
future.
This commit updates `Sha256` and `HmacSha256` classes adding new
flavors of `Update()` method which inputs bytes from a given buffer,
or from an object, or read from a `Message` for hash calculation.
This commit also updates unit test to add more test-cases (from RFC
4231) for HMAC and adds new set of test-cases for SHA-256. The test
also covers calculating hash over data read directly from a `Message`.
The ECDSA feature needs more heap to run because buffers for signing
and signature verification are dynamically allocated.
The number 2600 is the minimum (not precise) size to pass the
test_ecdsa unittest case. This is not revealed in CI tests because
DTLS is enabled (and thus we have much larger heap) for unittest
check.
Per Sec 4 of RFC 6605:
"ECDSA public keys consist of a single value, called "Q" in FIPS
186-3. In DNSSEC keys, Q is a simple bit string that represents the
uncompressed form of a curve point, "x | y"."
The bit string of the two curve points (X, Y) should have a fixed
length of 64 bytes and the additional `1` byte prefix should not be
included, because only uncompressed form is allowed.
This commit changes the trel platform implementation under posix such
that if the interface name used for trel is empty, the platform layer
would disable trel. This is done by having all `otPlatTrel` functions
returning immediately without performing any action. This commit also
changes the `OPENTHREAD_CONFIG_POSIX_APP_TREL_INTERFACE_NAME` to be
empty string. This is the posix config option specifying the interface
name to be used by the trel platform layer. Note that the trel
interface name can be given using this build-time config, or through
the `-trel-interface` (or `-t`) input arg option. When the input arg
is not used, the interface name is determined from the build-time
config `POSIX_APP_TREL_INTERFACE_NAME`. This commit therefore makes
the default behavior when `-t` is not used to disable trel platform.
An issue is caused by The Challenge TLV and TLV Request TLV MUST be
included if the response is an Accept and Request message in Step 4,
delete these two TLV checks when the response is a Link Accept
message.
src/ncp/BUILD.gn: Added new targets
spinel/BUILD.gn: Added configs to propagate the flags to dependent
targets
BUILD.gn: Updated top level BUILD.gn to include ncp targets
radio_spinel_impl.hpp: Removed compiler error for unused variable
mbedtls/BUILD.gn: Added a missing src file, added compiler flag to
ignore conversion as there is implicit unsigned int to unsigned char
conversion in ctr_drbg.c and ecp.c
This commit adds support for ECDSA using NIST P-256 curve and SHA-256
hash. `KeyPair` type is added which represents a set of public and
private keys. It provides methods for generation a new key-pair and
getting a DER format byte sequence representation of the key-pair.
This commit also adds methods to calculate ECDSA signature and verify
a signature for a hashed message. The underlying implementation uses
`mbedtls` APIs.
It also adds a unit-test `test-ecdsa` to cover behavior of the newly
added types and methods. The unit test also verifies the signature
calculation using the test vector example from RFC 6979.
Currently if OpenThread dies with something like VerifyOrDie, we can't
get any logs from GitHub Actions. This enables full logs and uploads
them when expect tests fail, making it easier to diagnose such errors.
If mError is set to error state before entering the RCP recovery, this
error will be recognized as an error in the recovery process, and
cause it to die, while there is actually no error.
This fixes it by clearing mError when starting the recovery process.
After coex precondition is approved, no action is taken to notify the
core. As a result, the coex precondition is not met when doing the
transmission. Now we move the code before HFCLK handling so that HFCLK
handling would notify the core.
This commit addresses an issue with `LinkRaw` on FTD/MTD builds. In
FTD/MTD builds, we add code to disable/enable MAC layer when link-raw
is being enabled/disabled. This ensures to avoid any conflict in
control of radio and sub-mac between `Mac` and `LinkRaw`. In RADIO
build, we directly enable/disable sub-mac (note that in FTD/MTD build
then `Mac` layer would be enable sub-mac).
Performing MAC frame encryption immediately after each copy results in
copying the already-encrypted frame, rather than the original frame
before encryption.
- Simplify 'GetNextCslTransmissionDelay'. Remove one unneeded function
argument.
- For a CSL transmission using 'nrf_802154_transmit_raw_at' there is
no need for 'nrf_802154_channel_set'.
This commit adds explicit error logs messages for the more common
error situation in trel platform implementation under posix, e.g., if
the trel netif cannot be found, or a unicast address cannot be added
to the netif. The new logs provide is included to provide more details
in addition to log message by `VerifyOrDie()` and/or `DieNow()`
This commit implements Enhanced-ACK Probing (on simulation platform).
- Add a new public API otLinkMetricsConfigEnhAckProbing which sends
Link Metrics Management Request to configure the probing. This is
called on Probing Initiator side.
- Add a new radio platform API otPlatRadioConfigureEnhAckProbing. This
API should be called on Probing Subject side when handling the
requests from Initiators. This API notifies the radio to start/stop
aggregating link metrics info and include the data into Vendor IE in
enhanced-ACK for the specific neighbor. As discussed in #5746, the
code for doing such thing should be put in radio driver.
- Add a util module util/link_metrics, which provides a group of APIs
to implement Probing Subject side logic for Enh-ACK Probing. Any
platform could use this module to implement the feature easily in
radio driver.
- Add new util APIs in util/mac_frame to generate Enh-ACK Probing IE
(Vendor IE with Thread OUI and SubType = 0) and set value for this
IE.
- Update the implementation in simulation/radio.c to support Probing
Subject side logic for Enh-ACK Probing, using APIs in
util/link_metrics and util/mac_frame.
- Add a test
v1_2_LowPower_7_1_01_SingleProbeLinkMetricsWithEnhancedAcks.py for
testing.
Misc:
- Add check for all the public Link Metrics APIs (Initiator side) to
ensure that the Subject is a neighbor of the Initiator. If the
address is not link-local or the neighbor is not found, an error
UNKNOWN_NEIGHBOR would be returned.
- Update PrepareEmptyFrame so that when it's called for reference
device, its frame version would be set to 2015.
This commit adds new builds under "simulation-build-autotools"
to cover multi-radio configurations: TREL only, 15.4+TREL,
15.4+TREL+ToBLE.
It also adds new GitHub action tests covering all `toranj`
test-cases with different configurations:
1) NCP model with TREL radio only,
2) POSIX App and RCP model with TREL radio only (emulated over
a virtual Ethernet netif).
This commit updates `toranj` test framework to support running tests
in posix-app mode over a TREL radio link (a virtual Ethernet netif is
used for TREL). It also updates the build script to easily set up
different configurations, ncp/posix-app with any radio combination:
15.4 only, TREL only, or multi radio (15.4 + TREL).
This commit adds new spinel properties (and their getters) related
to multi radio link feature. `SPINEL_PROP_SUPPORTED_RADIO_LINKS`
allows host to get the list of supported radio links by the device
itself, `SPINEL_PROP_NEIGHBOR_TABLE_MULTI_RADIO_INFO` provides
info about the radio links supported by all neighbors.
This commit adds new public OT definitions and API for radio link
configuration in `openthread/multi_radio.h`. Mainly the function
`otMultiRadioGetNeighborInfo()` is added which allows info about a
neighbor to be retrieved (e.g., which radio links are supported by the
neighbor and their preference value).
This commit allows us to use different MTU on different radio links.
Mesh Header frames are forwarded by routers over multiple hops to
reach a final destination. The forwarding path can have routers
supporting different radio links with varying MTU sizes. Since the
originator of the frame does not know the path and the MTU sizes of
supported radio links by the routers in the path, we limit the max
payload length of a Mesh Header frame to a fixed minimum value
(derived from 15.4 radio) ensuring it can be handled by any radio
link.
This commit implements TREL IPv6/UDP platform under POSIX App. The
implementation uses datagram sockets to exchange packets over a given
network interface (netif). The interface name can hard-coded in the
build using `OPENTHREAD_CONFIG_POSIX_APP_TREL_INTERFACE_NAME` config
or be specified as part of the input program arguments (using
`--trel-interface` or `-t` option).
This commit implements TREL protocol to encapsulate and exchange IEEE
802.15.4 frames over a packet switched network (e.g., a wireless LAN).
This commit also provides a TREL IPv6/UDP interface implementation
(using link-local IPv6 unicast/multicast addresses to communicate over
a subnet). It defines a platform abstraction (`otPlatTrelUdp6*`) for
TREL over IPv6/UDP.
This commit also provides an implementation of the TREL platform under
`examples/posix` focusing on simulating the behavior of the link.
This commit adds support for multi radio links in OpenThread core.
A set of `OPENTHREAD_CONFIG_RADIO_LINK_*` definitions (in header
`config/radio_link.h`) determines the supported radio link types.
This commit adds a new class `RadioSelector` which selects the radio
link for each message transmission. Per neighbor it tracks the
supported radio types and a preference value for each type.
`RadioSelector` updates the preference value based on the history of
rx/tx events with the neighbor, e.g., a successful tx on a radio link
increases the preference, whereas a failed tx attempt decreases it.
A new class `Mac::Links` is added defining a layer between `Mac` and
different radio links (e.g., `SubMac` for 802.15.4 radio type).
Broadcast frames are sent in parallel over all radio links. A unicast
transmission is sent over a single radio link at a time but on a tx
failure it may be retransmitted over other radio links.
This commit also adds the concept of deferred ack, allowing radio
links report status of ack at a later time through a different
callback.
This commit adds a new class `Crypto::HkdfSha256` which implements
HMAC-based Extract-and-Expand Key Derivation Function from RFC-5869
using SHA-256. It also adds a unit test for the new module.
The efr32 platform shows the following behavior:
> txpower -10
Done
>
> txpower
-113 dBm
Done
The bug is caused by the C promotion rules during the division of
int16_t by unsigned in otPlatRadioGetTransmitPower. This commit fixes
the issue.
- This commit fixes some issue in multicast forwarding from Thread to
Backbone.
- It also adds a test to verify that multicast forwarding works across
Thread and Backbone.
- Test script tests/scripts/thread-cert/mcast6.py is added for Host
to subscribe to a multicast address
The ping reply can not reach ROUTER1 since DUA feature is not
complete.
This commit fixes TMF issues related to the Host tun interface.
- Do not pass TMF messages to Host tun interface
- Backbone TMF (also using port 61631) keeps passing TMF messages to
Host tun interface
- Re-enable packet filters for ALOC/RLOC destined and TMF packets for
PLAT_NETIF and PLAT_UDP
This commit adds `Dns::Name` type which provides a set of helper
methods to encode/decode DNS names. `AppendName()` method encodes and
appends a full name (e.g., "test.example.com") to a message. Other
helper methods enable appending labels (or groups of labels) and/or
constructing a compressed name (using pointer labels). `ParseName()`
method parses and skips over a full name in a message. `ReadLabel()`
method reads labels one by one and works independently of whether the
encoded name is compressed or not. `ReadName()` method read an entire
name from message. The new methods are used in `Dns::Client`.
This commit also add a unit test `test-dns` covering the behavior of
the newly added helper methods.
Finally, this commit adds few helper methods in `ResourceRecords` to
get the size and check the type of a DNS record.
We found that it's possible that a Router, in a topology like above,
could send DUA.req so quickly after receiving Data Response from
Leader that the PBBR is not able to process the same Data Response
message and update the network data accordingly. Consequently, PBBR
sends DUA.rsp with kDuaInvalid status because it can't find a valid
Domain Prefix in the Network Data.
This commit help resolve this issue with two fixes:
- Node to delay for up to 1000ms before sending DUA.req when domain
prefix addresses is generated
- PBBR to respond with kDuaGeneralFailure to allow the node to
re-register the same DUA again.
This commit ensures each node create its own profile data, so that they
can be merged after tests to produce more accurate profile data.
This commit also prints the coverage data of message.cpp after all
profile data are merged.
This commit introduces two configurations for Backbone Router to turn
off corresponding features:
- OPENTHREAD_CONFIG_BACKBONE_ROUTER_DUA_NDPROXYING_ENABLE: 1 by
default, set to 0 to disable Backbone Router DUA ND Proxying
- OPENTHREAD_CONFIG_BACKBONE_ROUTER_MULTICAST_ROUTING_ENABLE: 1 by
default, set to 0 to disable Backbone Router Multicast Routing
Both configuration requires OPENTHREAD_CONFIG_BACKBONE_ROUTER_ENABLE.
NOTE: At least one of these two configurations must be ON if
OPENTHREAD_CONFIG_BACKBONE_ROUTER_ENABLE=1(otherwise it's meaningless
to turn on OPENTHREAD_CONFIG_BACKBONE_ROUTER_ENABLE).
This commit removes settings storage path from
`include/openthread-config-android.h` to allow users define
the settings storage path on Android platform.
This commit restrict diagnostic mode only when network stack is not up,
which prevents some issues caused by switching to diag mode after the
device was attached. For example, timers may not be triggered properly
after returnning from diagnostic mode.
5.3.3 pktverify fail by small chance when the ping reply is forwarded
from Router3 -> Leader -> Router2 instead of Router3 -> Router2. In
such case, the direct wpan.dst16 is not Router2's RLOC16, but Leader's
RLOC16.
This commit change 5.3.3 to check for both 6lowpan mesh dst16 and
wpan.dst16 against Router2's RLOC16.
Remove -nostartfiles. There's currently no custom __START defined
anywhere.
Remove -D__STARTUP_CLEAR_BSS for silabs. Standard initialization
should already take care of this.
This commit adds action to upload core dumps, so libs and binaries for
1.2 certification. This is intended to solve issues where programs
intermittently crash however hard to reproduce it.
This is added first for thread-1-2 and low-power-packet-verification
first as an experimental work. We can add same actions for other items
when it's necessary.
If user doesn't set the Partition Id using the command
'leaderpartitionid xxx', the current cli command 'leaderpartitionid'
always return 0. This commit renames the command 'leaderpartitionid'
to partitionid and let the command partitionid returns the current
leader Partition Id and add command partitionid preferred to set or
get preferred Partition Id.
This commit adds a new method `CheckRcpApiVersion()` which is used
during `Init()` to get the API version from RCP and verify that it
is within supported range.
This commit adds a new compatibility check model for RCP and host. It
updates the compatibility guideline documentation stating how the
compatibility policy for NCP versus RCP are handled differently. For
NCP, we continue to require new NCP firmware to remain backward
compatible and work with an older host driver.
For RCP and host, this commit introduces the RCP API Version model.
The API version numbers are used to check the compatibility between
host implementation and RCP firmware. Generally, a newer host side
implementation would work with a range of previous or older RCP
firmware versions.
This commit adds `SPINEL_RCP_API_VERSION` definition which specifies
the current spinel RCP API version. This number MUST be incremented
anytime there is a change in any of RCP specific spinel definitions.
`SPINEL_MIN_HOST_SUPPORTED_RCP_API_VERSION` specifies the minimum
spinel RCP API version which is supported by the host-side
implementation.
This commit also reserves a block of spinel properties value ranges
from `0xB0 - 0xFF` for RCP related property definitions. The smaller
property values help decrease the encoded byte stream length,
resulting in shorter spinel frames exchanged between RCP and host.
This commit update Github Actions workflows to use ubuntu 20.04
whenever applicable.
- Change ubuntu-latest to ubuntu-20.04 to cleanup the annotations:
Ubuntu-latest workflows will use Ubuntu-20.04 soon. For more
details, see
https://github.com/actions/virtual-environments/issues/1816
- Change ubuntu-18.04 to ubuntu-20.04 wherever ubuntu-20.04 works.
- Fixed a compile issue in tests/unit/test_link_quality.cpp on
ubuntu-20.04
- Can not get Simulation/expects work on ubuntu 20.04 due to unknown
issue. Leave for further enhancement.
This commit contains a set of smaller enhancements/changes in DNS
modules:
- Adds `Client::QueryInfo` class (mirroring `otDnsQuery`).
- Simplifies iteration over `mPendingQueries`.
- Uses `Ip6::Address` instead of `otIp6Address` (internally).
- Updates documentation style in `dns_headers.hpp` .
- Changes internal constant/enum definitions to be `private`.
- Adds `ResourceRecordAaaa::IsAaaa()` helper to check whether a
given Resource Record is of AAAA type.
- Small style fixes.
This commit updates `Dataset::Info::GenerateRandom()` to set the Key
Rotation Time in Security Policy component on a Dataset using the
default value (from `KeyManager`). This addresses the issue where the
generated Operational Dataset could potentially use zero for Key
Rotation time.
This commit also changes Security Policy Flags to use default value
from `KeyManager`.
This commit enables the feature IPV6_MULTICAST_LOOP into OpenThread IPv6
stack. The default-enabled feature allows a node receives a multicast
message sent by its own.
Software aes was using tables from RAM instead of ROM. It caused firsit
call to take longer than expected due to the need to fill the data.
Had to move to the most recent nrf security vestion as the one used did
not support this feature.
Oberon backend is software crypto implementation faster than mbedtls.
Since now AES can not be handled by cc310 switched to using Oberon
instead of vanilla mbedtls.
Also updated doc as some files were renamed.
Signed-off-by: Marek Porwisz <marek.porwisz@nordicsemi.no>
This commit avoid unnecessary rebuilds. The issue is caused by the
openthread-mbedtls-config target added by add_custom_target will always
be run, so the generated openthread-mbedtls-config.h is always
re-generated. This commit changes to use add_custom_command to generate
the header file.
MAC command frame has its command ID encrypted in frame version
802.15.4-2015. Radio driver cannot decrypt this frame payload without
extended address. So the frame pending bit is not correctly set in the
ACK in response to data request command with version 2015. This commit
adds a special handling for frame version 2015 and only checks the
frame type when deciding if it needs to set the frame pending bit.
This commit:
- Fixes the issue in CSL scheduler dealing with multiple SSEDs.
- Fixes the issue when CSL tx attempts reach max, CSL transmission to
this child cannot resume.
- Reset CSL sync status after child mode change to RxOnWhenIdle.
- Adds MLE version, CSL synchronization status and queued message
count to child table.
This commit simplifies the CLI module by adding new flavors of helper
methods `OutputLine/Format(aIndentSize, ...)` which prepend a given
number of indentation space characters before the format string.
It also harmonizes the other `Output{Item}()` methods which output an
item with a given indentation to use `aIndentSize` as the parameter
name and as the first parameter of the method.
It also simplifies the implementation of `OutputSpaces()`.
This commit adds a new module `DatasetUpdater` which provides
easy-to-use APIs for user to request an update to any component (a
subset of components) in Operational Dataset of the Thread network.
The change can be requested from any node in the network. The
implementation uses `MGMT_PENDING_SET` command and takes care of
preparing the Pending Dataset and updating timestamps and monitoring
for the Dataset to be updated and possibly retrying. It reports the
outcome (success or failure status) back to the user in a callback.
This commit also updates the `ChannelManager` module is to use the
`DatasetUpdater` to change the channel.
This commit contains small style changes in CLI module
- Not using `a{VariableName}` style for local variables
- Harmonize the use `char *aArgs[]` as the parameter type in command
handlers.
This commit addresses an issue in `RadioSpinel::Init()` to correctly
verify that device is connected to an RCP (i.e., capability list
includes `SPINEL_CAP_CONFIG_RADIO`) and if not then exit (`DieNow()`)
with `OT_EXIT_RADIO_SPINEL_INCOMPATIBLE` code.
It also simplifies the checking of capabilities for log stream support
(`SPINEL_CAP_OPENTHREAD_LOG_METADATA`) by changing the code to get and
process the `SPINEL_PROP_RADIO_CAPS` list only once from `IsRcp()`.
This commit adds missing error check during parsing of the input
parameters in property handlers for `NETWORK_NAME`, `THREAD_MODE`,
`STREAM_NET_INSECURE`, and `MAC_FIXED_RSS`.
It also changes the encoding of dataset and the msg buffer counter
to ensure to check for error.
Currently, processNextRxPacket fills in the received frame's mRxInfo
only for non-ack packets. When a SED polls its parent, the ACK frame
is passed up to the OT core in efr32RadioProcess, but the rx info is
incorrect (it is actually the rx info for the last received non-ack
packet).
OT core uses the RSSI and LQI internally, and for applications that
don't transmit/receive data frequenty, the rx info is stale. This
commit changes this behavior, so the radio driver populates the rx
info also for ACK packets.
This commit adds an option to allow share heap memory with message
buffer pool.
For MTD, there is usually no border agent or commissioner service. This
change allows the heap for meshcop to be used by application or network
management data after the device is attached. Thus the total memory
usage can be reduced.
On nRF platform, otPlatRadioGetNow always gets the LSB part of an
uint64_t time. However, on simulation platform, this is not the
case. So in
if (otPlatRadioGetNow(&GetInstance()) <
mTransmitFrame.mInfo.mTxInfo.mTxDelayBaseTime +
mTransmitFrame.mInfo.mTxInfo.mTxDelay)
we don't get the result expected. otPlatRadioGetNow(&GetInstance()) is
a very big number on simulation platform, and mTxDelayBaseTime is the
LSB part of the rx time.
When users add a FEM after the radio chip, the actual output power is
determined by both the radio chip and FEM. The radio driver only
provide a function to set the radio output power. This commit adds
macros and functions to allow users to implement the power setting
functions by themselves.
This commit allows bootstrap not to fail but print warning if
installing llvm@9 or clang-format-9 or clang-tidy-9 failed. This has
been the best practice for installing other pretty tools.
This commit adds an overload version for LinkedList::FindMatching
which doesn't require prev as parameter. In many cases we don't need
to get the previous item's pointer when finding in a list. This
version would help in these cases.
This commits adds a common helper method to read Link and/or MLE Frame
Counters from a message. The Link Frame Counter TLV is expected to be
present in the message. The MLE Frame Counter TLV, however, is optional
and when not present the Link Frame Counter is also used as MLE Frame
Counter value.
This commit adds template flavors of `Append<Tlv>()`, `Find<Tlv>()`,
and `Read<Tlv>()` in the common base `Tlv` class. This helps simplify
the processing and generating of TLVs in other modules and also adds
build-time type check for the value of simple TLVs (build error when
incorrect TLV Value type is used).
All `Tlv` sub-classes now inherit from `TlvInfo<kTlvType>` which
provides a constant `kType` specifying the TLV Type value. Simple TLVs
which contain a single value also track their TLV Value type by
inheriting from either `UintTlvInfo` (when their value is an integral
(unsigned int) type) or `SimpleTlvInfo` (when their value is
non-integral).
This commit also add `IsSame<A,B>()` to `TypeTraits` to check whether
two given types are the same. It also adds template flavors of
`HostSwap<IntType>()` in `Encoding` module.
This commit:
- Add callback for Domain Prefix events
- Add callback for ND Proxy events
- Add corresponding test to verify ND Proxy works
- Some misc enhancements to the Backbone tests
- Run sudo modprobe ip6table_filter in Docker host so that ip6tables
works in ubuntu docker instances.
- Use -DOTBR_REST=OFF -DOTBR_WEB=OFF for building OTBR Docker image
since these features are not used in tests.
- Setup radvd on Host to send Router Advertisements for the Domain
Prefix using configuration: AdvOnLink on; AdvAutonomous off;
AdvRouterAddr off;
- Set sysctl net.ipv6.conf.eth0.accept_ra=2 for BBR and Host
This commit implements DUA features of Thread 1.2 DUA that involves
sending and processing Backbone query and answer:
- Extend address query to the Backbone Link
- Send BB.qry for Thread address query
- Send ADDR_ANS.ntf for BB.ans
- DAD process
- PBBR to send BB.qry on the Backbone link (3 times if not answered)
- PBBR to receive and handle BB.qry and sends BB.ans
- PBBR to receive BB.ans and sends ADDR_ERR.ntf if duplicated
- PRO_BB.ntf
- Send PRO_BB.ntf when DUA registration is updated
- Handle PRO_BB.ntf
- Add test_dua_dad.py to test the DAD process when it was successful
or duplicated
- Verify the normal DAD process
- Verify Address Query can be extended to the Backbone link
- Verify DAD duplicate is handled correctly
- Verify PRO_BB.ntf for duplicated DUA is handled correctly
This commit adds `Dataset::Info` and `Dataset::Components` types
mirroring `otOperationalDataset` & `otOperationalDatasetComponents`
definitions and providing helper methods to get/set different fields
in the dataset.
This commit implements the Forward Tracking Series feature in Link Metrics.
- Two new apis are added:
- otLinkMetricsSendMgmtRequestForwardTrackingSeries, which is used
to send an MLE Link Metrics Management Request
- otLinkMetricsSendLinkProbe, which is used to send an MLE Link Probe
- A new class LinkMetricsSeriesInfo is used to maintain the data of
one Series configured by a neighbor. This class inherits
LinkedListEntry and each Neighbor has a list of
LinkMetricsSeriesInfo. All LinkedListEntrys are allocated and freed
by a Pool in LinkMetrics.
- To specify SeriesFlags in cli command for Forward Tracking Series, a
similar approach with LinkMetricsFlags is used. Another character
flags is used to represent SeriesFlags.
- Whenever the node receives a frame (including ACK) from a neighbor,
it would call Neighbor::AggregateLinkMetrics which goes through each
LinkMetricsSeriesInfo entry in the neighbor's list and aggregate the
data if the frame type matches the entry.
- Two test scripts are added to test this function:
- v1_2_LowPower_7_2_01_ForwardTrackingSeries.py
- v1_2_LowPower_test_forward_tracking_series.py
This commit adds a new header `common/type_traits.hpp` which provides
`IsPointer<Type>` to check whether a template `Type` is a pointer type
or not. This is then used in `Message` and `Dataset` methods where we
append/set a generic object to check (as an `static_assert`) that the
object type is not a pointer. This adds protection (causing a compile
time error) against potential incorrect use of these methods (i.e.,
passing a pointer instead of a reference to an object by mistake).
This commit fixes the bug that the Network Diagnostic callback is not
called when we failed to get the response (e.g. the request
timeouted). This results in no command output in the CLI.
This adds support for efr32mg21 BRD4180B.
It also removes BSP_SERIAL_APP_PORT and
gecko_sdk_suite/v3.0/hardware/kit/common/drivers/retargetserial.c from
efr32mg13.
This commit adds a new platform function `otPlatLogLine()`. This
function is optional and if not implemented by platform layer, a
default weak implementation is provided and used by the OpenThread
core using `otPlatLog()`.The new function is used by OpenThread core
when the feature `OPENTHREAD_CONFIG_LOG_DEFINE_AS_MACRO_ONLY` is not
enabled (which is the default behavior). In this case, the OT core
itself will prepare a full log line.
This commit also adds implementations of the new platform function for
the NCP and CLI modules.
This commit also adds two specializations of the `SetTlv()` for
`uint16_t` and `uint32_t` value types where the given integral value
is `BigEndian::HostSwap()`-ed before written as the TLV value (these
specializations replace `SetUint16Tlv()` and `SetUint32Tlv()`).
This commit simplifies `DatasetManager::SendSetRequest()` by adding a
method to `AppendDatasetToMessage()` which uses `Dataset::SetFrom()`
method to convert a given `otOperationalDataset` to a TLV sequence
before appending it to a given message. The conversion is performed in
a new method to ensure that the stack/temporary variable `Dataset` is
released before the call to process/send the prepared message.
When the SPI is transmitting a frame, the ncp_spi sets the SPI to
transmit the second frame. After the current frame is transmitted,
the SPI generates the END and ACQUIRED event at the same time. The
SPI driver processes the ACQUIRED event first and then the END event.
The ACQUIRED event notifies the up layer to set the SPI GPIO interrupt
pin. The END event notifies the up layer that the transmission has
completed. Because the SPI tx/rx buffer variables in the `spi_slave.c`
has been updated to the second frame buffer. The ncp_spi thinks that
the second frame has been transmitted in the END event. Then the second
frame is lost.
This CL processes the END event first then ACQUIRED event. To avoid
the cached frame buffer variables are passed to the ncp_spi, the SPI
driver gets the frame buffers directly from the SPI buffer registers.
- backbone/test_mlr_multicast_routing.py verifies the basic features
of Backbone multicast routing
- backbone/test_mlr_multicast_routing_timeout.py verifies that MLR
timeout works
- backbone/test_mlr_multicast_routing_commissioner_timeout.py verifies
that Commissioner MLR timeout works
Fixes the following error:
utils/parse_cmdline.cpp:230:28: runtime error: negation of -2147483648
cannot be represented in type 'int32_t' (aka 'int'); cast to an
unsigned type to negate this value to itself
If the RAIL interrupt fires late (for example, when the MCU is heavily
loaded), then RAIL_IEEE802154_GetAddress and
RAIL_IEEE802154_SetFramePending return RAIL_STATUS_INVALID_STATE
because it is too late to modify the outgoing Immediate ACK. The
proposed solution is to avoid asserting and print a warning to make
the user aware of such problems.
This commit enhances Backbone TMF:
- Subscribe Backbone TMF on multicast addresses on the Backbone
interface
- All Network BBRs Multicast Address
- All Domain BBRs Multicast Address
- Thread Netif no longer subscribe these two addresses, because BBR
Multicast Addresses are only defined for the Backbone Link in Thread
Spec 9.4.8.1
- Make sure backbone messages are using link local src addresses
- Verify src addr for b/bmr messages
Adds `OPENTHREAD_CONFIG_PLATFORM_RADIO_SPINEL_RX_FRAME_BUFFER_SIZE`
config option which specifies the rx frame buffer size used by
`SpinelInterface` in RCP host (posix) code. This is applicable/used when
`RadioSpinel` platform is used.
This commit updates and enhances OT logging by implementing some of
more common operations as functions (instead of macros) and preparing
the entire log line (appending log level and/or log region to the log
string if the corresponding OT config options are enabled) before
passing it to platform layer.
The OT logging previously used macro definitions all the way to
platform layer call to `otPlatLog` (which itself can be defined as a
macro through an OT config). This model was adopted to address a
restriction/requirement on certain platforms (e.g., platforms that
required to enable/use log tokenization). However, using macros adds
an overhead on all other platforms that do not have such a
requirement.
This commit adds `OPENTHREAD_CONFIG_LOG_DEFINE_AS_MACRO_ONLY` which
when enabled (set to 1) keeps the implementation as before (i.e.,
macros are used in the logging module). By default this is disabled
which enables the new implementation added from this commit.
This commit also adds `OPENTHREAD_CONFIG_PLAT_LOG_MACRO_NAME` which
replaces the previous `OPENTHREAD_CONFIG_PLAT_LOG_FUNCTION_NAME`. This
config is used to override the `otPlatLog` and define it as a macro. A
build-time check is added in the `config-check.h` to help any project
that is integrating OT and may be using the macro name override
behavior to detect the change from this commit and update its config
definitions.
Finally, this commit updates `check-simulation-build-autotools` script
to add a build with `OPENTHREAD_CONFIG_LOG_DEFINE_AS_MACRO_ONLY`
enabled.
This commit contains smaller enhancements in `BorderAgent` module
- define `ForwardContext` as a private sub-type of BorderAgent
- change `ForwardContext` to be `InstanceLocatorInit` and avoid
`new` (use `Init()`)
- add `HandleCoapResponse()` method which is called from `static`
method `HandleCoapResponse()`.
- convert file `static` functions `SendErrorMessage()` to `BorderAgent`
methods
- Add `State` enum and inline/remove `SetState()`.
- Smaller style/documentation fixes (e.g., remove unnecessary `{ }`).
This change ensures the cc2538 cmake build uses the release build type
and the compile option `-Os` (optimize for size). This harmonizes the
cmake build with automake version. It also helps address an issue with
recent PRs failing on cc2538 cmake build with arm-gcc-5 due to
reaching flash size limit (without `-Os` option).
This commit changes `EventToString()` to use an array instead of
`switch`. This helps with code size due to enumerator cases being
`uint32_t` bitmask values and therefore compliers may not be able to
optimize the `switch` statement as a table.
This commit adds a new helper method to set the token on a CoAP
`Message` by copying it from another `Message`. It also renames the
method which generates a random token of a given length to
`GenerateRandomToken()`.
This commit contains miscellaneous smaller enhancements in
`DataseManager` module:
- keep `public`, `protected` `private` definitions in this order
- add helper `GetType()`, `IsActiveDataset()`, `IsPendingDataset()`
- use `Read()` helper instead of `mLocal.Read()`
- remove unused definitions of `HandleUdpReceive()`
- remove `mUriGet`, `mUriSet`, and determine them based on the
dataset type (active/pending).
- re-order member variables to help with packing
- update method documentations
Currently, the WELLKNOWN_NODE_ID = 34 is not properly defined.
- In virtual time simulation, WELLKNOWN_NODE_ID limits the number of
ports each PORT_OFFSET can occupy. The virtual time simulator
listens at the nodeid=0 port rather than nodeid=34 port. So, there
is no such thing as wellknown node ID in virtual time simulation.
- In real time simulation, the sniffer listens at the nodeid=34
port. This PR changes it to nodeid=0 port to be consistent with
other parts.
- In posix virtual time, the simulator listens at the nodeid=0
port. So, there is no such thing as wellknown node ID in Posix
virtual time.
This commit changes it to MAX_NETWORK_SIZE = 33 and make it
(configuration OPENTHREAD_SIMULATION_MAX_NETWORK_SIZE) configurable in
simulation by:
- Makefile configuration: MAX_NETWORK_SIZE
- Cmake configuration: OT_SIMULATION_MAX_NETWORK_SIZE
The `url.cpp` can use core header files (e.g. `common/core_utils.hpp`)
This change ensure the core header files should be able to see each
other (e.g., `code_utils.hpp` including `arg_macros.hpp`).
The `configure` script runs with `#!/bin/sh`, but actually required
bash. POSIX sh does not have either the `function` keyword or pattern
replacement in variable subsititutions.
This commit adds three macros in a new header `arg_macros.hpp`
`OT_GET_FIRST()`, `OT_GET_RESET(...)`, and `OT_GET_SECOND()`. These
macros help with parsing variadic arguments passed to a function/macro
and can handle the case where variadic macro arguments is empty
without requiring toolchain specific behavior/support. This commit
also adds a unit test `test_macros` for the newly added macros.
This commit fixes random fails in Thread 1.2 Backbone tests that uses
OTBR Docker.
The fails are caused by failing to start tayga service when there are
many OTBR Dockers running. This commit turns off NAT64 feature of
OTBR in 1.2 Backbone tests to avoid this issue since NAT64 is not
useful for Backbone tests.
On the transmitter side, only maintain a single frame counter, and
never reuse it.
On the receiver side, maintain a second incoming frame counter eFC
alongside FC for each device, where eFC >= FC >= 0. When an Enh-ACK is
received, verify it against eFC. Update eFC to be equal to the
received frame counter. Do not touch FC. When a frame other than
Enh-ACK is received, verify it against FC. Update both eFC and FC to
be equal to the received frame counter.
Check the global state in the radio when an ack frame is found before
reporting a transmit was completed. This change avoids the case where
an acknowledgment frame from another transmission is mistaken for our
acknowledgment frame.
- Check source address of packets from users
- Determine anycast address by MLE API for accuracy
- Replace anycast address with a valid unicast address when sending
with platform UDP in UDP layer
- Replace anycast address with a valid unicast address in IP layer
Fixing a few formatting things I should've caught when reviewing the
update to the BBB guide:
- The callouts should only have a single > on the first line
- The ### within a code block was causing issues with my import
script... easier to just change them to a single #
For 8.x.x, there is validation that joiner has the same keys as the
commissioner after commissioning, it should be configured with a
different master key before start commissioning.
This command allows an Rx-Off-When-Idle device to send an empty mac
data frame or mac datarequest to its parent. This command is only used
for certification.
This commit adds new helper functions under `Utils::CmdLineParser` to
parse a given ASCII string as different simple types, namely signed or
unsigned integers of different bit lengths (`uint8/16/32/64`, and
`int8/16/32`). The new functions validate that the parsed value fits
within the supported range of the expected int type. This commit also
adds different flavors of `ParseAsHexString()` to parse a hex string
into sequence of bytes (with fixed/known size or unknown size allowing
or disallowing truncation). It also moves the parse related methods
(like `ParseAsIp6Prefix`) from CLI modules in `CmdLineParser`.
The CLI modules are then updated to use the new `ParseAs{Type}`
functions simplifying the code and adding extra checks when parsing
the CLI input.
Finally, this commit adds a unit test `test_cmd_line_parser` verifying
the behavior of new `ParseAs{Type}()` functions.
Added language to show how to replace Connman with Network Manager to
enable the default setup scripts.
Added pointers on setting up a WiLink 8 module for Wi-Fi AP
development.
Removed explanation of downloading and flashing the BeagleBone image
in favor of linking to the public BeagleBone documentation.
Removed explanation of expanding and truncating the filesystem in
favor of using the helper tool from BeagleBone.
This commit adds new helper methods in `Message` class. It adds new
template methods to allow an object (of any type) to be read from or
written/appended/prepended to the message. The `Read<ObjectType>()`
method returns a parse `otError` if there are not enough bytes
remaining in the message to read the entire object.
The template methods are used in other core modules which help
simplify the code (there is no need to specify the template type since
it can be deduced by the complier from the passed-in argument). Also
since the template methods directly use the `sizeof` the object type,
they help reduce the chance of incorrect use (using incorrect
read/write length when calling the method).
This commit also updates and renames the methods which read/write raw
bytes from/to the message to `ReadBytes()`/`WriteBytes()`. The order
of parameters in these methods are changed to follow the common
pattern used by other modules and the OT public APIs (i.e., the
pointer to the buffer is given first, followed by its length).
This commit adds `LookupTable` module which provides helper methods to
perform binary search in a generic sorted lookup table for specific
entry matching a given name string. It also provides `constexpr`
methods to check (at build-time) whether a lookup table array is
sorted. This commit also updates CLI modules to use the `LookupTable`
methods for command lookup. It also adds a unit test for the lookup
table.
The end formatting on openthread.io will be different (many step lists
removed and some text shifted around).
Also updated the Style Guide to add a Contributor tag section.
This commit enhances Backbone Router to send BMLR.ntf on the backbone
link for Multicast Listeners.
- Send BMLR.ntf to the Backbone link
- Add Backbone test with packet verification
- Includes some revision to the Thread 1.2 Backbone CI scripts to make
it more stable
This commit also adds a template version of `OutputBytes()` which
accepts a reference array of a specific length. This helps simplify
the calls to this helper method where the array length can be
inferred. It also changes the code to use `OutputBytes()` for
outputting master key, pskc, xpanid, etc.
This commit contains a group of style fixes and smaller enhancements
in CLI modules:
- Remove unnecessary `struct` when declaring variable.
- Remove use of single `"%s"` in `Output` methods.
- Fix order of `#include` headers.
- Remove unnecessary use of `OT_UNUSED_VARIABLE`.
- Remove unnecessary temp variables and casts.
- Add comments to `#endif` directives than are more than than 20
lines away from the corresponding `#if` they are associated with.
- Configure next response to 5.00 for Reference Device
- Handle 5.00 (and other COAP error codes) in DUA.rsp (required by 1.2
Test Spec)
- Update DUA test to handle COAP code 5.00
This commit allows running packet verification on a test info (.json)
directly without running the test procedure, which can be helpful for
developing and debugging packet verification code.
This commit is the first part in link metrics. It implements single
probe function.
An overview of major changes:
- Add link metrics apis which allow apps to send a single probe and
set report callback.
- Add cli commands for calling link metrics api and related README
doc.
- Add a new module link_metrics to implement the query process and
handle the report.
- Add related tlv types.
- Add simple script test to run single probe process.
Thread 1.2 CI with OTBR and Backbone link:
- Run OTBR in Dockers with Backbone link
- Enhance node.py to work with OTBR Docker
- Add Packet Verification for 5.11.1
- incomplete, some steps can not pass yet, just to make sure
Backbone traffic verification works
- Support running multiple tests simultaneously (default: each test
run 3 instances)
- Build OTBR Docker using OpenThread PR code
- Upload code coverage in Docker
Some implementation details:
- Most existing code of node.py is shared by OTBR Docker
- Backbone related test scripts are found in
tests/scripts/thread-cert/backbone
- A new script tests/scripts/thread-cert/run_bbr_tests.py is added to
manage multiple running tests
- Test configuration differs according to PORT_OFFSET
- Backbone interface name: Backbone{PORT_OFFSET}
- Backbone network prefix: 91{PORT_OFFSET:02x}::/64
- Docker instance name: otbr_{PORT_OFFSET}_{nodeid}
- Output Files:
- Pcap:
- Thread: {test_name}_{PORT_OFFSET}.pcap
- Backbone: {test_name}_{PORT_OFFSET}_backbone.pcap
- Merged: {test_name}_{PORT_OFFSET}_merged.pcap
- Log: {test_name}_{PORT_OFFSET}.log
This commit runs Thread 1.1 certification tests with packet
verification for 1.2 build because Thread 1.2 certified devices are
supposed to be able to pass Thread 1.1 certification first.
Note: changes to test TOPOLOGY:
- Original: nodes use version=1.1 by default
- Now: nodes use version according to ENV, except explicitly specified
This commit adds macros `FreeMessage()`, 'FreeMessageOnError()' and
`FreeAndNullMessageOnError()` which would free a given `Message`
pointer if not `nullptr` (conditionally on an `otError`).
These macros implement small yet common code patterns used in many of
the core modules. They are intentionally defined as macros instead of
inline methods/functions to ensure that they are fully inlined. Note
that an `inline` method/function is not necessarily always inlined by
the toolchain, and not inlining such small implementations could add a
rather large code-size overhead.
Now that we have a process in place where openthread.io can source
documentation from GitHub, we need a documentation style guide to
ensure that the format of docs here on GitHub meet the format
requirements for hosting on openthread.io.
When no arguments are provided to script/test, the script prints $1:
unbound variable and exits without printing the usage
information. This is due to the set -u at the top.
This commit has a small fix so that this usage is presented with the
usage information. Also, it prints an error when it detect an unknown
command.
LogError() uses otLogWarnMeshCoP(), which was included by
thread/thread_netif.hpp -> meshcop/joiner.hpp -> common/logging.hpp.
thread_netif.hpp includes joiner.hpp only if OT_JOINER=ON, so the
build would fail if OT_JOINER=OFF.
This commit fixes the above.
A compile error can occur in the absence of LIBREADLINE. However the
error I got is confusing and doesn't indicate that because the options
dependencies are not good. I think the options' dependency and
relationship here should be:
- When DEAMON=0 (ot-cli, ot-ncp will be built and ot-cli depends on
console), CLI_TRANSPORT=CONSOLE MUST be used. And otherwise
(DEAMON=1), CLI_TRANSPORT=UART MUST be used. So when users build
posix, they don't need to consider the option CLI_TRANSPORT. It's
reasonable to add the evaluation for CLI_TRANSPORT in
Makefile-posix.
- When CLI_TRANSPORT=CONSOLE, (HAVE_LIBEDIT || HAVE_LIBREADLINE) MUST
be defined and DAEMON=0 MUST be satisfied. I think (HAVE_LIBEDIT ||
HAVE_LIBREADLINE) is a result of CLI_TRANSPORT instead of the
reason. The reason for CLI_TRANSPORT should be DEAMON. Now I set
CLI_TRANSPORT option based on DAEMON and make (HAVE_LIBEDIT ||
HAVE_LIBREADLINE) as a check for CLI_TRANSPORT=CONSOLE.
If READLINE lib is not found, in this implementation, there will be an
error indicating that it's not found.
This commit changes the CLI `Process{Cmd}()` handler methods to return
an `otError` (instead of outputting the result). This helps harmonize
the `Process{Cmd}()` handlers in different CLI modules. It also
enables the result of CLI command to be outputted from `ProcessLine()`
after the command is looked up in the table and the corresponding
`Process{Cmd}()` handler is invoked.
This commit also adds a new error code `OT_ERROR_PENDING`. This
special error code indicates the success or error status of an
operation is not yet known and is pending. This is then used by some
of the CLI `Process{Cmd}()` methods which perform an async operation,
e.g., `ProcessDiscover()` returns `OT_ERROR_PENDING` if the discover
scan starts successfully, and later the final result is outputted from
scan callback. The `OutputResult(aError)` method is changed to output
nothing if the error is `OT_ERROR_PENDING`.
This commit changes the unit tests `CMakeLists.txt` file to list
the targets in `set_target_properties()` call one per line. This
helps make it easier to read, also reduces the chance of merge
conflicts when new unit tests are added.
This commit includes a relatively minimal set of changes that are
required to allow the efr32 platforms to function with the newly
released Silabs Gecko SDK v3.0.
Change Log:
- Pull in definitions for halInitChipSpecific() and all child
functions from GSDK v2.7.
- These will be replaced with a more elegant solution in a future
commit.
- Switch to the mbedtls that is packaged with GSDK v3.0.
- Allow for mixed casing when specifying BOARD environment variable
If CSL Channel is never specified, the actual CSL channel should
always be the phy channel that the device is using. If CSL Channel
hasn't been specified and radio channel changes, the actual CSL
channel should also change. In current implementation, CSL Channel is
by default a valid value (not specified by upper layer) and wouldn't
change when radio channel changes even if it's never specified.
This commit fixes this issue. On CSL receiver, a bit is extracted from
mCslChannel to be used as a flag mIsCslChannelSpecified. If it is
false, mCslChannel would keep synchronized to the value of
mRadioChannel in Mac and Csl Channel TLV wouldn't be appended in Child
Update Request to its parent. On CSL transmitter, CSL channel info in
child is allowed to be 0. If it's 0, the channel info in frame would
be set using Mac::GetPanChannel.
This makes kill commands in pty checks run with sudo. Otherwise
ot-daemon won't be killed and has to exit by itself, which makes
posix-pty-daemon fail sometimes.
This commit contains a group of smaller enhancements in Cli modules:
- Add and use OutputLine() helper method which outputs a formatted
string line (appends newline \r\n).
- Use binary search when finding the command in sCommands array (also
adds static_assert check to ensure sCommands array is sorted).
- Define Command struct as a private nested type.
- Use enum constants (replacing #define).
- Rename method to OutputResult() (from AppendResult) to harmonize
with rest of a Output{Something}() methods.
- Remove comments at #endif when within 20 lines of #if
This commit simplifies the generation/processing of CoAP Options in a
CoAP message. It adds helper methods `ReadExtendedOptionField()`,
`WriteExtendedOptionField` to decode/encode extended Option Header
fields (Option Number Delta or Option Length). It simplifies
`Option::Iterator` (using `Init()`/`Advance()` to parse and iterate
through all CoAP Options in a message). Note that the public OT
`otCoap` APIs and their behavior remain as before and unchanged.
Fix test_router_attach.py failing by a small chance.
Root cause: routerdowngradethreshold restored back to default (23)
after node reset, so the test had 5/120 chance to downgrade. We should
set it back to 32 before starting it.
This commit also enhances the test for a little bit:
- Make sure the node reattached as Router within 1 second
- Make sure the node does not downgrade after Router Selection Jitter
(3s)
This commit updates the logging in `Mle` modules by adding two
enumerations `MessageAction` and `MessageType` to indicate the action
(send, receive, delay, etc.) and the message type in the updated
`Log()` methods.
In current Mac::Frame implementation, when the frame is a Mac command,
the CommandId is always not included as its private payload, which
means we won't encrypt the CommandId.
In most cases the Private Payload(things we need to encrypt) shall be
set to the MAC Payload field(For Mac cmd, this field includes
CommandId, shown in Figure 7-17) and the Open Payload shall be
empty. The only 2 exception cases are listed in Table 9-1.
So for Mac command with version >= 2, its CommandId should be included
in Private Payload and should be encrypted when necessary. For Mac
command with version < 2, CommandId should be in included in Open
Payload and shouldn't be encrypted.
This commit fixes this problem and adds unit tests for this.
Consider such a case:
- The CSL transmitter has a buffered message for a CSL receiver and
has scheduled that tx.
- Before the CSL transmitter actually sends it, the receiver sends a
data request.
- The CSL transmitter immediately sends the buffered message to the
receiver.
- The scheduled time comes.
In current CSL implementation, though the buffered message has been
sent through indirect tx, when the origin CSL tx time comes, it would
send another 'empty frame' due to the missing of check and the
implementation of IndirectSender::PrepareFrameForChild. This commit
adds the check for this case and avoid to send the meaningless empty
frame.
This commit add support for a custom PDM (Persistent Data Manager)
which is also used inside Project CHIP.
Signed-off-by: Doru Gucea <doru-cristian.gucea@nxp.com>
This commit declares MLE `Header` as a `private` nested type of `Mle`
class. It also moves the `Command` enumeration definition into the
`Mle` class (from `Header`).
This replaces the usage of std::numeric_limits with C macro
UINT32_MAX. Removes the dependency of C++ header limits, which isn't
available on some platforms.
This commit contains a group of smaller changes/renames in `Coap`
modules:
- Add enumeration (c++ style) constants for CoAP `Type` and `Code`
and `OptionType`.
- Add helpers `Message::Is{Method}Request()` e.g., `IsPostRequest()`
- Define Thread URI Paths (in `uri_paths.hpp/cpp`) as char array.
- Add helper method in `Coap::Message` for common initializations
e.g., `InitAsConfirmablePost()`.
- Add helper methods for common `Coap:Message` type and code checks
e.g., `IsConfirmablePost()`.
- Re-define `OT_COAP_TYPE` values to use 2-bit unsigned int values
(per RFC-7252).
This commit adds `Checksum` class which implements IP checksum
calculation and verification (all related code from other modules is
now moved to `Checksum` class). The new checksum calculation allows
any message chunk size (removes a limitation with previous model
of requiring even sized chunks). This commit also adds a unit test
`test_checksum` covering the behavior of `Checksum` methods.
This commit relaxes the assert checks when parsing raw-link frame from
the radio tx-done callback to update the security frame counter. In an
FTD/MTD build, if/when raw-link is enabled, the `TxFrame` is prepared
and given by user and may not necessarily follow 15.4 frame format
(raw-link can be used with vendor-specific format), so we allow
failure when parsing the frame. In other cases (in an RCP build or in
an FTD/MTD build without raw-link) since the `TxFrame` should be
prepared by OpenThread core, we expect no error and therefore assert
if parsing fails.
This commit changes TimeMicro::kMaxDuration to Time::kMaxDuration
because in posix OPENTHREAD_CONFIG_PLATFORM_USEC_TIMER_ENABLE is not
set and TimeMicro is not defined.
And in this context, the intent is just to set the variable to a
maximum value.
This commit simplifies the logging in `Mle` modules. It renames and
simplifies the existing MLE logging methods. They are now defined as
`static` methods and the main implementation uses `#if` guards
checking the proper log level (when logs are not enabled they are
defined as empty inline methods).
This commit also adds new helper methods to log failure of sending or
processing of an MLE message, namely `Mle::LogSendError()` and
`Mle::LogProcessError()`. These are then used to simplify logging in
many methods in `Mle` and other related modules.
This commit adds a new parameter to `Ip6::ProcessReceiveCallback()`
allowing caller to indicate whether the method can take custody of the
passed-in message or whether it needs to make a copy of it (to use in
receive callback). This is indicated by a new `enum` definition
`Message::Ownership`. In case of `kTakeCustody` value, the caller
transfers custody of message to the called method (i.e. the method can
`Enqueue()` the message and would need to `Free()` the message when no
longer needed).
The `Ip6::HandleDatagram()` uses this to avoid copying the message in
cases where it is not needed (e.g. for a message that is passed to
host through callback but does not need to be processed by Thread
core).
This commit includes several enhancements to pktverify
- Add more fields of thread_meshcop and thread_address layers
- Remove COAP TLV manual parsing for now since it's not correctly
implemented
- Fix 5.5.2 which had already been using p.coap.tlv.status,
p.coap.tlv.rloc16, ...
Currently script/test can only build 1.2 together with 1.1. This
commit adds support to build 1.2 alone. And when THREAD_VERSION=1.2
and INTER_OP=1 are both set, both versions would be built. Sometimes
we only want to build 1.2. This would save some time for us.
This commit adds a option to debug CSL feature. When the option is
turned on, a CSL receiver wouldn't actually sleep so that it could
receive all packets from its parent and know the tx time.
This change allows `CopyTo()` method to be used to copy bytes backwards
within the same message (i.e., src and dest messages are the same and
the dest offset is before src offset). Unit test `test_message` is
updated in this commit to cover such a use.
However, the `CopyTo()` implementing can still potentially overwrite
the data when bytes are being copied forward within the same message.
This commit adds an assert not allowing such a use and updates the
method documentation mentioning this restriction.
This commit updates `Message::CopyTo()` method to use data chunks
(this copies data directly from the source message to the destination
avoiding the need for an extra buffer copy). It also addresses an
issue where if the requested copy length is more than the available
bytes in the source message, incorrect bytes may be copied into the
destination message, and the returned value (i.e. number of bytes
copied) can be invalid.
This commit also updates the unit test `test_message` covering
behavior of `CopyTo()` for different offsets and copy lengths. It also
checks the behavior of `Read()` when the read length goes beyond the
end of the message (trying to read more bytes than available in the
message).
This commit changes `Message::Write()` to return `void` instead of
returning the number of bytes written. The `Write()` method does not
resize the message and requires that the given data can be fully
written into the message within its existing length. The `Write()`
already contains an `OT_ASSERT()` to verify this.
This commit also removes the redundant `OT_ASSERT()` checks in few
places where `Write()` method's returned value was being used.
This commit adds the Multicast Listener Table for BBR:
- Implements Multicast Listener Table on BBR
- Adds registered MAs to MulticastListenerTable
- Reject when the table is full or the multicast address is invalid
and return failed status
- Respond with unsuccessful status along with failed addresses
- Expire Listeners from MulticastListenerTable per second (using
MinHeap for better performance)
- MLR enhancement
- Re-register only failed multicast addresses (used to register all
registering multicast addresses)
- Reference Device only APIs
- Some APIs are defined for reference devices and tests.
- Add tests
- Add unit test: test_multicast_listener_table.cpp (runs for 1.2-bbr
only)
- Add functional tests
This commit adds one test to verify that if a node subscribed MAs when
there is no PBBR in the network, it should still be able to send
MLR.req after PBBR is enabled.
This is a case that wasn't tested in existing tests.
With Thread 1.2, it is possible to receive an Enh-ACK with security
enabled. This commit:
- Move receive AES CCM related code to Frame class.
- Verify received Enh-ACK in Mac layer. If MIC check failed, the
transmitted frame will be marked as OT_ERROR_NO_ACK.
To enable CSL, it is necessary to get received Enh-ACK timestamp so
that the next sample time could be calculated with this timestamp and
CSL phase in CSL IE.
This commit removes the config setting
OPENTHREAD_CONFIG_MAC_CSL_RECEIVER_ENABLE automatically when it's 1.2
and MTD. The reason is that it's in core config and it's also used in
platform (radio) which cannot access core config.
If CSL_RECEIVER is not set in options in cmake and it's 1.2, then in
core config, OPENTHREAD_CONFIG_MAC_CSL_RECEIVER_ENABLE would be turned
on if it's MTD. While in platform, it's not turned on. And then there
would be a link issue.
A SSED uses the Child Update Request to start CSL synchronization. If
the CSL Channel TLV is not present in the message, the parent assigns
the Thread Network channel as the CSL channel for this child during
the attachment.
However, it may happen that a child changes its CSL channel to a
different one with a Child Update Request and decides to keep using
it. In a subsequent Child Update Request it could omit the CSL Channel
TLV (no changes) but the parent would change its CSL channel to the
Thread Network channel. This commit avoids that.
The `Message` data is stored in a sequence of linked-listed `Buffer`
instances. When reading or writing data in the `Message`, the internal
implementation iterates over the `Buffer` list and updates the data in
chunks. This commit adds two helper methods `GetFirstChunk()` and
`GetNextChunk()` to get first/next data chunk (contiguous buffer)
corresponding to a given offset and length into the message. These
helper methods are then used to simplify `Read()`, `Write()`, and
`UpdateChecksum()` methods. The unit test `test_message` is also
updated to verify reading and writing data at different offsets and
lengths.
This commit adds `TimeTicker` class which emits periodic ticks (with
one second period interval) to a set of registered tick receiver
modules. The `TimeTicker` would invoke `HandleTimeTick()` method
periodically on the registered receiver objects.
The `TimeTicker` model helps simplify the implementation of many
modules (such as `MeshForwarder`, `MleRoutuer`, `AddressResolver`,
`Ip6`, `DuaManager`, etc) which require periodic update/check of some
state (avoid each class using its own timer).
OT_CONFIG was used to specify a customized OpenThread core config file
which is only included by OpenThread core library. This commit changes
the behavior so that it specifies the OPENTHREAD_CONFIG_FILE which is
used by all components of OpenThread including the core library.
This commit contain a list of smaller enhancements in `Ip6` modules:
- Simplify `Ip6::Header` removing the PoD definition and providing
`enum` constants for the byte offset to different fields in the header
(replacing/removing static methods).
- Declare some of the `Ip6` methods as `private`.
- Remove error logs (not used/applicable anymore).
- Simplify checking of `destPort` in `ProcessReceiveCallback()`.
- Specify `int` size of `enum` definitions (declare internally-used
`enum`s a `private`).
- Add unit test `TestIp6Header()`.
This commit implements the CSL feature in Thread 1.2.
- Add macro definitions for low power to control the compiling of
source code.
- Add data and methods for running CSL in Mac and SubMac. This mainly
includes setting CSL parameters, starting/stopping CSL, and the
timer handling process.
- Add otPlatTimeGetAPI and implementation.
- Add CSL transmission implementation. CSL transmission is a new kind
of transmission, the related definition and implementaion for the
whole transmitting process is added.
- Add calling of start/stop CSL in certain cases.
- Implement CSL synchronization maintainence. If a CSL cordinator
didn't get a frame containing CSL IE for CSLTimeout, the CSL
receiver is regarded as de-synchronized.
- Add Cli interface for using CSL.
- Implement enhanced Ack with IE. The original code can only generate
auto ack for Imm-Ack. As CSL requires CSL IE included in enhanced
ack. This PR implements it.
- Add basic functional test for CSL transmission. More tests
corresponding to test plan would be added later.
GitHub Issues are for bugs and feature requests. To make bugs and feature requests more easy to find and organize, we close issues that are deemed out of scope for GitHub Issues.
The openthread-users Google Group is the recommended place for users to discuss OpenThread and interact directly with the OpenThread community. https://groups.google.com/forum/#!forum/openthread-users
OpenThread GitHub Discussions is the recommended place for users to discuss OpenThread and interact directly with the OpenThread community. https://github.com/openthread/openthread/discussions
@@ -62,7 +63,7 @@ For each new feature, create a working branch:
```bash
# Create a working branch for your new feature
git branch --track <branch-name> origin/master
git branch --track <branch-name> origin/main
# Checkout the branch
git checkout <branch-name>
@@ -84,16 +85,16 @@ This will open up a text editor where you can craft your commit message.
Prior to submitting your pull request, you might want to do a few things to clean up your branch and make it as simple as possible for the original repo's maintainer to test, accept, and merge your work.
If any commits have been made to the upstream master branch, you should rebase your development branch so that merging it will be a simple fast-forward that won't require any conflict resolution work.
If any commits have been made to the upstream main branch, you should rebase your development branch so that merging it will be a simple fast-forward that won't require any conflict resolution work.
```bash
# Fetch upstream master and merge with your repo's master branch
git checkout master
git pull upstream master
# Fetch upstream main and merge with your repo's main branch
git checkout main
git pull upstream main
# If there were any new commits, rebase your development branch
git checkout <branch-name>
git rebase master
git rebase main
```
Now, it may be desirable to squash some of your smaller commits down into a small number of larger more cohesive commits. You can do this with an interactive rebase:
@@ -101,14 +102,14 @@ Now, it may be desirable to squash some of your smaller commits down into a smal
```bash
# Rebase all commits on your development branch
git checkout
git rebase -i master
git rebase -i main
```
This will open up a text editor where you can specify which commits to squash.
#### Coding Conventions and Style
OpenThread uses and enforces the [OpenThread Coding Conventions and Style](STYLE_GUIDE.md) on all code, except for code located in [third_party](third_party). Use `script/make-pretty` and `script/make-pretty check` to automatically reformat code and check for code-style compliance, respectively. OpenThread currently requires [clang-format v6.0.0](http://releases.llvm.org/download.html#6.0.0) for C/C++ and [yapf v0.29.0](https://github.com/google/yapf) for Python.
OpenThread uses and enforces the [OpenThread Coding Conventions and Style](STYLE_GUIDE.md) on all code, except for code located in [third_party](third_party). Use `script/make-pretty` and `script/make-pretty check` to automatically reformat code and check for code-style compliance, respectively. OpenThread currently requires [clang-format v9.0.0](https://releases.llvm.org/download.html#9.0.0) for C/C++ and [yapf v0.31.0](https://github.com/google/yapf) for Python.
As part of the cleanup process, you should also run `script/make-pretty check` to ensure that your code passes the baseline code style checks.
@@ -127,3 +128,61 @@ This will trigger continuous-integration checks using GitHub Actions. You can vi
#### Submit Pull Request
Once you've validated that all continuous-integration checks have passed, go to the page for your fork on GitHub, select your development branch, and click the pull request button. If you need to make any adjustments to your pull request, just push the updates to GitHub. Your pull request will automatically track the changes on your development branch and update.
#### Checks fail
Once you've submitted a pull request, all continuous-integration checks are triggered again. If some of these checks fail, it could be either problems with the pull request or an intermittent failure of some test cases. For more information on the failure, check the output and download artifacts. (After all jobs in one group are completed, an `Artifacts` button appears beside the `Re-run` jobs button.) If the failure is intermittent, the check will usually pass after rerunning once or twice.
We want to eliminate intermittent failures as well, so when you experience such a failure, please log an issue and attach any relevant artifacts. If the artifacts are too big, provide the link of the failed run (do not rerun checks again, or it will be overwritten). Alternatively, upload the artifacts to a file-sharing service like Google Drive and share a link to it.
##### Analyze core dumps in failed checks
For some checks, core dumps for crashed programs are uploaded as artifacts in a failed check. Besides core dumps, binaries and shared libraries are also uploaded so that we can analyze the dumps locally. To analyze the dumps, download the artifact `core-xxx` and unzip it. The package is in the following format:
```
|-- build
| `-- cmake
| `-- openthread-simulation-1.2
| `-- examples
| `-- apps
| `-- cli
| |-- ot-cli-ftd
| `-- ot-cli-mtd
|-- ot-core-dump
| `-- corefile-ot-cli-ftd-11323-1606274703
`-- so-lib
|-- ld-linux-x86-64.so.2
|-- libc.so.6
`-- libgcc_s.so.1
```
Once unzipped:
1.`cd` to the unzipped directory
2. Run `gdb build/cmake/openthread-simulation-1.2/examples/apps/cli/ot-cli-ftd ./ot-core-dump/corefile-ot-cli-ftd-XXX`.
3. Set the absolute path of `so-lib`. In gdb, run `set solib-absolute-prefix /ABSOLUTE/PATH/TO/so-lib/`, then run `set solib-search-path /ABSOLUTE/PATH/TO/so-lib/`.
4. In gdb, run `backtrace` or `bt`. Then you should see the stack of the crashed program. Find and fix the problem!
## Contributing Documentation
Documentation undergoes the same review process as code and contributions may be mirrored on our [openthread.io](https://openthread.io) website.
### Codelabs and Guides
To review and contribute to OpenThread Codelabs and Guides, refer to the following GitHub repositories:
For information on how to author and format documentation for contribution, refer to the [Documentation Style Guide](https://github.com/openthread/ot-docs/blob/main/STYLE_GUIDE.md).
### API Reference topics
API Reference topics use [Doxygen comment blocks](https://www.doxygen.nl/manual/docblocks.html) to render the HTML output on [https://openthread.io/reference](https://openthread.io/reference). OpenThread scripts support the following Doxygen [special commands](https://www.doxygen.nl/manual/commands.html):
-@file
-@brief
-@param
-@returns
You can find most of these comments in the [OpenThread header files](https://github.com/openthread/openthread/tree/main/include/openthread). To review an example, refer to [`border_agent.h`](https://github.com/openthread/openthread/tree/main/include/openthread/border_agent.h). The Doxygen comments in `border_agent.h` output the [Border Agent](https://openthread.io/reference/group/api-border-agent) reference topic on openthread.io. For more information, refer to [Comments](https://github.com/openthread/openthread/blob/main/STYLE_GUIDE.md#comments) in the OpenThread Coding Conventions and Style guide.
OpenThread released by Google is... <a href="http://threadgroup.org/technology/ourtechnology#certifiedproducts"> <img src="https://cdn.rawgit.com/openthread/openthread/ab4c4e1e/doc/images/certified.svg" alt="Thread Certified Component" width="150px" align="right"> </a>
OpenThread released by Google is... <a href="https://www.threadgroup.org/What-is-Thread/Thread-Benefits#certifiedproducts"> <img src="https://cdn.rawgit.com/openthread/openthread/ab4c4e1e/doc/images/certified.svg" alt="Thread Certified Component" width="150px" align="right"> </a>
**...an open-source implementation of the [Thread](http://threadgroup.org/technology/ourtechnology) networking protocol.** Google Nest has released OpenThread to make the technology used in Nest products more broadly available to developers to accelerate the development of products for the connected home.
**...an open-source implementation of the [Thread](https://www.threadgroup.org/What-is-Thread/Overview) networking protocol.** Google Nest has released OpenThread to make the technology used in Nest products more broadly available to developers to accelerate the development of products for the connected home.
**...OS and platform agnostic**, with a narrow platform abstraction layer and a small memory footprint, making it highly portable. It supports both system-on-chip (SoC) and network co-processor (NCP) designs.
**...a Thread Certified Component**, implementing all features defined in the [Thread 1.1.1 specification](http://threadgroup.org/technology/ourtechnology#specifications), including all Thread networking layers (IPv6, 6LoWPAN, IEEE 802.15.4 with MAC security, Mesh Link Establishment, Mesh Routing) and device roles, as well as [Border Router](https://github.com/openthread/ot-br-posix) support.
**...a Thread Certified Component**, implementing all features defined in the [Thread 1.2 specification](https://www.threadgroup.org/support#specifications), including all Thread networking layers (IPv6, 6LoWPAN, IEEE 802.15.4 with MAC security, Mesh Link Establishment, Mesh Routing) and device roles, as well as [Border Router](https://github.com/openthread/ot-br-posix) support.
More information about Thread can be found at [threadgroup.org](http://threadgroup.org/). Thread is a registered trademark of the Thread Group, Inc.
@@ -51,9 +50,9 @@ If you're interested in contributing to OpenThread, read on.
# Contributing
We would love for you to contribute to OpenThread and help make it even better than it is today! See our [Contributing Guidelines](https://github.com/openthread/openthread/blob/master/CONTRIBUTING.md) for more information.
We would love for you to contribute to OpenThread and help make it even better than it is today! See our [Contributing Guidelines](https://github.com/openthread/openthread/blob/main/CONTRIBUTING.md) for more information.
Contributors are required to abide by our [Code of Conduct](https://github.com/openthread/openthread/blob/master/CODE_OF_CONDUCT.md) and [Coding Conventions and Style Guide](https://github.com/openthread/openthread/blob/master/STYLE_GUIDE.md).
Contributors are required to abide by our [Code of Conduct](https://github.com/openthread/openthread/blob/main/CODE_OF_CONDUCT.md) and [Coding Conventions and Style Guide](https://github.com/openthread/openthread/blob/main/STYLE_GUIDE.md).
# Versioning
@@ -61,16 +60,13 @@ OpenThread follows the [Semantic Versioning guidelines](http://semver.org/) for
# License
OpenThread is released under the [BSD 3-Clause license](https://github.com/openthread/openthread/blob/master/LICENSE). See the [`LICENSE`](https://github.com/openthread/openthread/blob/master/LICENSE) file for more information.
OpenThread is released under the [BSD 3-Clause license](https://github.com/openthread/openthread/blob/main/LICENSE). See the [`LICENSE`](https://github.com/openthread/openthread/blob/main/LICENSE) file for more information.
Please only use the OpenThread name and marks when accurately referencing this software distribution. Do not use the marks in a way that suggests you are endorsed by or otherwise affiliated with Nest, Google, or The Thread Group.
# Need help?
There are numerous avenues for OpenThread support:
OpenThread support is available on GitHub:
- Bugs and feature requests — [submit to the Issue Tracker](https://github.com/openthread/openthread/issues)
-Stack Overflow — [post questions using the `openthread` tag](http://stackoverflow.com/questions/tagged/openthread)
- Google Groups — [discussion and announcements at openthread-users](https://groups.google.com/forum/#!forum/openthread-users)
The openthread-users Google Group is the recommended place for users to discuss OpenThread and interact directly with the OpenThread team.
-Community Discussion - [ask questions, share ideas, and engage with other community members](https://github.com/openthread/openthread/discussions)
- OpenThread uses `script/make-pretty` to reformat code and enforce code format and style. `script/make-pretty check` build target is included in OpenThread's continuous integration and must pass before a pull request is merged.
-`script/make-pretty` requires [clang-format v6.0.0](http://releases.llvm.org/download.html#6.0.0) for C/C++ and [yapf v0.29.0](https://github.com/google/yapf) for Python.
-`script/make-pretty` requires [clang-format v9.0.0](https://releases.llvm.org/download.html#9.0.0) for C/C++ and [yapf v0.31.0](https://github.com/google/yapf) for Python.
### File Names
@@ -176,6 +176,14 @@
- Describes the purpose, function, and influence of each parameter as well as whether it is an input, an output, or both.
- Describes the return value, if present, and the expected range or constraints of it.
If your description is longer than 120 characters, continue the comment on the next line:
```
* @brief
* Records the history of different events, for example RX and TX messages or network info changes. All tracked
* entries are timestamped.
```
# Python
## Standards
@@ -188,4 +196,4 @@
## Format and Style
- All code should adhere to [Google Python Style Guide](http://google.github.io/styleguide/pyguide.html) except maximum line length being 119.
- All code should adhere to [Google Python Style Guide](https://google.github.io/styleguide/pyguide.html) except maximum line length being 119.
AM_CONDITIONAL([OPENTHREAD_EXAMPLES_NRF528XX], [test OPENTHREAD_EXAMPLES_NRF52811 || test OPENTHREAD_EXAMPLES_NRF52833 || test OPENTHREAD_EXAMPLES_NRF52840])
case ${with_examples} in
no)
AC_MSG_RESULT([no])
@@ -840,12 +845,11 @@ AC_MSG_CHECKING([whether to build platform libraries])
AC_ARG_WITH(platform,
[AS_HELP_STRING([--with-platform=TARGET],
[Build OpenThread platform libraries for one of: cc1352, cc2538, cc2650, cc2652,
AM_CONDITIONAL([OPENTHREAD_PLATFORM_NRF528XX], [test OPENTHREAD_PLATFORM_NRF52811 || test OPENTHREAD_PLATFORM_NRF52833 || test OPENTHREAD_PLATFORM_NRF52840])
AM_CONDITIONAL([OPENTHREAD_PLATFORM_K32W], [test OPENTHREAD_PLATFORM_K32W061 || test OPENTHREAD_PLATFORM_JN5189])
<td width="25%" style="background-color:rgb(238, 241, 242)"><b>Details</b></td><td><ul><li>Used to discover neighbors, configure links, and exchange routing information</li><li>Not a routable address</li><li>Always has a prefix of <code>fe80::/16</code></li></ul></td>
<td colspan=2 style="background-color:rgb(238, 241, 242)">An EID that identifies a Thread interface, independent of network topology. Used to reach a Thread interface within the same Thread partition. Also called a Unique Local Address (ULA).</td>
<td width="25%" style="background-color:rgb(238, 241, 242)"><b>Details</b></td><td><ul><li>Does not change as the topology changes</li><li>Should be used by applications</li><li>Always has a prefix <code>fd00::/8</code></li></ul></td>
<td width="25%" style="background-color:rgb(238, 241, 242)"><b>Details</b></td><td><ul><li>Generated once a device attaches to a network</li><li>For delivering IPv6 datagrams within a Thread network</li><li>Changes as the topology changes</li><li>Generally not used by applications</li></ul></td>
<td colspan=2 style="background-color:rgb(238, 241, 242)">Identifies a Thread interface via RLOC lookup, when the RLOC of a destination is not known.</td>
<td width="25%" style="background-color:rgb(238, 241, 242)"><b>Details</b></td><td><ul><li><code>fc<var>XX</var></code> = <a href="#anycast">ALOC destination</a>, which looks up the appropriate RLOC</li><li>Generally not used by applications</li></td>
<td width="25%" style="background-color:rgb(238, 241, 242)"><b>IID</b></td><td><ul><li>SLAAC — Randomly assigned by the device itself</li><li>DHCP — Assigned by a DHCPv6 server</li><li>Manual — Assigned by the application layer</li></ul></td>
<td width="25%" style="background-color:rgb(238, 241, 242)"><b>Details</b></td><td><ul><li>A public IPv6 address</li><li>Always has a prefix of <code>2000::/3</code></li></td>
</tr>
</tbody>
</table>
## Multicast
Multicast is used to communicate information to multiple devices at once. In a
Thread network, specific addresses are reserved for multicast use with different
groups of devices, depending on the scope.
| IPv6 Address | Scope | Delivered to |
| ------------ | ---------- | ----------------- |
| `ff02::1` | Link-Local | All FTDs and MEDs |
| `ff02::2` | Link-Local | All FTDs |
| `ff03::1` | Mesh-Local | All FTDs and MEDs |
| `ff03::2` | Mesh-Local | All FTDs |
Key Point: A major difference between FTDs and MTDs are that FTDs subscribe to
the `ff03::2` multicast address. MTDs do not.
You might notice that Sleepy End Devices (SEDs) are not included as a
recipient in the multicast table above. Instead, Thread defines
link-local and realm-local scope unicast prefix-based IPv6 multicast
address used for All Thread Nodes, including SEDs. These multicast
addresses vary by Thread network, because it is built on the unicast
Mesh-Local prefix (see [RFC 3306](https://tools.ietf.org/html/rfc3306)
for more details on unicast-prefix-based IPv6 multicast addresses).
Arbitrary scopes beyond those already listed are also supported for Thread
devices.
## Anycast
Anycast is used to route traffic to a Thread interface when the RLOC of a
destination is not known. An Anycast Locator (ALOC) identifies the location of
multiple interfaces within a Thread partition. The last 16 bits of an ALOC,
called the ALOC16, is in the format of <code>0xfc<var>XX</var></code>, which
represents the type of ALOC.
For example, an ALOC16 between `0xfc01` and `0xfc0f` is reserved for DHCPv6
Agents. If the specific DHCPv6 Agent RLOC is unknown (perhaps because the
network topology has changed), a message can be sent to a DHCPv6 Agent ALOC to
$(error Cannot use MBEDTLS_THREADING with CC310 support. CC310 library comes with built-in threading support. To disable CC310 please use DISABLE_BUILTIN_MBEDTLS=0)
OpenThread allows you to [configure](https://openthread.io/guides/build#configuration) the stack for different functionality and behavior. This configuration is based on changing compile-time constants during the build process using common switches listed in `/examples/common-switches.mk`.
This page lists the available common switches with description. Unless stated otherwise, the switches are set to 0 by default. For build command examples, see [build examples](https://openthread.io/guides/build#build_examples).
| BIG_ENDIAN | OT_BIG_ENDIAN | Allows the host platform to use big-endian byte order. |
| BORDER_AGENT | OT_BORDER_AGENT | Enables support for border agent. In most cases, enable this switch if you are building On-mesh Commissioner or Border Router with External Commissioning support. |
| BORDER_ROUTER | OT_BORDER_ROUTER | Enables support for Border Router. This switch is usually combined with the BORDER_AGENT and UDP_FORWARD (or PLATFORM_UDP in case of RCP design) switches to build Border Router device. |
| BORDER_ROUTING | OT_BORDER_ROUTING | Enables bi-directional border routing between Thread and Infrastructure networks for Border Router. |
| BORDER_ROUTING_NAT64 | OT_BORDER_ROUTING_NAT64 | Enables NAT64 border routing support for Border Router. |
| BUILTIN_MBEDTLS_MANAGEMENT | OT_BUILTIN_MBEDTLS_MANAGEMENT | Enables the built-in mbedTLS management. Enable this switch if the external mbedTLS is used, but mbedTLS memory allocation and debug config should be managed internally by OpenThread. |
| CHANNEL_MANAGER | OT_CHANNEL_MANAGER | Enables support for channel manager. Enable this switch on devices that are supposed to request a Thread network channel change. This switch should be used only with an FTD build. |
| CHANNEL_MONITOR | OT_CHANNEL_MONITOR | Enables support for channel monitor. Enable this switch on devices that are supposed to determine the cleaner channels. |
| CHILD_SUPERVISION | OT_CHILD_SUPERVISION | Enables support for [child supervision](https://openthread.io/guides/build/features/child-supervision). Enable this switch on a parent or child node with custom OpenThread application that manages the supervision, checks timeout intervals, and verifies connectivity between parent and child. |
| COAP | OT_COAP | Enables support for the CoAP API. Enable this switch if you want to control Constrained Application Protocol communication. |
| COAP_OBSERVE | OT_COAP_OBSERVE | Enables support for CoAP Observe (RFC7641) API. |
| COAPS | OT_COAPS | Enables support for the secure CoAP API. Enable this switch if you want to control Constrained Application Protocol Secure (CoAP over DTLS) communication. |
| COMMISSIONER | OT_COMMISSIONER | Enables support for Commissioner. Enable this switch on device that is able to perform Commissioner role. |
| COVERAGE | OT_COVERAGE | Enables the generation of code-coverage instances. |
| DEBUG | not implemented | Allows building debug instance. Code optimization is disabled. |
| DHCP6_CLIENT | OT_DHCP6_CLIENT | Enables support for the DHCP6 client. The device is able to act as typical DHCP client. Enable this switch on a device that is supposed to request networking parameters from the DHCP server. |
| DHCP6_SERVER | OT_DHCP6_SERVER | Enables support for the DHCP6 server. The device is able to act as typical DHCP server. Enable this switch on a device that is supposed to provide networking parameters to devices with DHCP_CLIENT switch enabled. |
| DIAGNOSTIC | OT_DIAGNOSTIC | Enables diagnostic support. Enable this switch on a device that is tested in the factory production stage. |
| DISABLE_BUILTIN_MBEDTLS | not implemented | Disables OpenThread's mbedTLS build. Enable this switch if you do not want to use the built-in mbedTLS and you do not want to manage mbedTLS internally. Enabling this switch will disable support for such features as memory allocation and debug. |
| DISABLE_DOC | not implemented | Disables building of the documentation. |
| DISABLE_EXECUTABLE | not implemented | Disables building of executables. |
| DISABLE_TOOLS | not implemented | Disables building of tools. |
| DEBUG_UART | not implemented | Enables the Debug UART platform feature. |
| DEBUG_UART_LOG | not implemented | Enables the log output for the debug UART. Requires OPENTHREAD_CONFIG_ENABLE_DEBUG_UART to be enabled. |
| DNS_CLIENT | OT_DNS_CLIENT | Enables support for DNS client. Enable this switch on a device that sends a DNS query for AAAA (IPv6) record. |
| DNS_DSO | OT_DNS_DSO | Enables support for DNS Stateful Operations (DSO). |
| DNSSD_SERVER | OT_DNSSD_SERVER | Enables support for DNS-SD server. DNS-SD server use service information from local SRP server to resolve DNS-SD query questions. |
| DUA | OT_DUA | Enables the Domain Unicast Address feature for Thread 1.2. |
| DYNAMIC_LOG_LEVEL | not implemented | Enables the dynamic log level feature. Enable this switch if OpenThread log level is required to be set at runtime. See [Logging guide](https://openthread.io/guides/build/logs) to learn more. |
| ECDSA | OT_ECDSA | Enables support for Elliptic Curve Digital Signature Algorithm. Enable this switch if ECDSA digital signature is used by application. |
| EXCLUDE_TCPLP_LIB | OT_EXCLUDE_TCPLP_LIB | Exclude TCPlp library from the build. |
| EXTERNAL_HEAP | OT_EXTERNAL_HEAP | Enables support for external heap. Enable this switch if the platform uses its own heap. Make sure to specify the external heap Calloc and Free functions to be used by the OpenThread stack. |
| FULL_LOGS | OT_FULL_LOGS | Enables all log levels and regions. This switch sets the log level to OT_LOG_LEVEL_DEBG and turns on all region flags. See [Logging guide](https://openthread.io/guides/build/logs) to learn more. |
| HISTORY_TRACKER | OT_HISTORY_TRACKER | Enables support for History Tracker. |
| IP6_FRAGM | OT_IP6_FRAGM | Enables support for IPv6 fragmentation. |
| JAM_DETECTION | OT_JAM_DETECTION | Enables support for [Jam Detection](https://openthread.io/guides/build/features/jam-detection). Enable this switch if a device requires the ability to detect signal jamming on a specific channel. |
| JOINER | OT_JOINER | Enables [support for Joiner](https://openthread.io/reference/group/api-joiner). Enable this switch on a device that has to be commissioned to join the network. |
| LEGACY | OT_LEGACY | Enables support for legacy network. |
| LINK_RAW | OT_LINK_RAW | Enables the Link Raw service. |
| LOG_OUTPUT | not implemented | Defines if the LOG output is to be created and where it goes. There are several options available: `NONE`, `DEBUG_UART`, `APP`, `PLATFORM_DEFINED` (default). See [Logging guide](https://openthread.io/guides/build/logs) to learn more. |
| MAC_FILTER | OT_MAC_FILTER | Enables support for the MAC filter. |
| MLE_LONG_ROUTES | OT_MLE_LONG_ROUTES | Enables the MLE long routes extension. **Note: Enabling this feature breaks conformance to the Thread Specification.** |
| NETDATA_PUBLISHER | OT_NETDATA_PUBLISHER | Enables support for Thread Network Data publisher. |
| PING_SENDER | OT_PING_SENDER | Enables support for ping sender. |
| OTNS | OT_OTNS | Enables support for [OpenThread Network Simulator](https://github.com/openthread/ot-ns). Enable this switch if you are building OpenThread for OpenThread Network Simulator. |
| REFERENCE_DEVICE | OT_REFERENCE_DEVICE | Enables support for Thread Test Harness reference device. Enable this switch on the reference device during certification. |
| SERVICE | OT_SERVICE | Enables support for injecting Service entries into the Thread Network Data. |
| SLAAC | OT_SLAAC | Enables support for adding auto-configured SLAAC addresses by OpenThread. This feature is enabled by default. |
| SNTP_CLIENT | OT_SNTP_CLIENT | Enables support for SNTP Client. |
| SPINEL_ENCRYPTER_LIBS | not implemented | Specifies library files (absolute paths) for implementing the NCP Spinel Encrypter. |
| SRP_CLIENT | OT_SRP_CLIENT | Enable support for SRP client. |
| SRP_SERVER | OT_SRP_SERVER | Enable support for SRP server. |
| THREAD_VERSION | OT_THREAD_VERSION | Enables the chosen Thread version (1.1 / 1.2 (default)). For example, set to `1.1` for Thread 1.1. |
| TIME_SYNC | OT_TIME_SYNC | Enables the time synchronization service feature. **Note: Enabling this feature breaks conformance to the Thread Specification.** | |
| TREL | OT_TREL | Enables TREL radio link for Thread over Infrastructure feature. |
| UDP_FORWARD | OT_UDP_FORWARD | Enables support for UDP forward. | Enable this switch on the Border Router device (running on the NCP design) with External Commissioning support to service Thread Commissioner packets on the NCP side. |
| UPTIME | OT_UPTIME | Enables support for tracking OpenThread instance's uptime. |
Some files were not shown because too many files have changed in this diff
Show More
Reference in New Issue
Block a user
Blocking a user prevents them from interacting with repositories, such as opening or commenting on pull requests or issues. Learn more about blocking a user.
Abtin Keshavarzian
