LibFlute Namespace Reference

Namespaces
	IpSec

Classes
class	AlcPacket
	A class for parsing and creating ALC packets. More...
class	EncodingSymbol
	A class for handling FEC encoding symbols. More...
class	File
	Represents a file being transmitted or received. More...
class	FileDeliveryTable
	A class for parsing and creating FLUTE FDTs (File Delivery Tables). More...
struct	FecOti
	OTI values struct. More...
class	Receiver
	FLUTE receiver class. More...
class	Transmitter
	FLUTE transmitter class. More...

Enumerations
enum class	ContentEncoding { NONE , ZLIB , DEFLATE , GZIP }
	Content Encodings. More...
enum class	FecScheme { CompactNoCode }
	Error correction schemes. More...

Functions
static void	create_udp_pkt (char *udp_buffer, const boost::asio::ip::udp::endpoint &endpoint, const char *data, size_t data_len, const boost::asio::ip::address &local_address)
static void	create_ip_hdr (char *ip_buffer, const boost::asio::ip::udp::endpoint &endpoint, size_t pkt_size, const boost::asio::ip::address &local_address)
static uint16_t	calculate_sum (const uint8_t *buffer, size_t len)
static void	write_uint16_be (uint8_t *buffer, uint16_t value)
static void	write_uint32_be (uint8_t *buffer, uint32_t value)
static const Transmitter::FileDescription::date_time_type &	_get_ntp_epoch ()

Enumeration Type Documentation

ContentEncoding

enum LibFlute::ContentEncoding

strong

Content Encodings.

Enumerator
NONE
ZLIB
DEFLATE
GZIP

Definition at line 34 of file flute_types.h.

                             {
    NONE,
    ZLIB,
    DEFLATE,
    GZIP
  };

FecScheme

enum LibFlute::FecScheme

strong

Error correction schemes.

Enumerator
CompactNoCode

Definition at line 44 of file flute_types.h.

                       {
    CompactNoCode
  };

Function Documentation

_get_ntp_epoch()

static const Transmitter::FileDescription::date_time_type& LibFlute::_get_ntp_epoch ( )

static

Definition at line 347 of file Transmitter.cpp.

{
  static bool is_set = false;
  static Transmitter::FileDescription::date_time_type ntp_epoch;
  if (!is_set) {
    std::tm ntp_epoch_tm = {.tm_mday=1, .tm_mon=0, .tm_year=0};
    ntp_epoch = std::chrono::system_clock::from_time_t(std::mktime(&ntp_epoch_tm));
    is_set = true;
  }
  return ntp_epoch;
}

calculate_sum()

static uint16_t LibFlute::calculate_sum ( const uint8_t *  buffer, size_t  len  )

static

Definition at line 941 of file Transmitter.cpp.

{
  uint32_t cksum = 0;
 
  while (len > 1) {
    cksum += (static_cast<uint32_t>(buffer[0]) << 8) | static_cast<uint32_t>(buffer[1]);
    len -= 2;
    buffer += 2;
  }
  if (len > 0) {
    cksum += static_cast<uint32_t>(buffer[0]) << 8;
  }
 
  while (cksum >> 16) {
    cksum = (cksum & 0xFFFF) + (cksum >> 16);
  }
 
  return static_cast<uint16_t>(~cksum);
}

create_ip_hdr()

static void LibFlute::create_ip_hdr ( char *  ip_buffer, const boost::asio::ip::udp::endpoint &  endpoint, size_t  pkt_size, const boost::asio::ip::address &  local_address  )

static

Definition at line 924 of file Transmitter.cpp.

{
  auto *ip_bytes = reinterpret_cast<uint8_t*>(ip_buffer);
 
  memset(ip_bytes, 0, 20);
  ip_bytes[0] = 0x45; // IPv4, 20-byte header
  ip_bytes[1] = 0;
  write_uint16_be(ip_bytes + 2, static_cast<uint16_t>(pkt_size));
  write_uint16_be(ip_bytes + 4, 0);
  write_uint16_be(ip_bytes + 6, 0);
  ip_bytes[8] = 63;
  ip_bytes[9] = endpoint.protocol().protocol();
  write_uint32_be(ip_bytes + 12, local_address.to_v4().to_uint());
  write_uint32_be(ip_bytes + 16, endpoint.address().to_v4().to_uint());
  write_uint16_be(ip_bytes + 10, calculate_sum(ip_bytes, 20));
}

create_udp_pkt()

static void LibFlute::create_udp_pkt ( char *  udp_buffer, const boost::asio::ip::udp::endpoint &  endpoint, const char *  data, size_t  data_len, const boost::asio::ip::address &  local_address  )

static

Definition at line 900 of file Transmitter.cpp.

{
  auto *udp_bytes = reinterpret_cast<uint8_t*>(udp_buffer);
  const auto udp_length = static_cast<uint16_t>(data_len + 8);
  const auto source_address = local_address.to_v4().to_uint();
  const auto destination_address = endpoint.address().to_v4().to_uint();
 
  write_uint16_be(udp_bytes, endpoint.port());
  write_uint16_be(udp_bytes + 2, endpoint.port());
  write_uint16_be(udp_bytes + 4, udp_length);
  write_uint16_be(udp_bytes + 6, 0);
  memcpy(udp_buffer + 8, data, data_len);
 
  std::vector<uint8_t> checksum_bytes(12 + udp_length);
  write_uint32_be(checksum_bytes.data(), source_address);
  write_uint32_be(checksum_bytes.data() + 4, destination_address);
  checksum_bytes[8] = 0;
  checksum_bytes[9] = endpoint.protocol().protocol();
  write_uint16_be(checksum_bytes.data() + 10, udp_length);
  memcpy(checksum_bytes.data() + 12, udp_bytes, udp_length);
 
  write_uint16_be(udp_bytes + 6, calculate_sum(checksum_bytes.data(), checksum_bytes.size()));
}

write_uint16_be()

static void LibFlute::write_uint16_be ( uint8_t *  buffer, uint16_t  value  )

static

Definition at line 961 of file Transmitter.cpp.

{
  buffer[0] = static_cast<uint8_t>((value >> 8) & 0xFF);
  buffer[1] = static_cast<uint8_t>(value & 0xFF);
}

write_uint32_be()

static void LibFlute::write_uint32_be ( uint8_t *  buffer, uint32_t  value  )

static

Definition at line 967 of file Transmitter.cpp.

{
  buffer[0] = static_cast<uint8_t>((value >> 24) & 0xFF);
  buffer[1] = static_cast<uint8_t>((value >> 16) & 0xFF);
  buffer[2] = static_cast<uint8_t>((value >> 8) & 0xFF);
  buffer[3] = static_cast<uint8_t>(value & 0xFF);
}