1 /*
2  *  Copyright (c) 2021, The OpenThread Authors.
3  *  All rights reserved.
4  *
5  *  Redistribution and use in source and binary forms, with or without
6  *  modification, are permitted provided that the following conditions are met:
7  *  1. Redistributions of source code must retain the above copyright
8  *     notice, this list of conditions and the following disclaimer.
9  *  2. Redistributions in binary form must reproduce the above copyright
10  *     notice, this list of conditions and the following disclaimer in the
11  *     documentation and/or other materials provided with the distribution.
12  *  3. Neither the name of the copyright holder nor the
13  *     names of its contributors may be used to endorse or promote products
14  *     derived from this software without specific prior written permission.
15  *
16  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17  *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19  *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
20  *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21  *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22  *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23  *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24  *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25  *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26  *  POSSIBILITY OF SUCH DAMAGE.
27  */
28 
29 /**
30  * @file
31  *   This file implements the History Tracker public APIs.
32  */
33 
34 #include "openthread-core-config.h"
35 
36 #if OPENTHREAD_CONFIG_HISTORY_TRACKER_ENABLE
37 
38 #include <openthread/history_tracker.h>
39 
40 #include "common/as_core_type.hpp"
41 #include "common/locator_getters.hpp"
42 #include "utils/history_tracker.hpp"
43 
44 using namespace ot;
45 
otHistoryTrackerInitIterator(otHistoryTrackerIterator * aIterator)46 void otHistoryTrackerInitIterator(otHistoryTrackerIterator *aIterator) { AsCoreType(aIterator).Init(); }
47 
otHistoryTrackerIterateNetInfoHistory(otInstance * aInstance,otHistoryTrackerIterator * aIterator,uint32_t * aEntryAge)48 const otHistoryTrackerNetworkInfo *otHistoryTrackerIterateNetInfoHistory(otInstance               *aInstance,
49                                                                          otHistoryTrackerIterator *aIterator,
50                                                                          uint32_t                 *aEntryAge)
51 {
52     AssertPointerIsNotNull(aEntryAge);
53 
54     return AsCoreType(aInstance).Get<Utils::HistoryTracker>().IterateNetInfoHistory(AsCoreType(aIterator), *aEntryAge);
55 }
56 
otHistoryTrackerIterateUnicastAddressHistory(otInstance * aInstance,otHistoryTrackerIterator * aIterator,uint32_t * aEntryAge)57 const otHistoryTrackerUnicastAddressInfo *otHistoryTrackerIterateUnicastAddressHistory(
58     otInstance               *aInstance,
59     otHistoryTrackerIterator *aIterator,
60     uint32_t                 *aEntryAge)
61 {
62     AssertPointerIsNotNull(aEntryAge);
63 
64     return AsCoreType(aInstance).Get<Utils::HistoryTracker>().IterateUnicastAddressHistory(AsCoreType(aIterator),
65                                                                                            *aEntryAge);
66 }
67 
otHistoryTrackerIterateMulticastAddressHistory(otInstance * aInstance,otHistoryTrackerIterator * aIterator,uint32_t * aEntryAge)68 const otHistoryTrackerMulticastAddressInfo *otHistoryTrackerIterateMulticastAddressHistory(
69     otInstance               *aInstance,
70     otHistoryTrackerIterator *aIterator,
71     uint32_t                 *aEntryAge)
72 {
73     AssertPointerIsNotNull(aEntryAge);
74 
75     return AsCoreType(aInstance).Get<Utils::HistoryTracker>().IterateMulticastAddressHistory(AsCoreType(aIterator),
76                                                                                              *aEntryAge);
77 }
78 
otHistoryTrackerIterateRxHistory(otInstance * aInstance,otHistoryTrackerIterator * aIterator,uint32_t * aEntryAge)79 const otHistoryTrackerMessageInfo *otHistoryTrackerIterateRxHistory(otInstance               *aInstance,
80                                                                     otHistoryTrackerIterator *aIterator,
81                                                                     uint32_t                 *aEntryAge)
82 {
83     AssertPointerIsNotNull(aEntryAge);
84 
85     return AsCoreType(aInstance).Get<Utils::HistoryTracker>().IterateRxHistory(AsCoreType(aIterator), *aEntryAge);
86 }
87 
otHistoryTrackerIterateTxHistory(otInstance * aInstance,otHistoryTrackerIterator * aIterator,uint32_t * aEntryAge)88 const otHistoryTrackerMessageInfo *otHistoryTrackerIterateTxHistory(otInstance               *aInstance,
89                                                                     otHistoryTrackerIterator *aIterator,
90                                                                     uint32_t                 *aEntryAge)
91 {
92     AssertPointerIsNotNull(aEntryAge);
93 
94     return AsCoreType(aInstance).Get<Utils::HistoryTracker>().IterateTxHistory(AsCoreType(aIterator), *aEntryAge);
95 }
96 
otHistoryTrackerIterateNeighborHistory(otInstance * aInstance,otHistoryTrackerIterator * aIterator,uint32_t * aEntryAge)97 const otHistoryTrackerNeighborInfo *otHistoryTrackerIterateNeighborHistory(otInstance               *aInstance,
98                                                                            otHistoryTrackerIterator *aIterator,
99                                                                            uint32_t                 *aEntryAge)
100 {
101     AssertPointerIsNotNull(aEntryAge);
102 
103     return AsCoreType(aInstance).Get<Utils::HistoryTracker>().IterateNeighborHistory(AsCoreType(aIterator), *aEntryAge);
104 }
105 
otHistoryTrackerIterateRouterHistory(otInstance * aInstance,otHistoryTrackerIterator * aIterator,uint32_t * aEntryAge)106 const otHistoryTrackerRouterInfo *otHistoryTrackerIterateRouterHistory(otInstance               *aInstance,
107                                                                        otHistoryTrackerIterator *aIterator,
108                                                                        uint32_t                 *aEntryAge)
109 {
110     AssertPointerIsNotNull(aEntryAge);
111 
112     return AsCoreType(aInstance).Get<Utils::HistoryTracker>().IterateRouterHistory(AsCoreType(aIterator), *aEntryAge);
113 }
114 
otHistoryTrackerIterateOnMeshPrefixHistory(otInstance * aInstance,otHistoryTrackerIterator * aIterator,uint32_t * aEntryAge)115 const otHistoryTrackerOnMeshPrefixInfo *otHistoryTrackerIterateOnMeshPrefixHistory(otInstance               *aInstance,
116                                                                                    otHistoryTrackerIterator *aIterator,
117                                                                                    uint32_t                 *aEntryAge)
118 {
119     AssertPointerIsNotNull(aEntryAge);
120 
121     return AsCoreType(aInstance).Get<Utils::HistoryTracker>().IterateOnMeshPrefixHistory(AsCoreType(aIterator),
122                                                                                          *aEntryAge);
123 }
124 
otHistoryTrackerIterateExternalRouteHistory(otInstance * aInstance,otHistoryTrackerIterator * aIterator,uint32_t * aEntryAge)125 const otHistoryTrackerExternalRouteInfo *otHistoryTrackerIterateExternalRouteHistory(
126     otInstance               *aInstance,
127     otHistoryTrackerIterator *aIterator,
128     uint32_t                 *aEntryAge)
129 {
130     AssertPointerIsNotNull(aEntryAge);
131 
132     return AsCoreType(aInstance).Get<Utils::HistoryTracker>().IterateExternalRouteHistory(AsCoreType(aIterator),
133                                                                                           *aEntryAge);
134 }
135 
otHistoryTrackerEntryAgeToString(uint32_t aEntryAge,char * aBuffer,uint16_t aSize)136 void otHistoryTrackerEntryAgeToString(uint32_t aEntryAge, char *aBuffer, uint16_t aSize)
137 {
138     Utils::HistoryTracker::EntryAgeToString(aEntryAge, aBuffer, aSize);
139 }
140 
141 #endif // OPENTHREAD_CONFIG_HISTORY_TRACKER_ENABLE
142