Browse Source

Split data and control packets

master
Théophile Bastian 2 years ago
parent
commit
c5541d1e79
  1. 75
      UdpVpn.cpp
  2. 13
      UdpVpn.hpp
  3. 2
      UdpVpnClient.cpp
  4. 2
      UdpVpnClient.hpp
  5. 4
      UdpVpnServer.cpp
  6. 2
      UdpVpnServer.hpp
  7. 119
      VpnPacket.cpp
  8. 136
      VpnPacket.hpp
  9. 5
      VpnPeer.cpp
  10. 6
      VpnPeer.hpp
  11. 5
      main.cpp

75
UdpVpn.cpp

@ -8,13 +8,15 @@ @@ -8,13 +8,15 @@
#include <string.h>
#include <poll.h>
#include <errno.h>
#include <math.h>
#include "ip_header.hpp"
static const size_t VPN_MTU = 1460; // TODO determine this -- issue #3
UdpVpn::UdpVpn()
: _stopped(false), _vpn_mtu(VPN_MTU), _tun_dev("cvpn%d"), _peer(nullptr)
: _stopped(false), _dump_requested(false), _vpn_mtu(VPN_MTU),
_tun_dev("cvpn%d"), _peer(nullptr)
{
_tun_dev.set_mtu(VpnPacket::get_tunnelled_mtu(_vpn_mtu));
_socket = socket(AF_INET6, SOCK_DGRAM, 0);
@ -42,6 +44,11 @@ void UdpVpn::run() { @@ -42,6 +44,11 @@ void UdpVpn::run() {
poll_fds[1].events = POLLIN;
while(!_stopped) {
if(_dump_requested) {
dump_state();
_dump_requested = false;
}
rc = poll(poll_fds, nfds, -1);
if(rc < 0) {
@ -75,7 +82,7 @@ size_t UdpVpn::read_from_tun(char* buffer, size_t len) { @@ -75,7 +82,7 @@ size_t UdpVpn::read_from_tun(char* buffer, size_t len) {
return _tun_dev.read(buffer, len);
}
size_t UdpVpn::read_from_tun(TunnelledPacket& packet) {
size_t UdpVpn::read_from_tun(VpnDataPacket& packet) {
size_t payload_space = packet.get_payload_space();
size_t nread = read_from_tun(packet.get_payload(), payload_space);
packet.set_payload_size(nread);
@ -136,9 +143,8 @@ size_t UdpVpn::transmit_to_peer(VpnPacket& packet) { @@ -136,9 +143,8 @@ size_t UdpVpn::transmit_to_peer(VpnPacket& packet) {
}
void UdpVpn::receive_from_tun() {
VpnPacket packet(_vpn_mtu);
TunnelledPacket tunnelled = TunnelledPacket::create(packet);
size_t nread = read_from_tun(tunnelled);
VpnDataPacket packet(_vpn_mtu, false);
size_t nread = read_from_tun(packet);
if(nread == 0)
return;
@ -149,8 +155,8 @@ void UdpVpn::receive_from_tun() { @@ -149,8 +155,8 @@ void UdpVpn::receive_from_tun() {
packet.set_peer(_peer.get());
kdebugf("Transmitting %s -> %s, size %d\n",
format_address(tunnelled.get_ipv6_header().source.s6_addr),
format_address(tunnelled.get_ipv6_header().dest.s6_addr),
format_address(packet.get_ipv6_header().source.s6_addr),
format_address(packet.get_ipv6_header().dest.s6_addr),
nread);
packet.prepare_for_sending();
@ -158,7 +164,7 @@ void UdpVpn::receive_from_tun() { @@ -158,7 +164,7 @@ void UdpVpn::receive_from_tun() {
}
void UdpVpn::receive_from_udp() {
VpnPacket packet(_vpn_mtu);
VpnPacket packet(_vpn_mtu, true);
sockaddr_in6 peer_ext_addr;
size_t nread = read_from_udp(packet, peer_ext_addr);
if(nread == 0)
@ -167,32 +173,41 @@ void UdpVpn::receive_from_udp() { @@ -167,32 +173,41 @@ void UdpVpn::receive_from_udp() {
// If we don't have a peer yet -- we're just setting the peer to nullptr.
packet.set_peer(_peer.get());
for(VpnPacketTLV tlv=packet.first_tlv();
!tlv.past_the_end();
tlv.seek_next_tlv())
{
switch(tlv.get_type()) {
case VpnPacket::PAYLOAD_TYPE_TUNNELLED:
{
TunnelledPacket tunnelled(tlv);
acquire_peer(tunnelled, peer_ext_addr);
receive_tunnelled_tlv(tunnelled);
}
break;
case VpnPacket::PAYLOAD_TYPE_UNDEF:
default:
debugf("#%d+%lu: ignoring TLV with bad type %d.\n",
packet.get_seqno(), tlv.get_offset(),
tlv.get_type());
break;
if(packet.is_control()) {
VpnControlPacket ctrl_packet(std::move(packet));
for(VpnPacketTLV tlv=ctrl_packet.first_tlv();
!tlv.past_the_end();
tlv.seek_next_tlv())
{
switch(tlv.get_type()) {
case VpnPacketTLV::PAYLOAD_TYPE_UNDEF:
default:
debugf("#%d+%lu: ignoring TLV with bad type %d.\n",
ctrl_packet.get_seqno(), tlv.get_offset(),
tlv.get_type());
break;
}
}
} else {
VpnDataPacket data_packet(std::move(packet));
acquire_peer(data_packet, peer_ext_addr);
receive_tunnelled_tlv(data_packet);
}
}
void UdpVpn::receive_tunnelled_tlv(TunnelledPacket& packet) {
void UdpVpn::receive_tunnelled_tlv(VpnDataPacket& packet) {
// Reinject into tun
kdebugf("Reinjecting tunnelled packet of size %d\n",
packet.get_payload_size());
kdebugf("Reinjecting tunnelled packet of size %d [#%ld, TS=%ld μs]\n",
packet.get_payload_size(),
packet.get_seqno(),
packet.get_sending_timestamp());
_tun_dev.write(packet.get_payload(), packet.get_payload_size());
}
void UdpVpn::dump_state() const {
printf("====== State dump ======\n");
printf("Packet loss rate: %.0lf%%\n",
round(_peer->get_loss_logger().get_loss_rate() * 100));
printf("==== End state dump ====\n");
}

13
UdpVpn.hpp

@ -41,13 +41,16 @@ class UdpVpn { @@ -41,13 +41,16 @@ class UdpVpn {
// Stop the server. Can be called from an interrupt.
void stop() { _stopped = true; }
// A state dump has been requested
void dump_requested() { _dump_requested = true; }
protected:
virtual void acquire_peer(
TunnelledPacket& packet,
VpnDataPacket& packet,
const sockaddr_in6& peer_ext_addr) = 0;
size_t read_from_tun(char* buffer, size_t len);
size_t read_from_tun(TunnelledPacket& packet);
size_t read_from_tun(VpnDataPacket& packet);
size_t read_from_udp(char* buffer, size_t len, sockaddr_in6& peer_addr);
size_t read_from_udp(VpnPacket& packet, sockaddr_in6& peer_addr);
@ -56,10 +59,12 @@ class UdpVpn { @@ -56,10 +59,12 @@ class UdpVpn {
void receive_from_tun();
void receive_from_udp();
void receive_tunnelled_tlv(TunnelledPacket& packet);
void receive_tunnelled_tlv(VpnDataPacket& packet);
void dump_state() const;
int _socket;
bool _stopped;
bool _stopped, _dump_requested;
size_t _vpn_mtu;

2
UdpVpnClient.cpp

@ -8,7 +8,7 @@ UdpVpnClient::UdpVpnClient(const struct sockaddr_in6& server) : UdpVpn() { @@ -8,7 +8,7 @@ UdpVpnClient::UdpVpnClient(const struct sockaddr_in6& server) : UdpVpn() {
}
void UdpVpnClient::acquire_peer(
TunnelledPacket& packet,
VpnDataPacket& packet,
const sockaddr_in6&)
{
if(!packet.parse_as_ipv6())

2
UdpVpnClient.hpp

@ -8,6 +8,6 @@ class UdpVpnClient: public UdpVpn { @@ -8,6 +8,6 @@ class UdpVpnClient: public UdpVpn {
protected:
virtual void acquire_peer(
TunnelledPacket& packet,
VpnDataPacket& packet,
const sockaddr_in6& peer_ext_addr);
};

4
UdpVpnServer.cpp

@ -16,7 +16,7 @@ UdpVpnServer::UdpVpnServer(const struct in6_addr& bind_addr6, in_port_t port) @@ -16,7 +16,7 @@ UdpVpnServer::UdpVpnServer(const struct in6_addr& bind_addr6, in_port_t port)
}
void UdpVpnServer::acquire_peer(
TunnelledPacket& packet,
VpnDataPacket& packet,
const sockaddr_in6& peer_ext_addr)
{
if(_peer)
@ -28,7 +28,7 @@ void UdpVpnServer::acquire_peer( @@ -28,7 +28,7 @@ void UdpVpnServer::acquire_peer(
const in6_addr& peer_inner_addr = packet.get_ipv6_header().source;
_peer = std::make_unique<VpnPeer>(this, peer_ext_addr, peer_inner_addr);
packet.get_packet().set_peer(_peer.get());
packet.set_peer(_peer.get());
debugf("Got new peer %s:%d -- %s\n",
format_address(peer_ext_addr.sin6_addr.s6_addr),

2
UdpVpnServer.hpp

@ -11,7 +11,7 @@ class UdpVpnServer: public UdpVpn { @@ -11,7 +11,7 @@ class UdpVpnServer: public UdpVpn {
UdpVpnServer(const struct in6_addr& bind_addr6, in_port_t port);
protected:
virtual void acquire_peer(
TunnelledPacket& packet,
VpnDataPacket& packet,
const sockaddr_in6& peer_ext_addr);
void bind(const struct in6_addr& bind_addr6, in_port_t port);

119
VpnPacket.cpp

@ -5,7 +5,7 @@ @@ -5,7 +5,7 @@
#include <cstring>
const size_t VpnPacket::VPN_HEADER_BYTES = 8;
const size_t VpnPacket::TLV_HEADER_BYTES = 3;
const size_t VpnControlPacket::TLV_HEADER_BYTES = 3;
static const size_t OUTER_HEADERS_BYTES =
40 /* IPv6 header */ + 8 /* UDP header */;
@ -13,40 +13,67 @@ static const size_t OUTER_HEADERS_BYTES = @@ -13,40 +13,67 @@ static const size_t OUTER_HEADERS_BYTES =
static const int
DATA_SEQNO_POS = 0,
DATA_CTRLBIT_POS = 4,
DATA_TIMESTAMP_POS = 4;
VpnPacket::VpnPacket(size_t mtu)
: _peer(nullptr), _data_space(mtu-OUTER_HEADERS_BYTES),
VpnPacket::VpnPacket(size_t mtu, bool inbound)
: _peer(nullptr), _inbound(inbound), _data_space(mtu-OUTER_HEADERS_BYTES),
_data_size(VPN_HEADER_BYTES), _reception_timestamp(0)
{
_data = new char[mtu - OUTER_HEADERS_BYTES];
_data = std::unique_ptr<char[]>(new char[mtu - OUTER_HEADERS_BYTES]);
}
VpnPacket::~VpnPacket() {
delete[] _data;
}
VpnPacket::~VpnPacket() {}
VpnPacketTLV VpnPacket::first_tlv() {
return VpnPacketTLV(*this, 0);
}
VpnPacket::VpnPacket(VpnPacket&& move_from) :
_peer(move_from._peer),
_inbound(move_from._inbound),
_data(std::move(move_from._data)),
_data_space(move_from._data_space),
_data_size(move_from._data_size),
_reception_timestamp(move_from._reception_timestamp)
{}
size_t VpnPacket::get_tunnelled_mtu(size_t udp_mtu) {
return udp_mtu - OUTER_HEADERS_BYTES - VPN_HEADER_BYTES - TLV_HEADER_BYTES;
return udp_mtu - OUTER_HEADERS_BYTES - VPN_HEADER_BYTES;
}
void VpnPacket::set_peer(VpnPeer* peer) {
_peer = peer;
if(_peer && _inbound)
_peer->got_inbound_packet(*this);
}
uint32_t VpnPacket::get_seqno() const {
return *(uint32_t*)(_data + DATA_SEQNO_POS);
return ntohl(*(uint32_t*)(_data.get() + DATA_SEQNO_POS));
}
uint32_t VpnPacket::get_sending_timestamp() const {
return *(uint32_t*)(_data + DATA_TIMESTAMP_POS);
return ntohl(
*(uint32_t*)(_data.get() + DATA_TIMESTAMP_POS) & 0x7fffffffUL
);
}
bool VpnPacket::is_control() const {
return *(unsigned char*)(_data.get() + DATA_CTRLBIT_POS) & 0x80;
}
void VpnPacket::set_control(bool is_control) {
unsigned char* ctrl_field =
(unsigned char*) (_data.get() + DATA_CTRLBIT_POS);
*ctrl_field &= 0x7f;
if(is_control)
*ctrl_field |= 0x80;
}
void VpnPacket::prepare_for_sending() {
*(uint32_t*)(_data + DATA_SEQNO_POS) = next_seqno();
*(uint32_t*)(_data + DATA_TIMESTAMP_POS) =
std::chrono::time_point_cast<std::chrono::microseconds>(
std::chrono::steady_clock::now()).time_since_epoch().count();
uint32_t* ts_field = (uint32_t*) (_data.get() + DATA_TIMESTAMP_POS);
*ts_field &= 0x80000000UL;
*(uint32_t*)(_data.get() + DATA_SEQNO_POS) = htonl(next_seqno());
*ts_field |=
htonl((std::chrono::time_point_cast<std::chrono::microseconds>(
std::chrono::steady_clock::now()).time_since_epoch().count())
& 0x7fffffffUL);
}
void VpnPacket::upon_reception() {
@ -61,8 +88,35 @@ uint32_t VpnPacket::next_seqno() { @@ -61,8 +88,35 @@ uint32_t VpnPacket::next_seqno() {
return _peer->next_seqno();
}
VpnControlPacket::VpnControlPacket(size_t mtu, bool inbound)
: VpnPacket(mtu, inbound)
{
set_control(true);
}
VpnControlPacket::VpnControlPacket(VpnPacket&& move_from)
: VpnPacket(std::move(move_from))
{}
VpnPacketTLV VpnControlPacket::first_tlv() {
return VpnPacketTLV(*this, 0);
}
VpnDataPacket::VpnDataPacket(size_t mtu, bool inbound)
: VpnPacket(mtu, inbound), _ipv6_parsed(false)
{
set_control(false);
}
VpnDataPacket::VpnDataPacket(VpnPacket&& move_from)
: VpnPacket(std::move(move_from)), _ipv6_parsed(false)
{}
bool VpnDataPacket::parse_as_ipv6() {
return parse_ipv6_header(get_payload(), get_payload_size(), _ipv6_header);
}
VpnPacketTLV::VpnPacketTLV(VpnPacket& packet, size_t payload_offset)
VpnPacketTLV::VpnPacketTLV(VpnControlPacket& packet, size_t payload_offset)
: _packet(packet), _tlv_pos(payload_offset)
{}
@ -71,10 +125,10 @@ VpnPacketTLV::VpnPacketTLV(const VpnPacketTLV& other) : @@ -71,10 +125,10 @@ VpnPacketTLV::VpnPacketTLV(const VpnPacketTLV& other) :
{}
VpnPacketTLV VpnPacketTLV::create(
VpnPacket& packet, VpnPacket::PayloadType type)
VpnControlPacket& packet, VpnPacketTLV::PayloadType type)
{
VpnPacketTLV tlv = VpnPacketTLV(packet, packet.get_payload_size());
packet.increase_payload_size(VpnPacket::TLV_HEADER_BYTES);
packet.increase_payload_size(VpnControlPacket::TLV_HEADER_BYTES);
char* data = tlv.get_data();
data[0] = type;
@ -89,7 +143,8 @@ VpnPacketTLV VpnPacketTLV::next_tlv() { @@ -89,7 +143,8 @@ VpnPacketTLV VpnPacketTLV::next_tlv() {
}
void VpnPacketTLV::seek_next_tlv() {
_tlv_pos = _tlv_pos + VpnPacket::TLV_HEADER_BYTES + get_payload_size();
_tlv_pos =
_tlv_pos + VpnControlPacket::TLV_HEADER_BYTES + get_payload_size();
}
uint16_t VpnPacketTLV::get_payload_size() const {
@ -108,25 +163,9 @@ uint16_t VpnPacketTLV::get_payload_space() const { @@ -108,25 +163,9 @@ uint16_t VpnPacketTLV::get_payload_space() const {
+ get_payload_size();
}
VpnPacket::PayloadType VpnPacketTLV::get_type() const {
return (VpnPacket::PayloadType)(*(uint8_t*)(get_data()));
VpnPacketTLV::PayloadType VpnPacketTLV::get_type() const {
return (PayloadType)(*(uint8_t*)(get_data()));
}
void VpnPacketTLV::set_type(VpnPacket::PayloadType type) {
void VpnPacketTLV::set_type(VpnPacketTLV::PayloadType type) {
*(uint8_t*)(get_data()) = (uint8_t) type;
}
TunnelledPacket::TunnelledPacket(VpnPacket& packet, size_t payload_offset)
: VpnPacketTLV(packet, payload_offset)
{}
TunnelledPacket::TunnelledPacket(const VpnPacketTLV& copy)
: VpnPacketTLV(copy._packet, copy._tlv_pos)
{}
TunnelledPacket TunnelledPacket::create(VpnPacket& packet) {
return VpnPacketTLV::create(packet, VpnPacket::PAYLOAD_TYPE_TUNNELLED);
}
bool TunnelledPacket::parse_as_ipv6() {
return parse_ipv6_header(get_payload(), get_payload_size(), _ipv6_header);
}

136
VpnPacket.hpp

@ -14,7 +14,17 @@ @@ -14,7 +14,17 @@
* +---------------+---------------+---------------+---------------+
* | Sequence number [4B] |
* +---------------------------------------------------------------+
* | Sending timestamp (μs) [4B] |
* |C| Sending timestamp (μs) [4B-1b] |
* +---------------+-----------------------------------------------+
* | ... |
* +---------------------------------------------------------------+
*
* Where C is a single bit. If set, the packet is a control packet, containing
* TLVs. If unset, the packet is a tunnelled packet bearing data to be
* reinjected.
*
* If C is set, the remaining of the packet has the following structure:
*
* +---------------+-----------------------------------------------+
* | Type [1B] | First payload size (B) [2B] | Payload |
* +---------------+-----------------------------------------------+
@ -27,7 +37,7 @@ @@ -27,7 +37,7 @@
* | ... |
* +---------------------------------------------------------------+
*
* Where
* Where:
* - Type is one of the values from PayloadType below;
* - Sender ID is an arbitrary value, recommended to be randomly chosen
* - Payload size is the size of the payload (excluding headers), in bytes;
@ -40,32 +50,30 @@ class VpnPacketTLV; @@ -40,32 +50,30 @@ class VpnPacketTLV;
class VpnPacket {
public:
static const size_t VPN_HEADER_BYTES;
static const size_t TLV_HEADER_BYTES;
enum PayloadType {
PAYLOAD_TYPE_UNDEF, ///< Undefined packet type
PAYLOAD_TYPE_TUNNELLED, ///< A tunnelled packet
PAYLOAD_TYPE_RR, ///< Receiver report
PAYLOAD_TYPE_REMB, ///< Receiver Estimated Maximum Bitrate
};
class PeerNotSet: public std::exception {};
VpnPacket(size_t mtu);
VpnPacket(size_t mtu, bool inbound);
~VpnPacket();
VpnPacketTLV first_tlv();
// Remove copy constructor and operator=
VpnPacket(const VpnPacket& copy) = delete;
VpnPacket& operator=(const VpnPacket& copy) = delete;
/// Move constructor
VpnPacket(VpnPacket&& move_from);
VpnPacket& operator=(VpnPacket&& move_from) = delete;
/// Get the maximal payload space for a given tunnel MTU
static size_t get_tunnelled_mtu(size_t udp_mtu);
/// Set packet peer -- used for sequence numbers
void set_peer(VpnPeer* peer) { _peer = peer; }
/// Set packet peer -- used for sequence numbers and loss rate
void set_peer(VpnPeer* peer);
/// Get a pointer to the packet payload (const version)
const char* get_payload() const { return _data + VPN_HEADER_BYTES; }
const char* get_payload() const {
return _data.get() + VPN_HEADER_BYTES; }
/// Get a pointer to the packet payload
char* get_payload() { return _data + VPN_HEADER_BYTES; }
char* get_payload() { return _data.get() + VPN_HEADER_BYTES; }
/// Get a pointer to the first free byte of the packet payload
char* get_next_payload() { return get_payload() + get_payload_size(); }
/// Get the space allocated for the packet payload
@ -83,9 +91,9 @@ class VpnPacket { @@ -83,9 +91,9 @@ class VpnPacket {
_data_size += payload_size_increment; }
/// Get a pointer to the full packet data (const version)
const char* get_data() const { return _data; }
const char* get_data() const { return _data.get(); }
/// Get a pointer to the full packet data
char* get_data() { return _data; }
char* get_data() { return _data.get(); }
/// Get the space allocated for the packet
size_t get_data_space() const { return _data_space; }
/// Get the total current size of the packet
@ -99,6 +107,8 @@ class VpnPacket { @@ -99,6 +107,8 @@ class VpnPacket {
uint32_t get_sending_timestamp() const;
/// Get this packet's reception timestamp
uint32_t get_reception_timestamp() const { return _reception_timestamp; }
/// Check whether this packet is control or data
bool is_control() const;
/** Fill the headers of the packet. This method must be called as close
* to the time the packet is actually sent as possible, as it handles
@ -111,30 +121,69 @@ class VpnPacket { @@ -111,30 +121,69 @@ class VpnPacket {
*/
void upon_reception();
protected:
void set_control(bool is_control);
private: // methods
inline uint32_t next_seqno();
private:
VpnPeer* _peer; // raw pointer: we do not own the peer in any way
bool _inbound; ///< is the packet received or sent?
char* _data;
std::unique_ptr<char[]> _data;
size_t _data_space, _data_size;
uint32_t _reception_timestamp;
};
class VpnControlPacket: public VpnPacket {
public:
static const size_t TLV_HEADER_BYTES;
VpnControlPacket(size_t mtu, bool inbound);
VpnControlPacket(VpnPacket&& move_from);
VpnPacketTLV first_tlv();
};
/** A packet sent through the VPN tunnel. */
class VpnDataPacket: public VpnPacket {
public:
VpnDataPacket(size_t mtu, bool inbound);
VpnDataPacket(VpnPacket&& move_from);
static VpnDataPacket create(VpnPacket& packet);
/// Try to parse the packet as IPv6, return `false` upon failure.
bool parse_as_ipv6();
bool ipv6_parsed() const { return _ipv6_parsed; }
const IPv6Header& get_ipv6_header() const { return _ipv6_header; }
private:
bool _ipv6_parsed;
IPv6Header _ipv6_header;
};
/** Base class for a TLV contained in a VpnPacket */
class VpnPacketTLV {
public:
VpnPacketTLV(VpnPacket& packet, size_t payload_offset);
VpnPacketTLV(VpnControlPacket& packet, size_t payload_offset);
VpnPacketTLV(const VpnPacketTLV& other);
enum PayloadType {
PAYLOAD_TYPE_UNDEF, ///< Undefined packet type
PAYLOAD_TYPE_RR, ///< Receiver report
PAYLOAD_TYPE_REMB, ///< Receiver Estimated Maximum Bitrate
};
static VpnPacketTLV create(
VpnPacket& packet,
VpnPacket::PayloadType type=VpnPacket::PAYLOAD_TYPE_UNDEF);
VpnControlPacket& packet,
PayloadType type=PAYLOAD_TYPE_UNDEF);
const VpnPacket& get_packet() const { return _packet; }
VpnPacket& get_packet() { return _packet; }
const VpnControlPacket& get_packet() const { return _packet; }
VpnControlPacket& get_packet() { return _packet; }
/// Get the next TLV in this packet.
VpnPacketTLV next_tlv();
@ -150,10 +199,12 @@ class VpnPacketTLV { @@ -150,10 +199,12 @@ class VpnPacketTLV {
/// Get a pointer to the payload (const version)
const char* get_payload() const {
return _packet.get_payload() + _tlv_pos + VpnPacket::TLV_HEADER_BYTES; }
return _packet.get_payload() + _tlv_pos
+ VpnControlPacket::TLV_HEADER_BYTES; }
/// Get a pointer to the payload
char* get_payload() {
return _packet.get_payload() + _tlv_pos + VpnPacket::TLV_HEADER_BYTES; }
return _packet.get_payload() + _tlv_pos
+ VpnControlPacket::TLV_HEADER_BYTES; }
/// Get the current payload size
uint16_t get_payload_size() const;
/// Set the current payload size
@ -168,43 +219,22 @@ class VpnPacketTLV { @@ -168,43 +219,22 @@ class VpnPacketTLV {
char* get_data() { return _packet.get_payload() + _tlv_pos; }
/// Get the current raw data size
uint16_t get_data_size() const {
return get_payload_size() + VpnPacket::TLV_HEADER_BYTES; }
return get_payload_size() + VpnControlPacket::TLV_HEADER_BYTES; }
/// Set the current raw data size
void set_data_size(uint16_t size) {
set_payload_size(size + VpnPacket::TLV_HEADER_BYTES); }
set_payload_size(size + VpnControlPacket::TLV_HEADER_BYTES); }
/// Get this TLV's type
VpnPacket::PayloadType get_type() const;
PayloadType get_type() const;
bool operator==(const VpnPacketTLV& other) const {
return &_packet == &other._packet && _tlv_pos == other._tlv_pos; }
protected: // meth
/// Set this TLV's type
void set_type(VpnPacket::PayloadType type);
void set_type(PayloadType type);
protected:
VpnPacket& _packet;
VpnControlPacket& _packet;
size_t _tlv_pos;
friend class TunnelledPacket;
};
/** A packet sent through the VPN tunnel.
*
* This must instantiated just before filling it with data. */
class TunnelledPacket: public VpnPacketTLV {
public:
TunnelledPacket(VpnPacket& packet, size_t payload_offset);
TunnelledPacket(const VpnPacketTLV& copy);
static TunnelledPacket create(VpnPacket& packet);
/// Try to parse the packet as IPv6, return `false` upon failure.
bool parse_as_ipv6();
bool ipv6_parsed() const { return _ipv6_parsed; }
const IPv6Header& get_ipv6_header() const { return _ipv6_header; }
private:
bool _ipv6_parsed;
IPv6Header _ipv6_header;
};

5
VpnPeer.cpp

@ -29,9 +29,14 @@ size_t VpnPeer::write(const VpnPacket& packet) { @@ -29,9 +29,14 @@ size_t VpnPeer::write(const VpnPacket& packet) {
return write(packet.get_data(), packet.get_data_size());
}
void VpnPeer::got_inbound_packet(const VpnPacket& packet) {
_packet_loss.log_packet(packet.get_seqno());
}
PacketLossLogger::PacketLossLogger() : _cur_seqno(0) {}
void PacketLossLogger::log_packet(uint32_t seqno) {
kdebugf(">> Logging %lu (loss %lf)\n", seqno, get_loss_rate());
uint32_t m_seqno = seqno % PACKET_LOSS_HISTSIZE;
int64_t diff = (int64_t)seqno - _cur_seqno;

6
VpnPeer.hpp

@ -56,15 +56,21 @@ class VpnPeer { @@ -56,15 +56,21 @@ class VpnPeer {
void set_int_addr(const in6_addr& int_addr);
const PacketLossLogger& get_loss_logger() { return _packet_loss; }
size_t write(const char* data, size_t len);
size_t write(const VpnPacket& packet);
uint32_t peek_next_seqno() const { return _next_send_seqno; }
uint32_t next_seqno() { return _next_send_seqno++; }
void got_inbound_packet(const VpnPacket& packet);
private:
UdpVpn* _vpn;
sockaddr_in6 _ext_addr;
in6_addr _int_addr;
uint32_t _next_send_seqno;
PacketLossLogger _packet_loss;
};

5
main.cpp

@ -27,6 +27,10 @@ void stop_sig_handler(int signal) { @@ -27,6 +27,10 @@ void stop_sig_handler(int signal) {
vpn_instance->stop();
}
void dump_sig_handler(int /*signal*/) {
vpn_instance->dump_requested();
}
bool parse_options(int argc, char** argv, ProgOptions& opts) {
int option;
memset(&opts, 0, sizeof(opts));
@ -91,6 +95,7 @@ int main(int argc, char** argv) { @@ -91,6 +95,7 @@ int main(int argc, char** argv) {
printf("=== END OPTIONS ==\n\n");
signal(SIGINT, stop_sig_handler);
signal(SIGUSR1, dump_sig_handler);
try {
if(program_options.listen && program_options.has_peer) {

Loading…
Cancel
Save