src/lib/cmdline_parse_ipaddr.c

   1 /*-
   2  * Copyright (c) <2010>, Intel Corporation
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * - Redistributions of source code must retain the above copyright
  10  *   notice, this list of conditions and the following disclaimer.
  11  *
  12  * - Redistributions in binary form must reproduce the above copyright
  13  *   notice, this list of conditions and the following disclaimer in
  14  *   the documentation and/or other materials provided with the
  15  *   distribution.
  16  *
  17  * - Neither the name of Intel Corporation nor the names of its
  18  *   contributors may be used to endorse or promote products derived
  19  *   from this software without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  25  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  27  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  28  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  30  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  31  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  32  * OF THE POSSIBILITY OF SUCH DAMAGE.
  33  */
  34
  35 /*
  36  * Copyright (c) 2009, Olivier MATZ <zer0@droids-corp.org>
  37  * All rights reserved.
  38  * Redistribution and use in source and binary forms, with or without
  39  * modification, are permitted provided that the following conditions are met:
  40  *
  41  *     * Redistributions of source code must retain the above copyright
  42  *       notice, this list of conditions and the following disclaimer.
  43  *     * Redistributions in binary form must reproduce the above copyright
  44  *       notice, this list of conditions and the following disclaimer in the
  45  *       documentation and/or other materials provided with the distribution.
  46  *     * Neither the name of the University of California, Berkeley nor the
  47  *       names of its contributors may be used to endorse or promote products
  48  *       derived from this software without specific prior written permission.
  49  *
  50  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
  51  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  52  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  53  * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
  54  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  55  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  56  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  57  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  58  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  59  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  60  */
  61
  62 /*
  63  * For inet_ntop() functions:
  64  *
  65  * Copyright (c) 1996 by Internet Software Consortium.
  66  *
  67  * Permission to use, copy, modify, and distribute this software for any
  68  * purpose with or without fee is hereby granted, provided that the above
  69  * copyright notice and this permission notice appear in all copies.
  70  *
  71  * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
  72  * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
  73  * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
  74  * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
  75  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  76  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
  77  * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  78  * SOFTWARE.
  79  */
  80
  81
  82 #include <stdio.h>
  83 #include <stdlib.h>
  84 #include <inttypes.h>
  85 #include <ctype.h>
  86 #include <string.h>
  87 #include <errno.h>
  88 #include <netinet/in.h>
  89 #ifndef __linux__
  90 #include <net/socket.h>
  91 #endif
  92
  93 #include "cmdline_parse.h"
  94 #include "cmdline_parse_ipaddr.h"
  95
  96 struct cmdline_token_ops cmdline_token_ipaddr_ops = {
  97         .parse = cmdline_parse_ipaddr,
  98         .complete_get_nb = NULL,
  99         .complete_get_elt = NULL,
 100         .get_help = cmdline_get_help_ipaddr,
 101 };
 102
 103 #define INADDRSZ 4
 104 #define IN6ADDRSZ 16
 105
 106 /*
 107  * WARNING: Don't even consider trying to compile this on a system where
 108  * sizeof(int) < 4.  sizeof(int) > 4 is fine; all the world's not a VAX.
 109  */
 110
 111 static int inet_pton4(const char *src, unsigned char *dst);
 112 static int inet_pton6(const char *src, unsigned char *dst);
 113
 114 /* int
 115  * inet_pton(af, src, dst)
 116  *      convert from presentation format (which usually means ASCII printable)
 117  *      to network format (which is usually some kind of binary format).
 118  * return:
 119  *      1 if the address was valid for the specified address family
 120  *      0 if the address wasn't valid (`dst' is untouched in this case)
 121  *      -1 if some other error occurred (`dst' is untouched in this case, too)
 122  * author:
 123  *      Paul Vixie, 1996.
 124  */
 125 static int
 126 my_inet_pton(int af, const char *src, void *dst)
 127 {
 128         switch (af) {
 129                 case AF_INET:
 130                         return (inet_pton4(src, dst));
 131                 case AF_INET6:
 132                         return (inet_pton6(src, dst));
 133                 default:
 134                         errno = EAFNOSUPPORT;
 135                         return (-1);
 136         }
 137         /* NOTREACHED */
 138 }
 139
 140 /* int
 141  * inet_pton4(src, dst)
 142  *      like inet_aton() but without all the hexadecimal and shorthand.
 143  * return:
 144  *      1 if `src' is a valid dotted quad, else 0.
 145  * notice:
 146  *      does not touch `dst' unless it's returning 1.
 147  * author:
 148  *      Paul Vixie, 1996.
 149  */
 150 static int
 151 inet_pton4(const char *src, unsigned char *dst)
 152 {
 153         static const char digits[] = "0123456789";
 154         int saw_digit, octets, ch;
 155         unsigned char tmp[INADDRSZ], *tp;
 156
 157         saw_digit = 0;
 158         octets = 0;
 159         *(tp = tmp) = 0;
 160         while ((ch = *src++) != '\0') {
 161                 const char *pch;
 162
 163                 if ((pch = strchr(digits, ch)) != NULL) {
 164                         unsigned int new = *tp * 10 + (pch - digits);
 165
 166                         if (new > 255)
 167                                 return (0);
 168                         if (! saw_digit) {
 169                                 if (++octets > 4)
 170                                         return (0);
 171                                 saw_digit = 1;
 172                         }
 173                         *tp = (unsigned char)new;
 174                 } else if (ch == '.' && saw_digit) {
 175                         if (octets == 4)
 176                                 return (0);
 177                         *++tp = 0;
 178                         saw_digit = 0;
 179                 } else
 180                         return (0);
 181         }
 182         if (octets < 4)
 183                 return (0);
 184
 185         memcpy(dst, tmp, INADDRSZ);
 186         return (1);
 187 }
 188
 189 /* int
 190  * inet_pton6(src, dst)
 191  *      convert presentation level address to network order binary form.
 192  * return:
 193  *      1 if `src' is a valid [RFC1884 2.2] address, else 0.
 194  * notice:
 195  *      (1) does not touch `dst' unless it's returning 1.
 196  *      (2) :: in a full address is silently ignored.
 197  * credit:
 198  *      inspired by Mark Andrews.
 199  * author:
 200  *      Paul Vixie, 1996.
 201  */
 202 static int
 203 inet_pton6(const char *src, unsigned char *dst)
 204 {
 205         static const char xdigits_l[] = "0123456789abcdef",
 206                 xdigits_u[] = "0123456789ABCDEF";
 207         unsigned char tmp[IN6ADDRSZ], *tp, *endp, *colonp;
 208         const char *xdigits, *curtok;
 209         int ch, saw_xdigit, count_xdigit;
 210         unsigned int val;
 211
 212         memset((tp = tmp), '\0', IN6ADDRSZ);
 213         endp = tp + IN6ADDRSZ;
 214         colonp = NULL;
 215         /* Leading :: requires some special handling. */
 216         if (*src == ':')
 217                 if (*++src != ':')
 218                         return (0);
 219         curtok = src;
 220         saw_xdigit = count_xdigit = 0;
 221         val = 0;
 222         while ((ch = *src++) != '\0') {
 223                 const char *pch;
 224
 225                 if ((pch = strchr((xdigits = xdigits_l), ch)) == NULL)
 226                         pch = strchr((xdigits = xdigits_u), ch);
 227                 if (pch != NULL) {
 228                         if (count_xdigit >= 4)
 229                                 return (0);
 230                         val <<= 4;
 231                         val |= (pch - xdigits);
 232                         if (val > 0xffff)
 233                                 return (0);
 234                         saw_xdigit = 1;
 235                         count_xdigit++;
 236                         continue;
 237                 }
 238                 if (ch == ':') {
 239                         curtok = src;
 240                         if (!saw_xdigit) {
 241                                 if (colonp)
 242                                         return (0);
 243                                 colonp = tp;
 244                                 continue;
 245                         } else if (*src == '\0') {
 246                                 return (0);
 247                         }
 248                         if (tp + sizeof(int16_t) > endp)
 249                                 return (0);
 250                         *tp++ = (unsigned char) ((val >> 8) & 0xff);
 251                         *tp++ = (unsigned char) (val & 0xff);
 252                         saw_xdigit = 0;
 253                         count_xdigit = 0;
 254                         val = 0;
 255                         continue;
 256                 }
 257                 if (ch == '.' && ((tp + INADDRSZ) <= endp) &&
 258                     inet_pton4(curtok, tp) > 0) {
 259                         tp += INADDRSZ;
 260                         saw_xdigit = 0;
 261                         count_xdigit = 0;
 262                         break;  /* '\0' was seen by inet_pton4(). */
 263                 }
 264                 return (0);
 265         }
 266         if (saw_xdigit) {
 267                 if (tp + sizeof(int16_t) > endp)
 268                         return (0);
 269                 *tp++ = (unsigned char) ((val >> 8) & 0xff);
 270                 *tp++ = (unsigned char) (val & 0xff);
 271         }
 272         if (colonp != NULL) {
 273                 /*
 274                  * Since some memmove()'s erroneously fail to handle
 275                  * overlapping regions, we'll do the shift by hand.
 276                  */
 277                 const int n = tp - colonp;
 278                 int i;
 279
 280                 for (i = 1; i <= n; i++) {
 281                         endp[- i] = colonp[n - i];
 282                         colonp[n - i] = 0;
 283                 }
 284                 tp = endp;
 285         }
 286         if (tp != endp)
 287                 return (0);
 288         memcpy(dst, tmp, IN6ADDRSZ);
 289         return (1);
 290 }
 291
 292 int
 293 cmdline_parse_ipaddr(cmdline_parse_token_hdr_t *tk, const char *buf, void *res,
 294                      unsigned ressize)
 295 {
 296         struct cmdline_token_ipaddr *tk2 = (struct cmdline_token_ipaddr *)tk;
 297         unsigned int token_len = 0;
 298         char ip_str[INET6_ADDRSTRLEN+4]; /* '+4' is for prefixlen (if any) */
 299         cmdline_ipaddr_t *ipaddr = res;
 300         char *prefix, *prefix_end;
 301         long prefixlen;
 302
 303         if (res && ressize < sizeof(cmdline_ipaddr_t))
 304                 return -1;
 305
 306         /* if token is too big... */
 307         token_len = snprintf(ip_str, sizeof(ip_str), "%s", buf);
 308         if (token_len >= sizeof(ip_str))
 309                 return -1;
 310
 311         /* convert the network prefix */
 312         if (tk2->ipaddr_data.flags & CMDLINE_IPADDR_NETWORK) {
 313                 prefix = strrchr(ip_str, '/');
 314                 if (prefix == NULL)
 315                         return -1;
 316                 *prefix = '\0';
 317                 prefix ++;
 318                 errno = 0;
 319                 prefixlen = strtol(prefix, &prefix_end, 10);
 320                 if (errno || (*prefix_end != '\0') )
 321                         return -1;
 322                 ipaddr->prefixlen = prefixlen;
 323         }
 324         else {
 325                 ipaddr->prefixlen = 0;
 326         }
 327
 328         /* convert the IP addr */
 329         if ((tk2->ipaddr_data.flags & CMDLINE_IPADDR_V4) &&
 330             my_inet_pton(AF_INET, ip_str, &ipaddr->addr.ipv4) == 1) {
 331                 ipaddr->family = AF_INET;
 332                 return token_len;
 333         }
 334         if ((tk2->ipaddr_data.flags & CMDLINE_IPADDR_V6) &&
 335             my_inet_pton(AF_INET6, ip_str, &ipaddr->addr.ipv6) == 1) {
 336                 ipaddr->family = AF_INET6;
 337                 return token_len;
 338         }
 339         return -1;
 340
 341 }
 342
 343 int cmdline_get_help_ipaddr(cmdline_parse_token_hdr_t *tk, char *dstbuf,
 344                             unsigned int size)
 345 {
 346         struct cmdline_token_ipaddr *tk2 = (struct cmdline_token_ipaddr *)tk;
 347
 348         switch (tk2->ipaddr_data.flags) {
 349         case CMDLINE_IPADDR_V4:
 350                 snprintf(dstbuf, size, "IPv4");
 351                 break;
 352         case CMDLINE_IPADDR_V6:
 353                 snprintf(dstbuf, size, "IPv6");
 354                 break;
 355         case CMDLINE_IPADDR_V4|CMDLINE_IPADDR_V6:
 356                 snprintf(dstbuf, size, "IPv4/IPv6");
 357                 break;
 358         case CMDLINE_IPADDR_NETWORK|CMDLINE_IPADDR_V4:
 359                 snprintf(dstbuf, size, "IPv4 network");
 360                 break;
 361         case CMDLINE_IPADDR_NETWORK|CMDLINE_IPADDR_V6:
 362                 snprintf(dstbuf, size, "IPv6 network");
 363                 break;
 364         case CMDLINE_IPADDR_NETWORK|CMDLINE_IPADDR_V4|CMDLINE_IPADDR_V6:
 365                 snprintf(dstbuf, size, "IPv4/IPv6 network");
 366                 break;
 367         default:
 368                 snprintf(dstbuf, size, "IPaddr (bad flags)");
 369                 break;
 370         }
 371         return 0;
 372 }