Internet on FIRE

/*

 *        BIRD Library -- IP address functions

 *

 *        (c) 1998--2000 Martin Mares <mj@ucw.cz>

 *

 *        Can be freely distributed and used under the terms of the GNU GPL.

 */

/**

 * DOC: IP addresses

 *

 * BIRD uses its own abstraction of IP address in order to share the same

 * code for both IPv4 and IPv6. IP addresses are represented as entities

 * of type &ip_addr which are never to be treated as numbers and instead

 * they must be manipulated using the following functions and macros.

 */

#include <stdlib.h>

#include "nest/bird.h"

#include "lib/ip.h"

int

ip6_compare(ip6_addr a, ip6_addr b)

{

  int i;

  for (i=0; i<4; i++)

    if (a.addr[i] > b.addr[i])

      return 1;

    else if (a.addr[i] < b.addr[i])

      return -1;

  return 0;

}

ip6_addr

ip6_mkmask(uint n)

{

  ip6_addr a;

  int i;

  for (i=0; i<4; i++)

  {

    if (!n)

      a.addr[i] = 0;

    else if (n >= 32)

    {

      a.addr[i] = ~0;

      n -= 32;

    }

    else

    {

      a.addr[i] = u32_mkmask(n);

      n = 0;

    }

  }

  return a;

}

uint

ip6_masklen(ip6_addr *a)

{

  int i, j, n;

  for (i=0, n=0; i<4; i++, n+=32)

    if (a->addr[i] != ~0U)

    {

      j = u32_masklen(a->addr[i]);

      if (j == 255)

        return j;

      n += j;

      while (++i < 4)

        if (a->addr[i])

          return 255;

      break;

    }

  return n;

}

int

ip4_classify(ip4_addr ad)

{

  u32 a = _I(ad);

  u32 b = a >> 24U;

  if (b && b <= 0xdf)

  {

    if (b == 0x7f)

      return IADDR_HOST | SCOPE_HOST;

    else if ((b == 0x0a) ||

             ((a & 0xffff0000) == 0xc0a80000) ||

             ((a & 0xfff00000) == 0xac100000))

      return IADDR_HOST | SCOPE_SITE;

    else

      return IADDR_HOST | SCOPE_UNIVERSE;

  }

  if (b >= 0xe0 && b <= 0xef)

    return IADDR_MULTICAST | SCOPE_UNIVERSE;

  if (a == 0xffffffff)

    return IADDR_BROADCAST | SCOPE_LINK;

  return IADDR_INVALID;

}

int

ip6_classify(ip6_addr *a)

{

  u32 x = a->addr[0];

  if ((x & 0xe0000000) == 0x20000000)                /* 2000::/3  Aggregatable Global Unicast Address */

    return IADDR_HOST | SCOPE_UNIVERSE;

  if ((x & 0xffc00000) == 0xfe800000)                /* fe80::/10 Link-Local Address */

    return IADDR_HOST | SCOPE_LINK;

  if ((x & 0xffc00000) == 0xfec00000)                /* fec0::/10 Site-Local Address */

    return IADDR_HOST | SCOPE_SITE;

  if ((x & 0xfe000000) == 0xfc000000)                /* fc00::/7  Unique Local Unicast Address (RFC 4193) */

    return IADDR_HOST | SCOPE_SITE;

  if ((x & 0xff000000) == 0xff000000)                /* ff00::/8  Multicast Address */

  {

    uint scope = (x >> 16) & 0x0f;

    switch (scope)

    {

    case 1:  return IADDR_MULTICAST | SCOPE_HOST;

    case 2:  return IADDR_MULTICAST | SCOPE_LINK;

    case 5:  return IADDR_MULTICAST | SCOPE_SITE;

    case 8:  return IADDR_MULTICAST | SCOPE_ORGANIZATION;

    case 14: return IADDR_MULTICAST | SCOPE_UNIVERSE;

    default: return IADDR_MULTICAST | SCOPE_UNDEFINED;

    }

  }

  if (!x && !a->addr[1])

  {

    u32 a2 = a->addr[2];

    u32 a3 = a->addr[3];

    if (a2 == 0 && a3 == 1)

      return IADDR_HOST | SCOPE_HOST;                /* Loopback address */

    if (a2 == 0)

      return ip4_classify(_MI4(a3));                /* IPv4 compatible addresses */

    if (a2 == 0xffff)

      return ip4_classify(_MI4(a3));                /* IPv4 mapped addresses */

    return IADDR_INVALID;

  }

  return IADDR_HOST | SCOPE_UNDEFINED;

}

/*

 *  Conversion of IPv6 address to presentation format and vice versa.

 *  Heavily inspired by routines written by Paul Vixie for the BIND project

 *  and of course by RFC 2373.

 */

char *

ip4_ntop(ip4_addr a, char *b)

{

  u32 x = _I(a);

  return b + bsprintf(b, "%d.%d.%d.%d", (x >> 24) & 0xff, (x >> 16) & 0xff, (x >> 8) & 0xff, x & 0xff);

}

char *

ip6_ntop(ip6_addr a, char *b)

{

  u16 words[8];

  int bestpos, bestlen, curpos, curlen, i;

  /* First of all, preprocess the address and find the longest run of zeros */

  bestlen = bestpos = curpos = curlen = 0;

  for (i=0; i<8; i++)

  {

    u32 x = a.addr[i/2];

    words[i] = ((i%2) ? x : (x >> 16)) & 0xffff;

    if (words[i])

      curlen = 0;

    else

    {

      if (!curlen)

        curpos = i;

      curlen++;

      if (curlen > bestlen)

      {

        bestpos = curpos;

        bestlen = curlen;

      }

    }

  }

  if (bestlen < 2)

    bestpos = -1;

  /* Is it an encapsulated IPv4 address? */

  if (!bestpos && ((bestlen == 5 && a.addr[2] == 0xffff) || (bestlen == 6)))

  {

    u32 x = a.addr[3];

    b += bsprintf(b, "::%s%d.%d.%d.%d",

                  a.addr[2] ? "ffff:" : "",

                  (x >> 24) & 0xff,

                  (x >> 16) & 0xff,

                  (x >> 8) & 0xff,

                  x & 0xff);

    return b;

  }

  /* Normal IPv6 formatting, compress the largest sequence of zeros */

  for (i=0; i<8; i++)

  {

    if (i == bestpos)

    {

      i += bestlen - 1;

      *b++ = ':';

      if (i == 7)

        *b++ = ':';

    }

    else

    {

      if (i)

        *b++ = ':';

      b += bsprintf(b, "%x", words[i]);

    }

  }

  *b = 0;

  return b;

}

int

ip4_pton(const char *a, ip4_addr *o)

{

  int i;

  unsigned long int l;

  u32 ia = 0;

  i=4;

  while (i--)

  {

    char *d, *c = strchr(a, '.');

    if (!c != !i)

      return 0;

    l = strtoul(a, &d, 10);

    if (((d != c) && *d) || (l > 255))

      return 0;

    ia = (ia << 8) | l;

    if (c)

      c++;

    a = c;

  }

  *o = ip4_from_u32(ia);

  return 1;

}

int

ip6_pton(const char *a, ip6_addr *o)

{

  u16 words[8];

  int i, j, k, l, hfil;

  const char *start;

  if (a[0] == ':')                        /* Leading :: */

  {

    if (a[1] != ':')

      return 0;

    a++;

  }

  hfil = -1;

  i = 0;

  while (*a)

  {

    if (*a == ':')                        /* :: */

    {

      if (hfil >= 0)

        return 0;

      hfil = i;

      a++;

      continue;

    }

    j = 0;

    l = 0;

    start = a;

    for (;;)

    {

      if (*a >= '0' && *a <= '9')

        k = *a++ - '0';

      else if (*a >= 'A' && *a <= 'F')

        k = *a++ - 'A' + 10;

      else if (*a >= 'a' && *a <= 'f')

        k = *a++ - 'a' + 10;

      else

        break;

      j = (j << 4) + k;

      if (j >= 0x10000 || ++l > 4)

        return 0;

    }

    if (*a == ':' && a[1])

      a++;

    else if (*a == '.' && (i == 6 || i < 6 && hfil >= 0))

    {                                /* Embedded IPv4 address */

      ip4_addr x;

      if (!ip4_pton(start, &x))

        return 0;

      words[i++] = _I(x) >> 16;

      words[i++] = _I(x);

      break;

    }

    else if (*a)

      return 0;

    if (i >= 8)

      return 0;

    words[i++] = j;

  }

  /* Replace :: with an appropriate number of zeros */

  if (hfil >= 0)

  {

    j = 8 - i;

    for (i=7; i-j >= hfil; i--)

      words[i] = words[i-j];

    for (; i>=hfil; i--)

      words[i] = 0;

  }

  /* Convert the address to ip6_addr format */

  for (i=0; i<4; i++)

    o->addr[i] = (words[2*i] << 16) | words[2*i+1];

  return 1;

}

/**

 * ip_scope_text - get textual representation of address scope

 * @scope: scope (%SCOPE_xxx)

 *

 * Returns a pointer to a textual name of the scope given.

 */

char *

ip_scope_text(uint scope)

{

  static char *scope_table[] = { "host", "link", "site", "org", "univ", "undef" };

  if (scope > SCOPE_UNDEFINED)

    return "?";

  else

    return scope_table[scope];

}

ip4_addr

ip4_class_mask(ip4_addr ad)

{

  u32 m, a = _I(ad);

  if (a == 0x00000000)

    m = 0x00000000;

  else if (a < 0x80000000)

    m = 0xff000000;

  else if (a < 0xc0000000)

    m = 0xffff0000;

  else

    m = 0xffffff00;

  if (a & ~m)

    m = 0xffffffff;

  return _MI4(m);

}

#if 0

/**

 * ipa_equal - compare two IP addresses for equality

 * @x: IP address

 * @y: IP address

 *

 * ipa_equal() returns 1 if @x and @y represent the same IP address, else 0.

 */

int ipa_equal(ip_addr x, ip_addr y) { DUMMY }

/**

 * ipa_nonzero - test if an IP address is defined

 * @x: IP address

 *

 * ipa_nonzero returns 1 if @x is a defined IP address (not all bits are zero),

 * else 0.

 *

 * The undefined all-zero address is reachable as a |IPA_NONE| macro.

 */

int ipa_nonzero(ip_addr x) { DUMMY }

/**

 * ipa_and - compute bitwise and of two IP addresses

 * @x: IP address

 * @y: IP address

 *

 * This function returns a bitwise and of @x and @y. It's primarily

 * used for network masking.

 */

ip_addr ipa_and(ip_addr x, ip_addr y) { DUMMY }

/**

 * ipa_or - compute bitwise or of two IP addresses

 * @x: IP address

 * @y: IP address

 *

 * This function returns a bitwise or of @x and @y.

 */

ip_addr ipa_or(ip_addr x, ip_addr y) { DUMMY }

/**

 * ipa_xor - compute bitwise xor of two IP addresses

 * @x: IP address

 * @y: IP address

 *

 * This function returns a bitwise xor of @x and @y.

 */

ip_addr ipa_xor(ip_addr x, ip_addr y) { DUMMY }

/**

 * ipa_not - compute bitwise negation of two IP addresses

 * @x: IP address

 *

 * This function returns a bitwise negation of @x.

 */

ip_addr ipa_not(ip_addr x) { DUMMY }

/**

 * ipa_mkmask - create a netmask

 * @x: prefix length

 *

 * This function returns an &ip_addr corresponding of a netmask

 * of an address prefix of size @x.

 */

ip_addr ipa_mkmask(int x) { DUMMY }

/**

 * ipa_masklen - calculate netmask length

 * @x: IP address

 *

 * This function checks whether @x represents a valid netmask and

 * returns the size of the associate network prefix or -1 for invalid

 * mask.

 */

int ipa_masklen(ip_addr x) { DUMMY }

/**

 * ipa_hash - hash IP addresses

 * @x: IP address

 *

 * ipa_hash() returns a 16-bit hash value of the IP address @x.

 */

int ipa_hash(ip_addr x) { DUMMY }

/**

 * ipa_hton - convert IP address to network order

 * @x: IP address

 *

 * Converts the IP address @x to the network byte order.

 *

 * Beware, this is a macro and it alters the argument!

 */

void ipa_hton(ip_addr x) { DUMMY }

/**

 * ipa_ntoh - convert IP address to host order

 * @x: IP address

 *

 * Converts the IP address @x from the network byte order.

 *

 * Beware, this is a macro and it alters the argument!

 */

void ipa_ntoh(ip_addr x) { DUMMY }

/**

 * ipa_classify - classify an IP address

 * @x: IP address

 *

 * ipa_classify() returns an address class of @x, that is a bitwise or

 * of address type (%IADDR_INVALID, %IADDR_HOST, %IADDR_BROADCAST, %IADDR_MULTICAST)

 * with address scope (%SCOPE_HOST to %SCOPE_UNIVERSE) or -1 (%IADDR_INVALID)

 * for an invalid address.

 */

int ipa_classify(ip_addr x) { DUMMY }

/**

 * ip4_class_mask - guess netmask according to address class

 * @x: IPv4 address

 *

 * This function (available in IPv4 version only) returns a

 * network mask according to the address class of @x. Although

 * classful addressing is nowadays obsolete, there still live

 * routing protocols transferring no prefix lengths nor netmasks

 * and this function could be useful to them.

 */

ip4_addr ip4_class_mask(ip4_addr x) { DUMMY }

/**

 * ipa_from_u32 - convert IPv4 address to an integer

 * @x: IP address

 *

 * This function takes an IPv4 address and returns its numeric

 * representation.

 */

u32 ipa_from_u32(ip_addr x) { DUMMY }

/**

 * ipa_to_u32 - convert integer to IPv4 address

 * @x: a 32-bit integer

 *

 * ipa_to_u32() takes a numeric representation of an IPv4 address

 * and converts it to the corresponding &ip_addr.

 */

ip_addr ipa_to_u32(u32 x) { DUMMY }

/**

 * ipa_compare - compare two IP addresses for order

 * @x: IP address

 * @y: IP address

 *

 * The ipa_compare() function takes two IP addresses and returns

 * -1 if @x is less than @y in canonical ordering (lexicographical

 * order of the bit strings), 1 if @x is greater than @y and 0

 * if they are the same.

 */

int ipa_compare(ip_addr x, ip_addr y) { DUMMY }

/**

 * ipa_build6 - build an IPv6 address from parts

 * @a1: part #1

 * @a2: part #2

 * @a3: part #3

 * @a4: part #4

 *

 * ipa_build() takes @a1 to @a4 and assembles them to a single IPv6

 * address. It's used for example when a protocol wants to bind its

 * socket to a hard-wired multicast address.

 */

ip_addr ipa_build6(u32 a1, u32 a2, u32 a3, u32 a4) { DUMMY }

/**

 * ip_ntop - convert IP address to textual representation

 * @a: IP address

 * @buf: buffer of size at least %STD_ADDRESS_P_LENGTH

 *

 * This function takes an IP address and creates its textual

 * representation for presenting to the user.

 */

char *ip_ntop(ip_addr a, char *buf) { DUMMY }

/**

 * ip_ntox - convert IP address to hexadecimal representation

 * @a: IP address

 * @buf: buffer of size at least %STD_ADDRESS_P_LENGTH

 *

 * This function takes an IP address and creates its hexadecimal

 * textual representation. Primary use: debugging dumps.

 */

char *ip_ntox(ip_addr a, char *buf) { DUMMY }

/**

 * ip_pton - parse textual representation of IP address

 * @a: textual representation

 * @o: where to put the resulting address

 *

 * This function parses a textual IP address representation and

 * stores the decoded address to a variable pointed to by @o.

 * Returns 0 if a parse error has occurred, else 0.

 */

int ip_pton(char *a, ip_addr *o) { DUMMY }

#endif