mirror of
https://github.com/mfontanini/libtins
synced 2026-01-27 20:24:26 +01:00
Added a generic PDUOption class. TCP, IP, DHCP and Dot11* now use this class to store their options.
This commit is contained in:
Matias Fontanini
183
src/dhcp.cpp
183
src/dhcp.cpp
@@ -31,8 +31,6 @@ using std::list;
|
||||
using std::runtime_error;
|
||||
|
||||
namespace Tins {
|
||||
const uint32_t DHCP::MAX_DHCP_SIZE = 312;
|
||||
|
||||
// Magic cookie: uint32_t.
|
||||
DHCP::DHCP() : _size(sizeof(uint32_t)) {
|
||||
opcode(BOOTREQUEST);
|
||||
@@ -63,148 +61,132 @@ DHCP::DHCP(const uint8_t *buffer, uint32_t total_sz)
|
||||
}
|
||||
if(total_sz < args[1])
|
||||
throw std::runtime_error("Not enough size for a DHCP header in the buffer.");
|
||||
add_option((Options)args[0], args[1], buffer);
|
||||
add_option(dhcp_option((Options)args[0], args[1], buffer));
|
||||
buffer += args[1];
|
||||
total_sz -= args[1];
|
||||
}
|
||||
}
|
||||
|
||||
DHCP::DHCPOption::DHCPOption(uint8_t opt, uint8_t len, const uint8_t *val)
|
||||
: option(opt), value(val, val ? (val + len) : val) {
|
||||
|
||||
void DHCP::add_option(const dhcp_option &option) {
|
||||
_options.push_back(option);
|
||||
_size += option.data_size() + (sizeof(uint8_t) << 1);
|
||||
}
|
||||
|
||||
bool DHCP::add_option(Options opt, uint8_t len, const uint8_t *val) {
|
||||
uint32_t opt_size = len + (sizeof(uint8_t) << 1);
|
||||
if(_size + opt_size > MAX_DHCP_SIZE)
|
||||
return false;
|
||||
_options.push_back(DHCPOption((uint8_t)opt, len, val));
|
||||
_size += opt_size;
|
||||
return true;
|
||||
}
|
||||
|
||||
const DHCP::DHCPOption *DHCP::search_option(Options opt) const{
|
||||
const DHCP::dhcp_option *DHCP::search_option(Options opt) const {
|
||||
for(options_type::const_iterator it = _options.begin(); it != _options.end(); ++it) {
|
||||
if(it->option == opt)
|
||||
if(it->option() == opt)
|
||||
return &(*it);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
bool DHCP::add_type_option(Flags type) {
|
||||
void DHCP::type(Flags type) {
|
||||
uint8_t int_type = type;
|
||||
return add_option(DHCP_MESSAGE_TYPE, sizeof(uint8_t), &int_type);
|
||||
add_option(dhcp_option(DHCP_MESSAGE_TYPE, sizeof(uint8_t), &int_type));
|
||||
}
|
||||
|
||||
bool DHCP::add_end_option() {
|
||||
return add_option(DHCP_MESSAGE_TYPE, 0, 0);
|
||||
void DHCP::end() {
|
||||
add_option(dhcp_option(DHCP_MESSAGE_TYPE));
|
||||
}
|
||||
|
||||
bool DHCP::search_type_option(uint8_t *value) {
|
||||
return generic_search(DHCP_MESSAGE_TYPE, value);
|
||||
uint8_t DHCP::type() const {
|
||||
return generic_search(DHCP_MESSAGE_TYPE, type2type<uint8_t>());
|
||||
}
|
||||
|
||||
bool DHCP::add_server_identifier(ipaddress_type ip) {
|
||||
void DHCP::server_identifier(ipaddress_type ip) {
|
||||
uint32_t ip_int = ip;
|
||||
return add_option(DHCP_SERVER_IDENTIFIER, sizeof(uint32_t), (const uint8_t*)&ip_int);
|
||||
add_option(dhcp_option(DHCP_SERVER_IDENTIFIER, sizeof(uint32_t), (const uint8_t*)&ip_int));
|
||||
}
|
||||
|
||||
bool DHCP::search_server_identifier(ipaddress_type *value) {
|
||||
return generic_search(DHCP_SERVER_IDENTIFIER, value);
|
||||
DHCP::ipaddress_type DHCP::server_identifier() const {
|
||||
return generic_search(DHCP_SERVER_IDENTIFIER, type2type<ipaddress_type>());
|
||||
}
|
||||
|
||||
bool DHCP::add_lease_time(uint32_t time) {
|
||||
void DHCP::lease_time(uint32_t time) {
|
||||
time = Endian::host_to_be(time);
|
||||
return add_option(DHCP_LEASE_TIME, sizeof(uint32_t), (const uint8_t*)&time);
|
||||
add_option(dhcp_option(DHCP_LEASE_TIME, sizeof(uint32_t), (const uint8_t*)&time));
|
||||
}
|
||||
|
||||
bool DHCP::search_lease_time(uint32_t *value) {
|
||||
return generic_search(DHCP_LEASE_TIME, value);
|
||||
uint32_t DHCP::lease_time() const {
|
||||
return Endian::host_to_be(generic_search(DHCP_LEASE_TIME, type2type<uint32_t>()));
|
||||
}
|
||||
|
||||
bool DHCP::add_renewal_time(uint32_t time) {
|
||||
void DHCP::renewal_time(uint32_t time) {
|
||||
time = Endian::host_to_be(time);
|
||||
return add_option(DHCP_RENEWAL_TIME, sizeof(uint32_t), (const uint8_t*)&time);
|
||||
add_option(dhcp_option(DHCP_RENEWAL_TIME, sizeof(uint32_t), (const uint8_t*)&time));
|
||||
}
|
||||
|
||||
bool DHCP::search_renewal_time(uint32_t *value) {
|
||||
return generic_search(DHCP_RENEWAL_TIME, value);
|
||||
uint32_t DHCP::renewal_time() const {
|
||||
return Endian::host_to_be(generic_search(DHCP_RENEWAL_TIME, type2type<uint32_t>()));
|
||||
}
|
||||
|
||||
bool DHCP::add_subnet_mask(ipaddress_type mask) {
|
||||
void DHCP::subnet_mask(ipaddress_type mask) {
|
||||
uint32_t mask_int = mask;
|
||||
return add_option(SUBNET_MASK, sizeof(uint32_t), (const uint8_t*)&mask_int);
|
||||
add_option(dhcp_option(SUBNET_MASK, sizeof(uint32_t), (const uint8_t*)&mask_int));
|
||||
}
|
||||
|
||||
bool DHCP::search_subnet_mask(ipaddress_type *value) {
|
||||
return generic_search(SUBNET_MASK, value);
|
||||
DHCP::ipaddress_type DHCP::subnet_mask() const {
|
||||
return generic_search(SUBNET_MASK, type2type<ipaddress_type>());
|
||||
}
|
||||
|
||||
bool DHCP::add_routers_option(const list<ipaddress_type> &routers) {
|
||||
uint32_t size;
|
||||
uint8_t *buffer = serialize_list(routers, size);
|
||||
bool ret = add_option(ROUTERS, size, buffer);
|
||||
delete[] buffer;
|
||||
return ret;
|
||||
void DHCP::routers(const list<ipaddress_type> &routers) {
|
||||
serialization_type buffer = serialize_list(routers);
|
||||
add_option(dhcp_option(ROUTERS, buffer.begin(), buffer.end()));
|
||||
}
|
||||
|
||||
bool DHCP::search_routers_option(std::list<ipaddress_type> *routers) {
|
||||
return generic_search(ROUTERS, routers);
|
||||
std::list<DHCP::ipaddress_type> DHCP::routers() const {
|
||||
return generic_search(ROUTERS, type2type<std::list<ipaddress_type> >());
|
||||
}
|
||||
|
||||
bool DHCP::add_dns_option(const list<ipaddress_type> &dns) {
|
||||
uint32_t size;
|
||||
uint8_t *buffer = serialize_list(dns, size);
|
||||
bool ret = add_option(DOMAIN_NAME_SERVERS, size, buffer);
|
||||
delete[] buffer;
|
||||
return ret;
|
||||
void DHCP::domain_name_servers(const list<ipaddress_type> &dns) {
|
||||
serialization_type buffer = serialize_list(dns);
|
||||
add_option(dhcp_option(DOMAIN_NAME_SERVERS, buffer.begin(), buffer.end()));
|
||||
}
|
||||
|
||||
bool DHCP::search_dns_option(std::list<ipaddress_type> *dns) {
|
||||
return generic_search(DOMAIN_NAME_SERVERS, dns);
|
||||
std::list<DHCP::ipaddress_type> DHCP::domain_name_servers() const {
|
||||
return generic_search(DOMAIN_NAME_SERVERS, type2type<std::list<ipaddress_type> >());
|
||||
}
|
||||
|
||||
bool DHCP::add_broadcast_option(ipaddress_type addr) {
|
||||
void DHCP::broadcast(ipaddress_type addr) {
|
||||
uint32_t int_addr = addr;
|
||||
return add_option(BROADCAST_ADDRESS, sizeof(uint32_t), (uint8_t*)&int_addr);
|
||||
add_option(dhcp_option(BROADCAST_ADDRESS, sizeof(uint32_t), (uint8_t*)&int_addr));
|
||||
}
|
||||
|
||||
bool DHCP::search_broadcast_option(ipaddress_type *value) {
|
||||
return generic_search(BROADCAST_ADDRESS, value);
|
||||
DHCP::ipaddress_type DHCP::broadcast() const {
|
||||
return generic_search(BROADCAST_ADDRESS, type2type<ipaddress_type>());
|
||||
}
|
||||
|
||||
bool DHCP::add_requested_ip_option(ipaddress_type addr) {
|
||||
void DHCP::requested_ip(ipaddress_type addr) {
|
||||
uint32_t int_addr = addr;
|
||||
return add_option(DHCP_REQUESTED_ADDRESS, sizeof(uint32_t), (uint8_t*)&int_addr);
|
||||
add_option(dhcp_option(DHCP_REQUESTED_ADDRESS, sizeof(uint32_t), (uint8_t*)&int_addr));
|
||||
}
|
||||
|
||||
bool DHCP::search_requested_ip_option(ipaddress_type *value) {
|
||||
return generic_search(DHCP_REQUESTED_ADDRESS, value);
|
||||
DHCP::ipaddress_type DHCP::requested_ip() const {
|
||||
return generic_search(DHCP_REQUESTED_ADDRESS, type2type<ipaddress_type>());
|
||||
}
|
||||
|
||||
bool DHCP::add_domain_name(const string &name) {
|
||||
return add_option(DOMAIN_NAME, name.size(), (const uint8_t*)name.c_str());
|
||||
void DHCP::domain_name(const string &name) {
|
||||
add_option(dhcp_option(DOMAIN_NAME, name.size(), (const uint8_t*)name.c_str()));
|
||||
}
|
||||
|
||||
bool DHCP::search_domain_name(std::string *value) {
|
||||
return generic_search(DOMAIN_NAME, value);
|
||||
std::string DHCP::domain_name() const {
|
||||
return generic_search(DOMAIN_NAME, type2type<std::string>());
|
||||
}
|
||||
|
||||
bool DHCP::add_rebind_time(uint32_t time) {
|
||||
void DHCP::rebind_time(uint32_t time) {
|
||||
time = Endian::host_to_be(time);
|
||||
return add_option(DHCP_REBINDING_TIME, sizeof(uint32_t), (uint8_t*)&time);
|
||||
add_option(dhcp_option(DHCP_REBINDING_TIME, sizeof(uint32_t), (uint8_t*)&time));
|
||||
}
|
||||
|
||||
bool DHCP::search_rebind_time(uint32_t *value) {
|
||||
return generic_search(DHCP_REBINDING_TIME, value);
|
||||
uint32_t DHCP::rebind_time() const {
|
||||
return Endian::host_to_be(generic_search(DHCP_REBINDING_TIME, type2type<uint32_t>()));
|
||||
}
|
||||
|
||||
uint8_t *DHCP::serialize_list(const list<ipaddress_type> &ip_list, uint32_t &sz) {
|
||||
uint8_t *buffer = new uint8_t[ip_list.size() * sizeof(uint32_t)];
|
||||
uint32_t *ptr = (uint32_t*)buffer;
|
||||
PDU::serialization_type DHCP::serialize_list(const list<ipaddress_type> &ip_list) {
|
||||
serialization_type buffer(ip_list.size() * sizeof(uint32_t));
|
||||
uint32_t *ptr = (uint32_t*)&buffer[0];
|
||||
for(list<ipaddress_type>::const_iterator it = ip_list.begin(); it != ip_list.end(); ++it)
|
||||
*(ptr++) = *it;
|
||||
sz = sizeof(uint32_t) * ip_list.size();
|
||||
return buffer;
|
||||
}
|
||||
|
||||
@@ -221,52 +203,39 @@ void DHCP::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *pa
|
||||
// Magic cookie
|
||||
*((uint32_t*)&result[0]) = Endian::host_to_be<uint32_t>(0x63825363);
|
||||
for(options_type::const_iterator it = _options.begin(); it != _options.end(); ++it) {
|
||||
*(ptr++) = it->option;
|
||||
*(ptr++) = it->value.size();
|
||||
std::copy(it->value.begin(), it->value.end(), ptr);
|
||||
ptr += it->value.size();
|
||||
*(ptr++) = it->option();
|
||||
*(ptr++) = it->data_size();
|
||||
std::copy(it->data_ptr(), it->data_ptr() + it->data_size(), ptr);
|
||||
ptr += it->data_size();
|
||||
}
|
||||
}
|
||||
BootP::write_serialization(buffer, total_sz, parent);
|
||||
}
|
||||
|
||||
bool DHCP::generic_search(Options opt, std::list<ipaddress_type> *container) {
|
||||
const DHCPOption *option = search_option(opt);
|
||||
std::list<DHCP::ipaddress_type> DHCP::generic_search(Options opt, type2type<std::list<ipaddress_type> >) const {
|
||||
const dhcp_option *option = search_option(opt);
|
||||
if(!option)
|
||||
return false;
|
||||
const uint32_t *ptr = (const uint32_t*)&option->value[0];
|
||||
uint32_t len = option->value.size();
|
||||
throw option_not_found();
|
||||
const uint32_t *ptr = (const uint32_t*)option->data_ptr();
|
||||
uint32_t len = option->data_size();
|
||||
if((len % sizeof(uint32_t)) != 0)
|
||||
return false;
|
||||
throw option_not_found();
|
||||
std::list<ipaddress_type> container;
|
||||
while(len) {
|
||||
container->push_back(ipaddress_type(*(ptr++)));
|
||||
container.push_back(ipaddress_type(*(ptr++)));
|
||||
len -= sizeof(uint32_t);
|
||||
}
|
||||
return true;
|
||||
return container;
|
||||
}
|
||||
|
||||
bool DHCP::generic_search(Options opt, std::string *str) {
|
||||
const DHCPOption *option = search_option(opt);
|
||||
std::string DHCP::generic_search(Options opt, type2type<std::string>) const {
|
||||
const dhcp_option *option = search_option(opt);
|
||||
if(!option)
|
||||
return false;
|
||||
*str = string(option->value.begin(), option->value.end());
|
||||
return true;
|
||||
throw option_not_found();
|
||||
return string(option->data_ptr(), option->data_ptr() + option->data_size());
|
||||
}
|
||||
|
||||
bool DHCP::generic_search(Options opt, uint32_t *value) {
|
||||
if(generic_search<uint32_t>(opt, value)) {
|
||||
*value = Endian::host_to_be(*value);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool DHCP::generic_search(Options opt, ipaddress_type *value) {
|
||||
uint32_t ip_int;
|
||||
if(generic_search(opt, &ip_int)) {
|
||||
*value = IPv4Address(Endian::host_to_be(ip_int));
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
DHCP::ipaddress_type DHCP::generic_search(Options opt, type2type<ipaddress_type>) const {
|
||||
return ipaddress_type(generic_search(opt, type2type<uint32_t>()));
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user