src/lib/misc.c

   1 /*
   2  * misc.c       Various miscellaneous functions.
   3  *
   4  * Version:     $Id$
   5  *
   6  *   This library is free software; you can redistribute it and/or
   7  *   modify it under the terms of the GNU Lesser General Public
   8  *   License as published by the Free Software Foundation; either
   9  *   version 2.1 of the License, or (at your option) any later version.
  10  *
  11  *   This library is distributed in the hope that it will be useful,
  12  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14  *   Lesser General Public License for more details.
  15  *
  16  *   You should have received a copy of the GNU Lesser General Public
  17  *   License along with this library; if not, write to the Free Software
  18  *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  *
  20  * Copyright 2000,2006  The FreeRADIUS server project
  21  */
  22
  23 RCSID("$Id$")
  24
  25 #include        <freeradius-devel/libradius.h>
  26
  27 #include        <ctype.h>
  28 #include        <sys/file.h>
  29 #include        <fcntl.h>
  30
  31 #define FR_PUT_LE16(a, val)\
  32         do {\
  33                 a[1] = ((uint16_t) (val)) >> 8;\
  34                 a[0] = ((uint16_t) (val)) & 0xff;\
  35         } while (0)
  36
  37 #ifdef HAVE_PTHREAD_H
  38 #  define PTHREAD_MUTEX_LOCK pthread_mutex_lock
  39 #  define PTHREAD_MUTEX_UNLOCK pthread_mutex_unlock
  40 #else
  41 #  define PTHREAD_MUTEX_LOCK(_x)
  42 #  define PTHREAD_MUTEX_UNLOCK(_x)
  43 #endif
  44
  45 bool    fr_dns_lookups = false;     /* IP -> hostname lookups? */
  46 bool    fr_hostname_lookups = true; /* hostname -> IP lookups? */
  47 int     fr_debug_flag = 0;
  48
  49 static char const *months[] = {
  50         "jan", "feb", "mar", "apr", "may", "jun",
  51         "jul", "aug", "sep", "oct", "nov", "dec" };
  52
  53 fr_thread_local_setup(char *, fr_inet_ntop_buffer);     /* macro */
  54
  55 typedef struct fr_talloc_link {
  56         bool armed;
  57         TALLOC_CTX *child;
  58 } fr_talloc_link_t;
  59
  60 /** Sets a signal handler using sigaction if available, else signal
  61  *
  62  * @param sig to set handler for.
  63  * @param func handler to set.
  64  */
  65 int fr_set_signal(int sig, sig_t func)
  66 {
  67 #ifdef HAVE_SIGACTION
  68         struct sigaction act;
  69
  70         memset(&act, 0, sizeof(act));
  71         act.sa_flags = 0;
  72         sigemptyset(&act.sa_mask);
  73         act.sa_handler = func;
  74
  75         if (sigaction(sig, &act, NULL) < 0) {
  76                 fr_strerror_printf("Failed setting signal %i handler via sigaction(): %s", sig, fr_syserror(errno));
  77                 return -1;
  78         }
  79 #else
  80         if (signal(sig, func) < 0) {
  81                 fr_strerror_printf("Failed setting signal %i handler via signal(): %s", sig, fr_syserror(errno));
  82                 return -1;
  83         }
  84 #endif
  85         return 0;
  86 }
  87
  88 static int _fr_trigger_talloc_ctx_free(fr_talloc_link_t *trigger)
  89 {
  90         if (trigger->armed) talloc_free(trigger->child);
  91
  92         return 0;
  93 }
  94
  95 static int _fr_disarm_talloc_ctx_free(bool **armed)
  96 {
  97         **armed = false;
  98         return 0;
  99 }
 100
 101 /** Link a parent and a child context, so the child is freed before the parent
 102  *
 103  * @note This is not thread safe. Do not free parent before threads are joined, do not call from a child thread.
 104  * @note It's OK to free the child before threads are joined, but this will leak memory until the parent is freed.
 105  *
 106  * @param parent who's fate the child should share.
 107  * @param child bound to parent's lifecycle.
 108  * @return 0 on success -1 on failure.
 109  */
 110 int fr_link_talloc_ctx_free(TALLOC_CTX *parent, TALLOC_CTX *child)
 111 {
 112         fr_talloc_link_t *trigger;
 113         bool **disarm;
 114
 115         trigger = talloc(parent, fr_talloc_link_t);
 116         if (!trigger) return -1;
 117
 118         disarm = talloc(child, bool *);
 119         if (!disarm) {
 120                 talloc_free(trigger);
 121                 return -1;
 122         }
 123
 124         trigger->child = child;
 125         trigger->armed = true;
 126         *disarm = &trigger->armed;
 127
 128         talloc_set_destructor(trigger, _fr_trigger_talloc_ctx_free);
 129         talloc_set_destructor(disarm, _fr_disarm_talloc_ctx_free);
 130
 131         return 0;
 132 }
 133
 134 /*
 135  *      Explicitly cleanup the memory allocated to the error inet_ntop
 136  *      buffer.
 137  */
 138 static void _fr_inet_ntop_free(void *arg)
 139 {
 140         free(arg);
 141 }
 142
 143 /** Wrapper around inet_ntop, prints IPv4/IPv6 addresses
 144  *
 145  * inet_ntop requires the caller pass in a buffer for the address.
 146  * This would be annoying and cumbersome, seeing as quite often the ASCII
 147  * address is only used for logging output.
 148  *
 149  * So as with lib/log.c use TLS to allocate thread specific buffers, and
 150  * write the IP address there instead.
 151  *
 152  * @param af address family, either AF_INET or AF_INET6.
 153  * @param src pointer to network address structure.
 154  * @return NULL on error, else pointer to ASCII buffer containing text version of address.
 155  */
 156 char const *fr_inet_ntop(int af, void const *src)
 157 {
 158         char *buffer;
 159
 160         if (!src) {
 161                 return NULL;
 162         }
 163
 164         buffer = fr_thread_local_init(fr_inet_ntop_buffer, _fr_inet_ntop_free);
 165         if (!buffer) {
 166                 int ret;
 167
 168                 /*
 169                  *      malloc is thread safe, talloc is not
 170                  */
 171                 buffer = malloc(sizeof(char) * INET6_ADDRSTRLEN);
 172                 if (!buffer) {
 173                         fr_perror("Failed allocating memory for inet_ntop buffer");
 174                         return NULL;
 175                 }
 176
 177                 ret = fr_thread_local_set(fr_inet_ntop_buffer, buffer);
 178                 if (ret != 0) {
 179                         fr_perror("Failed setting up TLS for inet_ntop buffer: %s", fr_syserror(ret));
 180                         free(buffer);
 181                         return NULL;
 182                 }
 183         }
 184         buffer[0] = '\0';
 185
 186         return inet_ntop(af, src, buffer, INET6_ADDRSTRLEN);
 187 }
 188
 189 /*
 190  *      Return an IP address in standard dot notation
 191  *
 192  *      FIXME: DELETE THIS
 193  */
 194 char const *ip_ntoa(char *buffer, uint32_t ipaddr)
 195 {
 196         ipaddr = ntohl(ipaddr);
 197
 198         sprintf(buffer, "%d.%d.%d.%d",
 199                 (ipaddr >> 24) & 0xff,
 200                 (ipaddr >> 16) & 0xff,
 201                 (ipaddr >>  8) & 0xff,
 202                 (ipaddr      ) & 0xff);
 203         return buffer;
 204 }
 205
 206 /** Parse an IPv4 address or IPv4 prefix in presentation format (and others)
 207  *
 208  * @param out Where to write the ip address value.
 209  * @param value to parse, may be dotted quad [+ prefix], or integer, or octal number, or '*' (INADDR_ANY).
 210  * @param inlen Length of value, if value is \0 terminated inlen may be -1.
 211  * @param resolve If true and value doesn't look like an IP address, try and resolve value as a hostname.
 212  * @param fallback to IPv4 resolution if no A records can be found.
 213  * @return 0 if ip address was parsed successfully, else -1 on error.
 214  */
 215 int fr_pton4(fr_ipaddr_t *out, char const *value, ssize_t inlen, bool resolve, bool fallback)
 216 {
 217         char *p;
 218         unsigned int prefix;
 219         char *eptr;
 220
 221         /* Dotted quad + / + [0-9]{1,2} */
 222         char buffer[INET_ADDRSTRLEN + 3];
 223
 224         /*
 225          *      Copy to intermediary buffer if we were given a length
 226          */
 227         if (inlen >= 0) {
 228                 if (inlen >= (ssize_t)sizeof(buffer)) {
 229                         fr_strerror_printf("Invalid IPv4 address string \"%s\"", value);
 230                         return -1;
 231                 }
 232                 memcpy(buffer, value, inlen);
 233                 buffer[inlen] = '\0';
 234         }
 235
 236         p = strchr(value, '/');
 237         /*
 238          *      192.0.2.2 is parsed as if it was /32
 239          */
 240         if (!p) {
 241                 out->prefix = 32;
 242                 out->af = AF_INET;
 243
 244                 /*
 245                  *      Allow '*' as the wildcard address usually 0.0.0.0
 246                  */
 247                 if ((value[0] == '*') && (value[1] == '\0')) {
 248                         out->ipaddr.ip4addr.s_addr = htonl(INADDR_ANY);
 249                 /*
 250                  *      Convert things which are obviously integers to IP addresses
 251                  *
 252                  *      We assume the number is the bigendian representation of the
 253                  *      IP address.
 254                  */
 255                 } else if (is_integer(value) || ((value[0] == '0') && (value[1] == 'x'))) {
 256                         out->ipaddr.ip4addr.s_addr = htonl(strtoul(value, NULL, 0));
 257                 } else if (!resolve) {
 258                         if (inet_pton(AF_INET, value, &out->ipaddr.ip4addr.s_addr) <= 0) {
 259                                 fr_strerror_printf("Failed to parse IPv4 address string \"%s\"", value);
 260                                 return -1;
 261                         }
 262                 } else if (ip_hton(out, AF_INET, value, fallback) < 0) return -1;
 263
 264                 return 0;
 265         }
 266
 267         /*
 268          *      Otherwise parse the prefix
 269          */
 270         if ((size_t)(p - value) >= INET_ADDRSTRLEN) {
 271                 fr_strerror_printf("Invalid IPv4 address string \"%s\"", value);
 272                 return -1;
 273         }
 274
 275         /*
 276          *      Copy the IP portion into a temporary buffer if we haven't already.
 277          */
 278         if (inlen < 0) memcpy(buffer, value, p - value);
 279         buffer[p - value] = '\0';
 280
 281         if (!resolve) {
 282                 if (inet_pton(AF_INET, buffer, &out->ipaddr.ip4addr.s_addr) <= 0) {
 283                         fr_strerror_printf("Failed to parse IPv4 address string \"%s\"", value);
 284                         return -1;
 285                 }
 286         } else if (ip_hton(out, AF_INET, buffer, fallback) < 0) return -1;
 287
 288         prefix = strtoul(p + 1, &eptr, 10);
 289         if (prefix > 32) {
 290                 fr_strerror_printf("Invalid IPv4 mask length \"%s\".  Should be between 0-32", p);
 291                 return -1;
 292         }
 293         if (eptr[0] != '\0') {
 294                 fr_strerror_printf("Failed to parse IPv4 address string \"%s\", "
 295                                    "got garbage after mask length \"%s\"", value, eptr);
 296                 return -1;
 297         }
 298
 299         if (prefix < 32) {
 300                 out->ipaddr.ip4addr = fr_inaddr_mask(&out->ipaddr.ip4addr, prefix);
 301         }
 302
 303         out->prefix = (uint8_t) prefix;
 304         out->af = AF_INET;
 305
 306         return 0;
 307 }
 308
 309 /** Parse an IPv6 address or IPv6 prefix in presentation format (and others)
 310  *
 311  * @param out Where to write the ip address value.
 312  * @param value to parse.
 313  * @param inlen Length of value, if value is \0 terminated inlen may be -1.
 314  * @param resolve If true and value doesn't look like an IP address, try and resolve value as a hostname.
 315  * @param fallback to IPv4 resolution if no AAAA records can be found.
 316  * @return 0 if ip address was parsed successfully, else -1 on error.
 317  */
 318 int fr_pton6(fr_ipaddr_t *out, char const *value, ssize_t inlen, bool resolve, bool fallback)
 319 {
 320         char const *p;
 321         unsigned int prefix;
 322         char *eptr;
 323
 324         /* IPv6  + / + [0-9]{1,3} */
 325         char buffer[INET6_ADDRSTRLEN + 4];
 326
 327         /*
 328          *      Copy to intermediary buffer if we were given a length
 329          */
 330         if (inlen >= 0) {
 331                 if (inlen >= (ssize_t)sizeof(buffer)) {
 332                         fr_strerror_printf("Invalid IPv6 address string \"%s\"", value);
 333                         return -1;
 334                 }
 335                 memcpy(buffer, value, inlen);
 336                 buffer[inlen] = '\0';
 337         }
 338
 339         p = strchr(value, '/');
 340         if (!p) {
 341                 /*
 342                  *      Allow '*' as the wildcard address
 343                  */
 344                 if ((value[0] == '*') && (value[1] == '\0')) {
 345                         memset(out->ipaddr.ip6addr.s6_addr, 0, sizeof(out->ipaddr.ip6addr.s6_addr));
 346                 } else if (!resolve) {
 347                         if (inet_pton(AF_INET6, value, out->ipaddr.ip6addr.s6_addr) <= 0) {
 348                                 fr_strerror_printf("Failed to parse IPv6 address string \"%s\"", value);
 349                                 return -1;
 350                         }
 351                 } else if (ip_hton(out, AF_INET6, value, fallback) < 0) return -1;
 352
 353                 out->prefix = 128;
 354                 out->af = AF_INET6;
 355
 356                 return 0;
 357         }
 358
 359         if ((p - value) >= INET6_ADDRSTRLEN) {
 360                 fr_strerror_printf("Invalid IPv6 address string \"%s\"", value);
 361                 return -1;
 362         }
 363
 364         /*
 365          *      Copy string to temporary buffer if we didn't do it earlier
 366          */
 367         if (inlen < 0) memcpy(buffer, value, p - value);
 368         buffer[p - value] = '\0';
 369
 370         if (!resolve) {
 371                 if (inet_pton(AF_INET6, buffer, out->ipaddr.ip6addr.s6_addr) <= 0) {
 372                         fr_strerror_printf("Failed to parse IPv6 address string \"%s\"", value);
 373                         return -1;
 374                 }
 375         } else if (ip_hton(out, AF_INET6, buffer, fallback) < 0) return -1;
 376
 377         prefix = strtoul(p + 1, &eptr, 10);
 378         if (prefix > 128) {
 379                 fr_strerror_printf("Invalid IPv6 mask length \"%s\".  Should be between 0-128", p);
 380                 return -1;
 381         }
 382         if (eptr[0] != '\0') {
 383                 fr_strerror_printf("Failed to parse IPv6 address string \"%s\", "
 384                                    "got garbage after mask length \"%s\"", value, eptr);
 385                 return -1;
 386         }
 387
 388         if (prefix < 128) {
 389                 struct in6_addr addr;
 390
 391                 addr = fr_in6addr_mask(&out->ipaddr.ip6addr, prefix);
 392                 memcpy(out->ipaddr.ip6addr.s6_addr, addr.s6_addr, sizeof(out->ipaddr.ip6addr.s6_addr));
 393         }
 394
 395         out->prefix = (uint8_t) prefix;
 396         out->af = AF_INET6;
 397
 398         return 0;
 399 }
 400
 401 /** Simple wrapper to decide whether an IP value is v4 or v6 and call the appropriate parser.
 402  *
 403  * @param out Where to write the ip address value.
 404  * @param value to parse.
 405  * @param inlen Length of value, if value is \0 terminated inlen may be -1.
 406  * @param resolve If true and value doesn't look like an IP address, try and resolve value as a hostname.
 407  * @return 0 if ip address was parsed successfully, else -1 on error.
 408  */
 409 int fr_pton(fr_ipaddr_t *out, char const *value, ssize_t inlen, bool resolve)
 410 {
 411         size_t len, i;
 412
 413         len = (inlen >= 0) ? (size_t)inlen : strlen(value);
 414         for (i = 0; i < len; i++) switch (value[i]) {
 415         /*
 416          *      Chars illegal in domain names and IPv4 addresses.
 417          *      Must be v6 and cannot be a domain.
 418          */
 419         case ':':
 420         case '[':
 421         case ']':
 422                 return fr_pton6(out, value, inlen, false, false);
 423
 424         /*
 425          *      Chars which don't really tell us anything
 426          */
 427         case '.':
 428         case '/':
 429                 continue;
 430
 431         default:
 432                 /*
 433                  *      Outside the range of IPv4 chars, must be a domain
 434                  *      Use A record in preference to AAAA record.
 435                  */
 436                 if ((value[i] < '0') || (value[i] > '9')) {
 437                         if (!resolve) return -1;
 438                         return fr_pton4(out, value, inlen, true, true);
 439                 }
 440                 break;
 441         }
 442
 443         /*
 444          *      All chars were in the IPv4 set [0-9/.], must be an IPv4
 445          *      address.
 446          */
 447         return fr_pton4(out, value, inlen, false, false);
 448 }
 449
 450 int fr_ntop(char *out, size_t outlen, fr_ipaddr_t *addr)
 451 {
 452         char buffer[INET6_ADDRSTRLEN];
 453
 454         if (inet_ntop(addr->af, &(addr->ipaddr), buffer, sizeof(buffer)) == NULL) return -1;
 455
 456         return snprintf(out, outlen, "%s/%i", buffer, addr->prefix);
 457 }
 458
 459 /*
 460  *      Internal wrapper for locking, to minimize the number of ifdef's
 461  *
 462  *      Use fcntl or error
 463  */
 464 int rad_lockfd(int fd, int lock_len)
 465 {
 466 #ifdef F_WRLCK
 467         struct flock fl;
 468
 469         fl.l_start = 0;
 470         fl.l_len = lock_len;
 471         fl.l_pid = getpid();
 472         fl.l_type = F_WRLCK;
 473         fl.l_whence = SEEK_CUR;
 474
 475         return fcntl(fd, F_SETLKW, (void *)&fl);
 476 #else
 477 #error "missing definition for F_WRLCK, all file locks will fail"
 478
 479         return -1;
 480 #endif
 481 }
 482
 483 /*
 484  *      Internal wrapper for locking, to minimize the number of ifdef's
 485  *
 486  *      Lock an fd, prefer lockf() over flock()
 487  *      Nonblocking version.
 488  */
 489 int rad_lockfd_nonblock(int fd, int lock_len)
 490 {
 491 #ifdef F_WRLCK
 492         struct flock fl;
 493
 494         fl.l_start = 0;
 495         fl.l_len = lock_len;
 496         fl.l_pid = getpid();
 497         fl.l_type = F_WRLCK;
 498         fl.l_whence = SEEK_CUR;
 499
 500         return fcntl(fd, F_SETLK, (void *)&fl);
 501 #else
 502 #error "missing definition for F_WRLCK, all file locks will fail"
 503
 504         return -1;
 505 #endif
 506 }
 507
 508 /*
 509  *      Internal wrapper for unlocking, to minimize the number of ifdef's
 510  *      in the source.
 511  *
 512  *      Unlock an fd, prefer lockf() over flock()
 513  */
 514 int rad_unlockfd(int fd, int lock_len)
 515 {
 516 #ifdef F_WRLCK
 517         struct flock fl;
 518
 519         fl.l_start = 0;
 520         fl.l_len = lock_len;
 521         fl.l_pid = getpid();
 522         fl.l_type = F_WRLCK;
 523         fl.l_whence = SEEK_CUR;
 524
 525         return fcntl(fd, F_UNLCK, (void *)&fl);
 526 #else
 527 #error "missing definition for F_WRLCK, all file locks will fail"
 528
 529         return -1;
 530 #endif
 531 }
 532
 533 /*
 534  *      Return an interface-id in standard colon notation
 535  */
 536 char *ifid_ntoa(char *buffer, size_t size, uint8_t const *ifid)
 537 {
 538         snprintf(buffer, size, "%x:%x:%x:%x",
 539                  (ifid[0] << 8) + ifid[1], (ifid[2] << 8) + ifid[3],
 540                  (ifid[4] << 8) + ifid[5], (ifid[6] << 8) + ifid[7]);
 541         return buffer;
 542 }
 543
 544
 545 /*
 546  *      Return an interface-id from
 547  *      one supplied in standard colon notation.
 548  */
 549 uint8_t *ifid_aton(char const *ifid_str, uint8_t *ifid)
 550 {
 551         static char const xdigits[] = "0123456789abcdef";
 552         char const *p, *pch;
 553         int num_id = 0, val = 0, idx = 0;
 554
 555         for (p = ifid_str; ; ++p) {
 556                 if (*p == ':' || *p == '\0') {
 557                         if (num_id <= 0)
 558                                 return NULL;
 559
 560                         /*
 561                          *      Drop 'val' into the array.
 562                          */
 563                         ifid[idx] = (val >> 8) & 0xff;
 564                         ifid[idx + 1] = val & 0xff;
 565                         if (*p == '\0') {
 566                                 /*
 567                                  *      Must have all entries before
 568                                  *      end of the string.
 569                                  */
 570                                 if (idx != 6)
 571                                         return NULL;
 572                                 break;
 573                         }
 574                         val = 0;
 575                         num_id = 0;
 576                         if ((idx += 2) > 6)
 577                                 return NULL;
 578                 } else if ((pch = strchr(xdigits, tolower(*p))) != NULL) {
 579                         if (++num_id > 4)
 580                                 return NULL;
 581                         /*
 582                          *      Dumb version of 'scanf'
 583                          */
 584                         val <<= 4;
 585                         val |= (pch - xdigits);
 586                 } else
 587                         return NULL;
 588         }
 589         return ifid;
 590 }
 591
 592
 593 #ifndef HAVE_INET_PTON
 594 static int inet_pton4(char const *src, struct in_addr *dst)
 595 {
 596         int octet;
 597         unsigned int num;
 598         char const *p, *off;
 599         uint8_t tmp[4];
 600         static char const digits[] = "0123456789";
 601
 602         octet = 0;
 603         p = src;
 604         while (1) {
 605                 num = 0;
 606                 while (*p && ((off = strchr(digits, *p)) != NULL)) {
 607                         num *= 10;
 608                         num += (off - digits);
 609
 610                         if (num > 255) return 0;
 611
 612                         p++;
 613                 }
 614                 if (!*p) break;
 615
 616                 /*
 617                  *      Not a digit, MUST be a dot, else we
 618                  *      die.
 619                  */
 620                 if (*p != '.') {
 621                         return 0;
 622                 }
 623
 624                 tmp[octet++] = num;
 625                 p++;
 626         }
 627
 628         /*
 629          *      End of the string.  At the fourth
 630          *      octet is OK, anything else is an
 631          *      error.
 632          */
 633         if (octet != 3) {
 634                 return 0;
 635         }
 636         tmp[3] = num;
 637
 638         memcpy(dst, &tmp, sizeof(tmp));
 639         return 1;
 640 }
 641
 642
 643 #ifdef HAVE_STRUCT_SOCKADDR_IN6
 644 /* int
 645  * inet_pton6(src, dst)
 646  *      convert presentation level address to network order binary form.
 647  * return:
 648  *      1 if `src' is a valid [RFC1884 2.2] address, else 0.
 649  * notice:
 650  *      (1) does not touch `dst' unless it's returning 1.
 651  *      (2) :: in a full address is silently ignored.
 652  * credit:
 653  *      inspired by Mark Andrews.
 654  * author:
 655  *      Paul Vixie, 1996.
 656  */
 657 static int inet_pton6(char const *src, unsigned char *dst)
 658 {
 659         static char const xdigits_l[] = "0123456789abcdef",
 660                           xdigits_u[] = "0123456789ABCDEF";
 661         u_char tmp[IN6ADDRSZ], *tp, *endp, *colonp;
 662         char const *xdigits, *curtok;
 663         int ch, saw_xdigit;
 664         u_int val;
 665
 666         memset((tp = tmp), 0, IN6ADDRSZ);
 667         endp = tp + IN6ADDRSZ;
 668         colonp = NULL;
 669         /* Leading :: requires some special handling. */
 670         if (*src == ':')
 671                 if (*++src != ':')
 672                         return (0);
 673         curtok = src;
 674         saw_xdigit = 0;
 675         val = 0;
 676         while ((ch = *src++) != '\0') {
 677                 char const *pch;
 678
 679                 if ((pch = strchr((xdigits = xdigits_l), ch)) == NULL)
 680                         pch = strchr((xdigits = xdigits_u), ch);
 681                 if (pch != NULL) {
 682                         val <<= 4;
 683                         val |= (pch - xdigits);
 684                         if (val > 0xffff)
 685                                 return (0);
 686                         saw_xdigit = 1;
 687                         continue;
 688                 }
 689                 if (ch == ':') {
 690                         curtok = src;
 691                         if (!saw_xdigit) {
 692                                 if (colonp)
 693                                         return (0);
 694                                 colonp = tp;
 695                                 continue;
 696                         }
 697                         if (tp + INT16SZ > endp)
 698                                 return (0);
 699                         *tp++ = (u_char) (val >> 8) & 0xff;
 700                         *tp++ = (u_char) val & 0xff;
 701                         saw_xdigit = 0;
 702                         val = 0;
 703                         continue;
 704                 }
 705                 if (ch == '.' && ((tp + INADDRSZ) <= endp) &&
 706                     inet_pton4(curtok, (struct in_addr *) tp) > 0) {
 707                         tp += INADDRSZ;
 708                         saw_xdigit = 0;
 709                         break;  /* '\0' was seen by inet_pton4(). */
 710                 }
 711                 return (0);
 712         }
 713         if (saw_xdigit) {
 714                 if (tp + INT16SZ > endp)
 715                         return (0);
 716                 *tp++ = (u_char) (val >> 8) & 0xff;
 717                 *tp++ = (u_char) val & 0xff;
 718         }
 719         if (colonp != NULL) {
 720                 /*
 721                  * Since some memmove()'s erroneously fail to handle
 722                  * overlapping regions, we'll do the shift by hand.
 723                  */
 724                 int const n = tp - colonp;
 725                 int i;
 726
 727                 for (i = 1; i <= n; i++) {
 728                         endp[- i] = colonp[n - i];
 729                         colonp[n - i] = 0;
 730                 }
 731                 tp = endp;
 732         }
 733         if (tp != endp)
 734                 return (0);
 735         /* bcopy(tmp, dst, IN6ADDRSZ); */
 736         memcpy(dst, tmp, IN6ADDRSZ);
 737         return (1);
 738 }
 739 #endif
 740
 741 /*
 742  *      Utility function, so that the rest of the server doesn't
 743  *      have ifdef's around IPv6 support
 744  */
 745 int inet_pton(int af, char const *src, void *dst)
 746 {
 747         if (af == AF_INET) {
 748                 return inet_pton4(src, dst);
 749         }
 750 #ifdef HAVE_STRUCT_SOCKADDR_IN6
 751
 752         if (af == AF_INET6) {
 753                 return inet_pton6(src, dst);
 754         }
 755 #endif
 756
 757         return -1;
 758 }
 759 #endif
 760
 761 #ifndef HAVE_INET_NTOP
 762 /*
 763  *      Utility function, so that the rest of the server doesn't
 764  *      have ifdef's around IPv6 support
 765  */
 766 char const *inet_ntop(int af, void const *src, char *dst, size_t cnt)
 767 {
 768         if (af == AF_INET) {
 769                 uint8_t const *ipaddr = src;
 770
 771                 if (cnt <= INET_ADDRSTRLEN) return NULL;
 772
 773                 snprintf(dst, cnt, "%d.%d.%d.%d",
 774                          ipaddr[0], ipaddr[1],
 775                          ipaddr[2], ipaddr[3]);
 776                 return dst;
 777         }
 778
 779         /*
 780          *      If the system doesn't define this, we define it
 781          *      in missing.h
 782          */
 783         if (af == AF_INET6) {
 784                 struct in6_addr const *ipaddr = src;
 785
 786                 if (cnt <= INET6_ADDRSTRLEN) return NULL;
 787
 788                 snprintf(dst, cnt, "%x:%x:%x:%x:%x:%x:%x:%x",
 789                          (ipaddr->s6_addr[0] << 8) | ipaddr->s6_addr[1],
 790                          (ipaddr->s6_addr[2] << 8) | ipaddr->s6_addr[3],
 791                          (ipaddr->s6_addr[4] << 8) | ipaddr->s6_addr[5],
 792                          (ipaddr->s6_addr[6] << 8) | ipaddr->s6_addr[7],
 793                          (ipaddr->s6_addr[8] << 8) | ipaddr->s6_addr[9],
 794                          (ipaddr->s6_addr[10] << 8) | ipaddr->s6_addr[11],
 795                          (ipaddr->s6_addr[12] << 8) | ipaddr->s6_addr[13],
 796                          (ipaddr->s6_addr[14] << 8) | ipaddr->s6_addr[15]);
 797                 return dst;
 798         }
 799
 800         return NULL;            /* don't support IPv6 */
 801 }
 802 #endif
 803
 804 /** Wrappers for IPv4/IPv6 host to IP address lookup
 805  *
 806  * This function returns only one IP address, of the specified address family,
 807  * or the first address (of whatever family), if AF_UNSPEC is used.
 808  *
 809  * If fallback is specified and af is AF_INET, but no AF_INET records were
 810  * found and a record for AF_INET6 exists that record will be returned.
 811  *
 812  * If fallback is specified and af is AF_INET6, and a record with AF_INET4 exists
 813  * that record will be returned instead.
 814  *
 815  * @param out Where to write result.
 816  * @param af To search for in preference.
 817  * @param hostname to search for.
 818  * @param fallback to the other adress family, if no records matching af, found.
 819  * @return 0 on success, else -1 on failure.
 820  */
 821 int ip_hton(fr_ipaddr_t *out, int af, char const *hostname, bool fallback)
 822 {
 823         int rcode;
 824         struct addrinfo hints, *ai = NULL, *alt = NULL, *res = NULL;
 825
 826         /*
 827          *      Avoid malloc for IP addresses.  This helps us debug
 828          *      memory errors when using talloc.
 829          */
 830 #ifdef TALLOC_DEBUG
 831         if (true) {
 832 #else
 833         if (!fr_hostname_lookups) {
 834 #endif
 835 #ifdef HAVE_STRUCT_SOCKADDR_IN6
 836                 if (af == AF_UNSPEC) {
 837                         char const *p;
 838
 839                         for (p = hostname; *p != '\0'; p++) {
 840                                 if ((*p == ':') ||
 841                                     (*p == '[') ||
 842                                     (*p == ']')) {
 843                                         af = AF_INET6;
 844                                         break;
 845                                 }
 846                         }
 847                 }
 848 #endif
 849
 850                 if (af == AF_UNSPEC) af = AF_INET;
 851
 852                 if (!inet_pton(af, hostname, &(out->ipaddr))) return -1;
 853
 854                 out->af = af;
 855                 return 0;
 856         }
 857
 858         memset(&hints, 0, sizeof(hints));
 859
 860         /*
 861          *      If we're falling back we need both IPv4 and IPv6 records
 862          */
 863         if (fallback) {
 864                 hints.ai_family = AF_UNSPEC;
 865         } else {
 866                 hints.ai_family = af;
 867         }
 868
 869         if ((rcode = getaddrinfo(hostname, NULL, &hints, &res)) != 0) {
 870                 switch (af) {
 871                 default:
 872                 case AF_UNSPEC:
 873                         fr_strerror_printf("Failed resolving \"%s\" to IP address: %s",
 874                                            hostname, gai_strerror(rcode));
 875                         return -1;
 876
 877                 case AF_INET:
 878                         fr_strerror_printf("Failed resolving \"%s\" to IPv4 address: %s",
 879                                            hostname, gai_strerror(rcode));
 880                         return -1;
 881
 882                 case AF_INET6:
 883                         fr_strerror_printf("Failed resolving \"%s\" to IPv6 address: %s",
 884                                            hostname, gai_strerror(rcode));
 885                         return -1;
 886                 }
 887         }
 888
 889         for (ai = res; ai; ai = ai->ai_next) {
 890                 if ((af == ai->ai_family) || (af == AF_UNSPEC)) break;
 891                 if (!alt && fallback && ((ai->ai_family == AF_INET) || (ai->ai_family == AF_INET6))) alt = ai;
 892         }
 893
 894         if (!ai) ai = alt;
 895         if (!ai) {
 896                 fr_strerror_printf("ip_hton failed to find requested information for host %.100s", hostname);
 897                 freeaddrinfo(res);
 898                 return -1;
 899         }
 900
 901         rcode = fr_sockaddr2ipaddr((struct sockaddr_storage *)ai->ai_addr,
 902                                    ai->ai_addrlen, out, NULL);
 903         freeaddrinfo(res);
 904         if (!rcode) return -1;
 905
 906         return 0;
 907 }
 908
 909 /*
 910  *      Look IP addresses up, and print names (depending on DNS config)
 911  */
 912 char const *ip_ntoh(fr_ipaddr_t const *src, char *dst, size_t cnt)
 913 {
 914         struct sockaddr_storage ss;
 915         int error;
 916         socklen_t salen;
 917
 918         /*
 919          *      No DNS lookups
 920          */
 921         if (!fr_dns_lookups) {
 922                 return inet_ntop(src->af, &(src->ipaddr), dst, cnt);
 923         }
 924
 925         if (!fr_ipaddr2sockaddr(src, 0, &ss, &salen)) {
 926                 return NULL;
 927         }
 928
 929         if ((error = getnameinfo((struct sockaddr *)&ss, salen, dst, cnt, NULL, 0,
 930                                  NI_NUMERICHOST | NI_NUMERICSERV)) != 0) {
 931                 fr_strerror_printf("ip_ntoh: %s", gai_strerror(error));
 932                 return NULL;
 933         }
 934         return dst;
 935 }
 936
 937 /** Mask off a portion of an IPv4 address
 938  *
 939  * @param ipaddr to mask.
 940  * @param prefix Number of contiguous bits to mask.
 941  * @return an ipv4 address with the host portion zeroed out.
 942  */
 943 struct in_addr fr_inaddr_mask(struct in_addr const *ipaddr, uint8_t prefix)
 944 {
 945         uint32_t ret;
 946
 947         if (prefix > 32) prefix = 32;
 948
 949         /* Short circuit */
 950         if (prefix == 32) return *ipaddr;
 951
 952         if (prefix == 0) ret = 0;
 953         else ret = htonl(~((0x00000001UL << (32 - prefix)) - 1)) & ipaddr->s_addr;
 954
 955         return (*(struct in_addr *)&ret);
 956 }
 957
 958 /** Mask off a portion of an IPv6 address
 959  *
 960  * @param ipaddr to mask.
 961  * @param prefix Number of contiguous bits to mask.
 962  * @return an ipv6 address with the host portion zeroed out.
 963  */
 964 struct in6_addr fr_in6addr_mask(struct in6_addr const *ipaddr, uint8_t prefix)
 965 {
 966         uint64_t const *p = (uint64_t const *) ipaddr;
 967         uint64_t ret[2], *o = ret;
 968
 969         if (prefix > 128) prefix = 128;
 970
 971         /* Short circuit */
 972         if (prefix == 128) return *ipaddr;
 973
 974         if (prefix >= 64) {
 975                 prefix -= 64;
 976                 *o++ = 0xffffffffffffffffULL & *p++;    /* lhs portion masked */
 977         } else {
 978                 ret[1] = 0;                             /* rhs portion zeroed */
 979         }
 980
 981         /* Max left shift is 63 else we get overflow */
 982         if (prefix > 0) {
 983                 *o = htonll(~((uint64_t)(0x0000000000000001ULL << (64 - prefix)) - 1)) & *p;
 984         } else {
 985                 *o = 0;
 986         }
 987
 988         return *(struct in6_addr *) &ret;
 989 }
 990
 991 /** Zeroes out the host portion of an fr_ipaddr_t
 992  *
 993  * @param[in,out] addr to mask
 994  * @param[in] prefix Length of the network portion.
 995  */
 996 void fr_ipaddr_mask(fr_ipaddr_t *addr, uint8_t prefix)
 997 {
 998
 999         switch (addr->af) {
1000         case AF_INET:
1001                 addr->ipaddr.ip4addr = fr_inaddr_mask(&addr->ipaddr.ip4addr, prefix);
1002                 break;
1003
1004         case AF_INET6:
1005                 addr->ipaddr.ip6addr = fr_in6addr_mask(&addr->ipaddr.ip6addr, prefix);
1006                 break;
1007
1008         default:
1009                 return;
1010         }
1011         addr->prefix = prefix;
1012 }
1013
1014 static char const hextab[] = "0123456789abcdef";
1015
1016 /** Convert hex strings to binary data
1017  *
1018  * @param bin Buffer to write output to.
1019  * @param outlen length of output buffer (or length of input string / 2).
1020  * @param hex input string.
1021  * @param inlen length of the input string
1022  * @return length of data written to buffer.
1023  */
1024 size_t fr_hex2bin(uint8_t *bin, size_t outlen, char const *hex, size_t inlen)
1025 {
1026         size_t i;
1027         size_t len;
1028         char *c1, *c2;
1029
1030         /*
1031          *      Smartly truncate output, caller should check number of bytes
1032          *      written.
1033          */
1034         len = inlen >> 1;
1035         if (len > outlen) len = outlen;
1036
1037         for (i = 0; i < len; i++) {
1038                 if(!(c1 = memchr(hextab, tolower((int) hex[i << 1]), sizeof(hextab))) ||
1039                    !(c2 = memchr(hextab, tolower((int) hex[(i << 1) + 1]), sizeof(hextab))))
1040                         break;
1041                 bin[i] = ((c1-hextab)<<4) + (c2-hextab);
1042         }
1043
1044         return i;
1045 }
1046
1047 /** Convert binary data to a hex string
1048  *
1049  * Ascii encoded hex string will not be prefixed with '0x'
1050  *
1051  * @warning If the output buffer isn't long enough, we have a buffer overflow.
1052  *
1053  * @param[out] hex Buffer to write hex output.
1054  * @param[in] bin input.
1055  * @param[in] inlen of bin input.
1056  * @return length of data written to buffer.
1057  */
1058 size_t fr_bin2hex(char *hex, uint8_t const *bin, size_t inlen)
1059 {
1060         size_t i;
1061
1062         for (i = 0; i < inlen; i++) {
1063                 hex[0] = hextab[((*bin) >> 4) & 0x0f];
1064                 hex[1] = hextab[*bin & 0x0f];
1065                 hex += 2;
1066                 bin++;
1067         }
1068
1069         *hex = '\0';
1070         return inlen * 2;
1071 }
1072
1073 /** Convert binary data to a hex string
1074  *
1075  * Ascii encoded hex string will not be prefixed with '0x'
1076  *
1077  * @param[in] ctx to alloc buffer in.
1078  * @param[in] bin input.
1079  * @param[in] inlen of bin input.
1080  * @return length of data written to buffer.
1081  */
1082 char *fr_abin2hex(TALLOC_CTX *ctx, uint8_t const *bin, size_t inlen)
1083 {
1084         char *buff;
1085
1086         buff = talloc_array(ctx, char, (inlen << 2));
1087         if (!buff) return NULL;
1088
1089         fr_bin2hex(buff, bin, inlen);
1090
1091         return buff;
1092 }
1093
1094 /** Consume the integer (or hex) portion of a value string
1095  *
1096  * @param value string to parse.
1097  * @param end pointer to the first non numeric char.
1098  * @return integer value.
1099  */
1100 uint32_t fr_strtoul(char const *value, char **end)
1101 {
1102         if ((value[0] == '0') && (value[1] == 'x')) {
1103                 return strtoul(value, end, 16);
1104         }
1105
1106         return strtoul(value, end, 10);
1107 }
1108
1109 /** Check whether the string is all whitespace
1110  *
1111  * @return true if the entirety of the string is whitespace, else false.
1112  */
1113 bool is_whitespace(char const *value)
1114 {
1115         do {
1116                 if (!isspace(*value)) return false;
1117         } while (*++value);
1118
1119         return true;
1120 }
1121
1122 /** Check whether the string is all numbers
1123  *
1124  * @return true if the entirety of the string is are numebrs, else false.
1125  */
1126 bool is_integer(char const *value)
1127 {
1128         do {
1129                 if (!isdigit(*value)) return false;
1130         } while (*++value);
1131
1132         return true;
1133 }
1134
1135 /** Check whether the string is allzeros
1136  *
1137  * @return true if the entirety of the string is are numebrs, else false.
1138  */
1139 bool is_zero(char const *value)
1140 {
1141         do {
1142                 if (*value != '0') return false;
1143         } while (*++value);
1144
1145         return true;
1146 }
1147
1148 /*
1149  *      So we don't have ifdef's in the rest of the code
1150  */
1151 #ifndef HAVE_CLOSEFROM
1152 int closefrom(int fd)
1153 {
1154         int i;
1155         int maxfd = 256;
1156
1157 #ifdef _SC_OPEN_MAX
1158         maxfd = sysconf(_SC_OPEN_MAX);
1159         if (maxfd < 0) {
1160           maxfd = 256;
1161         }
1162 #endif
1163
1164         if (fd > maxfd) return 0;
1165
1166         /*
1167          *      FIXME: return EINTR?
1168          *
1169          *      Use F_CLOSEM?
1170          */
1171         for (i = fd; i < maxfd; i++) {
1172                 close(i);
1173         }
1174
1175         return 0;
1176 }
1177 #endif
1178
1179 int fr_ipaddr_cmp(fr_ipaddr_t const *a, fr_ipaddr_t const *b)
1180 {
1181         if (a->af < b->af) return -1;
1182         if (a->af > b->af) return +1;
1183
1184         if (a->prefix < b->prefix) return -1;
1185         if (a->prefix > b->prefix) return +1;
1186
1187         switch (a->af) {
1188         case AF_INET:
1189                 return memcmp(&a->ipaddr.ip4addr,
1190                               &b->ipaddr.ip4addr,
1191                               sizeof(a->ipaddr.ip4addr));
1192                 break;
1193
1194 #ifdef HAVE_STRUCT_SOCKADDR_IN6
1195         case AF_INET6:
1196                 if (a->scope < b->scope) return -1;
1197                 if (a->scope > b->scope) return +1;
1198
1199                 return memcmp(&a->ipaddr.ip6addr,
1200                               &b->ipaddr.ip6addr,
1201                               sizeof(a->ipaddr.ip6addr));
1202                 break;
1203 #endif
1204
1205         default:
1206                 break;
1207         }
1208
1209         return -1;
1210 }
1211
1212 int fr_ipaddr2sockaddr(fr_ipaddr_t const *ipaddr, uint16_t port,
1213                        struct sockaddr_storage *sa, socklen_t *salen)
1214 {
1215         memset(sa, 0, sizeof(*sa));
1216
1217         if (ipaddr->af == AF_INET) {
1218                 struct sockaddr_in s4;
1219
1220                 *salen = sizeof(s4);
1221
1222                 memset(&s4, 0, sizeof(s4));
1223                 s4.sin_family = AF_INET;
1224                 s4.sin_addr = ipaddr->ipaddr.ip4addr;
1225                 s4.sin_port = htons(port);
1226                 memset(sa, 0, sizeof(*sa));
1227                 memcpy(sa, &s4, sizeof(s4));
1228
1229 #ifdef HAVE_STRUCT_SOCKADDR_IN6
1230         } else if (ipaddr->af == AF_INET6) {
1231                 struct sockaddr_in6 s6;
1232
1233                 *salen = sizeof(s6);
1234
1235                 memset(&s6, 0, sizeof(s6));
1236                 s6.sin6_family = AF_INET6;
1237                 s6.sin6_addr = ipaddr->ipaddr.ip6addr;
1238                 s6.sin6_port = htons(port);
1239                 s6.sin6_scope_id = ipaddr->scope;
1240                 memset(sa, 0, sizeof(*sa));
1241                 memcpy(sa, &s6, sizeof(s6));
1242 #endif
1243         } else {
1244                 return 0;
1245         }
1246
1247         return 1;
1248 }
1249
1250
1251 int fr_sockaddr2ipaddr(struct sockaddr_storage const *sa, socklen_t salen,
1252                        fr_ipaddr_t *ipaddr, uint16_t *port)
1253 {
1254         memset(ipaddr, 0, sizeof(*ipaddr));
1255
1256         if (sa->ss_family == AF_INET) {
1257                 struct sockaddr_in      s4;
1258
1259                 if (salen < sizeof(s4)) {
1260                         fr_strerror_printf("IPv4 address is too small");
1261                         return 0;
1262                 }
1263
1264                 memcpy(&s4, sa, sizeof(s4));
1265                 ipaddr->af = AF_INET;
1266                 ipaddr->prefix = 32;
1267                 ipaddr->ipaddr.ip4addr = s4.sin_addr;
1268                 if (port) *port = ntohs(s4.sin_port);
1269
1270 #ifdef HAVE_STRUCT_SOCKADDR_IN6
1271         } else if (sa->ss_family == AF_INET6) {
1272                 struct sockaddr_in6     s6;
1273
1274                 if (salen < sizeof(s6)) {
1275                         fr_strerror_printf("IPv6 address is too small");
1276                         return 0;
1277                 }
1278
1279                 memcpy(&s6, sa, sizeof(s6));
1280                 ipaddr->af = AF_INET6;
1281                 ipaddr->prefix = 128;
1282                 ipaddr->ipaddr.ip6addr = s6.sin6_addr;
1283                 if (port) *port = ntohs(s6.sin6_port);
1284                 ipaddr->scope = s6.sin6_scope_id;
1285 #endif
1286
1287         } else {
1288                 fr_strerror_printf("Unsupported address famility %d",
1289                                    sa->ss_family);
1290                 return 0;
1291         }
1292
1293         return 1;
1294 }
1295
1296 /** Convert UTF8 string to UCS2 encoding
1297  *
1298  * @note Borrowed from src/crypto/ms_funcs.c of wpa_supplicant project (http://hostap.epitest.fi/wpa_supplicant/)
1299  *
1300  * @param[out] out Where to write the ucs2 string.
1301  * @param[in] outlen Size of output buffer.
1302  * @param[in] in UTF8 string to convert.
1303  * @param[in] inlen length of UTF8 string.
1304  * @return the size of the UCS2 string written to the output buffer (in bytes).
1305  */
1306 ssize_t fr_utf8_to_ucs2(uint8_t *out, size_t outlen, char const *in, size_t inlen)
1307 {
1308         size_t i;
1309         uint8_t *start = out;
1310
1311         for (i = 0; i < inlen; i++) {
1312                 uint8_t c, c2, c3;
1313
1314                 c = in[i];
1315                 if ((size_t)(out - start) >= outlen) {
1316                         /* input too long */
1317                         return -1;
1318                 }
1319
1320                 /* One-byte encoding */
1321                 if (c <= 0x7f) {
1322                         FR_PUT_LE16(out, c);
1323                         out += 2;
1324                         continue;
1325                 } else if ((i == (inlen - 1)) || ((size_t)(out - start) >= (outlen - 1))) {
1326                         /* Incomplete surrogate */
1327                         return -1;
1328                 }
1329
1330                 c2 = in[++i];
1331                 /* Two-byte encoding */
1332                 if ((c & 0xe0) == 0xc0) {
1333                         FR_PUT_LE16(out, ((c & 0x1f) << 6) | (c2 & 0x3f));
1334                         out += 2;
1335                         continue;
1336                 }
1337                 if ((i == inlen) || ((size_t)(out - start) >= (outlen - 1))) {
1338                         /* Incomplete surrogate */
1339                         return -1;
1340                 }
1341
1342                 /* Three-byte encoding */
1343                 c3 = in[++i];
1344                 FR_PUT_LE16(out, ((c & 0xf) << 12) | ((c2 & 0x3f) << 6) | (c3 & 0x3f));
1345                 out += 2;
1346         }
1347
1348         return out - start;
1349 }
1350
1351 /** Write 128bit unsigned integer to buffer
1352  *
1353  * @author Alexey Frunze
1354  *
1355  * @param out where to write result to.
1356  * @param outlen size of out.
1357  * @param num 128 bit integer.
1358  */
1359 size_t fr_prints_uint128(char *out, size_t outlen, uint128_t const num)
1360 {
1361         char buff[128 / 3 + 1 + 1];
1362         uint64_t n[2];
1363         char *p = buff;
1364         int i;
1365 #ifdef RADIUS_LITTLE_ENDIAN
1366         const size_t l = 0;
1367         const size_t h = 1;
1368 #else
1369         const size_t l = 1;
1370         const size_t h = 0;
1371 #endif
1372
1373         memset(buff, '0', sizeof(buff) - 1);
1374         buff[sizeof(buff) - 1] = '\0';
1375
1376         memcpy(n, &num, sizeof(n));
1377
1378         for (i = 0; i < 128; i++) {
1379                 ssize_t j;
1380                 int carry;
1381
1382                 carry = (n[h] >= 0x8000000000000000);
1383
1384                 // Shift n[] left, doubling it
1385                 n[h] = ((n[h] << 1) & 0xffffffffffffffff) + (n[l] >= 0x8000000000000000);
1386                 n[l] = ((n[l] << 1) & 0xffffffffffffffff);
1387
1388                 // Add s[] to itself in decimal, doubling it
1389                 for (j = sizeof(buff) - 2; j >= 0; j--) {
1390                         buff[j] += buff[j] - '0' + carry;
1391                         carry = (buff[j] > '9');
1392                         if (carry) {
1393                                 buff[j] -= 10;
1394                         }
1395                 }
1396         }
1397
1398         while ((*p == '0') && (p < &buff[sizeof(buff) - 2])) {
1399                 p++;
1400         }
1401
1402         return strlcpy(out, p, outlen);
1403 }
1404
1405 /*
1406  *      Sort of strtok/strsep function.
1407  */
1408 static char *mystrtok(char **ptr, char const *sep)
1409 {
1410         char    *res;
1411
1412         if (**ptr == 0) {
1413                 return NULL;
1414         }
1415
1416         while (**ptr && strchr(sep, **ptr)) {
1417                 (*ptr)++;
1418         }
1419         if (**ptr == 0) {
1420                 return NULL;
1421         }
1422
1423         res = *ptr;
1424         while (**ptr && strchr(sep, **ptr) == NULL) {
1425                 (*ptr)++;
1426         }
1427
1428         if (**ptr != 0) {
1429                 *(*ptr)++ = 0;
1430         }
1431         return res;
1432 }
1433
1434 /** Convert string in various formats to a time_t
1435  *
1436  * @param date_str input date string.
1437  * @param date time_t to write result to.
1438  * @return 0 on success or -1 on error.
1439  */
1440 int fr_get_time(char const *date_str, time_t *date)
1441 {
1442         int             i;
1443         time_t          t;
1444         struct tm       *tm, s_tm;
1445         char            buf[64];
1446         char            *p;
1447         char            *f[4];
1448         char            *tail = NULL;
1449
1450         /*
1451          * Test for unix timestamp date
1452          */
1453         *date = strtoul(date_str, &tail, 10);
1454         if (*tail == '\0') {
1455                 return 0;
1456         }
1457
1458         tm = &s_tm;
1459         memset(tm, 0, sizeof(*tm));
1460         tm->tm_isdst = -1;      /* don't know, and don't care about DST */
1461
1462         strlcpy(buf, date_str, sizeof(buf));
1463
1464         p = buf;
1465         f[0] = mystrtok(&p, " \t");
1466         f[1] = mystrtok(&p, " \t");
1467         f[2] = mystrtok(&p, " \t");
1468         f[3] = mystrtok(&p, " \t"); /* may, or may not, be present */
1469         if (!f[0] || !f[1] || !f[2]) return -1;
1470
1471         /*
1472          *      The time has a colon, where nothing else does.
1473          *      So if we find it, bubble it to the back of the list.
1474          */
1475         if (f[3]) {
1476                 for (i = 0; i < 3; i++) {
1477                         if (strchr(f[i], ':')) {
1478                                 p = f[3];
1479                                 f[3] = f[i];
1480                                 f[i] = p;
1481                                 break;
1482                         }
1483                 }
1484         }
1485
1486         /*
1487          *  The month is text, which allows us to find it easily.
1488          */
1489         tm->tm_mon = 12;
1490         for (i = 0; i < 3; i++) {
1491                 if (isalpha( (int) *f[i])) {
1492                         /*
1493                          *  Bubble the month to the front of the list
1494                          */
1495                         p = f[0];
1496                         f[0] = f[i];
1497                         f[i] = p;
1498
1499                         for (i = 0; i < 12; i++) {
1500                                 if (strncasecmp(months[i], f[0], 3) == 0) {
1501                                         tm->tm_mon = i;
1502                                         break;
1503                                 }
1504                         }
1505                 }
1506         }
1507
1508         /* month not found? */
1509         if (tm->tm_mon == 12) return -1;
1510
1511         /*
1512          *  The year may be in f[1], or in f[2]
1513          */
1514         tm->tm_year = atoi(f[1]);
1515         tm->tm_mday = atoi(f[2]);
1516
1517         if (tm->tm_year >= 1900) {
1518                 tm->tm_year -= 1900;
1519
1520         } else {
1521                 /*
1522                  *  We can't use 2-digit years any more, they make it
1523                  *  impossible to tell what's the day, and what's the year.
1524                  */
1525                 if (tm->tm_mday < 1900) return -1;
1526
1527                 /*
1528                  *  Swap the year and the day.
1529                  */
1530                 i = tm->tm_year;
1531                 tm->tm_year = tm->tm_mday - 1900;
1532                 tm->tm_mday = i;
1533         }
1534
1535         /*
1536          *  If the day is out of range, die.
1537          */
1538         if ((tm->tm_mday < 1) || (tm->tm_mday > 31)) {
1539                 return -1;
1540         }
1541
1542         /*
1543          *      There may be %H:%M:%S.  Parse it in a hacky way.
1544          */
1545         if (f[3]) {
1546                 f[0] = f[3];    /* HH */
1547                 f[1] = strchr(f[0], ':'); /* find : separator */
1548                 if (!f[1]) return -1;
1549
1550                 *(f[1]++) = '\0'; /* nuke it, and point to MM:SS */
1551
1552                 f[2] = strchr(f[1], ':'); /* find : separator */
1553                 if (f[2]) {
1554                   *(f[2]++) = '\0';     /* nuke it, and point to SS */
1555                   tm->tm_sec = atoi(f[2]);
1556                 }                       /* else leave it as zero */
1557
1558                 tm->tm_hour = atoi(f[0]);
1559                 tm->tm_min = atoi(f[1]);
1560         }
1561
1562         /*
1563          *  Returns -1 on error.
1564          */
1565         t = mktime(tm);
1566         if (t == (time_t) -1) return -1;
1567
1568         *date = t;
1569
1570         return 0;
1571 }
1572
1573 /** Compares two pointers
1574  *
1575  * @param a first pointer to compare.
1576  * @param b second pointer to compare.
1577  * @return -1 if a < b, +1 if b > a, or 0 if both equal.
1578  */
1579 int8_t fr_pointer_cmp(void const *a, void const *b)
1580 {
1581         if (a < b) return -1;
1582         if (a == b) return 0;
1583
1584         return 1;
1585 }
1586
1587 static int _quick_partition(void const *to_sort[], int min, int max, fr_cmp_t cmp) {
1588         void const *pivot = to_sort[min];
1589         int i = min;
1590         int j = max + 1;
1591         void const *tmp;
1592
1593         for (;;) {
1594                 do ++i; while((cmp(to_sort[i], pivot) <= 0) && i <= max);
1595                 do --j; while(cmp(to_sort[j], pivot) > 0);
1596
1597                 if (i >= j) break;
1598
1599                 tmp = to_sort[i];
1600                 to_sort[i] = to_sort[j];
1601                 to_sort[j] = tmp;
1602         }
1603
1604         tmp = to_sort[min];
1605         to_sort[min] = to_sort[j];
1606         to_sort[j] = tmp;
1607
1608         return j;
1609 }
1610
1611 /** Quick sort an array of pointers using a comparator
1612  *
1613  * @param to_sort array of pointers to sort.
1614  * @param min_idx the lowest index (usually 0).
1615  * @param max_idx the highest index (usually length of array - 1).
1616  * @param cmp the comparison function to use to sort the array elements.
1617  */
1618 void fr_quick_sort(void const *to_sort[], int min_idx, int max_idx, fr_cmp_t cmp)
1619 {
1620         int part;
1621
1622         if (min_idx >= max_idx) return;
1623
1624         part = _quick_partition(to_sort, min_idx, max_idx, cmp);
1625         fr_quick_sort(to_sort, min_idx, part - 1, cmp);
1626         fr_quick_sort(to_sort, part + 1, max_idx, cmp);
1627 }
1628
1629 #ifdef TALLOC_DEBUG
1630 void fr_talloc_verify_cb(UNUSED const void *ptr, UNUSED int depth,
1631                          UNUSED int max_depth, UNUSED int is_ref,
1632                          UNUSED void *private_data)
1633 {
1634         /* do nothing */
1635 }
1636 #endif