]> git.ipfire.org Git - thirdparty/cups.git/blob - cups/file.c
projects / thirdparty / cups.git / blob
? search:


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