netutils.h

Go to the documentation of this file.

/*
 * Copyright (c) 2013,2016 - Adjacent Link LLC, Bridgewater, New Jersey
 * Copyright (c) 2008-2010 - DRS CenGen, LLC, Columbia, Maryland
 * 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.
 * * Neither the name of DRS CenGen, LLC nor the names of its
 *   contributors may be used to endorse or promote products derived
 *   from this software without specific prior written permission.
 *
 * 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.
 */

#ifndef EMANEUTILSNETUTILS_HEADER_
#define EMANEUTILSNETUTILS_HEADER_

#include <sstream>
#include <vector>
#include <cstdint>
#include <cstring>
#include <arpa/inet.h>

namespace EMANE
{
  namespace Utils
  {
    struct UdpHeader
    {
      std::uint16_t u16Udpsrc;
      std::uint16_t u16Udpdst;
      std::uint16_t u16Udplen;
      std::uint16_t u16Udpcheck;
    } __attribute__((packed));


    const std::uint8_t IP_PROTO_UDP = 0x11;

    const std::uint16_t UDP_HEADER_LEN = 8;


    inline std::uint8_t
    get_ip_version(std::uint8_t vhl)
    {
      return ((vhl >> 4) & 0x0F);
    }

    inline std::uint8_t
    get_ip_hdrlen(std::uint8_t vhl)
    {
      return ((vhl & 0x0F) << 2);
    }


    inline std::uint8_t
    get_ip_dscp(std::uint8_t tos)
    {
      return (tos >> 2);
    }

    inline std::uint8_t
    get_ip_dscp(std::uint8_t ver, std::uint8_t clas)
    {
      return (((ver & 0x0F) << 2) | (clas >> 6));
    }


    struct Ip4Header
    {
      std::uint8_t  u8Ipv4vhl;
      std::uint8_t  u8Ipv4tos;
      std::uint16_t u16Ipv4len;
      std::uint16_t u16Ipv4id;
      std::uint16_t u16Ipv4frag;
      std::uint8_t  u8Ipv4hops;
      std::uint8_t  u8Ipv4proto;
      std::uint16_t u16Ipv4check;
      std::uint32_t u32Ipv4src;
      std::uint32_t u32Ipv4dst;
    } __attribute__((packed));

    const std::uint16_t IPV4_HEADER_LEN = 20;


    const std::uint16_t IPV4_ADDR_LEN = 4;


    const std::uint16_t IPV6_ADDR_LEN = 16;

    const std::uint8_t IPV6_P_ICMP = 0x3A;

    inline std::uint8_t
    get_version(const Ip4Header *ip)
    {
      return get_ip_version(ip->u8Ipv4vhl);
    }


    inline std::uint8_t
    get_hdrlen(const Ip4Header *ip)
    {
      return get_ip_hdrlen(ip->u8Ipv4vhl);
    }


    inline std::uint16_t
    get_len(const Ip4Header *ip)
    {
      return ntohs(ip->u16Ipv4len);
    }


    inline std::uint8_t
    get_dscp(const Ip4Header *ip)
    {
      return get_ip_dscp(ip->u8Ipv4tos);
    }

    inline void
    addr_to_string(const std::uint8_t * addr, size_t addrlen, const char *delim, char *buf, size_t buflen)
    {
      size_t pos = 0;

      for(size_t i = 0; i < addrlen; ++i)
        {
          if(i < (addrlen - 1))
            {
              pos += snprintf(buf + pos, buflen - pos, "%02X%s", addr[i] & 0xFF, delim);
            }
          else
            {
              pos += snprintf(buf + pos, buflen - pos, "%02X", addr[i] & 0xFF);
            }
        }
    }


    struct Ip6Header
    {
      struct {
        std::uint8_t   u8Ipv6Ver;
        std::uint8_t   u8Ipv6Class;
        std::uint16_t  u16Ipv6Flow;
      } vcf;

      std::uint16_t u16Ipv6len;
      std::uint8_t  u8Ipv6next;
      std::uint8_t  u8Ipv6hops;
      std::uint8_t  Ipv6src[IPV6_ADDR_LEN];
      std::uint8_t  Ipv6dst[IPV6_ADDR_LEN];
    } __attribute__((packed));

    const std::uint16_t IPV6_HEADER_LEN = 40;

    const std::uint16_t IPV6_MAX_BIT_LEN = 128;



    inline std::uint8_t
    get_version(const Ip6Header *ip)
    {
      return get_ip_version(ip->vcf.u8Ipv6Ver);
    }

    inline std::uint8_t
    get_hdrlen(const Ip6Header *ip)
    {
      return get_ip_hdrlen(ip->vcf.u8Ipv6Ver);
    }

    inline std::uint16_t
    get_len(const Ip6Header *ip)
    {
      return (ntohs(ip->u16Ipv6len) + IPV6_HEADER_LEN);
    }

    inline std::uint8_t
    get_dscp(const Ip6Header *ip)
    {
      return get_ip_dscp(ip->vcf.u8Ipv6Ver, ip->vcf.u8Ipv6Class);
    }



    const std::uint16_t ETH_ALEN = 6;


    const std::uint16_t ETH_HEADER_LEN = 14;


    const std::uint16_t ETHARP_HEADER_LEN = 28;

    const std::uint16_t IP_MAX_PACKET = 0xFFFF;


    const std::uint16_t ARPHRD_ETHER = 0x0001;


    const std::uint16_t ETH_P_IPV4 = 0x0800;


    const std::uint16_t ETH_P_ARP = 0x0806;

    const std::uint16_t ETH_P_IPV6 = 0x86DD;

    struct  EtherAddrBytes{
      std::uint8_t  buff[ETH_ALEN];
    } __attribute__((packed));

    struct EtherAddrWords{
      std::uint16_t word1;
      std::uint16_t word2;
      std::uint16_t word3;
    } __attribute__((packed));

    union EtherAddr {
      struct EtherAddrBytes bytes;
      struct EtherAddrWords words;
    } __attribute__((packed));

    struct  EtherHeader{
      union  EtherAddr dst;
      union  EtherAddr src;
      std::uint16_t u16proto;
    } __attribute__((packed));


    inline const EtherAddr*
    get_srcaddr(const EtherHeader *eth)
    {
      return (&eth->src);
    }

    inline const EtherAddr*
    get_dstaddr(const EtherHeader *eth)
    {
      return (&eth->dst);
    }

    inline std::uint16_t
    get_protocol(const EtherHeader *eth)
    {
      return ntohs(eth->u16proto);
    }



    inline const char *
    addr_to_string(const EtherAddr * addr)
    {
      static char buf[64];

      addr_to_string((std::uint8_t*) addr, ETH_ALEN, ":", buf, sizeof(buf));

      return buf;
    }


    inline std::string
    ethaddr_to_string(const EtherAddr * addr)
    {
      char buf[64];

      addr_to_string((std::uint8_t*) addr, ETH_ALEN, ":", buf, sizeof(buf));

      return buf;
    }



    struct EtherArpHeader
    {
      std::uint16_t        u16hwType;
      std::uint16_t        u16protocol;
      std::uint8_t         u8hwAddrLen;
      std::uint8_t         u8protoAddrLen;
      std::uint16_t        u16code;
      EtherAddr         srcHwAddr;
      std::uint32_t        u32srcProtoAddr;
      EtherAddr         dstHwAddr;
      std::uint32_t        u32dstProtoAddr;
    } __attribute__((packed));

    inline std::uint16_t
    get_hwtype(const EtherArpHeader *arp)
    {
      return ntohs(arp->u16hwType);
    }


    inline std::uint16_t
    get_protocol(const EtherArpHeader *arp)
    {
      return ntohs(arp->u16protocol);
    }


    inline std::uint8_t
    get_hwaddrlen(const EtherArpHeader *arp)
    {
      return (arp->u8hwAddrLen);
    }


    inline std::uint8_t
    get_protoaddrlen(const EtherArpHeader *arp)
    {
      return (arp->u8protoAddrLen);
    }

    inline std::uint16_t
    get_code(const EtherArpHeader *arp)
    {
      return ntohs(arp->u16code);
    }


    inline const EtherAddr*
    get_srchwaddr(const EtherArpHeader *arp)
    {
      return (&arp->srcHwAddr);
    }


    inline const EtherAddr*
    get_dsthwaddr(const EtherArpHeader *arp)
    {
      return (&arp->dstHwAddr);
    }

    inline std::uint32_t
    get_srcprotoaddr(const EtherArpHeader *arp)
    {
      return (arp->u32srcProtoAddr);
    }


    inline std::uint32_t
    get_dstprotoaddr(const EtherArpHeader *arp)
    {
      return (arp->u32dstProtoAddr);
    }


    const std::uint16_t ETH_ARPOP_REQUEST = 0x0001;


    const std::uint16_t ETH_ARPOP_REPLY = 0x0002;



    inline std::uint16_t
    ethaddr4_to_id (const EtherAddr *addr)
    {
      // multicast mac
      static std::uint8_t MulticastMacAddr[3] = {0x01, 0x00, 0x5E};

      // broadcast mac
      static std::uint8_t BroadcastMacAddr[ETH_ALEN] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};

      // multicast
      if(memcmp(addr->bytes.buff, MulticastMacAddr, 3) == 0)
        {
          return ntohs(0xFFFF);
        }
      // broadcast
      else if(memcmp(addr->bytes.buff, BroadcastMacAddr, 6) == 0)
        {
          return ntohs(0xFFFF);
        }
      // unicast
      else
        {
          return ntohs(addr->words.word3);
        }
    }


    inline std::uint16_t
    ethaddr6_to_id (const EtherAddr *addr)
    {
      // multicast mac
      static std::uint8_t MulticastMacAddr[2] = {0x33, 0x33};

      // broadcast mac
      static std::uint8_t BroadcastMacAddr[ETH_ALEN] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};

      // multicast
      if(memcmp(addr->bytes.buff, MulticastMacAddr, 2) == 0)
        {
          return ntohs(0xFFFF);
        }
      // broadcast
      else if(memcmp(addr->bytes.buff, BroadcastMacAddr, 6) == 0)
        {
          return ntohs(0xFFFF);
        }
      // unicast
      else
        {
          return ntohs(addr->words.word3);
        }
    }

    inline std::uint8_t
    get_prefixlen (const in6_addr *prefix)
    {
      std::uint8_t len = 0;
      std::uint8_t *u8ptr = (std::uint8_t *) prefix;

      while ((*u8ptr == 0xff) && len < IPV6_MAX_BIT_LEN)
        {
          len += 8;
          u8ptr++;
        }

      if (len < IPV6_MAX_BIT_LEN)
        {
          std::uint8_t byte = *u8ptr;
          while (byte)
            {
              len++;
              byte <<= 1;
            }
        }

      return len;
    }


    inline std::uint16_t
    inet_cksum (const void * buf, int buflen, std::uint16_t prev = 0)
    {
      std::uint32_t sum = 0;
      std::uint16_t *w = (std::uint16_t *) buf;

      while (buflen > 1) {
        sum += *w;
        buflen -= 2;
        w++;
      }

      if (buflen) {
        std::uint8_t *byte = (std::uint8_t *) w;
        sum += *byte;
      }

      sum += prev;
      sum = (sum >> 16) + (sum & 0xFFFF);
      return (sum + (sum >> 16));
    }

    struct IP6ICMPHeader {
      std::uint8_t    u8Type;
      std::uint8_t    u8Code;
      std::uint16_t   u16Checksum;
      std::uint32_t   u32Flags;
      sockaddr_in6 targetAddr;
    } __attribute__((packed));

    const std::uint8_t IP6_ICMP_NEIGH_SOLICIT = 135;

    const std::uint8_t IP6_ICMP_NEIGH_ADVERT = 136;

    inline std::string formatFrequency(const std::uint64_t val, const int precision = 6)
    {
      std::stringstream ss;

      ss.precision(precision);

      const float fFrequency = val;

      if(fFrequency < 1e+3)
        {
          ss << fFrequency << " Hz";
        }
      else if (fFrequency < 1e+6)
        {
          ss << (fFrequency / 1e+3) << " KHz";
        }
      else if (fFrequency < 1e+9)
        {
          ss << (fFrequency / 1e+6) << " MHz";
        }
      else if (fFrequency < 1e+12)
        {
          ss << (fFrequency / 1e+9) << " GHz";
        }
      else
        {
          ss << (fFrequency / 1e+12) << " THz";
        }

      return ss.str();
    }

    inline std::vector<std::string> getTokens(const std::string & sInput, const char * pzDelimeter)
    {
      char *pzToken = NULL;

      int iTokenCount = 0;

      std::string str = sInput;

      std::vector<std::string> strVector;

      while ((pzToken = strtok (iTokenCount == 0 ? &str[0] : NULL, pzDelimeter)) != NULL)
        {
          ++iTokenCount;

          strVector.push_back(pzToken);
        }

      return strVector;
    }
  }
}

#endif // EMANEUTILSNETUTILS_HEADER_