]> git.ipfire.org Git - thirdparty/cups.git/blob - scheduler/printers.c
projects / thirdparty / cups.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Remove old logging of IPP conformance issues.
[thirdparty/cups.git] / scheduler / printers.c
1 /*
2 * "$Id$"
3 *
4 * Printer routines for the CUPS scheduler.
5 *
6 * Copyright 2007-2014 by Apple Inc.
7 * Copyright 1997-2007 by Easy Software Products, all rights reserved.
8 *
9 * These coded instructions, statements, and computer programs are the
10 * property of Apple Inc. and are protected by Federal copyright
11 * law. Distribution and use rights are outlined in the file "LICENSE.txt"
12 * which should have been included with this file. If this file is
13 * file is missing or damaged, see the license at "http://www.cups.org/".
14 */
15
16 /*
17 * Include necessary headers...
18 */
19
20 #include "cupsd.h"
21 #include <cups/dir.h>
22 #ifdef HAVE_APPLICATIONSERVICES_H
23 # include <ApplicationServices/ApplicationServices.h>
24 #endif /* HAVE_APPLICATIONSERVICES_H */
25 #ifdef HAVE_SYS_MOUNT_H
26 # include <sys/mount.h>
27 #endif /* HAVE_SYS_MOUNT_H */
28 #ifdef HAVE_SYS_STATVFS_H
29 # include <sys/statvfs.h>
30 #elif defined(HAVE_SYS_STATFS_H)
31 # include <sys/statfs.h>
32 #endif /* HAVE_SYS_STATVFS_H */
33 #ifdef HAVE_SYS_VFS_H
34 # include <sys/vfs.h>
35 #endif /* HAVE_SYS_VFS_H */
36 #ifdef __APPLE__
37 # include <asl.h>
38 #endif /* __APPLE__ */
39
40
41 /*
42 * Local functions...
43 */
44
45 static void add_printer_defaults(cupsd_printer_t *p);
46 static void add_printer_filter(cupsd_printer_t *p, mime_type_t *type,
47 const char *filter);
48 static void add_printer_formats(cupsd_printer_t *p);
49 static int compare_printers(void *first, void *second, void *data);
50 static void delete_printer_filters(cupsd_printer_t *p);
51 static void dirty_printer(cupsd_printer_t *p);
52 static void load_ppd(cupsd_printer_t *p);
53 static ipp_t *new_media_col(_pwg_size_t *size, const char *source,
54 const char *type);
55 static void write_xml_string(cups_file_t *fp, const char *s);
56
57
58 /*
59 * 'cupsdAddPrinter()' - Add a printer to the system.
60 */
61
62 cupsd_printer_t * /* O - New printer */
63 cupsdAddPrinter(const char *name) /* I - Name of printer */
64 {
65 cupsd_printer_t *p; /* New printer */
66 char uri[1024], /* Printer URI */
67 uuid[64]; /* Printer UUID */
68
69
70 /*
71 * Range check input...
72 */
73
74 cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdAddPrinter(\"%s\")", name);
75
76 /*
77 * Create a new printer entity...
78 */
79
80 if ((p = calloc(1, sizeof(cupsd_printer_t))) == NULL)
81 {
82 cupsdLogMessage(CUPSD_LOG_CRIT, "Unable to allocate memory for printer - %s",
83 strerror(errno));
84 return (NULL);
85 }
86
87 cupsdSetString(&p->name, name);
88 cupsdSetString(&p->info, name);
89 cupsdSetString(&p->hostname, ServerName);
90
91 httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL,
92 ServerName, RemotePort, "/printers/%s", name);
93 cupsdSetString(&p->uri, uri);
94 cupsdSetString(&p->uuid, httpAssembleUUID(ServerName, RemotePort, name, 0,
95 uuid, sizeof(uuid)));
96 cupsdSetDeviceURI(p, "file:///dev/null");
97
98 p->state = IPP_PRINTER_STOPPED;
99 p->state_time = time(NULL);
100 p->accepting = 0;
101 p->shared = DefaultShared;
102 p->filetype = mimeAddType(MimeDatabase, "printer", name);
103
104 cupsdSetString(&p->job_sheets[0], "none");
105 cupsdSetString(&p->job_sheets[1], "none");
106
107 cupsdSetString(&p->error_policy, ErrorPolicy);
108 cupsdSetString(&p->op_policy, DefaultPolicy);
109
110 p->op_policy_ptr = DefaultPolicyPtr;
111
112 /*
113 * Insert the printer in the printer list alphabetically...
114 */
115
116 if (!Printers)
117 Printers = cupsArrayNew(compare_printers, NULL);
118
119 cupsdLogMessage(CUPSD_LOG_DEBUG2,
120 "cupsdAddPrinter: Adding %s to Printers", p->name);
121 cupsArrayAdd(Printers, p);
122
123 /*
124 * Return the new printer...
125 */
126
127 return (p);
128 }
129
130
131 /*
132 * 'cupsdCreateCommonData()' - Create the common printer data.
133 */
134
135 void
136 cupsdCreateCommonData(void)
137 {
138 int i; /* Looping var */
139 ipp_attribute_t *attr; /* Attribute data */
140 cups_dir_t *dir; /* Notifier directory */
141 cups_dentry_t *dent; /* Notifier directory entry */
142 cups_array_t *notifiers; /* Notifier array */
143 char filename[1024], /* Filename */
144 *notifier; /* Current notifier */
145 cupsd_policy_t *p; /* Current policy */
146 int k_supported; /* Maximum file size supported */
147 #ifdef HAVE_STATVFS
148 struct statvfs spoolinfo; /* FS info for spool directory */
149 double spoolsize; /* FS size */
150 #elif defined(HAVE_STATFS)
151 struct statfs spoolinfo; /* FS info for spool directory */
152 double spoolsize; /* FS size */
153 #endif /* HAVE_STATVFS */
154 static const int nups[] = /* number-up-supported values */
155 { 1, 2, 4, 6, 9, 16 };
156 static const int orients[4] =/* orientation-requested-supported values */
157 {
158 IPP_PORTRAIT,
159 IPP_LANDSCAPE,
160 IPP_REVERSE_LANDSCAPE,
161 IPP_REVERSE_PORTRAIT
162 };
163 static const char * const holds[] = /* job-hold-until-supported values */
164 {
165 "no-hold",
166 "indefinite",
167 "day-time",
168 "evening",
169 "night",
170 "second-shift",
171 "third-shift",
172 "weekend"
173 };
174 static const char * const versions[] =/* ipp-versions-supported values */
175 {
176 "1.0",
177 "1.1",
178 "2.0",
179 "2.1"
180 };
181 static const int ops[] = /* operations-supported values */
182 {
183 IPP_PRINT_JOB,
184 IPP_VALIDATE_JOB,
185 IPP_CREATE_JOB,
186 IPP_SEND_DOCUMENT,
187 IPP_CANCEL_JOB,
188 IPP_GET_JOB_ATTRIBUTES,
189 IPP_GET_JOBS,
190 IPP_GET_PRINTER_ATTRIBUTES,
191 IPP_HOLD_JOB,
192 IPP_RELEASE_JOB,
193 IPP_RESTART_JOB,
194 IPP_PAUSE_PRINTER,
195 IPP_RESUME_PRINTER,
196 IPP_PURGE_JOBS,
197 IPP_SET_PRINTER_ATTRIBUTES,
198 IPP_SET_JOB_ATTRIBUTES,
199 IPP_GET_PRINTER_SUPPORTED_VALUES,
200 IPP_CREATE_PRINTER_SUBSCRIPTION,
201 IPP_CREATE_JOB_SUBSCRIPTION,
202 IPP_GET_SUBSCRIPTION_ATTRIBUTES,
203 IPP_GET_SUBSCRIPTIONS,
204 IPP_RENEW_SUBSCRIPTION,
205 IPP_CANCEL_SUBSCRIPTION,
206 IPP_GET_NOTIFICATIONS,
207 IPP_ENABLE_PRINTER,
208 IPP_DISABLE_PRINTER,
209 IPP_HOLD_NEW_JOBS,
210 IPP_RELEASE_HELD_NEW_JOBS,
211 IPP_CANCEL_JOBS,
212 IPP_CANCEL_MY_JOBS,
213 IPP_CLOSE_JOB,
214 CUPS_GET_DEFAULT,
215 CUPS_GET_PRINTERS,
216 CUPS_ADD_PRINTER,
217 CUPS_DELETE_PRINTER,
218 CUPS_GET_CLASSES,
219 CUPS_ADD_CLASS,
220 CUPS_DELETE_CLASS,
221 CUPS_ACCEPT_JOBS,
222 CUPS_REJECT_JOBS,
223 CUPS_SET_DEFAULT,
224 CUPS_GET_DEVICES,
225 CUPS_GET_PPDS,
226 CUPS_MOVE_JOB,
227 CUPS_AUTHENTICATE_JOB,
228 CUPS_GET_PPD,
229 CUPS_GET_DOCUMENT,
230 IPP_RESTART_JOB
231 };
232 static const char * const charsets[] =/* charset-supported values */
233 {
234 "us-ascii",
235 "utf-8"
236 };
237 static const char * const compressions[] =
238 { /* document-compression-supported values */
239 "none"
240 #ifdef HAVE_LIBZ
241 ,"gzip"
242 #endif /* HAVE_LIBZ */
243 };
244 static const char * const media_col_supported[] =
245 { /* media-col-supported values */
246 "media-bottom-margin",
247 "media-left-margin",
248 "media-right-margin",
249 "media-size",
250 "media-source",
251 "media-top-margin",
252 "media-type"
253 };
254 static const char * const multiple_document_handling[] =
255 { /* multiple-document-handling-supported values */
256 "separate-documents-uncollated-copies",
257 "separate-documents-collated-copies"
258 };
259 static const char * const notify_attrs[] =
260 { /* notify-attributes-supported values */
261 "printer-state-change-time",
262 "notify-lease-expiration-time",
263 "notify-subscriber-user-name"
264 };
265 static const char * const notify_events[] =
266 { /* notify-events-supported values */
267 "job-completed",
268 "job-config-changed",
269 "job-created",
270 "job-progress",
271 "job-state-changed",
272 "job-stopped",
273 "printer-added",
274 "printer-changed",
275 "printer-config-changed",
276 "printer-deleted",
277 "printer-finishings-changed",
278 "printer-media-changed",
279 "printer-modified",
280 "printer-restarted",
281 "printer-shutdown",
282 "printer-state-changed",
283 "printer-stopped",
284 "server-audit",
285 "server-restarted",
286 "server-started",
287 "server-stopped"
288 };
289 static const char * const job_creation[] =
290 { /* job-creation-attributes-supported */
291 "copies",
292 "finishings",
293 "ipp-attribute-fidelity",
294 "job-hold-until",
295 "job-name",
296 "job-priority",
297 "job-sheets",
298 "media",
299 "media-col",
300 "multiple-document-handling",
301 "number-up",
302 "output-bin",
303 "orientation-requested",
304 "page-ranges",
305 "print-color-mode",
306 "print-quality",
307 "printer-resolution",
308 "sides"
309 };
310 static const char * const job_settable[] =
311 { /* job-settable-attributes-supported */
312 "copies",
313 "finishings",
314 "job-hold-until",
315 "job-name",
316 "job-priority",
317 "media",
318 "media-col",
319 "multiple-document-handling",
320 "number-up",
321 "output-bin",
322 "orientation-requested",
323 "page-ranges",
324 "print-color-mode",
325 "print-quality",
326 "printer-resolution",
327 "sides"
328 };
329 static const char * const pdf_versions[] =
330 { /* pdf-versions-supported */
331 "adobe-1.2",
332 "adobe-1.3",
333 "adobe-1.4",
334 "adobe-1.5",
335 "adobe-1.6",
336 "adobe-1.7",
337 "iso-19005-1_2005",
338 "iso-32000-1_2008",
339 "pwg-5102.3"
340 };
341 static const char * const printer_settable[] =
342 { /* printer-settable-attributes-supported */
343 "printer-info",
344 "printer-location"
345 };
346 static const char * const which_jobs[] =
347 { /* which-jobs-supported values */
348 "completed",
349 "not-completed",
350 "aborted",
351 "all",
352 "canceled",
353 "pending",
354 "pending-held",
355 "processing",
356 "processing-stopped"
357 };
358
359
360 if (CommonData)
361 ippDelete(CommonData);
362
363 CommonData = ippNew();
364
365 /*
366 * Get the maximum spool size based on the size of the filesystem used for
367 * the RequestRoot directory. If the host OS doesn't support the statfs call
368 * or the filesystem is larger than 2TiB, always report INT_MAX.
369 */
370
371 #ifdef HAVE_STATVFS
372 if (statvfs(RequestRoot, &spoolinfo))
373 k_supported = INT_MAX;
374 else if ((spoolsize = (double)spoolinfo.f_frsize * spoolinfo.f_blocks / 1024) >
375 INT_MAX)
376 k_supported = INT_MAX;
377 else
378 k_supported = (int)spoolsize;
379
380 #elif defined(HAVE_STATFS)
381 if (statfs(RequestRoot, &spoolinfo))
382 k_supported = INT_MAX;
383 else if ((spoolsize = (double)spoolinfo.f_bsize * spoolinfo.f_blocks / 1024) >
384 INT_MAX)
385 k_supported = INT_MAX;
386 else
387 k_supported = (int)spoolsize;
388
389 #else
390 k_supported = INT_MAX;
391 #endif /* HAVE_STATVFS */
392
393 /*
394 * This list of attributes is sorted to improve performance when the
395 * client provides a requested-attributes attribute...
396 */
397
398 /* charset-configured */
399 ippAddString(CommonData, IPP_TAG_PRINTER, IPP_TAG_CHARSET | IPP_TAG_COPY,
400 "charset-configured", NULL, "utf-8");
401
402 /* charset-supported */
403 ippAddStrings(CommonData, IPP_TAG_PRINTER, IPP_TAG_CHARSET | IPP_TAG_COPY,
404 "charset-supported", sizeof(charsets) / sizeof(charsets[0]),
405 NULL, charsets);
406
407 /* compression-supported */
408 ippAddStrings(CommonData, IPP_TAG_PRINTER, IPP_TAG_KEYWORD | IPP_TAG_COPY,
409 "compression-supported",
410 sizeof(compressions) / sizeof(compressions[0]),
411 NULL, compressions);
412
413 /* copies-supported */
414 ippAddRange(CommonData, IPP_TAG_PRINTER, "copies-supported", 1, MaxCopies);
415
416 /* cups-version */
417 ippAddString(CommonData, IPP_TAG_PRINTER, IPP_TAG_TEXT | IPP_TAG_COPY,
418 "cups-version", NULL, CUPS_SVERSION + 6);
419
420 /* generated-natural-language-supported (no IPP_TAG_COPY) */
421 ippAddString(CommonData, IPP_TAG_PRINTER, IPP_TAG_LANGUAGE,
422 "generated-natural-language-supported", NULL, DefaultLanguage);
423
424 /* ipp-versions-supported */
425 ippAddStrings(CommonData, IPP_TAG_PRINTER, IPP_TAG_KEYWORD | IPP_TAG_COPY,
426 "ipp-versions-supported", sizeof(versions) / sizeof(versions[0]),
427 NULL, versions);
428
429 /* ippget-event-life */
430 ippAddInteger(CommonData, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
431 "ippget-event-life", 15);
432
433 /* job-cancel-after-supported */
434 ippAddRange(CommonData, IPP_TAG_PRINTER, "job-cancel-after-supported",
435 0, INT_MAX);
436
437 /* job-creation-attributes-supported */
438 ippAddStrings(CommonData, IPP_TAG_PRINTER, IPP_TAG_KEYWORD | IPP_TAG_COPY,
439 "job-creation-attributes-supported",
440 sizeof(job_creation) / sizeof(job_creation[0]),
441 NULL, job_creation);
442
443 /* job-hold-until-supported */
444 ippAddStrings(CommonData, IPP_TAG_PRINTER, IPP_TAG_KEYWORD | IPP_TAG_COPY,
445 "job-hold-until-supported", sizeof(holds) / sizeof(holds[0]),
446 NULL, holds);
447
448 /* job-ids-supported */
449 ippAddBoolean(CommonData, IPP_TAG_PRINTER, "job-ids-supported", 1);
450
451 /* job-k-octets-supported */
452 ippAddRange(CommonData, IPP_TAG_PRINTER, "job-k-octets-supported", 0,
453 k_supported);
454
455 /* job-priority-supported */
456 ippAddInteger(CommonData, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
457 "job-priority-supported", 100);
458
459 /* job-settable-attributes-supported */
460 ippAddStrings(CommonData, IPP_TAG_PRINTER, IPP_TAG_KEYWORD | IPP_TAG_COPY,
461 "job-settable-attributes-supported",
462 sizeof(job_settable) / sizeof(job_settable[0]),
463 NULL, job_settable);
464
465 /* job-sheets-supported */
466 if (cupsArrayCount(Banners) > 0)
467 {
468 /*
469 * Setup the job-sheets-supported attribute...
470 */
471
472 if (Classification && !ClassifyOverride)
473 attr = ippAddString(CommonData, IPP_TAG_PRINTER,
474 IPP_TAG_NAME | IPP_TAG_COPY,
475 "job-sheets-supported", NULL, Classification);
476 else
477 attr = ippAddStrings(CommonData, IPP_TAG_PRINTER,
478 IPP_TAG_NAME | IPP_TAG_COPY,
479 "job-sheets-supported", cupsArrayCount(Banners) + 1,
480 NULL, NULL);
481
482 if (attr == NULL)
483 cupsdLogMessage(CUPSD_LOG_EMERG,
484 "Unable to allocate memory for "
485 "job-sheets-supported attribute: %s!", strerror(errno));
486 else if (!Classification || ClassifyOverride)
487 {
488 cupsd_banner_t *banner; /* Current banner */
489
490
491 attr->values[0].string.text = _cupsStrAlloc("none");
492
493 for (i = 1, banner = (cupsd_banner_t *)cupsArrayFirst(Banners);
494 banner;
495 i ++, banner = (cupsd_banner_t *)cupsArrayNext(Banners))
496 attr->values[i].string.text = banner->name;
497 }
498 }
499 else
500 ippAddString(CommonData, IPP_TAG_PRINTER, IPP_TAG_NAME | IPP_TAG_COPY,
501 "job-sheets-supported", NULL, "none");
502
503 /* jpeg-k-octets-supported */
504 ippAddRange(CommonData, IPP_TAG_PRINTER, "jpeg-k-octets-supported", 0,
505 k_supported);
506
507 /* jpeg-x-dimension-supported */
508 ippAddRange(CommonData, IPP_TAG_PRINTER, "jpeg-x-dimension-supported", 0,
509 65535);
510
511 /* jpeg-y-dimension-supported */
512 ippAddRange(CommonData, IPP_TAG_PRINTER, "jpeg-y-dimension-supported", 1,
513 65535);
514
515 /* media-col-supported */
516 ippAddStrings(CommonData, IPP_TAG_PRINTER, IPP_TAG_KEYWORD | IPP_TAG_COPY,
517 "media-col-supported",
518 sizeof(media_col_supported) /
519 sizeof(media_col_supported[0]), NULL,
520 media_col_supported);
521
522 /* multiple-document-handling-supported */
523 ippAddStrings(CommonData, IPP_TAG_PRINTER, IPP_TAG_KEYWORD | IPP_TAG_COPY,
524 "multiple-document-handling-supported",
525 sizeof(multiple_document_handling) /
526 sizeof(multiple_document_handling[0]), NULL,
527 multiple_document_handling);
528
529 /* multiple-document-jobs-supported */
530 ippAddBoolean(CommonData, IPP_TAG_PRINTER,
531 "multiple-document-jobs-supported", 1);
532
533 /* multiple-operation-time-out */
534 ippAddInteger(CommonData, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
535 "multiple-operation-time-out", MultipleOperationTimeout);
536
537 /* natural-language-configured (no IPP_TAG_COPY) */
538 ippAddString(CommonData, IPP_TAG_PRINTER, IPP_TAG_LANGUAGE,
539 "natural-language-configured", NULL, DefaultLanguage);
540
541 /* notify-attributes-supported */
542 ippAddStrings(CommonData, IPP_TAG_PRINTER, IPP_TAG_KEYWORD | IPP_TAG_COPY,
543 "notify-attributes-supported",
544 (int)(sizeof(notify_attrs) / sizeof(notify_attrs[0])),
545 NULL, notify_attrs);
546
547 /* notify-lease-duration-supported */
548 ippAddRange(CommonData, IPP_TAG_PRINTER,
549 "notify-lease-duration-supported", 0,
550 MaxLeaseDuration ? MaxLeaseDuration : 2147483647);
551
552 /* notify-max-events-supported */
553 ippAddInteger(CommonData, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
554 "notify-max-events-supported", MaxEvents);
555
556 /* notify-events-supported */
557 ippAddStrings(CommonData, IPP_TAG_PRINTER, IPP_TAG_KEYWORD | IPP_TAG_COPY,
558 "notify-events-supported",
559 (int)(sizeof(notify_events) / sizeof(notify_events[0])),
560 NULL, notify_events);
561
562 /* notify-pull-method-supported */
563 ippAddString(CommonData, IPP_TAG_PRINTER, IPP_TAG_KEYWORD | IPP_TAG_COPY,
564 "notify-pull-method-supported", NULL, "ippget");
565
566 /* notify-schemes-supported */
567 snprintf(filename, sizeof(filename), "%s/notifier", ServerBin);
568 if ((dir = cupsDirOpen(filename)) != NULL)
569 {
570 notifiers = cupsArrayNew((cups_array_func_t)strcmp, NULL);
571
572 while ((dent = cupsDirRead(dir)) != NULL)
573 if (S_ISREG(dent->fileinfo.st_mode) &&
574 (dent->fileinfo.st_mode & S_IXOTH) != 0)
575 cupsArrayAdd(notifiers, _cupsStrAlloc(dent->filename));
576
577 if (cupsArrayCount(notifiers) > 0)
578 {
579 attr = ippAddStrings(CommonData, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
580 "notify-schemes-supported",
581 cupsArrayCount(notifiers), NULL, NULL);
582
583 for (i = 0, notifier = (char *)cupsArrayFirst(notifiers);
584 notifier;
585 i ++, notifier = (char *)cupsArrayNext(notifiers))
586 attr->values[i].string.text = notifier;
587 }
588
589 cupsArrayDelete(notifiers);
590 cupsDirClose(dir);
591 }
592
593 /* number-up-supported */
594 ippAddIntegers(CommonData, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
595 "number-up-supported", sizeof(nups) / sizeof(nups[0]), nups);
596
597 /* operations-supported */
598 ippAddIntegers(CommonData, IPP_TAG_PRINTER, IPP_TAG_ENUM,
599 "operations-supported", sizeof(ops) / sizeof(ops[0]), ops);
600
601 /* orientation-requested-supported */
602 ippAddIntegers(CommonData, IPP_TAG_PRINTER, IPP_TAG_ENUM,
603 "orientation-requested-supported", 4, orients);
604
605 /* page-ranges-supported */
606 ippAddBoolean(CommonData, IPP_TAG_PRINTER, "page-ranges-supported", 1);
607
608 /* pdf-k-octets-supported */
609 ippAddRange(CommonData, IPP_TAG_PRINTER, "pdf-k-octets-supported", 0,
610 k_supported);
611
612 /* pdf-versions-supported */
613 ippAddStrings(CommonData, IPP_TAG_PRINTER, IPP_TAG_KEYWORD | IPP_TAG_COPY,
614 "pdf-versions-supported",
615 sizeof(pdf_versions) / sizeof(pdf_versions[0]), NULL,
616 pdf_versions);
617
618 /* pdl-override-supported */
619 ippAddString(CommonData, IPP_TAG_PRINTER, IPP_TAG_KEYWORD | IPP_TAG_COPY,
620 "pdl-override-supported", NULL, "attempted");
621
622 /* printer-op-policy-supported */
623 attr = ippAddStrings(CommonData, IPP_TAG_PRINTER, IPP_TAG_NAME | IPP_TAG_COPY,
624 "printer-op-policy-supported", cupsArrayCount(Policies),
625 NULL, NULL);
626 for (i = 0, p = (cupsd_policy_t *)cupsArrayFirst(Policies);
627 p;
628 i ++, p = (cupsd_policy_t *)cupsArrayNext(Policies))
629 attr->values[i].string.text = p->name;
630
631 /* printer-settable-attributes-supported */
632 ippAddStrings(CommonData, IPP_TAG_PRINTER, IPP_TAG_KEYWORD | IPP_TAG_COPY,
633 "printer-settable-attributes-supported",
634 sizeof(printer_settable) / sizeof(printer_settable[0]),
635 NULL, printer_settable);
636
637 /* server-is-sharing-printers */
638 ippAddBoolean(CommonData, IPP_TAG_PRINTER, "server-is-sharing-printers",
639 BrowseLocalProtocols != 0 && Browsing);
640
641 /* which-jobs-supported */
642 ippAddStrings(CommonData, IPP_TAG_PRINTER, IPP_TAG_KEYWORD | IPP_TAG_COPY,
643 "which-jobs-supported",
644 sizeof(which_jobs) / sizeof(which_jobs[0]), NULL, which_jobs);
645 }
646
647
648 /*
649 * 'cupsdDeleteAllPrinters()' - Delete all printers from the system.
650 */
651
652 void
653 cupsdDeleteAllPrinters(void)
654 {
655 cupsd_printer_t *p; /* Pointer to current printer/class */
656
657
658 for (p = (cupsd_printer_t *)cupsArrayFirst(Printers);
659 p;
660 p = (cupsd_printer_t *)cupsArrayNext(Printers))
661 {
662 p->op_policy_ptr = DefaultPolicyPtr;
663 cupsdDeletePrinter(p, 0);
664 }
665 }
666
667
668 /*
669 * 'cupsdDeletePrinter()' - Delete a printer from the system.
670 */
671
672 int /* O - 1 if classes affected, 0 otherwise */
673 cupsdDeletePrinter(
674 cupsd_printer_t *p, /* I - Printer to delete */
675 int update) /* I - Update printers.conf? */
676 {
677 int i, /* Looping var */
678 changed = 0; /* Class changed? */
679
680
681 cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdDeletePrinter(p=%p(%s), update=%d)",
682 p, p->name, update);
683
684 /*
685 * Save the current position in the Printers array...
686 */
687
688 cupsArraySave(Printers);
689
690 /*
691 * Stop printing on this printer...
692 */
693
694 cupsdSetPrinterState(p, IPP_PRINTER_STOPPED, update);
695
696 p->state = IPP_PRINTER_STOPPED; /* Force for browsed printers */
697
698 if (p->job)
699 cupsdSetJobState(p->job, IPP_JOB_PENDING, CUPSD_JOB_FORCE,
700 update ? "Job stopped due to printer being deleted." :
701 "Job stopped.");
702
703 /*
704 * Remove the printer from the list...
705 */
706
707 cupsdLogMessage(CUPSD_LOG_DEBUG2,
708 "cupsdDeletePrinter: Removing %s from Printers", p->name);
709 cupsArrayRemove(Printers, p);
710
711 /*
712 * If p is the default printer, assign a different one...
713 */
714
715 if (p == DefaultPrinter)
716 DefaultPrinter = NULL;
717
718 /*
719 * Remove this printer from any classes...
720 */
721
722 changed = cupsdDeletePrinterFromClasses(p);
723
724 /*
725 * Deregister from any browse protocols...
726 */
727
728 cupsdDeregisterPrinter(p, 1);
729
730 /*
731 * Free all memory used by the printer...
732 */
733
734 if (p->printers != NULL)
735 free(p->printers);
736
737 delete_printer_filters(p);
738
739 for (i = 0; i < p->num_reasons; i ++)
740 _cupsStrFree(p->reasons[i]);
741
742 ippDelete(p->attrs);
743 ippDelete(p->ppd_attrs);
744
745 mimeDeleteType(MimeDatabase, p->filetype);
746 mimeDeleteType(MimeDatabase, p->prefiltertype);
747
748 cupsdFreeStrings(&(p->users));
749 cupsdFreeQuotas(p);
750
751 cupsdClearString(&p->uri);
752 cupsdClearString(&p->hostname);
753 cupsdClearString(&p->name);
754 cupsdClearString(&p->location);
755 cupsdClearString(&p->make_model);
756 cupsdClearString(&p->info);
757 cupsdClearString(&p->job_sheets[0]);
758 cupsdClearString(&p->job_sheets[1]);
759 cupsdClearString(&p->device_uri);
760 cupsdClearString(&p->sanitized_device_uri);
761 cupsdClearString(&p->port_monitor);
762 cupsdClearString(&p->op_policy);
763 cupsdClearString(&p->error_policy);
764
765 cupsdClearString(&p->alert);
766 cupsdClearString(&p->alert_description);
767
768 #if defined(HAVE_DNSSD) || defined(HAVE_AVAHI)
769 cupsdClearString(&p->pdl);
770 cupsdClearString(&p->reg_name);
771 #endif /* HAVE_DNSSD || HAVE_AVAHI */
772
773 cupsArrayDelete(p->filetypes);
774
775 cupsFreeOptions(p->num_options, p->options);
776
777 free(p);
778
779 /*
780 * Restore the previous position in the Printers array...
781 */
782
783 cupsArrayRestore(Printers);
784
785 return (changed);
786 }
787
788
789 /*
790 * 'cupsdFindDest()' - Find a destination in the list.
791 */
792
793 cupsd_printer_t * /* O - Destination in list */
794 cupsdFindDest(const char *name) /* I - Name of printer or class to find */
795 {
796 cupsd_printer_t key; /* Search key */
797
798
799 key.name = (char *)name;
800 return ((cupsd_printer_t *)cupsArrayFind(Printers, &key));
801 }
802
803
804 /*
805 * 'cupsdFindPrinter()' - Find a printer in the list.
806 */
807
808 cupsd_printer_t * /* O - Printer in list */
809 cupsdFindPrinter(const char *name) /* I - Name of printer to find */
810 {
811 cupsd_printer_t *p; /* Printer in list */
812
813
814 if ((p = cupsdFindDest(name)) != NULL && (p->type & CUPS_PRINTER_CLASS))
815 return (NULL);
816 else
817 return (p);
818 }
819
820
821 /*
822 * 'cupsdLoadAllPrinters()' - Load printers from the printers.conf file.
823 */
824
825 void
826 cupsdLoadAllPrinters(void)
827 {
828 int i; /* Looping var */
829 cups_file_t *fp; /* printers.conf file */
830 int linenum; /* Current line number */
831 char line[4096], /* Line from file */
832 *value, /* Pointer to value */
833 *valueptr; /* Pointer into value */
834 cupsd_printer_t *p; /* Current printer */
835
836
837 /*
838 * Open the printers.conf file...
839 */
840
841 snprintf(line, sizeof(line), "%s/printers.conf", ServerRoot);
842 if ((fp = cupsdOpenConfFile(line)) == NULL)
843 return;
844
845 /*
846 * Read printer configurations until we hit EOF...
847 */
848
849 linenum = 0;
850 p = NULL;
851
852 while (cupsFileGetConf(fp, line, sizeof(line), &value, &linenum))
853 {
854 /*
855 * Decode the directive...
856 */
857
858 if (!_cups_strcasecmp(line, "<Printer") ||
859 !_cups_strcasecmp(line, "<DefaultPrinter"))
860 {
861 /*
862 * <Printer name> or <DefaultPrinter name>
863 */
864
865 if (p == NULL && value)
866 {
867 /*
868 * Add the printer and a base file type...
869 */
870
871 cupsdLogMessage(CUPSD_LOG_DEBUG, "Loading printer %s...", value);
872
873 p = cupsdAddPrinter(value);
874 p->accepting = 1;
875 p->state = IPP_PRINTER_IDLE;
876
877 /*
878 * Set the default printer as needed...
879 */
880
881 if (!_cups_strcasecmp(line, "<DefaultPrinter"))
882 DefaultPrinter = p;
883 }
884 else
885 cupsdLogMessage(CUPSD_LOG_ERROR,
886 "Syntax error on line %d of printers.conf.", linenum);
887 }
888 else if (!_cups_strcasecmp(line, "</Printer>"))
889 {
890 if (p != NULL)
891 {
892 /*
893 * Close out the current printer...
894 */
895
896 cupsdSetPrinterAttrs(p);
897
898 if (strncmp(p->device_uri, "file:", 5) &&
899 p->state != IPP_PRINTER_STOPPED)
900 {
901 /*
902 * See if the backend exists...
903 */
904
905 snprintf(line, sizeof(line), "%s/backend/%s", ServerBin,
906 p->device_uri);
907
908 if ((valueptr = strchr(line + strlen(ServerBin), ':')) != NULL)
909 *valueptr = '\0'; /* Chop everything but URI scheme */
910
911 if (access(line, 0))
912 {
913 /*
914 * Backend does not exist, stop printer...
915 */
916
917 p->state = IPP_PRINTER_STOPPED;
918 snprintf(p->state_message, sizeof(p->state_message),
919 "Backend %s does not exist!", line);
920 }
921 }
922
923 p = NULL;
924 }
925 else
926 cupsdLogMessage(CUPSD_LOG_ERROR,
927 "Syntax error on line %d of printers.conf.", linenum);
928 }
929 else if (!p)
930 {
931 cupsdLogMessage(CUPSD_LOG_ERROR,
932 "Syntax error on line %d of printers.conf.", linenum);
933 }
934 else if (!_cups_strcasecmp(line, "UUID"))
935 {
936 if (value && !strncmp(value, "urn:uuid:", 9))
937 cupsdSetString(&(p->uuid), value);
938 else
939 cupsdLogMessage(CUPSD_LOG_ERROR,
940 "Bad UUID on line %d of printers.conf.", linenum);
941 }
942 else if (!_cups_strcasecmp(line, "AuthInfoRequired"))
943 {
944 if (!cupsdSetAuthInfoRequired(p, value, NULL))
945 cupsdLogMessage(CUPSD_LOG_ERROR,
946 "Bad AuthInfoRequired on line %d of printers.conf.",
947 linenum);
948 }
949 else if (!_cups_strcasecmp(line, "Info"))
950 {
951 if (value)
952 cupsdSetString(&p->info, value);
953 }
954 else if (!_cups_strcasecmp(line, "MakeModel"))
955 {
956 if (value)
957 cupsdSetString(&p->make_model, value);
958 }
959 else if (!_cups_strcasecmp(line, "Location"))
960 {
961 if (value)
962 cupsdSetString(&p->location, value);
963 }
964 else if (!_cups_strcasecmp(line, "DeviceURI"))
965 {
966 if (value)
967 cupsdSetDeviceURI(p, value);
968 else
969 cupsdLogMessage(CUPSD_LOG_ERROR,
970 "Syntax error on line %d of printers.conf.", linenum);
971 }
972 else if (!_cups_strcasecmp(line, "Option") && value)
973 {
974 /*
975 * Option name value
976 */
977
978 for (valueptr = value; *valueptr && !isspace(*valueptr & 255); valueptr ++);
979
980 if (!*valueptr)
981 cupsdLogMessage(CUPSD_LOG_ERROR,
982 "Syntax error on line %d of printers.conf.", linenum);
983 else
984 {
985 for (; *valueptr && isspace(*valueptr & 255); *valueptr++ = '\0');
986
987 p->num_options = cupsAddOption(value, valueptr, p->num_options,
988 &(p->options));
989 }
990 }
991 else if (!_cups_strcasecmp(line, "PortMonitor"))
992 {
993 if (value && strcmp(value, "none"))
994 cupsdSetString(&p->port_monitor, value);
995 else if (value)
996 cupsdClearString(&p->port_monitor);
997 else
998 cupsdLogMessage(CUPSD_LOG_ERROR,
999 "Syntax error on line %d of printers.conf.", linenum);
1000 }
1001 else if (!_cups_strcasecmp(line, "Reason"))
1002 {
1003 if (value &&
1004 strcmp(value, "connecting-to-device") &&
1005 strcmp(value, "cups-insecure-filter-warning") &&
1006 strcmp(value, "cups-missing-filter-warning"))
1007 {
1008 for (i = 0 ; i < p->num_reasons; i ++)
1009 if (!strcmp(value, p->reasons[i]))
1010 break;
1011
1012 if (i >= p->num_reasons &&
1013 p->num_reasons < (int)(sizeof(p->reasons) / sizeof(p->reasons[0])))
1014 {
1015 p->reasons[p->num_reasons] = _cupsStrAlloc(value);
1016 p->num_reasons ++;
1017 }
1018 }
1019 else
1020 cupsdLogMessage(CUPSD_LOG_ERROR,
1021 "Syntax error on line %d of printers.conf.", linenum);
1022 }
1023 else if (!_cups_strcasecmp(line, "State"))
1024 {
1025 /*
1026 * Set the initial queue state...
1027 */
1028
1029 if (value && !_cups_strcasecmp(value, "idle"))
1030 p->state = IPP_PRINTER_IDLE;
1031 else if (value && !_cups_strcasecmp(value, "stopped"))
1032 {
1033 p->state = IPP_PRINTER_STOPPED;
1034
1035 for (i = 0 ; i < p->num_reasons; i ++)
1036 if (!strcmp("paused", p->reasons[i]))
1037 break;
1038
1039 if (i >= p->num_reasons &&
1040 p->num_reasons < (int)(sizeof(p->reasons) / sizeof(p->reasons[0])))
1041 {
1042 p->reasons[p->num_reasons] = _cupsStrAlloc("paused");
1043 p->num_reasons ++;
1044 }
1045 }
1046 else
1047 cupsdLogMessage(CUPSD_LOG_ERROR,
1048 "Syntax error on line %d of printers.conf.", linenum);
1049 }
1050 else if (!_cups_strcasecmp(line, "StateMessage"))
1051 {
1052 /*
1053 * Set the initial queue state message...
1054 */
1055
1056 if (value)
1057 strlcpy(p->state_message, value, sizeof(p->state_message));
1058 }
1059 else if (!_cups_strcasecmp(line, "StateTime"))
1060 {
1061 /*
1062 * Set the state time...
1063 */
1064
1065 if (value)
1066 p->state_time = atoi(value);
1067 }
1068 else if (!_cups_strcasecmp(line, "Accepting"))
1069 {
1070 /*
1071 * Set the initial accepting state...
1072 */
1073
1074 if (value &&
1075 (!_cups_strcasecmp(value, "yes") ||
1076 !_cups_strcasecmp(value, "on") ||
1077 !_cups_strcasecmp(value, "true")))
1078 p->accepting = 1;
1079 else if (value &&
1080 (!_cups_strcasecmp(value, "no") ||
1081 !_cups_strcasecmp(value, "off") ||
1082 !_cups_strcasecmp(value, "false")))
1083 p->accepting = 0;
1084 else
1085 cupsdLogMessage(CUPSD_LOG_ERROR,
1086 "Syntax error on line %d of printers.conf.", linenum);
1087 }
1088 else if (!_cups_strcasecmp(line, "Type"))
1089 {
1090 if (value)
1091 p->type = (cups_ptype_t)atoi(value);
1092 else
1093 cupsdLogMessage(CUPSD_LOG_ERROR,
1094 "Syntax error on line %d of printers.conf.", linenum);
1095 }
1096 else if (!_cups_strcasecmp(line, "Shared"))
1097 {
1098 /*
1099 * Set the initial shared state...
1100 */
1101
1102 if (value &&
1103 (!_cups_strcasecmp(value, "yes") ||
1104 !_cups_strcasecmp(value, "on") ||
1105 !_cups_strcasecmp(value, "true")))
1106 p->shared = 1;
1107 else if (value &&
1108 (!_cups_strcasecmp(value, "no") ||
1109 !_cups_strcasecmp(value, "off") ||
1110 !_cups_strcasecmp(value, "false")))
1111 p->shared = 0;
1112 else
1113 cupsdLogMessage(CUPSD_LOG_ERROR,
1114 "Syntax error on line %d of printers.conf.", linenum);
1115 }
1116 else if (!_cups_strcasecmp(line, "JobSheets"))
1117 {
1118 /*
1119 * Set the initial job sheets...
1120 */
1121
1122 if (value)
1123 {
1124 for (valueptr = value; *valueptr && !isspace(*valueptr & 255); valueptr ++);
1125
1126 if (*valueptr)
1127 *valueptr++ = '\0';
1128
1129 cupsdSetString(&p->job_sheets[0], value);
1130
1131 while (isspace(*valueptr & 255))
1132 valueptr ++;
1133
1134 if (*valueptr)
1135 {
1136 for (value = valueptr; *valueptr && !isspace(*valueptr & 255); valueptr ++);
1137
1138 if (*valueptr)
1139 *valueptr = '\0';
1140
1141 cupsdSetString(&p->job_sheets[1], value);
1142 }
1143 }
1144 else
1145 cupsdLogMessage(CUPSD_LOG_ERROR,
1146 "Syntax error on line %d of printers.conf.", linenum);
1147 }
1148 else if (!_cups_strcasecmp(line, "AllowUser"))
1149 {
1150 if (value)
1151 {
1152 p->deny_users = 0;
1153 cupsdAddString(&(p->users), value);
1154 }
1155 else
1156 cupsdLogMessage(CUPSD_LOG_ERROR,
1157 "Syntax error on line %d of printers.conf.", linenum);
1158 }
1159 else if (!_cups_strcasecmp(line, "DenyUser"))
1160 {
1161 if (value)
1162 {
1163 p->deny_users = 1;
1164 cupsdAddString(&(p->users), value);
1165 }
1166 else
1167 cupsdLogMessage(CUPSD_LOG_ERROR,
1168 "Syntax error on line %d of printers.conf.", linenum);
1169 }
1170 else if (!_cups_strcasecmp(line, "QuotaPeriod"))
1171 {
1172 if (value)
1173 p->quota_period = atoi(value);
1174 else
1175 cupsdLogMessage(CUPSD_LOG_ERROR,
1176 "Syntax error on line %d of printers.conf.", linenum);
1177 }
1178 else if (!_cups_strcasecmp(line, "PageLimit"))
1179 {
1180 if (value)
1181 p->page_limit = atoi(value);
1182 else
1183 cupsdLogMessage(CUPSD_LOG_ERROR,
1184 "Syntax error on line %d of printers.conf.", linenum);
1185 }
1186 else if (!_cups_strcasecmp(line, "KLimit"))
1187 {
1188 if (value)
1189 p->k_limit = atoi(value);
1190 else
1191 cupsdLogMessage(CUPSD_LOG_ERROR,
1192 "Syntax error on line %d of printers.conf.", linenum);
1193 }
1194 else if (!_cups_strcasecmp(line, "OpPolicy"))
1195 {
1196 if (value)
1197 {
1198 cupsd_policy_t *pol; /* Policy */
1199
1200
1201 if ((pol = cupsdFindPolicy(value)) != NULL)
1202 {
1203 cupsdSetString(&p->op_policy, value);
1204 p->op_policy_ptr = pol;
1205 }
1206 else
1207 cupsdLogMessage(CUPSD_LOG_ERROR,
1208 "Bad policy \"%s\" on line %d of printers.conf",
1209 value, linenum);
1210 }
1211 else
1212 cupsdLogMessage(CUPSD_LOG_ERROR,
1213 "Syntax error on line %d of printers.conf.", linenum);
1214 }
1215 else if (!_cups_strcasecmp(line, "ErrorPolicy"))
1216 {
1217 if (value)
1218 cupsdSetString(&p->error_policy, value);
1219 else
1220 cupsdLogMessage(CUPSD_LOG_ERROR,
1221 "Syntax error on line %d of printers.conf.", linenum);
1222 }
1223 else if (!_cups_strcasecmp(line, "Attribute") && value)
1224 {
1225 for (valueptr = value; *valueptr && !isspace(*valueptr & 255); valueptr ++);
1226
1227 if (!*valueptr)
1228 cupsdLogMessage(CUPSD_LOG_ERROR,
1229 "Syntax error on line %d of printers.conf.", linenum);
1230 else
1231 {
1232 for (; *valueptr && isspace(*valueptr & 255); *valueptr++ = '\0');
1233
1234 if (!p->attrs)
1235 cupsdSetPrinterAttrs(p);
1236
1237 if (!strcmp(value, "marker-change-time"))
1238 p->marker_time = atoi(valueptr);
1239 else
1240 cupsdSetPrinterAttr(p, value, valueptr);
1241 }
1242 }
1243 else if (_cups_strcasecmp(line, "Filter") &&
1244 _cups_strcasecmp(line, "Prefilter") &&
1245 _cups_strcasecmp(line, "Product"))
1246 {
1247 /*
1248 * Something else we don't understand (and that wasn't used in a prior
1249 * release of CUPS...
1250 */
1251
1252 cupsdLogMessage(CUPSD_LOG_ERROR,
1253 "Unknown configuration directive %s on line %d of "
1254 "printers.conf.", line, linenum);
1255 }
1256 }
1257
1258 cupsFileClose(fp);
1259 }
1260
1261
1262 /*
1263 * 'cupsdRenamePrinter()' - Rename a printer.
1264 */
1265
1266 void
1267 cupsdRenamePrinter(
1268 cupsd_printer_t *p, /* I - Printer */
1269 const char *name) /* I - New name */
1270 {
1271 /*
1272 * Remove the printer from the array(s) first...
1273 */
1274
1275 cupsdLogMessage(CUPSD_LOG_DEBUG2,
1276 "cupsdRenamePrinter: Removing %s from Printers", p->name);
1277 cupsArrayRemove(Printers, p);
1278
1279 /*
1280 * Rename the printer type...
1281 */
1282
1283 mimeDeleteType(MimeDatabase, p->filetype);
1284 p->filetype = mimeAddType(MimeDatabase, "printer", name);
1285
1286 if (p->prefiltertype)
1287 {
1288 mimeDeleteType(MimeDatabase, p->prefiltertype);
1289 p->prefiltertype = mimeAddType(MimeDatabase, "prefilter", name);
1290 }
1291
1292 /*
1293 * Rename the printer...
1294 */
1295
1296 cupsdSetString(&p->name, name);
1297
1298 /*
1299 * Reset printer attributes...
1300 */
1301
1302 cupsdSetPrinterAttrs(p);
1303
1304 /*
1305 * Add the printer back to the printer array(s)...
1306 */
1307
1308 cupsdLogMessage(CUPSD_LOG_DEBUG2,
1309 "cupsdRenamePrinter: Adding %s to Printers", p->name);
1310 cupsArrayAdd(Printers, p);
1311 }
1312
1313
1314 /*
1315 * 'cupsdSaveAllPrinters()' - Save all printer definitions to the printers.conf
1316 * file.
1317 */
1318
1319 void
1320 cupsdSaveAllPrinters(void)
1321 {
1322 int i; /* Looping var */
1323 cups_file_t *fp; /* printers.conf file */
1324 char filename[1024], /* printers.conf filename */
1325 temp[1024], /* Temporary string */
1326 value[2048], /* Value string */
1327 *ptr, /* Pointer into value */
1328 *name; /* Current user/group name */
1329 cupsd_printer_t *printer; /* Current printer class */
1330 time_t curtime; /* Current time */
1331 struct tm *curdate; /* Current date */
1332 cups_option_t *option; /* Current option */
1333 ipp_attribute_t *marker; /* Current marker attribute */
1334
1335
1336 /*
1337 * Create the printers.conf file...
1338 */
1339
1340 snprintf(filename, sizeof(filename), "%s/printers.conf", ServerRoot);
1341
1342 if ((fp = cupsdCreateConfFile(filename, ConfigFilePerm & 0600)) == NULL)
1343 return;
1344
1345 cupsdLogMessage(CUPSD_LOG_INFO, "Saving printers.conf...");
1346
1347 /*
1348 * Write a small header to the file...
1349 */
1350
1351 curtime = time(NULL);
1352 curdate = localtime(&curtime);
1353 strftime(temp, sizeof(temp) - 1, "%Y-%m-%d %H:%M", curdate);
1354
1355 cupsFilePuts(fp, "# Printer configuration file for " CUPS_SVERSION "\n");
1356 cupsFilePrintf(fp, "# Written by cupsd on %s\n", temp);
1357 cupsFilePuts(fp, "# DO NOT EDIT THIS FILE WHEN CUPSD IS RUNNING\n");
1358
1359 /*
1360 * Write each local printer known to the system...
1361 */
1362
1363 for (printer = (cupsd_printer_t *)cupsArrayFirst(Printers);
1364 printer;
1365 printer = (cupsd_printer_t *)cupsArrayNext(Printers))
1366 {
1367 /*
1368 * Skip printer classes...
1369 */
1370
1371 if (printer->type & CUPS_PRINTER_CLASS)
1372 continue;
1373
1374 /*
1375 * Write printers as needed...
1376 */
1377
1378 if (printer == DefaultPrinter)
1379 cupsFilePrintf(fp, "<DefaultPrinter %s>\n", printer->name);
1380 else
1381 cupsFilePrintf(fp, "<Printer %s>\n", printer->name);
1382
1383 cupsFilePrintf(fp, "UUID %s\n", printer->uuid);
1384
1385 if (printer->num_auth_info_required > 0)
1386 {
1387 switch (printer->num_auth_info_required)
1388 {
1389 case 1 :
1390 strlcpy(value, printer->auth_info_required[0], sizeof(value));
1391 break;
1392
1393 case 2 :
1394 snprintf(value, sizeof(value), "%s,%s",
1395 printer->auth_info_required[0],
1396 printer->auth_info_required[1]);
1397 break;
1398
1399 case 3 :
1400 default :
1401 snprintf(value, sizeof(value), "%s,%s,%s",
1402 printer->auth_info_required[0],
1403 printer->auth_info_required[1],
1404 printer->auth_info_required[2]);
1405 break;
1406 }
1407
1408 cupsFilePutConf(fp, "AuthInfoRequired", value);
1409 }
1410
1411 if (printer->info)
1412 cupsFilePutConf(fp, "Info", printer->info);
1413
1414 if (printer->location)
1415 cupsFilePutConf(fp, "Location", printer->location);
1416
1417 if (printer->make_model)
1418 cupsFilePutConf(fp, "MakeModel", printer->make_model);
1419
1420 cupsFilePutConf(fp, "DeviceURI", printer->device_uri);
1421
1422 if (printer->port_monitor)
1423 cupsFilePutConf(fp, "PortMonitor", printer->port_monitor);
1424
1425 if (printer->state == IPP_PRINTER_STOPPED)
1426 {
1427 cupsFilePuts(fp, "State Stopped\n");
1428
1429 if (printer->state_message)
1430 cupsFilePutConf(fp, "StateMessage", printer->state_message);
1431 }
1432 else
1433 cupsFilePuts(fp, "State Idle\n");
1434
1435 cupsFilePrintf(fp, "StateTime %d\n", (int)printer->state_time);
1436
1437 for (i = 0; i < printer->num_reasons; i ++)
1438 if (strcmp(printer->reasons[i], "connecting-to-device") &&
1439 strcmp(printer->reasons[i], "cups-insecure-filter-warning") &&
1440 strcmp(printer->reasons[i], "cups-missing-filter-warning"))
1441 cupsFilePutConf(fp, "Reason", printer->reasons[i]);
1442
1443 cupsFilePrintf(fp, "Type %d\n", printer->type);
1444
1445 if (printer->accepting)
1446 cupsFilePuts(fp, "Accepting Yes\n");
1447 else
1448 cupsFilePuts(fp, "Accepting No\n");
1449
1450 if (printer->shared)
1451 cupsFilePuts(fp, "Shared Yes\n");
1452 else
1453 cupsFilePuts(fp, "Shared No\n");
1454
1455 snprintf(value, sizeof(value), "%s %s", printer->job_sheets[0],
1456 printer->job_sheets[1]);
1457 cupsFilePutConf(fp, "JobSheets", value);
1458
1459 cupsFilePrintf(fp, "QuotaPeriod %d\n", printer->quota_period);
1460 cupsFilePrintf(fp, "PageLimit %d\n", printer->page_limit);
1461 cupsFilePrintf(fp, "KLimit %d\n", printer->k_limit);
1462
1463 for (name = (char *)cupsArrayFirst(printer->users);
1464 name;
1465 name = (char *)cupsArrayNext(printer->users))
1466 cupsFilePutConf(fp, printer->deny_users ? "DenyUser" : "AllowUser", name);
1467
1468 if (printer->op_policy)
1469 cupsFilePutConf(fp, "OpPolicy", printer->op_policy);
1470 if (printer->error_policy)
1471 cupsFilePutConf(fp, "ErrorPolicy", printer->error_policy);
1472
1473 for (i = printer->num_options, option = printer->options;
1474 i > 0;
1475 i --, option ++)
1476 {
1477 snprintf(value, sizeof(value), "%s %s", option->name, option->value);
1478 cupsFilePutConf(fp, "Option", value);
1479 }
1480
1481 if ((marker = ippFindAttribute(printer->attrs, "marker-colors",
1482 IPP_TAG_NAME)) != NULL)
1483 {
1484 snprintf(value, sizeof(value), "%s ", marker->name);
1485
1486 for (i = 0, ptr = value + strlen(value);
1487 i < marker->num_values && ptr < (value + sizeof(value) - 1);
1488 i ++)
1489 {
1490 if (i)
1491 *ptr++ = ',';
1492
1493 strlcpy(ptr, marker->values[i].string.text, (size_t)(value + sizeof(value) - ptr));
1494 ptr += strlen(ptr);
1495 }
1496
1497 *ptr = '\0';
1498 cupsFilePutConf(fp, "Attribute", value);
1499 }
1500
1501 if ((marker = ippFindAttribute(printer->attrs, "marker-levels",
1502 IPP_TAG_INTEGER)) != NULL)
1503 {
1504 cupsFilePrintf(fp, "Attribute %s %d", marker->name,
1505 marker->values[0].integer);
1506 for (i = 1; i < marker->num_values; i ++)
1507 cupsFilePrintf(fp, ",%d", marker->values[i].integer);
1508 cupsFilePuts(fp, "\n");
1509 }
1510
1511 if ((marker = ippFindAttribute(printer->attrs, "marker-low-levels",
1512 IPP_TAG_INTEGER)) != NULL)
1513 {
1514 cupsFilePrintf(fp, "Attribute %s %d", marker->name,
1515 marker->values[0].integer);
1516 for (i = 1; i < marker->num_values; i ++)
1517 cupsFilePrintf(fp, ",%d", marker->values[i].integer);
1518 cupsFilePuts(fp, "\n");
1519 }
1520
1521 if ((marker = ippFindAttribute(printer->attrs, "marker-high-levels",
1522 IPP_TAG_INTEGER)) != NULL)
1523 {
1524 cupsFilePrintf(fp, "Attribute %s %d", marker->name,
1525 marker->values[0].integer);
1526 for (i = 1; i < marker->num_values; i ++)
1527 cupsFilePrintf(fp, ",%d", marker->values[i].integer);
1528 cupsFilePuts(fp, "\n");
1529 }
1530
1531 if ((marker = ippFindAttribute(printer->attrs, "marker-message",
1532 IPP_TAG_TEXT)) != NULL)
1533 {
1534 snprintf(value, sizeof(value), "%s %s", marker->name,
1535 marker->values[0].string.text);
1536
1537 cupsFilePutConf(fp, "Attribute", value);
1538 }
1539
1540 if ((marker = ippFindAttribute(printer->attrs, "marker-names",
1541 IPP_TAG_NAME)) != NULL)
1542 {
1543 snprintf(value, sizeof(value), "%s ", marker->name);
1544
1545 for (i = 0, ptr = value + strlen(value);
1546 i < marker->num_values && ptr < (value + sizeof(value) - 1);
1547 i ++)
1548 {
1549 if (i)
1550 *ptr++ = ',';
1551
1552 strlcpy(ptr, marker->values[i].string.text, (size_t)(value + sizeof(value) - ptr));
1553 ptr += strlen(ptr);
1554 }
1555
1556 *ptr = '\0';
1557 cupsFilePutConf(fp, "Attribute", value);
1558 }
1559
1560 if ((marker = ippFindAttribute(printer->attrs, "marker-types",
1561 IPP_TAG_KEYWORD)) != NULL)
1562 {
1563 snprintf(value, sizeof(value), "%s ", marker->name);
1564
1565 for (i = 0, ptr = value + strlen(value);
1566 i < marker->num_values && ptr < (value + sizeof(value) - 1);
1567 i ++)
1568 {
1569 if (i)
1570 *ptr++ = ',';
1571
1572 strlcpy(ptr, marker->values[i].string.text, (size_t)(value + sizeof(value) - ptr));
1573 ptr += strlen(ptr);
1574 }
1575
1576 *ptr = '\0';
1577 cupsFilePutConf(fp, "Attribute", value);
1578 }
1579
1580 if (printer->marker_time)
1581 cupsFilePrintf(fp, "Attribute marker-change-time %ld\n",
1582 (long)printer->marker_time);
1583
1584 cupsFilePuts(fp, "</Printer>\n");
1585 }
1586
1587 cupsdCloseCreatedConfFile(fp, filename);
1588 }
1589
1590
1591 /*
1592 * 'cupsdSetAuthInfoRequired()' - Set the required authentication info.
1593 */
1594
1595 int /* O - 1 if value OK, 0 otherwise */
1596 cupsdSetAuthInfoRequired(
1597 cupsd_printer_t *p, /* I - Printer */
1598 const char *values, /* I - Plain text value (or NULL) */
1599 ipp_attribute_t *attr) /* I - IPP attribute value (or NULL) */
1600 {
1601 int i; /* Looping var */
1602
1603
1604 p->num_auth_info_required = 0;
1605
1606 /*
1607 * Do we have a plain text value?
1608 */
1609
1610 if (values)
1611 {
1612 /*
1613 * Yes, grab the keywords...
1614 */
1615
1616 const char *end; /* End of current value */
1617
1618
1619 while (*values && p->num_auth_info_required < 4)
1620 {
1621 if ((end = strchr(values, ',')) == NULL)
1622 end = values + strlen(values);
1623
1624 if ((end - values) == 4 && !strncmp(values, "none", 4))
1625 {
1626 if (p->num_auth_info_required != 0 || *end)
1627 return (0);
1628
1629 p->auth_info_required[p->num_auth_info_required] = "none";
1630 p->num_auth_info_required ++;
1631
1632 return (1);
1633 }
1634 else if ((end - values) == 9 && !strncmp(values, "negotiate", 9))
1635 {
1636 if (p->num_auth_info_required != 0 || *end)
1637 return (0);
1638
1639 p->auth_info_required[p->num_auth_info_required] = "negotiate";
1640 p->num_auth_info_required ++;
1641
1642 /*
1643 * Don't allow sharing of queues that require Kerberos authentication.
1644 */
1645
1646 if (p->shared)
1647 {
1648 cupsdDeregisterPrinter(p, 1);
1649 p->shared = 0;
1650 }
1651 }
1652 else if ((end - values) == 6 && !strncmp(values, "domain", 6))
1653 {
1654 p->auth_info_required[p->num_auth_info_required] = "domain";
1655 p->num_auth_info_required ++;
1656 }
1657 else if ((end - values) == 8 && !strncmp(values, "password", 8))
1658 {
1659 p->auth_info_required[p->num_auth_info_required] = "password";
1660 p->num_auth_info_required ++;
1661 }
1662 else if ((end - values) == 8 && !strncmp(values, "username", 8))
1663 {
1664 p->auth_info_required[p->num_auth_info_required] = "username";
1665 p->num_auth_info_required ++;
1666 }
1667 else
1668 return (0);
1669
1670 values = (*end) ? end + 1 : end;
1671 }
1672
1673 if (p->num_auth_info_required == 0)
1674 {
1675 p->auth_info_required[0] = "none";
1676 p->num_auth_info_required = 1;
1677 }
1678
1679 /*
1680 * Update the printer-type value as needed...
1681 */
1682
1683 if (p->num_auth_info_required > 1 ||
1684 strcmp(p->auth_info_required[0], "none"))
1685 p->type |= CUPS_PRINTER_AUTHENTICATED;
1686 else
1687 p->type &= (cups_ptype_t)~CUPS_PRINTER_AUTHENTICATED;
1688
1689 return (1);
1690 }
1691
1692 /*
1693 * Grab values from an attribute instead...
1694 */
1695
1696 if (!attr || attr->num_values > 4)
1697 return (0);
1698
1699 for (i = 0; i < attr->num_values; i ++)
1700 {
1701 if (!strcmp(attr->values[i].string.text, "none"))
1702 {
1703 if (p->num_auth_info_required != 0 || attr->num_values != 1)
1704 return (0);
1705
1706 p->auth_info_required[p->num_auth_info_required] = "none";
1707 p->num_auth_info_required ++;
1708
1709 return (1);
1710 }
1711 else if (!strcmp(attr->values[i].string.text, "negotiate"))
1712 {
1713 if (p->num_auth_info_required != 0 || attr->num_values != 1)
1714 return (0);
1715
1716 p->auth_info_required[p->num_auth_info_required] = "negotiate";
1717 p->num_auth_info_required ++;
1718
1719 /*
1720 * Don't allow sharing of queues that require Kerberos authentication.
1721 */
1722
1723 if (p->shared)
1724 {
1725 cupsdDeregisterPrinter(p, 1);
1726 p->shared = 0;
1727 }
1728
1729 return (1);
1730 }
1731 else if (!strcmp(attr->values[i].string.text, "domain"))
1732 {
1733 p->auth_info_required[p->num_auth_info_required] = "domain";
1734 p->num_auth_info_required ++;
1735 }
1736 else if (!strcmp(attr->values[i].string.text, "password"))
1737 {
1738 p->auth_info_required[p->num_auth_info_required] = "password";
1739 p->num_auth_info_required ++;
1740 }
1741 else if (!strcmp(attr->values[i].string.text, "username"))
1742 {
1743 p->auth_info_required[p->num_auth_info_required] = "username";
1744 p->num_auth_info_required ++;
1745 }
1746 else
1747 return (0);
1748 }
1749
1750 return (1);
1751 }
1752
1753
1754 /*
1755 * 'cupsdSetDeviceURI()' - Set the device URI for a printer.
1756 */
1757
1758 void
1759 cupsdSetDeviceURI(cupsd_printer_t *p, /* I - Printer */
1760 const char *uri) /* I - Device URI */
1761 {
1762 char buffer[1024], /* URI buffer */
1763 *start, /* Start of data after scheme */
1764 *slash, /* First slash after scheme:// */
1765 *ptr; /* Pointer into user@host:port part */
1766
1767
1768 /*
1769 * Set the full device URI..
1770 */
1771
1772 cupsdSetString(&(p->device_uri), uri);
1773
1774 /*
1775 * Copy the device URI to a temporary buffer so we can sanitize any auth
1776 * info in it...
1777 */
1778
1779 strlcpy(buffer, uri, sizeof(buffer));
1780
1781 /*
1782 * Find the end of the scheme:// part...
1783 */
1784
1785 if ((ptr = strchr(buffer, ':')) != NULL)
1786 {
1787 for (start = ptr + 1; *start; start ++)
1788 if (*start != '/')
1789 break;
1790
1791 /*
1792 * Find the next slash (/) in the URI...
1793 */
1794
1795 if ((slash = strchr(start, '/')) == NULL)
1796 slash = start + strlen(start); /* No slash, point to the end */
1797
1798 /*
1799 * Check for an @ sign before the slash...
1800 */
1801
1802 if ((ptr = strchr(start, '@')) != NULL && ptr < slash)
1803 {
1804 /*
1805 * Found an @ sign and it is before the resource part, so we have
1806 * an authentication string. Copy the remaining URI over the
1807 * authentication string...
1808 */
1809
1810 _cups_strcpy(start, ptr + 1);
1811 }
1812 }
1813
1814 /*
1815 * Save the sanitized URI...
1816 */
1817
1818 cupsdSetString(&(p->sanitized_device_uri), buffer);
1819 }
1820
1821
1822 /*
1823 * 'cupsdSetPrinterAttr()' - Set a printer attribute.
1824 */
1825
1826 void
1827 cupsdSetPrinterAttr(
1828 cupsd_printer_t *p, /* I - Printer */
1829 const char *name, /* I - Attribute name */
1830 const char *value) /* I - Attribute value string */
1831 {
1832 ipp_attribute_t *attr; /* Attribute */
1833 int i, /* Looping var */
1834 count; /* Number of values */
1835 char *temp, /* Temporary copy of value string */
1836 *ptr, /* Pointer into value */
1837 *start, /* Start of value */
1838 quote; /* Quote character */
1839 ipp_tag_t value_tag; /* Value tag for this attribute */
1840
1841
1842 /*
1843 * Don't allow empty values...
1844 */
1845
1846 if (!*value && strcmp(name, "marker-message"))
1847 {
1848 cupsdLogMessage(CUPSD_LOG_ERROR, "Ignoring empty \"%s\" attribute", name);
1849 return;
1850 }
1851
1852 /*
1853 * Copy the value string so we can do what we want with it...
1854 */
1855
1856 if ((temp = strdup(value)) == NULL)
1857 {
1858 cupsdLogMessage(CUPSD_LOG_ERROR,
1859 "Unable to duplicate value for \"%s\" attribute.", name);
1860 return;
1861 }
1862
1863 /*
1864 * Count the number of values...
1865 */
1866
1867 for (count = 1, quote = '\0', ptr = temp;
1868 *ptr;
1869 ptr ++)
1870 {
1871 if (*ptr == quote)
1872 quote = '\0';
1873 else if (quote)
1874 continue;
1875 else if (*ptr == '\\' && ptr[1])
1876 ptr ++;
1877 else if (*ptr == '\'' || *ptr == '\"')
1878 quote = *ptr;
1879 else if (*ptr == ',')
1880 count ++;
1881 }
1882
1883 /*
1884 * Then add or update the attribute as needed...
1885 */
1886
1887 if (!strcmp(name, "marker-levels") || !strcmp(name, "marker-low-levels") ||
1888 !strcmp(name, "marker-high-levels"))
1889 {
1890 /*
1891 * Integer values...
1892 */
1893
1894 if ((attr = ippFindAttribute(p->attrs, name, IPP_TAG_INTEGER)) != NULL &&
1895 attr->num_values < count)
1896 {
1897 ippDeleteAttribute(p->attrs, attr);
1898 attr = NULL;
1899 }
1900
1901 if (attr)
1902 attr->num_values = count;
1903 else
1904 attr = ippAddIntegers(p->attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER, name,
1905 count, NULL);
1906
1907 if (!attr)
1908 {
1909 free(temp);
1910 cupsdLogMessage(CUPSD_LOG_ERROR,
1911 "Unable to allocate memory for printer attribute "
1912 "(%d values)", count);
1913 return;
1914 }
1915
1916 for (i = 0, start = temp; i < count; i ++)
1917 {
1918 if ((ptr = strchr(start, ',')) != NULL)
1919 *ptr++ = '\0';
1920
1921 attr->values[i].integer = strtol(start, NULL, 10);
1922
1923 if (ptr)
1924 start = ptr;
1925 }
1926 }
1927 else
1928 {
1929 /*
1930 * Name or keyword values...
1931 */
1932
1933 if (!strcmp(name, "marker-types"))
1934 value_tag = IPP_TAG_KEYWORD;
1935 else if (!strcmp(name, "marker-message"))
1936 value_tag = IPP_TAG_TEXT;
1937 else
1938 value_tag = IPP_TAG_NAME;
1939
1940 if ((attr = ippFindAttribute(p->attrs, name, value_tag)) != NULL &&
1941 attr->num_values < count)
1942 {
1943 ippDeleteAttribute(p->attrs, attr);
1944 attr = NULL;
1945 }
1946
1947 if (attr)
1948 {
1949 for (i = 0; i < attr->num_values; i ++)
1950 _cupsStrFree(attr->values[i].string.text);
1951
1952 attr->num_values = count;
1953 }
1954 else
1955 attr = ippAddStrings(p->attrs, IPP_TAG_PRINTER, value_tag, name,
1956 count, NULL, NULL);
1957
1958 if (!attr)
1959 {
1960 free(temp);
1961 cupsdLogMessage(CUPSD_LOG_ERROR,
1962 "Unable to allocate memory for printer attribute "
1963 "(%d values)", count);
1964 return;
1965 }
1966
1967 for (i = 0, quote = '\0', ptr = temp; i < count; i ++)
1968 {
1969 for (start = ptr; *ptr; ptr ++)
1970 {
1971 if (*ptr == quote)
1972 *ptr = quote = '\0';
1973 else if (quote)
1974 continue;
1975 else if (*ptr == '\\' && ptr[1])
1976 _cups_strcpy(ptr, ptr + 1);
1977 else if (*ptr == '\'' || *ptr == '\"')
1978 {
1979 quote = *ptr;
1980
1981 if (ptr == start)
1982 start ++;
1983 else
1984 _cups_strcpy(ptr, ptr + 1);
1985 }
1986 else if (*ptr == ',')
1987 {
1988 *ptr++ = '\0';
1989 break;
1990 }
1991 }
1992
1993 attr->values[i].string.text = _cupsStrAlloc(start);
1994 }
1995 }
1996
1997 free(temp);
1998 }
1999
2000
2001 /*
2002 * 'cupsdSetPrinterAttrs()' - Set printer attributes based upon the PPD file.
2003 */
2004
2005 void
2006 cupsdSetPrinterAttrs(cupsd_printer_t *p)/* I - Printer to setup */
2007 {
2008 int i; /* Looping var */
2009 char resource[HTTP_MAX_URI]; /* Resource portion of URI */
2010 cupsd_location_t *auth; /* Pointer to authentication element */
2011 const char *auth_supported; /* Authentication supported */
2012 ipp_t *oldattrs; /* Old printer attributes */
2013 ipp_attribute_t *attr; /* Attribute data */
2014 char *name, /* Current user/group name */
2015 *filter; /* Current filter */
2016
2017
2018 DEBUG_printf(("cupsdSetPrinterAttrs: entering name = %s, type = %x\n", p->name,
2019 p->type));
2020
2021 /*
2022 * Make sure that we have the common attributes defined...
2023 */
2024
2025 if (!CommonData)
2026 cupsdCreateCommonData();
2027
2028 /*
2029 * Clear out old filters, if any...
2030 */
2031
2032 delete_printer_filters(p);
2033
2034 /*
2035 * Figure out the authentication that is required for the printer.
2036 */
2037
2038 auth_supported = "requesting-user-name";
2039
2040 if (p->type & CUPS_PRINTER_CLASS)
2041 snprintf(resource, sizeof(resource), "/classes/%s", p->name);
2042 else
2043 snprintf(resource, sizeof(resource), "/printers/%s", p->name);
2044
2045 if ((auth = cupsdFindBest(resource, HTTP_POST)) == NULL ||
2046 auth->type == CUPSD_AUTH_NONE)
2047 auth = cupsdFindPolicyOp(p->op_policy_ptr, IPP_PRINT_JOB);
2048
2049 if (auth)
2050 {
2051 int auth_type; /* Authentication type */
2052
2053
2054 if ((auth_type = auth->type) == CUPSD_AUTH_DEFAULT)
2055 auth_type = cupsdDefaultAuthType();
2056
2057 if (auth_type == CUPSD_AUTH_BASIC || auth_type == CUPSD_AUTH_BASICDIGEST)
2058 auth_supported = "basic";
2059 else if (auth_type == CUPSD_AUTH_DIGEST)
2060 auth_supported = "digest";
2061 #ifdef HAVE_GSSAPI
2062 else if (auth_type == CUPSD_AUTH_NEGOTIATE)
2063 auth_supported = "negotiate";
2064 #endif /* HAVE_GSSAPI */
2065
2066 if (auth_type != CUPSD_AUTH_NONE)
2067 p->type |= CUPS_PRINTER_AUTHENTICATED;
2068 else
2069 p->type &= (cups_ptype_t)~CUPS_PRINTER_AUTHENTICATED;
2070 }
2071 else
2072 p->type &= (cups_ptype_t)~CUPS_PRINTER_AUTHENTICATED;
2073
2074 /*
2075 * Create the required IPP attributes for a printer...
2076 */
2077
2078 oldattrs = p->attrs;
2079 p->attrs = ippNew();
2080
2081 ippAddString(p->attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
2082 "uri-authentication-supported", NULL, auth_supported);
2083 ippAddString(p->attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
2084 "uri-security-supported", NULL, "none");
2085 ippAddString(p->attrs, IPP_TAG_PRINTER, IPP_TAG_NAME, "printer-name", NULL,
2086 p->name);
2087 ippAddString(p->attrs, IPP_TAG_PRINTER, IPP_TAG_TEXT, "printer-location",
2088 NULL, p->location ? p->location : "");
2089 ippAddString(p->attrs, IPP_TAG_PRINTER, IPP_TAG_TEXT, "printer-info",
2090 NULL, p->info ? p->info : "");
2091 ippAddString(p->attrs, IPP_TAG_PRINTER, IPP_TAG_URI, "printer-uuid", NULL,
2092 p->uuid);
2093
2094 if (cupsArrayCount(p->users) > 0)
2095 {
2096 if (p->deny_users)
2097 attr = ippAddStrings(p->attrs, IPP_TAG_PRINTER, IPP_TAG_NAME,
2098 "requesting-user-name-denied",
2099 cupsArrayCount(p->users), NULL, NULL);
2100 else
2101 attr = ippAddStrings(p->attrs, IPP_TAG_PRINTER, IPP_TAG_NAME,
2102 "requesting-user-name-allowed",
2103 cupsArrayCount(p->users), NULL, NULL);
2104
2105 for (i = 0, name = (char *)cupsArrayFirst(p->users);
2106 name;
2107 i ++, name = (char *)cupsArrayNext(p->users))
2108 attr->values[i].string.text = _cupsStrAlloc(name);
2109 }
2110
2111 ippAddInteger(p->attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
2112 "job-quota-period", p->quota_period);
2113 ippAddInteger(p->attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
2114 "job-k-limit", p->k_limit);
2115 ippAddInteger(p->attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
2116 "job-page-limit", p->page_limit);
2117 if (p->num_auth_info_required > 0 && strcmp(p->auth_info_required[0], "none"))
2118 ippAddStrings(p->attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
2119 "auth-info-required", p->num_auth_info_required, NULL,
2120 p->auth_info_required);
2121
2122 if (cupsArrayCount(Banners) > 0)
2123 {
2124 /*
2125 * Setup the job-sheets-default attribute...
2126 */
2127
2128 attr = ippAddStrings(p->attrs, IPP_TAG_PRINTER, IPP_TAG_NAME,
2129 "job-sheets-default", 2, NULL, NULL);
2130
2131 if (attr != NULL)
2132 {
2133 attr->values[0].string.text = _cupsStrAlloc(Classification ?
2134 Classification : p->job_sheets[0]);
2135 attr->values[1].string.text = _cupsStrAlloc(Classification ?
2136 Classification : p->job_sheets[1]);
2137 }
2138 }
2139
2140 p->raw = 0;
2141 p->remote = 0;
2142
2143 /*
2144 * Assign additional attributes depending on whether this is a printer
2145 * or class...
2146 */
2147
2148 if (p->type & CUPS_PRINTER_CLASS)
2149 {
2150 p->raw = 1;
2151 p->type &= (cups_ptype_t)~CUPS_PRINTER_OPTIONS;
2152
2153 /*
2154 * Add class-specific attributes...
2155 */
2156
2157 ippAddString(p->attrs, IPP_TAG_PRINTER, IPP_TAG_TEXT,
2158 "printer-make-and-model", NULL, "Local Printer Class");
2159 ippAddString(p->attrs, IPP_TAG_PRINTER, IPP_TAG_URI, "device-uri", NULL,
2160 "file:///dev/null");
2161
2162 if (p->num_printers > 0)
2163 {
2164 /*
2165 * Add a list of member names; URIs are added in copy_printer_attrs...
2166 */
2167
2168 attr = ippAddStrings(p->attrs, IPP_TAG_PRINTER, IPP_TAG_NAME,
2169 "member-names", p->num_printers, NULL, NULL);
2170 p->type |= CUPS_PRINTER_OPTIONS;
2171
2172 for (i = 0; i < p->num_printers; i ++)
2173 {
2174 if (attr != NULL)
2175 attr->values[i].string.text = _cupsStrAlloc(p->printers[i]->name);
2176
2177 p->type &= (cups_ptype_t)~CUPS_PRINTER_OPTIONS | p->printers[i]->type;
2178 }
2179 }
2180 }
2181 else
2182 {
2183 /*
2184 * Add printer-specific attributes...
2185 */
2186
2187 ippAddString(p->attrs, IPP_TAG_PRINTER, IPP_TAG_URI, "device-uri", NULL,
2188 p->sanitized_device_uri);
2189
2190 /*
2191 * Assign additional attributes from the PPD file (if any)...
2192 */
2193
2194 load_ppd(p);
2195
2196 /*
2197 * Add filters for printer...
2198 */
2199
2200 cupsdSetPrinterReasons(p, "-cups-missing-filter-warning,"
2201 "cups-insecure-filter-warning");
2202
2203 if (p->pc && p->pc->filters)
2204 {
2205 for (filter = (char *)cupsArrayFirst(p->pc->filters);
2206 filter;
2207 filter = (char *)cupsArrayNext(p->pc->filters))
2208 add_printer_filter(p, p->filetype, filter);
2209 }
2210 else if (!(p->type & CUPS_PRINTER_REMOTE))
2211 {
2212 char interface[1024]; /* Interface script */
2213
2214
2215 snprintf(interface, sizeof(interface), "%s/interfaces/%s", ServerRoot,
2216 p->name);
2217 if (!access(interface, X_OK))
2218 {
2219 /*
2220 * Yes, we have a System V style interface script; use it!
2221 */
2222
2223 snprintf(interface, sizeof(interface), "*/* 0 %s/interfaces/%s",
2224 ServerRoot, p->name);
2225 add_printer_filter(p, p->filetype, interface);
2226 }
2227 else
2228 {
2229 /*
2230 * Add a filter from application/vnd.cups-raw to printer/name to
2231 * handle "raw" printing by users.
2232 */
2233
2234 add_printer_filter(p, p->filetype, "application/vnd.cups-raw 0 -");
2235
2236 /*
2237 * Add a PostScript filter, since this is still possibly PS printer.
2238 */
2239
2240 add_printer_filter(p, p->filetype,
2241 "application/vnd.cups-postscript 0 -");
2242 }
2243 }
2244
2245 if (p->pc && p->pc->prefilters)
2246 {
2247 if (!p->prefiltertype)
2248 p->prefiltertype = mimeAddType(MimeDatabase, "prefilter", p->name);
2249
2250 for (filter = (char *)cupsArrayFirst(p->pc->prefilters);
2251 filter;
2252 filter = (char *)cupsArrayNext(p->pc->prefilters))
2253 add_printer_filter(p, p->prefiltertype, filter);
2254 }
2255 }
2256
2257 /*
2258 * Copy marker attributes as needed...
2259 */
2260
2261 if (oldattrs)
2262 {
2263 ipp_attribute_t *oldattr; /* Old attribute */
2264
2265
2266 if ((oldattr = ippFindAttribute(oldattrs, "marker-colors",
2267 IPP_TAG_NAME)) != NULL)
2268 {
2269 if ((attr = ippAddStrings(p->attrs, IPP_TAG_PRINTER, IPP_TAG_NAME,
2270 "marker-colors", oldattr->num_values, NULL,
2271 NULL)) != NULL)
2272 {
2273 for (i = 0; i < oldattr->num_values; i ++)
2274 attr->values[i].string.text =
2275 _cupsStrAlloc(oldattr->values[i].string.text);
2276 }
2277 }
2278
2279 if ((oldattr = ippFindAttribute(oldattrs, "marker-levels",
2280 IPP_TAG_INTEGER)) != NULL)
2281 {
2282 if ((attr = ippAddIntegers(p->attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
2283 "marker-levels", oldattr->num_values,
2284 NULL)) != NULL)
2285 {
2286 for (i = 0; i < oldattr->num_values; i ++)
2287 attr->values[i].integer = oldattr->values[i].integer;
2288 }
2289 }
2290
2291 if ((oldattr = ippFindAttribute(oldattrs, "marker-message",
2292 IPP_TAG_TEXT)) != NULL)
2293 ippAddString(p->attrs, IPP_TAG_PRINTER, IPP_TAG_TEXT, "marker-message",
2294 NULL, oldattr->values[0].string.text);
2295
2296 if ((oldattr = ippFindAttribute(oldattrs, "marker-low-levels",
2297 IPP_TAG_INTEGER)) != NULL)
2298 {
2299 if ((attr = ippAddIntegers(p->attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
2300 "marker-low-levels", oldattr->num_values,
2301 NULL)) != NULL)
2302 {
2303 for (i = 0; i < oldattr->num_values; i ++)
2304 attr->values[i].integer = oldattr->values[i].integer;
2305 }
2306 }
2307
2308 if ((oldattr = ippFindAttribute(oldattrs, "marker-high-levels",
2309 IPP_TAG_INTEGER)) != NULL)
2310 {
2311 if ((attr = ippAddIntegers(p->attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
2312 "marker-high-levels", oldattr->num_values,
2313 NULL)) != NULL)
2314 {
2315 for (i = 0; i < oldattr->num_values; i ++)
2316 attr->values[i].integer = oldattr->values[i].integer;
2317 }
2318 }
2319
2320 if ((oldattr = ippFindAttribute(oldattrs, "marker-names",
2321 IPP_TAG_NAME)) != NULL)
2322 {
2323 if ((attr = ippAddStrings(p->attrs, IPP_TAG_PRINTER, IPP_TAG_NAME,
2324 "marker-names", oldattr->num_values, NULL,
2325 NULL)) != NULL)
2326 {
2327 for (i = 0; i < oldattr->num_values; i ++)
2328 attr->values[i].string.text =
2329 _cupsStrAlloc(oldattr->values[i].string.text);
2330 }
2331 }
2332
2333 if ((oldattr = ippFindAttribute(oldattrs, "marker-types",
2334 IPP_TAG_KEYWORD)) != NULL)
2335 {
2336 if ((attr = ippAddStrings(p->attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
2337 "marker-types", oldattr->num_values, NULL,
2338 NULL)) != NULL)
2339 {
2340 for (i = 0; i < oldattr->num_values; i ++)
2341 attr->values[i].string.text =
2342 _cupsStrAlloc(oldattr->values[i].string.text);
2343 }
2344 }
2345
2346 ippDelete(oldattrs);
2347 }
2348
2349 /*
2350 * Force sharing off for remote queues...
2351 */
2352
2353 if (p->type & CUPS_PRINTER_REMOTE)
2354 p->shared = 0;
2355
2356 /*
2357 * Populate the document-format-supported attribute...
2358 */
2359
2360 add_printer_formats(p);
2361
2362 DEBUG_printf(("cupsdSetPrinterAttrs: leaving name = %s, type = %x\n", p->name,
2363 p->type));
2364
2365 /*
2366 * Add name-default attributes...
2367 */
2368
2369 add_printer_defaults(p);
2370
2371 /*
2372 * Let the browse protocols reflect the change
2373 */
2374
2375 cupsdRegisterPrinter(p);
2376 }
2377
2378
2379 /*
2380 * 'cupsdSetPrinterReasons()' - Set/update the reasons strings.
2381 */
2382
2383 int /* O - 1 if something changed, 0 otherwise */
2384 cupsdSetPrinterReasons(
2385 cupsd_printer_t *p, /* I - Printer */
2386 const char *s) /* I - Reasons strings */
2387 {
2388 int i, /* Looping var */
2389 changed = 0; /* Did something change? */
2390 const char *sptr; /* Pointer into reasons */
2391 char reason[255], /* Reason string */
2392 *rptr; /* Pointer into reason */
2393
2394
2395 cupsdLogMessage(CUPSD_LOG_DEBUG2,
2396 "cupsdSetPrinterReasons(p=%p(%s),s=\"%s\"", p, p->name, s);
2397
2398 if (s[0] == '-' || s[0] == '+')
2399 {
2400 /*
2401 * Add/remove reasons...
2402 */
2403
2404 sptr = s + 1;
2405 }
2406 else
2407 {
2408 /*
2409 * Replace reasons...
2410 */
2411
2412 sptr = s;
2413
2414 for (i = 0; i < p->num_reasons; i ++)
2415 _cupsStrFree(p->reasons[i]);
2416
2417 p->num_reasons = 0;
2418 changed = 1;
2419
2420 dirty_printer(p);
2421 }
2422
2423 if (!strcmp(s, "none"))
2424 return (changed);
2425
2426 /*
2427 * Loop through all of the reasons...
2428 */
2429
2430 while (*sptr)
2431 {
2432 /*
2433 * Skip leading whitespace and commas...
2434 */
2435
2436 while (isspace(*sptr & 255) || *sptr == ',')
2437 sptr ++;
2438
2439 for (rptr = reason; *sptr && !isspace(*sptr & 255) && *sptr != ','; sptr ++)
2440 if (rptr < (reason + sizeof(reason) - 1))
2441 *rptr++ = *sptr;
2442
2443 if (rptr == reason)
2444 break;
2445
2446 *rptr = '\0';
2447
2448 if (s[0] == '-')
2449 {
2450 /*
2451 * Remove reason...
2452 */
2453
2454 for (i = 0; i < p->num_reasons; i ++)
2455 if (!strcmp(reason, p->reasons[i]))
2456 {
2457 /*
2458 * Found a match, so remove it...
2459 */
2460
2461 p->num_reasons --;
2462 changed = 1;
2463 _cupsStrFree(p->reasons[i]);
2464
2465 if (i < p->num_reasons)
2466 memmove(p->reasons + i, p->reasons + i + 1, (size_t)(p->num_reasons - i) * sizeof(char *));
2467
2468 if (!strcmp(reason, "paused") && p->state == IPP_PRINTER_STOPPED)
2469 cupsdSetPrinterState(p, IPP_PRINTER_IDLE, 1);
2470
2471 if (!strcmp(reason, "cups-waiting-for-job-completed") && p->job)
2472 p->job->completed = 0;
2473
2474 if (strcmp(reason, "connecting-to-device"))
2475 dirty_printer(p);
2476
2477 break;
2478 }
2479 }
2480 else if (p->num_reasons < (int)(sizeof(p->reasons) / sizeof(p->reasons[0])))
2481 {
2482 /*
2483 * Add reason...
2484 */
2485
2486 for (i = 0; i < p->num_reasons; i ++)
2487 if (!strcmp(reason, p->reasons[i]))
2488 break;
2489
2490 if (i >= p->num_reasons)
2491 {
2492 if (i >= (int)(sizeof(p->reasons) / sizeof(p->reasons[0])))
2493 {
2494 cupsdLogMessage(CUPSD_LOG_ALERT,
2495 "Too many printer-state-reasons values for %s (%d)",
2496 p->name, i + 1);
2497 return (changed);
2498 }
2499
2500 p->reasons[i] = _cupsStrAlloc(reason);
2501 p->num_reasons ++;
2502 changed = 1;
2503
2504 if (!strcmp(reason, "paused") && p->state != IPP_PRINTER_STOPPED)
2505 cupsdSetPrinterState(p, IPP_PRINTER_STOPPED, 1);
2506
2507 if (!strcmp(reason, "cups-waiting-for-job-completed") && p->job)
2508 p->job->completed = 1;
2509
2510 if (strcmp(reason, "connecting-to-device"))
2511 dirty_printer(p);
2512 }
2513 }
2514 }
2515
2516 return (changed);
2517 }
2518
2519
2520 /*
2521 * 'cupsdSetPrinterState()' - Update the current state of a printer.
2522 */
2523
2524 void
2525 cupsdSetPrinterState(
2526 cupsd_printer_t *p, /* I - Printer to change */
2527 ipp_pstate_t s, /* I - New state */
2528 int update) /* I - Update printers.conf? */
2529 {
2530 cupsd_job_t *job; /* Current job */
2531 ipp_pstate_t old_state; /* Old printer state */
2532 static const char * const printer_states[] =
2533 { /* State strings */
2534 "idle",
2535 "processing",
2536 "stopped"
2537 };
2538
2539
2540 /*
2541 * Set the new state...
2542 */
2543
2544 old_state = p->state;
2545 p->state = s;
2546
2547 if (old_state != s)
2548 {
2549 cupsdAddEvent(s == IPP_PRINTER_STOPPED ? CUPSD_EVENT_PRINTER_STOPPED :
2550 CUPSD_EVENT_PRINTER_STATE, p, NULL,
2551 "%s \"%s\" state changed to %s.",
2552 (p->type & CUPS_PRINTER_CLASS) ? "Class" : "Printer",
2553 p->name, printer_states[p->state - IPP_PRINTER_IDLE]);
2554
2555 /*
2556 * Let the browse code know this needs to be updated...
2557 */
2558
2559 p->state_time = time(NULL);
2560 }
2561
2562 /*
2563 * Set/clear the paused reason as needed...
2564 */
2565
2566 if (s == IPP_PRINTER_STOPPED)
2567 cupsdSetPrinterReasons(p, "+paused");
2568 else
2569 cupsdSetPrinterReasons(p, "-paused");
2570
2571 if (old_state != s)
2572 {
2573 for (job = (cupsd_job_t *)cupsArrayFirst(ActiveJobs);
2574 job;
2575 job = (cupsd_job_t *)cupsArrayNext(ActiveJobs))
2576 if (job->reasons && job->state_value == IPP_JOB_PENDING &&
2577 !_cups_strcasecmp(job->dest, p->name))
2578 ippSetString(job->attrs, &job->reasons, 0,
2579 s == IPP_PRINTER_STOPPED ? "printer-stopped" : "none");
2580 }
2581
2582 /*
2583 * Clear the message for the queue when going to processing...
2584 */
2585
2586 if (s == IPP_PRINTER_PROCESSING)
2587 p->state_message[0] = '\0';
2588
2589 /*
2590 * Let the browse protocols reflect the change...
2591 */
2592
2593 if (update)
2594 cupsdRegisterPrinter(p);
2595
2596 /*
2597 * Save the printer configuration if a printer goes from idle or processing
2598 * to stopped (or visa-versa)...
2599 */
2600
2601 if (update &&
2602 (old_state == IPP_PRINTER_STOPPED) != (s == IPP_PRINTER_STOPPED))
2603 dirty_printer(p);
2604 }
2605
2606
2607 /*
2608 * 'cupsdStopPrinter()' - Stop a printer from printing any jobs...
2609 */
2610
2611 void
2612 cupsdStopPrinter(cupsd_printer_t *p, /* I - Printer to stop */
2613 int update)/* I - Update printers.conf? */
2614 {
2615 /*
2616 * Set the printer state...
2617 */
2618
2619 cupsdSetPrinterState(p, IPP_PRINTER_STOPPED, update);
2620
2621 /*
2622 * See if we have a job printing on this printer...
2623 */
2624
2625 if (p->job && p->job->state_value == IPP_JOB_PROCESSING)
2626 cupsdSetJobState(p->job, IPP_JOB_PENDING, CUPSD_JOB_DEFAULT,
2627 "Job stopped due to printer being paused.");
2628 }
2629
2630
2631 /*
2632 * 'cupsdUpdatePrinterPPD()' - Update keywords in a printer's PPD file.
2633 */
2634
2635 int /* O - 1 if successful, 0 otherwise */
2636 cupsdUpdatePrinterPPD(
2637 cupsd_printer_t *p, /* I - Printer */
2638 int num_keywords, /* I - Number of keywords */
2639 cups_option_t *keywords) /* I - Keywords */
2640 {
2641 int i; /* Looping var */
2642 cups_file_t *src, /* Original file */
2643 *dst; /* New file */
2644 char srcfile[1024], /* Original filename */
2645 dstfile[1024], /* New filename */
2646 line[1024], /* Line from file */
2647 keystring[41]; /* Keyword from line */
2648 cups_option_t *keyword; /* Current keyword */
2649
2650
2651 cupsdLogMessage(CUPSD_LOG_INFO, "Updating keywords in PPD file for %s...",
2652 p->name);
2653
2654 /*
2655 * Get the old and new PPD filenames...
2656 */
2657
2658 snprintf(srcfile, sizeof(srcfile), "%s/ppd/%s.ppd.O", ServerRoot, p->name);
2659 snprintf(dstfile, sizeof(srcfile), "%s/ppd/%s.ppd", ServerRoot, p->name);
2660
2661 /*
2662 * Rename the old file and open the old and new...
2663 */
2664
2665 if (rename(dstfile, srcfile))
2666 {
2667 cupsdLogMessage(CUPSD_LOG_ERROR, "Unable to backup PPD file for %s: %s",
2668 p->name, strerror(errno));
2669 return (0);
2670 }
2671
2672 if ((src = cupsFileOpen(srcfile, "r")) == NULL)
2673 {
2674 cupsdLogMessage(CUPSD_LOG_ERROR, "Unable to open PPD file \"%s\": %s",
2675 srcfile, strerror(errno));
2676 rename(srcfile, dstfile);
2677 return (0);
2678 }
2679
2680 if ((dst = cupsFileOpen(dstfile, "w")) == NULL)
2681 {
2682 cupsdLogMessage(CUPSD_LOG_ERROR, "Unable to create PPD file \"%s\": %s",
2683 dstfile, strerror(errno));
2684 cupsFileClose(src);
2685 rename(srcfile, dstfile);
2686 return (0);
2687 }
2688
2689 /*
2690 * Copy the first line and then write out all of the keywords...
2691 */
2692
2693 if (!cupsFileGets(src, line, sizeof(line)))
2694 {
2695 cupsdLogMessage(CUPSD_LOG_ERROR, "Unable to read PPD file \"%s\": %s",
2696 srcfile, strerror(errno));
2697 cupsFileClose(src);
2698 cupsFileClose(dst);
2699 rename(srcfile, dstfile);
2700 return (0);
2701 }
2702
2703 cupsFilePrintf(dst, "%s\n", line);
2704
2705 for (i = num_keywords, keyword = keywords; i > 0; i --, keyword ++)
2706 {
2707 cupsdLogMessage(CUPSD_LOG_DEBUG, "*%s: %s", keyword->name, keyword->value);
2708 cupsFilePrintf(dst, "*%s: %s\n", keyword->name, keyword->value);
2709 }
2710
2711 /*
2712 * Then copy the rest of the PPD file, dropping any keywords we changed.
2713 */
2714
2715 while (cupsFileGets(src, line, sizeof(line)))
2716 {
2717 /*
2718 * Skip keywords we've already set...
2719 */
2720
2721 if (sscanf(line, "*%40[^:]:", keystring) == 1 &&
2722 cupsGetOption(keystring, num_keywords, keywords))
2723 continue;
2724
2725 /*
2726 * Otherwise write the line...
2727 */
2728
2729 cupsFilePrintf(dst, "%s\n", line);
2730 }
2731
2732 /*
2733 * Close files and return...
2734 */
2735
2736 cupsFileClose(src);
2737 cupsFileClose(dst);
2738
2739 return (1);
2740 }
2741
2742
2743 /*
2744 * 'cupsdUpdatePrinters()' - Update printers after a partial reload.
2745 */
2746
2747 void
2748 cupsdUpdatePrinters(void)
2749 {
2750 cupsd_printer_t *p; /* Current printer */
2751
2752
2753 /*
2754 * Loop through the printers and recreate the printer attributes
2755 * for any local printers since the policy and/or access control
2756 * stuff may have changed. Also, if browsing is disabled, remove
2757 * any remote printers...
2758 */
2759
2760 for (p = (cupsd_printer_t *)cupsArrayFirst(Printers);
2761 p;
2762 p = (cupsd_printer_t *)cupsArrayNext(Printers))
2763 {
2764 /*
2765 * Update the operation policy pointer...
2766 */
2767
2768 if ((p->op_policy_ptr = cupsdFindPolicy(p->op_policy)) == NULL)
2769 p->op_policy_ptr = DefaultPolicyPtr;
2770
2771 /*
2772 * Update printer attributes...
2773 */
2774
2775 cupsdSetPrinterAttrs(p);
2776 }
2777 }
2778
2779
2780 /*
2781 * 'cupsdValidateDest()' - Validate a printer/class destination.
2782 */
2783
2784 const char * /* O - Printer or class name */
2785 cupsdValidateDest(
2786 const char *uri, /* I - Printer URI */
2787 cups_ptype_t *dtype, /* O - Type (printer or class) */
2788 cupsd_printer_t **printer) /* O - Printer pointer */
2789 {
2790 cupsd_printer_t *p; /* Current printer */
2791 char localname[1024],/* Localized hostname */
2792 *lptr, /* Pointer into localized hostname */
2793 *sptr, /* Pointer into server name */
2794 *rptr, /* Pointer into resource */
2795 scheme[32], /* Scheme portion of URI */
2796 username[64], /* Username portion of URI */
2797 hostname[HTTP_MAX_HOST],
2798 /* Host portion of URI */
2799 resource[HTTP_MAX_URI];
2800 /* Resource portion of URI */
2801 int port; /* Port portion of URI */
2802
2803
2804 DEBUG_printf(("cupsdValidateDest(uri=\"%s\", dtype=%p, printer=%p)\n", uri,
2805 dtype, printer));
2806
2807 /*
2808 * Initialize return values...
2809 */
2810
2811 if (printer)
2812 *printer = NULL;
2813
2814 if (dtype)
2815 *dtype = (cups_ptype_t)0;
2816
2817 /*
2818 * Pull the hostname and resource from the URI...
2819 */
2820
2821 httpSeparateURI(HTTP_URI_CODING_ALL, uri, scheme, sizeof(scheme),
2822 username, sizeof(username), hostname, sizeof(hostname),
2823 &port, resource, sizeof(resource));
2824
2825 /*
2826 * See if the resource is a class or printer...
2827 */
2828
2829 if (!strncmp(resource, "/classes/", 9))
2830 {
2831 /*
2832 * Class...
2833 */
2834
2835 rptr = resource + 9;
2836 }
2837 else if (!strncmp(resource, "/printers/", 10))
2838 {
2839 /*
2840 * Printer...
2841 */
2842
2843 rptr = resource + 10;
2844 }
2845 else
2846 {
2847 /*
2848 * Bad resource name...
2849 */
2850
2851 return (NULL);
2852 }
2853
2854 /*
2855 * See if the printer or class name exists...
2856 */
2857
2858 p = cupsdFindDest(rptr);
2859
2860 if (p == NULL && strchr(rptr, '@') == NULL)
2861 return (NULL);
2862 else if (p != NULL)
2863 {
2864 if (printer)
2865 *printer = p;
2866
2867 if (dtype)
2868 *dtype = p->type & (CUPS_PRINTER_CLASS | CUPS_PRINTER_REMOTE);
2869
2870 return (p->name);
2871 }
2872
2873 /*
2874 * Change localhost to the server name...
2875 */
2876
2877 if (!_cups_strcasecmp(hostname, "localhost"))
2878 strlcpy(hostname, ServerName, sizeof(hostname));
2879
2880 strlcpy(localname, hostname, sizeof(localname));
2881
2882 if (!_cups_strcasecmp(hostname, ServerName))
2883 {
2884 /*
2885 * Localize the hostname...
2886 */
2887
2888 lptr = strchr(localname, '.');
2889 sptr = strchr(ServerName, '.');
2890
2891 if (sptr != NULL && lptr != NULL)
2892 {
2893 /*
2894 * Strip the common domain name components...
2895 */
2896
2897 while (lptr != NULL)
2898 {
2899 if (!_cups_strcasecmp(lptr, sptr))
2900 {
2901 *lptr = '\0';
2902 break;
2903 }
2904 else
2905 lptr = strchr(lptr + 1, '.');
2906 }
2907 }
2908 }
2909
2910 DEBUG_printf(("localized hostname is \"%s\"...\n", localname));
2911
2912 /*
2913 * Find a matching printer or class...
2914 */
2915
2916 for (p = (cupsd_printer_t *)cupsArrayFirst(Printers);
2917 p;
2918 p = (cupsd_printer_t *)cupsArrayNext(Printers))
2919 if (!_cups_strcasecmp(p->hostname, localname) &&
2920 !_cups_strcasecmp(p->name, rptr))
2921 {
2922 if (printer)
2923 *printer = p;
2924
2925 if (dtype)
2926 *dtype = p->type & (CUPS_PRINTER_CLASS | CUPS_PRINTER_REMOTE);
2927
2928 return (p->name);
2929 }
2930
2931 return (NULL);
2932 }
2933
2934
2935 /*
2936 * 'cupsdWritePrintcap()' - Write a pseudo-printcap file for older applications
2937 * that need it...
2938 */
2939
2940 void
2941 cupsdWritePrintcap(void)
2942 {
2943 int i; /* Looping var */
2944 cups_file_t *fp; /* Printcap file */
2945 cupsd_printer_t *p; /* Current printer */
2946
2947
2948 /*
2949 * See if we have a printcap file; if not, don't bother writing it.
2950 */
2951
2952 if (!Printcap || !*Printcap)
2953 return;
2954
2955 cupsdLogMessage(CUPSD_LOG_INFO, "Generating printcap %s...", Printcap);
2956
2957 /*
2958 * Open the printcap file...
2959 */
2960
2961 if ((fp = cupsFileOpen(Printcap, "w")) == NULL)
2962 return;
2963
2964 /*
2965 * Put a comment header at the top so that users will know where the
2966 * data has come from...
2967 */
2968
2969 if (PrintcapFormat != PRINTCAP_PLIST)
2970 cupsFilePrintf(fp, "# This file was automatically generated by cupsd(8) "
2971 "from the\n"
2972 "# %s/printers.conf file. All changes to this file\n"
2973 "# will be lost.\n", ServerRoot);
2974
2975 /*
2976 * Write a new printcap with the current list of printers.
2977 */
2978
2979 switch (PrintcapFormat)
2980 {
2981 case PRINTCAP_BSD :
2982 /*
2983 * Each printer is put in the file as:
2984 *
2985 * Printer1:
2986 * Printer2:
2987 * Printer3:
2988 * ...
2989 * PrinterN:
2990 */
2991
2992 if (DefaultPrinter)
2993 cupsFilePrintf(fp, "%s|%s:rm=%s:rp=%s:\n", DefaultPrinter->name,
2994 DefaultPrinter->info, ServerName,
2995 DefaultPrinter->name);
2996
2997 for (p = (cupsd_printer_t *)cupsArrayFirst(Printers);
2998 p;
2999 p = (cupsd_printer_t *)cupsArrayNext(Printers))
3000 if (p != DefaultPrinter)
3001 cupsFilePrintf(fp, "%s|%s:rm=%s:rp=%s:\n", p->name, p->info,
3002 ServerName, p->name);
3003 break;
3004
3005 case PRINTCAP_PLIST :
3006 /*
3007 * Each printer is written as a dictionary in a plist file.
3008 * Currently the printer-name, printer-info, printer-is-accepting-jobs,
3009 * printer-location, printer-make-and-model, printer-state,
3010 * printer-state-reasons, printer-type, and (sanitized) device-uri.
3011 */
3012
3013 cupsFilePuts(fp, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
3014 "<!DOCTYPE plist PUBLIC \"-//Apple Computer//DTD "
3015 "PLIST 1.0//EN\" \"http://www.apple.com/DTDs/"
3016 "PropertyList-1.0.dtd\">\n"
3017 "<plist version=\"1.0\">\n"
3018 "<array>\n");
3019
3020 for (p = (cupsd_printer_t *)cupsArrayFirst(Printers);
3021 p;
3022 p = (cupsd_printer_t *)cupsArrayNext(Printers))
3023 {
3024 cupsFilePuts(fp, "\t<dict>\n"
3025 "\t\t<key>printer-name</key>\n"
3026 "\t\t<string>");
3027 write_xml_string(fp, p->name);
3028 cupsFilePuts(fp, "</string>\n"
3029 "\t\t<key>printer-info</key>\n"
3030 "\t\t<string>");
3031 write_xml_string(fp, p->info);
3032 cupsFilePrintf(fp, "</string>\n"
3033 "\t\t<key>printer-is-accepting-jobs</key>\n"
3034 "\t\t<%s/>\n"
3035 "\t\t<key>printer-location</key>\n"
3036 "\t\t<string>", p->accepting ? "true" : "false");
3037 write_xml_string(fp, p->location);
3038 cupsFilePuts(fp, "</string>\n"
3039 "\t\t<key>printer-make-and-model</key>\n"
3040 "\t\t<string>");
3041 write_xml_string(fp, p->make_model);
3042 cupsFilePrintf(fp, "</string>\n"
3043 "\t\t<key>printer-state</key>\n"
3044 "\t\t<integer>%d</integer>\n"
3045 "\t\t<key>printer-state-reasons</key>\n"
3046 "\t\t<array>\n", p->state);
3047 for (i = 0; i < p->num_reasons; i ++)
3048 {
3049 cupsFilePuts(fp, "\t\t\t<string>");
3050 write_xml_string(fp, p->reasons[i]);
3051 cupsFilePuts(fp, "</string>\n");
3052 }
3053 cupsFilePrintf(fp, "\t\t</array>\n"
3054 "\t\t<key>printer-type</key>\n"
3055 "\t\t<integer>%d</integer>\n"
3056 "\t\t<key>device-uri</key>\n"
3057 "\t\t<string>", p->type);
3058 write_xml_string(fp, p->sanitized_device_uri);
3059 cupsFilePuts(fp, "</string>\n"
3060 "\t</dict>\n");
3061 }
3062 cupsFilePuts(fp, "</array>\n"
3063 "</plist>\n");
3064 break;
3065
3066 case PRINTCAP_SOLARIS :
3067 /*
3068 * Each printer is put in the file as:
3069 *
3070 * _all:all=Printer1,Printer2,Printer3,...,PrinterN
3071 * _default:use=DefaultPrinter
3072 * Printer1:\
3073 * :bsdaddr=ServerName,Printer1:\
3074 * :description=Description:
3075 * Printer2:
3076 * :bsdaddr=ServerName,Printer2:\
3077 * :description=Description:
3078 * Printer3:
3079 * :bsdaddr=ServerName,Printer3:\
3080 * :description=Description:
3081 * ...
3082 * PrinterN:
3083 * :bsdaddr=ServerName,PrinterN:\
3084 * :description=Description:
3085 */
3086
3087 cupsFilePuts(fp, "_all:all=");
3088 for (p = (cupsd_printer_t *)cupsArrayFirst(Printers);
3089 p;
3090 p = (cupsd_printer_t *)cupsArrayCurrent(Printers))
3091 cupsFilePrintf(fp, "%s%c", p->name,
3092 cupsArrayNext(Printers) ? ',' : '\n');
3093
3094 if (DefaultPrinter)
3095 cupsFilePrintf(fp, "_default:use=%s\n", DefaultPrinter->name);
3096
3097 for (p = (cupsd_printer_t *)cupsArrayFirst(Printers);
3098 p;
3099 p = (cupsd_printer_t *)cupsArrayNext(Printers))
3100 cupsFilePrintf(fp, "%s:\\\n"
3101 "\t:bsdaddr=%s,%s:\\\n"
3102 "\t:description=%s:\n",
3103 p->name, ServerName, p->name,
3104 p->info ? p->info : "");
3105 break;
3106 }
3107
3108 /*
3109 * Close the file...
3110 */
3111
3112 cupsFileClose(fp);
3113 }
3114
3115
3116 /*
3117 * 'add_printer_defaults()' - Add name-default attributes to the printer attributes.
3118 */
3119
3120 static void
3121 add_printer_defaults(cupsd_printer_t *p)/* I - Printer */
3122 {
3123 int i; /* Looping var */
3124 int num_options; /* Number of default options */
3125 cups_option_t *options, /* Default options */
3126 *option; /* Current option */
3127 char name[256]; /* name-default */
3128
3129
3130 /*
3131 * Maintain a common array of default attribute names...
3132 */
3133
3134 if (!CommonDefaults)
3135 {
3136 CommonDefaults = cupsArrayNew((cups_array_func_t)strcmp, NULL);
3137
3138 cupsArrayAdd(CommonDefaults, _cupsStrAlloc("copies-default"));
3139 cupsArrayAdd(CommonDefaults, _cupsStrAlloc("document-format-default"));
3140 cupsArrayAdd(CommonDefaults, _cupsStrAlloc("finishings-default"));
3141 cupsArrayAdd(CommonDefaults, _cupsStrAlloc("job-account-id-default"));
3142 cupsArrayAdd(CommonDefaults,
3143 _cupsStrAlloc("job-accounting-user-id-default"));
3144 cupsArrayAdd(CommonDefaults, _cupsStrAlloc("job-cancel-after-default"));
3145 cupsArrayAdd(CommonDefaults, _cupsStrAlloc("job-hold-until-default"));
3146 cupsArrayAdd(CommonDefaults, _cupsStrAlloc("job-priority-default"));
3147 cupsArrayAdd(CommonDefaults, _cupsStrAlloc("job-sheets-default"));
3148 cupsArrayAdd(CommonDefaults, _cupsStrAlloc("media-col-default"));
3149 cupsArrayAdd(CommonDefaults, _cupsStrAlloc("number-up-default"));
3150 cupsArrayAdd(CommonDefaults,
3151 _cupsStrAlloc("orientation-requested-default"));
3152 }
3153
3154 /*
3155 * Add all of the default options from the .conf files...
3156 */
3157
3158 for (num_options = 0, options = NULL, i = p->num_options, option = p->options;
3159 i > 0;
3160 i --, option ++)
3161 {
3162 if (strcmp(option->name, "ipp-options") &&
3163 strcmp(option->name, "job-sheets") &&
3164 strcmp(option->name, "lease-duration"))
3165 {
3166 snprintf(name, sizeof(name), "%s-default", option->name);
3167 num_options = cupsAddOption(name, option->value, num_options, &options);
3168
3169 if (!cupsArrayFind(CommonDefaults, name))
3170 cupsArrayAdd(CommonDefaults, _cupsStrAlloc(name));
3171 }
3172 }
3173
3174 /*
3175 * Convert options to IPP attributes...
3176 */
3177
3178 cupsEncodeOptions2(p->attrs, num_options, options, IPP_TAG_PRINTER);
3179 cupsFreeOptions(num_options, options);
3180
3181 /*
3182 * Add standard -default attributes as needed...
3183 */
3184
3185 if (!cupsGetOption("copies", p->num_options, p->options))
3186 ippAddInteger(p->attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER, "copies-default",
3187 1);
3188
3189 if (!cupsGetOption("document-format", p->num_options, p->options))
3190 ippAddString(p->attrs, IPP_TAG_PRINTER, IPP_TAG_MIMETYPE,
3191 "document-format-default", NULL, "application/octet-stream");
3192
3193 if (!cupsGetOption("job-cancel-after", p->num_options, p->options))
3194 ippAddInteger(p->attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
3195 "job-cancel-after-default", MaxJobTime);
3196
3197 if (!cupsGetOption("job-hold-until", p->num_options, p->options))
3198 ippAddString(p->attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
3199 "job-hold-until-default", NULL, "no-hold");
3200
3201 if (!cupsGetOption("job-priority", p->num_options, p->options))
3202 ippAddInteger(p->attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
3203 "job-priority-default", 50);
3204
3205 if (!cupsGetOption("number-up", p->num_options, p->options))
3206 ippAddInteger(p->attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
3207 "number-up-default", 1);
3208
3209 if (!cupsGetOption("notify-lease-duration", p->num_options, p->options))
3210 ippAddInteger(p->attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
3211 "notify-lease-duration-default", DefaultLeaseDuration);
3212
3213 if (!cupsGetOption("notify-events", p->num_options, p->options))
3214 ippAddString(p->attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
3215 "notify-events-default", NULL, "job-completed");
3216
3217 if (!cupsGetOption("orientation-requested", p->num_options, p->options))
3218 ippAddString(p->attrs, IPP_TAG_PRINTER, IPP_TAG_NOVALUE,
3219 "orientation-requested-default", NULL, NULL);
3220
3221 if (!cupsGetOption("print-quality", p->num_options, p->options))
3222 ippAddInteger(p->attrs, IPP_TAG_PRINTER, IPP_TAG_ENUM,
3223 "print-quality-default", IPP_QUALITY_NORMAL);
3224 }
3225
3226
3227 /*
3228 * 'add_printer_filter()' - Add a MIME filter for a printer.
3229 */
3230
3231 static void
3232 add_printer_filter(
3233 cupsd_printer_t *p, /* I - Printer to add to */
3234 mime_type_t *filtertype, /* I - Filter or prefilter MIME type */
3235 const char *filter) /* I - Filter to add */
3236 {
3237 char super[MIME_MAX_SUPER], /* Super-type for filter */
3238 type[MIME_MAX_TYPE], /* Type for filter */
3239 dsuper[MIME_MAX_SUPER], /* Destination super-type for filter */
3240 dtype[MIME_MAX_TYPE], /* Destination type for filter */
3241 dest[MIME_MAX_SUPER + MIME_MAX_TYPE + 2],
3242 /* Destination super/type */
3243 program[1024]; /* Program/filter name */
3244 int cost; /* Cost of filter */
3245 size_t maxsize = 0; /* Maximum supported file size */
3246 mime_type_t *temptype, /* MIME type looping var */
3247 *desttype; /* Destination MIME type */
3248 mime_filter_t *filterptr; /* MIME filter */
3249 char filename[1024]; /* Full filter filename */
3250
3251
3252 cupsdLogMessage(CUPSD_LOG_DEBUG2,
3253 "add_printer_filter(p=%p(%s), filtertype=%p(%s/%s), "
3254 "filter=\"%s\")", p, p->name, filtertype, filtertype->super,
3255 filtertype->type, filter);
3256
3257 /*
3258 * Parse the filter string; it should be in one of the following formats:
3259 *
3260 * source/type cost program
3261 * source/type cost maxsize(nnnn) program
3262 * source/type dest/type cost program
3263 * source/type dest/type cost maxsize(nnnn) program
3264 */
3265
3266 if (sscanf(filter, "%15[^/]/%255s%*[ \t]%15[^/]/%255s%d%*[ \t]%1023[^\n]",
3267 super, type, dsuper, dtype, &cost, program) == 6)
3268 {
3269 snprintf(dest, sizeof(dest), "%s/%s/%s", p->name, dsuper, dtype);
3270
3271 if ((desttype = mimeType(MimeDatabase, "printer", dest)) == NULL)
3272 {
3273 desttype = mimeAddType(MimeDatabase, "printer", dest);
3274 if (!p->dest_types)
3275 p->dest_types = cupsArrayNew(NULL, NULL);
3276
3277 cupsArrayAdd(p->dest_types, desttype);
3278 }
3279
3280 }
3281 else
3282 {
3283 if (sscanf(filter, "%15[^/]/%255s%d%*[ \t]%1023[^\n]", super, type, &cost,
3284 program) == 4)
3285 {
3286 desttype = filtertype;
3287 }
3288 else
3289 {
3290 cupsdLogMessage(CUPSD_LOG_ERROR, "%s: invalid filter string \"%s\"!",
3291 p->name, filter);
3292 return;
3293 }
3294 }
3295
3296 if (!strncmp(program, "maxsize(", 8))
3297 {
3298 char *ptr; /* Pointer into maxsize(nnnn) program */
3299
3300 maxsize = (size_t)strtoll(program + 8, &ptr, 10);
3301
3302 if (*ptr != ')')
3303 {
3304 cupsdLogMessage(CUPSD_LOG_ERROR, "%s: invalid filter string \"%s\"!",
3305 p->name, filter);
3306 return;
3307 }
3308
3309 ptr ++;
3310 while (_cups_isspace(*ptr))
3311 ptr ++;
3312
3313 _cups_strcpy(program, ptr);
3314 }
3315
3316 /*
3317 * Check permissions on the filter and its containing directory...
3318 */
3319
3320 if (strcmp(program, "-"))
3321 {
3322 if (program[0] == '/')
3323 strlcpy(filename, program, sizeof(filename));
3324 else
3325 snprintf(filename, sizeof(filename), "%s/filter/%s", ServerBin, program);
3326
3327 _cupsFileCheck(filename, _CUPS_FILE_CHECK_PROGRAM, !RunUser,
3328 cupsdLogFCMessage, p);
3329 }
3330
3331 /*
3332 * Add the filter to the MIME database, supporting wildcards as needed...
3333 */
3334
3335 for (temptype = mimeFirstType(MimeDatabase);
3336 temptype;
3337 temptype = mimeNextType(MimeDatabase))
3338 if (((super[0] == '*' && _cups_strcasecmp(temptype->super, "printer")) ||
3339 !_cups_strcasecmp(temptype->super, super)) &&
3340 (type[0] == '*' || !_cups_strcasecmp(temptype->type, type)))
3341 {
3342 if (desttype != filtertype)
3343 {
3344 cupsdLogMessage(CUPSD_LOG_DEBUG2,
3345 "add_printer_filter: %s: adding filter %s/%s %s/%s %d "
3346 "%s", p->name, temptype->super, temptype->type,
3347 desttype->super, desttype->type,
3348 cost, program);
3349 filterptr = mimeAddFilter(MimeDatabase, temptype, desttype, cost,
3350 program);
3351
3352 if (!mimeFilterLookup(MimeDatabase, desttype, filtertype))
3353 {
3354 cupsdLogMessage(CUPSD_LOG_DEBUG2,
3355 "add_printer_filter: %s: adding filter %s/%s %s/%s "
3356 "0 -", p->name, desttype->super, desttype->type,
3357 filtertype->super, filtertype->type);
3358 mimeAddFilter(MimeDatabase, desttype, filtertype, 0, "-");
3359 }
3360 }
3361 else
3362 {
3363 cupsdLogMessage(CUPSD_LOG_DEBUG2,
3364 "add_printer_filter: %s: adding filter %s/%s %s/%s %d "
3365 "%s", p->name, temptype->super, temptype->type,
3366 filtertype->super, filtertype->type,
3367 cost, program);
3368 filterptr = mimeAddFilter(MimeDatabase, temptype, filtertype, cost,
3369 program);
3370 }
3371
3372 if (filterptr)
3373 filterptr->maxsize = maxsize;
3374 }
3375 }
3376
3377
3378 /*
3379 * 'add_printer_formats()' - Add document-format-supported values for a printer.
3380 */
3381
3382 static void
3383 add_printer_formats(cupsd_printer_t *p) /* I - Printer */
3384 {
3385 int i; /* Looping var */
3386 mime_type_t *type; /* Current MIME type */
3387 cups_array_t *filters; /* Filters */
3388 ipp_attribute_t *attr; /* document-format-supported attribute */
3389 char mimetype[MIME_MAX_SUPER + MIME_MAX_TYPE + 2];
3390 /* MIME type name */
3391
3392
3393 /*
3394 * Raw (and remote) queues advertise all of the supported MIME
3395 * types...
3396 */
3397
3398 cupsArrayDelete(p->filetypes);
3399 p->filetypes = NULL;
3400
3401 if (p->raw)
3402 {
3403 ippAddStrings(p->attrs, IPP_TAG_PRINTER,
3404 (ipp_tag_t)(IPP_TAG_MIMETYPE | IPP_TAG_COPY),
3405 "document-format-supported", NumMimeTypes, NULL, MimeTypes);
3406 return;
3407 }
3408
3409 /*
3410 * Otherwise, loop through the supported MIME types and see if there
3411 * are filters for them...
3412 */
3413
3414 cupsdLogMessage(CUPSD_LOG_DEBUG2, "add_printer_formats: %d types, %d filters",
3415 mimeNumTypes(MimeDatabase), mimeNumFilters(MimeDatabase));
3416
3417 p->filetypes = cupsArrayNew(NULL, NULL);
3418
3419 for (type = mimeFirstType(MimeDatabase);
3420 type;
3421 type = mimeNextType(MimeDatabase))
3422 {
3423 if (!_cups_strcasecmp(type->super, "printer"))
3424 continue;
3425
3426 snprintf(mimetype, sizeof(mimetype), "%s/%s", type->super, type->type);
3427
3428 if ((filters = mimeFilter(MimeDatabase, type, p->filetype, NULL)) != NULL)
3429 {
3430 cupsdLogMessage(CUPSD_LOG_DEBUG2,
3431 "add_printer_formats: %s: %s needs %d filters",
3432 p->name, mimetype, cupsArrayCount(filters));
3433
3434 cupsArrayDelete(filters);
3435 cupsArrayAdd(p->filetypes, type);
3436 }
3437 else
3438 cupsdLogMessage(CUPSD_LOG_DEBUG2,
3439 "add_printer_formats: %s: %s not supported",
3440 p->name, mimetype);
3441 }
3442
3443 /*
3444 * Add the file formats that can be filtered...
3445 */
3446
3447 if ((type = mimeType(MimeDatabase, "application", "octet-stream")) == NULL ||
3448 !cupsArrayFind(p->filetypes, type))
3449 i = 1;
3450 else
3451 i = 0;
3452
3453 cupsdLogMessage(CUPSD_LOG_DEBUG2,
3454 "add_printer_formats: %s: %d supported types",
3455 p->name, cupsArrayCount(p->filetypes) + i);
3456
3457 attr = ippAddStrings(p->attrs, IPP_TAG_PRINTER, IPP_TAG_MIMETYPE,
3458 "document-format-supported",
3459 cupsArrayCount(p->filetypes) + i, NULL, NULL);
3460
3461 if (i)
3462 attr->values[0].string.text = _cupsStrAlloc("application/octet-stream");
3463
3464 for (type = (mime_type_t *)cupsArrayFirst(p->filetypes);
3465 type;
3466 i ++, type = (mime_type_t *)cupsArrayNext(p->filetypes))
3467 {
3468 snprintf(mimetype, sizeof(mimetype), "%s/%s", type->super, type->type);
3469
3470 attr->values[i].string.text = _cupsStrAlloc(mimetype);
3471 }
3472
3473 #if defined(HAVE_DNSSD) || defined(HAVE_AVAHI)
3474 {
3475 char pdl[1024]; /* Buffer to build pdl list */
3476 mime_filter_t *filter; /* MIME filter looping var */
3477
3478
3479 /*
3480 * We only support raw printing if this is not a Tioga PrintJobMgr based
3481 * queue and if application/octet-stream is a known type...
3482 */
3483
3484 for (filter = (mime_filter_t *)cupsArrayFirst(MimeDatabase->filters);
3485 filter;
3486 filter = (mime_filter_t *)cupsArrayNext(MimeDatabase->filters))
3487 {
3488 if (filter->dst == p->filetype && filter->filter &&
3489 strstr(filter->filter, "PrintJobMgr"))
3490 break;
3491 }
3492
3493 pdl[0] = '\0';
3494
3495 if (!filter && mimeType(MimeDatabase, "application", "octet-stream"))
3496 strlcat(pdl, "application/octet-stream,", sizeof(pdl));
3497
3498 /*
3499 * Then list a bunch of formats that are supported by the printer...
3500 */
3501
3502 for (type = (mime_type_t *)cupsArrayFirst(p->filetypes);
3503 type;
3504 type = (mime_type_t *)cupsArrayNext(p->filetypes))
3505 {
3506 if (!_cups_strcasecmp(type->super, "application"))
3507 {
3508 if (!_cups_strcasecmp(type->type, "pdf"))
3509 strlcat(pdl, "application/pdf,", sizeof(pdl));
3510 else if (!_cups_strcasecmp(type->type, "postscript"))
3511 strlcat(pdl, "application/postscript,", sizeof(pdl));
3512 }
3513 else if (!_cups_strcasecmp(type->super, "image"))
3514 {
3515 if (!_cups_strcasecmp(type->type, "jpeg"))
3516 strlcat(pdl, "image/jpeg,", sizeof(pdl));
3517 else if (!_cups_strcasecmp(type->type, "png"))
3518 strlcat(pdl, "image/png,", sizeof(pdl));
3519 else if (!_cups_strcasecmp(type->type, "pwg-raster"))
3520 strlcat(pdl, "image/pwg-raster,", sizeof(pdl));
3521 }
3522 }
3523
3524 if (pdl[0])
3525 pdl[strlen(pdl) - 1] = '\0'; /* Remove trailing comma */
3526
3527 cupsdSetString(&p->pdl, pdl);
3528 }
3529 #endif /* HAVE_DNSSD || HAVE_AVAHI */
3530 }
3531
3532
3533 /*
3534 * 'compare_printers()' - Compare two printers.
3535 */
3536
3537 static int /* O - Result of comparison */
3538 compare_printers(void *first, /* I - First printer */
3539 void *second, /* I - Second printer */
3540 void *data) /* I - App data (not used) */
3541 {
3542 (void)data;
3543
3544 return (_cups_strcasecmp(((cupsd_printer_t *)first)->name,
3545 ((cupsd_printer_t *)second)->name));
3546 }
3547
3548
3549 /*
3550 * 'delete_printer_filters()' - Delete all MIME filters for a printer.
3551 */
3552
3553 static void
3554 delete_printer_filters(
3555 cupsd_printer_t *p) /* I - Printer to remove from */
3556 {
3557 mime_filter_t *filter; /* MIME filter looping var */
3558 mime_type_t *type; /* Destination types for filters */
3559
3560
3561 /*
3562 * Range check input...
3563 */
3564
3565 if (p == NULL)
3566 return;
3567
3568 /*
3569 * Remove all filters from the MIME database that have a destination
3570 * type == printer...
3571 */
3572
3573 for (filter = mimeFirstFilter(MimeDatabase);
3574 filter;
3575 filter = mimeNextFilter(MimeDatabase))
3576 if (filter->dst == p->filetype || filter->dst == p->prefiltertype ||
3577 cupsArrayFind(p->dest_types, filter->dst))
3578 {
3579 /*
3580 * Delete the current filter...
3581 */
3582
3583 mimeDeleteFilter(MimeDatabase, filter);
3584 }
3585
3586 for (type = (mime_type_t *)cupsArrayFirst(p->dest_types);
3587 type;
3588 type = (mime_type_t *)cupsArrayNext(p->dest_types))
3589 mimeDeleteType(MimeDatabase, type);
3590
3591 cupsArrayDelete(p->dest_types);
3592 p->dest_types = NULL;
3593
3594 cupsdSetPrinterReasons(p, "-cups-insecure-filter-warning"
3595 ",cups-missing-filter-warning");
3596 }
3597
3598
3599 /*
3600 * 'dirty_printer()' - Mark config and state files dirty for the specified
3601 * printer.
3602 */
3603
3604 static void
3605 dirty_printer(cupsd_printer_t *p) /* I - Printer */
3606 {
3607 if (p->type & CUPS_PRINTER_CLASS)
3608 cupsdMarkDirty(CUPSD_DIRTY_CLASSES);
3609 else
3610 cupsdMarkDirty(CUPSD_DIRTY_PRINTERS);
3611
3612 if (PrintcapFormat == PRINTCAP_PLIST)
3613 cupsdMarkDirty(CUPSD_DIRTY_PRINTCAP);
3614 }
3615
3616
3617 /*
3618 * 'load_ppd()' - Load a cached PPD file, updating the cache as needed.
3619 */
3620
3621 static void
3622 load_ppd(cupsd_printer_t *p) /* I - Printer */
3623 {
3624 int i, j, k; /* Looping vars */
3625 char cache_name[1024]; /* Cache filename */
3626 struct stat cache_info; /* Cache file info */
3627 ppd_file_t *ppd; /* PPD file */
3628 char ppd_name[1024]; /* PPD filename */
3629 struct stat ppd_info; /* PPD file info */
3630 int num_media; /* Number of media options */
3631 ppd_size_t *size; /* Current PPD size */
3632 ppd_option_t *duplex, /* Duplex option */
3633 *output_bin, /* OutputBin option */
3634 *output_mode, /* OutputMode option */
3635 *resolution; /* (Set|JCL|)Resolution option */
3636 ppd_choice_t *choice, /* Current PPD choice */
3637 *input_slot, /* Current input slot */
3638 *media_type; /* Current media type */
3639 ppd_attr_t *ppd_attr; /* PPD attribute */
3640 int xdpi, /* Horizontal resolution */
3641 ydpi; /* Vertical resolution */
3642 const char *resptr; /* Pointer into resolution keyword */
3643 _pwg_size_t *pwgsize; /* Current PWG size */
3644 _pwg_map_t *pwgsource, /* Current PWG source */
3645 *pwgtype; /* Current PWG type */
3646 ipp_attribute_t *attr; /* Attribute data */
3647 _ipp_value_t *val; /* Attribute value */
3648 int num_finishings, /* Number of finishings */
3649 finishings[5]; /* finishings-supported values */
3650 int num_qualities, /* Number of print-quality values */
3651 qualities[3]; /* print-quality values */
3652 int num_margins, /* Number of media-*-margin-supported values */
3653 margins[16]; /* media-*-margin-supported values */
3654 const char *filter, /* Current filter */
3655 *mandatory; /* Current mandatory attribute */
3656 static const char * const sides[3] = /* sides-supported values */
3657 {
3658 "one-sided",
3659 "two-sided-long-edge",
3660 "two-sided-short-edge"
3661 };
3662 static const char * const standard_commands[] =
3663 { /* Standard CUPS commands */
3664 "AutoConfigure",
3665 "Clean",
3666 "PrintSelfTestPage"
3667 };
3668
3669
3670 /*
3671 * Check to see if the cache is up-to-date...
3672 */
3673
3674 snprintf(cache_name, sizeof(cache_name), "%s/%s.data", CacheDir, p->name);
3675 if (stat(cache_name, &cache_info))
3676 cache_info.st_mtime = 0;
3677
3678 snprintf(ppd_name, sizeof(ppd_name), "%s/ppd/%s.ppd", ServerRoot, p->name);
3679 if (stat(ppd_name, &ppd_info))
3680 ppd_info.st_mtime = 1;
3681
3682 ippDelete(p->ppd_attrs);
3683 p->ppd_attrs = NULL;
3684
3685 _ppdCacheDestroy(p->pc);
3686 p->pc = NULL;
3687
3688 if (cache_info.st_mtime >= ppd_info.st_mtime)
3689 {
3690 cupsdLogMessage(CUPSD_LOG_DEBUG, "load_ppd: Loading %s...", cache_name);
3691
3692 if ((p->pc = _ppdCacheCreateWithFile(cache_name, &p->ppd_attrs)) != NULL &&
3693 p->ppd_attrs)
3694 {
3695 /*
3696 * Loaded successfully!
3697 */
3698
3699 return;
3700 }
3701 }
3702
3703 /*
3704 * Reload PPD attributes from disk...
3705 */
3706
3707 cupsdMarkDirty(CUPSD_DIRTY_PRINTERS);
3708
3709 cupsdLogMessage(CUPSD_LOG_DEBUG, "load_ppd: Loading %s...", ppd_name);
3710
3711 p->type &= (cups_ptype_t)~CUPS_PRINTER_OPTIONS;
3712 p->type |= CUPS_PRINTER_BW;
3713
3714 finishings[0] = IPP_FINISHINGS_NONE;
3715 num_finishings = 1;
3716
3717 p->ppd_attrs = ippNew();
3718
3719 if ((ppd = _ppdOpenFile(ppd_name, _PPD_LOCALIZATION_NONE)) != NULL)
3720 {
3721 /*
3722 * Add make/model and other various attributes...
3723 */
3724
3725 p->pc = _ppdCacheCreateWithPPD(ppd);
3726
3727 if (!p->pc)
3728 cupsdLogMessage(CUPSD_LOG_WARN, "Unable to create cache of \"%s\": %s",
3729 ppd_name, cupsLastErrorString());
3730
3731 ppdMarkDefaults(ppd);
3732
3733 if (ppd->color_device)
3734 p->type |= CUPS_PRINTER_COLOR;
3735 if (ppd->variable_sizes)
3736 p->type |= CUPS_PRINTER_VARIABLE;
3737 if (!ppd->manual_copies)
3738 p->type |= CUPS_PRINTER_COPIES;
3739 if ((ppd_attr = ppdFindAttr(ppd, "cupsFax", NULL)) != NULL)
3740 if (ppd_attr->value && !_cups_strcasecmp(ppd_attr->value, "true"))
3741 p->type |= CUPS_PRINTER_FAX;
3742
3743 ippAddBoolean(p->ppd_attrs, IPP_TAG_PRINTER, "color-supported", (char)ppd->color_device);
3744
3745 if (p->pc && p->pc->charge_info_uri)
3746 ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_URI,
3747 "printer-charge-info-uri", NULL, p->pc->charge_info_uri);
3748
3749 if (p->pc && p->pc->account_id)
3750 ippAddBoolean(p->ppd_attrs, IPP_TAG_PRINTER, "job-account-id-supported",
3751 1);
3752
3753 if (p->pc && p->pc->accounting_user_id)
3754 ippAddBoolean(p->ppd_attrs, IPP_TAG_PRINTER,
3755 "job-accounting-user-id-supported", 1);
3756
3757 if (p->pc && p->pc->password)
3758 {
3759 ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
3760 "job-password-encryption-supported", NULL, "none");
3761 ippAddInteger(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
3762 "job-password-supported", (int)strlen(p->pc->password));
3763 }
3764
3765 if (ppd->throughput)
3766 {
3767 ippAddInteger(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
3768 "pages-per-minute", ppd->throughput);
3769 if (ppd->color_device)
3770 ippAddInteger(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
3771 "pages-per-minute-color", ppd->throughput);
3772 }
3773 else
3774 {
3775 /*
3776 * When there is no speed information, just say "1 page per minute".
3777 */
3778
3779 ippAddInteger(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
3780 "pages-per-minute", 1);
3781 if (ppd->color_device)
3782 ippAddInteger(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
3783 "pages-per-minute-color", 1);
3784 }
3785
3786 num_qualities = 0;
3787
3788 if ((output_mode = ppdFindOption(ppd, "OutputMode")) != NULL)
3789 {
3790 if (ppdFindChoice(output_mode, "draft") ||
3791 ppdFindChoice(output_mode, "fast"))
3792 qualities[num_qualities ++] = IPP_QUALITY_DRAFT;
3793
3794 qualities[num_qualities ++] = IPP_QUALITY_NORMAL;
3795
3796 if (ppdFindChoice(output_mode, "best") ||
3797 ppdFindChoice(output_mode, "high"))
3798 qualities[num_qualities ++] = IPP_QUALITY_HIGH;
3799 }
3800 else if ((ppd_attr = ppdFindAttr(ppd, "APPrinterPreset", NULL)) != NULL)
3801 {
3802 do
3803 {
3804 if (strstr(ppd_attr->spec, "draft") ||
3805 strstr(ppd_attr->spec, "Draft"))
3806 {
3807 qualities[num_qualities ++] = IPP_QUALITY_DRAFT;
3808 break;
3809 }
3810 }
3811 while ((ppd_attr = ppdFindNextAttr(ppd, "APPrinterPreset",
3812 NULL)) != NULL);
3813
3814 qualities[num_qualities ++] = IPP_QUALITY_NORMAL;
3815 qualities[num_qualities ++] = IPP_QUALITY_HIGH;
3816 }
3817 else
3818 qualities[num_qualities ++] = IPP_QUALITY_NORMAL;
3819
3820 ippAddIntegers(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_ENUM,
3821 "print-quality-supported", num_qualities, qualities);
3822
3823 if (ppd->nickname)
3824 {
3825 /*
3826 * The NickName can be localized in the character set specified
3827 * by the LanugageEncoding attribute. However, ppdOpen2() has
3828 * already converted the ppd->nickname member to UTF-8 for us
3829 * (the original attribute value is available separately)
3830 */
3831
3832 cupsdSetString(&p->make_model, ppd->nickname);
3833 }
3834 else if (ppd->modelname)
3835 {
3836 /*
3837 * Model name can only contain specific characters...
3838 */
3839
3840 cupsdSetString(&p->make_model, ppd->modelname);
3841 }
3842 else
3843 cupsdSetString(&p->make_model, "Bad PPD File");
3844
3845 ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_TEXT,
3846 "printer-make-and-model", NULL, p->make_model);
3847
3848 /*
3849 * Add media options from the PPD file...
3850 */
3851
3852 if (ppd->num_sizes == 0 || !p->pc)
3853 {
3854 if (!ppdFindAttr(ppd, "APScannerOnly", NULL))
3855 cupsdLogMessage(CUPSD_LOG_CRIT,
3856 "The PPD file for printer %s contains no media "
3857 "options and is therefore invalid!", p->name);
3858
3859 ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
3860 "media-default", NULL, "unknown");
3861 ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
3862 "media-supported", NULL, "unknown");
3863 }
3864 else
3865 {
3866 /*
3867 * media-default
3868 */
3869
3870 if ((size = ppdPageSize(ppd, NULL)) != NULL)
3871 pwgsize = _ppdCacheGetSize(p->pc, size->name);
3872 else
3873 pwgsize = NULL;
3874
3875 ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
3876 "media-default", NULL,
3877 pwgsize ? pwgsize->map.pwg : "unknown");
3878
3879 /*
3880 * media-col-default
3881 */
3882
3883 if (pwgsize)
3884 {
3885 ipp_t *col; /* Collection value */
3886
3887 input_slot = ppdFindMarkedChoice(ppd, "InputSlot");
3888 media_type = ppdFindMarkedChoice(ppd, "MediaType");
3889 col = new_media_col(pwgsize,
3890 input_slot ?
3891 _ppdCacheGetSource(p->pc,
3892 input_slot->choice) :
3893 NULL,
3894 media_type ?
3895 _ppdCacheGetType(p->pc,
3896 media_type->choice) :
3897 NULL);
3898
3899 ippAddCollection(p->ppd_attrs, IPP_TAG_PRINTER, "media-col-default",
3900 col);
3901 ippDelete(col);
3902 }
3903
3904 /*
3905 * media-supported
3906 */
3907
3908 num_media = p->pc->num_sizes;
3909 if (p->pc->custom_min_keyword)
3910 num_media += 2;
3911
3912 if ((attr = ippAddStrings(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
3913 "media-supported", num_media, NULL,
3914 NULL)) != NULL)
3915 {
3916 val = attr->values;
3917
3918 for (i = p->pc->num_sizes, pwgsize = p->pc->sizes;
3919 i > 0;
3920 i --, pwgsize ++, val ++)
3921 val->string.text = _cupsStrAlloc(pwgsize->map.pwg);
3922
3923 if (p->pc->custom_min_keyword)
3924 {
3925 val->string.text = _cupsStrAlloc(p->pc->custom_min_keyword);
3926 val ++;
3927 val->string.text = _cupsStrAlloc(p->pc->custom_max_keyword);
3928 }
3929 }
3930
3931 /*
3932 * media-size-supported
3933 */
3934
3935 num_media = p->pc->num_sizes;
3936 if (p->pc->custom_min_keyword)
3937 num_media ++;
3938
3939 if ((attr = ippAddCollections(p->ppd_attrs, IPP_TAG_PRINTER,
3940 "media-size-supported", num_media,
3941 NULL)) != NULL)
3942 {
3943 val = attr->values;
3944
3945 for (i = p->pc->num_sizes, pwgsize = p->pc->sizes;
3946 i > 0;
3947 i --, pwgsize ++, val ++)
3948 {
3949 val->collection = ippNew();
3950 ippAddInteger(val->collection, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
3951 "x-dimension", pwgsize->width);
3952 ippAddInteger(val->collection, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
3953 "y-dimension", pwgsize->length);
3954 }
3955
3956 if (p->pc->custom_min_keyword)
3957 {
3958 val->collection = ippNew();
3959 ippAddRange(val->collection, IPP_TAG_PRINTER, "x-dimension",
3960 p->pc->custom_min_width, p->pc->custom_max_width);
3961 ippAddRange(val->collection, IPP_TAG_PRINTER, "y-dimension",
3962 p->pc->custom_min_length, p->pc->custom_max_length);
3963 }
3964 }
3965
3966 /*
3967 * media-source-supported
3968 */
3969
3970 if (p->pc->num_sources > 0 &&
3971 (attr = ippAddStrings(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
3972 "media-source-supported", p->pc->num_sources,
3973 NULL, NULL)) != NULL)
3974 {
3975 for (i = p->pc->num_sources, pwgsource = p->pc->sources,
3976 val = attr->values;
3977 i > 0;
3978 i --, pwgsource ++, val ++)
3979 val->string.text = _cupsStrAlloc(pwgsource->pwg);
3980 }
3981
3982 /*
3983 * media-type-supported
3984 */
3985
3986 if (p->pc->num_types > 0 &&
3987 (attr = ippAddStrings(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
3988 "media-type-supported", p->pc->num_types,
3989 NULL, NULL)) != NULL)
3990 {
3991 for (i = p->pc->num_types, pwgtype = p->pc->types,
3992 val = attr->values;
3993 i > 0;
3994 i --, pwgtype ++, val ++)
3995 val->string.text = _cupsStrAlloc(pwgtype->pwg);
3996 }
3997
3998 /*
3999 * media-*-margin-supported
4000 */
4001
4002 for (i = p->pc->num_sizes, pwgsize = p->pc->sizes, num_margins = 0;
4003 i > 0 && num_margins < (int)(sizeof(margins) / sizeof(margins[0]));
4004 i --, pwgsize ++)
4005 {
4006 for (j = 0; j < num_margins; j ++)
4007 if (pwgsize->bottom == margins[j])
4008 break;
4009
4010 if (j >= num_margins)
4011 {
4012 margins[num_margins] = pwgsize->bottom;
4013 num_margins ++;
4014 }
4015 }
4016
4017 if (num_margins > 0)
4018 ippAddIntegers(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
4019 "media-bottom-margin-supported", num_margins, margins);
4020 else
4021 ippAddInteger(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
4022 "media-bottom-margin-supported", 0);
4023
4024 for (i = p->pc->num_sizes, pwgsize = p->pc->sizes, num_margins = 0;
4025 i > 0 && num_margins < (int)(sizeof(margins) / sizeof(margins[0]));
4026 i --, pwgsize ++)
4027 {
4028 for (j = 0; j < num_margins; j ++)
4029 if (pwgsize->left == margins[j])
4030 break;
4031
4032 if (j >= num_margins)
4033 {
4034 margins[num_margins] = pwgsize->left;
4035 num_margins ++;
4036 }
4037 }
4038
4039 if (num_margins > 0)
4040 ippAddIntegers(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
4041 "media-left-margin-supported", num_margins, margins);
4042 else
4043 ippAddInteger(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
4044 "media-left-margin-supported", 0);
4045
4046 for (i = p->pc->num_sizes, pwgsize = p->pc->sizes, num_margins = 0;
4047 i > 0 && num_margins < (int)(sizeof(margins) / sizeof(margins[0]));
4048 i --, pwgsize ++)
4049 {
4050 for (j = 0; j < num_margins; j ++)
4051 if (pwgsize->right == margins[j])
4052 break;
4053
4054 if (j >= num_margins)
4055 {
4056 margins[num_margins] = pwgsize->right;
4057 num_margins ++;
4058 }
4059 }
4060
4061 if (num_margins > 0)
4062 ippAddIntegers(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
4063 "media-right-margin-supported", num_margins, margins);
4064 else
4065 ippAddInteger(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
4066 "media-right-margin-supported", 0);
4067
4068 for (i = p->pc->num_sizes, pwgsize = p->pc->sizes, num_margins = 0;
4069 i > 0 && num_margins < (int)(sizeof(margins) / sizeof(margins[0]));
4070 i --, pwgsize ++)
4071 {
4072 for (j = 0; j < num_margins; j ++)
4073 if (pwgsize->top == margins[j])
4074 break;
4075
4076 if (j >= num_margins)
4077 {
4078 margins[num_margins] = pwgsize->top;
4079 num_margins ++;
4080 }
4081 }
4082
4083 if (num_margins > 0)
4084 ippAddIntegers(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
4085 "media-top-margin-supported", num_margins, margins);
4086 else
4087 ippAddInteger(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
4088 "media-top-margin-supported", 0);
4089
4090 /*
4091 * media-col-database
4092 */
4093
4094 num_media = p->pc->num_sizes;
4095 if (p->pc->num_sources)
4096 {
4097 if (p->pc->num_types > 0)
4098 num_media += p->pc->num_sizes * p->pc->num_sources *
4099 p->pc->num_types;
4100 else
4101 num_media += p->pc->num_sizes * p->pc->num_sources;
4102 }
4103 else if (p->pc->num_types)
4104 num_media += p->pc->num_sizes * p->pc->num_types;
4105
4106 if ((attr = ippAddCollections(p->ppd_attrs, IPP_TAG_PRINTER,
4107 "media-col-database", num_media,
4108 NULL)) != NULL)
4109 {
4110 for (i = p->pc->num_sizes, pwgsize = p->pc->sizes, val = attr->values;
4111 i > 0;
4112 i --, pwgsize ++)
4113 {
4114 /*
4115 * Start by adding the page size without source or type...
4116 */
4117
4118 ppdMarkOption(ppd, "PageSize", pwgsize->map.ppd);
4119
4120 val->collection = new_media_col(pwgsize, NULL, NULL);
4121 val ++;
4122
4123 /*
4124 * Then add the specific, supported combinations of size, source, and
4125 * type...
4126 */
4127
4128 if (p->pc->num_sources > 0)
4129 {
4130 for (j = p->pc->num_sources, pwgsource = p->pc->sources;
4131 j > 0;
4132 j --, pwgsource ++)
4133 {
4134 ppdMarkOption(ppd, "InputSlot", pwgsource->ppd);
4135
4136 if (p->pc->num_types > 0)
4137 {
4138 for (k = p->pc->num_types, pwgtype = p->pc->types;
4139 k > 0;
4140 k --, pwgtype ++)
4141 {
4142 if (!ppdMarkOption(ppd, "MediaType", pwgtype->ppd))
4143 {
4144 val->collection = new_media_col(pwgsize, pwgsource->pwg,
4145 pwgtype->pwg);
4146 val ++;
4147 }
4148 }
4149 }
4150 else if (!ppdConflicts(ppd))
4151 {
4152 val->collection = new_media_col(pwgsize, pwgsource->pwg, NULL);
4153 val ++;
4154 }
4155 }
4156 }
4157 else if (p->pc->num_types > 0)
4158 {
4159 for (j = p->pc->num_types, pwgtype = p->pc->types;
4160 j > 0;
4161 j --, pwgtype ++)
4162 {
4163 if (!ppdMarkOption(ppd, "MediaType", pwgtype->ppd))
4164 {
4165 val->collection = new_media_col(pwgsize, NULL, pwgtype->pwg);
4166 val ++;
4167 }
4168 }
4169 }
4170 }
4171
4172 /*
4173 * Update the number of media-col-database values...
4174 */
4175
4176 attr->num_values = val - attr->values;
4177 }
4178 }
4179
4180 /*
4181 * Output bin...
4182 */
4183
4184 if (p->pc && p->pc->num_bins > 0)
4185 {
4186 attr = ippAddStrings(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
4187 "output-bin-supported", p->pc->num_bins,
4188 NULL, NULL);
4189
4190 if (attr != NULL)
4191 {
4192 for (i = 0, val = attr->values;
4193 i < p->pc->num_bins;
4194 i ++, val ++)
4195 val->string.text = _cupsStrAlloc(p->pc->bins[i].pwg);
4196 }
4197
4198 if ((output_bin = ppdFindOption(ppd, "OutputBin")) != NULL)
4199 {
4200 for (i = 0; i < p->pc->num_bins; i ++)
4201 if (!strcmp(p->pc->bins[i].ppd, output_bin->defchoice))
4202 break;
4203
4204 if (i >= p->pc->num_bins)
4205 i = 0;
4206
4207 ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
4208 "output-bin-default", NULL, p->pc->bins[i].pwg);
4209 }
4210 else
4211 ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
4212 "output-bin-default", NULL, p->pc->bins[0].pwg);
4213 }
4214 else if (((ppd_attr = ppdFindAttr(ppd, "DefaultOutputOrder",
4215 NULL)) != NULL &&
4216 !_cups_strcasecmp(ppd_attr->value, "Reverse")) ||
4217 (!ppd_attr && ppd->manufacturer && /* "Compatibility heuristic" */
4218 (!_cups_strcasecmp(ppd->manufacturer, "epson") ||
4219 !_cups_strcasecmp(ppd->manufacturer, "lexmark"))))
4220 {
4221 /*
4222 * Report that this printer has a single output bin that leaves pages face
4223 * up.
4224 */
4225
4226 ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
4227 "output-bin-supported", NULL, "face-up");
4228 ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
4229 "output-bin-default", NULL, "face-up");
4230 }
4231 else
4232 {
4233 ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
4234 "output-bin-supported", NULL, "face-down");
4235 ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
4236 "output-bin-default", NULL, "face-down");
4237 }
4238
4239 /*
4240 * print-color-mode...
4241 */
4242
4243 if (ppd->color_device)
4244 {
4245 static const char * const color_modes[] =
4246 {
4247 "monochrome",
4248 "color"
4249 };
4250
4251 ippAddStrings(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
4252 "print-color-mode-supported", 2, NULL, color_modes);
4253 ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
4254 "print-color-mode-default", NULL, "color");
4255 }
4256 else
4257 {
4258 ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
4259 "print-color-mode-supported", NULL, "monochrome");
4260 ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
4261 "print-color-mode-default", NULL, "monochrome");
4262 }
4263
4264 /*
4265 * Mandatory job attributes, if any...
4266 */
4267
4268 if (p->pc && cupsArrayCount(p->pc->mandatory) > 0)
4269 {
4270 int count = cupsArrayCount(p->pc->mandatory);
4271 /* Number of mandatory attributes */
4272
4273 attr = ippAddStrings(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
4274 "printer-mandatory-job-attributes", count, NULL,
4275 NULL);
4276
4277 for (val = attr->values,
4278 mandatory = (char *)cupsArrayFirst(p->pc->mandatory);
4279 mandatory;
4280 val ++, mandatory = (char *)cupsArrayNext(p->pc->mandatory))
4281 val->string.text = _cupsStrAlloc(mandatory);
4282 }
4283
4284 /*
4285 * Printer resolutions...
4286 */
4287
4288 if ((resolution = ppdFindOption(ppd, "Resolution")) == NULL)
4289 if ((resolution = ppdFindOption(ppd, "JCLResolution")) == NULL)
4290 if ((resolution = ppdFindOption(ppd, "SetResolution")) == NULL)
4291 resolution = ppdFindOption(ppd, "CNRes_PGP");
4292
4293 if (resolution)
4294 {
4295 /*
4296 * Report all supported resolutions...
4297 */
4298
4299 attr = ippAddResolutions(p->ppd_attrs, IPP_TAG_PRINTER,
4300 "printer-resolution-supported",
4301 resolution->num_choices, IPP_RES_PER_INCH,
4302 NULL, NULL);
4303
4304 for (i = 0, choice = resolution->choices;
4305 i < resolution->num_choices;
4306 i ++, choice ++)
4307 {
4308 xdpi = ydpi = (int)strtol(choice->choice, (char **)&resptr, 10);
4309 if (resptr > choice->choice && xdpi > 0 && *resptr == 'x')
4310 ydpi = (int)strtol(resptr + 1, (char **)&resptr, 10);
4311
4312 if (xdpi <= 0 || ydpi <= 0)
4313 {
4314 cupsdLogMessage(CUPSD_LOG_WARN,
4315 "Bad resolution \"%s\" for printer %s.",
4316 choice->choice, p->name);
4317 xdpi = ydpi = 300;
4318 }
4319
4320 attr->values[i].resolution.xres = xdpi;
4321 attr->values[i].resolution.yres = ydpi;
4322 attr->values[i].resolution.units = IPP_RES_PER_INCH;
4323
4324 if (choice->marked)
4325 ippAddResolution(p->ppd_attrs, IPP_TAG_PRINTER,
4326 "printer-resolution-default", IPP_RES_PER_INCH,
4327 xdpi, ydpi);
4328 }
4329 }
4330 else if ((ppd_attr = ppdFindAttr(ppd, "DefaultResolution", NULL)) != NULL &&
4331 ppd_attr->value)
4332 {
4333 /*
4334 * Just the DefaultResolution to report...
4335 */
4336
4337 xdpi = ydpi = (int)strtol(ppd_attr->value, (char **)&resptr, 10);
4338 if (resptr > ppd_attr->value && xdpi > 0)
4339 {
4340 if (*resptr == 'x')
4341 ydpi = (int)strtol(resptr + 1, (char **)&resptr, 10);
4342 else
4343 ydpi = xdpi;
4344 }
4345
4346 if (xdpi <= 0 || ydpi <= 0)
4347 {
4348 cupsdLogMessage(CUPSD_LOG_WARN,
4349 "Bad default resolution \"%s\" for printer %s.",
4350 ppd_attr->value, p->name);
4351 xdpi = ydpi = 300;
4352 }
4353
4354 ippAddResolution(p->ppd_attrs, IPP_TAG_PRINTER,
4355 "printer-resolution-default", IPP_RES_PER_INCH,
4356 xdpi, ydpi);
4357 ippAddResolution(p->ppd_attrs, IPP_TAG_PRINTER,
4358 "printer-resolution-supported", IPP_RES_PER_INCH,
4359 xdpi, ydpi);
4360 }
4361 else
4362 {
4363 /*
4364 * No resolutions in PPD - make one up...
4365 */
4366
4367 ippAddResolution(p->ppd_attrs, IPP_TAG_PRINTER,
4368 "printer-resolution-default", IPP_RES_PER_INCH,
4369 300, 300);
4370 ippAddResolution(p->ppd_attrs, IPP_TAG_PRINTER,
4371 "printer-resolution-supported", IPP_RES_PER_INCH,
4372 300, 300);
4373 }
4374
4375 /*
4376 * Duplexing, etc...
4377 */
4378
4379 ppdMarkDefaults(ppd);
4380
4381 if ((duplex = ppdFindOption(ppd, "Duplex")) == NULL)
4382 if ((duplex = ppdFindOption(ppd, "EFDuplex")) == NULL)
4383 if ((duplex = ppdFindOption(ppd, "EFDuplexing")) == NULL)
4384 if ((duplex = ppdFindOption(ppd, "KD03Duplex")) == NULL)
4385 duplex = ppdFindOption(ppd, "JCLDuplex");
4386
4387 if (duplex && duplex->num_choices > 1 &&
4388 !ppdInstallableConflict(ppd, duplex->keyword, "DuplexTumble"))
4389 {
4390 p->type |= CUPS_PRINTER_DUPLEX;
4391
4392 ippAddStrings(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
4393 "sides-supported", 3, NULL, sides);
4394
4395 if (!_cups_strcasecmp(duplex->defchoice, "DuplexTumble"))
4396 ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
4397 "sides-default", NULL, "two-sided-short-edge");
4398 else if (!_cups_strcasecmp(duplex->defchoice, "DuplexNoTumble"))
4399 ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
4400 "sides-default", NULL, "two-sided-long-edge");
4401 else
4402 ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
4403 "sides-default", NULL, "one-sided");
4404 }
4405 else
4406 {
4407 ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
4408 "sides-supported", NULL, "one-sided");
4409 ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
4410 "sides-default", NULL, "one-sided");
4411 }
4412
4413 if (ppdFindOption(ppd, "Collate") != NULL)
4414 p->type |= CUPS_PRINTER_COLLATE;
4415
4416 if (ppdFindOption(ppd, "StapleLocation") != NULL)
4417 {
4418 p->type |= CUPS_PRINTER_STAPLE;
4419 finishings[num_finishings++] = IPP_FINISHINGS_STAPLE;
4420 }
4421
4422 if (ppdFindOption(ppd, "BindEdge") != NULL)
4423 {
4424 p->type |= CUPS_PRINTER_BIND;
4425 finishings[num_finishings++] = IPP_FINISHINGS_BIND;
4426 }
4427
4428 for (i = 0; i < ppd->num_sizes; i ++)
4429 if (ppd->sizes[i].length > 1728)
4430 p->type |= CUPS_PRINTER_LARGE;
4431 else if (ppd->sizes[i].length > 1008)
4432 p->type |= CUPS_PRINTER_MEDIUM;
4433 else
4434 p->type |= CUPS_PRINTER_SMALL;
4435
4436 if ((ppd_attr = ppdFindAttr(ppd, "APICADriver", NULL)) != NULL &&
4437 ppd_attr->value && !_cups_strcasecmp(ppd_attr->value, "true"))
4438 {
4439 if ((ppd_attr = ppdFindAttr(ppd, "APScannerOnly", NULL)) != NULL &&
4440 ppd_attr->value && !_cups_strcasecmp(ppd_attr->value, "true"))
4441 p->type |= CUPS_PRINTER_SCANNER;
4442 else
4443 p->type |= CUPS_PRINTER_MFP;
4444 }
4445
4446 /*
4447 * Scan the filters in the PPD file...
4448 */
4449
4450 if (p->pc)
4451 {
4452 for (filter = (const char *)cupsArrayFirst(p->pc->filters);
4453 filter;
4454 filter = (const char *)cupsArrayNext(p->pc->filters))
4455 {
4456 if (!_cups_strncasecmp(filter, "application/vnd.cups-command", 28) &&
4457 _cups_isspace(filter[28]))
4458 {
4459 p->type |= CUPS_PRINTER_COMMANDS;
4460 break;
4461 }
4462 }
4463 }
4464
4465 if (p->type & CUPS_PRINTER_COMMANDS)
4466 {
4467 char *commands, /* Copy of commands */
4468 *start, /* Start of name */
4469 *end; /* End of name */
4470 int count; /* Number of commands */
4471
4472 if ((ppd_attr = ppdFindAttr(ppd, "cupsCommands", NULL)) != NULL)
4473 {
4474 for (count = 0, start = ppd_attr->value; *start; count ++)
4475 {
4476 while (_cups_isspace(*start))
4477 start ++;
4478
4479 if (!*start)
4480 break;
4481
4482 while (*start && !isspace(*start & 255))
4483 start ++;
4484 }
4485 }
4486 else
4487 count = 0;
4488
4489 if (count > 0)
4490 {
4491 /*
4492 * Make a copy of the commands string and count how many commands there
4493 * are...
4494 */
4495
4496 attr = ippAddStrings(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
4497 "printer-commands", count, NULL, NULL);
4498
4499 commands = strdup(ppd_attr->value);
4500
4501 for (count = 0, start = commands; *start; count ++)
4502 {
4503 while (isspace(*start & 255))
4504 start ++;
4505
4506 if (!*start)
4507 break;
4508
4509 end = start;
4510 while (*end && !isspace(*end & 255))
4511 end ++;
4512
4513 if (*end)
4514 *end++ = '\0';
4515
4516 attr->values[count].string.text = _cupsStrAlloc(start);
4517
4518 start = end;
4519 }
4520
4521 free(commands);
4522 }
4523 else
4524 {
4525 /*
4526 * Add the standard list of commands...
4527 */
4528
4529 ippAddStrings(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
4530 "printer-commands",
4531 (int)(sizeof(standard_commands) /
4532 sizeof(standard_commands[0])), NULL,
4533 standard_commands);
4534 }
4535 }
4536 else
4537 {
4538 /*
4539 * No commands supported...
4540 */
4541
4542 ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
4543 "printer-commands", NULL, "none");
4544 }
4545
4546 /*
4547 * Show current and available port monitors for this printer...
4548 */
4549
4550 ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_NAME, "port-monitor",
4551 NULL, p->port_monitor ? p->port_monitor : "none");
4552
4553 for (i = 1, ppd_attr = ppdFindAttr(ppd, "cupsPortMonitor", NULL);
4554 ppd_attr;
4555 i ++, ppd_attr = ppdFindNextAttr(ppd, "cupsPortMonitor", NULL));
4556
4557 if (ppd->protocols)
4558 {
4559 if (strstr(ppd->protocols, "TBCP"))
4560 i ++;
4561 else if (strstr(ppd->protocols, "BCP"))
4562 i ++;
4563 }
4564
4565 attr = ippAddStrings(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_NAME,
4566 "port-monitor-supported", i, NULL, NULL);
4567
4568 attr->values[0].string.text = _cupsStrAlloc("none");
4569
4570 for (i = 1, ppd_attr = ppdFindAttr(ppd, "cupsPortMonitor", NULL);
4571 ppd_attr;
4572 i ++, ppd_attr = ppdFindNextAttr(ppd, "cupsPortMonitor", NULL))
4573 attr->values[i].string.text = _cupsStrAlloc(ppd_attr->value);
4574
4575 if (ppd->protocols)
4576 {
4577 if (strstr(ppd->protocols, "TBCP"))
4578 attr->values[i].string.text = _cupsStrAlloc("tbcp");
4579 else if (strstr(ppd->protocols, "BCP"))
4580 attr->values[i].string.text = _cupsStrAlloc("bcp");
4581 }
4582
4583 if (ppdFindAttr(ppd, "APRemoteQueueID", NULL))
4584 p->type |= CUPS_PRINTER_REMOTE;
4585
4586 #ifdef HAVE_APPLICATIONSERVICES_H
4587 /*
4588 * Convert the file referenced in APPrinterIconPath to a 128x128 PNG
4589 * and save it as cacheDir/printername.png
4590 */
4591
4592 if ((ppd_attr = ppdFindAttr(ppd, "APPrinterIconPath", NULL)) != NULL &&
4593 ppd_attr->value &&
4594 !_cupsFileCheck(ppd_attr->value, _CUPS_FILE_CHECK_FILE, !RunUser,
4595 cupsdLogFCMessage, p))
4596 {
4597 CGImageRef imageRef = NULL;/* Current icon image */
4598 CGImageRef biggestIconRef = NULL;
4599 /* Biggest icon image */
4600 CGImageRef closestTo128IconRef = NULL;
4601 /* Icon image closest to and >= 128 */
4602 CGImageSourceRef sourceRef; /* The file's image source */
4603 char outPath[HTTP_MAX_URI];
4604 /* The path to the PNG file */
4605 CFURLRef outUrl; /* The URL made from the outPath */
4606 CFURLRef icnsFileUrl; /* The URL of the original ICNS icon file */
4607 CGImageDestinationRef destRef; /* The image destination to write */
4608 size_t bytesPerRow; /* The bytes per row used for resizing */
4609 CGContextRef context; /* The CG context used for resizing */
4610
4611 snprintf(outPath, sizeof(outPath), "%s/%s.png", CacheDir, p->name);
4612 outUrl = CFURLCreateFromFileSystemRepresentation(kCFAllocatorDefault, (UInt8 *)outPath, (CFIndex)strlen(outPath), FALSE);
4613 icnsFileUrl = CFURLCreateFromFileSystemRepresentation(kCFAllocatorDefault, (UInt8 *)ppd_attr->value, (CFIndex)strlen(ppd_attr->value), FALSE);
4614 if (outUrl && icnsFileUrl)
4615 {
4616 sourceRef = CGImageSourceCreateWithURL(icnsFileUrl, NULL);
4617 if (sourceRef)
4618 {
4619 for (i = 0; i < (int)CGImageSourceGetCount(sourceRef); i ++)
4620 {
4621 imageRef = CGImageSourceCreateImageAtIndex(sourceRef, (size_t)i, NULL);
4622 if (!imageRef)
4623 continue;
4624
4625 if (CGImageGetWidth(imageRef) == CGImageGetHeight(imageRef))
4626 {
4627 /*
4628 * Loop through remembering the icon closest to 128 but >= 128
4629 * and then remember the largest icon.
4630 */
4631
4632 if (CGImageGetWidth(imageRef) >= 128 &&
4633 (!closestTo128IconRef ||
4634 CGImageGetWidth(imageRef) <
4635 CGImageGetWidth(closestTo128IconRef)))
4636 {
4637 CGImageRelease(closestTo128IconRef);
4638 CGImageRetain(imageRef);
4639 closestTo128IconRef = imageRef;
4640 }
4641
4642 if (!biggestIconRef ||
4643 CGImageGetWidth(imageRef) > CGImageGetWidth(biggestIconRef))
4644 {
4645 CGImageRelease(biggestIconRef);
4646 CGImageRetain(imageRef);
4647 biggestIconRef = imageRef;
4648 }
4649 }
4650
4651 CGImageRelease(imageRef);
4652 }
4653
4654 if (biggestIconRef)
4655 {
4656 /*
4657 * If biggestIconRef is NULL, we found no icons. Otherwise we first
4658 * want the closest to 128, but if none are larger than 128, we want
4659 * the largest icon available.
4660 */
4661
4662 imageRef = closestTo128IconRef ? closestTo128IconRef :
4663 biggestIconRef;
4664 CGImageRetain(imageRef);
4665 CGImageRelease(biggestIconRef);
4666 if (closestTo128IconRef)
4667 CGImageRelease(closestTo128IconRef);
4668 destRef = CGImageDestinationCreateWithURL(outUrl, kUTTypePNG, 1,
4669 NULL);
4670 if (destRef)
4671 {
4672 if (CGImageGetWidth(imageRef) != 128)
4673 {
4674 bytesPerRow = CGImageGetBytesPerRow(imageRef) /
4675 CGImageGetWidth(imageRef) * 128;
4676 context = CGBitmapContextCreate(NULL, 128, 128,
4677 CGImageGetBitsPerComponent(imageRef),
4678 bytesPerRow,
4679 CGImageGetColorSpace(imageRef),
4680 kCGImageAlphaPremultipliedFirst);
4681 if (context)
4682 {
4683 CGContextDrawImage(context, CGRectMake(0, 0, 128, 128),
4684 imageRef);
4685 CGImageRelease(imageRef);
4686 imageRef = CGBitmapContextCreateImage(context);
4687 CGContextRelease(context);
4688 }
4689 }
4690
4691 CGImageDestinationAddImage(destRef, imageRef, NULL);
4692 CGImageDestinationFinalize(destRef);
4693 CFRelease(destRef);
4694 }
4695
4696 CGImageRelease(imageRef);
4697 }
4698
4699 CFRelease(sourceRef);
4700 }
4701 }
4702
4703 if (outUrl)
4704 CFRelease(outUrl);
4705
4706 if (icnsFileUrl)
4707 CFRelease(icnsFileUrl);
4708 }
4709 #endif /* HAVE_APPLICATIONSERVICES_H */
4710
4711 /*
4712 * Close the PPD and set the type...
4713 */
4714
4715 ppdClose(ppd);
4716 }
4717 else if (!access(ppd_name, 0))
4718 {
4719 int pline; /* PPD line number */
4720 ppd_status_t pstatus; /* PPD load status */
4721
4722
4723 pstatus = ppdLastError(&pline);
4724
4725 cupsdLogMessage(CUPSD_LOG_ERROR, "PPD file for %s cannot be loaded!",
4726 p->name);
4727
4728 if (pstatus <= PPD_ALLOC_ERROR)
4729 cupsdLogMessage(CUPSD_LOG_ERROR, "%s", strerror(errno));
4730 else
4731 cupsdLogMessage(CUPSD_LOG_ERROR, "%s on line %d.",
4732 ppdErrorString(pstatus), pline);
4733
4734 cupsdLogMessage(CUPSD_LOG_INFO,
4735 "Hint: Run \"cupstestppd %s\" and fix any errors.",
4736 ppd_name);
4737 }
4738 else
4739 {
4740 /*
4741 * If we have an interface script, add a filter entry for it...
4742 */
4743
4744 char interface[1024]; /* Interface script */
4745
4746
4747 snprintf(interface, sizeof(interface), "%s/interfaces/%s", ServerRoot,
4748 p->name);
4749 if (!access(interface, X_OK))
4750 {
4751 /*
4752 * Yes, we have a System V style interface script; use it!
4753 */
4754
4755 ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_TEXT,
4756 "printer-make-and-model", NULL,
4757 "Local System V Printer");
4758 }
4759 else if (((!strncmp(p->device_uri, "ipp://", 6) ||
4760 !strncmp(p->device_uri, "ipps://", 7)) &&
4761 (strstr(p->device_uri, "/printers/") != NULL ||
4762 strstr(p->device_uri, "/classes/") != NULL)) ||
4763 ((strstr(p->device_uri, "._ipp.") != NULL ||
4764 strstr(p->device_uri, "._ipps.") != NULL) &&
4765 !strcmp(p->device_uri + strlen(p->device_uri) - 5, "/cups")))
4766 {
4767 /*
4768 * Tell the client this is really a hard-wired remote printer.
4769 */
4770
4771 p->type |= CUPS_PRINTER_REMOTE;
4772
4773 /*
4774 * Point the printer-uri-supported attribute to the
4775 * remote printer...
4776 */
4777
4778 if (strchr(p->device_uri, '?'))
4779 {
4780 /*
4781 * Strip trailing "?options" from URI...
4782 */
4783
4784 char resource[HTTP_MAX_URI], /* New URI */
4785 *ptr; /* Pointer into URI */
4786
4787 strlcpy(resource, p->device_uri, sizeof(resource));
4788 if ((ptr = strchr(resource, '?')) != NULL)
4789 *ptr = '\0';
4790
4791 ippAddString(p->attrs, IPP_TAG_PRINTER, IPP_TAG_URI,
4792 "printer-uri-supported", NULL, resource);
4793 }
4794 else
4795 ippAddString(p->attrs, IPP_TAG_PRINTER, IPP_TAG_URI,
4796 "printer-uri-supported", NULL, p->device_uri);
4797
4798 /*
4799 * Then set the make-and-model accordingly...
4800 */
4801
4802 ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_TEXT,
4803 "printer-make-and-model", NULL, "Remote Printer");
4804
4805 /*
4806 * Print all files directly...
4807 */
4808
4809 p->raw = 1;
4810 p->remote = 1;
4811 }
4812 else
4813 {
4814 /*
4815 * Otherwise we have neither - treat this as a "dumb" printer
4816 * with no PPD file...
4817 */
4818
4819 ippAddString(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_TEXT,
4820 "printer-make-and-model", NULL, "Local Raw Printer");
4821
4822 p->raw = 1;
4823 }
4824 }
4825
4826 ippAddIntegers(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_ENUM,
4827 "finishings-supported", num_finishings, finishings);
4828 ippAddInteger(p->ppd_attrs, IPP_TAG_PRINTER, IPP_TAG_ENUM,
4829 "finishings-default", IPP_FINISHINGS_NONE);
4830
4831 if (ppd && p->pc)
4832 {
4833 /*
4834 * Save cached PPD attributes to disk...
4835 */
4836
4837 cupsdLogMessage(CUPSD_LOG_DEBUG, "load_ppd: Saving %s...", cache_name);
4838
4839 _ppdCacheWriteFile(p->pc, cache_name, p->ppd_attrs);
4840 }
4841 else
4842 {
4843 /*
4844 * Remove cache files...
4845 */
4846
4847 if (cache_info.st_mtime)
4848 unlink(cache_name);
4849 }
4850 }
4851
4852
4853 /*
4854 * 'new_media_col()' - Create a media-col collection value.
4855 */
4856
4857 static ipp_t * /* O - Collection value */
4858 new_media_col(_pwg_size_t *size, /* I - media-size/margin values */
4859 const char *source, /* I - media-source value */
4860 const char *type) /* I - media-type value */
4861 {
4862 ipp_t *media_col, /* Collection value */
4863 *media_size; /* media-size value */
4864
4865
4866 media_col = ippNew();
4867
4868 media_size = ippNew();
4869 ippAddInteger(media_size, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
4870 "x-dimension", size->width);
4871 ippAddInteger(media_size, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
4872 "y-dimension", size->length);
4873 ippAddCollection(media_col, IPP_TAG_PRINTER, "media-size", media_size);
4874 ippDelete(media_size);
4875
4876 ippAddInteger(media_col, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
4877 "media-bottom-margin", size->bottom);
4878 ippAddInteger(media_col, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
4879 "media-left-margin", size->left);
4880 ippAddInteger(media_col, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
4881 "media-right-margin", size->right);
4882 ippAddInteger(media_col, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
4883 "media-top-margin", size->top);
4884
4885 if (source)
4886 ippAddString(media_col, IPP_TAG_PRINTER, IPP_TAG_KEYWORD, "media-source",
4887 NULL, source);
4888
4889 if (type)
4890 ippAddString(media_col, IPP_TAG_PRINTER, IPP_TAG_KEYWORD, "media-type",
4891 NULL, type);
4892
4893 return (media_col);
4894 }
4895
4896
4897 /*
4898 * 'write_xml_string()' - Write a string with XML escaping.
4899 */
4900
4901 static void
4902 write_xml_string(cups_file_t *fp, /* I - File to write to */
4903 const char *s) /* I - String to write */
4904 {
4905 const char *start; /* Start of current sequence */
4906
4907
4908 if (!s)
4909 return;
4910
4911 for (start = s; *s; s ++)
4912 {
4913 if (*s == '&')
4914 {
4915 if (s > start)
4916 cupsFileWrite(fp, start, (size_t)(s - start));
4917
4918 cupsFilePuts(fp, "&amp;");
4919 start = s + 1;
4920 }
4921 else if (*s == '<')
4922 {
4923 if (s > start)
4924 cupsFileWrite(fp, start, (size_t)(s - start));
4925
4926 cupsFilePuts(fp, "&lt;");
4927 start = s + 1;
4928 }
4929 }
4930
4931 if (s > start)
4932 cupsFilePuts(fp, start);
4933 }
4934
4935
4936 /*
4937 * End of "$Id$".
4938 */
Unnamed repository; edit this file 'description' to name the repository.