mirror of
https://github.com/mfontanini/libtins
synced 2026-01-23 02:35:57 +01:00
264 lines
7.7 KiB
C++
264 lines
7.7 KiB
C++
/*
|
|
* Copyright (c) 2014, 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.
|
|
*
|
|
*/
|
|
|
|
#ifdef TINS_DEBUG
|
|
#include <cassert>
|
|
#endif
|
|
#include <cstring>
|
|
#include "pppoe.h"
|
|
#include "rawpdu.h"
|
|
#include "exceptions.h"
|
|
|
|
namespace Tins {
|
|
|
|
PPPoE::PPPoE()
|
|
: _header(), _tags_size()
|
|
{
|
|
version(1);
|
|
type(1);
|
|
}
|
|
|
|
PPPoE::PPPoE(const uint8_t *buffer, uint32_t total_sz)
|
|
: _tags_size()
|
|
{
|
|
if(total_sz < sizeof(_header))
|
|
throw malformed_packet();
|
|
std::memcpy(&_header, buffer, sizeof(_header));
|
|
buffer += sizeof(_header);
|
|
total_sz -= sizeof(_header);
|
|
total_sz = std::min(total_sz, (uint32_t)payload_length());
|
|
// If this is a session data packet
|
|
if(code() == 0) {
|
|
if(total_sz > 0) {
|
|
inner_pdu(
|
|
new RawPDU(buffer, total_sz)
|
|
);
|
|
}
|
|
}
|
|
else {
|
|
const uint8_t *end = buffer + total_sz;
|
|
while(buffer < end) {
|
|
if(buffer + sizeof(uint32_t) * 2 > end)
|
|
throw malformed_packet();
|
|
uint16_t opt_type;
|
|
std::memcpy(&opt_type, buffer, sizeof(uint16_t));
|
|
uint16_t opt_len;
|
|
std::memcpy(&opt_len, buffer + sizeof(uint16_t), sizeof(uint16_t));
|
|
buffer += sizeof(uint16_t) * 2;
|
|
total_sz -= sizeof(uint16_t) * 2;
|
|
if(Endian::be_to_host(opt_len) > total_sz)
|
|
throw malformed_packet();
|
|
add_tag(
|
|
tag(
|
|
static_cast<TagTypes>(opt_type),
|
|
Endian::be_to_host(opt_len),
|
|
buffer
|
|
)
|
|
);
|
|
buffer += Endian::be_to_host(opt_len);
|
|
total_sz -= Endian::be_to_host(opt_len);
|
|
}
|
|
}
|
|
}
|
|
|
|
const PPPoE::tag *PPPoE::search_tag(TagTypes identifier) const {
|
|
for(tags_type::const_iterator it = _tags.begin(); it != _tags.end(); ++it) {
|
|
if(it->option() == identifier)
|
|
return &*it;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void PPPoE::version(small_uint<4> new_version) {
|
|
_header.version = new_version;
|
|
}
|
|
|
|
void PPPoE::type(small_uint<4> new_type) {
|
|
_header.type = new_type;
|
|
}
|
|
|
|
void PPPoE::code(uint8_t new_code) {
|
|
_header.code = new_code;
|
|
}
|
|
|
|
void PPPoE::session_id(uint16_t new_session_id) {
|
|
_header.session_id = Endian::host_to_be(new_session_id);
|
|
}
|
|
|
|
void PPPoE::payload_length(uint16_t new_payload_length) {
|
|
_header.payload_length = Endian::host_to_be(new_payload_length);
|
|
}
|
|
|
|
uint32_t PPPoE::header_size() const {
|
|
return sizeof(_header) + _tags_size;
|
|
}
|
|
|
|
void PPPoE::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *)
|
|
{
|
|
#ifdef TINS_DEBUG
|
|
assert(total_sz == sizeof(_header) + _tags_size);
|
|
#endif
|
|
std::memcpy(buffer, &_header, sizeof(_header));
|
|
if(_tags_size > 0)
|
|
((pppoe_hdr*)buffer)->payload_length = Endian::host_to_be(_tags_size);
|
|
buffer += sizeof(_header);
|
|
uint16_t uint16_t_buffer;
|
|
for(tags_type::const_iterator it = _tags.begin(); it != _tags.end(); ++it) {
|
|
uint16_t_buffer = it->option();
|
|
std::memcpy(buffer, &uint16_t_buffer, sizeof(uint16_t));
|
|
uint16_t_buffer = Endian::host_to_be(static_cast<uint16_t>(it->length_field()));
|
|
std::memcpy(buffer + sizeof(uint16_t), &uint16_t_buffer, sizeof(uint16_t));
|
|
std::copy(
|
|
it->data_ptr(),
|
|
it->data_ptr() + it->data_size(),
|
|
buffer + sizeof(uint16_t) * 2
|
|
);
|
|
buffer += sizeof(uint16_t) * 2 + it->data_size();
|
|
}
|
|
}
|
|
|
|
void PPPoE::add_tag(const tag &option) {
|
|
_tags_size += static_cast<uint16_t>(option.data_size() + sizeof(uint16_t) * 2);
|
|
_tags.push_back(option);
|
|
}
|
|
|
|
// *********************** Setters *************************
|
|
|
|
void PPPoE::end_of_list() {
|
|
add_tag(
|
|
END_OF_LIST
|
|
);
|
|
}
|
|
|
|
void PPPoE::service_name(const std::string &value) {
|
|
add_tag_iterable(SERVICE_NAME, value);
|
|
}
|
|
|
|
void PPPoE::ac_name(const std::string &value) {
|
|
add_tag_iterable(AC_NAME, value);
|
|
}
|
|
|
|
void PPPoE::host_uniq(const byte_array &value) {
|
|
add_tag_iterable(HOST_UNIQ, value);
|
|
}
|
|
|
|
void PPPoE::ac_cookie(const byte_array &value) {
|
|
add_tag_iterable(AC_COOKIE, value);
|
|
}
|
|
|
|
void PPPoE::vendor_specific(const vendor_spec_type &value) {
|
|
std::vector<uint8_t> buffer(sizeof(uint32_t) + value.data.size());
|
|
uint32_t tmp_vendor_id = Endian::host_to_be(value.vendor_id);
|
|
std::memcpy(&buffer[0], &tmp_vendor_id, sizeof(uint32_t));
|
|
std::copy(
|
|
value.data.begin(),
|
|
value.data.end(),
|
|
buffer.begin() + sizeof(uint32_t)
|
|
);
|
|
add_tag(
|
|
tag(
|
|
VENDOR_SPECIFIC,
|
|
buffer.begin(),
|
|
buffer.end()
|
|
)
|
|
);
|
|
}
|
|
|
|
void PPPoE::relay_session_id(const byte_array &value) {
|
|
add_tag_iterable(RELAY_SESSION_ID, value);
|
|
}
|
|
|
|
void PPPoE::service_name_error(const std::string &value) {
|
|
add_tag_iterable(SERVICE_NAME_ERROR, value);
|
|
}
|
|
|
|
void PPPoE::ac_system_error(const std::string &value) {
|
|
add_tag_iterable(AC_SYSTEM_ERROR, value);
|
|
}
|
|
|
|
void PPPoE::generic_error(const std::string &value) {
|
|
add_tag_iterable(GENERIC_ERROR, value);
|
|
}
|
|
|
|
// *********************** Getters *************************
|
|
|
|
std::string PPPoE::service_name() const {
|
|
return search_and_convert<std::string>(SERVICE_NAME);
|
|
}
|
|
|
|
std::string PPPoE::ac_name() const {
|
|
return search_and_convert<std::string>(AC_NAME);
|
|
}
|
|
|
|
byte_array PPPoE::host_uniq() const {
|
|
return search_and_convert<byte_array>(HOST_UNIQ);
|
|
}
|
|
|
|
byte_array PPPoE::ac_cookie() const {
|
|
return search_and_convert<byte_array>(AC_COOKIE);
|
|
}
|
|
|
|
PPPoE::vendor_spec_type PPPoE::vendor_specific() const {
|
|
const tag *t = search_tag(VENDOR_SPECIFIC);
|
|
if(!t)
|
|
throw option_not_found();
|
|
return t->to<vendor_spec_type>();
|
|
}
|
|
|
|
byte_array PPPoE::relay_session_id() const {
|
|
return search_and_convert<byte_array>(RELAY_SESSION_ID);
|
|
}
|
|
|
|
std::string PPPoE::service_name_error() const {
|
|
return search_and_convert<std::string>(SERVICE_NAME_ERROR);
|
|
}
|
|
|
|
std::string PPPoE::ac_system_error() const {
|
|
return search_and_convert<std::string>(AC_SYSTEM_ERROR);
|
|
}
|
|
|
|
std::string PPPoE::generic_error() const {
|
|
return search_and_convert<std::string>(GENERIC_ERROR);
|
|
}
|
|
|
|
PPPoE::vendor_spec_type PPPoE::vendor_spec_type::from_option(const tag &opt) {
|
|
if(opt.data_size() < sizeof(uint32_t))
|
|
throw malformed_option();
|
|
vendor_spec_type output;
|
|
std::memcpy(&output.vendor_id, opt.data_ptr(), sizeof(uint32_t));
|
|
output.vendor_id = Endian::be_to_host(output.vendor_id);
|
|
output.data.assign(
|
|
opt.data_ptr() + sizeof(uint32_t),
|
|
opt.data_ptr() + opt.data_size()
|
|
);
|
|
return output;
|
|
}
|
|
} //namespace Tins
|
|
|