src/libfreeswan/libfreeswan/ttoaddr.c

   1 /*
   2  * conversion from text forms of addresses to internal ones
   3  * Copyright (C) 2000  Henry Spencer.
   4  *
   5  * This library is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU Library General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or (at your
   8  * option) any later version.  See <http://www.fsf.org/copyleft/lgpl.txt>.
   9  *
  10  * This library is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  12  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
  13  * License for more details.
  14  *
  15  * RCSID $Id: ttoaddr.c,v 1.1 2004/03/15 20:35:26 as Exp $
  16  */
  17 #include "internal.h"
  18 #include "freeswan.h"
  19
  20 /*
  21  * Legal ASCII characters in a domain name.  Underscore technically is not,
  22  * but is a common misunderstanding.  Non-ASCII characters are simply
  23  * exempted from checking at the moment, to allow for UTF-8 encoded stuff;
  24  * the purpose of this check is merely to catch blatant errors.
  25  */
  26 static const char namechars[] = "abcdefghijklmnopqrstuvwxyz0123456789"
  27                                 "ABCDEFGHIJKLMNOPQRSTUVWXYZ-_.";
  28 #define ISASCII(c)      (((c) & 0x80) == 0)
  29
  30 static err_t tryname(const char *, size_t, int, int, ip_address *);
  31 static err_t tryhex(const char *, size_t, int, ip_address *);
  32 static err_t trydotted(const char *, size_t, ip_address *);
  33 static err_t getbyte(const char **, const char *, int *);
  34 static err_t colon(const char *, size_t, ip_address *);
  35 static err_t getpiece(const char **, const char *, unsigned *);
  36
  37 /*
  38  - ttoaddr - convert text name or dotted-decimal address to binary address
  39  */
  40 err_t                           /* NULL for success, else string literal */
  41 ttoaddr(src, srclen, af, dst)
  42 const char *src;
  43 size_t srclen;                  /* 0 means "apply strlen" */
  44 int af;                         /* address family */
  45 ip_address *dst;
  46 {
  47         err_t oops;
  48 #       define  HEXLEN  10      /* strlen("0x11223344") */
  49         int nultermd;
  50
  51         if (srclen == 0) {
  52                 srclen = strlen(src);
  53                 if (srclen == 0)
  54                         return "empty string";
  55                 nultermd = 1;
  56         } else
  57                 nultermd = 0;   /* at least, not *known* to be terminated */
  58
  59         switch (af) {
  60         case AF_INET:
  61         case AF_INET6:
  62         case 0:                  /* guess */
  63                 break;
  64
  65         default:
  66                 return "invalid address family";
  67         }
  68
  69         if (af == AF_INET && srclen == HEXLEN && *src == '0') {
  70                 if (*(src+1) == 'x' || *(src+1) == 'X')
  71                         return tryhex(src+2, srclen-2, 'x', dst);
  72                 if (*(src+1) == 'h' || *(src+1) == 'H')
  73                         return tryhex(src+2, srclen-2, 'h', dst);
  74         }
  75
  76         if (memchr(src, ':', srclen) != NULL) {
  77             if(af == 0)
  78             {
  79                 af = AF_INET6;
  80             }
  81
  82                 if (af != AF_INET6)
  83                         return "non-ipv6 address may not contain `:'";
  84                 return colon(src, srclen, dst);
  85         }
  86
  87         if (af == 0 || af == AF_INET) {
  88                 oops = trydotted(src, srclen, dst);
  89                 if (oops == NULL)
  90                         return NULL;            /* it worked */
  91                 if (*oops != '?')
  92                         return oops;            /* probably meant as d-d */
  93         }
  94
  95         return tryname(src, srclen, nultermd, af, dst);
  96 }
  97
  98 /*
  99  - tnatoaddr - convert text numeric address (only) to binary address
 100  */
 101 err_t                           /* NULL for success, else string literal */
 102 tnatoaddr(src, srclen, af, dst)
 103 const char *src;
 104 size_t srclen;                  /* 0 means "apply strlen" */
 105 int af;                         /* address family */
 106 ip_address *dst;
 107 {
 108         err_t oops;
 109
 110         if (srclen == 0) {
 111                 srclen = strlen(src);
 112                 if (srclen == 0)
 113                         return "empty string";
 114         }
 115
 116         switch (af) {
 117         case 0:  /* guess */
 118                 oops = colon(src, srclen, dst);
 119                 if(oops == NULL)
 120                 {
 121                     return NULL;
 122                 }
 123                 oops = trydotted(src, srclen, dst);
 124                 if(oops == NULL)
 125                 {
 126                     return NULL;
 127                 }
 128                 return "does not appear to be either IPv4 or IPv6 numeric address";
 129                 break;
 130
 131         case AF_INET6:
 132                 return colon(src, srclen, dst);
 133                 break;
 134         case AF_INET:
 135                 oops = trydotted(src, srclen, dst);
 136                 if (oops == NULL)
 137                         return NULL;            /* it worked */
 138                 if (*oops != '?')
 139                         return oops;            /* probably meant as d-d */
 140                 return "does not appear to be numeric address";
 141                 break;
 142         default:
 143                 return "unknown address family in tnatoaddr";
 144                 break;
 145         }
 146 }
 147
 148 /*
 149  - tryname - try it as a name
 150  * Slightly complicated by lack of reliable NUL termination in source.
 151  */
 152 static err_t
 153 tryname(src, srclen, nultermd, af, dst)
 154 const char *src;
 155 size_t srclen;
 156 int nultermd;                   /* is it known to be NUL-terminated? */
 157 int af;
 158 ip_address *dst;
 159 {
 160         struct hostent *h;
 161         struct netent *ne = NULL;
 162         char namebuf[100];      /* enough for most DNS names */
 163         const char *cp;
 164         char *p = namebuf;
 165         size_t n;
 166
 167         for (cp = src, n = srclen; n > 0; cp++, n--)
 168                 if (ISASCII(*cp) && strchr(namechars, *cp) == NULL)
 169                         return "illegal (non-DNS-name) character in name";
 170
 171         if (nultermd)
 172                 cp = src;
 173         else {
 174                 if (srclen+1 > sizeof(namebuf)) {
 175                         p = (char *) MALLOC(srclen+1);
 176                         if (p == NULL)
 177                                 return "unable to get temporary space for name";
 178                 }
 179                 p[0] = '\0';    /* strncpy semantics are wrong */
 180                 strncat(p, src, srclen);
 181                 cp = (const char *)p;
 182         }
 183
 184         h = gethostbyname2(cp, af);
 185         if (h == NULL && af == AF_INET)
 186                 ne = getnetbyname(cp);
 187         if (p != namebuf)
 188                 FREE(p);
 189         if (h == NULL && ne == NULL)
 190                 return "does not look numeric and name lookup failed";
 191
 192         if (h != NULL) {
 193                 if (h->h_addrtype != af)
 194                         return "address-type mismatch from gethostbyname2!!!";
 195                 return initaddr((unsigned char *)h->h_addr, h->h_length, af, dst);
 196         } else {
 197                 if (ne->n_addrtype != af)
 198                         return "address-type mismatch from getnetbyname!!!";
 199                 ne->n_net = htonl(ne->n_net);
 200                 return initaddr((unsigned char *)&ne->n_net, sizeof(ne->n_net),
 201                                                                 af, dst);
 202         }
 203 }
 204
 205 /*
 206  - tryhex - try conversion as an eight-digit hex number (AF_INET only)
 207  */
 208 static err_t
 209 tryhex(src, srclen, flavor, dst)
 210 const char *src;
 211 size_t srclen;                  /* should be 8 */
 212 int flavor;                     /* 'x' for network order, 'h' for host order */
 213 ip_address *dst;
 214 {
 215         err_t oops;
 216         unsigned long ul;
 217         union {
 218                 uint32_t addr;
 219                 unsigned char buf[4];
 220         } u;
 221
 222         if (srclen != 8)
 223                 return "internal error, tryhex called with bad length";
 224
 225         oops = ttoul(src, srclen, 16, &ul);
 226         if (oops != NULL)
 227                 return oops;
 228
 229         u.addr = (flavor == 'h') ? ul : htonl(ul);
 230         return initaddr(u.buf, sizeof(u.buf), AF_INET, dst);
 231 }
 232
 233 /*
 234  - trydotted - try conversion as dotted decimal (AF_INET only)
 235  *
 236  * If the first char of a complaint is '?', that means "didn't look like
 237  * dotted decimal at all".
 238  */
 239 static err_t
 240 trydotted(src, srclen, dst)
 241 const char *src;
 242 size_t srclen;
 243 ip_address *dst;
 244 {
 245         const char *stop = src + srclen;        /* just past end */
 246         int byte;
 247         err_t oops;
 248 #       define  NBYTES  4
 249         unsigned char buf[NBYTES];
 250         int i;
 251
 252         memset(buf, 0, sizeof(buf));
 253         for (i = 0; i < NBYTES && src < stop; i++) {
 254                 oops = getbyte(&src, stop, &byte);
 255                 if (oops != NULL) {
 256                         if (*oops != '?')
 257                                 return oops;    /* bad number */
 258                         if (i > 1)
 259                                 return oops+1;  /* failed number */
 260                         return oops;            /* with leading '?' */
 261                 }
 262                 buf[i] = byte;
 263                 if (i < 3 && src < stop && *src++ != '.') {
 264                         if (i == 0)
 265                                 return "?syntax error in dotted-decimal address";
 266                         else
 267                                 return "syntax error in dotted-decimal address";
 268                 }
 269         }
 270         if (src != stop)
 271                 return "extra garbage on end of dotted-decimal address";
 272
 273         return initaddr(buf, sizeof(buf), AF_INET, dst);
 274 }
 275
 276 /*
 277  - getbyte - try to scan a byte in dotted decimal
 278  * A subtlety here is that all this arithmetic on ASCII digits really is
 279  * highly portable -- ANSI C guarantees that digits 0-9 are contiguous.
 280  * It's easier to just do it ourselves than set up for a call to ttoul().
 281  *
 282  * If the first char of a complaint is '?', that means "didn't look like a
 283  * number at all".
 284  */
 285 err_t
 286 getbyte(srcp, stop, retp)
 287 const char **srcp;              /* *srcp is updated */
 288 const char *stop;               /* first untouchable char */
 289 int *retp;                      /* return-value pointer */
 290 {
 291         char c;
 292         const char *p;
 293         int no;
 294
 295         if (*srcp >= stop)
 296                 return "?empty number in dotted-decimal address";
 297
 298         no = 0;
 299         p = *srcp;
 300         while (p < stop && no <= 255 && (c = *p) >= '0' && c <= '9') {
 301                 no = no*10 + (c - '0');
 302                 p++;
 303         }
 304         if (p == *srcp)
 305                 return "?non-numeric component in dotted-decimal address";
 306         *srcp = p;
 307         if (no > 255)
 308                 return "byte overflow in dotted-decimal address";
 309         *retp = no;
 310         return NULL;
 311 }
 312
 313 /*
 314  - colon - convert IPv6 "numeric" address
 315  */
 316 static err_t
 317 colon(src, srclen, dst)
 318 const char *src;
 319 size_t srclen;                  /* known to be >0 */
 320 ip_address *dst;
 321 {
 322         const char *stop = src + srclen;        /* just past end */
 323         unsigned piece;
 324         int gapat;              /* where was empty piece seen */
 325         err_t oops;
 326 #       define  NPIECES 8
 327         unsigned char buf[NPIECES*2];   /* short may have wrong byte order */
 328         int i;
 329         int j;
 330 #       define  IT      "IPv6 numeric address"
 331         int naftergap;
 332
 333         /* leading or trailing :: becomes single empty field */
 334         if (*src == ':') {              /* legal only if leading :: */
 335                 if (srclen == 1 || *(src+1) != ':')
 336                         return "illegal leading `:' in " IT;
 337                 if (srclen == 2) {
 338                         unspecaddr(AF_INET6, dst);
 339                         return NULL;
 340                 }
 341                 src++;          /* past first but not second */
 342                 srclen--;
 343         }
 344         if (*(stop-1) == ':') {         /* legal only if trailing :: */
 345                 if (srclen == 1 || *(stop-2) != ':')
 346                         return "illegal trailing `:' in " IT;
 347                 srclen--;               /* leave one */
 348         }
 349
 350         gapat = -1;
 351         for (i = 0; i < NPIECES && src < stop; i++) {
 352                 oops = getpiece(&src, stop, &piece);
 353                 if (oops != NULL && *oops == ':') {     /* empty field */
 354                         if (gapat >= 0)
 355                                 return "more than one :: in " IT;
 356                         gapat = i;
 357                 } else if (oops != NULL)
 358                         return oops;
 359                 buf[2*i] = piece >> 8;
 360                 buf[2*i + 1] = piece & 0xff;
 361                 if (i < NPIECES-1) {    /* there should be more input */
 362                         if (src == stop && gapat < 0)
 363                                 return IT " ends prematurely";
 364                         if (src != stop && *src++ != ':')
 365                                 return "syntax error in " IT;
 366                 }
 367         }
 368         if (src != stop)
 369                 return "extra garbage on end of " IT;
 370
 371         if (gapat < 0 && i < NPIECES)   /* should have been caught earlier */
 372                 return "incomplete " IT " (internal error)";
 373         if (gapat >= 0 && i == NPIECES)
 374                 return "non-abbreviating empty field in " IT;
 375         if (gapat >= 0) {
 376                 naftergap = i - (gapat + 1);
 377                 for (i--, j = NPIECES-1; naftergap > 0; i--, j--, naftergap--) {
 378                         buf[2*j] = buf[2*i];
 379                         buf[2*j + 1] = buf[2*i + 1];
 380                 }
 381                 for (; j >= gapat; j--)
 382                         buf[2*j] = buf[2*j + 1] = 0;
 383         }
 384
 385         return initaddr(buf, sizeof(buf), AF_INET6, dst);
 386 }
 387
 388 /*
 389  - getpiece - try to scan one 16-bit piece of an IPv6 address
 390  */
 391 err_t                           /* ":" means "empty field seen" */
 392 getpiece(srcp, stop, retp)
 393 const char **srcp;              /* *srcp is updated */
 394 const char *stop;               /* first untouchable char */
 395 unsigned *retp;                 /* return-value pointer */
 396 {
 397         const char *p;
 398 #       define  NDIG    4
 399         int d;
 400         unsigned long ret;
 401         err_t oops;
 402
 403         if (*srcp >= stop || **srcp == ':') {   /* empty field */
 404                 *retp = 0;
 405                 return ":";
 406         }
 407
 408         p = *srcp;
 409         d = 0;
 410         while (p < stop && d < NDIG && isxdigit(*p)) {
 411                 p++;
 412                 d++;
 413         }
 414         if (d == 0)
 415                 return "non-hex field in IPv6 numeric address";
 416         if (p < stop && d == NDIG && isxdigit(*p))
 417                 return "field in IPv6 numeric address longer than 4 hex digits";
 418
 419         oops = ttoul(*srcp, d, 16, &ret);
 420         if (oops != NULL)       /* shouldn't happen, really... */
 421                 return oops;
 422
 423         *srcp = p;
 424         *retp = ret;
 425         return NULL;
 426 }