1 /*
2 * Simulated client test program for CUPS.
3 *
4 * Copyright © 2017-2019 by Apple Inc.
5 *
6 * Licensed under Apache License v2.0. See the file "LICENSE" for more
7 * information.
8 */
9
10 /*
11 * Include necessary headers...
12 */
13
14 #include <config.h>
15 #include <stdio.h>
16 #include <stdlib.h>
17 #include <cups/cups.h>
18 #include <cups/raster.h>
19 #include <cups/string-private.h>
20 #include <cups/thread-private.h>
21
22
23 /*
24 * Constants...
25 */
26
27 #define MAX_CLIENTS 16 /* Maximum number of client threads */
28
29
30 /*
31 * Local types...
32 */
33
34 typedef struct _client_data_s
35 {
36 const char *uri, /* Printer URI */
37 *hostname, /* Hostname */
38 *user, /* Username */
39 *resource; /* Resource path */
40 int port; /* Port number */
41 http_encryption_t encryption; /* Use encryption? */
42 const char *docfile, /* Document file */
43 *docformat; /* Document format */
44 int grayscale, /* Force grayscale? */
45 keepfile; /* Keep temporary file? */
46 ipp_pstate_t printer_state; /* Current printer state */
47 char printer_state_reasons[1024];
48 /* Current printer-state-reasons */
49 int job_id; /* Job ID for submitted job */
50 ipp_jstate_t job_state; /* Current job state */
51 char job_state_reasons[1024];
52 /* Current job-state-reasons */
53 } _client_data_t;
54
55
56 /*
57 * Local globals...
58 */
59
60 static int client_count = 0;
61 static _cups_mutex_t client_mutex = _CUPS_MUTEX_INITIALIZER;
62 static int verbosity = 0;
63
64
65 /*
66 * Local functions...
67 */
68
69 static const char *make_raster_file(ipp_t *response, int grayscale, char *tempname, size_t tempsize, const char **format);
70 static void *monitor_printer(_client_data_t *data);
71 static void *run_client(_client_data_t *data);
72 static void show_attributes(const char *title, int request, ipp_t *ipp);
73 static void show_capabilities(ipp_t *response);
74 static void usage(void);
75
76
77 /*
78 * 'main()' - Main entry.
79 */
80
81 int /* O - Exit status */
main(int argc,char * argv[])82 main(int argc, /* I - Number of command-line arguments */
83 char *argv[]) /* I - Command-line arguments */
84 {
85 int i; /* Looping var */
86 const char *opt; /* Current option */
87 int num_clients = 0,/* Number of clients to simulate */
88 clients_started = 0;
89 /* Number of clients that have been started */
90 char scheme[32], /* URI scheme */
91 userpass[256], /* Username:password */
92 hostname[256], /* Hostname */
93 resource[256]; /* Resource path */
94 _client_data_t data; /* Client data */
95
96
97 /*
98 * Parse command-line options...
99 */
100
101 if (argc == 1)
102 return (0);
103
104 memset(&data, 0, sizeof(data));
105
106 for (i = 1; i < argc; i ++)
107 {
108 if (argv[i][0] == '-')
109 {
110 for (opt = argv[i] + 1; *opt; opt ++)
111 {
112 switch (*opt)
113 {
114 case 'c' : /* -c num-clients */
115 if (num_clients)
116 {
117 puts("Number of clients can only be specified once.");
118 usage();
119 return (1);
120 }
121
122 i ++;
123 if (i >= argc)
124 {
125 puts("Expected client count after '-c'.");
126 usage();
127 return (1);
128 }
129
130 if ((num_clients = atoi(argv[i])) < 1)
131 {
132 puts("Number of clients must be one or more.");
133 usage();
134 return (1);
135 }
136 break;
137
138 case 'd' : /* -d document-format */
139 if (data.docformat)
140 {
141 puts("Document format can only be specified once.");
142 usage();
143 return (1);
144 }
145
146 i ++;
147 if (i >= argc)
148 {
149 puts("Expected document format after '-d'.");
150 usage();
151 return (1);
152 }
153
154 data.docformat = argv[i];
155 break;
156
157 case 'f' : /* -f print-file */
158 if (data.docfile)
159 {
160 puts("Print file can only be specified once.");
161 usage();
162 return (1);
163 }
164
165 i ++;
166 if (i >= argc)
167 {
168 puts("Expected print file after '-f'.");
169 usage();
170 return (1);
171 }
172
173 data.docfile = argv[i];
174 break;
175
176 case 'g' :
177 data.grayscale = 1;
178 break;
179
180 case 'k' :
181 data.keepfile = 1;
182 break;
183
184 case 'v' :
185 verbosity ++;
186 break;
187
188 default :
189 printf("Unknown option '-%c'.\n", *opt);
190 usage();
191 return (1);
192 }
193 }
194 }
195 else if (data.uri || (strncmp(argv[i], "ipp://", 6) && strncmp(argv[i], "ipps://", 7)))
196 {
197 printf("Unknown command-line argument '%s'.\n", argv[i]);
198 usage();
199 return (1);
200 }
201 else
202 data.uri = argv[i];
203 }
204
205 /*
206 * Make sure we have everything we need.
207 */
208
209 if (!data.uri)
210 {
211 puts("Expected printer URI.");
212 usage();
213 return (1);
214 }
215
216 if (num_clients < 1)
217 num_clients = 1;
218
219 /*
220 * Connect to the printer...
221 */
222
223 if (httpSeparateURI(HTTP_URI_CODING_ALL, data.uri, scheme, sizeof(scheme), userpass, sizeof(userpass), hostname, sizeof(hostname), &data.port, resource, sizeof(resource)) < HTTP_URI_STATUS_OK)
224 {
225 printf("Bad printer URI '%s'.\n", data.uri);
226 return (1);
227 }
228
229 if (!data.port)
230 data.port = IPP_PORT;
231
232 if (!strcmp(scheme, "https") || !strcmp(scheme, "ipps"))
233 data.encryption = HTTP_ENCRYPTION_ALWAYS;
234 else
235 data.encryption = HTTP_ENCRYPTION_IF_REQUESTED;
236
237 /*
238 * Start the client threads...
239 */
240
241 data.hostname = hostname;
242 data.resource = resource;
243
244 while (clients_started < num_clients)
245 {
246 _cupsMutexLock(&client_mutex);
247 if (client_count < MAX_CLIENTS)
248 {
249 _cups_thread_t tid; /* New thread */
250
251 client_count ++;
252 _cupsMutexUnlock(&client_mutex);
253 tid = _cupsThreadCreate((_cups_thread_func_t)run_client, &data);
254 _cupsThreadDetach(tid);
255 }
256 else
257 {
258 _cupsMutexUnlock(&client_mutex);
259 sleep(1);
260 }
261 }
262
263 while (client_count > 0)
264 {
265 _cupsMutexLock(&client_mutex);
266 printf("%d RUNNING CLIENTS\n", client_count);
267 _cupsMutexUnlock(&client_mutex);
268 sleep(1);
269 }
270
271 return (0);
272 }
273
274
275 /*
276 * 'make_raster_file()' - Create a temporary raster file.
277 */
278
279 static const char * /* O - Print filename */
make_raster_file(ipp_t * response,int grayscale,char * tempname,size_t tempsize,const char ** format)280 make_raster_file(ipp_t *response, /* I - Printer attributes */
281 int grayscale, /* I - Force grayscale? */
282 char *tempname, /* I - Temporary filename buffer */
283 size_t tempsize, /* I - Size of temp file buffer */
284 const char **format) /* O - Print format */
285 {
286 int i, /* Looping var */
287 count; /* Number of values */
288 ipp_attribute_t *attr; /* Printer attribute */
289 const char *type = NULL; /* Raster type (colorspace + bits) */
290 pwg_media_t *media = NULL; /* Media size */
291 int xdpi = 0, /* Horizontal resolution */
292 ydpi = 0; /* Vertical resolution */
293 int fd; /* Temporary file */
294 cups_mode_t mode; /* Raster mode */
295 cups_raster_t *ras; /* Raster stream */
296 cups_page_header2_t header; /* Page header */
297 unsigned char *line, /* Line of raster data */
298 *lineptr; /* Pointer into line */
299 unsigned y, /* Current position on page */
300 xcount, ycount, /* Current count for X and Y */
301 xrep, yrep, /* Repeat count for X and Y */
302 xoff, yoff, /* Offsets for X and Y */
303 yend; /* End Y value */
304 int temprow, /* Row in template */
305 tempcolor; /* Template color */
306 const char *template; /* Pointer into template */
307 const unsigned char *color; /* Current color */
308 static const unsigned char colors[][3] =
309 { /* Colors for test */
310 { 191, 191, 191 },
311 { 127, 127, 127 },
312 { 63, 63, 63 },
313 { 0, 0, 0 },
314 { 255, 0, 0 },
315 { 255, 127, 0 },
316 { 255, 255, 0 },
317 { 127, 255, 0 },
318 { 0, 255, 0 },
319 { 0, 255, 127 },
320 { 0, 255, 255 },
321 { 0, 127, 255 },
322 { 0, 0, 255 },
323 { 127, 0, 255 },
324 { 255, 0, 255 }
325 };
326 static const char * const templates[] =
327 { /* Raster template */
328 " CCC U U PPPP SSS TTTTT EEEEE SSS TTTTT 000 1 222 333 4 55555 66 77777 888 999 ",
329 "C C U U P P S S T E S S T 0 0 11 2 2 3 3 4 4 5 6 7 8 8 9 9 ",
330 "C U U P P S T E S T 0 0 1 2 3 4 4 5 6 7 8 8 9 9 ",
331 "C U U PPPP SSS ----- T EEEE SSS T 0 0 0 1 22 333 44444 555 6666 7 888 9999 ",
332 "C U U P S T E S T 0 0 1 2 3 4 5 6 6 7 8 8 9 ",
333 "C C U U P S S T E S S T 0 0 1 2 3 3 4 5 5 6 6 7 8 8 9 ",
334 " CCC UUU P SSS T EEEEE SSS T 000 111 22222 333 4 555 666 7 888 99 ",
335 " "
336 };
337
338
339 /*
340 * Figure out the output format...
341 */
342
343 if ((attr = ippFindAttribute(response, "document-format-supported", IPP_TAG_MIMETYPE)) == NULL)
344 {
345 puts("No supported document formats, aborting.");
346 return (NULL);
347 }
348
349 if (*format)
350 {
351 if (!ippContainsString(attr, *format))
352 {
353 printf("Printer does not support document-format '%s'.\n", *format);
354 return (NULL);
355 }
356
357 if (!strcmp(*format, "image/urf"))
358 mode = CUPS_RASTER_WRITE_APPLE;
359 else if (!strcmp(*format, "image/pwg-raster"))
360 mode = CUPS_RASTER_WRITE_PWG;
361 else
362 {
363 printf("Unable to generate document-format '%s'.\n", *format);
364 return (NULL);
365 }
366 }
367 else if (ippContainsString(attr, "image/urf"))
368 {
369 /*
370 * Apple Raster format...
371 */
372
373 *format = "image/urf";
374 mode = CUPS_RASTER_WRITE_APPLE;
375 }
376 else if (ippContainsString(attr, "image/pwg-raster"))
377 {
378 /*
379 * PWG Raster format...
380 */
381
382 *format = "image/pwg-raster";
383 mode = CUPS_RASTER_WRITE_PWG;
384 }
385 else
386 {
387 /*
388 * No supported raster format...
389 */
390
391 puts("Printer does not support Apple or PWG raster files, aborting.");
392 return (NULL);
393 }
394
395 /*
396 * Figure out the the media, resolution, and color mode...
397 */
398
399 if ((attr = ippFindAttribute(response, "media-default", IPP_TAG_KEYWORD)) != NULL)
400 {
401 /*
402 * Use default media...
403 */
404
405 media = pwgMediaForPWG(ippGetString(attr, 0, NULL));
406 }
407 else if ((attr = ippFindAttribute(response, "media-ready", IPP_TAG_KEYWORD)) != NULL)
408 {
409 /*
410 * Use ready media...
411 */
412
413 if (ippContainsString(attr, "na_letter_8.5x11in"))
414 media = pwgMediaForPWG("na_letter_8.5x11in");
415 else if (ippContainsString(attr, "iso_a4_210x297mm"))
416 media = pwgMediaForPWG("iso_a4_210x297mm");
417 else
418 media = pwgMediaForPWG(ippGetString(attr, 0, NULL));
419 }
420 else
421 {
422 puts("No default or ready media reported by printer, aborting.");
423 return (NULL);
424 }
425
426 if (mode == CUPS_RASTER_WRITE_APPLE && (attr = ippFindAttribute(response, "urf-supported", IPP_TAG_KEYWORD)) != NULL)
427 {
428 for (i = 0, count = ippGetCount(attr); i < count; i ++)
429 {
430 const char *val = ippGetString(attr, i, NULL);
431
432 if (!strncmp(val, "RS", 2))
433 xdpi = ydpi = atoi(val + 2);
434 else if (!strncmp(val, "W8", 2) && !type)
435 type = "sgray_8";
436 else if (!strncmp(val, "SRGB24", 6) && !grayscale)
437 type = "srgb_8";
438 }
439 }
440 else if (mode == CUPS_RASTER_WRITE_PWG && (attr = ippFindAttribute(response, "pwg-raster-document-resolution-supported", IPP_TAG_RESOLUTION)) != NULL)
441 {
442 for (i = 0, count = ippGetCount(attr); i < count; i ++)
443 {
444 int tempxdpi, tempydpi;
445 ipp_res_t tempunits;
446
447 tempxdpi = ippGetResolution(attr, 0, &tempydpi, &tempunits);
448
449 if (i == 0 || tempxdpi < xdpi || tempydpi < ydpi)
450 {
451 xdpi = tempxdpi;
452 ydpi = tempydpi;
453 }
454 }
455
456 if ((attr = ippFindAttribute(response, "pwg-raster-document-type-supported", IPP_TAG_KEYWORD)) != NULL)
457 {
458 if (!grayscale && ippContainsString(attr, "srgb_8"))
459 type = "srgb_8";
460 else if (ippContainsString(attr, "sgray_8"))
461 type = "sgray_8";
462 }
463 }
464
465 if (xdpi < 72 || ydpi < 72)
466 {
467 puts("No supported raster resolutions, aborting.");
468 return (NULL);
469 }
470
471 if (!type)
472 {
473 puts("No supported color spaces or bit depths, aborting.");
474 return (NULL);
475 }
476
477 /*
478 * Make the raster context and details...
479 */
480
481 if (!cupsRasterInitPWGHeader(&header, media, type, xdpi, ydpi, "one-sided", NULL))
482 {
483 printf("Unable to initialize raster context: %s\n", cupsRasterErrorString());
484 return (NULL);
485 }
486
487 header.cupsInteger[CUPS_RASTER_PWG_TotalPageCount] = 1;
488
489 if (header.cupsWidth > (4 * header.HWResolution[0]))
490 {
491 xoff = header.HWResolution[0] / 2;
492 yoff = header.HWResolution[1] / 2;
493 }
494 else
495 {
496 xoff = 0;
497 yoff = 0;
498 }
499
500 xrep = (header.cupsWidth - 2 * xoff) / 140;
501 yrep = xrep * header.HWResolution[1] / header.HWResolution[0];
502 yend = header.cupsHeight - yoff;
503
504 /*
505 * Prepare the raster file...
506 */
507
508 if ((line = malloc(header.cupsBytesPerLine)) == NULL)
509 {
510 printf("Unable to allocate %u bytes for raster output: %s\n", header.cupsBytesPerLine, strerror(errno));
511 return (NULL);
512 }
513
514 if ((fd = cupsTempFd(tempname, (int)tempsize)) < 0)
515 {
516 printf("Unable to create temporary print file: %s\n", strerror(errno));
517 free(line);
518 return (NULL);
519 }
520
521 if ((ras = cupsRasterOpen(fd, mode)) == NULL)
522 {
523 printf("Unable to open raster stream: %s\n", cupsRasterErrorString());
524 close(fd);
525 free(line);
526 return (NULL);
527 }
528
529 /*
530 * Write a single page consisting of the template dots repeated over the page.
531 */
532
533 cupsRasterWriteHeader2(ras, &header);
534
535 memset(line, 0xff, header.cupsBytesPerLine);
536
537 for (y = 0; y < yoff; y ++)
538 cupsRasterWritePixels(ras, line, header.cupsBytesPerLine);
539
540 for (temprow = 0, tempcolor = 0; y < yend;)
541 {
542 template = templates[temprow];
543 color = colors[tempcolor];
544
545 temprow ++;
546 if (temprow >= (int)(sizeof(templates) / sizeof(templates[0])))
547 {
548 temprow = 0;
549 tempcolor ++;
550 if (tempcolor >= (int)(sizeof(colors) / sizeof(colors[0])))
551 tempcolor = 0;
552 else if (tempcolor > 3 && header.cupsColorSpace == CUPS_CSPACE_SW)
553 tempcolor = 0;
554 }
555
556 memset(line, 0xff, header.cupsBytesPerLine);
557
558 if (header.cupsColorSpace == CUPS_CSPACE_SW)
559 {
560 /*
561 * Do grayscale output...
562 */
563
564 for (lineptr = line + xoff; *template; template ++)
565 {
566 if (*template != ' ')
567 {
568 for (xcount = xrep; xcount > 0; xcount --)
569 *lineptr++ = *color;
570 }
571 else
572 {
573 lineptr += xrep;
574 }
575 }
576 }
577 else
578 {
579 /*
580 * Do color output...
581 */
582
583 for (lineptr = line + 3 * xoff; *template; template ++)
584 {
585 if (*template != ' ')
586 {
587 for (xcount = xrep; xcount > 0; xcount --, lineptr += 3)
588 memcpy(lineptr, color, 3);
589 }
590 else
591 {
592 lineptr += 3 * xrep;
593 }
594 }
595 }
596
597 for (ycount = yrep; ycount > 0 && y < yend; ycount --, y ++)
598 cupsRasterWritePixels(ras, line, header.cupsBytesPerLine);
599 }
600
601 memset(line, 0xff, header.cupsBytesPerLine);
602
603 for (y = 0; y < header.cupsHeight; y ++)
604 cupsRasterWritePixels(ras, line, header.cupsBytesPerLine);
605
606 cupsRasterClose(ras);
607
608 close(fd);
609
610 printf("PRINT FILE: %s\n", tempname);
611
612 return (tempname);
613 }
614
615
616 /*
617 * 'monitor_printer()' - Monitor the job and printer states.
618 */
619
620 static void * /* O - Thread exit code */
monitor_printer(_client_data_t * data)621 monitor_printer(
622 _client_data_t *data) /* I - Client data */
623 {
624 http_t *http; /* Connection to printer */
625 ipp_t *request, /* IPP request */
626 *response; /* IPP response */
627 ipp_attribute_t *attr; /* Attribute in response */
628 ipp_pstate_t printer_state; /* Printer state */
629 char printer_state_reasons[1024];
630 /* Printer state reasons */
631 ipp_jstate_t job_state; /* Job state */
632 char job_state_reasons[1024];/* Printer state reasons */
633 static const char * const jattrs[] = /* Job attributes we want */
634 {
635 "job-state",
636 "job-state-reasons"
637 };
638 static const char * const pattrs[] = /* Printer attributes we want */
639 {
640 "printer-state",
641 "printer-state-reasons"
642 };
643
644
645 /*
646 * Open a connection to the printer...
647 */
648
649 http = httpConnect2(data->hostname, data->port, NULL, AF_UNSPEC, data->encryption, 1, 0, NULL);
650
651 /*
652 * Loop until the job is canceled, aborted, or completed.
653 */
654
655 printer_state = (ipp_pstate_t)0;
656 printer_state_reasons[0] = '\0';
657
658 job_state = (ipp_jstate_t)0;
659 job_state_reasons[0] = '\0';
660
661 while (data->job_state < IPP_JSTATE_CANCELED)
662 {
663 /*
664 * Reconnect to the printer as needed...
665 */
666
667 if (httpGetFd(http) < 0)
668 httpReconnect2(http, 30000, NULL);
669
670 if (httpGetFd(http) >= 0)
671 {
672 /*
673 * Connected, so check on the printer state...
674 */
675
676 request = ippNewRequest(IPP_OP_GET_PRINTER_ATTRIBUTES);
677 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, data->uri);
678 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name", NULL, cupsUser());
679 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD, "requested-attributes", (int)(sizeof(pattrs) / sizeof(pattrs[0])), NULL, pattrs);
680
681 response = cupsDoRequest(http, request, data->resource);
682
683 if ((attr = ippFindAttribute(response, "printer-state", IPP_TAG_ENUM)) != NULL)
684 printer_state = (ipp_pstate_t)ippGetInteger(attr, 0);
685
686 if ((attr = ippFindAttribute(response, "printer-state-reasons", IPP_TAG_KEYWORD)) != NULL)
687 ippAttributeString(attr, printer_state_reasons, sizeof(printer_state_reasons));
688
689 if (printer_state != data->printer_state || strcmp(printer_state_reasons, data->printer_state_reasons))
690 {
691 printf("PRINTER: %s (%s)\n", ippEnumString("printer-state", (int)printer_state), printer_state_reasons);
692
693 data->printer_state = printer_state;
694 strlcpy(data->printer_state_reasons, printer_state_reasons, sizeof(data->printer_state_reasons));
695 }
696
697 ippDelete(response);
698
699 if (data->job_id > 0)
700 {
701 /*
702 * Check the status of the job itself...
703 */
704
705 request = ippNewRequest(IPP_OP_GET_JOB_ATTRIBUTES);
706 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, data->uri);
707 ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "job-id", data->job_id);
708 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name", NULL, cupsUser());
709 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD, "requested-attributes", (int)(sizeof(jattrs) / sizeof(jattrs[0])), NULL, jattrs);
710
711 response = cupsDoRequest(http, request, data->resource);
712
713 if ((attr = ippFindAttribute(response, "job-state", IPP_TAG_ENUM)) != NULL)
714 job_state = (ipp_jstate_t)ippGetInteger(attr, 0);
715
716 if ((attr = ippFindAttribute(response, "job-state-reasons", IPP_TAG_KEYWORD)) != NULL)
717 ippAttributeString(attr, job_state_reasons, sizeof(job_state_reasons));
718
719 if (job_state != data->job_state || strcmp(job_state_reasons, data->job_state_reasons))
720 {
721 printf("JOB %d: %s (%s)\n", data->job_id, ippEnumString("job-state", (int)job_state), job_state_reasons);
722
723 data->job_state = job_state;
724 strlcpy(data->job_state_reasons, job_state_reasons, sizeof(data->job_state_reasons));
725 }
726
727 ippDelete(response);
728 }
729 }
730
731 if (data->job_state < IPP_JSTATE_CANCELED)
732 {
733 /*
734 * Sleep for 5 seconds...
735 */
736
737 sleep(5);
738 }
739 }
740
741 /*
742 * Cleanup and return...
743 */
744
745 httpClose(http);
746
747 printf("FINISHED MONITORING JOB %d\n", data->job_id);
748
749 return (NULL);
750 }
751
752
753 /*
754 * 'run_client()' - Run a client thread.
755 */
756
757 static void * /* O - Thread exit code */
run_client(_client_data_t * data)758 run_client(
759 _client_data_t *data) /* I - Client data */
760 {
761 _cups_thread_t monitor_id; /* Monitoring thread ID */
762 const char *name; /* Job name */
763 char tempfile[1024] = ""; /* Temporary file (if any) */
764 _client_data_t ldata; /* Local client data */
765 http_t *http; /* Connection to printer */
766 ipp_t *request, /* IPP request */
767 *response; /* IPP response */
768 ipp_attribute_t *attr; /* Attribute in response */
769 static const char * const pattrs[] = /* Printer attributes we are interested in */
770 {
771 "job-template",
772 "printer-defaults",
773 "printer-description",
774 "media-col-database",
775 "media-col-ready"
776 };
777
778
779 ldata = *data;
780
781 /*
782 * Start monitoring the printer in the background...
783 */
784
785 monitor_id = _cupsThreadCreate((_cups_thread_func_t)monitor_printer, &ldata);
786
787 /*
788 * Open a connection to the printer...
789 */
790
791 http = httpConnect2(data->hostname, data->port, NULL, AF_UNSPEC, data->encryption, 1, 0, NULL);
792
793 /*
794 * Query printer status and capabilities...
795 */
796
797 request = ippNewRequest(IPP_OP_GET_PRINTER_ATTRIBUTES);
798 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, ldata.uri);
799 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name", NULL, cupsUser());
800 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD, "requested-attributes", (int)(sizeof(pattrs) / sizeof(pattrs[0])), NULL, pattrs);
801
802 response = cupsDoRequest(http, request, ldata.resource);
803
804 if (verbosity)
805 show_capabilities(response);
806
807 /*
808 * Now figure out what we will be printing...
809 */
810
811 if (ldata.docfile)
812 {
813 /*
814 * User specified a print file, figure out the format...
815 */
816 const char *ext; /* Filename extension */
817
818 if ((ext = strrchr(ldata.docfile, '.')) != NULL)
819 {
820 /*
821 * Guess the format from the extension...
822 */
823
824 if (!strcmp(ext, ".jpg"))
825 ldata.docformat = "image/jpeg";
826 else if (!strcmp(ext, ".pdf"))
827 ldata.docformat = "application/pdf";
828 else if (!strcmp(ext, ".ps"))
829 ldata.docformat = "application/postscript";
830 else if (!strcmp(ext, ".pwg"))
831 ldata.docformat = "image/pwg-raster";
832 else if (!strcmp(ext, ".urf"))
833 ldata.docformat = "image/urf";
834 else
835 ldata.docformat = "application/octet-stream";
836 }
837 else
838 {
839 /*
840 * Tell the printer to auto-detect...
841 */
842
843 ldata.docformat = "application/octet-stream";
844 }
845 }
846 else
847 {
848 /*
849 * No file specified, make something to test with...
850 */
851
852 if ((ldata.docfile = make_raster_file(response, ldata.grayscale, tempfile, sizeof(tempfile), &ldata.docformat)) == NULL)
853 return ((void *)1);
854 }
855
856 ippDelete(response);
857
858 /*
859 * Create a job and wait for completion...
860 */
861
862 request = ippNewRequest(IPP_OP_CREATE_JOB);
863 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, ldata.uri);
864 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name", NULL, cupsUser());
865
866 if ((name = strrchr(ldata.docfile, '/')) != NULL)
867 name ++;
868 else
869 name = ldata.docfile;
870
871 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "job-name", NULL, name);
872
873 if (verbosity)
874 show_attributes("Create-Job request", 1, request);
875
876 response = cupsDoRequest(http, request, ldata.resource);
877
878 if (verbosity)
879 show_attributes("Create-Job response", 0, response);
880
881 if (cupsLastError() >= IPP_STATUS_REDIRECTION_OTHER_SITE)
882 {
883 printf("Unable to create print job: %s\n", cupsLastErrorString());
884
885 ldata.job_state = IPP_JSTATE_ABORTED;
886
887 goto cleanup;
888 }
889
890 if ((attr = ippFindAttribute(response, "job-id", IPP_TAG_INTEGER)) == NULL)
891 {
892 puts("No job-id returned in Create-Job request.");
893
894 ldata.job_state = IPP_JSTATE_ABORTED;
895
896 goto cleanup;
897 }
898
899 ldata.job_id = ippGetInteger(attr, 0);
900
901 printf("CREATED JOB %d, sending %s of type %s\n", ldata.job_id, ldata.docfile, ldata.docformat);
902
903 ippDelete(response);
904
905 request = ippNewRequest(IPP_OP_SEND_DOCUMENT);
906 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, ldata.uri);
907 ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "job-id", ldata.job_id);
908 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name", NULL, cupsUser());
909 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_MIMETYPE, "document-format", NULL, ldata.docformat);
910 ippAddBoolean(request, IPP_TAG_OPERATION, "last-document", 1);
911
912 if (verbosity)
913 show_attributes("Send-Document request", 1, request);
914
915 response = cupsDoFileRequest(http, request, ldata.resource, ldata.docfile);
916
917 if (verbosity)
918 show_attributes("Send-Document response", 0, response);
919
920 if (cupsLastError() >= IPP_STATUS_REDIRECTION_OTHER_SITE)
921 {
922 printf("Unable to print file: %s\n", cupsLastErrorString());
923
924 ldata.job_state = IPP_JSTATE_ABORTED;
925
926 goto cleanup;
927 }
928
929 puts("WAITING FOR JOB TO COMPLETE");
930
931 while (ldata.job_state < IPP_JSTATE_CANCELED)
932 sleep(1);
933
934 /*
935 * Cleanup after ourselves...
936 */
937
938 cleanup:
939
940 httpClose(http);
941
942 if (tempfile[0] && !ldata.keepfile)
943 unlink(tempfile);
944
945 _cupsThreadWait(monitor_id);
946
947 _cupsMutexLock(&client_mutex);
948 client_count --;
949 _cupsMutexUnlock(&client_mutex);
950
951 return (NULL);
952 }
953
954
955 /*
956 * 'show_attributes()' - Show attributes in a request or response.
957 */
958
959 static void
show_attributes(const char * title,int request,ipp_t * ipp)960 show_attributes(const char *title, /* I - Title */
961 int request, /* I - 1 for request, 0 for response */
962 ipp_t *ipp) /* I - IPP request/response */
963 {
964 int minor, major = ippGetVersion(ipp, &minor);
965 /* IPP version number */
966 ipp_tag_t group = IPP_TAG_ZERO;
967 /* Current group tag */
968 ipp_attribute_t *attr; /* Current attribute */
969 const char *name; /* Attribute name */
970 char buffer[1024]; /* Value */
971
972
973 printf("%s:\n", title);
974 printf(" version=%d.%d\n", major, minor);
975 printf(" request-id=%d\n", ippGetRequestId(ipp));
976 if (!request)
977 printf(" status-code=%s\n", ippErrorString(ippGetStatusCode(ipp)));
978
979 for (attr = ippFirstAttribute(ipp); attr; attr = ippNextAttribute(ipp))
980 {
981 if (group != ippGetGroupTag(attr))
982 {
983 group = ippGetGroupTag(attr);
984 if (group)
985 printf(" %s:\n", ippTagString(group));
986 }
987
988 if ((name = ippGetName(attr)) != NULL)
989 {
990 ippAttributeString(attr, buffer, sizeof(buffer));
991 printf(" %s(%s%s)=%s\n", name, ippGetCount(attr) > 1 ? "1setOf " : "", ippTagString(ippGetValueTag(attr)), buffer);
992 }
993 }
994 }
995
996
997 /*
998 * 'show_capabilities()' - Show printer capabilities.
999 */
1000
1001 static void
show_capabilities(ipp_t * response)1002 show_capabilities(ipp_t *response) /* I - Printer attributes */
1003 {
1004 int i; /* Looping var */
1005 ipp_attribute_t *attr; /* Attribute */
1006 char buffer[1024]; /* Attribute value buffer */
1007 static const char * const pattrs[] = /* Attributes we want to show */
1008 {
1009 "copies-default",
1010 "copies-supported",
1011 "finishings-default",
1012 "finishings-ready",
1013 "finishings-supported",
1014 "media-default",
1015 "media-ready",
1016 "media-supported",
1017 "output-bin-default",
1018 "output-bin-supported",
1019 "print-color-mode-default",
1020 "print-color-mode-supported",
1021 "sides-default",
1022 "sides-supported",
1023 "document-format-default",
1024 "document-format-supported",
1025 "pwg-raster-document-resolution-supported",
1026 "pwg-raster-document-type-supported",
1027 "urf-supported"
1028 };
1029
1030
1031 puts("CAPABILITIES:");
1032 for (i = 0; i < (int)(sizeof(pattrs) / sizeof(pattrs[0])); i ++)
1033 {
1034 if ((attr = ippFindAttribute(response, pattrs[i], IPP_TAG_ZERO)) != NULL)
1035 {
1036 ippAttributeString(attr, buffer, sizeof(buffer));
1037 printf(" %s=%s\n", pattrs[i], buffer);
1038 }
1039 }
1040 }
1041
1042
1043 /*
1044 * 'usage()' - Show program usage...
1045 */
1046
1047 static void
usage(void)1048 usage(void)
1049 {
1050 puts("Usage: ./testclient printer-uri [options]");
1051 puts("Options:");
1052 puts(" -c num-clients Simulate multiple clients");
1053 puts(" -d document-format Generate the specified format");
1054 puts(" -f print-file Print the named file");
1055 puts(" -g Force grayscale printing");
1056 puts(" -k Keep temporary files");
1057 puts(" -v Be more verbose");
1058 }
1059