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 (uint16_t *buffer, size_t len)
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 334 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 ( uint16_t *  buffer, size_t  len  )

static

Definition at line 876 of file Transmitter.cpp.

{
  uint32_t cksum = 0;
 
  while (len > 1) {
    cksum += ntohs(*buffer);
    len -= 2;
    buffer++;
  }
  if (len > 0) {
    cksum += (*reinterpret_cast<uint8_t*>(buffer)) << 8;
  }
  
  while (cksum >> 16) {
    cksum = (cksum & 0xFFFF) + (cksum >> 16);
  }
 
  uint16_t result = htons(static_cast<uint16_t>(~cksum));
 
  return result;
}

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 857 of file Transmitter.cpp.

{
  struct iphdr *ip_hdr = reinterpret_cast<struct iphdr*>(ip_buffer);
 
  ip_hdr->version = IPVERSION;
  ip_hdr->ihl = 5; // 20 bytes
  ip_hdr->tos = 0;
  ip_hdr->tot_len = htons(pkt_size);
  ip_hdr->id = 0;
  ip_hdr->frag_off = 0; // not fragmenting
  ip_hdr->ttl = 63; // TTL 63 hops
  ip_hdr->protocol = endpoint.protocol().protocol();
  ip_hdr->check = 0;
  ip_hdr->saddr = htonl(local_address.to_v4().to_uint());
  ip_hdr->daddr = htonl(endpoint.address().to_v4().to_uint());
 
  ip_hdr->check = calculate_sum(reinterpret_cast<uint16_t*>(ip_hdr), 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 831 of file Transmitter.cpp.

{
  struct udp_pseudo_hdr {
    in_addr_t source;
    in_addr_t dest;
    uint8_t reserved;
    uint8_t protocol;
    uint16_t length;
  } *pseudo_hdr = reinterpret_cast<struct udp_pseudo_hdr*>(udp_buffer - sizeof(*pseudo_hdr));
  struct udphdr *udp_hdr = reinterpret_cast<struct udphdr*>(udp_buffer);
 
  pseudo_hdr->source = htonl(local_address.to_v4().to_uint());
  pseudo_hdr->dest = htonl(endpoint.address().to_v4().to_uint());
  pseudo_hdr->reserved = 0;
  pseudo_hdr->protocol = endpoint.protocol().protocol();
  pseudo_hdr->length = htons(data_len + 8);
 
  udp_hdr->uh_sport = htons(endpoint.port());
  udp_hdr->uh_dport = udp_hdr->uh_sport;
  udp_hdr->uh_ulen = pseudo_hdr->length;
  udp_hdr->uh_sum = 0;
  memcpy(udp_buffer+8, data, data_len);
 
  udp_hdr->uh_sum = calculate_sum(reinterpret_cast<uint16_t*>(pseudo_hdr), data_len + 8 + 12);
}