cups/file.c

   1 /*
   2  * File functions for CUPS.
   3  *
   4  * Since stdio files max out at 256 files on many systems, we have to
   5  * write similar functions without this limit.  At the same time, using
   6  * our own file functions allows us to provide transparent support of
   7  * gzip'd print files, PPD files, etc.
   8  *
   9  * Copyright 2007-2015 by Apple Inc.
  10  * Copyright 1997-2007 by Easy Software Products, all rights reserved.
  11  *
  12  * These coded instructions, statements, and computer programs are the
  13  * property of Apple Inc. and are protected by Federal copyright
  14  * law.  Distribution and use rights are outlined in the file "LICENSE.txt"
  15  * which should have been included with this file.  If this file is
  16  * file is missing or damaged, see the license at "http://www.cups.org/".
  17  *
  18  * This file is subject to the Apple OS-Developed Software exception.
  19  */
  20
  21 /*
  22  * Include necessary headers...
  23  */
  24
  25 #include "file-private.h"
  26 #include <sys/stat.h>
  27 #include <sys/types.h>
  28
  29
  30 /*
  31  * Local functions...
  32  */
  33
  34 #ifdef HAVE_LIBZ
  35 static ssize_t  cups_compress(cups_file_t *fp, const char *buf, size_t bytes);
  36 #endif /* HAVE_LIBZ */
  37 static ssize_t  cups_fill(cups_file_t *fp);
  38 static int      cups_open(const char *filename, int mode);
  39 static ssize_t  cups_read(cups_file_t *fp, char *buf, size_t bytes);
  40 static ssize_t  cups_write(cups_file_t *fp, const char *buf, size_t bytes);
  41
  42
  43 #ifndef WIN32
  44 /*
  45  * '_cupsFileCheck()' - Check the permissions of the given filename.
  46  */
  47
  48 _cups_fc_result_t                       /* O - Check result */
  49 _cupsFileCheck(
  50     const char          *filename,      /* I - Filename to check */
  51     _cups_fc_filetype_t filetype,       /* I - Type of file checks? */
  52     int                 dorootchecks,   /* I - Check for root permissions? */
  53     _cups_fc_func_t     cb,             /* I - Callback function */
  54     void                *context)       /* I - Context pointer for callback */
  55
  56 {
  57   struct stat           fileinfo;       /* File information */
  58   char                  message[1024],  /* Message string */
  59                         temp[1024],     /* Parent directory filename */
  60                         *ptr;           /* Pointer into parent directory */
  61   _cups_fc_result_t     result;         /* Check result */
  62
  63
  64  /*
  65   * Does the filename contain a relative path ("../")?
  66   */
  67
  68   if (strstr(filename, "../"))
  69   {
  70    /*
  71     * Yes, fail it!
  72     */
  73
  74     result = _CUPS_FILE_CHECK_RELATIVE_PATH;
  75     goto finishup;
  76   }
  77
  78  /*
  79   * Does the program even exist and is it accessible?
  80   */
  81
  82   if (stat(filename, &fileinfo))
  83   {
  84    /*
  85     * Nope...
  86     */
  87
  88     result = _CUPS_FILE_CHECK_MISSING;
  89     goto finishup;
  90   }
  91
  92  /*
  93   * Check the execute bit...
  94   */
  95
  96   result = _CUPS_FILE_CHECK_OK;
  97
  98   switch (filetype)
  99   {
 100     case _CUPS_FILE_CHECK_DIRECTORY :
 101         if (!S_ISDIR(fileinfo.st_mode))
 102           result = _CUPS_FILE_CHECK_WRONG_TYPE;
 103         break;
 104
 105     default :
 106         if (!S_ISREG(fileinfo.st_mode))
 107           result = _CUPS_FILE_CHECK_WRONG_TYPE;
 108         break;
 109   }
 110
 111   if (result)
 112     goto finishup;
 113
 114  /*
 115   * Are we doing root checks?
 116   */
 117
 118   if (!dorootchecks)
 119   {
 120    /*
 121     * Nope, so anything (else) goes...
 122     */
 123
 124     goto finishup;
 125   }
 126
 127  /*
 128   * Verify permission of the file itself:
 129   *
 130   * 1. Must be owned by root
 131   * 2. Must not be writable by group
 132   * 3. Must not be setuid
 133   * 4. Must not be writable by others
 134   */
 135
 136   if (fileinfo.st_uid ||                /* 1. Must be owned by root */
 137       (fileinfo.st_mode & S_IWGRP)  ||  /* 2. Must not be writable by group */
 138       (fileinfo.st_mode & S_ISUID) ||   /* 3. Must not be setuid */
 139       (fileinfo.st_mode & S_IWOTH))     /* 4. Must not be writable by others */
 140   {
 141     result = _CUPS_FILE_CHECK_PERMISSIONS;
 142     goto finishup;
 143   }
 144
 145   if (filetype == _CUPS_FILE_CHECK_DIRECTORY ||
 146       filetype == _CUPS_FILE_CHECK_FILE_ONLY)
 147     goto finishup;
 148
 149  /*
 150   * Now check the containing directory...
 151   */
 152
 153   strlcpy(temp, filename, sizeof(temp));
 154   if ((ptr = strrchr(temp, '/')) != NULL)
 155   {
 156     if (ptr == temp)
 157       ptr[1] = '\0';
 158     else
 159       *ptr = '\0';
 160   }
 161
 162   if (stat(temp, &fileinfo))
 163   {
 164    /*
 165     * Doesn't exist?!?
 166     */
 167
 168     result   = _CUPS_FILE_CHECK_MISSING;
 169     filetype = _CUPS_FILE_CHECK_DIRECTORY;
 170     filename = temp;
 171
 172     goto finishup;
 173   }
 174
 175   if (fileinfo.st_uid ||                /* 1. Must be owned by root */
 176       (fileinfo.st_mode & S_IWGRP) ||   /* 2. Must not be writable by group */
 177       (fileinfo.st_mode & S_ISUID) ||   /* 3. Must not be setuid */
 178       (fileinfo.st_mode & S_IWOTH))     /* 4. Must not be writable by others */
 179   {
 180     result   = _CUPS_FILE_CHECK_PERMISSIONS;
 181     filetype = _CUPS_FILE_CHECK_DIRECTORY;
 182     filename = temp;
 183   }
 184
 185  /*
 186   * Common return point...
 187   */
 188
 189   finishup:
 190
 191   if (cb)
 192   {
 193     cups_lang_t *lang = cupsLangDefault();
 194                                         /* Localization information */
 195
 196     switch (result)
 197     {
 198       case _CUPS_FILE_CHECK_OK :
 199           if (filetype == _CUPS_FILE_CHECK_DIRECTORY)
 200             snprintf(message, sizeof(message),
 201                      _cupsLangString(lang, _("Directory \"%s\" permissions OK "
 202                                              "(0%o/uid=%d/gid=%d).")),
 203                      filename, fileinfo.st_mode, (int)fileinfo.st_uid,
 204                      (int)fileinfo.st_gid);
 205           else
 206             snprintf(message, sizeof(message),
 207                      _cupsLangString(lang, _("File \"%s\" permissions OK "
 208                                              "(0%o/uid=%d/gid=%d).")),
 209                      filename, fileinfo.st_mode, (int)fileinfo.st_uid,
 210                      (int)fileinfo.st_gid);
 211           break;
 212
 213       case _CUPS_FILE_CHECK_MISSING :
 214           if (filetype == _CUPS_FILE_CHECK_DIRECTORY)
 215             snprintf(message, sizeof(message),
 216                      _cupsLangString(lang, _("Directory \"%s\" not available: "
 217                                              "%s")),
 218                      filename, strerror(errno));
 219           else
 220             snprintf(message, sizeof(message),
 221                      _cupsLangString(lang, _("File \"%s\" not available: %s")),
 222                      filename, strerror(errno));
 223           break;
 224
 225       case _CUPS_FILE_CHECK_PERMISSIONS :
 226           if (filetype == _CUPS_FILE_CHECK_DIRECTORY)
 227             snprintf(message, sizeof(message),
 228                      _cupsLangString(lang, _("Directory \"%s\" has insecure "
 229                                              "permissions "
 230                                              "(0%o/uid=%d/gid=%d).")),
 231                      filename, fileinfo.st_mode, (int)fileinfo.st_uid,
 232                      (int)fileinfo.st_gid);
 233           else
 234             snprintf(message, sizeof(message),
 235                      _cupsLangString(lang, _("File \"%s\" has insecure "
 236                                              "permissions "
 237                                              "(0%o/uid=%d/gid=%d).")),
 238                      filename, fileinfo.st_mode, (int)fileinfo.st_uid,
 239                      (int)fileinfo.st_gid);
 240           break;
 241
 242       case _CUPS_FILE_CHECK_WRONG_TYPE :
 243           if (filetype == _CUPS_FILE_CHECK_DIRECTORY)
 244             snprintf(message, sizeof(message),
 245                      _cupsLangString(lang, _("Directory \"%s\" is a file.")),
 246                      filename);
 247           else
 248             snprintf(message, sizeof(message),
 249                      _cupsLangString(lang, _("File \"%s\" is a directory.")),
 250                      filename);
 251           break;
 252
 253       case _CUPS_FILE_CHECK_RELATIVE_PATH :
 254           if (filetype == _CUPS_FILE_CHECK_DIRECTORY)
 255             snprintf(message, sizeof(message),
 256                      _cupsLangString(lang, _("Directory \"%s\" contains a "
 257                                              "relative path.")), filename);
 258           else
 259             snprintf(message, sizeof(message),
 260                      _cupsLangString(lang, _("File \"%s\" contains a relative "
 261                                              "path.")), filename);
 262           break;
 263     }
 264
 265     (*cb)(context, result, message);
 266   }
 267
 268   return (result);
 269 }
 270
 271
 272 /*
 273  * '_cupsFileCheckFilter()' - Report file check results as CUPS filter messages.
 274  */
 275
 276 void
 277 _cupsFileCheckFilter(
 278     void              *context,         /* I - Context pointer (unused) */
 279     _cups_fc_result_t result,           /* I - Result code */
 280     const char        *message)         /* I - Message text */
 281 {
 282   const char    *prefix;                /* Messaging prefix */
 283
 284
 285   (void)context;
 286
 287   switch (result)
 288   {
 289     default :
 290     case _CUPS_FILE_CHECK_OK :
 291         prefix = "DEBUG2";
 292         break;
 293
 294     case _CUPS_FILE_CHECK_MISSING :
 295     case _CUPS_FILE_CHECK_WRONG_TYPE :
 296         prefix = "ERROR";
 297         fputs("STATE: +cups-missing-filter-warning\n", stderr);
 298         break;
 299
 300     case _CUPS_FILE_CHECK_PERMISSIONS :
 301     case _CUPS_FILE_CHECK_RELATIVE_PATH :
 302         prefix = "ERROR";
 303         fputs("STATE: +cups-insecure-filter-warning\n", stderr);
 304         break;
 305   }
 306
 307   fprintf(stderr, "%s: %s\n", prefix, message);
 308 }
 309 #endif /* !WIN32 */
 310
 311
 312 /*
 313  * 'cupsFileClose()' - Close a CUPS file.
 314  *
 315  * @since CUPS 1.2/macOS 10.5@
 316  */
 317
 318 int                                     /* O - 0 on success, -1 on error */
 319 cupsFileClose(cups_file_t *fp)          /* I - CUPS file */
 320 {
 321   int   fd;                             /* File descriptor */
 322   char  mode;                           /* Open mode */
 323   int   status;                         /* Return status */
 324   int   is_stdio;                       /* Is a stdio file? */
 325
 326
 327   DEBUG_printf(("cupsFileClose(fp=%p)", (void *)fp));
 328
 329  /*
 330   * Range check...
 331   */
 332
 333   if (!fp)
 334     return (-1);
 335
 336  /*
 337   * Flush pending write data...
 338   */
 339
 340   if (fp->mode == 'w')
 341     status = cupsFileFlush(fp);
 342   else
 343     status = 0;
 344
 345 #ifdef HAVE_LIBZ
 346   if (fp->compressed && status >= 0)
 347   {
 348     if (fp->mode == 'r')
 349     {
 350      /*
 351       * Free decompression data...
 352       */
 353
 354       inflateEnd(&fp->stream);
 355     }
 356     else
 357     {
 358      /*
 359       * Flush any remaining compressed data...
 360       */
 361
 362       unsigned char     trailer[8];     /* Trailer CRC and length */
 363       int               done;           /* Done writing... */
 364
 365
 366       fp->stream.avail_in = 0;
 367
 368       for (done = 0;;)
 369       {
 370         if (fp->stream.next_out > fp->cbuf)
 371         {
 372           if (cups_write(fp, (char *)fp->cbuf,
 373                          (size_t)(fp->stream.next_out - fp->cbuf)) < 0)
 374             status = -1;
 375
 376           fp->stream.next_out  = fp->cbuf;
 377           fp->stream.avail_out = sizeof(fp->cbuf);
 378         }
 379
 380         if (done || status < 0)
 381           break;
 382
 383         done = deflate(&fp->stream, Z_FINISH) == Z_STREAM_END &&
 384                fp->stream.next_out == fp->cbuf;
 385       }
 386
 387      /*
 388       * Write the CRC and length...
 389       */
 390
 391       trailer[0] = (unsigned char)fp->crc;
 392       trailer[1] = (unsigned char)(fp->crc >> 8);
 393       trailer[2] = (unsigned char)(fp->crc >> 16);
 394       trailer[3] = (unsigned char)(fp->crc >> 24);
 395       trailer[4] = (unsigned char)fp->pos;
 396       trailer[5] = (unsigned char)(fp->pos >> 8);
 397       trailer[6] = (unsigned char)(fp->pos >> 16);
 398       trailer[7] = (unsigned char)(fp->pos >> 24);
 399
 400       if (cups_write(fp, (char *)trailer, 8) < 0)
 401         status = -1;
 402
 403      /*
 404       * Free all memory used by the compression stream...
 405       */
 406
 407       deflateEnd(&(fp->stream));
 408     }
 409   }
 410 #endif /* HAVE_LIBZ */
 411
 412  /*
 413   * Save the file descriptor we used and free memory...
 414   */
 415
 416   fd       = fp->fd;
 417   mode     = fp->mode;
 418   is_stdio = fp->is_stdio;
 419
 420   if (fp->printf_buffer)
 421     free(fp->printf_buffer);
 422
 423   free(fp);
 424
 425  /*
 426   * Close the file, returning the close status...
 427   */
 428
 429   if (mode == 's')
 430   {
 431     if (httpAddrClose(NULL, fd) < 0)
 432       status = -1;
 433   }
 434   else if (!is_stdio)
 435   {
 436     if (close(fd) < 0)
 437       status = -1;
 438   }
 439
 440   return (status);
 441 }
 442
 443
 444 /*
 445  * 'cupsFileCompression()' - Return whether a file is compressed.
 446  *
 447  * @since CUPS 1.2/macOS 10.5@
 448  */
 449
 450 int                                     /* O - @code CUPS_FILE_NONE@ or @code CUPS_FILE_GZIP@ */
 451 cupsFileCompression(cups_file_t *fp)    /* I - CUPS file */
 452 {
 453   return (fp ? fp->compressed : CUPS_FILE_NONE);
 454 }
 455
 456
 457 /*
 458  * 'cupsFileEOF()' - Return the end-of-file status.
 459  *
 460  * @since CUPS 1.2/macOS 10.5@
 461  */
 462
 463 int                                     /* O - 1 on end of file, 0 otherwise */
 464 cupsFileEOF(cups_file_t *fp)            /* I - CUPS file */
 465 {
 466   return (fp ? fp->eof : 1);
 467 }
 468
 469
 470 /*
 471  * 'cupsFileFind()' - Find a file using the specified path.
 472  *
 473  * This function allows the paths in the path string to be separated by
 474  * colons (UNIX standard) or semicolons (Windows standard) and stores the
 475  * result in the buffer supplied.  If the file cannot be found in any of
 476  * the supplied paths, @code NULL@ is returned. A @code NULL@ path only
 477  * matches the current directory.
 478  *
 479  * @since CUPS 1.2/macOS 10.5@
 480  */
 481
 482 const char *                            /* O - Full path to file or @code NULL@ if not found */
 483 cupsFileFind(const char *filename,      /* I - File to find */
 484              const char *path,          /* I - Colon/semicolon-separated path */
 485              int        executable,     /* I - 1 = executable files, 0 = any file/dir */
 486              char       *buffer,        /* I - Filename buffer */
 487              int        bufsize)        /* I - Size of filename buffer */
 488 {
 489   char  *bufptr,                        /* Current position in buffer */
 490         *bufend;                        /* End of buffer */
 491
 492
 493  /*
 494   * Range check input...
 495   */
 496
 497   DEBUG_printf(("cupsFileFind(filename=\"%s\", path=\"%s\", executable=%d, buffer=%p, bufsize=%d)", filename, path, executable, (void *)buffer, bufsize));
 498
 499   if (!filename || !buffer || bufsize < 2)
 500     return (NULL);
 501
 502   if (!path)
 503   {
 504    /*
 505     * No path, so check current directory...
 506     */
 507
 508     if (!access(filename, 0))
 509     {
 510       strlcpy(buffer, filename, (size_t)bufsize);
 511       return (buffer);
 512     }
 513     else
 514       return (NULL);
 515   }
 516
 517  /*
 518   * Now check each path and return the first match...
 519   */
 520
 521   bufend = buffer + bufsize - 1;
 522   bufptr = buffer;
 523
 524   while (*path)
 525   {
 526 #ifdef WIN32
 527     if (*path == ';' || (*path == ':' && ((bufptr - buffer) > 1 || !isalpha(buffer[0] & 255))))
 528 #else
 529     if (*path == ';' || *path == ':')
 530 #endif /* WIN32 */
 531     {
 532       if (bufptr > buffer && bufptr[-1] != '/' && bufptr < bufend)
 533         *bufptr++ = '/';
 534
 535       strlcpy(bufptr, filename, (size_t)(bufend - bufptr));
 536
 537 #ifdef WIN32
 538       if (!access(buffer, 0))
 539 #else
 540       if (!access(buffer, executable ? X_OK : 0))
 541 #endif /* WIN32 */
 542       {
 543         DEBUG_printf(("1cupsFileFind: Returning \"%s\"", buffer));
 544         return (buffer);
 545       }
 546
 547       bufptr = buffer;
 548     }
 549     else if (bufptr < bufend)
 550       *bufptr++ = *path;
 551
 552     path ++;
 553   }
 554
 555  /*
 556   * Check the last path...
 557   */
 558
 559   if (bufptr > buffer && bufptr[-1] != '/' && bufptr < bufend)
 560     *bufptr++ = '/';
 561
 562   strlcpy(bufptr, filename, (size_t)(bufend - bufptr));
 563
 564   if (!access(buffer, 0))
 565   {
 566     DEBUG_printf(("1cupsFileFind: Returning \"%s\"", buffer));
 567     return (buffer);
 568   }
 569   else
 570   {
 571     DEBUG_puts("1cupsFileFind: Returning NULL");
 572     return (NULL);
 573   }
 574 }
 575
 576
 577 /*
 578  * 'cupsFileFlush()' - Flush pending output.
 579  *
 580  * @since CUPS 1.2/macOS 10.5@
 581  */
 582
 583 int                                     /* O - 0 on success, -1 on error */
 584 cupsFileFlush(cups_file_t *fp)          /* I - CUPS file */
 585 {
 586   ssize_t       bytes;                  /* Bytes to write */
 587
 588
 589   DEBUG_printf(("cupsFileFlush(fp=%p)", (void *)fp));
 590
 591  /*
 592   * Range check input...
 593   */
 594
 595   if (!fp || fp->mode != 'w')
 596   {
 597     DEBUG_puts("1cupsFileFlush: Attempt to flush a read-only file...");
 598     return (-1);
 599   }
 600
 601   bytes = (ssize_t)(fp->ptr - fp->buf);
 602
 603   DEBUG_printf(("2cupsFileFlush: Flushing " CUPS_LLFMT " bytes...",
 604                 CUPS_LLCAST bytes));
 605
 606   if (bytes > 0)
 607   {
 608 #ifdef HAVE_LIBZ
 609     if (fp->compressed)
 610       bytes = cups_compress(fp, fp->buf, (size_t)bytes);
 611     else
 612 #endif /* HAVE_LIBZ */
 613       bytes = cups_write(fp, fp->buf, (size_t)bytes);
 614
 615     if (bytes < 0)
 616       return (-1);
 617
 618     fp->ptr = fp->buf;
 619   }
 620
 621   return (0);
 622 }
 623
 624
 625 /*
 626  * 'cupsFileGetChar()' - Get a single character from a file.
 627  *
 628  * @since CUPS 1.2/macOS 10.5@
 629  */
 630
 631 int                                     /* O - Character or -1 on end of file */
 632 cupsFileGetChar(cups_file_t *fp)        /* I - CUPS file */
 633 {
 634  /*
 635   * Range check input...
 636   */
 637
 638   DEBUG_printf(("4cupsFileGetChar(fp=%p)", (void *)fp));
 639
 640   if (!fp || (fp->mode != 'r' && fp->mode != 's'))
 641   {
 642     DEBUG_puts("5cupsFileGetChar: Bad arguments!");
 643     return (-1);
 644   }
 645
 646  /*
 647   * If the input buffer is empty, try to read more data...
 648   */
 649
 650   DEBUG_printf(("5cupsFileGetChar: fp->eof=%d, fp->ptr=%p, fp->end=%p", fp->eof, (void *)fp->ptr, (void *)fp->end));
 651
 652   if (fp->ptr >= fp->end)
 653     if (cups_fill(fp) <= 0)
 654     {
 655       DEBUG_puts("5cupsFileGetChar: Unable to fill buffer!");
 656       return (-1);
 657     }
 658
 659  /*
 660   * Return the next character in the buffer...
 661   */
 662
 663   DEBUG_printf(("5cupsFileGetChar: Returning %d...", *(fp->ptr) & 255));
 664
 665   fp->pos ++;
 666
 667   DEBUG_printf(("6cupsFileGetChar: pos=" CUPS_LLFMT, CUPS_LLCAST fp->pos));
 668
 669   return (*(fp->ptr)++ & 255);
 670 }
 671
 672
 673 /*
 674  * 'cupsFileGetConf()' - Get a line from a configuration file.
 675  *
 676  * @since CUPS 1.2/macOS 10.5@
 677  */
 678
 679 char *                                  /* O  - Line read or @code NULL@ on end of file or error */
 680 cupsFileGetConf(cups_file_t *fp,        /* I  - CUPS file */
 681                 char        *buf,       /* O  - String buffer */
 682                 size_t      buflen,     /* I  - Size of string buffer */
 683                 char        **value,    /* O  - Pointer to value */
 684                 int         *linenum)   /* IO - Current line number */
 685 {
 686   char  *ptr;                           /* Pointer into line */
 687
 688
 689  /*
 690   * Range check input...
 691   */
 692
 693   DEBUG_printf(("2cupsFileGetConf(fp=%p, buf=%p, buflen=" CUPS_LLFMT
 694                 ", value=%p, linenum=%p)", (void *)fp, (void *)buf, CUPS_LLCAST buflen, (void *)value, (void *)linenum));
 695
 696   if (!fp || (fp->mode != 'r' && fp->mode != 's') ||
 697       !buf || buflen < 2 || !value)
 698   {
 699     if (value)
 700       *value = NULL;
 701
 702     return (NULL);
 703   }
 704
 705  /*
 706   * Read the next non-comment line...
 707   */
 708
 709   *value = NULL;
 710
 711   while (cupsFileGets(fp, buf, buflen))
 712   {
 713     (*linenum) ++;
 714
 715    /*
 716     * Strip any comments...
 717     */
 718
 719     if ((ptr = strchr(buf, '#')) != NULL)
 720     {
 721       if (ptr > buf && ptr[-1] == '\\')
 722       {
 723         // Unquote the #...
 724         _cups_strcpy(ptr - 1, ptr);
 725       }
 726       else
 727       {
 728         // Strip the comment and any trailing whitespace...
 729         while (ptr > buf)
 730         {
 731           if (!_cups_isspace(ptr[-1]))
 732             break;
 733
 734           ptr --;
 735         }
 736
 737         *ptr = '\0';
 738       }
 739     }
 740
 741    /*
 742     * Strip leading whitespace...
 743     */
 744
 745     for (ptr = buf; _cups_isspace(*ptr); ptr ++);
 746
 747     if (ptr > buf)
 748       _cups_strcpy(buf, ptr);
 749
 750    /*
 751     * See if there is anything left...
 752     */
 753
 754     if (buf[0])
 755     {
 756      /*
 757       * Yes, grab any value and return...
 758       */
 759
 760       for (ptr = buf; *ptr; ptr ++)
 761         if (_cups_isspace(*ptr))
 762           break;
 763
 764       if (*ptr)
 765       {
 766        /*
 767         * Have a value, skip any other spaces...
 768         */
 769
 770         while (_cups_isspace(*ptr))
 771           *ptr++ = '\0';
 772
 773         if (*ptr)
 774           *value = ptr;
 775
 776        /*
 777         * Strip trailing whitespace and > for lines that begin with <...
 778         */
 779
 780         ptr += strlen(ptr) - 1;
 781
 782         if (buf[0] == '<' && *ptr == '>')
 783           *ptr-- = '\0';
 784         else if (buf[0] == '<' && *ptr != '>')
 785         {
 786          /*
 787           * Syntax error...
 788           */
 789
 790           *value = NULL;
 791           return (buf);
 792         }
 793
 794         while (ptr > *value && _cups_isspace(*ptr))
 795           *ptr-- = '\0';
 796       }
 797
 798      /*
 799       * Return the line...
 800       */
 801
 802       return (buf);
 803     }
 804   }
 805
 806   return (NULL);
 807 }
 808
 809
 810 /*
 811  * 'cupsFileGetLine()' - Get a CR and/or LF-terminated line that may
 812  *                       contain binary data.
 813  *
 814  * This function differs from @link cupsFileGets@ in that the trailing CR
 815  * and LF are preserved, as is any binary data on the line. The buffer is
 816  * nul-terminated, however you should use the returned length to determine
 817  * the number of bytes on the line.
 818  *
 819  * @since CUPS 1.2/macOS 10.5@
 820  */
 821
 822 size_t                                  /* O - Number of bytes on line or 0 on end of file */
 823 cupsFileGetLine(cups_file_t *fp,        /* I - File to read from */
 824                 char        *buf,       /* I - Buffer */
 825                 size_t      buflen)     /* I - Size of buffer */
 826 {
 827   int           ch;                     /* Character from file */
 828   char          *ptr,                   /* Current position in line buffer */
 829                 *end;                   /* End of line buffer */
 830
 831
 832  /*
 833   * Range check input...
 834   */
 835
 836   DEBUG_printf(("2cupsFileGetLine(fp=%p, buf=%p, buflen=" CUPS_LLFMT ")", (void *)fp, (void *)buf, CUPS_LLCAST buflen));
 837
 838   if (!fp || (fp->mode != 'r' && fp->mode != 's') || !buf || buflen < 3)
 839     return (0);
 840
 841  /*
 842   * Now loop until we have a valid line...
 843   */
 844
 845   for (ptr = buf, end = buf + buflen - 2; ptr < end ;)
 846   {
 847     if (fp->ptr >= fp->end)
 848       if (cups_fill(fp) <= 0)
 849         break;
 850
 851     *ptr++ = ch = *(fp->ptr)++;
 852     fp->pos ++;
 853
 854     if (ch == '\r')
 855     {
 856      /*
 857       * Check for CR LF...
 858       */
 859
 860       if (fp->ptr >= fp->end)
 861         if (cups_fill(fp) <= 0)
 862           break;
 863
 864       if (*(fp->ptr) == '\n')
 865       {
 866         *ptr++ = *(fp->ptr)++;
 867         fp->pos ++;
 868       }
 869
 870       break;
 871     }
 872     else if (ch == '\n')
 873     {
 874      /*
 875       * Line feed ends a line...
 876       */
 877
 878       break;
 879     }
 880   }
 881
 882   *ptr = '\0';
 883
 884   DEBUG_printf(("4cupsFileGetLine: pos=" CUPS_LLFMT, CUPS_LLCAST fp->pos));
 885
 886   return ((size_t)(ptr - buf));
 887 }
 888
 889
 890 /*
 891  * 'cupsFileGets()' - Get a CR and/or LF-terminated line.
 892  *
 893  * @since CUPS 1.2/macOS 10.5@
 894  */
 895
 896 char *                                  /* O - Line read or @code NULL@ on end of file or error */
 897 cupsFileGets(cups_file_t *fp,           /* I - CUPS file */
 898              char        *buf,          /* O - String buffer */
 899              size_t      buflen)        /* I - Size of string buffer */
 900 {
 901   int           ch;                     /* Character from file */
 902   char          *ptr,                   /* Current position in line buffer */
 903                 *end;                   /* End of line buffer */
 904
 905
 906  /*
 907   * Range check input...
 908   */
 909
 910   DEBUG_printf(("2cupsFileGets(fp=%p, buf=%p, buflen=" CUPS_LLFMT ")", (void *)fp, (void *)buf, CUPS_LLCAST buflen));
 911
 912   if (!fp || (fp->mode != 'r' && fp->mode != 's') || !buf || buflen < 2)
 913     return (NULL);
 914
 915  /*
 916   * Now loop until we have a valid line...
 917   */
 918
 919   for (ptr = buf, end = buf + buflen - 1; ptr < end ;)
 920   {
 921     if (fp->ptr >= fp->end)
 922       if (cups_fill(fp) <= 0)
 923       {
 924         if (ptr == buf)
 925           return (NULL);
 926         else
 927           break;
 928       }
 929
 930     ch = *(fp->ptr)++;
 931     fp->pos ++;
 932
 933     if (ch == '\r')
 934     {
 935      /*
 936       * Check for CR LF...
 937       */
 938
 939       if (fp->ptr >= fp->end)
 940         if (cups_fill(fp) <= 0)
 941           break;
 942
 943       if (*(fp->ptr) == '\n')
 944       {
 945         fp->ptr ++;
 946         fp->pos ++;
 947       }
 948
 949       break;
 950     }
 951     else if (ch == '\n')
 952     {
 953      /*
 954       * Line feed ends a line...
 955       */
 956
 957       break;
 958     }
 959     else
 960       *ptr++ = (char)ch;
 961   }
 962
 963   *ptr = '\0';
 964
 965   DEBUG_printf(("4cupsFileGets: pos=" CUPS_LLFMT, CUPS_LLCAST fp->pos));
 966
 967   return (buf);
 968 }
 969
 970
 971 /*
 972  * 'cupsFileLock()' - Temporarily lock access to a file.
 973  *
 974  * @since CUPS 1.2/macOS 10.5@
 975  */
 976
 977 int                                     /* O - 0 on success, -1 on error */
 978 cupsFileLock(cups_file_t *fp,           /* I - CUPS file */
 979              int         block)         /* I - 1 to wait for the lock, 0 to fail right away */
 980 {
 981  /*
 982   * Range check...
 983   */
 984
 985   if (!fp || fp->mode == 's')
 986     return (-1);
 987
 988  /*
 989   * Try the lock...
 990   */
 991
 992 #ifdef WIN32
 993   return (_locking(fp->fd, block ? _LK_LOCK : _LK_NBLCK, 0));
 994 #else
 995   return (lockf(fp->fd, block ? F_LOCK : F_TLOCK, 0));
 996 #endif /* WIN32 */
 997 }
 998
 999
1000 /*
1001  * 'cupsFileNumber()' - Return the file descriptor associated with a CUPS file.
1002  *
1003  * @since CUPS 1.2/macOS 10.5@
1004  */
1005
1006 int                                     /* O - File descriptor */
1007 cupsFileNumber(cups_file_t *fp)         /* I - CUPS file */
1008 {
1009   if (fp)
1010     return (fp->fd);
1011   else
1012     return (-1);
1013 }
1014
1015
1016 /*
1017  * 'cupsFileOpen()' - Open a CUPS file.
1018  *
1019  * The "mode" parameter can be "r" to read, "w" to write, overwriting any
1020  * existing file, "a" to append to an existing file or create a new file,
1021  * or "s" to open a socket connection.
1022  *
1023  * When opening for writing ("w"), an optional number from 1 to 9 can be
1024  * supplied which enables Flate compression of the file.  Compression is
1025  * not supported for the "a" (append) mode.
1026  *
1027  * When opening a socket connection, the filename is a string of the form
1028  * "address:port" or "hostname:port". The socket will make an IPv4 or IPv6
1029  * connection as needed, generally preferring IPv6 connections when there is
1030  * a choice.
1031  *
1032  * @since CUPS 1.2/macOS 10.5@
1033  */
1034
1035 cups_file_t *                           /* O - CUPS file or @code NULL@ if the file or socket cannot be opened */
1036 cupsFileOpen(const char *filename,      /* I - Name of file */
1037              const char *mode)          /* I - Open mode */
1038 {
1039   cups_file_t   *fp;                    /* New CUPS file */
1040   int           fd;                     /* File descriptor */
1041   char          hostname[1024],         /* Hostname */
1042                 *portname;              /* Port "name" (number or service) */
1043   http_addrlist_t *addrlist;            /* Host address list */
1044
1045
1046   DEBUG_printf(("cupsFileOpen(filename=\"%s\", mode=\"%s\")", filename,
1047                 mode));
1048
1049  /*
1050   * Range check input...
1051   */
1052
1053   if (!filename || !mode ||
1054       (*mode != 'r' && *mode != 'w' && *mode != 'a' && *mode != 's') ||
1055       (*mode == 'a' && isdigit(mode[1] & 255)))
1056     return (NULL);
1057
1058  /*
1059   * Open the file...
1060   */
1061
1062   switch (*mode)
1063   {
1064     case 'a' : /* Append file */
1065         fd = cups_open(filename,
1066                        O_RDWR | O_CREAT | O_APPEND | O_LARGEFILE | O_BINARY);
1067         break;
1068
1069     case 'r' : /* Read file */
1070         fd = open(filename, O_RDONLY | O_LARGEFILE | O_BINARY, 0);
1071         break;
1072
1073     case 'w' : /* Write file */
1074         fd = cups_open(filename, O_WRONLY | O_LARGEFILE | O_BINARY);
1075         if (fd < 0 && errno == ENOENT)
1076         {
1077           fd = cups_open(filename,
1078                          O_WRONLY | O_CREAT | O_EXCL | O_LARGEFILE | O_BINARY);
1079           if (fd < 0 && errno == EEXIST)
1080             fd = cups_open(filename, O_WRONLY | O_LARGEFILE | O_BINARY);
1081         }
1082
1083         if (fd >= 0)
1084 #ifdef WIN32
1085           _chsize(fd, 0);
1086 #else
1087           ftruncate(fd, 0);
1088 #endif /* WIN32 */
1089         break;
1090
1091     case 's' : /* Read/write socket */
1092         strlcpy(hostname, filename, sizeof(hostname));
1093         if ((portname = strrchr(hostname, ':')) != NULL)
1094           *portname++ = '\0';
1095         else
1096           return (NULL);
1097
1098        /*
1099         * Lookup the hostname and service...
1100         */
1101
1102         if ((addrlist = httpAddrGetList(hostname, AF_UNSPEC, portname)) == NULL)
1103           return (NULL);
1104
1105        /*
1106         * Connect to the server...
1107         */
1108
1109         if (!httpAddrConnect(addrlist, &fd))
1110         {
1111           httpAddrFreeList(addrlist);
1112           return (NULL);
1113         }
1114
1115         httpAddrFreeList(addrlist);
1116         break;
1117
1118     default : /* Remove bogus compiler warning... */
1119         return (NULL);
1120   }
1121
1122   if (fd < 0)
1123     return (NULL);
1124
1125  /*
1126   * Create the CUPS file structure...
1127   */
1128
1129   if ((fp = cupsFileOpenFd(fd, mode)) == NULL)
1130   {
1131     if (*mode == 's')
1132       httpAddrClose(NULL, fd);
1133     else
1134       close(fd);
1135   }
1136
1137  /*
1138   * Return it...
1139   */
1140
1141   return (fp);
1142 }
1143
1144 /*
1145  * 'cupsFileOpenFd()' - Open a CUPS file using a file descriptor.
1146  *
1147  * The "mode" parameter can be "r" to read, "w" to write, "a" to append,
1148  * or "s" to treat the file descriptor as a bidirectional socket connection.
1149  *
1150  * When opening for writing ("w"), an optional number from 1 to 9 can be
1151  * supplied which enables Flate compression of the file.  Compression is
1152  * not supported for the "a" (append) mode.
1153  *
1154  * @since CUPS 1.2/macOS 10.5@
1155  */
1156
1157 cups_file_t *                           /* O - CUPS file or @code NULL@ if the file could not be opened */
1158 cupsFileOpenFd(int        fd,           /* I - File descriptor */
1159                const char *mode)        /* I - Open mode */
1160 {
1161   cups_file_t   *fp;                    /* New CUPS file */
1162
1163
1164   DEBUG_printf(("cupsFileOpenFd(fd=%d, mode=\"%s\")", fd, mode));
1165
1166  /*
1167   * Range check input...
1168   */
1169
1170   if (fd < 0 || !mode ||
1171       (*mode != 'r' && *mode != 'w' && *mode != 'a' && *mode != 's') ||
1172       (*mode == 'a' && isdigit(mode[1] & 255)))
1173     return (NULL);
1174
1175  /*
1176   * Allocate memory...
1177   */
1178
1179   if ((fp = calloc(1, sizeof(cups_file_t))) == NULL)
1180     return (NULL);
1181
1182  /*
1183   * Open the file...
1184   */
1185
1186   fp->fd = fd;
1187
1188   switch (*mode)
1189   {
1190     case 'a' :
1191         fp->pos = lseek(fd, 0, SEEK_END);
1192
1193     case 'w' :
1194         fp->mode = 'w';
1195         fp->ptr  = fp->buf;
1196         fp->end  = fp->buf + sizeof(fp->buf);
1197
1198 #ifdef HAVE_LIBZ
1199         if (mode[1] >= '1' && mode[1] <= '9')
1200         {
1201          /*
1202           * Open a compressed stream, so write the standard gzip file
1203           * header...
1204           */
1205
1206           unsigned char header[10];     /* gzip file header */
1207           time_t        curtime;        /* Current time */
1208
1209
1210           curtime   = time(NULL);
1211           header[0] = 0x1f;
1212           header[1] = 0x8b;
1213           header[2] = Z_DEFLATED;
1214           header[3] = 0;
1215           header[4] = (unsigned char)curtime;
1216           header[5] = (unsigned char)(curtime >> 8);
1217           header[6] = (unsigned char)(curtime >> 16);
1218           header[7] = (unsigned char)(curtime >> 24);
1219           header[8] = 0;
1220           header[9] = 0x03;
1221
1222           cups_write(fp, (char *)header, 10);
1223
1224          /*
1225           * Initialize the compressor...
1226           */
1227
1228           deflateInit2(&(fp->stream), mode[1] - '0', Z_DEFLATED, -15, 8,
1229                        Z_DEFAULT_STRATEGY);
1230
1231           fp->stream.next_out  = fp->cbuf;
1232           fp->stream.avail_out = sizeof(fp->cbuf);
1233           fp->compressed       = 1;
1234           fp->crc              = crc32(0L, Z_NULL, 0);
1235         }
1236 #endif /* HAVE_LIBZ */
1237         break;
1238
1239     case 'r' :
1240         fp->mode = 'r';
1241         break;
1242
1243     case 's' :
1244         fp->mode = 's';
1245         break;
1246
1247     default : /* Remove bogus compiler warning... */
1248         return (NULL);
1249   }
1250
1251  /*
1252   * Don't pass this file to child processes...
1253   */
1254
1255 #ifndef WIN32
1256   fcntl(fp->fd, F_SETFD, fcntl(fp->fd, F_GETFD) | FD_CLOEXEC);
1257 #endif /* !WIN32 */
1258
1259   return (fp);
1260 }
1261
1262
1263 /*
1264  * 'cupsFilePeekChar()' - Peek at the next character from a file.
1265  *
1266  * @since CUPS 1.2/macOS 10.5@
1267  */
1268
1269 int                                     /* O - Character or -1 on end of file */
1270 cupsFilePeekChar(cups_file_t *fp)       /* I - CUPS file */
1271 {
1272  /*
1273   * Range check input...
1274   */
1275
1276   if (!fp || (fp->mode != 'r' && fp->mode != 's'))
1277     return (-1);
1278
1279  /*
1280   * If the input buffer is empty, try to read more data...
1281   */
1282
1283   if (fp->ptr >= fp->end)
1284     if (cups_fill(fp) <= 0)
1285       return (-1);
1286
1287  /*
1288   * Return the next character in the buffer...
1289   */
1290
1291   return (*(fp->ptr) & 255);
1292 }
1293
1294
1295 /*
1296  * 'cupsFilePrintf()' - Write a formatted string.
1297  *
1298  * @since CUPS 1.2/macOS 10.5@
1299  */
1300
1301 int                                     /* O - Number of bytes written or -1 on error */
1302 cupsFilePrintf(cups_file_t *fp,         /* I - CUPS file */
1303                const char  *format,     /* I - Printf-style format string */
1304                ...)                     /* I - Additional args as necessary */
1305 {
1306   va_list       ap;                     /* Argument list */
1307   ssize_t       bytes;                  /* Formatted size */
1308
1309
1310   DEBUG_printf(("2cupsFilePrintf(fp=%p, format=\"%s\", ...)", (void *)fp, format));
1311
1312   if (!fp || !format || (fp->mode != 'w' && fp->mode != 's'))
1313     return (-1);
1314
1315   if (!fp->printf_buffer)
1316   {
1317    /*
1318     * Start with an 1k printf buffer...
1319     */
1320
1321     if ((fp->printf_buffer = malloc(1024)) == NULL)
1322       return (-1);
1323
1324     fp->printf_size = 1024;
1325   }
1326
1327   va_start(ap, format);
1328   bytes = vsnprintf(fp->printf_buffer, fp->printf_size, format, ap);
1329   va_end(ap);
1330
1331   if (bytes >= (ssize_t)fp->printf_size)
1332   {
1333    /*
1334     * Expand the printf buffer...
1335     */
1336
1337     char        *temp;                  /* Temporary buffer pointer */
1338
1339
1340     if (bytes > 65535)
1341       return (-1);
1342
1343     if ((temp = realloc(fp->printf_buffer, (size_t)(bytes + 1))) == NULL)
1344       return (-1);
1345
1346     fp->printf_buffer = temp;
1347     fp->printf_size   = (size_t)(bytes + 1);
1348
1349     va_start(ap, format);
1350     bytes = vsnprintf(fp->printf_buffer, fp->printf_size, format, ap);
1351     va_end(ap);
1352   }
1353
1354   if (fp->mode == 's')
1355   {
1356     if (cups_write(fp, fp->printf_buffer, (size_t)bytes) < 0)
1357       return (-1);
1358
1359     fp->pos += bytes;
1360
1361     DEBUG_printf(("4cupsFilePrintf: pos=" CUPS_LLFMT, CUPS_LLCAST fp->pos));
1362
1363     return ((int)bytes);
1364   }
1365
1366   if ((fp->ptr + bytes) > fp->end)
1367     if (cupsFileFlush(fp))
1368       return (-1);
1369
1370   fp->pos += bytes;
1371
1372   DEBUG_printf(("4cupsFilePrintf: pos=" CUPS_LLFMT, CUPS_LLCAST fp->pos));
1373
1374   if ((size_t)bytes > sizeof(fp->buf))
1375   {
1376 #ifdef HAVE_LIBZ
1377     if (fp->compressed)
1378       return ((int)cups_compress(fp, fp->printf_buffer, (size_t)bytes));
1379     else
1380 #endif /* HAVE_LIBZ */
1381       return ((int)cups_write(fp, fp->printf_buffer, (size_t)bytes));
1382   }
1383   else
1384   {
1385     memcpy(fp->ptr, fp->printf_buffer, (size_t)bytes);
1386     fp->ptr += bytes;
1387     return ((int)bytes);
1388   }
1389 }
1390
1391
1392 /*
1393  * 'cupsFilePutChar()' - Write a character.
1394  *
1395  * @since CUPS 1.2/macOS 10.5@
1396  */
1397
1398 int                                     /* O - 0 on success, -1 on error */
1399 cupsFilePutChar(cups_file_t *fp,        /* I - CUPS file */
1400                 int         c)          /* I - Character to write */
1401 {
1402  /*
1403   * Range check input...
1404   */
1405
1406   if (!fp || (fp->mode != 'w' && fp->mode != 's'))
1407     return (-1);
1408
1409   if (fp->mode == 's')
1410   {
1411    /*
1412     * Send character immediately over socket...
1413     */
1414
1415     char ch;                            /* Output character */
1416
1417
1418     ch = (char)c;
1419
1420     if (send(fp->fd, &ch, 1, 0) < 1)
1421       return (-1);
1422   }
1423   else
1424   {
1425    /*
1426     * Buffer it up...
1427     */
1428
1429     if (fp->ptr >= fp->end)
1430       if (cupsFileFlush(fp))
1431         return (-1);
1432
1433     *(fp->ptr) ++ = (char)c;
1434   }
1435
1436   fp->pos ++;
1437
1438   DEBUG_printf(("4cupsFilePutChar: pos=" CUPS_LLFMT, CUPS_LLCAST fp->pos));
1439
1440   return (0);
1441 }
1442
1443
1444 /*
1445  * 'cupsFilePutConf()' - Write a configuration line.
1446  *
1447  * This function handles any comment escaping of the value.
1448  *
1449  * @since CUPS 1.4/macOS 10.6@
1450  */
1451
1452 ssize_t                                 /* O - Number of bytes written or -1 on error */
1453 cupsFilePutConf(cups_file_t *fp,        /* I - CUPS file */
1454                 const char *directive,  /* I - Directive */
1455                 const char *value)      /* I - Value */
1456 {
1457   ssize_t       bytes,                  /* Number of bytes written */
1458                 temp;                   /* Temporary byte count */
1459   const char    *ptr;                   /* Pointer into value */
1460
1461
1462   if (!fp || !directive || !*directive)
1463     return (-1);
1464
1465   if ((bytes = cupsFilePuts(fp, directive)) < 0)
1466     return (-1);
1467
1468   if (cupsFilePutChar(fp, ' ') < 0)
1469     return (-1);
1470   bytes ++;
1471
1472   if (value && *value)
1473   {
1474     if ((ptr = strchr(value, '#')) != NULL)
1475     {
1476      /*
1477       * Need to quote the first # in the info string...
1478       */
1479
1480       if ((temp = cupsFileWrite(fp, value, (size_t)(ptr - value))) < 0)
1481         return (-1);
1482       bytes += temp;
1483
1484       if (cupsFilePutChar(fp, '\\') < 0)
1485         return (-1);
1486       bytes ++;
1487
1488       if ((temp = cupsFilePuts(fp, ptr)) < 0)
1489         return (-1);
1490       bytes += temp;
1491     }
1492     else if ((temp = cupsFilePuts(fp, value)) < 0)
1493       return (-1);
1494     else
1495       bytes += temp;
1496   }
1497
1498   if (cupsFilePutChar(fp, '\n') < 0)
1499     return (-1);
1500   else
1501     return (bytes + 1);
1502 }
1503
1504
1505 /*
1506  * 'cupsFilePuts()' - Write a string.
1507  *
1508  * Like the @code fputs@ function, no newline is appended to the string.
1509  *
1510  * @since CUPS 1.2/macOS 10.5@
1511  */
1512
1513 int                                     /* O - Number of bytes written or -1 on error */
1514 cupsFilePuts(cups_file_t *fp,           /* I - CUPS file */
1515              const char  *s)            /* I - String to write */
1516 {
1517   ssize_t       bytes;                  /* Bytes to write */
1518
1519
1520  /*
1521   * Range check input...
1522   */
1523
1524   if (!fp || !s || (fp->mode != 'w' && fp->mode != 's'))
1525     return (-1);
1526
1527  /*
1528   * Write the string...
1529   */
1530
1531   bytes = (ssize_t)strlen(s);
1532
1533   if (fp->mode == 's')
1534   {
1535     if (cups_write(fp, s, (size_t)bytes) < 0)
1536       return (-1);
1537
1538     fp->pos += bytes;
1539
1540     DEBUG_printf(("4cupsFilePuts: pos=" CUPS_LLFMT, CUPS_LLCAST fp->pos));
1541
1542     return ((int)bytes);
1543   }
1544
1545   if ((fp->ptr + bytes) > fp->end)
1546     if (cupsFileFlush(fp))
1547       return (-1);
1548
1549   fp->pos += bytes;
1550
1551   DEBUG_printf(("4cupsFilePuts: pos=" CUPS_LLFMT, CUPS_LLCAST fp->pos));
1552
1553   if ((size_t)bytes > sizeof(fp->buf))
1554   {
1555 #ifdef HAVE_LIBZ
1556     if (fp->compressed)
1557       return ((int)cups_compress(fp, s, (size_t)bytes));
1558     else
1559 #endif /* HAVE_LIBZ */
1560       return ((int)cups_write(fp, s, (size_t)bytes));
1561   }
1562   else
1563   {
1564     memcpy(fp->ptr, s, (size_t)bytes);
1565     fp->ptr += bytes;
1566     return ((int)bytes);
1567   }
1568 }
1569
1570
1571 /*
1572  * 'cupsFileRead()' - Read from a file.
1573  *
1574  * @since CUPS 1.2/macOS 10.5@
1575  */
1576
1577 ssize_t                                 /* O - Number of bytes read or -1 on error */
1578 cupsFileRead(cups_file_t *fp,           /* I - CUPS file */
1579              char        *buf,          /* O - Buffer */
1580              size_t      bytes)         /* I - Number of bytes to read */
1581 {
1582   size_t        total;                  /* Total bytes read */
1583   ssize_t       count;                  /* Bytes read */
1584
1585
1586   DEBUG_printf(("2cupsFileRead(fp=%p, buf=%p, bytes=" CUPS_LLFMT ")", (void *)fp, (void *)buf, CUPS_LLCAST bytes));
1587
1588  /*
1589   * Range check input...
1590   */
1591
1592   if (!fp || !buf || (fp->mode != 'r' && fp->mode != 's'))
1593     return (-1);
1594
1595   if (bytes == 0)
1596     return (0);
1597
1598  /*
1599   * Loop until all bytes are read...
1600   */
1601
1602   total = 0;
1603   while (bytes > 0)
1604   {
1605     if (fp->ptr >= fp->end)
1606       if (cups_fill(fp) <= 0)
1607       {
1608         DEBUG_printf(("4cupsFileRead: cups_fill() returned -1, total="
1609                       CUPS_LLFMT, CUPS_LLCAST total));
1610
1611         if (total > 0)
1612           return ((ssize_t)total);
1613         else
1614           return (-1);
1615       }
1616
1617     count = (ssize_t)(fp->end - fp->ptr);
1618     if (count > (ssize_t)bytes)
1619       count = (ssize_t)bytes;
1620
1621     memcpy(buf, fp->ptr,(size_t) count);
1622     fp->ptr += count;
1623     fp->pos += count;
1624
1625     DEBUG_printf(("4cupsFileRead: pos=" CUPS_LLFMT, CUPS_LLCAST fp->pos));
1626
1627    /*
1628     * Update the counts for the last read...
1629     */
1630
1631     bytes -= (size_t)count;
1632     total += (size_t)count;
1633     buf   += count;
1634   }
1635
1636  /*
1637   * Return the total number of bytes read...
1638   */
1639
1640   DEBUG_printf(("3cupsFileRead: total=" CUPS_LLFMT, CUPS_LLCAST total));
1641
1642   return ((ssize_t)total);
1643 }
1644
1645
1646 /*
1647  * 'cupsFileRewind()' - Set the current file position to the beginning of the
1648  *                      file.
1649  *
1650  * @since CUPS 1.2/macOS 10.5@
1651  */
1652
1653 off_t                                   /* O - New file position or -1 on error */
1654 cupsFileRewind(cups_file_t *fp)         /* I - CUPS file */
1655 {
1656  /*
1657   * Range check input...
1658   */
1659
1660   DEBUG_printf(("cupsFileRewind(fp=%p)", (void *)fp));
1661   DEBUG_printf(("2cupsFileRewind: pos=" CUPS_LLFMT, CUPS_LLCAST fp->pos));
1662
1663   if (!fp || fp->mode != 'r')
1664     return (-1);
1665
1666  /*
1667   * Handle special cases...
1668   */
1669
1670   if (fp->bufpos == 0)
1671   {
1672    /*
1673     * No seeking necessary...
1674     */
1675
1676     fp->pos = 0;
1677
1678     if (fp->ptr)
1679     {
1680       fp->ptr = fp->buf;
1681       fp->eof = 0;
1682     }
1683
1684     DEBUG_printf(("2cupsFileRewind: pos=" CUPS_LLFMT, CUPS_LLCAST fp->pos));
1685
1686     return (0);
1687   }
1688
1689  /*
1690   * Otherwise, seek in the file and cleanup any compression buffers...
1691   */
1692
1693 #ifdef HAVE_LIBZ
1694   if (fp->compressed)
1695   {
1696     inflateEnd(&fp->stream);
1697     fp->compressed = 0;
1698   }
1699 #endif /* HAVE_LIBZ */
1700
1701   if (lseek(fp->fd, 0, SEEK_SET))
1702   {
1703     DEBUG_printf(("1cupsFileRewind: lseek failed: %s", strerror(errno)));
1704     return (-1);
1705   }
1706
1707   fp->bufpos = 0;
1708   fp->pos    = 0;
1709   fp->ptr    = NULL;
1710   fp->end    = NULL;
1711   fp->eof    = 0;
1712
1713   DEBUG_printf(("2cupsFileRewind: pos=" CUPS_LLFMT, CUPS_LLCAST fp->pos));
1714
1715   return (0);
1716 }
1717
1718
1719 /*
1720  * 'cupsFileSeek()' - Seek in a file.
1721  *
1722  * @since CUPS 1.2/macOS 10.5@
1723  */
1724
1725 off_t                                   /* O - New file position or -1 on error */
1726 cupsFileSeek(cups_file_t *fp,           /* I - CUPS file */
1727              off_t       pos)           /* I - Position in file */
1728 {
1729   ssize_t       bytes;                  /* Number bytes in buffer */
1730
1731
1732   DEBUG_printf(("cupsFileSeek(fp=%p, pos=" CUPS_LLFMT ")", (void *)fp, CUPS_LLCAST pos));
1733   DEBUG_printf(("2cupsFileSeek: fp->pos=" CUPS_LLFMT, CUPS_LLCAST fp->pos));
1734   DEBUG_printf(("2cupsFileSeek: fp->ptr=%p, fp->end=%p", (void *)fp->ptr, (void *)fp->end));
1735
1736  /*
1737   * Range check input...
1738   */
1739
1740   if (!fp || pos < 0 || fp->mode != 'r')
1741     return (-1);
1742
1743  /*
1744   * Handle special cases...
1745   */
1746
1747   if (pos == 0)
1748     return (cupsFileRewind(fp));
1749
1750   if (fp->ptr)
1751   {
1752     bytes = (ssize_t)(fp->end - fp->buf);
1753
1754     DEBUG_printf(("2cupsFileSeek: bytes=" CUPS_LLFMT, CUPS_LLCAST bytes));
1755
1756     if (pos >= fp->bufpos && pos < (fp->bufpos + bytes))
1757     {
1758      /*
1759       * No seeking necessary...
1760       */
1761
1762       fp->pos = pos;
1763       fp->ptr = fp->buf + pos - fp->bufpos;
1764       fp->eof = 0;
1765
1766       return (pos);
1767     }
1768   }
1769
1770 #ifdef HAVE_LIBZ
1771   if (!fp->compressed && !fp->ptr)
1772   {
1773    /*
1774     * Preload a buffer to determine whether the file is compressed...
1775     */
1776
1777     if (cups_fill(fp) <= 0)
1778       return (-1);
1779   }
1780 #endif /* HAVE_LIBZ */
1781
1782  /*
1783   * Seek forwards or backwards...
1784   */
1785
1786   fp->eof = 0;
1787
1788   if (pos < fp->bufpos)
1789   {
1790    /*
1791     * Need to seek backwards...
1792     */
1793
1794     DEBUG_puts("2cupsFileSeek: SEEK BACKWARDS");
1795
1796 #ifdef HAVE_LIBZ
1797     if (fp->compressed)
1798     {
1799       inflateEnd(&fp->stream);
1800
1801       lseek(fp->fd, 0, SEEK_SET);
1802       fp->bufpos = 0;
1803       fp->pos    = 0;
1804       fp->ptr    = NULL;
1805       fp->end    = NULL;
1806
1807       while ((bytes = cups_fill(fp)) > 0)
1808         if (pos >= fp->bufpos && pos < (fp->bufpos + bytes))
1809           break;
1810
1811       if (bytes <= 0)
1812         return (-1);
1813
1814       fp->ptr = fp->buf + pos - fp->bufpos;
1815       fp->pos = pos;
1816     }
1817     else
1818 #endif /* HAVE_LIBZ */
1819     {
1820       fp->bufpos = lseek(fp->fd, pos, SEEK_SET);
1821       fp->pos    = fp->bufpos;
1822       fp->ptr    = NULL;
1823       fp->end    = NULL;
1824
1825       DEBUG_printf(("2cupsFileSeek: lseek() returned " CUPS_LLFMT,
1826                     CUPS_LLCAST fp->pos));
1827     }
1828   }
1829   else
1830   {
1831    /*
1832     * Need to seek forwards...
1833     */
1834
1835     DEBUG_puts("2cupsFileSeek: SEEK FORWARDS");
1836
1837 #ifdef HAVE_LIBZ
1838     if (fp->compressed)
1839     {
1840       while ((bytes = cups_fill(fp)) > 0)
1841       {
1842         if (pos >= fp->bufpos && pos < (fp->bufpos + bytes))
1843           break;
1844       }
1845
1846       if (bytes <= 0)
1847         return (-1);
1848
1849       fp->ptr = fp->buf + pos - fp->bufpos;
1850       fp->pos = pos;
1851     }
1852     else
1853 #endif /* HAVE_LIBZ */
1854     {
1855       fp->bufpos = lseek(fp->fd, pos, SEEK_SET);
1856       fp->pos    = fp->bufpos;
1857       fp->ptr    = NULL;
1858       fp->end    = NULL;
1859
1860       DEBUG_printf(("2cupsFileSeek: lseek() returned " CUPS_LLFMT,
1861                     CUPS_LLCAST fp->pos));
1862     }
1863   }
1864
1865   DEBUG_printf(("2cupsFileSeek: pos=" CUPS_LLFMT, CUPS_LLCAST fp->pos));
1866
1867   return (fp->pos);
1868 }
1869
1870
1871 /*
1872  * 'cupsFileStderr()' - Return a CUPS file associated with stderr.
1873  *
1874  * @since CUPS 1.2/macOS 10.5@
1875  */
1876
1877 cups_file_t *                           /* O - CUPS file */
1878 cupsFileStderr(void)
1879 {
1880   _cups_globals_t *cg = _cupsGlobals(); /* Pointer to library globals... */
1881
1882
1883  /*
1884   * Open file descriptor 2 as needed...
1885   */
1886
1887   if (!cg->stdio_files[2])
1888   {
1889    /*
1890     * Flush any pending output on the stdio file...
1891     */
1892
1893     fflush(stderr);
1894
1895    /*
1896     * Open file descriptor 2...
1897     */
1898
1899     if ((cg->stdio_files[2] = cupsFileOpenFd(2, "w")) != NULL)
1900       cg->stdio_files[2]->is_stdio = 1;
1901   }
1902
1903   return (cg->stdio_files[2]);
1904 }
1905
1906
1907 /*
1908  * 'cupsFileStdin()' - Return a CUPS file associated with stdin.
1909  *
1910  * @since CUPS 1.2/macOS 10.5@
1911  */
1912
1913 cups_file_t *                           /* O - CUPS file */
1914 cupsFileStdin(void)
1915 {
1916   _cups_globals_t *cg = _cupsGlobals(); /* Pointer to library globals... */
1917
1918
1919  /*
1920   * Open file descriptor 0 as needed...
1921   */
1922
1923   if (!cg->stdio_files[0])
1924   {
1925    /*
1926     * Open file descriptor 0...
1927     */
1928
1929     if ((cg->stdio_files[0] = cupsFileOpenFd(0, "r")) != NULL)
1930       cg->stdio_files[0]->is_stdio = 1;
1931   }
1932
1933   return (cg->stdio_files[0]);
1934 }
1935
1936
1937 /*
1938  * 'cupsFileStdout()' - Return a CUPS file associated with stdout.
1939  *
1940  * @since CUPS 1.2/macOS 10.5@
1941  */
1942
1943 cups_file_t *                           /* O - CUPS file */
1944 cupsFileStdout(void)
1945 {
1946   _cups_globals_t *cg = _cupsGlobals(); /* Pointer to library globals... */
1947
1948
1949  /*
1950   * Open file descriptor 1 as needed...
1951   */
1952
1953   if (!cg->stdio_files[1])
1954   {
1955    /*
1956     * Flush any pending output on the stdio file...
1957     */
1958
1959     fflush(stdout);
1960
1961    /*
1962     * Open file descriptor 1...
1963     */
1964
1965     if ((cg->stdio_files[1] = cupsFileOpenFd(1, "w")) != NULL)
1966       cg->stdio_files[1]->is_stdio = 1;
1967   }
1968
1969   return (cg->stdio_files[1]);
1970 }
1971
1972
1973 /*
1974  * 'cupsFileTell()' - Return the current file position.
1975  *
1976  * @since CUPS 1.2/macOS 10.5@
1977  */
1978
1979 off_t                                   /* O - File position */
1980 cupsFileTell(cups_file_t *fp)           /* I - CUPS file */
1981 {
1982   DEBUG_printf(("2cupsFileTell(fp=%p)", (void *)fp));
1983   DEBUG_printf(("3cupsFileTell: pos=" CUPS_LLFMT, CUPS_LLCAST (fp ? fp->pos : -1)));
1984
1985   return (fp ? fp->pos : 0);
1986 }
1987
1988
1989 /*
1990  * 'cupsFileUnlock()' - Unlock access to a file.
1991  *
1992  * @since CUPS 1.2/macOS 10.5@
1993  */
1994
1995 int                                     /* O - 0 on success, -1 on error */
1996 cupsFileUnlock(cups_file_t *fp)         /* I - CUPS file */
1997 {
1998  /*
1999   * Range check...
2000   */
2001
2002   DEBUG_printf(("cupsFileUnlock(fp=%p)", (void *)fp));
2003
2004   if (!fp || fp->mode == 's')
2005     return (-1);
2006
2007  /*
2008   * Unlock...
2009   */
2010
2011 #ifdef WIN32
2012   return (_locking(fp->fd, _LK_UNLCK, 0));
2013 #else
2014   return (lockf(fp->fd, F_ULOCK, 0));
2015 #endif /* WIN32 */
2016 }
2017
2018
2019 /*
2020  * 'cupsFileWrite()' - Write to a file.
2021  *
2022  * @since CUPS 1.2/macOS 10.5@
2023  */
2024
2025 ssize_t                                 /* O - Number of bytes written or -1 on error */
2026 cupsFileWrite(cups_file_t *fp,          /* I - CUPS file */
2027               const char  *buf,         /* I - Buffer */
2028               size_t      bytes)        /* I - Number of bytes to write */
2029 {
2030  /*
2031   * Range check input...
2032   */
2033
2034   DEBUG_printf(("2cupsFileWrite(fp=%p, buf=%p, bytes=" CUPS_LLFMT ")", (void *)fp, (void *)buf, CUPS_LLCAST bytes));
2035
2036   if (!fp || !buf || (fp->mode != 'w' && fp->mode != 's'))
2037     return (-1);
2038
2039   if (bytes == 0)
2040     return (0);
2041
2042  /*
2043   * Write the buffer...
2044   */
2045
2046   if (fp->mode == 's')
2047   {
2048     if (cups_write(fp, buf, bytes) < 0)
2049       return (-1);
2050
2051     fp->pos += (off_t)bytes;
2052
2053     DEBUG_printf(("4cupsFileWrite: pos=" CUPS_LLFMT, CUPS_LLCAST fp->pos));
2054
2055     return ((ssize_t)bytes);
2056   }
2057
2058   if ((fp->ptr + bytes) > fp->end)
2059     if (cupsFileFlush(fp))
2060       return (-1);
2061
2062   fp->pos += (off_t)bytes;
2063
2064   DEBUG_printf(("4cupsFileWrite: pos=" CUPS_LLFMT, CUPS_LLCAST fp->pos));
2065
2066   if (bytes > sizeof(fp->buf))
2067   {
2068 #ifdef HAVE_LIBZ
2069     if (fp->compressed)
2070       return (cups_compress(fp, buf, bytes));
2071     else
2072 #endif /* HAVE_LIBZ */
2073       return (cups_write(fp, buf, bytes));
2074   }
2075   else
2076   {
2077     memcpy(fp->ptr, buf, bytes);
2078     fp->ptr += bytes;
2079     return ((ssize_t)bytes);
2080   }
2081 }
2082
2083
2084 #ifdef HAVE_LIBZ
2085 /*
2086  * 'cups_compress()' - Compress a buffer of data.
2087  */
2088
2089 static ssize_t                          /* O - Number of bytes written or -1 */
2090 cups_compress(cups_file_t *fp,          /* I - CUPS file */
2091               const char  *buf,         /* I - Buffer */
2092               size_t      bytes)        /* I - Number bytes */
2093 {
2094   DEBUG_printf(("7cups_compress(fp=%p, buf=%p, bytes=" CUPS_LLFMT ")", (void *)fp, (void *)buf, CUPS_LLCAST bytes));
2095
2096  /*
2097   * Update the CRC...
2098   */
2099
2100   fp->crc = crc32(fp->crc, (const Bytef *)buf, (uInt)bytes);
2101
2102  /*
2103   * Deflate the bytes...
2104   */
2105
2106   fp->stream.next_in  = (Bytef *)buf;
2107   fp->stream.avail_in = (uInt)bytes;
2108
2109   while (fp->stream.avail_in > 0)
2110   {
2111    /*
2112     * Flush the current buffer...
2113     */
2114
2115     DEBUG_printf(("9cups_compress: avail_in=%d, avail_out=%d",
2116                   fp->stream.avail_in, fp->stream.avail_out));
2117
2118     if (fp->stream.avail_out < (uInt)(sizeof(fp->cbuf) / 8))
2119     {
2120       if (cups_write(fp, (char *)fp->cbuf, (size_t)(fp->stream.next_out - fp->cbuf)) < 0)
2121         return (-1);
2122
2123       fp->stream.next_out  = fp->cbuf;
2124       fp->stream.avail_out = sizeof(fp->cbuf);
2125     }
2126
2127     deflate(&(fp->stream), Z_NO_FLUSH);
2128   }
2129
2130   return ((ssize_t)bytes);
2131 }
2132 #endif /* HAVE_LIBZ */
2133
2134
2135 /*
2136  * 'cups_fill()' - Fill the input buffer.
2137  */
2138
2139 static ssize_t                          /* O - Number of bytes or -1 */
2140 cups_fill(cups_file_t *fp)              /* I - CUPS file */
2141 {
2142   ssize_t               bytes;          /* Number of bytes read */
2143 #ifdef HAVE_LIBZ
2144   int                   status;         /* Decompression status */
2145   const unsigned char   *ptr,           /* Pointer into buffer */
2146                         *end;           /* End of buffer */
2147 #endif /* HAVE_LIBZ */
2148
2149
2150   DEBUG_printf(("7cups_fill(fp=%p)", (void *)fp));
2151   DEBUG_printf(("9cups_fill: fp->ptr=%p, fp->end=%p, fp->buf=%p, fp->bufpos=" CUPS_LLFMT ", fp->eof=%d", (void *)fp->ptr, (void *)fp->end, (void *)fp->buf, CUPS_LLCAST fp->bufpos, fp->eof));
2152
2153   if (fp->ptr && fp->end)
2154     fp->bufpos += fp->end - fp->buf;
2155
2156 #ifdef HAVE_LIBZ
2157   DEBUG_printf(("9cups_fill: fp->compressed=%d", fp->compressed));
2158
2159   while (!fp->ptr || fp->compressed)
2160   {
2161    /*
2162     * Check to see if we have read any data yet; if not, see if we have a
2163     * compressed file...
2164     */
2165
2166     if (!fp->ptr)
2167     {
2168      /*
2169       * Reset the file position in case we are seeking...
2170       */
2171
2172       fp->compressed = 0;
2173
2174      /*
2175       * Read the first bytes in the file to determine if we have a gzip'd
2176       * file...
2177       */
2178
2179       if ((bytes = cups_read(fp, (char *)fp->buf, sizeof(fp->buf))) < 0)
2180       {
2181        /*
2182         * Can't read from file!
2183         */
2184
2185         DEBUG_printf(("9cups_fill: cups_read() returned " CUPS_LLFMT,
2186                       CUPS_LLCAST bytes));
2187
2188         fp->eof = 1;
2189
2190         return (-1);
2191       }
2192
2193       if (bytes < 10 || fp->buf[0] != 0x1f ||
2194           (fp->buf[1] & 255) != 0x8b ||
2195           fp->buf[2] != 8 || (fp->buf[3] & 0xe0) != 0)
2196       {
2197        /*
2198         * Not a gzip'd file!
2199         */
2200
2201         fp->ptr = fp->buf;
2202         fp->end = fp->buf + bytes;
2203
2204         DEBUG_printf(("9cups_fill: Returning " CUPS_LLFMT,
2205                       CUPS_LLCAST bytes));
2206
2207         return (bytes);
2208       }
2209
2210      /*
2211       * Parse header junk: extra data, original name, and comment...
2212       */
2213
2214       ptr = (unsigned char *)fp->buf + 10;
2215       end = (unsigned char *)fp->buf + bytes;
2216
2217       if (fp->buf[3] & 0x04)
2218       {
2219        /*
2220         * Skip extra data...
2221         */
2222
2223         if ((ptr + 2) > end)
2224         {
2225          /*
2226           * Can't read from file!
2227           */
2228
2229           DEBUG_puts("9cups_fill: Extra gzip header data missing, returning -1.");
2230
2231           fp->eof = 1;
2232           errno   = EIO;
2233
2234           return (-1);
2235         }
2236
2237         bytes = ((unsigned char)ptr[1] << 8) | (unsigned char)ptr[0];
2238         ptr   += 2 + bytes;
2239
2240         if (ptr > end)
2241         {
2242          /*
2243           * Can't read from file!
2244           */
2245
2246           DEBUG_puts("9cups_fill: Extra gzip header data does not fit in initial buffer, returning -1.");
2247
2248           fp->eof = 1;
2249           errno   = EIO;
2250
2251           return (-1);
2252         }
2253       }
2254
2255       if (fp->buf[3] & 0x08)
2256       {
2257        /*
2258         * Skip original name data...
2259         */
2260
2261         while (ptr < end && *ptr)
2262           ptr ++;
2263
2264         if (ptr < end)
2265           ptr ++;
2266         else
2267         {
2268          /*
2269           * Can't read from file!
2270           */
2271
2272           DEBUG_puts("9cups_fill: Original filename in gzip header data does not fit in initial buffer, returning -1.");
2273
2274           fp->eof = 1;
2275           errno   = EIO;
2276
2277           return (-1);
2278         }
2279       }
2280
2281       if (fp->buf[3] & 0x10)
2282       {
2283        /*
2284         * Skip comment data...
2285         */
2286
2287         while (ptr < end && *ptr)
2288           ptr ++;
2289
2290         if (ptr < end)
2291           ptr ++;
2292         else
2293         {
2294          /*
2295           * Can't read from file!
2296           */
2297
2298           DEBUG_puts("9cups_fill: Comment in gzip header data does not fit in initial buffer, returning -1.");
2299
2300           fp->eof = 1;
2301           errno   = EIO;
2302
2303           return (-1);
2304         }
2305       }
2306
2307       if (fp->buf[3] & 0x02)
2308       {
2309        /*
2310         * Skip header CRC data...
2311         */
2312
2313         ptr += 2;
2314
2315         if (ptr > end)
2316         {
2317          /*
2318           * Can't read from file!
2319           */
2320
2321           DEBUG_puts("9cups_fill: Header CRC in gzip header data does not fit in initial buffer, returning -1.");
2322
2323           fp->eof = 1;
2324           errno   = EIO;
2325
2326           return (-1);
2327         }
2328       }
2329
2330      /*
2331       * Copy the flate-compressed data to the compression buffer...
2332       */
2333
2334       if ((bytes = end - ptr) > 0)
2335         memcpy(fp->cbuf, ptr, (size_t)bytes);
2336
2337      /*
2338       * Setup the decompressor data...
2339       */
2340
2341       fp->stream.zalloc    = (alloc_func)0;
2342       fp->stream.zfree     = (free_func)0;
2343       fp->stream.opaque    = (voidpf)0;
2344       fp->stream.next_in   = (Bytef *)fp->cbuf;
2345       fp->stream.next_out  = NULL;
2346       fp->stream.avail_in  = (uInt)bytes;
2347       fp->stream.avail_out = 0;
2348       fp->crc              = crc32(0L, Z_NULL, 0);
2349
2350       if ((status = inflateInit2(&(fp->stream), -15)) != Z_OK)
2351       {
2352         DEBUG_printf(("9cups_fill: inflateInit2 returned %d, returning -1.", status));
2353
2354         fp->eof = 1;
2355         errno   = EIO;
2356
2357         return (-1);
2358       }
2359
2360       fp->compressed = 1;
2361     }
2362
2363     if (fp->compressed)
2364     {
2365      /*
2366       * If we have reached end-of-file, return immediately...
2367       */
2368
2369       if (fp->eof)
2370       {
2371         DEBUG_puts("9cups_fill: EOF, returning 0.");
2372
2373         return (0);
2374       }
2375
2376      /*
2377       * Fill the decompression buffer as needed...
2378       */
2379
2380       if (fp->stream.avail_in == 0)
2381       {
2382         if ((bytes = cups_read(fp, (char *)fp->cbuf, sizeof(fp->cbuf))) <= 0)
2383         {
2384           DEBUG_printf(("9cups_fill: cups_read error, returning %d.", (int)bytes));
2385
2386           fp->eof = 1;
2387
2388           return (bytes);
2389         }
2390
2391         fp->stream.next_in  = fp->cbuf;
2392         fp->stream.avail_in = (uInt)bytes;
2393       }
2394
2395      /*
2396       * Decompress data from the buffer...
2397       */
2398
2399       fp->stream.next_out  = (Bytef *)fp->buf;
2400       fp->stream.avail_out = sizeof(fp->buf);
2401
2402       status = inflate(&(fp->stream), Z_NO_FLUSH);
2403
2404       if (fp->stream.next_out > (Bytef *)fp->buf)
2405         fp->crc = crc32(fp->crc, (Bytef *)fp->buf,
2406                         (uInt)(fp->stream.next_out - (Bytef *)fp->buf));
2407
2408       if (status == Z_STREAM_END)
2409       {
2410        /*
2411         * Read the CRC and length...
2412         */
2413
2414         unsigned char   trailer[8];     /* Trailer bytes */
2415         uLong           tcrc;           /* Trailer CRC */
2416         ssize_t         tbytes = 0;     /* Number of bytes */
2417
2418         if (fp->stream.avail_in > 0)
2419         {
2420           if (fp->stream.avail_in > sizeof(trailer))
2421             tbytes = (ssize_t)sizeof(trailer);
2422           else
2423             tbytes = (ssize_t)fp->stream.avail_in;
2424
2425           memcpy(trailer, fp->stream.next_in, (size_t)tbytes);
2426           fp->stream.next_in  += tbytes;
2427           fp->stream.avail_in -= (size_t)tbytes;
2428         }
2429
2430         if (tbytes < (ssize_t)sizeof(trailer))
2431         {
2432           if (read(fp->fd, trailer + tbytes, sizeof(trailer) - (size_t)tbytes) < ((ssize_t)sizeof(trailer) - tbytes))
2433           {
2434            /*
2435             * Can't get it, so mark end-of-file...
2436             */
2437
2438             DEBUG_puts("9cups_fill: Unable to read gzip CRC trailer, returning -1.");
2439
2440             fp->eof = 1;
2441             errno   = EIO;
2442
2443             return (-1);
2444           }
2445         }
2446
2447         tcrc = ((((((uLong)trailer[3] << 8) | (uLong)trailer[2]) << 8) |
2448                 (uLong)trailer[1]) << 8) | (uLong)trailer[0];
2449
2450         if (tcrc != fp->crc)
2451         {
2452          /*
2453           * Bad CRC, mark end-of-file...
2454           */
2455
2456           DEBUG_printf(("9cups_fill: tcrc=%08x != fp->crc=%08x, returning -1.", (unsigned int)tcrc, (unsigned int)fp->crc));
2457
2458           fp->eof = 1;
2459           errno   = EIO;
2460
2461           return (-1);
2462         }
2463
2464        /*
2465         * Otherwise, reset the compressed flag so that we re-read the
2466         * file header...
2467         */
2468
2469         fp->compressed = 0;
2470       }
2471       else if (status < Z_OK)
2472       {
2473         DEBUG_printf(("9cups_fill: inflate returned %d, returning -1.", status));
2474
2475         fp->eof = 1;
2476         errno   = EIO;
2477
2478         return (-1);
2479       }
2480
2481       bytes = (ssize_t)sizeof(fp->buf) - (ssize_t)fp->stream.avail_out;
2482
2483      /*
2484       * Return the decompressed data...
2485       */
2486
2487       fp->ptr = fp->buf;
2488       fp->end = fp->buf + bytes;
2489
2490       if (bytes)
2491       {
2492         DEBUG_printf(("9cups_fill: Returning %d.", (int)bytes));
2493         return (bytes);
2494       }
2495     }
2496   }
2497 #endif /* HAVE_LIBZ */
2498
2499  /*
2500   * Read a buffer's full of data...
2501   */
2502
2503   if ((bytes = cups_read(fp, fp->buf, sizeof(fp->buf))) <= 0)
2504   {
2505    /*
2506     * Can't read from file!
2507     */
2508
2509     fp->eof = 1;
2510     fp->ptr = fp->buf;
2511     fp->end = fp->buf;
2512   }
2513   else
2514   {
2515    /*
2516     * Return the bytes we read...
2517     */
2518
2519     fp->eof = 0;
2520     fp->ptr = fp->buf;
2521     fp->end = fp->buf + bytes;
2522   }
2523
2524   DEBUG_printf(("9cups_fill: Not gzip, returning %d.", (int)bytes));
2525
2526   return (bytes);
2527 }
2528
2529
2530 /*
2531  * 'cups_open()' - Safely open a file for writing.
2532  *
2533  * We don't allow appending to directories or files that are hard-linked or
2534  * symlinked.
2535  */
2536
2537 static int                              /* O - File descriptor or -1 otherwise */
2538 cups_open(const char *filename,         /* I - Filename */
2539           int        mode)              /* I - Open mode */
2540 {
2541   int           fd;                     /* File descriptor */
2542   struct stat   fileinfo;               /* File information */
2543 #ifndef WIN32
2544   struct stat   linkinfo;               /* Link information */
2545 #endif /* !WIN32 */
2546
2547
2548  /*
2549   * Open the file...
2550   */
2551
2552   if ((fd = open(filename, mode, 0666)) < 0)
2553     return (-1);
2554
2555  /*
2556   * Then verify that the file descriptor doesn't point to a directory or hard-
2557   * linked file.
2558   */
2559
2560   if (fstat(fd, &fileinfo))
2561   {
2562     close(fd);
2563     return (-1);
2564   }
2565
2566   if (fileinfo.st_nlink != 1)
2567   {
2568     close(fd);
2569     errno = EPERM;
2570     return (-1);
2571   }
2572
2573 #ifdef WIN32
2574   if (fileinfo.st_mode & _S_IFDIR)
2575 #else
2576   if (S_ISDIR(fileinfo.st_mode))
2577 #endif /* WIN32 */
2578   {
2579     close(fd);
2580     errno = EISDIR;
2581     return (-1);
2582   }
2583
2584 #ifndef WIN32
2585  /*
2586   * Then use lstat to determine whether the filename is a symlink...
2587   */
2588
2589   if (lstat(filename, &linkinfo))
2590   {
2591     close(fd);
2592     return (-1);
2593   }
2594
2595   if (S_ISLNK(linkinfo.st_mode) ||
2596       fileinfo.st_dev != linkinfo.st_dev ||
2597       fileinfo.st_ino != linkinfo.st_ino ||
2598 #ifdef HAVE_ST_GEN
2599       fileinfo.st_gen != linkinfo.st_gen ||
2600 #endif /* HAVE_ST_GEN */
2601       fileinfo.st_nlink != linkinfo.st_nlink ||
2602       fileinfo.st_mode != linkinfo.st_mode)
2603   {
2604    /*
2605     * Yes, don't allow!
2606     */
2607
2608     close(fd);
2609     errno = EPERM;
2610     return (-1);
2611   }
2612 #endif /* !WIN32 */
2613
2614   return (fd);
2615 }
2616
2617
2618 /*
2619  * 'cups_read()' - Read from a file descriptor.
2620  */
2621
2622 static ssize_t                          /* O - Number of bytes read or -1 */
2623 cups_read(cups_file_t *fp,              /* I - CUPS file */
2624           char        *buf,             /* I - Buffer */
2625           size_t      bytes)            /* I - Number bytes */
2626 {
2627   ssize_t       total;                  /* Total bytes read */
2628
2629
2630   DEBUG_printf(("7cups_read(fp=%p, buf=%p, bytes=" CUPS_LLFMT ")", (void *)fp, (void *)buf, CUPS_LLCAST bytes));
2631
2632  /*
2633   * Loop until we read at least 0 bytes...
2634   */
2635
2636   for (;;)
2637   {
2638 #ifdef WIN32
2639     if (fp->mode == 's')
2640       total = (ssize_t)recv(fp->fd, buf, (unsigned)bytes, 0);
2641     else
2642       total = (ssize_t)read(fp->fd, buf, (unsigned)bytes);
2643 #else
2644     if (fp->mode == 's')
2645       total = recv(fp->fd, buf, bytes, 0);
2646     else
2647       total = read(fp->fd, buf, bytes);
2648 #endif /* WIN32 */
2649
2650     DEBUG_printf(("9cups_read: total=" CUPS_LLFMT, CUPS_LLCAST total));
2651
2652     if (total >= 0)
2653       break;
2654
2655    /*
2656     * Reads can be interrupted by signals and unavailable resources...
2657     */
2658
2659     if (errno == EAGAIN || errno == EINTR)
2660       continue;
2661     else
2662       return (-1);
2663   }
2664
2665  /*
2666   * Return the total number of bytes read...
2667   */
2668
2669   return (total);
2670 }
2671
2672
2673 /*
2674  * 'cups_write()' - Write to a file descriptor.
2675  */
2676
2677 static ssize_t                          /* O - Number of bytes written or -1 */
2678 cups_write(cups_file_t *fp,             /* I - CUPS file */
2679            const char  *buf,            /* I - Buffer */
2680            size_t      bytes)           /* I - Number bytes */
2681 {
2682   size_t        total;                  /* Total bytes written */
2683   ssize_t       count;                  /* Count this time */
2684
2685
2686   DEBUG_printf(("7cups_write(fp=%p, buf=%p, bytes=" CUPS_LLFMT ")", (void *)fp, (void *)buf, CUPS_LLCAST bytes));
2687
2688  /*
2689   * Loop until all bytes are written...
2690   */
2691
2692   total = 0;
2693   while (bytes > 0)
2694   {
2695 #ifdef WIN32
2696     if (fp->mode == 's')
2697       count = (ssize_t)send(fp->fd, buf, (unsigned)bytes, 0);
2698     else
2699       count = (ssize_t)write(fp->fd, buf, (unsigned)bytes);
2700 #else
2701     if (fp->mode == 's')
2702       count = send(fp->fd, buf, bytes, 0);
2703     else
2704       count = write(fp->fd, buf, bytes);
2705 #endif /* WIN32 */
2706
2707     DEBUG_printf(("9cups_write: count=" CUPS_LLFMT, CUPS_LLCAST count));
2708
2709     if (count < 0)
2710     {
2711      /*
2712       * Writes can be interrupted by signals and unavailable resources...
2713       */
2714
2715       if (errno == EAGAIN || errno == EINTR)
2716         continue;
2717       else
2718         return (-1);
2719     }
2720
2721    /*
2722     * Update the counts for the last write call...
2723     */
2724
2725     bytes -= (size_t)count;
2726     total += (size_t)count;
2727     buf   += count;
2728   }
2729
2730  /*
2731   * Return the total number of bytes written...
2732   */
2733
2734   return ((ssize_t)total);
2735 }