624 lines
20 KiB
C++
624 lines
20 KiB
C++
/*
|
|
* Copyright (c) 2017, Matias Fontanini
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are
|
|
* met:
|
|
*
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above
|
|
* copyright notice, this list of conditions and the following disclaimer
|
|
* in the documentation and/or other materials provided with the
|
|
* distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
*/
|
|
|
|
#include <vector>
|
|
#include <tins/dhcpv6.h>
|
|
#include <tins/exceptions.h>
|
|
#include <tins/memory_helpers.h>
|
|
|
|
using std::vector;
|
|
using std::memcpy;
|
|
using std::equal;
|
|
|
|
using Tins::Memory::InputMemoryStream;
|
|
using Tins::Memory::OutputMemoryStream;
|
|
|
|
namespace Tins {
|
|
|
|
namespace Internals {
|
|
|
|
template<typename InputIterator>
|
|
void class_option_data2option(InputIterator start,
|
|
InputIterator end,
|
|
vector<uint8_t>& buffer,
|
|
size_t start_index = 0) {
|
|
size_t index = start_index;
|
|
uint16_t uint16_t_buffer;
|
|
while (start != end) {
|
|
buffer.resize(buffer.size() + sizeof(uint16_t) + start->size());
|
|
uint16_t_buffer = Endian::host_to_be(static_cast<uint16_t>(start->size()));
|
|
memcpy(&buffer[index], &uint16_t_buffer, sizeof(uint16_t));
|
|
index += sizeof(uint16_t);
|
|
if (!start->empty()) {
|
|
memcpy(&*buffer.begin() + index, &*start->begin(), start->size());
|
|
}
|
|
index += start->size();
|
|
|
|
start++;
|
|
}
|
|
}
|
|
|
|
template<typename OutputType>
|
|
OutputType option2class_option_data(const uint8_t* ptr, uint32_t total_sz) {
|
|
typedef typename OutputType::value_type value_type;
|
|
OutputType output;
|
|
size_t index = 0;
|
|
while (index + 2 < total_sz) {
|
|
uint16_t size;
|
|
memcpy(&size, ptr + index, sizeof(uint16_t));
|
|
size = Endian::be_to_host(size);
|
|
index += sizeof(uint16_t);
|
|
if (index + size > total_sz) {
|
|
throw option_not_found();
|
|
}
|
|
output.push_back(
|
|
value_type(ptr + index, ptr + index + size)
|
|
);
|
|
index += size;
|
|
}
|
|
if (index != total_sz) {
|
|
throw malformed_option();
|
|
}
|
|
return output;
|
|
}
|
|
|
|
} // Internals
|
|
|
|
PDU::metadata DHCPv6::extract_metadata(const uint8_t* /*buffer*/, uint32_t total_sz) {
|
|
if (TINS_UNLIKELY(total_sz < 2)) {
|
|
throw malformed_packet();
|
|
}
|
|
return metadata(total_sz, pdu_flag, PDU::UNKNOWN);
|
|
}
|
|
|
|
DHCPv6::DHCPv6()
|
|
: header_data_(), options_size_() {
|
|
|
|
}
|
|
|
|
DHCPv6::DHCPv6(const uint8_t* buffer, uint32_t total_sz)
|
|
: options_size_() {
|
|
InputMemoryStream stream(buffer, total_sz);
|
|
if (!stream) {
|
|
throw malformed_packet();
|
|
}
|
|
// Relay Agent/Server Messages
|
|
const MessageType message_type = (MessageType)*stream.pointer();
|
|
bool is_relay_msg = (message_type == RELAY_FORWARD || message_type == RELAY_REPLY);
|
|
uint32_t required_size = is_relay_msg ? 2 : 4;
|
|
stream.read(&header_data_, required_size);
|
|
if (is_relay_message()) {
|
|
stream.read(link_addr_);
|
|
stream.read(peer_addr_);
|
|
}
|
|
while (stream) {
|
|
uint16_t opt = stream.read_be<uint16_t>();
|
|
uint16_t data_size = stream.read_be<uint16_t>();
|
|
if (!stream.can_read(data_size)) {
|
|
throw malformed_packet();
|
|
}
|
|
add_option(option(opt, stream.pointer(), stream.pointer() + data_size));
|
|
stream.skip(data_size);
|
|
}
|
|
}
|
|
|
|
void DHCPv6::add_option(const option& opt) {
|
|
options_.push_back(opt);
|
|
options_size_ += opt.data_size() + sizeof(uint16_t) * 2;
|
|
}
|
|
|
|
bool DHCPv6::remove_option(OptionTypes type) {
|
|
options_type::iterator iter = search_option_iterator(type);
|
|
if (iter == options_.end()) {
|
|
return false;
|
|
}
|
|
options_size_ -= iter->data_size() + sizeof(uint16_t) * 2;
|
|
options_.erase(iter);
|
|
return true;
|
|
}
|
|
|
|
const DHCPv6::option* DHCPv6::search_option(OptionTypes type) const {
|
|
// Search for the iterator. If we found something, return it, otherwise return nullptr.
|
|
options_type::const_iterator iter = search_option_iterator(type);
|
|
return (iter != options_.end()) ? &*iter : 0;
|
|
}
|
|
|
|
DHCPv6::options_type::const_iterator DHCPv6::search_option_iterator(OptionTypes type) const {
|
|
return Internals::find_option_const<option>(options_, type);
|
|
}
|
|
|
|
DHCPv6::options_type::iterator DHCPv6::search_option_iterator(OptionTypes type) {
|
|
return Internals::find_option<option>(options_, type);
|
|
}
|
|
|
|
void DHCPv6::write_option(const option& opt, OutputMemoryStream& stream) const {
|
|
stream.write_be<uint16_t>(opt.option());
|
|
stream.write_be<uint16_t>(opt.length_field());
|
|
stream.write(opt.data_ptr(), opt.data_size());
|
|
}
|
|
|
|
void DHCPv6::msg_type(MessageType type) {
|
|
header_data_[0] = static_cast<uint8_t>(type);
|
|
}
|
|
|
|
void DHCPv6::hop_count(uint8_t count) {
|
|
header_data_[1] = count;
|
|
}
|
|
|
|
void DHCPv6::transaction_id(small_uint<24> id) {
|
|
uint32_t id_32 = id;
|
|
header_data_[1] = id_32 >> 16;
|
|
header_data_[2] = id_32 >> 8;
|
|
header_data_[3] = id_32 & 0xff;
|
|
}
|
|
|
|
void DHCPv6::peer_address(const ipaddress_type& addr) {
|
|
peer_addr_ = addr;
|
|
}
|
|
|
|
void DHCPv6::link_address(const ipaddress_type& addr) {
|
|
link_addr_ = addr;
|
|
}
|
|
|
|
bool DHCPv6::is_relay_message() const {
|
|
return msg_type() == 12 || msg_type() == 13;
|
|
}
|
|
|
|
uint32_t DHCPv6::header_size() const {
|
|
return (is_relay_message() ? (2 + ipaddress_type::address_size * 2) : 4) + options_size_;
|
|
}
|
|
|
|
bool DHCPv6::matches_response(const uint8_t* ptr, uint32_t total_sz) const {
|
|
if (!is_relay_message()) {
|
|
if (total_sz < 4 || (ptr[0] == 12 || ptr[0] == 13)) {
|
|
return false;
|
|
}
|
|
return equal(header_data_ + 1, header_data_ + 4, ptr + 1);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void DHCPv6::write_serialization(uint8_t* buffer, uint32_t total_sz) {
|
|
const uint32_t required_size = is_relay_message() ? 2 : 4;
|
|
OutputMemoryStream stream(buffer, total_sz);
|
|
stream.write(header_data_, required_size);
|
|
if (is_relay_message()) {
|
|
stream.write(link_addr_);
|
|
stream.write(peer_addr_);
|
|
}
|
|
for (options_type::const_iterator it = options_.begin(); it != options_.end(); ++it) {
|
|
write_option(*it, stream);
|
|
}
|
|
}
|
|
|
|
|
|
// ********************************************************************
|
|
// Option getters
|
|
// ********************************************************************
|
|
|
|
DHCPv6::ia_na_type DHCPv6::ia_na() const {
|
|
return search_and_convert<ia_na_type>(IA_NA);
|
|
}
|
|
|
|
DHCPv6::ia_ta_type DHCPv6::ia_ta() const {
|
|
return search_and_convert<ia_ta_type>(IA_TA);
|
|
}
|
|
|
|
DHCPv6::ia_address_type DHCPv6::ia_address() const {
|
|
return search_and_convert<ia_address_type>(IA_ADDR);
|
|
}
|
|
|
|
DHCPv6::option_request_type DHCPv6::option_request() const {
|
|
return search_and_convert<option_request_type>(OPTION_REQUEST);
|
|
}
|
|
|
|
uint8_t DHCPv6::preference() const {
|
|
return search_and_convert<uint8_t>(PREFERENCE);
|
|
}
|
|
|
|
uint16_t DHCPv6::elapsed_time() const {
|
|
return search_and_convert<uint16_t>(ELAPSED_TIME);
|
|
}
|
|
|
|
DHCPv6::relay_msg_type DHCPv6::relay_message() const {
|
|
return search_and_convert<relay_msg_type>(RELAY_MSG);
|
|
}
|
|
|
|
DHCPv6::authentication_type DHCPv6::authentication() const {
|
|
return search_and_convert<authentication_type>(AUTH);
|
|
}
|
|
|
|
DHCPv6::ipaddress_type DHCPv6::server_unicast() const {
|
|
return search_and_convert<ipaddress_type>(UNICAST);
|
|
}
|
|
|
|
DHCPv6::status_code_type DHCPv6::status_code() const {
|
|
return search_and_convert<status_code_type>(STATUS_CODE);
|
|
}
|
|
|
|
bool DHCPv6::has_rapid_commit() const {
|
|
return search_option(RAPID_COMMIT) != NULL;
|
|
}
|
|
|
|
DHCPv6::user_class_type DHCPv6::user_class() const {
|
|
return search_and_convert<user_class_type>(USER_CLASS);
|
|
}
|
|
|
|
DHCPv6::vendor_class_type DHCPv6::vendor_class() const {
|
|
return search_and_convert<vendor_class_type>(VENDOR_CLASS);
|
|
}
|
|
|
|
DHCPv6::vendor_info_type DHCPv6::vendor_info() const {
|
|
return search_and_convert<vendor_info_type>(VENDOR_OPTS);
|
|
}
|
|
|
|
DHCPv6::interface_id_type DHCPv6::interface_id() const {
|
|
return search_and_convert<interface_id_type>(INTERFACE_ID);
|
|
}
|
|
|
|
uint8_t DHCPv6::reconfigure_msg() const {
|
|
return search_and_convert<uint8_t>(RECONF_MSG);
|
|
}
|
|
|
|
bool DHCPv6::has_reconfigure_accept() const {
|
|
return search_option(RECONF_ACCEPT) != NULL;
|
|
}
|
|
|
|
DHCPv6::duid_type DHCPv6::client_id() const {
|
|
return search_and_convert<duid_type>(CLIENTID);
|
|
}
|
|
|
|
DHCPv6::duid_type DHCPv6::server_id() const {
|
|
return search_and_convert<duid_type>(SERVERID);
|
|
}
|
|
|
|
// ********************************************************************
|
|
// Option setters
|
|
// ********************************************************************
|
|
|
|
void DHCPv6::ia_na(const ia_na_type& value) {
|
|
vector<uint8_t> buffer(sizeof(uint32_t) * 3 + value.options.size());
|
|
OutputMemoryStream stream(buffer);
|
|
stream.write_be(value.id);
|
|
stream.write_be(value.t1);
|
|
stream.write_be(value.t2);
|
|
stream.write(value.options.begin(), value.options.end());
|
|
add_option(option(IA_NA, buffer.begin(), buffer.end()));
|
|
}
|
|
|
|
void DHCPv6::ia_ta(const ia_ta_type& value) {
|
|
vector<uint8_t> buffer(sizeof(uint32_t) + value.options.size());
|
|
OutputMemoryStream stream(buffer);
|
|
stream.write_be(value.id);
|
|
stream.write(value.options.begin(), value.options.end());
|
|
add_option(option(IA_TA, buffer.begin(), buffer.end()));
|
|
}
|
|
|
|
void DHCPv6::ia_address(const ia_address_type& value) {
|
|
vector<uint8_t> buffer(
|
|
sizeof(uint32_t) * 2 + ipaddress_type::address_size + value.options.size()
|
|
);
|
|
OutputMemoryStream stream(buffer);
|
|
stream.write(value.address);
|
|
stream.write_be(value.preferred_lifetime);
|
|
stream.write_be(value.valid_lifetime);
|
|
stream.write(value.options.begin(), value.options.end());
|
|
add_option(option(IA_ADDR, buffer.begin(), buffer.end()));
|
|
}
|
|
|
|
void DHCPv6::option_request(const option_request_type& value) {
|
|
typedef option_request_type::const_iterator iterator;
|
|
|
|
vector<uint8_t> buffer(value.size() * sizeof(uint16_t));
|
|
OutputMemoryStream stream(buffer);
|
|
for (iterator it = value.begin(); it != value.end(); ++it) {
|
|
stream.write_be(*it);
|
|
}
|
|
add_option(option(OPTION_REQUEST, buffer.begin(), buffer.end()));
|
|
}
|
|
|
|
void DHCPv6::preference(uint8_t value) {
|
|
add_option(option(PREFERENCE, 1, &value));
|
|
}
|
|
|
|
void DHCPv6::elapsed_time(uint16_t value) {
|
|
value = Endian::host_to_be(value);
|
|
add_option(option(ELAPSED_TIME, 2, (const uint8_t*)&value));
|
|
}
|
|
|
|
void DHCPv6::relay_message(const relay_msg_type& value) {
|
|
add_option(option(RELAY_MSG, value.begin(), value.end()));
|
|
}
|
|
|
|
void DHCPv6::authentication(const authentication_type& value) {
|
|
vector<uint8_t> buffer(
|
|
sizeof(uint8_t) * 3 + sizeof(uint64_t) + value.auth_info.size()
|
|
);
|
|
OutputMemoryStream stream(buffer);
|
|
stream.write(value.protocol);
|
|
stream.write(value.algorithm);
|
|
stream.write(value.rdm);
|
|
stream.write_be(value.replay_detection);
|
|
stream.write(value.auth_info.begin(), value.auth_info.end());
|
|
add_option(option(AUTH, buffer.begin(), buffer.end()));
|
|
}
|
|
|
|
void DHCPv6::server_unicast(const ipaddress_type& value) {
|
|
add_option(option(UNICAST, value.begin(), value.end()));
|
|
}
|
|
|
|
void DHCPv6::status_code(const status_code_type& value) {
|
|
vector<uint8_t> buffer(sizeof(uint16_t) + value.message.size());
|
|
OutputMemoryStream stream(buffer);
|
|
stream.write_be(value.code);
|
|
stream.write(value.message.begin(), value.message.end());
|
|
add_option(option(STATUS_CODE, buffer.begin(), buffer.end()));
|
|
}
|
|
|
|
void DHCPv6::rapid_commit() {
|
|
add_option(RAPID_COMMIT);
|
|
}
|
|
|
|
void DHCPv6::user_class(const user_class_type& value) {
|
|
vector<uint8_t> buffer;
|
|
Internals::class_option_data2option(value.data.begin(), value.data.end(), buffer);
|
|
add_option(option(USER_CLASS, buffer.begin(), buffer.end()));
|
|
}
|
|
|
|
void DHCPv6::vendor_class(const vendor_class_type& value) {
|
|
vector<uint8_t> buffer(sizeof(uint32_t));
|
|
OutputMemoryStream stream(buffer);
|
|
stream.write_be(value.enterprise_number);
|
|
Internals::class_option_data2option(
|
|
value.vendor_class_data.begin(),
|
|
value.vendor_class_data.end(),
|
|
buffer,
|
|
sizeof(uint32_t)
|
|
);
|
|
add_option(
|
|
option(VENDOR_CLASS, buffer.begin(), buffer.end())
|
|
);
|
|
}
|
|
|
|
void DHCPv6::vendor_info(const vendor_info_type& value) {
|
|
vector<uint8_t> buffer(sizeof(uint32_t) + value.data.size());
|
|
OutputMemoryStream stream(buffer);
|
|
stream.write_be(value.enterprise_number);
|
|
stream.write(value.data.begin(), value.data.end());
|
|
add_option(option(VENDOR_OPTS, buffer.begin(), buffer.end()));
|
|
}
|
|
|
|
void DHCPv6::interface_id(const interface_id_type& value) {
|
|
add_option(option(INTERFACE_ID, value.begin(), value.end()));
|
|
}
|
|
|
|
void DHCPv6::reconfigure_msg(uint8_t value) {
|
|
add_option(option(RECONF_MSG, 1, &value));
|
|
}
|
|
|
|
void DHCPv6::reconfigure_accept() {
|
|
add_option(RECONF_ACCEPT);
|
|
}
|
|
|
|
void DHCPv6::client_id(const duid_type& value) {
|
|
serialization_type buffer(sizeof(uint16_t) + value.data.size());
|
|
OutputMemoryStream stream(buffer);
|
|
stream.write_be(value.id);
|
|
stream.write(value.data.begin(), value.data.end());
|
|
add_option(option(CLIENTID, buffer.begin(), buffer.end()));
|
|
}
|
|
|
|
void DHCPv6::server_id(const duid_type& value) {
|
|
serialization_type buffer(sizeof(uint16_t) + value.data.size());
|
|
OutputMemoryStream stream(buffer);
|
|
stream.write_be(value.id);
|
|
stream.write(value.data.begin(), value.data.end());
|
|
add_option(option(SERVERID, buffer.begin(), buffer.end()));
|
|
}
|
|
|
|
// DUIDs
|
|
|
|
DHCPv6::duid_llt DHCPv6::duid_llt::from_bytes(const uint8_t* buffer, uint32_t total_sz) {
|
|
// at least one byte for lladdress
|
|
if (total_sz < sizeof(uint16_t) + sizeof(uint32_t) + 1) {
|
|
throw malformed_option();
|
|
}
|
|
InputMemoryStream stream(buffer, total_sz);
|
|
duid_llt output;
|
|
output.hw_type = stream.read_be<uint16_t>();
|
|
output.time = stream.read_be<uint32_t>();
|
|
stream.read(output.lladdress, stream.size());
|
|
return output;
|
|
}
|
|
|
|
PDU::serialization_type DHCPv6::duid_llt::serialize() const {
|
|
serialization_type output(sizeof(uint16_t) + sizeof(uint32_t) + lladdress.size());
|
|
OutputMemoryStream stream(output);
|
|
stream.write_be(hw_type);
|
|
stream.write_be(time);
|
|
stream.write(lladdress.begin(), lladdress.end());
|
|
return output;
|
|
}
|
|
|
|
DHCPv6::duid_en DHCPv6::duid_en::from_bytes(const uint8_t* buffer, uint32_t total_sz) {
|
|
// at least one byte for identifier
|
|
if (total_sz < sizeof(uint32_t) + 1) {
|
|
throw malformed_option();
|
|
}
|
|
InputMemoryStream stream(buffer, total_sz);
|
|
duid_en output;
|
|
output.enterprise_number = stream.read_be<uint32_t>();
|
|
stream.read(output.identifier, stream.size());
|
|
return output;
|
|
}
|
|
|
|
PDU::serialization_type DHCPv6::duid_en::serialize() const {
|
|
serialization_type output(sizeof(uint32_t) + identifier.size());
|
|
OutputMemoryStream stream(output);
|
|
stream.write_be(enterprise_number);
|
|
stream.write(identifier.begin(), identifier.end());
|
|
return output;
|
|
}
|
|
|
|
DHCPv6::duid_ll DHCPv6::duid_ll::from_bytes(const uint8_t* buffer, uint32_t total_sz) {
|
|
// at least one byte for lladdress
|
|
if (total_sz < sizeof(uint16_t) + 1) {
|
|
throw malformed_option();
|
|
}
|
|
InputMemoryStream stream(buffer, total_sz);
|
|
duid_ll output;
|
|
output.hw_type = stream.read_be<uint16_t>();
|
|
stream.read(output.lladdress, stream.size());
|
|
return output;
|
|
}
|
|
|
|
PDU::serialization_type DHCPv6::duid_ll::serialize() const {
|
|
serialization_type output(sizeof(uint16_t) + lladdress.size());
|
|
OutputMemoryStream stream(output);
|
|
stream.write_be(hw_type);
|
|
stream.write(lladdress.begin(), lladdress.end());
|
|
return output;
|
|
}
|
|
|
|
// Options
|
|
|
|
DHCPv6::ia_na_type DHCPv6::ia_na_type::from_option(const option& opt) {
|
|
if (opt.data_size() < sizeof(uint32_t) * 3) {
|
|
throw malformed_option();
|
|
}
|
|
InputMemoryStream stream(opt.data_ptr(), opt.data_size());
|
|
DHCPv6::ia_na_type output;
|
|
output.id = stream.read_be<uint32_t>();
|
|
output.t1 = stream.read_be<uint32_t>();
|
|
output.t2 = stream.read_be<uint32_t>();
|
|
stream.read(output.options, stream.size());
|
|
return output;
|
|
}
|
|
|
|
DHCPv6::ia_ta_type DHCPv6::ia_ta_type::from_option(const option& opt) {
|
|
if (opt.data_size() < sizeof(uint32_t)) {
|
|
throw malformed_option();
|
|
}
|
|
InputMemoryStream stream(opt.data_ptr(), opt.data_size());
|
|
DHCPv6::ia_ta_type output;
|
|
output.id = stream.read_be<uint32_t>();
|
|
stream.read(output.options, stream.size());
|
|
return output;
|
|
}
|
|
|
|
DHCPv6::ia_address_type DHCPv6::ia_address_type::from_option(const option& opt) {
|
|
if (opt.data_size() < sizeof(uint32_t) * 2 + DHCPv6::ipaddress_type::address_size) {
|
|
throw malformed_option();
|
|
}
|
|
InputMemoryStream stream(opt.data_ptr(), opt.data_size());
|
|
DHCPv6::ia_address_type output;
|
|
stream.read(output.address);
|
|
output.preferred_lifetime = stream.read_be<uint32_t>();
|
|
output.valid_lifetime = stream.read_be<uint32_t>();
|
|
stream.read(output.options, stream.size());
|
|
return output;
|
|
}
|
|
|
|
DHCPv6::authentication_type DHCPv6::authentication_type::from_option(const option& opt) {
|
|
if (opt.data_size() < sizeof(uint8_t) * 3 + sizeof(uint64_t)) {
|
|
throw malformed_option();
|
|
}
|
|
InputMemoryStream stream(opt.data_ptr(), opt.data_size());
|
|
authentication_type output;
|
|
output.protocol = stream.read<uint8_t>();
|
|
output.algorithm = stream.read<uint8_t>();
|
|
output.rdm = stream.read<uint8_t>();
|
|
output.replay_detection = stream.read_be<uint64_t>();
|
|
stream.read(output.auth_info, stream.size());
|
|
return output;
|
|
}
|
|
|
|
DHCPv6::status_code_type DHCPv6::status_code_type::from_option(const option& opt) {
|
|
if (opt.data_size() < sizeof(uint16_t)) {
|
|
throw malformed_option();
|
|
}
|
|
InputMemoryStream stream(opt.data_ptr(), opt.data_size());
|
|
status_code_type output;
|
|
output.code = stream.read_be<uint16_t>();
|
|
output.message.assign(stream.pointer(), stream.pointer() + stream.size());
|
|
return output;
|
|
}
|
|
|
|
DHCPv6::vendor_info_type DHCPv6::vendor_info_type::from_option(const option& opt) {
|
|
if (opt.data_size() < sizeof(uint32_t)) {
|
|
throw malformed_option();
|
|
}
|
|
InputMemoryStream stream(opt.data_ptr(), opt.data_size());
|
|
vendor_info_type output;
|
|
output.enterprise_number = stream.read_be<uint32_t>();
|
|
stream.read(output.data, stream.size());
|
|
return output;
|
|
}
|
|
|
|
DHCPv6::vendor_class_type DHCPv6::vendor_class_type::from_option(const option& opt) {
|
|
if (opt.data_size() < sizeof(uint32_t)) {
|
|
throw malformed_option();
|
|
}
|
|
typedef vendor_class_type::class_data_type data_type;
|
|
InputMemoryStream stream(opt.data_ptr(), opt.data_size());
|
|
vendor_class_type output;
|
|
output.enterprise_number = stream.read_be<uint32_t>();
|
|
output.vendor_class_data = Internals::option2class_option_data<data_type>(
|
|
stream.pointer(),
|
|
stream.size()
|
|
);
|
|
|
|
return output;
|
|
}
|
|
|
|
DHCPv6::duid_type DHCPv6::duid_type::from_option(const option& opt) {
|
|
if (opt.data_size() < sizeof(uint16_t) + 1) {
|
|
throw malformed_option();
|
|
}
|
|
InputMemoryStream stream(opt.data_ptr(), opt.data_size());
|
|
uint16_t id = stream.read_be<uint16_t>();
|
|
return duid_type(
|
|
id,
|
|
serialization_type(stream.pointer(), stream.pointer() + stream.size())
|
|
);
|
|
}
|
|
|
|
DHCPv6::user_class_type DHCPv6::user_class_type::from_option(const option& opt) {
|
|
if (opt.data_size() < sizeof(uint16_t)) {
|
|
throw malformed_option();
|
|
}
|
|
user_class_type output;
|
|
output.data = Internals::option2class_option_data<data_type>(
|
|
opt.data_ptr(), static_cast<uint32_t>(opt.data_size())
|
|
);
|
|
return output;
|
|
}
|
|
|
|
} // namespace Tins
|