net/inet_addr.c

   1 /*
   2  * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * Copyright (c) 1999-2003 Apple Computer, Inc.  All Rights Reserved.
   7  *
   8  * This file contains Original Code and/or Modifications of Original Code
   9  * as defined in and that are subject to the Apple Public Source License
  10  * Version 2.0 (the 'License'). You may not use this file except in
  11  * compliance with the License. Please obtain a copy of the License at
  12  * http://www.opensource.apple.com/apsl/ and read it before using this
  13  * file.
  14  *
  15  * The Original Code and all software distributed under the License are
  16  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  17  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  18  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  20  * Please see the License for the specific language governing rights and
  21  * limitations under the License.
  22  *
  23  * @APPLE_LICENSE_HEADER_END@
  24  */
  25 /*
  26  * Copyright (c) 1983, 1990, 1993
  27  *      The Regents of the University of California.  All rights reserved.
  28  *
  29  * Redistribution and use in source and binary forms, with or without
  30  * modification, are permitted provided that the following conditions
  31  * are met:
  32  * 1. Redistributions of source code must retain the above copyright
  33  *    notice, this list of conditions and the following disclaimer.
  34  * 2. Redistributions in binary form must reproduce the above copyright
  35  *    notice, this list of conditions and the following disclaimer in the
  36  *    documentation and/or other materials provided with the distribution.
  37  * 3. All advertising materials mentioning features or use of this software
  38  *    must display the following acknowledgement:
  39  *      This product includes software developed by the University of
  40  *      California, Berkeley and its contributors.
  41  * 4. Neither the name of the University nor the names of its contributors
  42  *    may be used to endorse or promote products derived from this software
  43  *    without specific prior written permission.
  44  *
  45  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  46  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  47  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  48  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  49  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  50  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  51  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  52  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  53  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  54  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  55  * SUCH DAMAGE.
  56  */
  57
  58
  59 #include <sys/param.h>
  60 #include <netinet/in.h>
  61 #include <arpa/inet.h>
  62 #include <ctype.h>
  63 #include <errno.h>
  64
  65 /*
  66  * Ascii internet address interpretation routine.
  67  * The value returned is in network order.
  68  */
  69 u_long
  70 inet_addr(cp)
  71         register const char *cp;
  72 {
  73         struct in_addr val;
  74
  75         if (inet_aton(cp, &val))
  76                 return (val.s_addr);
  77         return (INADDR_NONE);
  78 }
  79
  80 /*
  81  * Check whether "cp" is a valid ascii representation
  82  * of an Internet address and convert to a binary address.
  83  * Returns 1 if the address is valid, 0 if not.
  84  * This replaces inet_addr, the return value from which
  85  * cannot distinguish between failure and a local broadcast address.
  86  */
  87 int
  88 inet_aton(cp, addr)
  89         register const char *cp;
  90         struct in_addr *addr;
  91 {
  92         u_long parts[4];
  93         u_int32_t val;
  94         char *c;
  95         char *endptr;
  96         int gotend, n;
  97
  98         c = (char *)cp;
  99         n = 0;
 100         /*
 101          * Run through the string, grabbing numbers until
 102          * the end of the string, or some error
 103          */
 104         gotend = 0;
 105         while (!gotend) {
 106                 errno = 0;
 107                 val = strtoul(c, &endptr, 0);
 108
 109                 if (errno == ERANGE)    /* Fail completely if it overflowed. */
 110                         return (0);
 111
 112                 /*
 113                  * If the whole string is invalid, endptr will equal
 114                  * c.. this way we can make sure someone hasn't
 115                  * gone '.12' or something which would get past
 116                  * the next check.
 117                  */
 118                 if (endptr == c)
 119                         return (0);
 120                 parts[n] = val;
 121                 c = endptr;
 122
 123                 /* Check the next character past the previous number's end */
 124                 switch (*c) {
 125                 case '.' :
 126                         /* Make sure we only do 3 dots .. */
 127                         if (n == 3)     /* Whoops. Quit. */
 128                                 return (0);
 129                         n++;
 130                         c++;
 131                         break;
 132
 133                 case '\0':
 134                         gotend = 1;
 135                         break;
 136
 137                 default:
 138                         if (isspace((unsigned char)*c)) {
 139                                 gotend = 1;
 140                                 break;
 141                         } else
 142                                 return (0);     /* Invalid character, so fail */
 143                 }
 144
 145         }
 146
 147         /*
 148          * Concoct the address according to
 149          * the number of parts specified.
 150          */
 151
 152         switch (n) {
 153         case 0:                         /* a -- 32 bits */
 154                 /*
 155                  * Nothing is necessary here.  Overflow checking was
 156                  * already done in strtoul().
 157                  */
 158                 break;
 159         case 1:                         /* a.b -- 8.24 bits */
 160                 if (val > 0xffffff || parts[0] > 0xff)
 161                         return (0);
 162                 val |= parts[0] << 24;
 163                 break;
 164
 165         case 2:                         /* a.b.c -- 8.8.16 bits */
 166                 if (val > 0xffff || parts[0] > 0xff || parts[1] > 0xff)
 167                         return (0);
 168                 val |= (parts[0] << 24) | (parts[1] << 16);
 169                 break;
 170
 171         case 3:                         /* a.b.c.d -- 8.8.8.8 bits */
 172                 if (val > 0xff || parts[0] > 0xff || parts[1] > 0xff ||
 173                     parts[2] > 0xff)
 174                         return (0);
 175                 val |= (parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8);
 176                 break;
 177         }
 178
 179         if (addr != NULL)
 180                 addr->s_addr = htonl(val);
 181         return (1);
 182 }