net/inet_addr-fbsd.c

   1 /*      $KAME: inet_addr.c,v 1.5 2001/08/20 02:32:40 itojun Exp $       */
   2
   3 /*
   4  * ++Copyright++ 1983, 1990, 1993
   5  * -
   6  * Copyright (c) 1983, 1990, 1993
   7  *    The Regents of the University of California.  All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  * 3. All advertising materials mentioning features or use of this software
  18  *    must display the following acknowledgement:
  19  *      This product includes software developed by the University of
  20  *      California, Berkeley and its contributors.
  21  * 4. Neither the name of the University nor the names of its contributors
  22  *    may be used to endorse or promote products derived from this software
  23  *    without specific prior written permission.
  24  *
  25  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  27  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  28  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  29  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  30  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  31  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  32  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  33  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  34  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  35  * SUCH DAMAGE.
  36  * -
  37  * Portions Copyright (c) 1993 by Digital Equipment Corporation.
  38  *
  39  * Permission to use, copy, modify, and distribute this software for any
  40  * purpose with or without fee is hereby granted, provided that the above
  41  * copyright notice and this permission notice appear in all copies, and that
  42  * the name of Digital Equipment Corporation not be used in advertising or
  43  * publicity pertaining to distribution of the document or software without
  44  * specific, written prior permission.
  45  *
  46  * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
  47  * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
  48  * OF MERCHANTABILITY AND FITNESS.   IN NO EVENT SHALL DIGITAL EQUIPMENT
  49  * CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
  50  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  51  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
  52  * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  53  * SOFTWARE.
  54  * -
  55  * --Copyright--
  56  */
  57
  58 #if defined(LIBC_SCCS) && !defined(lint)
  59 static char sccsid[] = "@(#)inet_addr.c 8.1 (Berkeley) 6/17/93";
  60 #endif /* LIBC_SCCS and not lint */
  61 #include <sys/cdefs.h>
  62 __FBSDID("$FreeBSD: src/lib/libc/net/inet_addr.c,v 1.16 2002/04/19 04:46:20 suz Exp $");
  63
  64 #include "xlocale_private.h"
  65
  66 #include <sys/param.h>
  67
  68 #include <netinet/in.h>
  69 #include <arpa/inet.h>
  70
  71 #include <ctype.h>
  72 #include <errno.h>
  73 #include <string.h>
  74 #include <stdlib.h>
  75
  76 /*
  77  * ASCII internet address interpretation routine.
  78  * The value returned is in network order.
  79  */
  80 in_addr_t               /* XXX should be struct in_addr :( */
  81 inet_addr(cp)
  82         const char *cp;
  83 {
  84         struct in_addr val;
  85
  86         if (inet_aton(cp, &val))
  87                 return (val.s_addr);
  88         return (INADDR_NONE);
  89 }
  90
  91 /*
  92  * Check whether "cp" is a valid ASCII representation
  93  * of an Internet address and convert to a binary address.
  94  * Returns 1 if the address is valid, 0 if not.
  95  * This replaces inet_addr, the return value from which
  96  * cannot distinguish between failure and a local broadcast address.
  97  */
  98 int
  99 inet_aton(cp, addr)
 100         const char *cp;
 101         struct in_addr *addr;
 102 {
 103         u_long parts[4];
 104         in_addr_t val;
 105         char *c;
 106         char *endptr;
 107         int gotend, n;
 108         locale_t loc = __current_locale();
 109
 110         c = (char *)cp;
 111         n = 0;
 112         /*
 113          * Run through the string, grabbing numbers until
 114          * the end of the string, or some error
 115          */
 116         gotend = 0;
 117         while (!gotend) {
 118                 errno = 0;
 119                 val = strtoul_l(c, &endptr, 0, loc);
 120
 121                 if (errno == ERANGE)    /* Fail completely if it overflowed. */
 122                         return (0);
 123
 124                 /*
 125                  * If the whole string is invalid, endptr will equal
 126                  * c.. this way we can make sure someone hasn't
 127                  * gone '.12' or something which would get past
 128                  * the next check.
 129                  */
 130                 if (endptr == c)
 131                         return (0);
 132                 parts[n] = val;
 133                 c = endptr;
 134
 135                 /* Check the next character past the previous number's end */
 136                 switch (*c) {
 137                 case '.' :
 138                         /* Make sure we only do 3 dots .. */
 139                         if (n == 3)     /* Whoops. Quit. */
 140                                 return (0);
 141                         n++;
 142                         c++;
 143                         break;
 144
 145                 case '\0':
 146                         gotend = 1;
 147                         break;
 148
 149                 default:
 150                         if (isspace_l((unsigned char)*c, loc)) {
 151                                 gotend = 1;
 152                                 break;
 153                         } else
 154                                 return (0);     /* Invalid character, so fail */
 155                 }
 156
 157         }
 158
 159         /*
 160          * Concoct the address according to
 161          * the number of parts specified.
 162          */
 163
 164         switch (n) {
 165         case 0:                         /* a -- 32 bits */
 166                 /*
 167                  * Nothing is necessary here.  Overflow checking was
 168                  * already done in strtoul().
 169                  */
 170                 break;
 171         case 1:                         /* a.b -- 8.24 bits */
 172                 if (val > 0xffffff || parts[0] > 0xff)
 173                         return (0);
 174                 val |= parts[0] << 24;
 175                 break;
 176
 177         case 2:                         /* a.b.c -- 8.8.16 bits */
 178                 if (val > 0xffff || parts[0] > 0xff || parts[1] > 0xff)
 179                         return (0);
 180                 val |= (parts[0] << 24) | (parts[1] << 16);
 181                 break;
 182
 183         case 3:                         /* a.b.c.d -- 8.8.8.8 bits */
 184                 if (val > 0xff || parts[0] > 0xff || parts[1] > 0xff ||
 185                     parts[2] > 0xff)
 186                         return (0);
 187                 val |= (parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8);
 188                 break;
 189         }
 190
 191         if (addr != NULL)
 192                 addr->s_addr = htonl(val);
 193         return (1);
 194 }
 195
 196 /*
 197  * Weak aliases for applications that use certain private entry points,
 198  * and fail to include <arpa/inet.h>.
 199  */
 200 #undef inet_addr
 201 __weak_reference(__inet_addr, inet_addr);
 202 #undef inet_aton
 203 __weak_reference(__inet_aton, inet_aton);