1 /*
2  *  Copyright (c) 2016, 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 DHCPv6 Server.
32  */
33 
34 #include "dhcp6_server.hpp"
35 
36 #if OPENTHREAD_CONFIG_DHCP6_SERVER_ENABLE
37 
38 #include "common/array.hpp"
39 #include "common/as_core_type.hpp"
40 #include "common/code_utils.hpp"
41 #include "common/encoding.hpp"
42 #include "common/locator_getters.hpp"
43 #include "common/log.hpp"
44 #include "instance/instance.hpp"
45 #include "thread/mle.hpp"
46 #include "thread/thread_netif.hpp"
47 
48 namespace ot {
49 namespace Dhcp6 {
50 
51 RegisterLogModule("Dhcp6Server");
52 
Server(Instance & aInstance)53 Server::Server(Instance &aInstance)
54     : InstanceLocator(aInstance)
55     , mSocket(aInstance, *this)
56     , mPrefixAgentsCount(0)
57     , mPrefixAgentsMask(0)
58 {
59     ClearAllBytes(mPrefixAgents);
60 }
61 
UpdateService(void)62 Error Server::UpdateService(void)
63 {
64     Error                           error  = kErrorNone;
65     uint16_t                        rloc16 = Get<Mle::MleRouter>().GetRloc16();
66     NetworkData::Iterator           iterator;
67     NetworkData::OnMeshPrefixConfig config;
68     Lowpan::Context                 lowpanContext;
69 
70     // remove dhcp agent aloc and prefix delegation
71     for (PrefixAgent &prefixAgent : mPrefixAgents)
72     {
73         bool found = false;
74 
75         if (!prefixAgent.IsValid())
76         {
77             continue;
78         }
79 
80         iterator = NetworkData::kIteratorInit;
81 
82         while (Get<NetworkData::Leader>().GetNextOnMeshPrefix(iterator, rloc16, config) == kErrorNone)
83         {
84             if (!(config.mDhcp || config.mConfigure))
85             {
86                 continue;
87             }
88 
89             error = Get<NetworkData::Leader>().GetContext(prefixAgent.GetPrefixAsAddress(), lowpanContext);
90 
91             if ((error == kErrorNone) && (prefixAgent.GetContextId() == lowpanContext.mContextId))
92             {
93                 // still in network data
94                 found = true;
95                 break;
96             }
97         }
98 
99         if (!found)
100         {
101             Get<ThreadNetif>().RemoveUnicastAddress(prefixAgent.GetAloc());
102             prefixAgent.Clear();
103             mPrefixAgentsCount--;
104         }
105     }
106 
107     // add dhcp agent aloc and prefix delegation
108     iterator = NetworkData::kIteratorInit;
109 
110     while (Get<NetworkData::Leader>().GetNextOnMeshPrefix(iterator, rloc16, config) == kErrorNone)
111     {
112         if (!(config.mDhcp || config.mConfigure))
113         {
114             continue;
115         }
116 
117         error = Get<NetworkData::Leader>().GetContext(AsCoreType(&config.mPrefix.mPrefix), lowpanContext);
118 
119         if (error == kErrorNone)
120         {
121             AddPrefixAgent(config.GetPrefix(), lowpanContext);
122         }
123     }
124 
125     if (mPrefixAgentsCount > 0)
126     {
127         Start();
128     }
129     else
130     {
131         Stop();
132     }
133 
134     return error;
135 }
136 
Start(void)137 void Server::Start(void)
138 {
139     VerifyOrExit(!mSocket.IsOpen());
140 
141     IgnoreError(mSocket.Open());
142     IgnoreError(mSocket.Bind(kDhcpServerPort));
143 
144 exit:
145     return;
146 }
147 
Stop(void)148 void Server::Stop(void) { IgnoreError(mSocket.Close()); }
149 
AddPrefixAgent(const Ip6::Prefix & aIp6Prefix,const Lowpan::Context & aContext)150 void Server::AddPrefixAgent(const Ip6::Prefix &aIp6Prefix, const Lowpan::Context &aContext)
151 {
152     Error        error    = kErrorNone;
153     PrefixAgent *newEntry = nullptr;
154 
155     for (PrefixAgent &prefixAgent : mPrefixAgents)
156     {
157         if (!prefixAgent.IsValid())
158         {
159             newEntry = &prefixAgent;
160         }
161         else if (prefixAgent.GetPrefix() == aIp6Prefix)
162         {
163             // already added
164             ExitNow();
165         }
166     }
167 
168     VerifyOrExit(newEntry != nullptr, error = kErrorNoBufs);
169 
170     newEntry->Set(aIp6Prefix, Get<Mle::MleRouter>().GetMeshLocalPrefix(), aContext.mContextId);
171     Get<ThreadNetif>().AddUnicastAddress(newEntry->GetAloc());
172     mPrefixAgentsCount++;
173 
174 exit:
175     LogWarnOnError(error, "add DHCPv6 prefix agent");
176     OT_UNUSED_VARIABLE(error);
177 }
178 
HandleUdpReceive(Message & aMessage,const Ip6::MessageInfo & aMessageInfo)179 void Server::HandleUdpReceive(Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
180 {
181     Header header;
182 
183     SuccessOrExit(aMessage.Read(aMessage.GetOffset(), header));
184     aMessage.MoveOffset(sizeof(header));
185 
186     // discard if not solicit type
187     VerifyOrExit((header.GetType() == kTypeSolicit));
188 
189     ProcessSolicit(aMessage, aMessageInfo.GetPeerAddr(), header.GetTransactionId());
190 
191 exit:
192     return;
193 }
194 
ProcessSolicit(Message & aMessage,const Ip6::Address & aDst,const TransactionId & aTransactionId)195 void Server::ProcessSolicit(Message &aMessage, const Ip6::Address &aDst, const TransactionId &aTransactionId)
196 {
197     IaNa             iana;
198     ClientIdentifier clientIdentifier;
199     uint16_t         optionOffset;
200     uint16_t         offset = aMessage.GetOffset();
201     uint16_t         length = aMessage.GetLength() - aMessage.GetOffset();
202 
203     // Client Identifier (discard if not present)
204     VerifyOrExit((optionOffset = FindOption(aMessage, offset, length, kOptionClientIdentifier)) > 0);
205     SuccessOrExit(ProcessClientIdentifier(aMessage, optionOffset, clientIdentifier));
206 
207     // Server Identifier (assuming Rapid Commit, discard if present)
208     VerifyOrExit(FindOption(aMessage, offset, length, kOptionServerIdentifier) == 0);
209 
210     // Rapid Commit (assuming Rapid Commit, discard if not present)
211     VerifyOrExit(FindOption(aMessage, offset, length, kOptionRapidCommit) > 0);
212 
213     // Elapsed Time if present
214     if ((optionOffset = FindOption(aMessage, offset, length, kOptionElapsedTime)) > 0)
215     {
216         SuccessOrExit(ProcessElapsedTime(aMessage, optionOffset));
217     }
218 
219     // IA_NA (discard if not present)
220     VerifyOrExit((optionOffset = FindOption(aMessage, offset, length, kOptionIaNa)) > 0);
221     SuccessOrExit(ProcessIaNa(aMessage, optionOffset, iana));
222 
223     SuccessOrExit(SendReply(aDst, aTransactionId, clientIdentifier, iana));
224 
225 exit:
226     return;
227 }
228 
FindOption(Message & aMessage,uint16_t aOffset,uint16_t aLength,Code aCode)229 uint16_t Server::FindOption(Message &aMessage, uint16_t aOffset, uint16_t aLength, Code aCode)
230 {
231     uint16_t end  = aOffset + aLength;
232     uint16_t rval = 0;
233 
234     while (aOffset <= end)
235     {
236         Option option;
237 
238         SuccessOrExit(aMessage.Read(aOffset, option));
239 
240         if (option.GetCode() == aCode)
241         {
242             ExitNow(rval = aOffset);
243         }
244 
245         aOffset += sizeof(option) + option.GetLength();
246     }
247 
248 exit:
249     return rval;
250 }
ProcessClientIdentifier(Message & aMessage,uint16_t aOffset,ClientIdentifier & aClientId)251 Error Server::ProcessClientIdentifier(Message &aMessage, uint16_t aOffset, ClientIdentifier &aClientId)
252 {
253     Error error = kErrorNone;
254 
255     SuccessOrExit(error = aMessage.Read(aOffset, aClientId));
256     VerifyOrExit((aClientId.GetLength() == sizeof(aClientId) - sizeof(Option)) &&
257                      (aClientId.GetDuidType() == kDuidLinkLayerAddress) &&
258                      (aClientId.GetDuidHardwareType() == kHardwareTypeEui64),
259                  error = kErrorParse);
260 exit:
261     return error;
262 }
263 
ProcessElapsedTime(Message & aMessage,uint16_t aOffset)264 Error Server::ProcessElapsedTime(Message &aMessage, uint16_t aOffset)
265 {
266     Error       error = kErrorNone;
267     ElapsedTime option;
268 
269     SuccessOrExit(error = aMessage.Read(aOffset, option));
270     VerifyOrExit(option.GetLength() == sizeof(option) - sizeof(Option), error = kErrorParse);
271 exit:
272     return error;
273 }
274 
ProcessIaNa(Message & aMessage,uint16_t aOffset,IaNa & aIaNa)275 Error Server::ProcessIaNa(Message &aMessage, uint16_t aOffset, IaNa &aIaNa)
276 {
277     Error    error = kErrorNone;
278     uint16_t optionOffset;
279     uint16_t length;
280 
281     SuccessOrExit(error = aMessage.Read(aOffset, aIaNa));
282 
283     aOffset += sizeof(aIaNa);
284     length = aIaNa.GetLength() + sizeof(Option) - sizeof(IaNa);
285 
286     VerifyOrExit(length <= aMessage.GetLength() - aOffset, error = kErrorParse);
287 
288     mPrefixAgentsMask = 0;
289 
290     while (length > 0)
291     {
292         VerifyOrExit((optionOffset = FindOption(aMessage, aOffset, length, kOptionIaAddress)) > 0);
293         SuccessOrExit(error = ProcessIaAddress(aMessage, optionOffset));
294 
295         length -= ((optionOffset - aOffset) + sizeof(IaAddress));
296         aOffset = optionOffset + sizeof(IaAddress);
297     }
298 
299 exit:
300     return error;
301 }
302 
ProcessIaAddress(Message & aMessage,uint16_t aOffset)303 Error Server::ProcessIaAddress(Message &aMessage, uint16_t aOffset)
304 {
305     Error     error = kErrorNone;
306     IaAddress option;
307 
308     SuccessOrExit(error = aMessage.Read(aOffset, option));
309     VerifyOrExit(option.GetLength() == sizeof(option) - sizeof(Option), error = kErrorParse);
310 
311     // mask matching prefix
312     for (uint16_t i = 0; i < GetArrayLength(mPrefixAgents); i++)
313     {
314         if (mPrefixAgents[i].IsValid() && mPrefixAgents[i].IsPrefixMatch(option.GetAddress()))
315         {
316             mPrefixAgentsMask |= (1 << i);
317             break;
318         }
319     }
320 
321 exit:
322     return error;
323 }
324 
SendReply(const Ip6::Address & aDst,const TransactionId & aTransactionId,ClientIdentifier & aClientId,IaNa & aIaNa)325 Error Server::SendReply(const Ip6::Address  &aDst,
326                         const TransactionId &aTransactionId,
327                         ClientIdentifier    &aClientId,
328                         IaNa                &aIaNa)
329 {
330     Error            error = kErrorNone;
331     Ip6::MessageInfo messageInfo;
332     Message         *message;
333 
334     VerifyOrExit((message = mSocket.NewMessage()) != nullptr, error = kErrorNoBufs);
335     SuccessOrExit(error = AppendHeader(*message, aTransactionId));
336     SuccessOrExit(error = AppendServerIdentifier(*message));
337     SuccessOrExit(error = AppendClientIdentifier(*message, aClientId));
338     SuccessOrExit(error = AppendIaNa(*message, aIaNa));
339     SuccessOrExit(error = AppendStatusCode(*message, kStatusSuccess));
340     SuccessOrExit(error = AppendIaAddress(*message, aClientId));
341     SuccessOrExit(error = AppendRapidCommit(*message));
342 
343     messageInfo.SetPeerAddr(aDst);
344     messageInfo.SetPeerPort(kDhcpClientPort);
345     SuccessOrExit(error = mSocket.SendTo(*message, messageInfo));
346 
347 exit:
348     FreeMessageOnError(message, error);
349     return error;
350 }
351 
AppendHeader(Message & aMessage,const TransactionId & aTransactionId)352 Error Server::AppendHeader(Message &aMessage, const TransactionId &aTransactionId)
353 {
354     Header header;
355 
356     header.Clear();
357     header.SetType(kTypeReply);
358     header.SetTransactionId(aTransactionId);
359     return aMessage.Append(header);
360 }
361 
AppendClientIdentifier(Message & aMessage,ClientIdentifier & aClientId)362 Error Server::AppendClientIdentifier(Message &aMessage, ClientIdentifier &aClientId)
363 {
364     return aMessage.Append(aClientId);
365 }
366 
AppendServerIdentifier(Message & aMessage)367 Error Server::AppendServerIdentifier(Message &aMessage)
368 {
369     Error            error = kErrorNone;
370     ServerIdentifier option;
371     Mac::ExtAddress  eui64;
372 
373     Get<Radio>().GetIeeeEui64(eui64);
374 
375     option.Init();
376     option.SetDuidType(kDuidLinkLayerAddress);
377     option.SetDuidHardwareType(kHardwareTypeEui64);
378     option.SetDuidLinkLayerAddress(eui64);
379     SuccessOrExit(error = aMessage.Append(option));
380 
381 exit:
382     return error;
383 }
384 
AppendIaNa(Message & aMessage,IaNa & aIaNa)385 Error Server::AppendIaNa(Message &aMessage, IaNa &aIaNa)
386 {
387     Error    error  = kErrorNone;
388     uint16_t length = 0;
389 
390     if (mPrefixAgentsMask)
391     {
392         for (uint16_t i = 0; i < GetArrayLength(mPrefixAgents); i++)
393         {
394             if (mPrefixAgentsMask & (1 << i))
395             {
396                 length += sizeof(IaAddress);
397             }
398         }
399     }
400     else
401     {
402         length += sizeof(IaAddress) * mPrefixAgentsCount;
403     }
404 
405     length += sizeof(IaNa) + sizeof(StatusCode) - sizeof(Option);
406 
407     aIaNa.SetLength(length);
408     aIaNa.SetT1(IaNa::kDefaultT1);
409     aIaNa.SetT2(IaNa::kDefaultT2);
410     SuccessOrExit(error = aMessage.Append(aIaNa));
411 
412 exit:
413     return error;
414 }
415 
AppendStatusCode(Message & aMessage,Status aStatusCode)416 Error Server::AppendStatusCode(Message &aMessage, Status aStatusCode)
417 {
418     StatusCode option;
419 
420     option.Init();
421     option.SetStatusCode(aStatusCode);
422     return aMessage.Append(option);
423 }
424 
AppendIaAddress(Message & aMessage,ClientIdentifier & aClientId)425 Error Server::AppendIaAddress(Message &aMessage, ClientIdentifier &aClientId)
426 {
427     Error error = kErrorNone;
428 
429     if (mPrefixAgentsMask)
430     {
431         // if specified, only apply specified prefixes
432         for (uint16_t i = 0; i < GetArrayLength(mPrefixAgents); i++)
433         {
434             if (mPrefixAgentsMask & (1 << i))
435             {
436                 SuccessOrExit(error = AddIaAddress(aMessage, mPrefixAgents[i].GetPrefixAsAddress(), aClientId));
437             }
438         }
439     }
440     else
441     {
442         // if not specified, apply all configured prefixes
443         for (const PrefixAgent &prefixAgent : mPrefixAgents)
444         {
445             if (prefixAgent.IsValid())
446             {
447                 SuccessOrExit(error = AddIaAddress(aMessage, prefixAgent.GetPrefixAsAddress(), aClientId));
448             }
449         }
450     }
451 
452 exit:
453     return error;
454 }
455 
AddIaAddress(Message & aMessage,const Ip6::Address & aPrefix,ClientIdentifier & aClientId)456 Error Server::AddIaAddress(Message &aMessage, const Ip6::Address &aPrefix, ClientIdentifier &aClientId)
457 {
458     Error     error = kErrorNone;
459     IaAddress option;
460 
461     option.Init();
462     option.GetAddress().SetPrefix(aPrefix.mFields.m8, OT_IP6_PREFIX_BITSIZE);
463     option.GetAddress().GetIid().SetFromExtAddress(aClientId.GetDuidLinkLayerAddress());
464     option.SetPreferredLifetime(IaAddress::kDefaultPreferredLifetime);
465     option.SetValidLifetime(IaAddress::kDefaultValidLifetime);
466     SuccessOrExit(error = aMessage.Append(option));
467 
468 exit:
469     return error;
470 }
471 
AppendRapidCommit(Message & aMessage)472 Error Server::AppendRapidCommit(Message &aMessage)
473 {
474     RapidCommit option;
475 
476     option.Init();
477     return aMessage.Append(option);
478 }
479 
480 } // namespace Dhcp6
481 } // namespace ot
482 
483 #endif //  OPENTHREAD_CONFIG_DHCP6_SERVER_ENABLE
484