]> git.ipfire.org Git - thirdparty/cups.git/blob - systemv/lpstat.c
projects / thirdparty / cups.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge changes from CUPS 1.6svn-r10112.
[thirdparty/cups.git] / systemv / lpstat.c
1 /*
2 * "$Id: lpstat.c 7921 2008-09-10 15:42:24Z mike $"
3 *
4 * "lpstat" command for CUPS.
5 *
6 * Copyright 2007-2011 by Apple Inc.
7 * Copyright 1997-2006 by Easy Software Products.
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 * Contents:
16 *
17 * main() - Parse options and show status information.
18 * check_dest() - Verify that the named destination(s) exists.
19 * match_list() - Match a name from a list of comma or space-separated
20 * names.
21 * show_accepting() - Show acceptance status.
22 * show_classes() - Show printer classes.
23 * show_default() - Show default destination.
24 * show_devices() - Show printer devices.
25 * show_jobs() - Show active print jobs.
26 * show_printers() - Show printers.
27 * show_scheduler() - Show scheduler status.
28 */
29
30 /*
31 * Include necessary headers...
32 */
33
34 #include <cups/cups-private.h>
35
36
37 /*
38 * Local functions...
39 */
40
41 static void check_dest(const char *command, const char *name,
42 int *num_dests, cups_dest_t **dests);
43 static int match_list(const char *list, const char *name);
44 static int show_accepting(const char *printers, int num_dests,
45 cups_dest_t *dests);
46 static int show_classes(const char *dests);
47 static void show_default(cups_dest_t *dest);
48 static int show_devices(const char *printers, int num_dests,
49 cups_dest_t *dests);
50 static int show_jobs(const char *dests, const char *users, int long_status,
51 int ranking, const char *which);
52 static int show_printers(const char *printers, int num_dests,
53 cups_dest_t *dests, int long_status);
54 static void show_scheduler(void);
55
56
57 /*
58 * 'main()' - Parse options and show status information.
59 */
60
61 int
62 main(int argc, /* I - Number of command-line arguments */
63 char *argv[]) /* I - Command-line arguments */
64 {
65 int i, /* Looping var */
66 status; /* Exit status */
67 int num_dests; /* Number of user destinations */
68 cups_dest_t *dests; /* User destinations */
69 int long_status; /* Long status report? */
70 int ranking; /* Show job ranking? */
71 const char *which; /* Which jobs to show? */
72 char op; /* Last operation on command-line */
73
74
75 _cupsSetLocale(argv);
76
77 /*
78 * Parse command-line options...
79 */
80
81 num_dests = 0;
82 dests = NULL;
83 long_status = 0;
84 ranking = 0;
85 status = 0;
86 which = "not-completed";
87 op = 0;
88
89 for (i = 1; i < argc; i ++)
90 if (argv[i][0] == '-')
91 switch (argv[i][1])
92 {
93 case 'D' : /* Show description */
94 long_status = 1;
95 break;
96
97 case 'E' : /* Encrypt */
98 #ifdef HAVE_SSL
99 cupsSetEncryption(HTTP_ENCRYPT_REQUIRED);
100 #else
101 _cupsLangPrintf(stderr,
102 _("%s: Sorry, no encryption support."),
103 argv[0]);
104 #endif /* HAVE_SSL */
105 break;
106
107 case 'H' : /* Show server and port */
108 if (cupsServer()[0] == '/')
109 _cupsLangPuts(stdout, cupsServer());
110 else
111 _cupsLangPrintf(stdout, "%s:%d", cupsServer(), ippPort());
112 break;
113
114 case 'P' : /* Show paper types */
115 op = 'P';
116 break;
117
118 case 'R' : /* Show ranking */
119 ranking = 1;
120 break;
121
122 case 'S' : /* Show charsets */
123 op = 'S';
124 if (!argv[i][2])
125 i ++;
126 break;
127
128 case 'U' : /* Username */
129 if (argv[i][2])
130 cupsSetUser(argv[i] + 2);
131 else
132 {
133 i ++;
134 if (i >= argc)
135 {
136 _cupsLangPrintf(stderr,
137 _("%s: Error - expected username after "
138 "\"-U\" option."),
139 argv[0]);
140 return (1);
141 }
142
143 cupsSetUser(argv[i]);
144 }
145 break;
146
147 case 'W' : /* Show which jobs? */
148 if (argv[i][2])
149 which = argv[i] + 2;
150 else
151 {
152 i ++;
153
154 if (i >= argc)
155 {
156 _cupsLangPrintf(stderr,
157 _("%s: Error - need \"completed\", "
158 "\"not-completed\", or \"all\" after "
159 "\"-W\" option."),
160 argv[0]);
161 return (1);
162 }
163
164 which = argv[i];
165 }
166
167 if (strcmp(which, "completed") && strcmp(which, "not-completed") &&
168 strcmp(which, "all"))
169 {
170 _cupsLangPrintf(stderr,
171 _("%s: Error - need \"completed\", "
172 "\"not-completed\", or \"all\" after "
173 "\"-W\" option."),
174 argv[0]);
175 return (1);
176 }
177 break;
178
179 case 'a' : /* Show acceptance status */
180 op = 'a';
181
182 if (argv[i][2])
183 {
184 check_dest(argv[0], argv[i] + 2, &num_dests, &dests);
185
186 status |= show_accepting(argv[i] + 2, num_dests, dests);
187 }
188 else if ((i + 1) < argc && argv[i + 1][0] != '-')
189 {
190 i ++;
191
192 check_dest(argv[0], argv[i], &num_dests, &dests);
193
194 status |= show_accepting(argv[i], num_dests, dests);
195 }
196 else
197 {
198 if (num_dests <= 1)
199 {
200 cupsFreeDests(num_dests, dests);
201 num_dests = cupsGetDests(&dests);
202 }
203
204 status |= show_accepting(NULL, num_dests, dests);
205 }
206 break;
207
208 #ifdef __sgi
209 case 'b' : /* Show both the local and remote status */
210 op = 'b';
211
212 if (argv[i][2])
213 {
214 /*
215 * The local and remote status are separated by a blank line;
216 * since all CUPS jobs are networked, we only output the
217 * second list for now... In the future, we might further
218 * emulate this by listing the remote server's queue, but
219 * for now this is enough to make the SGI printstatus program
220 * happy...
221 */
222
223 check_dest(argv[0], argv[i] + 2, &num_dests, &dests);
224
225 puts("");
226 status |= show_jobs(argv[i] + 2, NULL, 3, ranking, which);
227 }
228 else
229 {
230 _cupsLangPrintf(stderr,
231 _("%s: Error - expected destination after "
232 "\"-b\" option."),
233 argv[0]);
234
235 return (1);
236 }
237 break;
238 #endif /* __sgi */
239
240 case 'c' : /* Show classes and members */
241 op = 'c';
242
243 if (argv[i][2])
244 {
245 check_dest(argv[0], argv[i] + 2, &num_dests, &dests);
246
247 status |= show_classes(argv[i] + 2);
248 }
249 else if ((i + 1) < argc && argv[i + 1][0] != '-')
250 {
251 i ++;
252
253 check_dest(argv[0], argv[i], &num_dests, &dests);
254
255 status |= show_classes(argv[i]);
256 }
257 else
258 status |= show_classes(NULL);
259 break;
260
261 case 'd' : /* Show default destination */
262 op = 'd';
263
264 if (num_dests != 1 || !dests[0].is_default)
265 {
266 cupsFreeDests(num_dests, dests);
267
268 dests = cupsGetNamedDest(CUPS_HTTP_DEFAULT, NULL, NULL);
269 num_dests = dests ? 1 : 0;
270 }
271
272 show_default(dests);
273 break;
274
275 case 'f' : /* Show forms */
276 op = 'f';
277 if (!argv[i][2])
278 i ++;
279 break;
280
281 case 'h' : /* Connect to host */
282 if (argv[i][2])
283 cupsSetServer(argv[i] + 2);
284 else
285 {
286 i ++;
287
288 if (i >= argc)
289 {
290 _cupsLangPrintf(stderr,
291 _("%s: Error - expected hostname after "
292 "\"-h\" option."),
293 argv[0]);
294 return (1);
295 }
296
297 cupsSetServer(argv[i]);
298 }
299 break;
300
301 case 'l' : /* Long status or long job status */
302 #ifdef __sgi
303 op = 'l';
304
305 if (argv[i][2])
306 {
307 check_dest(argv[0], argv[i] + 2, &num_dests, &dests);
308
309 status |= show_jobs(argv[i] + 2, NULL, 3, ranking, which);
310 }
311 else
312 #endif /* __sgi */
313 long_status = 2;
314 break;
315
316 case 'o' : /* Show jobs by destination */
317 op = 'o';
318
319 if (argv[i][2])
320 {
321 check_dest(argv[0], argv[i] + 2, &num_dests, &dests);
322
323 status |= show_jobs(argv[i] + 2, NULL, long_status, ranking,
324 which);
325 }
326 else if ((i + 1) < argc && argv[i + 1][0] != '-')
327 {
328 i ++;
329
330 check_dest(argv[0], argv[i], &num_dests, &dests);
331
332 status |= show_jobs(argv[i], NULL, long_status, ranking, which);
333 }
334 else
335 status |= show_jobs(NULL, NULL, long_status, ranking, which);
336 break;
337
338 case 'p' : /* Show printers */
339 op = 'p';
340
341 if (argv[i][2])
342 {
343 check_dest(argv[0], argv[i] + 2, &num_dests, &dests);
344
345 status |= show_printers(argv[i] + 2, num_dests, dests,
346 long_status);
347 }
348 else if ((i + 1) < argc && argv[i + 1][0] != '-')
349 {
350 i ++;
351
352 check_dest(argv[0], argv[i], &num_dests, &dests);
353
354 status |= show_printers(argv[i], num_dests, dests, long_status);
355 }
356 else
357 {
358 if (num_dests <= 1)
359 {
360 cupsFreeDests(num_dests, dests);
361 num_dests = cupsGetDests(&dests);
362 }
363
364 status |= show_printers(NULL, num_dests, dests, long_status);
365 }
366 break;
367
368 case 'r' : /* Show scheduler status */
369 op = 'r';
370
371 show_scheduler();
372 break;
373
374 case 's' : /* Show summary */
375 op = 's';
376
377 if (num_dests <= 1)
378 {
379 cupsFreeDests(num_dests, dests);
380 num_dests = cupsGetDests(&dests);
381 }
382
383 show_default(cupsGetDest(NULL, NULL, num_dests, dests));
384 status |= show_classes(NULL);
385 status |= show_devices(NULL, num_dests, dests);
386 break;
387
388 case 't' : /* Show all info */
389 op = 't';
390
391 if (num_dests <= 1)
392 {
393 cupsFreeDests(num_dests, dests);
394 num_dests = cupsGetDests(&dests);
395 }
396
397 show_scheduler();
398 show_default(cupsGetDest(NULL, NULL, num_dests, dests));
399 status |= show_classes(NULL);
400 status |= show_devices(NULL, num_dests, dests);
401 status |= show_accepting(NULL, num_dests, dests);
402 status |= show_printers(NULL, num_dests, dests, long_status);
403 status |= show_jobs(NULL, NULL, long_status, ranking, which);
404 break;
405
406 case 'u' : /* Show jobs by user */
407 op = 'u';
408
409 if (argv[i][2])
410 status |= show_jobs(NULL, argv[i] + 2, long_status, ranking,
411 which);
412 else if ((i + 1) < argc && argv[i + 1][0] != '-')
413 {
414 i ++;
415 status |= show_jobs(NULL, argv[i], long_status, ranking, which);
416 }
417 else
418 status |= show_jobs(NULL, NULL, long_status, ranking, which);
419 break;
420
421 case 'v' : /* Show printer devices */
422 op = 'v';
423
424 if (argv[i][2])
425 {
426 check_dest(argv[0], argv[i] + 2, &num_dests, &dests);
427
428 status |= show_devices(argv[i] + 2, num_dests, dests);
429 }
430 else if ((i + 1) < argc && argv[i + 1][0] != '-')
431 {
432 i ++;
433
434 check_dest(argv[0], argv[i], &num_dests, &dests);
435
436 status |= show_devices(argv[i], num_dests, dests);
437 }
438 else
439 {
440 if (num_dests <= 1)
441 {
442 cupsFreeDests(num_dests, dests);
443 num_dests = cupsGetDests(&dests);
444 }
445
446 status |= show_devices(NULL, num_dests, dests);
447 }
448 break;
449
450 default :
451 _cupsLangPrintf(stderr,
452 _("%s: Error - unknown option \"%c\"."),
453 argv[0], argv[i][1]);
454 return (1);
455 }
456 else
457 {
458 status |= show_jobs(argv[i], NULL, long_status, ranking, which);
459 op = 'o';
460 }
461
462 if (!op)
463 status |= show_jobs(NULL, cupsUser(), long_status, ranking, which);
464
465 return (status);
466 }
467
468
469 /*
470 * 'check_dest()' - Verify that the named destination(s) exists.
471 */
472
473 static void
474 check_dest(const char *command, /* I - Command name */
475 const char *name, /* I - List of printer/class names */
476 int *num_dests, /* IO - Number of destinations */
477 cups_dest_t **dests) /* IO - Destinations */
478 {
479 const char *dptr; /* Pointer into name */
480 char *pptr, /* Pointer into printer */
481 printer[1024]; /* Current printer/class name */
482
483
484 /*
485 * Load the destination list as necessary...
486 */
487
488 if (*num_dests <= 1)
489 {
490 if (*num_dests)
491 cupsFreeDests(*num_dests, *dests);
492
493 if (strchr(name, ','))
494 *num_dests = cupsGetDests(dests);
495 else
496 {
497 strlcpy(printer, name, sizeof(printer));
498 if ((pptr = strchr(printer, '/')) != NULL)
499 *pptr++ = '\0';
500
501 if ((*dests = cupsGetNamedDest(CUPS_HTTP_DEFAULT, printer, pptr)) == NULL)
502 {
503 _cupsLangPrintf(stderr,
504 _("%s: Invalid destination name in list \"%s\"."),
505 command, name);
506 exit(1);
507 }
508 else
509 {
510 *num_dests = 1;
511 return;
512 }
513 }
514 }
515
516 /*
517 * Scan the name string for printer/class name(s)...
518 */
519
520 for (dptr = name; *dptr;)
521 {
522 /*
523 * Skip leading whitespace and commas...
524 */
525
526 while (isspace(*dptr & 255) || *dptr == ',')
527 dptr ++;
528
529 if (!*dptr)
530 break;
531
532 /*
533 * Extract a single destination name from the name string...
534 */
535
536 for (pptr = printer; !isspace(*dptr & 255) && *dptr != ',' && *dptr;)
537 {
538 if ((pptr - printer) < (sizeof(printer) - 1))
539 *pptr++ = *dptr++;
540 else
541 {
542 _cupsLangPrintf(stderr,
543 _("%s: Invalid destination name in list \"%s\"."),
544 command, name);
545 exit(1);
546 }
547 }
548
549 *pptr = '\0';
550
551 /*
552 * Check the destination...
553 */
554
555 if (!cupsGetDest(printer, NULL, *num_dests, *dests))
556 {
557 _cupsLangPrintf(stderr,
558 _("%s: Unknown destination \"%s\"."), command, printer);
559 exit(1);
560 }
561 }
562 }
563
564
565 /*
566 * 'match_list()' - Match a name from a list of comma or space-separated names.
567 */
568
569 static int /* O - 1 on match, 0 on no match */
570 match_list(const char *list, /* I - List of names */
571 const char *name) /* I - Name to find */
572 {
573 const char *nameptr; /* Pointer into name */
574
575
576 /*
577 * An empty list always matches...
578 */
579
580 if (!list || !*list)
581 return (1);
582
583 if (!name)
584 return (0);
585
586 while (*list)
587 {
588 /*
589 * Skip leading whitespace and commas...
590 */
591
592 while (isspace(*list & 255) || *list == ',')
593 list ++;
594
595 if (!*list)
596 break;
597
598 /*
599 * Compare names...
600 */
601
602 for (nameptr = name;
603 *nameptr && *list && tolower(*nameptr & 255) == tolower(*list & 255);
604 nameptr ++, list ++);
605
606 if (!*nameptr && (!*list || *list == ',' || isspace(*list & 255)))
607 return (1);
608
609 while (*list && !isspace(*list & 255) && *list != ',')
610 list ++;
611 }
612
613 return (0);
614 }
615
616
617 /*
618 * 'show_accepting()' - Show acceptance status.
619 */
620
621 static int /* O - 0 on success, 1 on fail */
622 show_accepting(const char *printers, /* I - Destinations */
623 int num_dests, /* I - Number of user-defined dests */
624 cups_dest_t *dests) /* I - User-defined destinations */
625 {
626 int i; /* Looping var */
627 ipp_t *request, /* IPP Request */
628 *response; /* IPP Response */
629 ipp_attribute_t *attr; /* Current attribute */
630 const char *printer, /* Printer name */
631 *message; /* Printer device URI */
632 int accepting; /* Accepting requests? */
633 time_t ptime; /* Printer state time */
634 struct tm *pdate; /* Printer state date & time */
635 char printer_state_time[255];/* Printer state time */
636 static const char *pattrs[] = /* Attributes we need for printers... */
637 {
638 "printer-name",
639 "printer-state-change-time",
640 "printer-state-message",
641 "printer-is-accepting-jobs"
642 };
643
644
645 DEBUG_printf(("show_accepting(printers=\"%s\")\n", printers));
646
647 if (printers != NULL && !strcmp(printers, "all"))
648 printers = NULL;
649
650 /*
651 * Build a CUPS_GET_PRINTERS request, which requires the following
652 * attributes:
653 *
654 * attributes-charset
655 * attributes-natural-language
656 * requested-attributes
657 * requesting-user-name
658 */
659
660 request = ippNewRequest(CUPS_GET_PRINTERS);
661
662 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
663 "requested-attributes", sizeof(pattrs) / sizeof(pattrs[0]),
664 NULL, pattrs);
665
666 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
667 NULL, cupsUser());
668
669 /*
670 * Do the request and get back a response...
671 */
672
673 if ((response = cupsDoRequest(CUPS_HTTP_DEFAULT, request, "/")) != NULL)
674 {
675 DEBUG_puts("show_accepting: request succeeded...");
676
677 if (response->request.status.status_code > IPP_OK_CONFLICT)
678 {
679 _cupsLangPrintf(stderr, "lpstat: %s", cupsLastErrorString());
680 ippDelete(response);
681 return (1);
682 }
683
684 /*
685 * Loop through the printers returned in the list and display
686 * their devices...
687 */
688
689 for (attr = response->attrs; attr != NULL; attr = attr->next)
690 {
691 /*
692 * Skip leading attributes until we hit a printer...
693 */
694
695 while (attr != NULL && attr->group_tag != IPP_TAG_PRINTER)
696 attr = attr->next;
697
698 if (attr == NULL)
699 break;
700
701 /*
702 * Pull the needed attributes from this printer...
703 */
704
705 printer = NULL;
706 message = NULL;
707 accepting = 1;
708 ptime = 0;
709
710 while (attr != NULL && attr->group_tag == IPP_TAG_PRINTER)
711 {
712 if (!strcmp(attr->name, "printer-name") &&
713 attr->value_tag == IPP_TAG_NAME)
714 printer = attr->values[0].string.text;
715 else if (!strcmp(attr->name, "printer-state-change-time") &&
716 attr->value_tag == IPP_TAG_INTEGER)
717 ptime = (time_t)attr->values[0].integer;
718 else if (!strcmp(attr->name, "printer-state-message") &&
719 attr->value_tag == IPP_TAG_TEXT)
720 message = attr->values[0].string.text;
721 else if (!strcmp(attr->name, "printer-is-accepting-jobs") &&
722 attr->value_tag == IPP_TAG_BOOLEAN)
723 accepting = attr->values[0].boolean;
724
725 attr = attr->next;
726 }
727
728 /*
729 * See if we have everything needed...
730 */
731
732 if (printer == NULL)
733 {
734 if (attr == NULL)
735 break;
736 else
737 continue;
738 }
739
740 /*
741 * Display the printer entry if needed...
742 */
743
744 if (match_list(printers, printer))
745 {
746 pdate = localtime(&ptime);
747 strftime(printer_state_time, sizeof(printer_state_time), "%c", pdate);
748
749 if (accepting)
750 _cupsLangPrintf(stdout, _("%s accepting requests since %s"),
751 printer, printer_state_time);
752 else
753 {
754 _cupsLangPrintf(stdout, _("%s not accepting requests since %s -"),
755 printer, printer_state_time);
756 _cupsLangPrintf(stdout, _("\t%s"),
757 (message == NULL || !*message) ?
758 "reason unknown" : message);
759 }
760
761 for (i = 0; i < num_dests; i ++)
762 if (!_cups_strcasecmp(dests[i].name, printer) && dests[i].instance)
763 {
764 if (accepting)
765 _cupsLangPrintf(stdout, _("%s/%s accepting requests since %s"),
766 printer, dests[i].instance, printer_state_time);
767 else
768 {
769 _cupsLangPrintf(stdout,
770 _("%s/%s not accepting requests since %s -"),
771 printer, dests[i].instance, printer_state_time);
772 _cupsLangPrintf(stdout, _("\t%s"),
773 (message == NULL || !*message) ?
774 "reason unknown" : message);
775 }
776 }
777 }
778
779 if (attr == NULL)
780 break;
781 }
782
783 ippDelete(response);
784 }
785 else
786 {
787 _cupsLangPrintf(stderr, "lpstat: %s", cupsLastErrorString());
788 return (1);
789 }
790
791 return (0);
792 }
793
794
795 /*
796 * 'show_classes()' - Show printer classes.
797 */
798
799 static int /* O - 0 on success, 1 on fail */
800 show_classes(const char *dests) /* I - Destinations */
801 {
802 int i; /* Looping var */
803 ipp_t *request, /* IPP Request */
804 *response, /* IPP Response */
805 *response2; /* IPP response from remote server */
806 http_t *http2; /* Remote server */
807 ipp_attribute_t *attr; /* Current attribute */
808 const char *printer, /* Printer class name */
809 *printer_uri; /* Printer class URI */
810 ipp_attribute_t *members; /* Printer members */
811 char method[HTTP_MAX_URI], /* Request method */
812 username[HTTP_MAX_URI], /* Username:password */
813 server[HTTP_MAX_URI], /* Server name */
814 resource[HTTP_MAX_URI]; /* Resource name */
815 int port; /* Port number */
816 static const char *cattrs[] = /* Attributes we need for classes... */
817 {
818 "printer-name",
819 "printer-uri-supported",
820 "member-names"
821 };
822
823
824 DEBUG_printf(("show_classes(dests=\"%s\")\n", dests));
825
826 if (dests != NULL && !strcmp(dests, "all"))
827 dests = NULL;
828
829 /*
830 * Build a CUPS_GET_CLASSES request, which requires the following
831 * attributes:
832 *
833 * attributes-charset
834 * attributes-natural-language
835 * requested-attributes
836 * requesting-user-name
837 */
838
839 request = ippNewRequest(CUPS_GET_CLASSES);
840
841 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
842 "requested-attributes", sizeof(cattrs) / sizeof(cattrs[0]),
843 NULL, cattrs);
844
845 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
846 NULL, cupsUser());
847
848 /*
849 * Do the request and get back a response...
850 */
851
852 if ((response = cupsDoRequest(CUPS_HTTP_DEFAULT, request, "/")) != NULL)
853 {
854 DEBUG_puts("show_classes: request succeeded...");
855
856 if (response->request.status.status_code > IPP_OK_CONFLICT)
857 {
858 _cupsLangPrintf(stderr, "lpstat: %s", cupsLastErrorString());
859 ippDelete(response);
860 return (1);
861 }
862
863 /*
864 * Loop through the printers returned in the list and display
865 * their devices...
866 */
867
868 for (attr = response->attrs; attr != NULL; attr = attr->next)
869 {
870 /*
871 * Skip leading attributes until we hit a job...
872 */
873
874 while (attr != NULL && attr->group_tag != IPP_TAG_PRINTER)
875 attr = attr->next;
876
877 if (attr == NULL)
878 break;
879
880 /*
881 * Pull the needed attributes from this job...
882 */
883
884 printer = NULL;
885 printer_uri = NULL;
886 members = NULL;
887
888 while (attr != NULL && attr->group_tag == IPP_TAG_PRINTER)
889 {
890 if (!strcmp(attr->name, "printer-name") &&
891 attr->value_tag == IPP_TAG_NAME)
892 printer = attr->values[0].string.text;
893
894 if (!strcmp(attr->name, "printer-uri-supported") &&
895 attr->value_tag == IPP_TAG_URI)
896 printer_uri = attr->values[0].string.text;
897
898 if (!strcmp(attr->name, "member-names") &&
899 attr->value_tag == IPP_TAG_NAME)
900 members = attr;
901
902 attr = attr->next;
903 }
904
905 /*
906 * If this is a remote class, grab the class info from the
907 * remote server...
908 */
909
910 response2 = NULL;
911 if (members == NULL && printer_uri != NULL)
912 {
913 httpSeparateURI(HTTP_URI_CODING_ALL, printer_uri, method, sizeof(method),
914 username, sizeof(username), server, sizeof(server),
915 &port, resource, sizeof(resource));
916
917 if (!_cups_strcasecmp(server, cupsServer()))
918 http2 = CUPS_HTTP_DEFAULT;
919 else
920 http2 = httpConnectEncrypt(server, port, cupsEncryption());
921
922 /*
923 * Build an IPP_GET_PRINTER_ATTRIBUTES request, which requires the
924 * following attributes:
925 *
926 * attributes-charset
927 * attributes-natural-language
928 * printer-uri
929 * requested-attributes
930 */
931
932 request = ippNewRequest(IPP_GET_PRINTER_ATTRIBUTES);
933
934 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
935 "printer-uri", NULL, printer_uri);
936
937 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
938 "requested-attributes",
939 sizeof(cattrs) / sizeof(cattrs[0]),
940 NULL, cattrs);
941
942 if ((response2 = cupsDoRequest(http2, request, "/")) != NULL)
943 members = ippFindAttribute(response2, "member-names", IPP_TAG_NAME);
944
945 if (http2)
946 httpClose(http2);
947 }
948
949 /*
950 * See if we have everything needed...
951 */
952
953 if (printer == NULL)
954 {
955 if (response2)
956 ippDelete(response2);
957
958 if (attr == NULL)
959 break;
960 else
961 continue;
962 }
963
964 /*
965 * Display the printer entry if needed...
966 */
967
968 if (match_list(dests, printer))
969 {
970 _cupsLangPrintf(stdout, _("members of class %s:"), printer);
971
972 if (members)
973 {
974 for (i = 0; i < members->num_values; i ++)
975 _cupsLangPrintf(stdout, "\t%s", members->values[i].string.text);
976 }
977 else
978 _cupsLangPuts(stdout, "\tunknown");
979 }
980
981 if (response2)
982 ippDelete(response2);
983
984 if (attr == NULL)
985 break;
986 }
987
988 ippDelete(response);
989 }
990 else
991 {
992 _cupsLangPrintf(stderr, "lpstat: %s", cupsLastErrorString());
993 return (1);
994 }
995
996 return (0);
997 }
998
999
1000 /*
1001 * 'show_default()' - Show default destination.
1002 */
1003
1004 static void
1005 show_default(cups_dest_t *dest) /* I - Default destination */
1006 {
1007 const char *printer, /* Printer name */
1008 *val; /* Environment variable name */
1009
1010
1011 if (dest)
1012 {
1013 if (dest->instance)
1014 _cupsLangPrintf(stdout, _("system default destination: %s/%s"),
1015 dest->name, dest->instance);
1016 else
1017 _cupsLangPrintf(stdout, _("system default destination: %s"),
1018 dest->name);
1019 }
1020 else
1021 {
1022 val = NULL;
1023
1024 if ((printer = getenv("LPDEST")) == NULL)
1025 {
1026 if ((printer = getenv("PRINTER")) != NULL)
1027 {
1028 if (!strcmp(printer, "lp"))
1029 printer = NULL;
1030 else
1031 val = "PRINTER";
1032 }
1033 }
1034 else
1035 val = "LPDEST";
1036
1037 if (printer)
1038 _cupsLangPrintf(stdout,
1039 _("lpstat: error - %s environment variable names "
1040 "non-existent destination \"%s\"."),
1041 val, printer);
1042 else
1043 _cupsLangPuts(stdout, _("no system default destination"));
1044 }
1045 }
1046
1047
1048 /*
1049 * 'show_devices()' - Show printer devices.
1050 */
1051
1052 static int /* O - 0 on success, 1 on fail */
1053 show_devices(const char *printers, /* I - Destinations */
1054 int num_dests, /* I - Number of user-defined dests */
1055 cups_dest_t *dests) /* I - User-defined destinations */
1056 {
1057 int i; /* Looping var */
1058 ipp_t *request, /* IPP Request */
1059 *response; /* IPP Response */
1060 ipp_attribute_t *attr; /* Current attribute */
1061 const char *printer, /* Printer name */
1062 *uri, /* Printer URI */
1063 *device; /* Printer device URI */
1064 static const char *pattrs[] = /* Attributes we need for printers... */
1065 {
1066 "printer-name",
1067 "printer-uri-supported",
1068 "device-uri"
1069 };
1070
1071
1072 DEBUG_printf(("show_devices(printers=\"%s\")\n", printers));
1073
1074 if (printers != NULL && !strcmp(printers, "all"))
1075 printers = NULL;
1076
1077 /*
1078 * Build a CUPS_GET_PRINTERS request, which requires the following
1079 * attributes:
1080 *
1081 * attributes-charset
1082 * attributes-natural-language
1083 * requested-attributes
1084 * requesting-user-name
1085 */
1086
1087 request = ippNewRequest(CUPS_GET_PRINTERS);
1088
1089 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
1090 "requested-attributes", sizeof(pattrs) / sizeof(pattrs[0]),
1091 NULL, pattrs);
1092
1093 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
1094 NULL, cupsUser());
1095
1096 /*
1097 * Do the request and get back a response...
1098 */
1099
1100 if ((response = cupsDoRequest(CUPS_HTTP_DEFAULT, request, "/")) != NULL)
1101 {
1102 DEBUG_puts("show_devices: request succeeded...");
1103
1104 if (response->request.status.status_code > IPP_OK_CONFLICT)
1105 {
1106 _cupsLangPrintf(stderr, "lpstat: %s", cupsLastErrorString());
1107 ippDelete(response);
1108 return (1);
1109 }
1110
1111 /*
1112 * Loop through the printers returned in the list and display
1113 * their devices...
1114 */
1115
1116 for (attr = response->attrs; attr != NULL; attr = attr->next)
1117 {
1118 /*
1119 * Skip leading attributes until we hit a job...
1120 */
1121
1122 while (attr != NULL && attr->group_tag != IPP_TAG_PRINTER)
1123 attr = attr->next;
1124
1125 if (attr == NULL)
1126 break;
1127
1128 /*
1129 * Pull the needed attributes from this job...
1130 */
1131
1132 printer = NULL;
1133 device = NULL;
1134 uri = NULL;
1135
1136 while (attr != NULL && attr->group_tag == IPP_TAG_PRINTER)
1137 {
1138 if (!strcmp(attr->name, "printer-name") &&
1139 attr->value_tag == IPP_TAG_NAME)
1140 printer = attr->values[0].string.text;
1141
1142 if (!strcmp(attr->name, "printer-uri-supported") &&
1143 attr->value_tag == IPP_TAG_URI)
1144 uri = attr->values[0].string.text;
1145
1146 if (!strcmp(attr->name, "device-uri") &&
1147 attr->value_tag == IPP_TAG_URI)
1148 device = attr->values[0].string.text;
1149
1150 attr = attr->next;
1151 }
1152
1153 /*
1154 * See if we have everything needed...
1155 */
1156
1157 if (printer == NULL)
1158 {
1159 if (attr == NULL)
1160 break;
1161 else
1162 continue;
1163 }
1164
1165 /*
1166 * Display the printer entry if needed...
1167 */
1168
1169 if (match_list(printers, printer))
1170 {
1171 #ifdef __osf__ /* Compaq/Digital like to do it their own way... */
1172 char scheme[HTTP_MAX_URI], /* Components of printer URI */
1173 username[HTTP_MAX_URI],
1174 hostname[HTTP_MAX_URI],
1175 resource[HTTP_MAX_URI];
1176 int port;
1177
1178
1179 if (device == NULL)
1180 {
1181 httpSeparateURI(HTTP_URI_CODING_ALL, uri, scheme, sizeof(scheme),
1182 username, sizeof(username), hostname,
1183 sizeof(hostname), &port, resource, sizeof(resource));
1184 _cupsLangPrintf(stdout,
1185 _("Output for printer %s is sent to remote "
1186 "printer %s on %s"),
1187 printer, strrchr(resource, '/') + 1, hostname);
1188 }
1189 else if (!strncmp(device, "file:", 5))
1190 _cupsLangPrintf(stdout,
1191 _("Output for printer %s is sent to %s"),
1192 printer, device + 5);
1193 else
1194 _cupsLangPrintf(stdout,
1195 _("Output for printer %s is sent to %s"),
1196 printer, device);
1197
1198 for (i = 0; i < num_dests; i ++)
1199 if (!_cups_strcasecmp(printer, dests[i].name) && dests[i].instance)
1200 {
1201 if (device == NULL)
1202 _cupsLangPrintf(stdout,
1203 _("Output for printer %s/%s is sent to "
1204 "remote printer %s on %s"),
1205 printer, dests[i].instance,
1206 strrchr(resource, '/') + 1, hostname);
1207 else if (!strncmp(device, "file:", 5))
1208 _cupsLangPrintf(stdout,
1209 _("Output for printer %s/%s is sent to %s"),
1210 printer, dests[i].instance, device + 5);
1211 else
1212 _cupsLangPrintf(stdout,
1213 _("Output for printer %s/%s is sent to %s"),
1214 printer, dests[i].instance, device);
1215 }
1216 #else
1217 if (device == NULL)
1218 _cupsLangPrintf(stdout, _("device for %s: %s"),
1219 printer, uri);
1220 else if (!strncmp(device, "file:", 5))
1221 _cupsLangPrintf(stdout, _("device for %s: %s"),
1222 printer, device + 5);
1223 else
1224 _cupsLangPrintf(stdout, _("device for %s: %s"),
1225 printer, device);
1226
1227 for (i = 0; i < num_dests; i ++)
1228 if (!_cups_strcasecmp(printer, dests[i].name) && dests[i].instance)
1229 {
1230 if (device == NULL)
1231 _cupsLangPrintf(stdout, _("device for %s/%s: %s"),
1232 printer, dests[i].instance, uri);
1233 else if (!strncmp(device, "file:", 5))
1234 _cupsLangPrintf(stdout, _("device for %s/%s: %s"),
1235 printer, dests[i].instance, device + 5);
1236 else
1237 _cupsLangPrintf(stdout, _("device for %s/%s: %s"),
1238 printer, dests[i].instance, device);
1239 }
1240 #endif /* __osf__ */
1241 }
1242
1243 if (attr == NULL)
1244 break;
1245 }
1246
1247 ippDelete(response);
1248 }
1249 else
1250 {
1251 _cupsLangPrintf(stderr, "lpstat: %s", cupsLastErrorString());
1252 return (1);
1253 }
1254
1255 return (0);
1256 }
1257
1258
1259 /*
1260 * 'show_jobs()' - Show active print jobs.
1261 */
1262
1263 static int /* O - 0 on success, 1 on fail */
1264 show_jobs(const char *dests, /* I - Destinations */
1265 const char *users, /* I - Users */
1266 int long_status, /* I - Show long status? */
1267 int ranking, /* I - Show job ranking? */
1268 const char *which) /* I - Show which jobs? */
1269 {
1270 int i; /* Looping var */
1271 ipp_t *request, /* IPP Request */
1272 *response; /* IPP Response */
1273 ipp_attribute_t *attr, /* Current attribute */
1274 *reasons; /* Job state reasons attribute */
1275 const char *dest, /* Pointer into job-printer-uri */
1276 *username, /* Pointer to job-originating-user-name */
1277 *title, /* Pointer to job-name */
1278 *message; /* Pointer to job-printer-state-message */
1279 int rank, /* Rank in queue */
1280 jobid, /* job-id */
1281 size; /* job-k-octets */
1282 time_t jobtime; /* time-at-creation */
1283 struct tm *jobdate; /* Date & time */
1284 char temp[255], /* Temporary buffer */
1285 date[255]; /* Date buffer */
1286 static const char *jattrs[] = /* Attributes we need for jobs... */
1287 {
1288 "job-id",
1289 "job-k-octets",
1290 "job-name",
1291 "job-originating-user-name",
1292 "job-printer-state-message",
1293 "job-printer-uri",
1294 "job-state-reasons",
1295 "time-at-creation"
1296 };
1297
1298
1299 DEBUG_printf(("show_jobs(dests=\"%s\", users=\"%s\", long_status=%d, "
1300 "ranking=%d, which=\"%s\")\n", dests, users, long_status,
1301 ranking, which));
1302
1303 if (dests != NULL && !strcmp(dests, "all"))
1304 dests = NULL;
1305
1306 /*
1307 * Build a IPP_GET_JOBS request, which requires the following
1308 * attributes:
1309 *
1310 * attributes-charset
1311 * attributes-natural-language
1312 * printer-uri
1313 * requested-attributes
1314 * requesting-user-name
1315 * which-jobs
1316 */
1317
1318 request = ippNewRequest(IPP_GET_JOBS);
1319
1320 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
1321 NULL, "ipp://localhost/");
1322
1323 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
1324 "requested-attributes", sizeof(jattrs) / sizeof(jattrs[0]),
1325 NULL, jattrs);
1326
1327 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
1328 NULL, cupsUser());
1329
1330 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD, "which-jobs",
1331 NULL, which);
1332
1333 /*
1334 * Do the request and get back a response...
1335 */
1336
1337 if ((response = cupsDoRequest(CUPS_HTTP_DEFAULT, request, "/")) != NULL)
1338 {
1339 /*
1340 * Loop through the job list and display them...
1341 */
1342
1343 if (response->request.status.status_code > IPP_OK_CONFLICT)
1344 {
1345 _cupsLangPrintf(stderr, "lpstat: %s", cupsLastErrorString());
1346 ippDelete(response);
1347 return (1);
1348 }
1349
1350 rank = -1;
1351
1352 for (attr = response->attrs; attr != NULL; attr = attr->next)
1353 {
1354 /*
1355 * Skip leading attributes until we hit a job...
1356 */
1357
1358 while (attr != NULL && attr->group_tag != IPP_TAG_JOB)
1359 attr = attr->next;
1360
1361 if (attr == NULL)
1362 break;
1363
1364 /*
1365 * Pull the needed attributes from this job...
1366 */
1367
1368 jobid = 0;
1369 size = 0;
1370 username = NULL;
1371 dest = NULL;
1372 jobtime = 0;
1373 title = "no title";
1374 message = NULL;
1375 reasons = NULL;
1376
1377 while (attr != NULL && attr->group_tag == IPP_TAG_JOB)
1378 {
1379 if (!strcmp(attr->name, "job-id") &&
1380 attr->value_tag == IPP_TAG_INTEGER)
1381 jobid = attr->values[0].integer;
1382 else if (!strcmp(attr->name, "job-k-octets") &&
1383 attr->value_tag == IPP_TAG_INTEGER)
1384 size = attr->values[0].integer;
1385 else if (!strcmp(attr->name, "time-at-creation") &&
1386 attr->value_tag == IPP_TAG_INTEGER)
1387 jobtime = attr->values[0].integer;
1388 else if (!strcmp(attr->name, "job-printer-state-message") &&
1389 attr->value_tag == IPP_TAG_TEXT)
1390 message = attr->values[0].string.text;
1391 else if (!strcmp(attr->name, "job-printer-uri") &&
1392 attr->value_tag == IPP_TAG_URI)
1393 {
1394 if ((dest = strrchr(attr->values[0].string.text, '/')) != NULL)
1395 dest ++;
1396 }
1397 else if (!strcmp(attr->name, "job-originating-user-name") &&
1398 attr->value_tag == IPP_TAG_NAME)
1399 username = attr->values[0].string.text;
1400 else if (!strcmp(attr->name, "job-name") &&
1401 attr->value_tag == IPP_TAG_NAME)
1402 title = attr->values[0].string.text;
1403 else if (!strcmp(attr->name, "job-state-reasons") &&
1404 attr->value_tag == IPP_TAG_KEYWORD)
1405 reasons = attr;
1406
1407 attr = attr->next;
1408 }
1409
1410 /*
1411 * See if we have everything needed...
1412 */
1413
1414 if (dest == NULL || jobid == 0)
1415 {
1416 if (attr == NULL)
1417 break;
1418 else
1419 continue;
1420 }
1421
1422 /*
1423 * Display the job...
1424 */
1425
1426 rank ++;
1427
1428 if (match_list(dests, dest) && match_list(users, username))
1429 {
1430 jobdate = localtime(&jobtime);
1431 snprintf(temp, sizeof(temp), "%s-%d", dest, jobid);
1432
1433 if (long_status == 3)
1434 {
1435 /*
1436 * Show the consolidated output format for the SGI tools...
1437 */
1438
1439 if (!strftime(date, sizeof(date), "%b %d %H:%M", jobdate))
1440 strcpy(date, "Unknown");
1441
1442 _cupsLangPrintf(stdout, "%s;%s;%d;%s;%s",
1443 temp, username ? username : "unknown",
1444 size, title ? title : "unknown", date);
1445 }
1446 else
1447 {
1448 if (!strftime(date, sizeof(date), "%c", jobdate))
1449 strcpy(date, "Unknown");
1450
1451 if (ranking)
1452 _cupsLangPrintf(stdout, "%3d %-21s %-13s %8.0f %s",
1453 rank, temp, username ? username : "unknown",
1454 1024.0 * size, date);
1455 else
1456 _cupsLangPrintf(stdout, "%-23s %-13s %8.0f %s",
1457 temp, username ? username : "unknown",
1458 1024.0 * size, date);
1459 if (long_status)
1460 {
1461 if (message)
1462 _cupsLangPrintf(stdout, _("\tStatus: %s"), message);
1463
1464 if (reasons)
1465 {
1466 char alerts[1024], /* Alerts string */
1467 *aptr; /* Pointer into alerts string */
1468
1469 for (i = 0, aptr = alerts; i < reasons->num_values; i ++)
1470 {
1471 if (i)
1472 snprintf(aptr, sizeof(alerts) - (aptr - alerts), " %s",
1473 reasons->values[i].string.text);
1474 else
1475 strlcpy(alerts, reasons->values[i].string.text,
1476 sizeof(alerts));
1477
1478 aptr += strlen(aptr);
1479 }
1480
1481 _cupsLangPrintf(stdout, _("\tAlerts: %s"), alerts);
1482 }
1483
1484 _cupsLangPrintf(stdout, _("\tqueued for %s"), dest);
1485 }
1486 }
1487 }
1488
1489 if (attr == NULL)
1490 break;
1491 }
1492
1493 ippDelete(response);
1494 }
1495 else
1496 {
1497 _cupsLangPrintf(stderr, "lpstat: %s", cupsLastErrorString());
1498 return (1);
1499 }
1500
1501 return (0);
1502 }
1503
1504
1505 /*
1506 * 'show_printers()' - Show printers.
1507 */
1508
1509 static int /* O - 0 on success, 1 on fail */
1510 show_printers(const char *printers, /* I - Destinations */
1511 int num_dests, /* I - Number of user-defined dests */
1512 cups_dest_t *dests, /* I - User-defined destinations */
1513 int long_status) /* I - Show long status? */
1514 {
1515 int i, j; /* Looping vars */
1516 ipp_t *request, /* IPP Request */
1517 *response, /* IPP Response */
1518 *jobs; /* IPP Get Jobs response */
1519 ipp_attribute_t *attr, /* Current attribute */
1520 *jobattr, /* Job ID attribute */
1521 *reasons; /* Job state reasons attribute */
1522 const char *printer, /* Printer name */
1523 *message, /* Printer state message */
1524 *description, /* Description of printer */
1525 *location, /* Location of printer */
1526 *make_model, /* Make and model of printer */
1527 *uri; /* URI of printer */
1528 ipp_attribute_t *allowed, /* requesting-user-name-allowed */
1529 *denied; /* requestint-user-name-denied */
1530 ipp_pstate_t pstate; /* Printer state */
1531 cups_ptype_t ptype; /* Printer type */
1532 time_t ptime; /* Printer state time */
1533 struct tm *pdate; /* Printer state date & time */
1534 int jobid; /* Job ID of current job */
1535 char printer_uri[HTTP_MAX_URI],
1536 /* Printer URI */
1537 printer_state_time[255];/* Printer state time */
1538 _cups_globals_t *cg = _cupsGlobals(); /* Global data */
1539 static const char *pattrs[] = /* Attributes we need for printers... */
1540 {
1541 "printer-name",
1542 "printer-state",
1543 "printer-state-message",
1544 "printer-state-reasons",
1545 "printer-state-change-time",
1546 "printer-type",
1547 "printer-info",
1548 "printer-location",
1549 "printer-make-and-model",
1550 "printer-uri-supported",
1551 "requesting-user-name-allowed",
1552 "requesting-user-name-denied"
1553 };
1554 static const char *jattrs[] = /* Attributes we need for jobs... */
1555 {
1556 "job-id",
1557 "job-state"
1558 };
1559
1560
1561 DEBUG_printf(("show_printers(printers=\"%s\", num_dests=%d, dests=%p, "
1562 "long_status=%d)\n", printers, num_dests, dests, long_status));
1563
1564 if (printers != NULL && !strcmp(printers, "all"))
1565 printers = NULL;
1566
1567 /*
1568 * Build a CUPS_GET_PRINTERS request, which requires the following
1569 * attributes:
1570 *
1571 * attributes-charset
1572 * attributes-natural-language
1573 * requested-attributes
1574 * requesting-user-name
1575 */
1576
1577 request = ippNewRequest(CUPS_GET_PRINTERS);
1578
1579 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
1580 "requested-attributes", sizeof(pattrs) / sizeof(pattrs[0]),
1581 NULL, pattrs);
1582
1583 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
1584 NULL, cupsUser());
1585
1586 /*
1587 * Do the request and get back a response...
1588 */
1589
1590 if ((response = cupsDoRequest(CUPS_HTTP_DEFAULT, request, "/")) != NULL)
1591 {
1592 DEBUG_puts("show_printers: request succeeded...");
1593
1594 if (response->request.status.status_code > IPP_OK_CONFLICT)
1595 {
1596 _cupsLangPrintf(stderr, "lpstat: %s", cupsLastErrorString());
1597 ippDelete(response);
1598 return (1);
1599 }
1600
1601 /*
1602 * Loop through the printers returned in the list and display
1603 * their status...
1604 */
1605
1606 for (attr = response->attrs; attr != NULL; attr = attr->next)
1607 {
1608 /*
1609 * Skip leading attributes until we hit a job...
1610 */
1611
1612 while (attr != NULL && attr->group_tag != IPP_TAG_PRINTER)
1613 attr = attr->next;
1614
1615 if (attr == NULL)
1616 break;
1617
1618 /*
1619 * Pull the needed attributes from this job...
1620 */
1621
1622 printer = NULL;
1623 ptime = 0;
1624 ptype = CUPS_PRINTER_LOCAL;
1625 pstate = IPP_PRINTER_IDLE;
1626 message = NULL;
1627 description = NULL;
1628 location = NULL;
1629 make_model = NULL;
1630 reasons = NULL;
1631 uri = NULL;
1632 jobid = 0;
1633 allowed = NULL;
1634 denied = NULL;
1635
1636 while (attr != NULL && attr->group_tag == IPP_TAG_PRINTER)
1637 {
1638 if (!strcmp(attr->name, "printer-name") &&
1639 attr->value_tag == IPP_TAG_NAME)
1640 printer = attr->values[0].string.text;
1641 else if (!strcmp(attr->name, "printer-state") &&
1642 attr->value_tag == IPP_TAG_ENUM)
1643 pstate = (ipp_pstate_t)attr->values[0].integer;
1644 else if (!strcmp(attr->name, "printer-type") &&
1645 attr->value_tag == IPP_TAG_ENUM)
1646 ptype = (cups_ptype_t)attr->values[0].integer;
1647 else if (!strcmp(attr->name, "printer-state-message") &&
1648 attr->value_tag == IPP_TAG_TEXT)
1649 message = attr->values[0].string.text;
1650 else if (!strcmp(attr->name, "printer-state-change-time") &&
1651 attr->value_tag == IPP_TAG_INTEGER)
1652 ptime = (time_t)attr->values[0].integer;
1653 else if (!strcmp(attr->name, "printer-info") &&
1654 attr->value_tag == IPP_TAG_TEXT)
1655 description = attr->values[0].string.text;
1656 else if (!strcmp(attr->name, "printer-location") &&
1657 attr->value_tag == IPP_TAG_TEXT)
1658 location = attr->values[0].string.text;
1659 else if (!strcmp(attr->name, "printer-make-and-model") &&
1660 attr->value_tag == IPP_TAG_TEXT)
1661 make_model = attr->values[0].string.text;
1662 else if (!strcmp(attr->name, "printer-uri-supported") &&
1663 attr->value_tag == IPP_TAG_URI)
1664 uri = attr->values[0].string.text;
1665 else if (!strcmp(attr->name, "printer-state-reasons") &&
1666 attr->value_tag == IPP_TAG_KEYWORD)
1667 reasons = attr;
1668 else if (!strcmp(attr->name, "requesting-user-name-allowed") &&
1669 attr->value_tag == IPP_TAG_NAME)
1670 allowed = attr;
1671 else if (!strcmp(attr->name, "requesting-user-name-denied") &&
1672 attr->value_tag == IPP_TAG_NAME)
1673 denied = attr;
1674
1675 attr = attr->next;
1676 }
1677
1678 /*
1679 * See if we have everything needed...
1680 */
1681
1682 if (printer == NULL)
1683 {
1684 if (attr == NULL)
1685 break;
1686 else
1687 continue;
1688 }
1689
1690 /*
1691 * Display the printer entry if needed...
1692 */
1693
1694 if (match_list(printers, printer))
1695 {
1696 /*
1697 * If the printer state is "IPP_PRINTER_PROCESSING", then grab the
1698 * current job for the printer.
1699 */
1700
1701 if (pstate == IPP_PRINTER_PROCESSING)
1702 {
1703 /*
1704 * Build an IPP_GET_JOBS request, which requires the following
1705 * attributes:
1706 *
1707 * attributes-charset
1708 * attributes-natural-language
1709 * printer-uri
1710 * limit
1711 * requested-attributes
1712 */
1713
1714 request = ippNewRequest(IPP_GET_JOBS);
1715
1716 request->request.op.operation_id = IPP_GET_JOBS;
1717 request->request.op.request_id = 1;
1718
1719 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
1720 "requested-attributes",
1721 sizeof(jattrs) / sizeof(jattrs[0]), NULL, jattrs);
1722
1723 httpAssembleURIf(HTTP_URI_CODING_ALL, printer_uri, sizeof(printer_uri),
1724 "ipp", NULL, "localhost", 0, "/printers/%s", printer);
1725 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
1726 "printer-uri", NULL, printer_uri);
1727
1728 if ((jobs = cupsDoRequest(CUPS_HTTP_DEFAULT, request, "/")) != NULL)
1729 {
1730 /*
1731 * Get the current active job on this queue...
1732 */
1733
1734 ipp_jstate_t jobstate = IPP_JOB_PENDING;
1735 jobid = 0;
1736
1737 for (jobattr = jobs->attrs; jobattr; jobattr = jobattr->next)
1738 {
1739 if (!jobattr->name)
1740 {
1741 if (jobstate == IPP_JOB_PROCESSING)
1742 break;
1743 else
1744 continue;
1745 }
1746
1747 if (!strcmp(jobattr->name, "job-id") &&
1748 jobattr->value_tag == IPP_TAG_INTEGER)
1749 jobid = jobattr->values[0].integer;
1750 else if (!strcmp(jobattr->name, "job-state") &&
1751 jobattr->value_tag == IPP_TAG_ENUM)
1752 jobstate = jobattr->values[0].integer;
1753 }
1754
1755 if (jobstate != IPP_JOB_PROCESSING)
1756 jobid = 0;
1757
1758 ippDelete(jobs);
1759 }
1760 }
1761
1762 /*
1763 * Display it...
1764 */
1765
1766 pdate = localtime(&ptime);
1767 strftime(printer_state_time, sizeof(printer_state_time), "%c", pdate);
1768
1769 switch (pstate)
1770 {
1771 case IPP_PRINTER_IDLE :
1772 _cupsLangPrintf(stdout,
1773 _("printer %s is idle. enabled since %s"),
1774 printer, printer_state_time);
1775 break;
1776 case IPP_PRINTER_PROCESSING :
1777 _cupsLangPrintf(stdout,
1778 _("printer %s now printing %s-%d. "
1779 "enabled since %s"),
1780 printer, printer, jobid, printer_state_time);
1781 break;
1782 case IPP_PRINTER_STOPPED :
1783 _cupsLangPrintf(stdout,
1784 _("printer %s disabled since %s -"),
1785 printer, printer_state_time);
1786 break;
1787 }
1788
1789 if ((message && *message) || pstate == IPP_PRINTER_STOPPED)
1790 {
1791 if (!message || !*message)
1792 _cupsLangPuts(stdout, _("\treason unknown"));
1793 else
1794 _cupsLangPrintf(stdout, "\t%s", message);
1795 }
1796
1797 if (long_status > 1)
1798 {
1799 _cupsLangPuts(stdout, _("\tForm mounted:"));
1800 _cupsLangPuts(stdout, _("\tContent types: any"));
1801 _cupsLangPuts(stdout, _("\tPrinter types: unknown"));
1802 }
1803
1804 if (long_status)
1805 {
1806 _cupsLangPrintf(stdout, _("\tDescription: %s"),
1807 description ? description : "");
1808
1809 if (reasons)
1810 {
1811 char alerts[1024], /* Alerts string */
1812 *aptr; /* Pointer into alerts string */
1813
1814 for (i = 0, aptr = alerts; i < reasons->num_values; i ++)
1815 {
1816 if (i)
1817 snprintf(aptr, sizeof(alerts) - (aptr - alerts), " %s",
1818 reasons->values[i].string.text);
1819 else
1820 strlcpy(alerts, reasons->values[i].string.text,
1821 sizeof(alerts));
1822
1823 aptr += strlen(aptr);
1824 }
1825
1826 _cupsLangPrintf(stdout, _("\tAlerts: %s"), alerts);
1827 }
1828 }
1829 if (long_status > 1)
1830 {
1831 _cupsLangPrintf(stdout, _("\tLocation: %s"),
1832 location ? location : "");
1833
1834 if (ptype & CUPS_PRINTER_REMOTE)
1835 {
1836 _cupsLangPuts(stdout, _("\tConnection: remote"));
1837
1838 if (make_model && !strstr(make_model, "System V Printer") &&
1839 !strstr(make_model, "Raw Printer") && uri)
1840 _cupsLangPrintf(stdout, _("\tInterface: %s.ppd"),
1841 uri);
1842 }
1843 else
1844 {
1845 _cupsLangPuts(stdout, _("\tConnection: direct"));
1846
1847 if (make_model && strstr(make_model, "System V Printer"))
1848 _cupsLangPrintf(stdout,
1849 _("\tInterface: %s/interfaces/%s"),
1850 cg->cups_serverroot, printer);
1851 else if (make_model && !strstr(make_model, "Raw Printer"))
1852 _cupsLangPrintf(stdout,
1853 _("\tInterface: %s/ppd/%s.ppd"),
1854 cg->cups_serverroot, printer);
1855 }
1856 _cupsLangPuts(stdout, _("\tOn fault: no alert"));
1857 _cupsLangPuts(stdout, _("\tAfter fault: continue"));
1858 /* TODO update to use printer-error-policy */
1859 if (allowed)
1860 {
1861 _cupsLangPuts(stdout, _("\tUsers allowed:"));
1862 for (j = 0; j < allowed->num_values; j ++)
1863 _cupsLangPrintf(stdout, "\t\t%s",
1864 allowed->values[j].string.text);
1865 }
1866 else if (denied)
1867 {
1868 _cupsLangPuts(stdout, _("\tUsers denied:"));
1869 for (j = 0; j < denied->num_values; j ++)
1870 _cupsLangPrintf(stdout, "\t\t%s",
1871 denied->values[j].string.text);
1872 }
1873 else
1874 {
1875 _cupsLangPuts(stdout, _("\tUsers allowed:"));
1876 _cupsLangPuts(stdout, _("\t\t(all)"));
1877 }
1878 _cupsLangPuts(stdout, _("\tForms allowed:"));
1879 _cupsLangPuts(stdout, _("\t\t(none)"));
1880 _cupsLangPuts(stdout, _("\tBanner required"));
1881 _cupsLangPuts(stdout, _("\tCharset sets:"));
1882 _cupsLangPuts(stdout, _("\t\t(none)"));
1883 _cupsLangPuts(stdout, _("\tDefault pitch:"));
1884 _cupsLangPuts(stdout, _("\tDefault page size:"));
1885 _cupsLangPuts(stdout, _("\tDefault port settings:"));
1886 }
1887
1888 for (i = 0; i < num_dests; i ++)
1889 if (!_cups_strcasecmp(printer, dests[i].name) && dests[i].instance)
1890 {
1891 switch (pstate)
1892 {
1893 case IPP_PRINTER_IDLE :
1894 _cupsLangPrintf(stdout,
1895 _("printer %s/%s is idle. "
1896 "enabled since %s"),
1897 printer, dests[i].instance,
1898 printer_state_time);
1899 break;
1900 case IPP_PRINTER_PROCESSING :
1901 _cupsLangPrintf(stdout,
1902 _("printer %s/%s now printing %s-%d. "
1903 "enabled since %s"),
1904 printer, dests[i].instance, printer, jobid,
1905 printer_state_time);
1906 break;
1907 case IPP_PRINTER_STOPPED :
1908 _cupsLangPrintf(stdout,
1909 _("printer %s/%s disabled since %s -"),
1910 printer, dests[i].instance,
1911 printer_state_time);
1912 break;
1913 }
1914
1915 if ((message && *message) || pstate == IPP_PRINTER_STOPPED)
1916 {
1917 if (!message || !*message)
1918 _cupsLangPuts(stdout, _("\treason unknown"));
1919 else
1920 _cupsLangPrintf(stdout, "\t%s", message);
1921 }
1922
1923 if (long_status > 1)
1924 {
1925 _cupsLangPuts(stdout, _("\tForm mounted:"));
1926 _cupsLangPuts(stdout, _("\tContent types: any"));
1927 _cupsLangPuts(stdout, _("\tPrinter types: unknown"));
1928 }
1929
1930 if (long_status)
1931 {
1932 _cupsLangPrintf(stdout, _("\tDescription: %s"),
1933 description ? description : "");
1934
1935 if (reasons)
1936 {
1937 char alerts[1024], /* Alerts string */
1938 *aptr; /* Pointer into alerts string */
1939
1940 for (i = 0, aptr = alerts; i < reasons->num_values; i ++)
1941 {
1942 if (i)
1943 snprintf(aptr, sizeof(alerts) - (aptr - alerts), " %s",
1944 reasons->values[i].string.text);
1945 else
1946 strlcpy(alerts, reasons->values[i].string.text,
1947 sizeof(alerts));
1948
1949 aptr += strlen(aptr);
1950 }
1951
1952 _cupsLangPrintf(stdout, _("\tAlerts: %s"), alerts);
1953 }
1954 }
1955 if (long_status > 1)
1956 {
1957 _cupsLangPrintf(stdout, _("\tLocation: %s"),
1958 location ? location : "");
1959
1960 if (ptype & CUPS_PRINTER_REMOTE)
1961 {
1962 _cupsLangPuts(stdout, _("\tConnection: remote"));
1963
1964 if (make_model && !strstr(make_model, "System V Printer") &&
1965 !strstr(make_model, "Raw Printer") && uri)
1966 _cupsLangPrintf(stdout, _("\tInterface: %s.ppd"), uri);
1967 }
1968 else
1969 {
1970 _cupsLangPuts(stdout, _("\tConnection: direct"));
1971
1972 if (make_model && strstr(make_model, "System V Printer"))
1973 _cupsLangPrintf(stdout,
1974 _("\tInterface: %s/interfaces/%s"),
1975 cg->cups_serverroot, printer);
1976 else if (make_model && !strstr(make_model, "Raw Printer"))
1977 _cupsLangPrintf(stdout,
1978 _("\tInterface: %s/ppd/%s.ppd"),
1979 cg->cups_serverroot, printer);
1980 }
1981 _cupsLangPuts(stdout, _("\tOn fault: no alert"));
1982 _cupsLangPuts(stdout, _("\tAfter fault: continue"));
1983 /* TODO update to use printer-error-policy */
1984 if (allowed)
1985 {
1986 _cupsLangPuts(stdout, _("\tUsers allowed:"));
1987 for (j = 0; j < allowed->num_values; j ++)
1988 _cupsLangPrintf(stdout, "\t\t%s",
1989 allowed->values[j].string.text);
1990 }
1991 else if (denied)
1992 {
1993 _cupsLangPuts(stdout, _("\tUsers denied:"));
1994 for (j = 0; j < denied->num_values; j ++)
1995 _cupsLangPrintf(stdout, "\t\t%s",
1996 denied->values[j].string.text);
1997 }
1998 else
1999 {
2000 _cupsLangPuts(stdout, _("\tUsers allowed:"));
2001 _cupsLangPuts(stdout, _("\t\t(all)"));
2002 }
2003 _cupsLangPuts(stdout, _("\tForms allowed:"));
2004 _cupsLangPuts(stdout, _("\t\t(none)"));
2005 _cupsLangPuts(stdout, _("\tBanner required"));
2006 _cupsLangPuts(stdout, _("\tCharset sets:"));
2007 _cupsLangPuts(stdout, _("\t\t(none)"));
2008 _cupsLangPuts(stdout, _("\tDefault pitch:"));
2009 _cupsLangPuts(stdout, _("\tDefault page size:"));
2010 _cupsLangPuts(stdout, _("\tDefault port settings:"));
2011 }
2012 }
2013 }
2014
2015 if (attr == NULL)
2016 break;
2017 }
2018
2019 ippDelete(response);
2020 }
2021 else
2022 {
2023 _cupsLangPrintf(stderr, "lpstat: %s", cupsLastErrorString());
2024 return (1);
2025 }
2026
2027 return (0);
2028 }
2029
2030
2031 /*
2032 * 'show_scheduler()' - Show scheduler status.
2033 */
2034
2035 static void
2036 show_scheduler(void)
2037 {
2038 http_t *http; /* Connection to server */
2039
2040
2041 if ((http = httpConnectEncrypt(cupsServer(), ippPort(),
2042 cupsEncryption())) != NULL)
2043 {
2044 _cupsLangPuts(stdout, _("scheduler is running"));
2045 httpClose(http);
2046 }
2047 else
2048 _cupsLangPuts(stdout, _("scheduler is not running"));
2049 }
2050
2051
2052 /*
2053 * End of "$Id: lpstat.c 7921 2008-09-10 15:42:24Z mike $".
2054 */
Unnamed repository; edit this file 'description' to name the repository.