contrib/bind/lib/isc/print.c

   1 /*
   2  * Copyright (C) 2004-2008  Internet Systems Consortium, Inc. ("ISC")
   3  * Copyright (C) 1999-2001, 2003  Internet Software Consortium.
   4  *
   5  * Permission to use, copy, modify, and/or distribute this software for any
   6  * purpose with or without fee is hereby granted, provided that the above
   7  * copyright notice and this permission notice appear in all copies.
   8  *
   9  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
  10  * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  11  * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
  12  * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  13  * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  14  * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  15  * PERFORMANCE OF THIS SOFTWARE.
  16  */
  17
  18 /* $Id: print.c,v 1.33.128.2 2008/02/18 23:46:30 tbox Exp $ */
  19
  20 /*! \file */
  21
  22 #include <config.h>
  23
  24 #include <ctype.h>
  25 #include <stdio.h>              /* for sprintf() */
  26 #include <string.h>             /* for strlen() */
  27
  28 #define ISC__PRINT_SOURCE       /* Used to get the isc_print_* prototypes. */
  29
  30 #include <isc/assertions.h>
  31 #include <isc/int.h>
  32 #include <isc/msgs.h>
  33 #include <isc/print.h>
  34 #include <isc/stdlib.h>
  35 #include <isc/util.h>
  36
  37 int
  38 isc_print_sprintf(char *str, const char *format, ...) {
  39         va_list ap;
  40
  41         va_start(ap, format);
  42         vsprintf(str, format, ap);
  43         va_end(ap);
  44         return (strlen(str));
  45 }
  46
  47 /*!
  48  * Return length of string that would have been written if not truncated.
  49  */
  50
  51 int
  52 isc_print_snprintf(char *str, size_t size, const char *format, ...) {
  53         va_list ap;
  54         int ret;
  55
  56         va_start(ap, format);
  57         ret = vsnprintf(str, size, format, ap);
  58         va_end(ap);
  59         return (ret);
  60
  61 }
  62
  63 /*!
  64  * Return length of string that would have been written if not truncated.
  65  */
  66
  67 int
  68 isc_print_vsnprintf(char *str, size_t size, const char *format, va_list ap) {
  69         int h;
  70         int l;
  71         int q;
  72         int alt;
  73         int zero;
  74         int left;
  75         int plus;
  76         int space;
  77         int neg;
  78         isc_int64_t tmpi;
  79         isc_uint64_t tmpui;
  80         unsigned long width;
  81         unsigned long precision;
  82         unsigned int length;
  83         char buf[1024];
  84         char c;
  85         void *v;
  86         char *save = str;
  87         const char *cp;
  88         const char *head;
  89         int count = 0;
  90         int pad;
  91         int zeropad;
  92         int dot;
  93         double dbl;
  94 #ifdef HAVE_LONG_DOUBLE
  95         long double ldbl;
  96 #endif
  97         char fmt[32];
  98
  99         INSIST(str != NULL);
 100         INSIST(format != NULL);
 101
 102         while (*format != '\0') {
 103                 if (*format != '%') {
 104                         if (size > 1) {
 105                                 *str++ = *format;
 106                                 size--;
 107                         }
 108                         count++;
 109                         format++;
 110                         continue;
 111                 }
 112                 format++;
 113
 114                 /*
 115                  * Reset flags.
 116                  */
 117                 dot = neg = space = plus = left = zero = alt = h = l = q = 0;
 118                 width = precision = 0;
 119                 head = "";
 120                 length = pad = zeropad = 0;
 121
 122                 do {
 123                         if (*format == '#') {
 124                                 alt = 1;
 125                                 format++;
 126                         } else if (*format == '-') {
 127                                 left = 1;
 128                                 zero = 0;
 129                                 format++;
 130                         } else if (*format == ' ') {
 131                                 if (!plus)
 132                                         space = 1;
 133                                 format++;
 134                         } else if (*format == '+') {
 135                                 plus = 1;
 136                                 space = 0;
 137                                 format++;
 138                         } else if (*format == '0') {
 139                                 if (!left)
 140                                         zero = 1;
 141                                 format++;
 142                         } else
 143                                 break;
 144                 } while (1);
 145
 146                 /*
 147                  * Width.
 148                  */
 149                 if (*format == '*') {
 150                         width = va_arg(ap, int);
 151                         format++;
 152                 } else if (isdigit((unsigned char)*format)) {
 153                         char *e;
 154                         width = strtoul(format, &e, 10);
 155                         format = e;
 156                 }
 157
 158                 /*
 159                  * Precision.
 160                  */
 161                 if (*format == '.') {
 162                         format++;
 163                         dot = 1;
 164                         if (*format == '*') {
 165                                 precision = va_arg(ap, int);
 166                                 format++;
 167                         } else if (isdigit((unsigned char)*format)) {
 168                                 char *e;
 169                                 precision = strtoul(format, &e, 10);
 170                                 format = e;
 171                         }
 172                 }
 173
 174                 switch (*format) {
 175                 case '\0':
 176                         continue;
 177                 case '%':
 178                         if (size > 1) {
 179                                 *str++ = *format;
 180                                 size--;
 181                         }
 182                         count++;
 183                         break;
 184                 case 'q':
 185                         q = 1;
 186                         format++;
 187                         goto doint;
 188                 case 'h':
 189                         h = 1;
 190                         format++;
 191                         goto doint;
 192                 case 'l':
 193                         l = 1;
 194                         format++;
 195                         if (*format == 'l') {
 196                                 q = 1;
 197                                 format++;
 198                         }
 199                         goto doint;
 200                 case 'n':
 201                 case 'i':
 202                 case 'd':
 203                 case 'o':
 204                 case 'u':
 205                 case 'x':
 206                 case 'X':
 207                 doint:
 208                         if (precision != 0)
 209                                 zero = 0;
 210                         switch (*format) {
 211                         case 'n':
 212                                 if (h) {
 213                                         short int *p;
 214                                         p = va_arg(ap, short *);
 215                                         REQUIRE(p != NULL);
 216                                         *p = str - save;
 217                                 } else if (l) {
 218                                         long int *p;
 219                                         p = va_arg(ap, long *);
 220                                         REQUIRE(p != NULL);
 221                                         *p = str - save;
 222                                 } else {
 223                                         int *p;
 224                                         p = va_arg(ap, int *);
 225                                         REQUIRE(p != NULL);
 226                                         *p = str - save;
 227                                 }
 228                                 break;
 229                         case 'i':
 230                         case 'd':
 231                                 if (q)
 232                                         tmpi = va_arg(ap, isc_int64_t);
 233                                 else if (l)
 234                                         tmpi = va_arg(ap, long int);
 235                                 else
 236                                         tmpi = va_arg(ap, int);
 237                                 if (tmpi < 0) {
 238                                         head = "-";
 239                                         tmpui = -tmpi;
 240                                 } else {
 241                                         if (plus)
 242                                                 head = "+";
 243                                         else if (space)
 244                                                 head = " ";
 245                                         else
 246                                                 head = "";
 247                                         tmpui = tmpi;
 248                                 }
 249                                 if (tmpui <= 0xffffffffU)
 250                                         sprintf(buf, "%lu",
 251                                                 (unsigned long)tmpui);
 252                                 else {
 253                                         unsigned long mid;
 254                                         unsigned long lo;
 255                                         unsigned long hi;
 256                                         lo = tmpui % 1000000000;
 257                                         tmpui /= 1000000000;
 258                                         mid = tmpui % 1000000000;
 259                                         hi = tmpui / 1000000000;
 260                                         if (hi != 0)
 261                                                 sprintf(buf, "%lu", hi);
 262                                         else
 263                                                 buf[0] = '\n';
 264                                         sprintf(buf + strlen(buf), "%lu", mid);
 265                                         sprintf(buf + strlen(buf), "%lu", lo);
 266                                 }
 267                                 goto printint;
 268                         case 'o':
 269                                 if (q)
 270                                         tmpui = va_arg(ap, isc_uint64_t);
 271                                 else if (l)
 272                                         tmpui = va_arg(ap, long int);
 273                                 else
 274                                         tmpui = va_arg(ap, int);
 275                                 if (tmpui <= 0xffffffffU)
 276                                         sprintf(buf, alt ?  "%#lo" : "%lo",
 277                                                 (unsigned long)tmpui);
 278                                 else {
 279                                         unsigned long mid;
 280                                         unsigned long lo;
 281                                         unsigned long hi;
 282                                         lo = tmpui % 010000000000;
 283                                         tmpui /= 010000000000;
 284                                         mid = tmpui % 010000000000;
 285                                         hi = tmpui / 010000000000;
 286                                         if (hi != 0) {
 287                                                 sprintf(buf,
 288                                                         alt ?  "%#lo" : "%lo",
 289                                                         hi);
 290                                                 sprintf(buf + strlen(buf),
 291                                                         "%lo", mid);
 292                                         } else
 293                                                 sprintf(buf,
 294                                                         alt ?  "%#lo" : "%lo",
 295                                                         mid);
 296                                         sprintf(buf + strlen(buf), "%lo", lo);
 297                                 }
 298                                 goto printint;
 299                         case 'u':
 300                                 if (q)
 301                                         tmpui = va_arg(ap, isc_uint64_t);
 302                                 else if (l)
 303                                         tmpui = va_arg(ap, unsigned long int);
 304                                 else
 305                                         tmpui = va_arg(ap, unsigned int);
 306                                 if (tmpui <= 0xffffffffU)
 307                                         sprintf(buf, "%lu",
 308                                                 (unsigned long)tmpui);
 309                                 else {
 310                                         unsigned long mid;
 311                                         unsigned long lo;
 312                                         unsigned long hi;
 313                                         lo = tmpui % 1000000000;
 314                                         tmpui /= 1000000000;
 315                                         mid = tmpui % 1000000000;
 316                                         hi = tmpui / 1000000000;
 317                                         if (hi != 0)
 318                                                 sprintf(buf, "%lu", hi);
 319                                         else
 320                                                 buf[0] = '\n';
 321                                         sprintf(buf + strlen(buf), "%lu", mid);
 322                                         sprintf(buf + strlen(buf), "%lu", lo);
 323                                 }
 324                                 goto printint;
 325                         case 'x':
 326                                 if (q)
 327                                         tmpui = va_arg(ap, isc_uint64_t);
 328                                 else if (l)
 329                                         tmpui = va_arg(ap, unsigned long int);
 330                                 else
 331                                         tmpui = va_arg(ap, unsigned int);
 332                                 if (alt) {
 333                                         head = "0x";
 334                                         if (precision > 2)
 335                                                 precision -= 2;
 336                                 }
 337                                 if (tmpui <= 0xffffffffU)
 338                                         sprintf(buf, "%lx",
 339                                                 (unsigned long)tmpui);
 340                                 else {
 341                                         unsigned long hi = tmpui>>32;
 342                                         unsigned long lo = tmpui & 0xffffffff;
 343                                         sprintf(buf, "%lx", hi);
 344                                         sprintf(buf + strlen(buf), "%lx", lo);
 345                                 }
 346                                 goto printint;
 347                         case 'X':
 348                                 if (q)
 349                                         tmpui = va_arg(ap, isc_uint64_t);
 350                                 else if (l)
 351                                         tmpui = va_arg(ap, unsigned long int);
 352                                 else
 353                                         tmpui = va_arg(ap, unsigned int);
 354                                 if (alt) {
 355                                         head = "0X";
 356                                         if (precision > 2)
 357                                                 precision -= 2;
 358                                 }
 359                                 if (tmpui <= 0xffffffffU)
 360                                         sprintf(buf, "%lX",
 361                                                 (unsigned long)tmpui);
 362                                 else  {
 363                                         unsigned long hi = tmpui>>32;
 364                                         unsigned long lo = tmpui & 0xffffffff;
 365                                         sprintf(buf, "%lX", hi);
 366                                         sprintf(buf + strlen(buf), "%lX", lo);
 367                                 }
 368                                 goto printint;
 369                         printint:
 370                                 if (precision != 0 || width != 0) {
 371                                         length = strlen(buf);
 372                                         if (length < precision)
 373                                                 zeropad = precision - length;
 374                                         else if (length < width && zero)
 375                                                 zeropad = width - length;
 376                                         if (width != 0) {
 377                                                 pad = width - length -
 378                                                       zeropad - strlen(head);
 379                                                 if (pad < 0)
 380                                                         pad = 0;
 381                                         }
 382                                 }
 383                                 count += strlen(head) + strlen(buf) + pad +
 384                                          zeropad;
 385                                 if (!left) {
 386                                         while (pad > 0 && size > 1) {
 387                                                 *str++ = ' ';
 388                                                 size--;
 389                                                 pad--;
 390                                         }
 391                                 }
 392                                 cp = head;
 393                                 while (*cp != '\0' && size > 1) {
 394                                         *str++ = *cp++;
 395                                         size--;
 396                                 }
 397                                 while (zeropad > 0 && size > 1) {
 398                                         *str++ = '0';
 399                                         size--;
 400                                         zeropad--;
 401                                 }
 402                                 cp = buf;
 403                                 while (*cp != '\0' && size > 1) {
 404                                         *str++ = *cp++;
 405                                         size--;
 406                                 }
 407                                 while (pad > 0 && size > 1) {
 408                                         *str++ = ' ';
 409                                         size--;
 410                                         pad--;
 411                                 }
 412                                 break;
 413                         default:
 414                                 break;
 415                         }
 416                         break;
 417                 case 's':
 418                         cp = va_arg(ap, char *);
 419                         REQUIRE(cp != NULL);
 420
 421                         if (precision != 0) {
 422                                 /*
 423                                  * cp need not be NULL terminated.
 424                                  */
 425                                 const char *tp;
 426                                 unsigned long n;
 427
 428                                 n = precision;
 429                                 tp = cp;
 430                                 while (n != 0 && *tp != '\0')
 431                                         n--, tp++;
 432                                 length = precision - n;
 433                         } else {
 434                                 length = strlen(cp);
 435                         }
 436                         if (width != 0) {
 437                                 pad = width - length;
 438                                 if (pad < 0)
 439                                         pad = 0;
 440                         }
 441                         count += pad + length;
 442                         if (!left)
 443                                 while (pad > 0 && size > 1) {
 444                                         *str++ = ' ';
 445                                         size--;
 446                                         pad--;
 447                                 }
 448                         if (precision != 0)
 449                                 while (precision > 0 && *cp != '\0' &&
 450                                        size > 1) {
 451                                         *str++ = *cp++;
 452                                         size--;
 453                                         precision--;
 454                                 }
 455                         else
 456                                 while (*cp != '\0' && size > 1) {
 457                                         *str++ = *cp++;
 458                                         size--;
 459                                 }
 460                         while (pad > 0 && size > 1) {
 461                                 *str++ = ' ';
 462                                 size--;
 463                                 pad--;
 464                         }
 465                         break;
 466                 case 'c':
 467                         c = va_arg(ap, int);
 468                         if (width > 0) {
 469                                 count += width;
 470                                 width--;
 471                                 if (left) {
 472                                         *str++ = c;
 473                                         size--;
 474                                 }
 475                                 while (width-- > 0 && size > 1) {
 476                                         *str++ = ' ';
 477                                         size--;
 478                                 }
 479                                 if (!left && size > 1) {
 480                                         *str++ = c;
 481                                         size--;
 482                                 }
 483                         } else {
 484                                 count++;
 485                                 if (size > 1) {
 486                                         *str++ = c;
 487                                         size--;
 488                                 }
 489                         }
 490                         break;
 491                 case 'p':
 492                         v = va_arg(ap, void *);
 493                         sprintf(buf, "%p", v);
 494                         length = strlen(buf);
 495                         if (precision > length)
 496                                 zeropad = precision - length;
 497                         if (width > 0) {
 498                                 pad = width - length - zeropad;
 499                                 if (pad < 0)
 500                                         pad = 0;
 501                         }
 502                         count += length + pad + zeropad;
 503                         if (!left)
 504                                 while (pad > 0 && size > 1) {
 505                                         *str++ = ' ';
 506                                         size--;
 507                                         pad--;
 508                                 }
 509                         cp = buf;
 510                         if (zeropad > 0 && buf[0] == '0' &&
 511                             (buf[1] == 'x' || buf[1] == 'X')) {
 512                                 if (size > 1) {
 513                                         *str++ = *cp++;
 514                                         size--;
 515                                 }
 516                                 if (size > 1) {
 517                                         *str++ = *cp++;
 518                                         size--;
 519                                 }
 520                                 while (zeropad > 0 && size > 1) {
 521                                         *str++ = '0';
 522                                         size--;
 523                                         zeropad--;
 524                                 }
 525                         }
 526                         while (*cp != '\0' && size > 1) {
 527                                 *str++ = *cp++;
 528                                 size--;
 529                         }
 530                         while (pad > 0 && size > 1) {
 531                                 *str++ = ' ';
 532                                 size--;
 533                                 pad--;
 534                         }
 535                         break;
 536                 case 'D':       /*deprecated*/
 537                         INSIST("use %ld instead of %D" == NULL);
 538                 case 'O':       /*deprecated*/
 539                         INSIST("use %lo instead of %O" == NULL);
 540                 case 'U':       /*deprecated*/
 541                         INSIST("use %lu instead of %U" == NULL);
 542
 543                 case 'L':
 544 #ifdef HAVE_LONG_DOUBLE
 545                         l = 1;
 546 #else
 547                         INSIST("long doubles are not supported" == NULL);
 548 #endif
 549                         /*FALLTHROUGH*/
 550                 case 'e':
 551                 case 'E':
 552                 case 'f':
 553                 case 'g':
 554                 case 'G':
 555                         if (!dot)
 556                                 precision = 6;
 557                         /*
 558                          * IEEE floating point.
 559                          * MIN 2.2250738585072014E-308
 560                          * MAX 1.7976931348623157E+308
 561                          * VAX floating point has a smaller range than IEEE.
 562                          *
 563                          * precisions > 324 don't make much sense.
 564                          * if we cap the precision at 512 we will not
 565                          * overflow buf.
 566                          */
 567                         if (precision > 512)
 568                                 precision = 512;
 569                         sprintf(fmt, "%%%s%s.%lu%s%c", alt ? "#" : "",
 570                                 plus ? "+" : space ? " " : "",
 571                                 precision, l ? "L" : "", *format);
 572                         switch (*format) {
 573                         case 'e':
 574                         case 'E':
 575                         case 'f':
 576                         case 'g':
 577                         case 'G':
 578 #ifdef HAVE_LONG_DOUBLE
 579                                 if (l) {
 580                                         ldbl = va_arg(ap, long double);
 581                                         sprintf(buf, fmt, ldbl);
 582                                 } else
 583 #endif
 584                                 {
 585                                         dbl = va_arg(ap, double);
 586                                         sprintf(buf, fmt, dbl);
 587                                 }
 588                                 length = strlen(buf);
 589                                 if (width > 0) {
 590                                         pad = width - length;
 591                                         if (pad < 0)
 592                                                 pad = 0;
 593                                 }
 594                                 count += length + pad;
 595                                 if (!left)
 596                                         while (pad > 0 && size > 1) {
 597                                                 *str++ = ' ';
 598                                                 size--;
 599                                                 pad--;
 600                                         }
 601                                 cp = buf;
 602                                 while (*cp != ' ' && size > 1) {
 603                                         *str++ = *cp++;
 604                                         size--;
 605                                 }
 606                                 while (pad > 0 && size > 1) {
 607                                         *str++ = ' ';
 608                                         size--;
 609                                         pad--;
 610                                 }
 611                                 break;
 612                         default:
 613                                 continue;
 614                         }
 615                         break;
 616                 default:
 617                         continue;
 618                 }
 619                 format++;
 620         }
 621         if (size > 0)
 622                 *str = '\0';
 623         return (count);
 624 }