1 /*
2 * Copyright (c) 2023, 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 infrastructure DNS-SD module.
32 */
33
34 #include "dnssd.hpp"
35
36 #if OPENTHREAD_CONFIG_PLATFORM_DNSSD_ENABLE || OPENTHREAD_CONFIG_MULTICAST_DNS_ENABLE
37
38 #include "common/code_utils.hpp"
39 #include "common/locator_getters.hpp"
40 #include "instance/instance.hpp"
41
42 namespace ot {
43
44 //---------------------------------------------------------------------------------------------------------------------
45 // Dnssd::RequestIdRange
46
Add(RequestId aId)47 void Dnssd::RequestIdRange::Add(RequestId aId)
48 {
49 if (IsEmpty())
50 {
51 mStart = aId;
52 mEnd = aId + 1;
53 }
54 else if (SerialNumber::IsLess(aId, mStart)) // Equivalent to (aId < mStart)
55 {
56 mStart = aId;
57 }
58 else if (!SerialNumber::IsLess(aId, mEnd)) // Equivalent to !(aId < mEd) -> (aId >= mEnd)
59 {
60 mEnd = aId + 1;
61 }
62 }
63
Remove(RequestId aId)64 void Dnssd::RequestIdRange::Remove(RequestId aId)
65 {
66 if (!IsEmpty())
67 {
68 if (aId == mStart)
69 {
70 mStart++;
71 }
72 else if (aId + 1 == mEnd)
73 {
74 mEnd--;
75 }
76 }
77 }
78
Contains(RequestId aId) const79 bool Dnssd::RequestIdRange::Contains(RequestId aId) const
80 {
81 // Equivalent to `(aId >= mStart) && (aId < mEnd)`
82
83 return (!SerialNumber::IsLess(aId, mStart) && SerialNumber::IsLess(aId, mEnd));
84 }
85
86 //---------------------------------------------------------------------------------------------------------------------
87 // Dnssd
88
Dnssd(Instance & aInstance)89 Dnssd::Dnssd(Instance &aInstance)
90 : InstanceLocator(aInstance)
91 #if OPENTHREAD_CONFIG_PLATFORM_DNSSD_ALLOW_RUN_TIME_SELECTION
92 , mUseNativeMdns(true)
93 #endif
94 {
95 }
96
GetState(void) const97 Dnssd::State Dnssd::GetState(void) const
98 {
99 State state;
100
101 #if OPENTHREAD_CONFIG_PLATFORM_DNSSD_ALLOW_RUN_TIME_SELECTION
102 if (mUseNativeMdns)
103 #endif
104 #if OPENTHREAD_CONFIG_MULTICAST_DNS_ENABLE
105 {
106 state = Get<Dns::Multicast::Core>().IsEnabled() ? kReady : kStopped;
107 ExitNow();
108 }
109 #endif
110
111 #if OPENTHREAD_CONFIG_PLATFORM_DNSSD_ENABLE
112 state = MapEnum(otPlatDnssdGetState(&GetInstance()));
113 ExitNow();
114 #endif
115
116 exit:
117 return state;
118 }
119
RegisterService(const Service & aService,RequestId aRequestId,RegisterCallback aCallback)120 void Dnssd::RegisterService(const Service &aService, RequestId aRequestId, RegisterCallback aCallback)
121 {
122 VerifyOrExit(IsReady());
123
124 #if OPENTHREAD_CONFIG_PLATFORM_DNSSD_ALLOW_RUN_TIME_SELECTION
125 if (mUseNativeMdns)
126 #endif
127 #if OPENTHREAD_CONFIG_MULTICAST_DNS_ENABLE
128 {
129 IgnoreError(Get<Dns::Multicast::Core>().RegisterService(aService, aRequestId, aCallback));
130 ExitNow();
131 }
132 #endif
133
134 #if OPENTHREAD_CONFIG_PLATFORM_DNSSD_ENABLE
135 otPlatDnssdRegisterService(&GetInstance(), &aService, aRequestId, aCallback);
136 #endif
137
138 exit:
139 return;
140 }
141
UnregisterService(const Service & aService,RequestId aRequestId,RegisterCallback aCallback)142 void Dnssd::UnregisterService(const Service &aService, RequestId aRequestId, RegisterCallback aCallback)
143 {
144 VerifyOrExit(IsReady());
145
146 #if OPENTHREAD_CONFIG_PLATFORM_DNSSD_ALLOW_RUN_TIME_SELECTION
147 if (mUseNativeMdns)
148 #endif
149 #if OPENTHREAD_CONFIG_MULTICAST_DNS_ENABLE
150 {
151 IgnoreError(Get<Dns::Multicast::Core>().UnregisterService(aService));
152 VerifyOrExit(aCallback != nullptr);
153 aCallback(&GetInstance(), aRequestId, kErrorNone);
154 ExitNow();
155 }
156 #endif
157
158 #if OPENTHREAD_CONFIG_PLATFORM_DNSSD_ENABLE
159 otPlatDnssdUnregisterService(&GetInstance(), &aService, aRequestId, aCallback);
160 #endif
161
162 exit:
163 return;
164 }
165
RegisterHost(const Host & aHost,RequestId aRequestId,RegisterCallback aCallback)166 void Dnssd::RegisterHost(const Host &aHost, RequestId aRequestId, RegisterCallback aCallback)
167 {
168 VerifyOrExit(IsReady());
169
170 #if OPENTHREAD_CONFIG_PLATFORM_DNSSD_ALLOW_RUN_TIME_SELECTION
171 if (mUseNativeMdns)
172 #endif
173 #if OPENTHREAD_CONFIG_MULTICAST_DNS_ENABLE
174 {
175 IgnoreError(Get<Dns::Multicast::Core>().RegisterHost(aHost, aRequestId, aCallback));
176 ExitNow();
177 }
178 #endif
179
180 #if OPENTHREAD_CONFIG_PLATFORM_DNSSD_ENABLE
181 otPlatDnssdRegisterHost(&GetInstance(), &aHost, aRequestId, aCallback);
182 #endif
183
184 exit:
185 return;
186 }
187
UnregisterHost(const Host & aHost,RequestId aRequestId,RegisterCallback aCallback)188 void Dnssd::UnregisterHost(const Host &aHost, RequestId aRequestId, RegisterCallback aCallback)
189 {
190 VerifyOrExit(IsReady());
191
192 #if OPENTHREAD_CONFIG_PLATFORM_DNSSD_ALLOW_RUN_TIME_SELECTION
193 if (mUseNativeMdns)
194 #endif
195 #if OPENTHREAD_CONFIG_MULTICAST_DNS_ENABLE
196 {
197 IgnoreError(Get<Dns::Multicast::Core>().UnregisterHost(aHost));
198 VerifyOrExit(aCallback != nullptr);
199 aCallback(&GetInstance(), aRequestId, kErrorNone);
200 ExitNow();
201 }
202 #endif
203
204 #if OPENTHREAD_CONFIG_PLATFORM_DNSSD_ENABLE
205 otPlatDnssdUnregisterHost(&GetInstance(), &aHost, aRequestId, aCallback);
206 #endif
207
208 exit:
209 return;
210 }
211
RegisterKey(const Key & aKey,RequestId aRequestId,RegisterCallback aCallback)212 void Dnssd::RegisterKey(const Key &aKey, RequestId aRequestId, RegisterCallback aCallback)
213 {
214 VerifyOrExit(IsReady());
215
216 #if OPENTHREAD_CONFIG_PLATFORM_DNSSD_ALLOW_RUN_TIME_SELECTION
217 if (mUseNativeMdns)
218 #endif
219 #if OPENTHREAD_CONFIG_MULTICAST_DNS_ENABLE
220 {
221 IgnoreError(Get<Dns::Multicast::Core>().RegisterKey(aKey, aRequestId, aCallback));
222 ExitNow();
223 }
224 #endif
225
226 #if OPENTHREAD_CONFIG_PLATFORM_DNSSD_ENABLE
227 otPlatDnssdRegisterKey(&GetInstance(), &aKey, aRequestId, aCallback);
228 #endif
229
230 exit:
231 return;
232 }
233
UnregisterKey(const Key & aKey,RequestId aRequestId,RegisterCallback aCallback)234 void Dnssd::UnregisterKey(const Key &aKey, RequestId aRequestId, RegisterCallback aCallback)
235 {
236 VerifyOrExit(IsReady());
237
238 #if OPENTHREAD_CONFIG_PLATFORM_DNSSD_ALLOW_RUN_TIME_SELECTION
239 if (mUseNativeMdns)
240 #endif
241 #if OPENTHREAD_CONFIG_MULTICAST_DNS_ENABLE
242 {
243 IgnoreError(Get<Dns::Multicast::Core>().UnregisterKey(aKey));
244 VerifyOrExit(aCallback != nullptr);
245 aCallback(&GetInstance(), aRequestId, kErrorNone);
246 ExitNow();
247 }
248 #endif
249
250 #if OPENTHREAD_CONFIG_PLATFORM_DNSSD_ENABLE
251 otPlatDnssdUnregisterKey(&GetInstance(), &aKey, aRequestId, aCallback);
252 #endif
253
254 exit:
255 return;
256 }
257
StartBrowser(const Browser & aBrowser)258 void Dnssd::StartBrowser(const Browser &aBrowser)
259 {
260 VerifyOrExit(IsReady());
261
262 #if OPENTHREAD_CONFIG_PLATFORM_DNSSD_ALLOW_RUN_TIME_SELECTION
263 if (mUseNativeMdns)
264 #endif
265 #if OPENTHREAD_CONFIG_MULTICAST_DNS_ENABLE
266 {
267 IgnoreError(Get<Dns::Multicast::Core>().StartBrowser(aBrowser));
268 ExitNow();
269 }
270 #endif
271
272 #if OPENTHREAD_CONFIG_PLATFORM_DNSSD_ENABLE
273 otPlatDnssdStartBrowser(&GetInstance(), &aBrowser);
274 #endif
275
276 exit:
277 return;
278 }
279
StopBrowser(const Browser & aBrowser)280 void Dnssd::StopBrowser(const Browser &aBrowser)
281 {
282 VerifyOrExit(IsReady());
283
284 #if OPENTHREAD_CONFIG_PLATFORM_DNSSD_ALLOW_RUN_TIME_SELECTION
285 if (mUseNativeMdns)
286 #endif
287 #if OPENTHREAD_CONFIG_MULTICAST_DNS_ENABLE
288 {
289 IgnoreError(Get<Dns::Multicast::Core>().StopBrowser(aBrowser));
290 ExitNow();
291 }
292 #endif
293
294 #if OPENTHREAD_CONFIG_PLATFORM_DNSSD_ENABLE
295 otPlatDnssdStopBrowser(&GetInstance(), &aBrowser);
296 #endif
297
298 exit:
299 return;
300 }
301
StartSrvResolver(const SrvResolver & aResolver)302 void Dnssd::StartSrvResolver(const SrvResolver &aResolver)
303 {
304 VerifyOrExit(IsReady());
305
306 #if OPENTHREAD_CONFIG_PLATFORM_DNSSD_ALLOW_RUN_TIME_SELECTION
307 if (mUseNativeMdns)
308 #endif
309 #if OPENTHREAD_CONFIG_MULTICAST_DNS_ENABLE
310 {
311 IgnoreError(Get<Dns::Multicast::Core>().StartSrvResolver(aResolver));
312 ExitNow();
313 }
314 #endif
315
316 #if OPENTHREAD_CONFIG_PLATFORM_DNSSD_ENABLE
317 otPlatDnssdStartSrvResolver(&GetInstance(), &aResolver);
318 #endif
319
320 exit:
321 return;
322 }
323
StopSrvResolver(const SrvResolver & aResolver)324 void Dnssd::StopSrvResolver(const SrvResolver &aResolver)
325 {
326 VerifyOrExit(IsReady());
327
328 #if OPENTHREAD_CONFIG_PLATFORM_DNSSD_ALLOW_RUN_TIME_SELECTION
329 if (mUseNativeMdns)
330 #endif
331 #if OPENTHREAD_CONFIG_MULTICAST_DNS_ENABLE
332 {
333 IgnoreError(Get<Dns::Multicast::Core>().StopSrvResolver(aResolver));
334 ExitNow();
335 }
336 #endif
337
338 #if OPENTHREAD_CONFIG_PLATFORM_DNSSD_ENABLE
339 otPlatDnssdStopSrvResolver(&GetInstance(), &aResolver);
340 #endif
341
342 exit:
343 return;
344 }
345
StartTxtResolver(const TxtResolver & aResolver)346 void Dnssd::StartTxtResolver(const TxtResolver &aResolver)
347 {
348 VerifyOrExit(IsReady());
349
350 #if OPENTHREAD_CONFIG_PLATFORM_DNSSD_ALLOW_RUN_TIME_SELECTION
351 if (mUseNativeMdns)
352 #endif
353 #if OPENTHREAD_CONFIG_MULTICAST_DNS_ENABLE
354 {
355 IgnoreError(Get<Dns::Multicast::Core>().StartTxtResolver(aResolver));
356 ExitNow();
357 }
358 #endif
359
360 #if OPENTHREAD_CONFIG_PLATFORM_DNSSD_ENABLE
361 otPlatDnssdStartTxtResolver(&GetInstance(), &aResolver);
362 #endif
363
364 exit:
365 return;
366 }
367
StopTxtResolver(const TxtResolver & aResolver)368 void Dnssd::StopTxtResolver(const TxtResolver &aResolver)
369 {
370 VerifyOrExit(IsReady());
371
372 #if OPENTHREAD_CONFIG_PLATFORM_DNSSD_ALLOW_RUN_TIME_SELECTION
373 if (mUseNativeMdns)
374 #endif
375 #if OPENTHREAD_CONFIG_MULTICAST_DNS_ENABLE
376 {
377 IgnoreError(Get<Dns::Multicast::Core>().StopTxtResolver(aResolver));
378 ExitNow();
379 }
380 #endif
381
382 #if OPENTHREAD_CONFIG_PLATFORM_DNSSD_ENABLE
383 otPlatDnssdStopTxtResolver(&GetInstance(), &aResolver);
384 #endif
385
386 exit:
387 return;
388 }
389
StartIp6AddressResolver(const AddressResolver & aResolver)390 void Dnssd::StartIp6AddressResolver(const AddressResolver &aResolver)
391 {
392 VerifyOrExit(IsReady());
393
394 #if OPENTHREAD_CONFIG_PLATFORM_DNSSD_ALLOW_RUN_TIME_SELECTION
395 if (mUseNativeMdns)
396 #endif
397 #if OPENTHREAD_CONFIG_MULTICAST_DNS_ENABLE
398 {
399 IgnoreError(Get<Dns::Multicast::Core>().StartIp6AddressResolver(aResolver));
400 ExitNow();
401 }
402 #endif
403
404 #if OPENTHREAD_CONFIG_PLATFORM_DNSSD_ENABLE
405 otPlatDnssdStartIp6AddressResolver(&GetInstance(), &aResolver);
406 #endif
407
408 exit:
409 return;
410 }
411
StopIp6AddressResolver(const AddressResolver & aResolver)412 void Dnssd::StopIp6AddressResolver(const AddressResolver &aResolver)
413 {
414 VerifyOrExit(IsReady());
415
416 #if OPENTHREAD_CONFIG_PLATFORM_DNSSD_ALLOW_RUN_TIME_SELECTION
417 if (mUseNativeMdns)
418 #endif
419 #if OPENTHREAD_CONFIG_MULTICAST_DNS_ENABLE
420 {
421 IgnoreError(Get<Dns::Multicast::Core>().StopIp6AddressResolver(aResolver));
422 ExitNow();
423 }
424 #endif
425
426 #if OPENTHREAD_CONFIG_PLATFORM_DNSSD_ENABLE
427 otPlatDnssdStopIp6AddressResolver(&GetInstance(), &aResolver);
428 #endif
429
430 exit:
431 return;
432 }
433
StartIp4AddressResolver(const AddressResolver & aResolver)434 void Dnssd::StartIp4AddressResolver(const AddressResolver &aResolver)
435 {
436 VerifyOrExit(IsReady());
437
438 #if OPENTHREAD_CONFIG_PLATFORM_DNSSD_ALLOW_RUN_TIME_SELECTION
439 if (mUseNativeMdns)
440 #endif
441 #if OPENTHREAD_CONFIG_MULTICAST_DNS_ENABLE
442 {
443 IgnoreError(Get<Dns::Multicast::Core>().StartIp4AddressResolver(aResolver));
444 ExitNow();
445 }
446 #endif
447
448 #if OPENTHREAD_CONFIG_PLATFORM_DNSSD_ENABLE
449 otPlatDnssdStartIp4AddressResolver(&GetInstance(), &aResolver);
450 #endif
451
452 exit:
453 return;
454 }
455
StopIp4AddressResolver(const AddressResolver & aResolver)456 void Dnssd::StopIp4AddressResolver(const AddressResolver &aResolver)
457 {
458 VerifyOrExit(IsReady());
459
460 #if OPENTHREAD_CONFIG_PLATFORM_DNSSD_ALLOW_RUN_TIME_SELECTION
461 if (mUseNativeMdns)
462 #endif
463 #if OPENTHREAD_CONFIG_MULTICAST_DNS_ENABLE
464 {
465 IgnoreError(Get<Dns::Multicast::Core>().StopIp4AddressResolver(aResolver));
466 ExitNow();
467 }
468 #endif
469
470 #if OPENTHREAD_CONFIG_PLATFORM_DNSSD_ENABLE
471 otPlatDnssdStopIp4AddressResolver(&GetInstance(), &aResolver);
472 #endif
473
474 exit:
475 return;
476 }
477
HandleStateChange(void)478 void Dnssd::HandleStateChange(void)
479 {
480 #if OPENTHREAD_CONFIG_SRP_SERVER_ADVERTISING_PROXY_ENABLE
481 Get<Srp::AdvertisingProxy>().HandleDnssdPlatformStateChange();
482 #endif
483
484 #if OPENTHREAD_CONFIG_DNSSD_SERVER_ENABLE && OPENTHREAD_CONFIG_DNSSD_DISCOVERY_PROXY_ENABLE
485 Get<Dns::ServiceDiscovery::Server>().HandleDnssdPlatformStateChange();
486 #endif
487 }
488
489 #if OPENTHREAD_CONFIG_MULTICAST_DNS_ENABLE
HandleMdnsCoreStateChange(void)490 void Dnssd::HandleMdnsCoreStateChange(void)
491 {
492 #if OPENTHREAD_CONFIG_PLATFORM_DNSSD_ALLOW_RUN_TIME_SELECTION
493 if (mUseNativeMdns)
494 #endif
495 {
496 HandleStateChange();
497 }
498 }
499 #endif
500
501 #if OPENTHREAD_CONFIG_PLATFORM_DNSSD_ENABLE
otPlatDnssdStateHandleStateChange(otInstance * aInstance)502 extern "C" void otPlatDnssdStateHandleStateChange(otInstance *aInstance)
503 {
504 AsCoreType(aInstance).Get<Dnssd>().HandleStateChange();
505 }
506 #endif
507
508 } // namespace ot
509
510 #endif // OPENTHREAD_CONFIG_PLATFORM_DNSSD_ENABLE || OPENTHREAD_CONFIG_MULTICAST_DNS_ENABLE
511
