t_sockaddr_fcns.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: t_sockaddr_fcns.c,v 1.1 2005/12/23 04:07:10 klmitch Exp $
*/
#include "event-test.h"

#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/un.h>

RCSTAG("@(#)$Id: t_sockaddr_fcns.c,v 1.1 2005/12/23 04:07:10 klmitch Exp $");

TEST_PROG(t_sockaddr_fcns, "Test operation of socket address "
          "manipulation functions")
     TEST_ARG(t_sockaddr_fcns, "<t_sockaddr_fcns.addrs>")
     TEST_DEP(t_sockaddr_fcns, t_event_log)

unsigned int
value(const char *str)
{
  int i;
  struct {
    const char *name;
    unsigned int value;
  } map[] = {
    { "SUCCESS", 0 }, /* error codes */
    { "EINVAL", EINVAL },
    { "ADDRTOOLONG", EV_ERR_ADDRTOOLONG },
    { "ADDRINCOMPLETE", EV_ERR_ADDRINCOMPLETE },
    { "INVALIDCHAR", EV_ERR_INVALIDCHAR },
    { "COLONEXPECTED", EV_ERR_COLONEXPECTED },
    { "BADADDR", EV_ERR_BADADDR },
    { "NONE", AT_NONE }, /* address types */
    { "LOCAL", AT_LOCAL },
    { "IP4", AT_IPv4 },
    { "IP6", AT_IPv6 },
    { 0, 0 }
  };

  for (i = 0; map[i].name; i++) /* Search the name map */
    if (!strcmp(map[i].name, str))
      return map[i].value; /* found it, return the value */

  return 0;
}

int
main(int argc, char **argv)
{
  const char *ta = "/this/is/an/improbable/address";
  char *prog;
  ev_err_t err;
  ev_sockaddr_t addr;
  int len;

  ev_test_init(t_sockaddr_fcns); /* initialize test program */
  ev_prog_name(prog, argv);

  /* Clear the socket addresses... */
  memset(&addr, 0, sizeof(addr));

  /***************************************************************************
   * First task: Test the sa_* functions.                                    *
   ***************************************************************************/

  /* Begin with AT_NONE--all except sa_type_set() should fail */
  TEST(t_sockaddr_fcns, sa_none, "Test that AT_NONE addresses are rejected "
       "by all sa_* functions except sa_type_set()",
       (!(err = sa_type_set(&addr, AT_NONE)) && sa_type(&addr) == AT_NONE &&
        sa_ipaddrbuf_set(&addr, ta) == EINVAL &&
        sa_ipaddrport_set(&addr, 1234) == EINVAL &&
        sa_localaddr_set(&addr, ta) == EINVAL), 0,
       ("sa_type_set() properly set AT_NONE address type and other sa_* "
        "functions rejected it"),
       ("sa_type_set() failed to properly set AT_NONE address type or another "
        "sa_* function failed to reject it; error code %u, address type %u",
        err, sa_type(&addr)));

  /* Now, try AT_IPv4--before AT_IPv6, note. */
  TEST(t_sockaddr_fcns, sa_ipv4, "Test that sa_* functions handle IPv4 "
       "addresses properly",
       (!(err = sa_type_set(&addr, AT_IPv4)) && sa_type(&addr) == AT_IPv4 &&
        !(err = sa_ipaddrbuf_set(&addr, ta)) &&
        !(err = sa_ipaddrport_set(&addr, 1234)) &&
        !memcmp(sa_ipaddrbuf(&addr), ta, SOCK_ADDRBUFV4_LEN) &&
        sa_ipaddrbuf(&addr)[SOCK_ADDRBUFV4_LEN] == '\0' &&
        sa_ipaddrport(&addr) == 1234 &&
        sa_localaddr_set(&addr, ta) == EINVAL), 0,
       ("sa_* functions handle IPv4 addresses properly"),
       ("sa_* functions fail to handle IPv4 addresses properly; error "
        "code %u, address type %u", err, sa_type(&addr)));

  /* Next, let's try an AT_IPv6 address */
  TEST(t_sockaddr_fcns, sa_ipv6, "Test that sa_* functions handle IPv6 "
       "addresses properly",
       (!(err = sa_type_set(&addr, AT_IPv6)) && sa_type(&addr) == AT_IPv6 &&
        !(err = sa_ipaddrbuf_set(&addr, ta)) &&
        !(err = sa_ipaddrport_set(&addr, 0)) &&
        !memcmp(sa_ipaddrbuf(&addr), ta, SOCK_ADDRBUFV6_LEN) &&
        /* Note that the memset() above enables this even in the case of
         * structure padding.  We have to set the port to 0 for the no-
         * padding case in order to make this work.
         */
        sa_ipaddrbuf(&addr)[SOCK_ADDRBUFV6_LEN] == '\0' &&
        sa_ipaddrport(&addr) == 0 &&
        sa_localaddr_set(&addr, ta) == EINVAL), 0,
       ("sa_* functions handle IPv6 addresses properly"),
       ("sa_* functions fail to handle IPv6 addresses properly; error "
        "code %u, address type %u", err, sa_type(&addr)));

  /* Finally, let's try an AT_LOCAL address */
  TEST(t_sockaddr_fcns, sa_local, "Test that sa_* functions handle local "
       "addresses properly",
       (!(err = sa_type_set(&addr, AT_LOCAL)) && sa_type(&addr) == AT_LOCAL &&
        sa_ipaddrbuf_set(&addr, ta) == EINVAL &&
        sa_ipaddrport_set(&addr, 1234) == EINVAL &&
        !(err = sa_localaddr_set(&addr, ta)) &&
        !strcmp(sa_localaddr(&addr), ta)), 0,
       ("sa_* functions handle local addresses properly"),
       ("sa_* functions fail to handle local addresses properly; error "
        "code %u, address type %u", err, sa_type(&addr)));

  /***************************************************************************
   * Next: Test sockaddr_import() and sockaddr_export()                      *
   ***************************************************************************/

  TEST_DECL(t_sockaddr_fcns, sockaddr_import,
            "Test that sockaddr_import() can import socket address structures")
  TEST_DECL(t_sockaddr_fcns, sockaddr_export,
            "Test that sockaddr_export() can export socket address structures")
    do { /* allow us to break out of this test...and groups tests visually */
      struct sockaddr_un sun_in, sun_out;
      struct sockaddr_in sin_in, sin_out;
#ifdef HAVE_SOCKADDR_IN6
      struct sockaddr_in6 sin6_in, sin6_out;
#endif /* HAVE_SOCKADDR_IN6 */

      /* Clearing the socket address structures should allow memcmp() tests */
      memset(&sun_in, 0, sizeof(sun_in));
      memset(&sun_out, 0, sizeof(sun_out));
      memset(&sin_in, 0, sizeof(sin_in));
      memset(&sin_out, 0, sizeof(sin_out));
#ifdef HAVE_SOCKADDR_IN6
      memset(&sin6_in, 0, sizeof(sin6_in));
      memset(&sin6_out, 0, sizeof(sin6_out));
#endif /* HAVE_SOCKADDR_IN6 */

      /* start with a test of AT_LOCAL--that's simple... */
      sun_in.sun_family = AF_LOCAL;
      strcpy(sun_in.sun_path, ta); /* copy the local address over */

      /* Try an import */
      if ((err = sockaddr_import(&addr, (struct sockaddr *)&sun_in)) ||
          sa_type(&addr) != AT_LOCAL || strcmp(ta, sa_localaddr(&addr))) {
        FAIL(TEST_NAME(sockaddr_import), 0,
             "sockaddr_import() failed to import an AT_LOCAL address; "
             "error code %u, address type %u", err, sa_type(&addr));
        break; /* move on with the rest of the tests */
      }

      /* Next, try an export */
      len = sizeof(sun_out);
      if ((err = sockaddr_export(&addr, (struct sockaddr *)&sun_out, &len)) ||
          len != (sizeof(sun_out) - SOCK_LOCALADDR_LEN + strlen(ta)) ||
          memcmp(&sun_in, &sun_out, sizeof(sun_out))) {
        FAIL(TEST_NAME(sockaddr_export), 0,
             "sockaddr_export() failed to export an AT_LOCAL address; "
             "error code %u", err);
        break; /* move on with the rest of the tests */
      }

      /* Now, let's try an IPv4 address... */
      sin_in.sin_family = AF_INET;
      memcpy(&sin_in.sin_addr, ta, SOCK_ADDRBUFV4_LEN);
      sin_in.sin_port = htons(1234); /* have to be able to test port # */

      /* Try an import */
      if ((err = sockaddr_import(&addr, (struct sockaddr *)&sin_in)) ||
          sa_type(&addr) != AT_IPv4 ||
          memcmp(ta, sa_ipaddrbuf(&addr), SOCK_ADDRBUFV4_LEN) ||
          sa_ipaddrport(&addr) != 1234) {
        FAIL(TEST_NAME(sockaddr_import), 0,
             "sockaddr_import() failed to import an AT_IPv4 address; "
             "error code %u, address type %u", err, sa_type(&addr));
        break; /* move on with the rest of the tests */
      }

      /* Next, try an export */
      len = sizeof(sin_out);
      if ((err = sockaddr_export(&addr, (struct sockaddr *)&sin_out, &len)) ||
          len != sizeof(sin_out) || memcmp(&sin_in, &sin_out, len)) {
        FAIL(TEST_NAME(sockaddr_export), 0,
             "sockaddr_export() failed to export an AT_IPv4 address; "
             "error code %u", err);
        break; /* move on with the rest of the tests */
      }

#ifdef HAVE_SOCKADDR_IN6
      /* Finally, let's try an IPv6 address... */
      sin6_in.sin6_family = AF_INET6;
      memcpy(&sin6_in.sin6_addr, ta, SOCK_ADDRBUFV6_LEN);
      sin6_in.sin6_port = htons(1234); /* have to be able to test port # */

      /* Try an import */
      if ((err = sockaddr_import(&addr, (struct sockaddr *)&sin6_in)) ||
          sa_type(&addr) != AT_IPv6 ||
          memcmp(ta, sa_ipaddrbuf(&addr), SOCK_ADDRBUFV6_LEN) ||
          sa_ipaddrport(&addr) != 1234) {
        FAIL(TEST_NAME(sockaddr_import), 0,
             "sockaddr_import() failed to import an AT_IPv6 address; "
             "error code %u, address type %u", err, sa_type(&addr));
        break; /* move on with the rest of the tests */
      }

      /* Next, try an export */
      len = sizeof(sin6_out);
      if ((err = sockaddr_export(&addr, (struct sockaddr *)&sin6_out, &len)) ||
          len != sizeof(sin6_out) || memcmp(&sin6_in, &sin6_out, len)) {
        FAIL(TEST_NAME(sockaddr_export), 0,
             "sockaddr_export() failed to export an AT_IPv6 address; "
             "error code %u", err);
        break; /* move on with the rest of the tests */
      }
#endif /* HAVE_SOCKADDR_IN6 */

      /* Tests have been passed */
      PASS(TEST_NAME(sockaddr_import),
           "sockaddr_import() successfully imported socket addresses");
      PASS(TEST_NAME(sockaddr_export),
           "sockaddr_export() successfully exported socket addresses");
    } while (0);

  /***************************************************************************
   * Finally: Test sockaddr_ptoa() and sockaddr_atop()                       *
   ***************************************************************************/

  TEST_DECL(t_sockaddr_fcns, sockaddr_ptoa,
            "Test that sockaddr_ptoa() can process socket addresses")
  TEST_DECL(t_sockaddr_fcns, sockaddr_atop,
            "Test that sockaddr_atop() can display socket addresses")
    {
      char buf[512], presbuf[512], *t;
      unsigned char addrbuf[SOCK_LOCALADDR_LEN];
      ev_err_t exp;
      ev_satype_t type;
      int len, port;
      FILE *df;

      /* Just skip the tests if the data file isn't available */
      if (argc < 2 || !(df = fopen(argv[1], "r")))
        return 0;

      /* read the data file... */
      while ((t = fgets(buf, sizeof(buf), df))) {
        if ((t = strchr(buf, '\r')) || (t = strchr(buf, '\n')))
          *t = '\0'; /* chomp newline... */

        if (buf[0] == '#' || !(t = strtok(buf, " \t")))
          continue; /* skip empty lines and comments */

        exp = value(t); /* what's the expected return value? */

        if (!(t = strtok(0, " \t"))) { /* er... */
          fprintf(stderr, "%s: Expected IP address reading datafile %s\n",
                  prog, argv[1]);
          continue; /* skip the bogus line */
        }

        /* OK, let's try to parse it... */
        if ((err = sockaddr_ptoa(&addr, t, -1)) != exp)
          FAIL(TEST_NAME(sockaddr_ptoa), FATAL(0),
               "sockaddr_ptoa() failed with unexpected error %u (expected %u)",
               err, exp);

        if (exp || /* expected failure, go on to next test input */
            !(t = strtok(0, " \t"))) /* er, no verification data */
          continue;

        if (sa_type(&addr) != (type = value(t)))
          FAIL(TEST_NAME(sockaddr_ptoa), FATAL(0),
               "sockaddr_ptoa() parsed address type %u (expected %u)",
               sa_type(&addr), type);

        if (!(t = strtok(0, " \t"))) /* grab the address contents... */
          continue; /* no contents, just skip it */

        if (type == AT_LOCAL) { /* it's a local address */
          if (strcmp(sa_localaddr(&addr), t)) /* compare to what we got */
            FAIL(TEST_NAME(sockaddr_ptoa), FATAL(0),
                 "sockaddr_ptoa() parsed incorrect address: \"%s\" "
                 "(expected \"%s\")", sa_localaddr(&addr), t);
        } else { /* IP address, have to decode it */
          port = -1; /* initialize... */
          memset(addrbuf, 0, sizeof(addrbuf));

          /* decode the IP address... */
          for (len = 0; *t && *t; t++, len++)
            if (*t >= '0' && *t <= '9')
              addrbuf[len >> 1] |= (*t - '0') << (!(len & 0x01) << 2);
            else if (*t >= 'a' && *t <= 'f')
              addrbuf[len >> 1] |= (*t - 'a' + 0x0a) << (!(len & 0x01) << 2);
            else
              break; /* unrecognized character */

          if (*t == ':') /* got a port number specification */
            port = atoi(t + 1); /* convert it */
          else if (*t) {
            fprintf(stderr, "%s: Invalid character in address string: %c\n",
                    prog, *t);
            continue; /* skip this line */
          }

          if (memcmp(sa_ipaddrbuf(&addr), addrbuf, len >> 1) ||
              (port > 0 && sa_ipaddrport(&addr) != port))
            FAIL(TEST_NAME(sockaddr_ptoa), FATAL(0),
                 "sockaddr_ptoa() parsed incorrect address or port");
        }

        if (!(t = strtok(0, " \t"))) /* how about a presentation string? */
          continue; /* nothing there, just move on */

        /* try sockaddr_atop()... */
        presbuf[0] = '\0';
        if ((err = sockaddr_atop(&addr, presbuf, sizeof(presbuf), 0)) ||
            strcmp(presbuf, t))
          FAIL(TEST_NAME(sockaddr_atop), FATAL(0),
               "sockaddr_atop() failed or incorrectly formatted address; "
               "error code %u; expected: \"%s\"; got: \"%s\"", err, t,
               presbuf);

        /* Informational message */
        fprintf(stderr, "%s: INFO: Address formats to: \"%s\"\n", prog,
                presbuf);
      }

      /* All tests passed! */
      PASS(TEST_NAME(sockaddr_ptoa),
           "sockaddr_ptoa() correctly parsed addresses");
      PASS(TEST_NAME(sockaddr_atop),
           "sockaddr_atop() correctly formatted addresses");

      fclose(df); /* close the data file */
    }

  return 0;
}

---