sockaddr_ptoa.c

Go to the documentation of this file.

/*
** Copyright (C) 2005 by Kevin L. Mitchell <klmitch@mit.edu>
**
** This program is free software; you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation; either version 2 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
**
** @(#)$Id: sockaddr_ptoa.c,v 1.2 2005/12/18 00:15:11 klmitch Exp $
*/
#include "event_int.h"

#include <string.h>

RCSTAG("@(#)$Id: sockaddr_ptoa.c,v 1.2 2005/12/18 00:15:11 klmitch Exp $");

#define VALMASK                 0x0f

#define DIGIT                   0x10

#define XDIGIT                  0x20

#define COLON                   0x30

#define PERIOD                  0x40

#define TYPEMASK                0xf0

#define ctype(c)                (cmap[(int)(c)] & TYPEMASK)

#define cval(c)                 (cmap[(int)(c)] & VALMASK)

static unsigned char cmap[] = {
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x10, 0x11, 0x12, 0x13,
  0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};

#define _bcd(num, digit)        (((num) >> ((digit) << 2)) & 0x0f)

#define bcd(num)                (_bcd((num), 3) * 1000 +                      \
                                 _bcd((num), 2) *  100 +                      \
                                 _bcd((num), 1) *   10 +                      \
                                 _bcd((num), 0) *    1)

#define bcd_isquad(num)         ((num) <= 0x0255 && _bcd((num), 1) <= 9 &&    \
                                 _bcd((num), 0) <= 9)

#define hex_accum(accum, c)     ((accum) = ((accum) << 4) | cval((c)))

#define dec_accum(accum, c)     ((accum) = ((accum) * 10) + cval((c)))

struct partaddr {
  unsigned char*addr[2];        
  unsigned char addr2[SOCK_ADDRBUFV6_LEN];
  int           segs[2];        
  int           cnt;            
  ev_sockaddr_t*result;         
};

#define partaddr_init(pa, res)                                                \
do {                                                                          \
  struct partaddr *_pa = (pa);                                                \
  ev_sockaddr_t *_res = (res);                                                \
  int _i;                                                                     \
  _pa->addr[0] = sa_ipaddrbuf(_res); /* set partial addr pointers... */       \
  _pa->addr[1] = _pa->addr2;                                                  \
  for (_i = 0; _i < SOCK_ADDRBUFV6_LEN; _i++) /* initialize addresses */      \
    _pa->addr[1][_i] = 0;                                                     \
  _pa->segs[0] = _pa->segs[1] = _pa->cnt = 0; /* initialize counters... */    \
  _pa->result = _res; /* and remember where the result is */                  \
} while (0)

#define accumulate(pa, accum)                                                 \
do {                                                                          \
  struct partaddr *_pa = (pa);                                                \
  uint32_t _accum = (accum);                                                  \
  if (_pa->segs[0] + _pa->segs[1] + _pa->cnt + 1 >                            \
      (sa_type(_pa->result) == AT_IPv4 ?                                      \
       SOCK_ADDRBUFV4_LEN : SOCK_ADDRBUFV6_LEN))                              \
    ev_return(EV_ERR_ADDRTOOLONG); /* too many segments, bail out */          \
  _pa->addr[_pa->cnt][_pa->segs[_pa->cnt]++] = (_accum >> 8) & 0xff;          \
  _pa->addr[_pa->cnt][_pa->segs[_pa->cnt]++] = (_accum     ) & 0xff;          \
} while (0)

#define test_v6(pa)                                                           \
do {                                                                          \
  struct partaddr *_pa = (pa);                                                \
  if (!_pa->cnt && _pa->segs[0] != SOCK_ADDRBUFV6_LEN)                        \
    ev_return(EV_ERR_ADDRINCOMPLETE); /* malformed address, bail out */       \
} while (0)

ev_err_t
sockaddr_ptoa(ev_sockaddr_t *sa, const char *address, int alen)
{
  const unsigned char *t = (const unsigned char *)address;
  unsigned char lastc = '\0';
  enum { s_unspec, s_inet4, s_inet6, s_inet64, s_port } state = s_unspec;
  uint32_t accum = 0, accum2 = 0; /* gotta be large enough for overflow */
  struct partaddr pa;
  int dots = 0, i, j, doublec = 0, twoc = 0;
  ev_satype_t subtype = AT_NONE;

  ev_init(); /* make sure library is initialized... */

  if (!sa || !address) /* sanity-check arguments */
    ev_return(EINVAL);

  sa->sa_type = AT_NONE; /* initialize the resultant ev_sockaddr_t */
  memset((void *)&sa->sa_addr, 0, sizeof(sa->sa_addr));

  if (alen < 0) /* Length not set? */
    alen = strlen(address);

  if (*address == '/') { /* Ah ha, we have an AT_LOCAL address... */
    sa->sa_type = AT_LOCAL; /* set the type */
    if (alen >= SOCK_LOCALADDR_LEN)
      ev_return(EV_ERR_ADDRTOOLONG); /* address is too long to fit! */
    strncpy(sa->sa_addr.saa_localaddr, address, alen); /* copy the address */
    ev_return(0); /* we're all done!  Gee, that was easy... */
  }

  /* ...but this isn't!  Run a state-based parser to disassemble the address */

  partaddr_init(&pa, sa); /* initialize the struct partaddr */

  /* OK, process the address string character by character */
  for (; alen && *t; lastc = *(t++), alen--)
    switch (ctype(*t)) {
    case XDIGIT: /* hexadecimal digit... */
      if (state == s_unspec) { /* hex digit implies IPv6 address */
        state = s_inet6;
        sa->sa_type = AT_IPv6;
        subtype = AT_IPv6;
      } else if (state != s_inet6)
        ev_return(EV_ERR_INVALIDCHAR); /* bad character in address... */
      /*FALLTHROUGH*/
    case DIGIT: /* decimal digit */
      if (doublec) /* expecting a ':'... */
        ev_return(EV_ERR_COLONEXPECTED);
      if (state == s_unspec || state == s_inet6)
        hex_accum(accum, *t); /* accumulate as a hex digit string */
      else
        dec_accum(accum, *t); /* accumulate as a decimal digit string */

      if (state == s_unspec && !bcd_isquad(accum)) {
        /* component is too big to be part of an IPv4 address */
        state = s_inet6; /* so it must be an IPv6 address! */
        sa->sa_type = AT_IPv6;
        subtype = AT_IPv6;
      }

      if (accum > (state == s_inet4 ? 255 : 65535)) /* check for overflow */
        ev_return(EV_ERR_ADDRTOOLONG);

      twoc = 0; /* zero twoc... */
      break;

    case COLON:
      if (state == s_unspec) { /* OK, ':' implies IPv6 address */
        state = s_inet6;
        sa->sa_type = AT_IPv6;
        subtype = AT_IPv6;
        if (!lastc) /* first character is a colon? */
          doublec++; /* must be followed by another! */
      } else if (state != s_inet6)
        ev_return(EV_ERR_INVALIDCHAR); /* colon in non-IPv6 address? */
      else
        doublec = 0; /* zero doublec... */

      if (lastc == ':') { /* two ':' in a row; segment of zeros... */
        if (pa.cnt++) /* was there a previous one? */
          ev_return(EV_ERR_ADDRTOOLONG); /* too many zero runs */
        twoc++; /* have two colons in a row... */
      }

      accumulate(&pa, accum); /* OK, add component to address */
      accum = 0; /* and reset the accumulator */
      break;

    case PERIOD:
      if ((!twoc && lastc == ':') || /* . after a :?  Only if 2 in a row... */
          lastc == '.' || /* . after a .?  That doesn't make sense! */
          (dots && *address == '.')) /* .a.b -- malformed IPv4 address */
        ev_return(EV_ERR_INVALIDCHAR);
      dots++; /* increment the count of periods */
      twoc = 0; /* zero twoc */
      if (state == s_unspec) { /* OK, this is an IPv4 address! */
        accum2 = bcd(accum); /* store first quad in second accumulator */
        accum = 0; /* prepare for the next quad */
        state = s_inet4; /* and switch states */
        sa->sa_type = AT_IPv4;
        subtype = AT_IPv4;
        continue; /* must process next character! */
      } else if (state == s_inet6) { /* processing an IPv6 address... */
        if (bcd_isquad(accum)) { /* it's valid as an IPv4 quad... */

          /* The accumulated value could be either an IPv4 quad or an
           * IPv6 address component.  We won't know until later: if we
           * get another period, then it was a quad followed by a
           * quad; if we hit the end of the string, then it was an
           * IPv6 address component followed by a port number.
           */

          accum2 = accum; /* save this component for later... */
          accum = 0; /* must zero the accumulator for next component */
          state = s_inet64; /* switch to the intermediate state */
        } else { /* definitely an IPv6 address component */
          accumulate(&pa, accum); /* accumulate it... */
          accum = 0; /* reset the accumulator */
          test_v6(&pa); /* verify the address is valid... */
          state = s_port; /* what follows is definitely a port number */
        }
        continue; /* must process next character */
      } else if (state == s_inet64) { /* a second '.'; must be a v4 address */
        accum2 = bcd(accum2); /* decode second accumulator */
        state = s_inet4; /* switch to the IPv4 processing state */
        subtype = AT_IPv4;
        /* Drop through to the processing stage */
      } else if (state == s_inet4) {
        if (dots == 4) { /* what follows this '.' must be a port number */
          if (sa->sa_type == AT_IPv6)
            test_v6(&pa); /* verify it's a valid IPv6 address */
          state = s_port; /* switch to port processing state */
        }
      } else /* a '.' after a port?  huh? */
        ev_return(EV_ERR_INVALIDCHAR); /* malformed address! */

      if (dots & 0x01) { /* OK, if it's odd, we have only one quad so far... */
        accum2 = accum; /* so save it and zero the accumulator */
        accum = 0;
      } else { /* two quads, add them to the address */
        accumulate(&pa, (accum2 << 8) | accum);
        accum = 0; /* zero the accumulators */
        accum2 = 0;
      }
      break;

    default: /* unknown character */
      ev_return(EV_ERR_INVALIDCHAR); /* malformed address! */
      break;
    }

  /* OK, we've hit the end of the string.  Normalize the state... */
  if (state == s_unspec || (state == s_inet4 && dots == 1 &&
                            *address == '.')) {
    if (lastc && !dots) /* there must be at least one '.' */
      ev_return(EV_ERR_BADADDR);

    /* OK, let's assume an IPv4 wildcard address... */
    sa->sa_type = AT_IPv4;
    if (state == s_inet4) /* accumulator will contain a port number */
      state = s_port;
  } else if (state == s_inet64) {
    /* previous segment was an IPv6 address component */
    accumulate(&pa, accum2);
    test_v6(&pa); /* verify it's a valid address */
    state = s_port; /* accumulator will contain a port number */
  }

  /* At this point, we have the address type, and we have reduced the
   * set of possible states to { s_inet4, s_inet6, s_port }.  If we're
   * in one of the inet states, the accumulator contains an address
   * component and the port number will be 0.  Otherwise, the
   * accumulator contains the port number, and the address is
   * complete.
   */
  if (state == s_inet4) { /* IPv4 address component... */
    if (dots < 3) /* at least 3 dots are necessary */
      ev_return(EV_ERR_ADDRINCOMPLETE);
    accumulate(&pa, (accum2 << 8) | accum); /* add the component */
    if (sa->sa_type == AT_IPv6)
      test_v6(&pa); /* verify that v6 address is complete */
  } else if (state == s_inet6) { /* IPv6 address component */
    if (!twoc && lastc == ':') /* cannot end with ':' except in '::' case */
      ev_return(EV_ERR_INVALIDCHAR); /* malformed address... */
    accumulate(&pa, accum); /* add the address component */
    test_v6(&pa); /* verify that the address is complete */
  } else /* accumulator contains a port number */
    sa->sa_addr.saa_ipaddr.saai_port = accum; /* so remember it! */

  /* OK, one final step: If the v6 address contained '::', we need to
   * merge the two pieces of the address into one.  We do this by
   * walking backwards through the two pieces, starting at the very
   * end of piece 0 (the result) and at the last segment of piece 1.
   */
  for (i = SOCK_ADDRBUFV6_LEN - 1, j = pa.segs[1] - 1; i >= 0 && j >= 0;
       i--, j--)
    pa.addr[0][i] = pa.addr[1][j]; /* just do an assignment */

  /* Because of our pointer tricks with the struct partaddr, the final
   * answer is now contained in the ev_sockaddr_t we were passed to
   * begin with, and so we are now done.
   */
  ev_return(0);
}

---