Kea: option6_client_fqdn.cc Source File

| Kea 3.0.0

option6_client_fqdn.cc
Go to the documentation of this file.
1// Copyright (C) 2013-2024 Internet Systems Consortium, Inc. ("ISC")
2//
3// This Source Code Form is subject to the terms of the Mozilla Public
4// License, v. 2.0. If a copy of the MPL was not distributed with this
5// file, You can obtain one at http://mozilla.org/MPL/2.0/.
6
7#include <config.h>
8
9#include <dhcp/dhcp6.h>
10#include <dhcp/option6_client_fqdn.h>
11#include <dns/labelsequence.h>
12#include <util/buffer.h>
13#include <util/str.h>
14#include <sstream>
15
16namespace isc {
17namespace dhcp {
18
29 class Option6ClientFqdnImpl {
30public:
32 uint8_t flags_;
34 boost::shared_ptr<isc::dns::Name> domain_name_;
36 Option6ClientFqdn::DomainNameType domain_name_type_;
37
45 Option6ClientFqdnImpl(const uint8_t flags,
46 const std::string& domain_name,
47 const Option6ClientFqdn::DomainNameType name_type);
48
55 Option6ClientFqdnImpl(OptionBufferConstIter first,
56 OptionBufferConstIter last);
57
61 Option6ClientFqdnImpl(const Option6ClientFqdnImpl& source);
62
66 Option6ClientFqdnImpl& operator=(const Option6ClientFqdnImpl& source);
67
73 void setDomainName(const std::string& domain_name,
74 const Option6ClientFqdn::DomainNameType name_type);
75
87 static void checkFlags(const uint8_t flags, const bool check_mbz);
88
95 void parseWireData(OptionBufferConstIter first,
96 OptionBufferConstIter last);
97
98};
99
100Option6ClientFqdnImpl::
101 Option6ClientFqdnImpl(const uint8_t flags,
102 const std::string& domain_name,
103 // cppcheck 1.57 complains that const enum value is not
104 // passed by reference. Note that it accepts the non-const
105 // enum to be passed by value. In both cases it is
106 // unnecessary to pass the enum by reference.
107 // cppcheck-suppress passedByValue
108 const Option6ClientFqdn::DomainNameType name_type)
109 : flags_(flags),
110 domain_name_(),
111 domain_name_type_(name_type) {
112
113 // Check if flags are correct. Also check if MBZ bits are set.
114 checkFlags(flags_, true);
115 // Set domain name. It may throw an exception if domain name has wrong
116 // format.
117 setDomainName(domain_name, name_type);
118}
119
120 Option6ClientFqdnImpl::Option6ClientFqdnImpl(OptionBufferConstIter first,
121 OptionBufferConstIter last) {
122 parseWireData(first, last);
123 // Verify that flags value was correct. Do not check if MBZ bits are
124 // set because we should ignore those bits in received message.
125 checkFlags(flags_, false);
126}
127
128 Option6ClientFqdnImpl::
129 Option6ClientFqdnImpl(const Option6ClientFqdnImpl& source)
130 : flags_(source.flags_),
131 domain_name_(),
132 domain_name_type_(source.domain_name_type_) {
133 if (source.domain_name_) {
134 domain_name_.reset(new isc::dns::Name(*source.domain_name_));
135 }
136}
137
138 Option6ClientFqdnImpl&
139// This assignment operator handles assignment to self, it copies all
140// required values.
141// cppcheck-suppress operatorEqToSelf
142Option6ClientFqdnImpl::operator=(const Option6ClientFqdnImpl& source) {
143 if (source.domain_name_) {
144 domain_name_.reset(new isc::dns::Name(*source.domain_name_));
145
146 } else {
147 domain_name_.reset();
148
149 }
150
151 // This assignment should be exception safe.
152 flags_ = source.flags_;
153 domain_name_type_ = source.domain_name_type_;
154
155 return (*this);
156}
157
158void
159Option6ClientFqdnImpl::
160 setDomainName(const std::string& domain_name,
161 // cppcheck 1.57 complains that const enum value is not
162 // passed by reference. Note that it accepts the non-const
163 // enum to be passed by value. In both cases it is
164 // unnecessary to pass the enum by reference.
165 // cppcheck-suppress passedByValue
166 const Option6ClientFqdn::DomainNameType name_type) {
167 // domain-name must be trimmed. Otherwise, string comprising spaces only
168 // would be treated as a fully qualified name.
169 std::string name = isc::util::str::trim(domain_name);
170 if (name.empty()) {
171 if (name_type == Option6ClientFqdn::FULL) {
172 isc_throw(InvalidOption6FqdnDomainName,
173 "fully qualified domain-name must not be empty"
174 << " when setting new domain-name for DHCPv6 Client"
175 << " FQDN Option");
176 }
177 // The special case when domain-name is empty is marked by setting the
178 // pointer to the domain-name object to NULL.
179 domain_name_.reset();
180
181 } else {
182 try {
183 domain_name_.reset(new isc::dns::Name(name, true));
184
185 } catch (const Exception&) {
186 isc_throw(InvalidOption6FqdnDomainName, "invalid domain-name value '"
187 << domain_name << "' when setting new domain-name for"
188 << " DHCPv6 Client FQDN Option");
189
190 }
191 }
192
193 domain_name_type_ = name_type;
194}
195
196void
197Option6ClientFqdnImpl::checkFlags(const uint8_t flags, const bool check_mbz) {
198 // The Must Be Zero (MBZ) bits must not be set.
199 if (check_mbz && ((flags & ~Option6ClientFqdn::FLAG_MASK) != 0)) {
200 isc_throw(InvalidOption6FqdnFlags,
201 "invalid DHCPv6 Client FQDN Option flags: 0x"
202 << std::hex << static_cast<int>(flags) << std::dec);
203 }
204
205 // According to RFC 4704, section 4.1. if the N bit is 1, the S bit
206 // MUST be 0. Checking it here.
207 if ((flags & (Option6ClientFqdn::FLAG_N | Option6ClientFqdn::FLAG_S))
208 == (Option6ClientFqdn::FLAG_N | Option6ClientFqdn::FLAG_S)) {
209 isc_throw(InvalidOption6FqdnFlags,
210 "both N and S flag of the DHCPv6 Client FQDN Option are set."
211 << " According to RFC 4704, if the N bit is 1 the S bit"
212 << " MUST be 0");
213 }
214}
215
216void
217Option6ClientFqdnImpl::parseWireData(OptionBufferConstIter first,
218 OptionBufferConstIter last) {
219
220 // Buffer must comprise at least one byte with the flags.
221 // The domain-name may be empty.
222 if (std::distance(first, last) < Option6ClientFqdn::FLAG_FIELD_LEN) {
223 isc_throw(OutOfRange, "DHCPv6 Client FQDN Option ("
224 << D6O_CLIENT_FQDN << ") is truncated. Minimal option"
225 << " size is " << Option6ClientFqdn::FLAG_FIELD_LEN
226 << ", got option with size " << std::distance(first, last));
227 }
228
229 // Parse flags
230 flags_ = *(first++);
231
232 // Parse domain-name if any.
233 if (std::distance(first, last) > 0) {
234 // The FQDN may comprise a partial domain-name. In this case it lacks
235 // terminating 0. If this is the case, we will need to add zero at
236 // the end because Name object constructor requires it.
237 if (*(last - 1) != 0) {
238 // Create temporary buffer and add terminating zero.
239 OptionBuffer buf(first, last);
240 buf.push_back(0);
241 // Reset domain name.
242 isc::util::InputBuffer name_buf(&buf[0], buf.size());
243 try {
244 domain_name_.reset(new isc::dns::Name(name_buf, true));
245 } catch (const Exception&) {
246 if (Option::lenient_parsing_) {
247 isc_throw(SkipThisOptionError, "failed to parse "
248 "partial domain-name from wire format");
249 } else {
250 isc_throw(InvalidOption6FqdnDomainName, "failed to parse "
251 "partial domain-name from wire format");
252 }
253 }
254 // Terminating zero was missing, so set the domain-name type
255 // to partial.
256 domain_name_type_ = Option6ClientFqdn::PARTIAL;
257 } else {
258 // We are dealing with fully qualified domain name so there is
259 // no need to add terminating zero. Simply pass the buffer to
260 // Name object constructor.
261 isc::util::InputBuffer name_buf(&(*first),
262 std::distance(first, last));
263 try {
264 domain_name_.reset(new isc::dns::Name(name_buf, true));
265 } catch (const Exception&) {
266 if (Option::lenient_parsing_) {
267 isc_throw(SkipThisOptionError, "failed to parse "
268 "fully qualified domain-name from wire format");
269 } else {
270 isc_throw(InvalidOption6FqdnDomainName, "failed to parse "
271 "fully qualified domain-name from wire format");
272 }
273 }
274 // Set the domain-type to fully qualified domain name.
275 domain_name_type_ = Option6ClientFqdn::FULL;
276 }
277 }
278}
279
280 Option6ClientFqdn::Option6ClientFqdn(const uint8_t flag)
281 : Option(Option::V6, D6O_CLIENT_FQDN),
282 impl_(new Option6ClientFqdnImpl(flag, "", PARTIAL)) {
283}
284
285Option6ClientFqdn::Option6ClientFqdn(const uint8_t flag,
286 const std::string& domain_name,
287 const DomainNameType domain_name_type)
288 : Option(Option::V6, D6O_CLIENT_FQDN),
289 impl_(new Option6ClientFqdnImpl(flag, domain_name, domain_name_type)) {
290}
291
292 Option6ClientFqdn::Option6ClientFqdn(OptionBufferConstIter first,
293 OptionBufferConstIter last)
294 : Option(Option::V6, D6O_CLIENT_FQDN, first, last),
295 impl_(new Option6ClientFqdnImpl(first, last)) {
296}
297
298Option6ClientFqdn::~Option6ClientFqdn() {
299 delete(impl_);
300}
301
302 Option6ClientFqdn::Option6ClientFqdn(const Option6ClientFqdn& source)
303 : Option(source),
304 impl_(new Option6ClientFqdnImpl(*source.impl_)) {
305}
306
307 OptionPtr
308Option6ClientFqdn::clone() const {
309 return (cloneInternal<Option6ClientFqdn>());
310}
311
312 Option6ClientFqdn&
313// This assignment operator handles assignment to self, it uses copy
314// constructor of Option6ClientFqdnImpl to copy all required values.
315// cppcheck-suppress operatorEqToSelf
316Option6ClientFqdn::operator=(const Option6ClientFqdn& source) {
317 Option::operator=(source);
318 Option6ClientFqdnImpl* old_impl = impl_;
319 impl_ = new Option6ClientFqdnImpl(*source.impl_);
320 delete(old_impl);
321 return (*this);
322}
323
324bool
325Option6ClientFqdn::getFlag(const uint8_t flag) const {
326 // Caller should query for one of the: N, S or O flags. Any other
327 // value is invalid.
328 if (flag != FLAG_S && flag != FLAG_O && flag != FLAG_N) {
329 isc_throw(InvalidOption6FqdnFlags, "invalid DHCPv6 Client FQDN"
330 << " Option flag specified, expected N, S or O");
331 }
332
333 return ((impl_->flags_ & flag) != 0);
334}
335
336void
337Option6ClientFqdn::setFlag(const uint8_t flag, const bool set_flag) {
338 // Check that flag is in range between 0x1 and 0x7. Note that this
339 // allows to set or clear multiple flags concurrently. Setting
340 // concurrent bits is discouraged (see header file) but it is not
341 // checked here so it will work.
342 if (((flag & ~FLAG_MASK) != 0) || (flag == 0)) {
343 isc_throw(InvalidOption6FqdnFlags, "invalid DHCPv6 Client FQDN"
344 << " Option flag 0x" << std::hex
345 << static_cast<int>(flag) << std::dec
346 << " is being set. Expected: N, S or O");
347 }
348
349 // Copy the current flags into local variable. That way we will be able
350 // to test new flags settings before applying them.
351 uint8_t new_flag = impl_->flags_;
352 if (set_flag) {
353 new_flag |= flag;
354 } else {
355 new_flag &= ~flag;
356 }
357
358 // Check new flags. If they are valid, apply them.
359 Option6ClientFqdnImpl::checkFlags(new_flag, true);
360 impl_->flags_ = new_flag;
361}
362
363void
364Option6ClientFqdn::resetFlags() {
365 impl_->flags_ = 0;
366}
367
368std::string
369Option6ClientFqdn::getDomainName() const {
370 if (impl_->domain_name_) {
371 return (impl_->domain_name_->toText(impl_->domain_name_type_ ==
372 PARTIAL));
373 }
374 // If an object holding domain-name is NULL it means that the domain-name
375 // is empty.
376 return ("");
377}
378
379void
380Option6ClientFqdn::packDomainName(isc::util::OutputBuffer& buf) const {
381 // There is nothing to do if domain-name is empty.
382 if (!impl_->domain_name_) {
383 return;
384 }
385
386 // Domain name, encoded as a set of labels.
387 isc::dns::LabelSequence labels(*impl_->domain_name_);
388 if (labels.getDataLength() > 0) {
389 size_t read_len = 0;
390 const uint8_t* data = labels.getData(&read_len);
391 if (impl_->domain_name_type_ == PARTIAL) {
392 --read_len;
393 }
394 buf.writeData(data, read_len);
395 }
396}
397
398void
399Option6ClientFqdn::setDomainName(const std::string& domain_name,
400 const DomainNameType domain_name_type) {
401 impl_->setDomainName(domain_name, domain_name_type);
402}
403
404void
405Option6ClientFqdn::resetDomainName() {
406 setDomainName("", PARTIAL);
407}
408
409 Option6ClientFqdn::DomainNameType
410Option6ClientFqdn::getDomainNameType() const {
411 return (impl_->domain_name_type_);
412}
413
414void
415Option6ClientFqdn::pack(isc::util::OutputBuffer& buf, bool) const {
416 // Header = option code and length.
417 packHeader(buf);
418 // Flags field.
419 buf.writeUint8(impl_->flags_);
420 // Domain name.
421 packDomainName(buf);
422}
423
424void
425Option6ClientFqdn::unpack(OptionBufferConstIter first,
426 OptionBufferConstIter last) {
427 setData(first, last);
428 impl_->parseWireData(first, last);
429 // Check that the flags in the received option are valid. Ignore MBZ bits
430 // because we don't want to discard the whole option because of MBZ bits
431 // being set.
432 impl_->checkFlags(impl_->flags_, false);
433}
434
435std::string
436Option6ClientFqdn::toText(int indent) const {
437 std::ostringstream stream;
438 std::string in(indent, ' '); // base indentation
439 stream << in << "type=" << type_ << "(CLIENT_FQDN), "
440 << "flags: ("
441 << "N=" << (getFlag(FLAG_N) ? "1" : "0") << ", "
442 << "O=" << (getFlag(FLAG_O) ? "1" : "0") << ", "
443 << "S=" << (getFlag(FLAG_S) ? "1" : "0") << "), "
444 << "domain-name='" << getDomainName() << "' ("
445 << (getDomainNameType() == PARTIAL ? "partial" : "full")
446 << ")";
447
448 return (stream.str());
449}
450
451uint16_t
452Option6ClientFqdn::len() const {
453 uint16_t domain_name_length = 0;
454 if (impl_->domain_name_) {
455 // If domain name is partial, the NULL terminating character
456 // is not included and the option. Length has to be adjusted.
457 domain_name_length = impl_->domain_name_type_ == FULL ?
458 impl_->domain_name_->getLength() :
459 impl_->domain_name_->getLength() - 1;
460 }
461 return (getHeaderLen() + FLAG_FIELD_LEN + domain_name_length);
462}
463
464} // end of isc::dhcp namespace
465} // end of isc namespace
buffer.h
isc::Exception
This is a base class for exceptions thrown from the DNS library module.
Definition exceptions/exceptions.h:23
isc::OutOfRange
A generic exception that is thrown if a parameter given to a method would refer to or modify out-of-r...
Definition exceptions/exceptions.h:115
isc::dhcp::InvalidOption6FqdnDomainName
Exception thrown when invalid domain name is specified.
Definition option6_client_fqdn.h:27
isc::dhcp::InvalidOption6FqdnFlags
Exception thrown when invalid flags have been specified for DHCPv6 Client Fqdn Option.
Definition option6_client_fqdn.h:20
isc::dhcp::Option6ClientFqdnImpl
Implements the logic for the Option6ClientFqdn class.
Definition option6_client_fqdn.cc:29
isc::dhcp::Option6ClientFqdnImpl::operator=
Option6ClientFqdnImpl & operator=(const Option6ClientFqdnImpl &source)
Assignment operator.
Definition option6_client_fqdn.cc:142
isc::dhcp::Option6ClientFqdnImpl::domain_name_
boost::shared_ptr< isc::dns::Name > domain_name_
Holds the pointer to a domain name carried in the option.
Definition option6_client_fqdn.cc:34
isc::dhcp::Option6ClientFqdnImpl::flags_
uint8_t flags_
Holds flags carried by the option.
Definition option6_client_fqdn.cc:32
isc::dhcp::Option6ClientFqdnImpl::domain_name_type_
Option6ClientFqdn::DomainNameType domain_name_type_
Indicates whether domain name is partial or fully qualified.
Definition option6_client_fqdn.cc:36
isc::dhcp::Option6ClientFqdnImpl::setDomainName
void setDomainName(const std::string &domain_name, const Option6ClientFqdn::DomainNameType name_type)
Set a new domain name for the option.
Definition option6_client_fqdn.cc:160
isc::dhcp::Option6ClientFqdnImpl::parseWireData
void parseWireData(OptionBufferConstIter first, OptionBufferConstIter last)
Parse the Option provided in the wire format.
Definition option6_client_fqdn.cc:217
isc::dhcp::Option6ClientFqdnImpl::Option6ClientFqdnImpl
Option6ClientFqdnImpl(const uint8_t flags, const std::string &domain_name, const Option6ClientFqdn::DomainNameType name_type)
Constructor, from domain name.
Definition option6_client_fqdn.cc:101
isc::dhcp::Option6ClientFqdnImpl::checkFlags
static void checkFlags(const uint8_t flags, const bool check_mbz)
Check if flags are valid.
Definition option6_client_fqdn.cc:197
isc::dhcp::Option6ClientFqdn
Represents DHCPv6 Client FQDN Option (code 39).
Definition option6_client_fqdn.h:87
isc::dhcp::Option6ClientFqdn::resetFlags
void resetFlags()
Sets the flag field value to 0.
Definition option6_client_fqdn.cc:364
isc::dhcp::Option6ClientFqdn::FLAG_S
static const uint8_t FLAG_S
S bit.
Definition option6_client_fqdn.h:93
isc::dhcp::Option6ClientFqdn::FLAG_N
static const uint8_t FLAG_N
N bit.
Definition option6_client_fqdn.h:95
isc::dhcp::Option6ClientFqdn::getDomainNameType
DomainNameType getDomainNameType() const
Returns enumerator value which indicates whether domain-name is partial or full.
Definition option6_client_fqdn.cc:410
isc::dhcp::Option6ClientFqdn::clone
virtual OptionPtr clone() const
Copies this option and returns a pointer to the copy.
Definition option6_client_fqdn.cc:308
isc::dhcp::Option6ClientFqdn::FLAG_FIELD_LEN
static const uint16_t FLAG_FIELD_LEN
The length of the flag field within DHCPv6 Client Fqdn Option.
Definition option6_client_fqdn.h:102
isc::dhcp::Option6ClientFqdn::setDomainName
void setDomainName(const std::string &domain_name, const DomainNameType domain_name_type)
Set new domain-name.
Definition option6_client_fqdn.cc:399
isc::dhcp::Option6ClientFqdn::resetDomainName
void resetDomainName()
Set empty domain-name.
Definition option6_client_fqdn.cc:405
isc::dhcp::Option6ClientFqdn::FLAG_O
static const uint8_t FLAG_O
O bit.
Definition option6_client_fqdn.h:94
isc::dhcp::Option6ClientFqdn::FLAG_MASK
static const uint8_t FLAG_MASK
Mask which zeroes MBZ flag bits.
Definition option6_client_fqdn.h:99
isc::dhcp::Option6ClientFqdn::len
virtual uint16_t len() const
Returns length of the complete option (data length + DHCPv6 option header).
Definition option6_client_fqdn.cc:452
isc::dhcp::Option6ClientFqdn::unpack
virtual void unpack(OptionBufferConstIter first, OptionBufferConstIter last)
Parses option from the received buffer.
Definition option6_client_fqdn.cc:425
isc::dhcp::Option6ClientFqdn::Option6ClientFqdn
Option6ClientFqdn(const uint8_t flags, const std::string &domain_name, const DomainNameType domain_name_type=FULL)
Constructor, creates option instance using flags and domain name.
Definition option6_client_fqdn.cc:285
isc::dhcp::Option6ClientFqdn::getDomainName
std::string getDomainName() const
Returns the domain-name in the text format.
Definition option6_client_fqdn.cc:369
isc::dhcp::Option6ClientFqdn::DomainNameType
DomainNameType
Type of the domain-name: partial or full.
Definition option6_client_fqdn.h:105
isc::dhcp::Option6ClientFqdn::PARTIAL
@ PARTIAL
Definition option6_client_fqdn.h:106
isc::dhcp::Option6ClientFqdn::FULL
@ FULL
Definition option6_client_fqdn.h:107
isc::dhcp::Option6ClientFqdn::pack
virtual void pack(isc::util::OutputBuffer &buf, bool check=true) const
Writes option in the wire format into a buffer.
Definition option6_client_fqdn.cc:415
isc::dhcp::Option6ClientFqdn::operator=
Option6ClientFqdn & operator=(const Option6ClientFqdn &source)
Assignment operator.
Definition option6_client_fqdn.cc:316
isc::dhcp::Option6ClientFqdn::packDomainName
void packDomainName(isc::util::OutputBuffer &buf) const
Writes domain-name in the wire format into a buffer.
Definition option6_client_fqdn.cc:380
isc::dhcp::Option6ClientFqdn::toText
virtual std::string toText(int indent=0) const
Returns string representation of the option.
Definition option6_client_fqdn.cc:436
isc::dhcp::Option6ClientFqdn::getFlag
bool getFlag(const uint8_t flag) const
Checks if the specified flag of the DHCPv6 Client FQDN Option is set.
Definition option6_client_fqdn.cc:325
isc::dhcp::Option6ClientFqdn::~Option6ClientFqdn
virtual ~Option6ClientFqdn()
Destructor.
Definition option6_client_fqdn.cc:298
isc::dhcp::Option6ClientFqdn::setFlag
void setFlag(const uint8_t flag, const bool set)
Modifies the value of the specified DHCPv6 Client Fqdn Option flag.
Definition option6_client_fqdn.cc:337
isc::dhcp::Option::type_
uint16_t type_
option type (0-255 for DHCPv4, 0-65535 for DHCPv6)
Definition option.h:597
isc::dhcp::Option::lenient_parsing_
static bool lenient_parsing_
Governs whether options should be parsed less strictly.
Definition option.h:490
isc::dhcp::Option::getHeaderLen
virtual uint16_t getHeaderLen() const
Returns length of header (2 for v4, 4 for v6)
Definition option.cc:327
isc::dhcp::Option::V6
@ V6
Definition option.h:90
isc::dhcp::Option::operator=
Option & operator=(const Option &rhs)
Assignment operator.
Definition option.cc:73
isc::dhcp::Option::setData
void setData(InputIterator first, InputIterator last)
Sets content of this option from buffer.
Definition option.h:434
isc::dhcp::Option::cloneInternal
OptionPtr cloneInternal() const
Copies this option and returns a pointer to the copy.
Definition option.h:504
isc::dhcp::Option::packHeader
void packHeader(isc::util::OutputBuffer &buf, bool check=true) const
Store option's header in a buffer.
Definition option.cc:119
isc::dhcp::Option::Option
Option(Universe u, uint16_t type)
ctor, used for options constructed, usually during transmission
Definition option.cc:39
isc::dhcp::SkipThisOptionError
Exception thrown during option unpacking This exception is thrown when an error has occurred unpackin...
Definition option.h:67
isc::dns::LabelSequence
Light-weight Accessor to Name data.
Definition labelsequence.h:35
isc::dns::LabelSequence::getData
const uint8_t * getData(size_t *len) const
Return the wire-format data for this LabelSequence.
Definition labelsequence.cc:82
isc::dns::LabelSequence::getDataLength
size_t getDataLength() const
Return the length of the wire-format data of this LabelSequence.
Definition labelsequence.cc:88
isc::dns::Name
The Name class encapsulates DNS names.
Definition name.h:219
isc::util::InputBuffer
The InputBuffer class is a buffer abstraction for manipulating read-only data.
Definition buffer.h:81
isc::util::OutputBuffer
The OutputBuffer class is a buffer abstraction for manipulating mutable data.
Definition buffer.h:346
isc::util::OutputBuffer::writeUint8
void writeUint8(uint8_t data)
Write an unsigned 8-bit integer into the buffer.
Definition buffer.h:476
isc::util::OutputBuffer::writeData
void writeData(const void *data, size_t len)
Copy an arbitrary length of data into the buffer.
Definition buffer.h:559
dhcp6.h
D6O_CLIENT_FQDN
@ D6O_CLIENT_FQDN
Definition dhcp6.h:59
isc_throw
#define isc_throw(type, stream)
A shortcut macro to insert known values into exception arguments.
Definition exceptions/exceptions.h:210
labelsequence.h
isc::data
Definition base_stamped_element.cc:12
isc::dhcp
Definition dhcp4/client_handler.cc:20
isc::dhcp::OptionBufferConstIter
OptionBuffer::const_iterator OptionBufferConstIter
const_iterator for walking over OptionBuffer
Definition option.h:30
isc::dhcp::OptionBuffer
std::vector< uint8_t > OptionBuffer
buffer types used in DHCP code.
Definition option.h:24
isc::dhcp::OptionPtr
boost::shared_ptr< Option > OptionPtr
Definition option.h:37
isc::util::str::trim
string trim(const string &input)
Trim leading and trailing spaces.
Definition str.cc:32
isc
Defines the logger used by the top-level component of kea-lfc.
Definition agent_parser.cc:148
option6_client_fqdn.h
str.h