workspace/kdm/backend/printf.c

   1 /*
   2
   3 Copyright 2001,2002,2004 Oswald Buddenhagen <ossi@kde.org>
   4
   5 Permission to use, copy, modify, distribute, and sell this software and its
   6 documentation for any purpose is hereby granted without fee, provided that
   7 the above copyright notice appear in all copies and that both that
   8 copyright notice and this permission notice appear in supporting
   9 documentation.
  10
  11 The above copyright notice and this permission notice shall be included
  12 in all copies or substantial portions of the Software.
  13
  14 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  15 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  16 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  17 IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  18 OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  19 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  20 OTHER DEALINGS IN THE SOFTWARE.
  21
  22 Except as contained in this notice, the name of a copyright holder shall
  23 not be used in advertising or otherwise to promote the sale, use or
  24 other dealings in this Software without prior written authorization
  25 from the copyright holder.
  26
  27 */
  28
  29 /*
  30  * xdm - display manager daemon
  31  * Author: Keith Packard, MIT X Consortium
  32  *
  33  * printf.c - working horse of error.c
  34  */
  35
  36 /*
  37  * NOTE: this file is meant to be included, not linked,
  38  * so it can be used in the helper programs without much voodoo.
  39  */
  40
  41 /* ########## printf core implementation with some extensions ########## */
  42 /*
  43  * How to use the extensions:
  44  * - put ' or " in the flags field to quote a string with this char and
  45  *   escape special characters (only available, if PRINT_QUOTES is defined)
  46  * - put \\ in the flags field to quote special characters and leading and
  47  *   trailing spaces (only available, if PRINT_QUOTES is defined)
  48  * - arrays (only available, if PRINT_ARRAYS is defined)
  49  *   - the array modifier [ comes after the maximal field width specifier
  50  *   - the array length can be specified literally, with the '*' modifier
  51  *     (in which case an argument is expected) or will be automatically
  52  *     determined (stop values are -1 for ints and 0 for strings)
  53  *   - these modifiers expect their argument to be an in-line string quoted
  54  *     with an arbitrary character:
  55  *     - (, ) -> array pre-/suf-fix; default ""
  56  *     - <, > -> element pre-/suf-fix; default ""
  57  *     - | -> element separator; default " "
  58  *   - these modifiers expect no argument:
  59  *     - : -> print '<number of elements>: ' before an array
  60  *     - , -> short for |','
  61  *     - { -> short for ('{')' }'<' '|''
  62  *   - the pointer to the array is the last argument to the format
  63  * - the %m conversion from syslog() is supported
  64  */
  65
  66 /**************************************************************
  67  * Partially stolen from OpenSSH's OpenBSD compat directory.
  68  * (C) Patrick Powell, Brandon Long, Thomas Roessler,
  69  *     Michael Elkins, Ben Lindstrom
  70  **************************************************************/
  71
  72 #include <ctype.h>
  73 #include <string.h>
  74 #include <stdarg.h>
  75
  76 /* format flags - Bits */
  77 #define DP_F_MINUS     (1 << 0)
  78 #define DP_F_PLUS      (1 << 1)
  79 #define DP_F_SPACE     (1 << 2)
  80 #define DP_F_NUM       (1 << 3)
  81 #define DP_F_ZERO      (1 << 4)
  82 #define DP_F_UPCASE    (1 << 5)
  83 #define DP_F_UNSIGNED  (1 << 6)
  84 #define DP_F_SQUOTE    (1 << 7)
  85 #define DP_F_DQUOTE    (1 << 8)
  86 #define DP_F_BACKSL    (1 << 9)
  87 #define DP_F_ARRAY     (1 << 10)
  88 #define DP_F_COLON     (1 << 11)
  89
  90 /* Conversion Flags */
  91 #define DP_C_INT    0
  92 #define DP_C_BYTE   1
  93 #define DP_C_SHORT  2
  94 #define DP_C_LONG   3
  95 #define DP_C_STR    10
  96
  97 typedef void (*OutCh)( void *bp, char c );
  98
  99
 100 static void
 101 fmtint( OutCh dopr_outch, void *bp,
 102         long value, int base, int min, int max, int flags )
 103 {
 104         const char *ctab;
 105         unsigned long uvalue;
 106         int signvalue = 0;
 107         int place = 0;
 108         int spadlen = 0; /* amount to space pad */
 109         int zpadlen = 0; /* amount to zero pad */
 110         char convert[20];
 111
 112         if (max < 0)
 113                 max = 0;
 114
 115         uvalue = value;
 116
 117         if (!(flags & DP_F_UNSIGNED)) {
 118                 if (value < 0) {
 119                         signvalue = '-';
 120                         uvalue = -value;
 121                 } else if (flags & DP_F_PLUS) /* Do a sign (+/i) */
 122                         signvalue = '+';
 123                 else if (flags & DP_F_SPACE)
 124                         signvalue = ' ';
 125         }
 126
 127         ctab = (flags & DP_F_UPCASE) ? "0123456789ABCDEF" : "0123456789abcdef";
 128         do {
 129                 convert[place++] = ctab[uvalue % (unsigned)base];
 130                 uvalue = uvalue / (unsigned)base;
 131         } while (uvalue);
 132
 133         zpadlen = max - place;
 134         spadlen = min - (max > place ? max : place) -
 135                           (signvalue ? 1 : 0) - ((flags & DP_F_NUM) ? 2 : 0);
 136         if (zpadlen < 0)
 137                 zpadlen = 0;
 138         if (spadlen < 0)
 139                 spadlen = 0;
 140         if (flags & DP_F_ZERO) {
 141                 zpadlen = zpadlen > spadlen ? zpadlen : spadlen;
 142                 spadlen = 0;
 143         }
 144         if (flags & DP_F_MINUS)
 145                 spadlen = -spadlen; /* Left Justifty */
 146
 147
 148         /* Spaces */
 149         while (spadlen > 0) {
 150                 dopr_outch( bp, ' ' );
 151                 --spadlen;
 152         }
 153
 154         /* Sign */
 155         if (signvalue)
 156                 dopr_outch( bp, signvalue );
 157
 158         /* Prefix */
 159         if (flags & DP_F_NUM) {
 160                 dopr_outch( bp, '0' );
 161                 dopr_outch( bp, 'x' );
 162         }
 163
 164         /* Zeros */
 165         if (zpadlen > 0)
 166                 while (zpadlen > 0) {
 167                         dopr_outch( bp, '0' );
 168                         --zpadlen;
 169                 }
 170
 171         /* Digits */
 172         while (place > 0)
 173                 dopr_outch( bp, convert[--place] );
 174
 175         /* Left Justified spaces */
 176         while (spadlen < 0) {
 177                 dopr_outch( bp, ' ' );
 178                 ++spadlen;
 179         }
 180 }
 181
 182 typedef struct {
 183         const char *str;
 184         size_t len;
 185 } str_t;
 186
 187 static void
 188 putstr( OutCh dopr_outch, void *bp, str_t *st )
 189 {
 190         size_t pt;
 191
 192         for (pt = 0; pt < st->len; pt++)
 193                 dopr_outch( bp, st->str[pt] );
 194 }
 195
 196 static str_t _null_parents = { "(null)", 6 };
 197 #ifdef PRINT_ARRAYS
 198 static str_t _null_dparents = { "((null))", 8 };
 199 #endif
 200 #if defined(PRINT_QUOTES) || defined(PRINT_ARRAYS)
 201 static str_t _null_caps = { "NULL", 4 };
 202 #endif
 203
 204 static void
 205 fmtstr( OutCh dopr_outch, void *bp,
 206         const char *value, int flags, int min, int max )
 207 {
 208         int padlen, strln, curcol;
 209 #ifdef PRINT_QUOTES
 210         int lastcol;
 211 #endif
 212         char ch;
 213
 214         if (!value) {
 215 #ifdef PRINT_QUOTES
 216                 if (flags & (DP_F_SQUOTE | DP_F_DQUOTE))
 217                         putstr( dopr_outch, bp, &_null_caps );
 218                 else
 219 #endif
 220                         putstr( dopr_outch, bp, &_null_parents );
 221                 return;
 222         }
 223
 224         for (strln = 0; (unsigned)strln < (unsigned)max && value[strln]; strln++);
 225         padlen = min - strln;
 226         if (padlen < 0)
 227                 padlen = 0;
 228         if (flags & DP_F_MINUS)
 229                 padlen = -padlen; /* Left Justify */
 230
 231         for (; padlen > 0; padlen--)
 232                 dopr_outch( bp, ' ' );
 233 #ifdef PRINT_QUOTES
 234         lastcol = 0;
 235         if (flags & DP_F_SQUOTE)
 236                 dopr_outch( bp, '\'' );
 237         else if (flags & DP_F_DQUOTE)
 238                 dopr_outch( bp, '"');
 239         else if (flags & DP_F_BACKSL)
 240                 for (lastcol = strln; lastcol && value[lastcol - 1] == ' '; lastcol--);
 241 #endif
 242         for (curcol = 0; curcol < strln; curcol++) {
 243                 ch = value[curcol];
 244 #ifdef PRINT_QUOTES
 245                 if (flags & (DP_F_SQUOTE | DP_F_DQUOTE | DP_F_BACKSL)) {
 246                         switch (ch) {
 247                         case '\r': ch = 'r'; break;
 248                         case '\n': ch = 'n'; break;
 249                         case '\t': ch = 't'; break;
 250                         case '\a': ch = 'a'; break;
 251                         case '\b': ch = 'b'; break;
 252                         case '\v': ch = 'v'; break;
 253                         case '\f': ch = 'f'; break;
 254                         default:
 255                                 if (ch < 32 ||
 256                                     ((unsigned char)ch >= 0x7f && (unsigned char)ch < 0xa0))
 257                                 {
 258                                         dopr_outch( bp, '\\' );
 259                                         fmtint( dopr_outch, bp, (unsigned char)ch, 8, 3, 3, DP_F_ZERO );
 260                                         continue;
 261                                 } else {
 262                                         if ((ch == '\'' && (flags & DP_F_SQUOTE)) ||
 263                                             (ch == '"' && (flags & DP_F_DQUOTE) ) ||
 264                                             (ch == ' ' && (flags & DP_F_BACKSL) &&
 265                                              (!curcol || curcol >= lastcol)) ||
 266                                             ch == '\\')
 267                                                 dopr_outch( bp, '\\' );
 268                                         dopr_outch( bp, ch );
 269                                         continue;
 270                                 }
 271                         }
 272                         dopr_outch( bp, '\\' );
 273                 }
 274 #endif
 275                 dopr_outch( bp, ch );
 276         }
 277 #ifdef PRINT_QUOTES
 278         if (flags & DP_F_SQUOTE)
 279                 dopr_outch( bp, '\'' );
 280         else if (flags & DP_F_DQUOTE)
 281                 dopr_outch( bp, '"' );
 282 #endif
 283         for (; padlen < 0; padlen++)
 284                 dopr_outch( bp, ' ' );
 285 }
 286
 287 static void
 288 doPrint( OutCh dopr_outch, void *bp, const char *format, va_list args )
 289 {
 290         const char *strvalue;
 291 #ifdef PRINT_ARRAYS
 292         str_t arpr, arsf, arepr, aresf, aresp, *arp;
 293         void *arptr;
 294 #endif
 295         unsigned long value;
 296         int radix, min, max, flags, cflags, errn;
 297 #ifdef PRINT_ARRAYS
 298         int arlen;
 299         unsigned aridx;
 300         char sch;
 301 #endif
 302         char ch;
 303 #define NCHR if (!(ch = *format++)) return
 304
 305 # ifdef PRINT_ARRAYS
 306         arlen = 0;
 307 # endif
 308         radix = 0;
 309         errn = errno;
 310         for (;;) {
 311                 for (;;) {
 312                         NCHR;
 313                         if (ch == '%')
 314                                 break;
 315                         dopr_outch (bp, ch);
 316                 }
 317                 flags = cflags = min = 0;
 318                 max = -1;
 319                 for (;;) {
 320                         NCHR;
 321                         switch (ch) {
 322                         case '#': flags |= DP_F_NUM; continue;
 323                         case '-': flags |= DP_F_MINUS; continue;
 324                         case '+': flags |= DP_F_PLUS; continue;
 325                         case ' ': flags |= DP_F_SPACE; continue;
 326                         case '0': flags |= DP_F_ZERO; continue;
 327 #ifdef PRINT_QUOTES
 328                         case '"': flags |= DP_F_DQUOTE; continue;
 329                         case '\'': flags |= DP_F_SQUOTE; continue;
 330                         case '\\': flags |= DP_F_BACKSL; continue;
 331 #endif
 332                         }
 333                         break;
 334                 }
 335                 for (;;) {
 336                         if (isdigit( (unsigned char)ch )) {
 337                                 min = 10 * min + (ch - '0');
 338                                 NCHR;
 339                                 continue;
 340                         } else if (ch == '*') {
 341                                 min = va_arg( args, int );
 342                                 NCHR;
 343                         }
 344                         break;
 345                 }
 346                 if (ch == '.') {
 347                         max = 0;
 348                         for (;;) {
 349                                 NCHR;
 350                                 if (isdigit( (unsigned char)ch )) {
 351                                         max = 10 * max + (ch - '0');
 352                                         continue;
 353                                 } else if (ch == '*') {
 354                                         max = va_arg( args, int );
 355                                         NCHR;
 356                                 }
 357                                 break;
 358                         }
 359                 }
 360 #ifdef PRINT_ARRAYS
 361                 if (ch == '[') {
 362                         flags |= DP_F_ARRAY;
 363                         arlen = -1;
 364                         arpr.len = arsf.len = arepr.len = aresf.len = 0;
 365                         aresp.len = 1, aresp.str = " ";
 366                         for (;;) {
 367                                 NCHR;
 368                                 if (isdigit( (unsigned char)ch )) {
 369                                         arlen = 0;
 370                                         for (;;) {
 371                                                 arlen += (ch - '0');
 372                                                 NCHR;
 373                                                 if (!isdigit( (unsigned char)ch ))
 374                                                         break;
 375                                                 arlen *= 10;
 376                                         }
 377                                 }
 378                                 switch (ch) {
 379                                 case ':': flags |= DP_F_COLON; continue;
 380                                 case '*': arlen = va_arg( args, int ); continue;
 381                                 case '(': arp = &arpr; goto rar;
 382                                 case ')': arp = &arsf; goto rar;
 383                                 case '<': arp = &arepr; goto rar;
 384                                 case '>': arp = &aresf; goto rar;
 385                                 case '|': arp = &aresp;
 386                                   rar:
 387                                         NCHR;
 388                                         sch = ch;
 389                                         arp->str = format;
 390                                         do {
 391                                                 NCHR;
 392                                         } while (ch != sch);
 393                                         arp->len = format - arp->str - 1;
 394                                         continue;
 395                                 case ',':
 396                                         aresp.len = 1, aresp.str = ",";
 397                                         continue;
 398                                 case '{':
 399                                         aresp.len = 0, arpr.len = arepr.len = 1, arsf.len = 2;
 400                                         arpr.str = "{", arepr.str = " ", arsf.str = " }";
 401                                         continue;
 402                                 }
 403                                 break;
 404                         }
 405                 }
 406 #endif
 407                 for (;;) {
 408                         switch (ch) {
 409                         case 'h':
 410                                 cflags = DP_C_SHORT;
 411                                 NCHR;
 412                                 if (ch == 'h') {
 413                                         cflags = DP_C_BYTE;
 414                                         NCHR;
 415                                 }
 416                                 continue;
 417                         case 'l':
 418                                 cflags = DP_C_LONG;
 419                                 NCHR;
 420                                 continue;
 421                         }
 422                         break;
 423                 }
 424                 switch (ch) {
 425                 case '%':
 426                         dopr_outch( bp, ch );
 427                         break;
 428                 case 'm':
 429                         fmtstr( dopr_outch, bp, strerror( errn ), flags, min, max );
 430                         break;
 431                 case 'c':
 432                         dopr_outch( bp, va_arg( args, int ) );
 433                         break;
 434                 case 's':
 435 #ifdef PRINT_ARRAYS
 436                         cflags = DP_C_STR;
 437                         goto printit;
 438 #else
 439                         strvalue = va_arg( args, char * );
 440                         fmtstr( dopr_outch, bp, strvalue, flags, min, max );
 441                         break;
 442 #endif
 443                 case 'u':
 444                         flags |= DP_F_UNSIGNED;
 445                 case 'd':
 446                 case 'i':
 447                         radix = 10;
 448                         goto printit;
 449                 case 'X':
 450                         flags |= DP_F_UPCASE;
 451                 case 'x':
 452                         flags |= DP_F_UNSIGNED;
 453                         radix = 16;
 454                   printit:
 455 #ifdef PRINT_ARRAYS
 456                         if (flags & DP_F_ARRAY) {
 457                                 if (!(arptr = va_arg( args, void * )))
 458                                         putstr( dopr_outch, bp,
 459                                                 arpr.len ? &_null_caps : &_null_dparents );
 460                                 else {
 461                                         if (arlen == -1) {
 462                                                 arlen = 0;
 463                                                 switch (cflags) {
 464                                                 case DP_C_STR: while (((char **)arptr)[arlen]) arlen++; break;
 465                                                 case DP_C_BYTE: while (((unsigned char *)arptr)[arlen] != (unsigned char)-1) arlen++; break;
 466                                                 case DP_C_SHORT: while (((unsigned short int *)arptr)[arlen] != (unsigned short int)-1) arlen++; break;
 467                                                 case DP_C_LONG: while (((unsigned long int *)arptr)[arlen] != (unsigned long int)-1) arlen++; break;
 468                                                 default: while (((unsigned int *)arptr)[arlen] != (unsigned int)-1) arlen++; break;
 469                                                 }
 470                                         }
 471                                         if (flags & DP_F_COLON) {
 472                                                 fmtint( dopr_outch, bp, (long)arlen, 10, 0, -1, DP_F_UNSIGNED );
 473                                                 dopr_outch( bp, ':' );
 474                                                 dopr_outch( bp, ' ' );
 475                                         }
 476                                         putstr( dopr_outch, bp, &arpr );
 477                                         for (aridx = 0; aridx < (unsigned)arlen; aridx++) {
 478                                                 if (aridx)
 479                                                         putstr( dopr_outch, bp, &aresp );
 480                                                 putstr( dopr_outch, bp, &arepr );
 481                                                 if (cflags == DP_C_STR) {
 482                                                         strvalue = ((char **)arptr)[aridx];
 483                                                         fmtstr( dopr_outch, bp, strvalue, flags, min, max );
 484                                                 } else {
 485                                                         if (flags & DP_F_UNSIGNED) {
 486                                                                 switch (cflags) {
 487                                                                 case DP_C_BYTE: value = ((unsigned char *)arptr)[aridx]; break;
 488                                                                 case DP_C_SHORT: value = ((unsigned short int *)arptr)[aridx]; break;
 489                                                                 case DP_C_LONG: value = ((unsigned long int *)arptr)[aridx]; break;
 490                                                                 default: value = ((unsigned int *)arptr)[aridx]; break;
 491                                                                 }
 492                                                         } else {
 493                                                                 switch (cflags) {
 494                                                                 case DP_C_BYTE: value = ((signed char *)arptr)[aridx]; break;
 495                                                                 case DP_C_SHORT: value = ((short int *)arptr)[aridx]; break;
 496                                                                 case DP_C_LONG: value = ((long int *)arptr)[aridx]; break;
 497                                                                 default: value = ((int *)arptr)[aridx]; break;
 498                                                                 }
 499                                                         }
 500                                                         fmtint( dopr_outch, bp, value, radix, min, max, flags );
 501                                                 }
 502                                                 putstr( dopr_outch, bp, &aresf );
 503                                         }
 504                                         putstr( dopr_outch, bp, &arsf );
 505                                 }
 506                         } else {
 507                                 if (cflags == DP_C_STR) {
 508                                         strvalue = va_arg( args, char * );
 509                                         fmtstr( dopr_outch, bp, strvalue, flags, min, max );
 510                                 } else {
 511 #endif
 512                                         if (flags & DP_F_UNSIGNED) {
 513                                                 switch (cflags) {
 514                                                 case DP_C_LONG: value = va_arg( args, unsigned long int ); break;
 515                                                 default: value = va_arg( args, unsigned int ); break;
 516                                                 }
 517                                         } else {
 518                                                 switch (cflags) {
 519                                                 case DP_C_LONG: value = va_arg( args, long int ); break;
 520                                                 default: value = va_arg( args, int ); break;
 521                                                 }
 522                                         }
 523                                         fmtint( dopr_outch, bp, value, radix, min, max, flags );
 524 #ifdef PRINT_ARRAYS
 525                                 }
 526                         }
 527 #endif
 528                         break;
 529                 case 'p':
 530                         value = (long)va_arg( args, void * );
 531                         fmtint( dopr_outch, bp, value, 16, sizeof(long) * 2 + 2,
 532                                 max, flags | DP_F_UNSIGNED | DP_F_ZERO | DP_F_NUM );
 533                         break;
 534                 }
 535         }
 536 }
 537
 538 /* ########## end of printf core implementation ########## */
 539
 540
 541 /*
 542  * Logging function for xdm and helper programs.
 543  */
 544 #ifndef NO_LOGGER
 545
 546 #include <stdio.h>
 547 #include <time.h>
 548
 549 #ifdef USE_SYSLOG
 550 # include <syslog.h>
 551 # ifdef LOG_NAME
 552 #  define InitLog() openlog(LOG_NAME, LOG_PID, LOG_DAEMON)
 553 # else
 554 #  define InitLog() openlog(prog, LOG_PID, LOG_DAEMON)
 555 # endif
 556 static int lognums[] = { LOG_DEBUG, LOG_INFO, LOG_WARNING, LOG_ERR, LOG_CRIT };
 557 #else
 558 # define InitLog() while(0)
 559 #endif
 560
 561 static const char *lognams[] = { "debug", "info", "warning", "error", "panic" };
 562
 563 static void
 564 logTime( char *dbuf )
 565 {
 566         time_t tim;
 567         (void)time( &tim );
 568         strftime( dbuf, 20, "%b %e %H:%M:%S", localtime( &tim ) );
 569 }
 570
 571 #if defined(LOG_DEBUG_MASK) || defined(USE_SYSLOG)
 572 STATIC int debugLevel;
 573 #endif
 574
 575 #define OOMSTR "Out of memory. Expect problems.\n"
 576
 577 STATIC void
 578 logOutOfMem( void )
 579 {
 580         static time_t last;
 581         time_t tnow;
 582
 583         time( &tnow );
 584         if (last + 100 > tnow) { /* don't log bursts */
 585                 last = tnow;
 586                 return;
 587         }
 588         last = tnow;
 589 #ifdef USE_SYSLOG
 590         if (!(debugLevel & DEBUG_NOSYSLOG))
 591                 syslog( LOG_CRIT, OOMSTR );
 592         else
 593 #endif
 594         {
 595                 int el;
 596                 char dbuf[24], sbuf[128];
 597                 logTime( dbuf );
 598                 el = sprintf( sbuf, "%s "
 599 #ifdef LOG_NAME
 600                               LOG_NAME "[%ld]: " OOMSTR, dbuf,
 601 #else
 602                               "%s[%ld]: " OOMSTR, dbuf, prog,
 603 #endif
 604                               (long)getpid() );
 605                 write( 2, sbuf, el );
 606         }
 607 }
 608
 609 typedef struct {
 610         char *buf;
 611         int clen, blen, type;
 612         char lmbuf[128];
 613 } OCLBuf;
 614
 615 static void
 616 flush_OCL( OCLBuf *oclbp )
 617 {
 618         if (oclbp->clen) {
 619 #ifdef USE_SYSLOG
 620                 if (!(debugLevel & DEBUG_NOSYSLOG))
 621                         syslog( lognums[oclbp->type], "%.*s", oclbp->clen, oclbp->buf );
 622                 else
 623 #endif
 624                 {
 625                         oclbp->buf[oclbp->clen] = '\n';
 626                         write( 2, oclbp->buf, oclbp->clen + 1 );
 627                 }
 628                 oclbp->clen = 0;
 629         }
 630 }
 631
 632 static void
 633 outCh_OCL( void *bp, char c )
 634 {
 635         OCLBuf *oclbp = (OCLBuf *)bp;
 636         char *nbuf;
 637         int nlen;
 638
 639         if (c == '\n')
 640                 flush_OCL( oclbp );
 641         else {
 642                 if (oclbp->clen >= oclbp->blen - 1) {
 643                         if (oclbp->buf == oclbp->lmbuf) {
 644                                 flush_OCL( oclbp );
 645                                 oclbp->buf = 0;
 646                                 oclbp->blen = 0;
 647                         }
 648                         nlen = oclbp->blen * 3 / 2 + 128;
 649                         nbuf = Realloc( oclbp->buf, nlen );
 650                         if (nbuf) {
 651                                 oclbp->buf = nbuf;
 652                                 oclbp->blen = nlen;
 653                         } else {
 654                                 flush_OCL( oclbp );
 655                                 oclbp->buf = oclbp->lmbuf;
 656                                 oclbp->blen = sizeof(oclbp->lmbuf);
 657                         }
 658                 }
 659 #ifdef USE_SYSLOG
 660                 if (!oclbp->clen && (debugLevel & DEBUG_NOSYSLOG)) {
 661 #else
 662                 if (!oclbp->clen) {
 663 #endif
 664                         char dbuf[24];
 665                         logTime( dbuf );
 666                         oclbp->clen = sprintf( oclbp->buf, "%s "
 667 #ifdef LOG_NAME
 668                                                LOG_NAME "[%ld] %s: ", dbuf,
 669 #else
 670                                                "%s[%ld] %s: ", dbuf, prog,
 671 #endif
 672                                            (long)getpid(), lognams[oclbp->type] );
 673                 }
 674                 oclbp->buf[oclbp->clen++] = c;
 675         }
 676 }
 677
 678 static void
 679 logger( int type, const char *fmt, va_list args )
 680 {
 681         OCLBuf oclb;
 682
 683         oclb.buf = 0;
 684         oclb.blen = oclb.clen = 0;
 685         oclb.type = type;
 686         doPrint( outCh_OCL, &oclb, fmt, args );
 687         /* no flush, every message is supposed to be \n-terminated */
 688         if (oclb.buf && oclb.buf != oclb.lmbuf)
 689                 free( oclb.buf );
 690 }
 691
 692 #ifdef LOG_DEBUG_MASK
 693 STATIC void
 694 debug( const char *fmt, ... )
 695 {
 696         if (debugLevel & LOG_DEBUG_MASK) {
 697                 va_list args;
 698                 int olderrno = errno;
 699                 va_start( args, fmt );
 700                 logger( DM_DEBUG, fmt, args );
 701                 va_end( args );
 702                 errno = olderrno;
 703         }
 704 }
 705 #endif
 706
 707 #ifndef LOG_NO_INFO
 708 STATIC void
 709 logInfo( const char *fmt, ... )
 710 {
 711         va_list args;
 712
 713         va_start( args, fmt );
 714         logger( DM_INFO, fmt, args );
 715         va_end( args );
 716 }
 717 #endif
 718
 719 #ifndef LOG_NO_WARN
 720 STATIC void
 721 logWarn( const char *fmt, ... )
 722 {
 723         va_list args;
 724
 725         va_start( args, fmt );
 726         logger( DM_WARN, fmt, args );
 727         va_end( args );
 728 }
 729 #endif
 730
 731 #ifndef LOG_NO_ERROR
 732 STATIC void
 733 logError( const char *fmt, ... )
 734 {
 735         va_list args;
 736
 737         va_start( args, fmt );
 738         logger( DM_ERR, fmt, args );
 739         va_end( args );
 740 }
 741 #endif
 742
 743 #ifdef LOG_PANIC_EXIT
 744 STATIC void
 745 logPanic( const char *fmt, ... )
 746 {
 747         va_list args;
 748
 749         va_start( args, fmt );
 750         logger( DM_PANIC, fmt, args );
 751         va_end( args );
 752         exit( LOG_PANIC_EXIT );
 753 }
 754 #endif
 755
 756 #endif /* NO_LOGGER */
 757
 758 #ifdef NEED_FDPRINTF
 759
 760 typedef struct {
 761         char *buf;
 762         int clen, blen, tlen;
 763 } OCFBuf;
 764
 765 static void
 766 outCh_OCF( void *bp, char c )
 767 {
 768         OCFBuf *ocfbp = (OCFBuf *)bp;
 769         char *nbuf;
 770         int nlen;
 771
 772         ocfbp->tlen++;
 773         if (ocfbp->clen >= ocfbp->blen) {
 774                 if (ocfbp->blen < 0)
 775                         return;
 776                 nlen = ocfbp->blen * 3 / 2 + 100;
 777                 nbuf = Realloc( ocfbp->buf, nlen );
 778                 if (!nbuf) {
 779                         free( ocfbp->buf );
 780                         ocfbp->blen = -1;
 781                         ocfbp->buf = 0;
 782                         ocfbp->clen = 0;
 783                         return;
 784                 }
 785                 ocfbp->blen = nlen;
 786                 ocfbp->buf = nbuf;
 787         }
 788         ocfbp->buf[ocfbp->clen++] = c;
 789 }
 790
 791 STATIC int
 792 FdPrintf( int fd, const char *fmt, ... )
 793 {
 794         va_list args;
 795         OCFBuf ocfb = { 0, 0, 0, -1 };
 796
 797         va_start( args, fmt );
 798         doPrint( outCh_OCF, &ocfb, fmt, args );
 799         va_end( args );
 800         if (ocfb.buf) {
 801                 debug( "FdPrintf %\".*s to %d\n", ocfb.clen, ocfb.buf, fd );
 802                 (void)write( fd, ocfb.buf, ocfb.clen );
 803                 free( ocfb.buf );
 804         }
 805         return ocfb.tlen;
 806 }
 807
 808 #endif /* NEED_FDPRINTF */
 809
 810 #ifdef NEED_ASPRINTF
 811
 812 typedef struct {
 813         char *buf;
 814         int clen, blen, tlen;
 815 } OCABuf;
 816
 817 static void
 818 outCh_OCA( void *bp, char c )
 819 {
 820         OCABuf *ocabp = (OCABuf *)bp;
 821         char *nbuf;
 822         int nlen;
 823
 824         ocabp->tlen++;
 825         if (ocabp->clen >= ocabp->blen) {
 826                 if (ocabp->blen < 0)
 827                         return;
 828                 nlen = ocabp->blen * 3 / 2 + 100;
 829                 nbuf = Realloc( ocabp->buf, nlen );
 830                 if (!nbuf) {
 831                         free( ocabp->buf );
 832                         ocabp->blen = -1;
 833                         ocabp->buf = 0;
 834                         ocabp->clen = 0;
 835                         return;
 836                 }
 837                 ocabp->blen = nlen;
 838                 ocabp->buf = nbuf;
 839         }
 840         ocabp->buf[ocabp->clen++] = c;
 841 }
 842
 843 STATIC int
 844 VASPrintf( char **strp, const char *fmt, va_list args )
 845 {
 846         OCABuf ocab = { 0, 0, 0, -1 };
 847
 848         doPrint( outCh_OCA, &ocab, fmt, args );
 849         outCh_OCA( &ocab, 0 );
 850         *strp = Realloc( ocab.buf, ocab.clen );
 851         if (!*strp)
 852                 *strp = ocab.buf;
 853         return ocab.tlen;
 854 }
 855
 856 STATIC int
 857 ASPrintf( char **strp, const char *fmt, ... )
 858 {
 859         va_list args;
 860         int len;
 861
 862         va_start( args, fmt );
 863         len = VASPrintf( strp, fmt, args );
 864         va_end( args );
 865         return len;
 866 }
 867
 868 #endif /* NEED_ASPRINTF */