/*      $NetBSD: inet_pton.c,v 1.8 2012/03/13 21:13:38 christos Exp $   */

/*
* Copyright (c) 2004 by Internet Systems Consortium, Inc. ("ISC")
* Copyright (c) 1996,1999 by Internet Software Consortium.
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
* OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/

#include <sys/cdefs.h>
#if defined(LIBC_SCCS) && !defined(lint)
#if 0
static const char rcsid[] = "Id: inet_pton.c,v 1.5 2005/07/28 06:51:47 marka Exp";
#else
__RCSID("$NetBSD: inet_pton.c,v 1.8 2012/03/13 21:13:38 christos Exp $");
#endif
#endif /* LIBC_SCCS and not lint */

#include "port_before.h"

#include "namespace.h"
#include <sys/param.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <arpa/nameser.h>
#include <stddef.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
#include <errno.h>

#include "port_after.h"

#ifdef __weak_alias
__weak_alias(inet_pton,_inet_pton)
#endif

/*%
* WARNING: Don't even consider trying to compile this on a system where
* sizeof(int) < 4.  sizeof(int) > 4 is fine; all the world's not a VAX.
*/

static int      inet_pton4(const char *src, u_char *dst, int pton);
static int      inet_pton6(const char *src, u_char *dst);

/* int
* inet_pton(af, src, dst)
*      convert from presentation format (which usually means ASCII printable)
*      to network format (which is usually some kind of binary format).
* return:
*      1 if the address was valid for the specified address family
*      0 if the address wasn't valid (`dst' is untouched in this case)
*      -1 if some other error occurred (`dst' is untouched in this case, too)
* author:
*      Paul Vixie, 1996.
*/
int
inet_pton(int af, const char *src, void *dst)
{

       _DIAGASSERT(src != NULL);
       _DIAGASSERT(dst != NULL);

       switch (af) {
       case AF_INET:
               return (inet_pton4(src, dst, 1));
       case AF_INET6:
               return (inet_pton6(src, dst));
       default:
               errno = EAFNOSUPPORT;
               return (-1);
       }
       /* NOTREACHED */
}

/* int
* inet_pton4(src, dst, pton)
*      when last arg is 0: inet_aton(). with hexadecimal, octal and shorthand.
*      when last arg is 1: inet_pton(). decimal dotted-quad only.
* return:
*      1 if `src' is a valid input, else 0.
* notice:
*      does not touch `dst' unless it's returning 1.
* author:
*      Paul Vixie, 1996.
*/
static int
inet_pton4(const char *src, u_char *dst, int pton)
{
       u_int32_t val;
       u_int digit, base;
       ptrdiff_t n;
       unsigned char c;
       u_int parts[4];
       u_int *pp = parts;

       _DIAGASSERT(src != NULL);
       _DIAGASSERT(dst != NULL);

       c = *src;
       for (;;) {
               /*
                * Collect number up to ``.''.
                * Values are specified as for C:
                * 0x=hex, 0=octal, isdigit=decimal.
                */
               if (!isdigit(c))
                       return (0);
               val = 0; base = 10;
               if (c == '0') {
                       c = *++src;
                       if (c == 'x' || c == 'X')
                               base = 16, c = *++src;
                       else if (isdigit(c) && c != '9')
                               base = 8;
               }
               /* inet_pton() takes decimal only */
               if (pton && base != 10)
                       return (0);
               for (;;) {
                       if (isdigit(c)) {
                               digit = c - '0';
                               if (digit >= base)
                                       break;
                               val = (val * base) + digit;
                               c = *++src;
                       } else if (base == 16 && isxdigit(c)) {
                               digit = c + 10 - (islower(c) ? 'a' : 'A');
                               if (digit >= 16)
                                       break;
                               val = (val << 4) | digit;
                               c = *++src;
                       } else
                               break;
               }
               if (c == '.') {
                       /*
                        * Internet format:
                        *      a.b.c.d
                        *      a.b.c   (with c treated as 16 bits)
                        *      a.b     (with b treated as 24 bits)
                        *      a       (with a treated as 32 bits)
                        */
                       if (pp >= parts + 3)
                               return (0);
                       *pp++ = val;
                       c = *++src;
               } else
                       break;
       }
       /*
        * Check for trailing characters.
        */
       if (c != '\0' && !isspace(c))
               return (0);
       /*
        * Concoct the address according to
        * the number of parts specified.
        */
       n = pp - parts + 1;
       /* inet_pton() takes dotted-quad only.  it does not take shorthand. */
       if (pton && n != 4)
               return (0);
       switch (n) {

       case 0:
               return (0);             /* initial nondigit */

       case 1:                         /* a -- 32 bits */
               break;

       case 2:                         /* a.b -- 8.24 bits */
               if (parts[0] > 0xff || val > 0xffffff)
                       return (0);
               val |= parts[0] << 24;
               break;

       case 3:                         /* a.b.c -- 8.8.16 bits */
               if ((parts[0] | parts[1]) > 0xff || val > 0xffff)
                       return (0);
               val |= (parts[0] << 24) | (parts[1] << 16);
               break;

       case 4:                         /* a.b.c.d -- 8.8.8.8 bits */
               if ((parts[0] | parts[1] | parts[2] | val) > 0xff)
                       return (0);
               val |= (parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8);
               break;
       }
       if (dst) {
               val = htonl(val);
               memcpy(dst, &val, NS_INADDRSZ);
       }
       return (1);
}

/* int
* inet_pton6(src, dst)
*      convert presentation level address to network order binary form.
* return:
*      1 if `src' is a valid [RFC1884 2.2] address, else 0.
* notice:
*      (1) does not touch `dst' unless it's returning 1.
*      (2) :: in a full address is silently ignored.
* credit:
*      inspired by Mark Andrews.
* author:
*      Paul Vixie, 1996.
*/
static int
inet_pton6(const char *src, u_char *dst)
{
       static const char xdigits_l[] = "0123456789abcdef",
                         xdigits_u[] = "0123456789ABCDEF";
       u_char tmp[NS_IN6ADDRSZ], *tp, *endp, *colonp;
       const char *xdigits, *curtok;
       int ch, seen_xdigits;
       u_int val;

       _DIAGASSERT(src != NULL);
       _DIAGASSERT(dst != NULL);

       memset((tp = tmp), '\0', NS_IN6ADDRSZ);
       endp = tp + NS_IN6ADDRSZ;
       colonp = NULL;
       /* Leading :: requires some special handling. */
       if (*src == ':')
               if (*++src != ':')
                       return (0);
       curtok = src;
       seen_xdigits = 0;
       val = 0;
       while ((ch = *src++) != '\0') {
               const char *pch;

               if ((pch = strchr((xdigits = xdigits_l), ch)) == NULL)
                       pch = strchr((xdigits = xdigits_u), ch);
               if (pch != NULL) {
                       val <<= 4;
                       val |= (int)(pch - xdigits);
                       if (++seen_xdigits > 4)
                               return (0);
                       continue;
               }
               if (ch == ':') {
                       curtok = src;
                       if (!seen_xdigits) {
                               if (colonp)
                                       return (0);
                               colonp = tp;
                               continue;
                       } else if (*src == '\0')
                               return (0);
                       if (tp + NS_INT16SZ > endp)
                               return (0);
                       *tp++ = (u_char) (val >> 8) & 0xff;
                       *tp++ = (u_char) val & 0xff;
                       seen_xdigits = 0;
                       val = 0;
                       continue;
               }
               if (ch == '.' && ((tp + NS_INADDRSZ) <= endp) &&
                   inet_pton4(curtok, tp, 1) > 0) {
                       tp += NS_INADDRSZ;
                       seen_xdigits = 0;
                       break;  /*%< '\\0' was seen by inet_pton4(). */
               }
               return (0);
       }
       if (seen_xdigits) {
               if (tp + NS_INT16SZ > endp)
                       return (0);
               *tp++ = (u_char) (val >> 8) & 0xff;
               *tp++ = (u_char) val & 0xff;
       }
       if (colonp != NULL) {
               /*
                * Since some memmove()'s erroneously fail to handle
                * overlapping regions, we'll do the shift by hand.
                */
               const ptrdiff_t n = tp - colonp;
               int i;

               if (tp == endp)
                       return (0);
               for (i = 1; i <= n; i++) {
                       endp[- i] = colonp[n - i];
                       colonp[n - i] = 0;
               }
               tp = endp;
       }
       if (tp != endp)
               return (0);
       memcpy(dst, tmp, NS_IN6ADDRSZ);
       return (1);
}

/*! \file */

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.