1 /*
2 * LIBUSB interface code for CUPS.
3 *
4 * Copyright 2007-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 <libusb.h>
15 #include <cups/cups-private.h>
16 #include <cups/ppd-private.h>
17 #include <cups/dir.h>
18 #include <pthread.h>
19 #include <sys/select.h>
20 #include <sys/types.h>
21 #include <sys/stat.h>
22 #include <sys/time.h>
23 #include <unistd.h>
24
25
26 /*
27 * WAIT_EOF_DELAY is number of seconds we'll wait for responses from
28 * the printer after we've finished sending all the data
29 */
30
31 #define WAIT_EOF 0
32 #define WAIT_EOF_DELAY 7
33 #define WAIT_SIDE_DELAY 3
34 #define DEFAULT_TIMEOUT 5000L
35
36
37 /*
38 * Local types...
39 */
40
41 typedef struct usb_printer_s /**** USB Printer Data ****/
42 {
43 struct libusb_device *device; /* Device info */
44 int conf, /* Configuration */
45 origconf, /* Original configuration */
46 iface, /* Interface */
47 altset, /* Alternate setting */
48 write_endp, /* Write endpoint */
49 read_endp, /* Read endpoint */
50 protocol, /* Protocol: 1 = Uni-di, 2 = Bi-di. */
51 usblp_attached, /* "usblp" kernel module attached? */
52 reset_after_job;/* Set to 1 by print_device() */
53 unsigned quirks; /* Quirks flags */
54 struct libusb_device_handle *handle; /* Open handle to device */
55 } usb_printer_t;
56
57 typedef int (*usb_cb_t)(usb_printer_t *, const char *, const char *,
58 const void *);
59
60 typedef struct usb_globals_s /* Global USB printer information */
61 {
62 usb_printer_t *printer; /* Printer */
63
64 pthread_mutex_t read_thread_mutex;
65 pthread_cond_t read_thread_cond;
66 int read_thread_stop;
67 int read_thread_done;
68
69 pthread_mutex_t readwrite_lock_mutex;
70 pthread_cond_t readwrite_lock_cond;
71 int readwrite_lock;
72
73 int print_fd; /* File descriptor to print */
74 ssize_t print_bytes; /* Print bytes read */
75
76 int wait_eof;
77 int drain_output; /* Drain all pending output */
78 int bidi_flag; /* 0=unidirectional, 1=bidirectional */
79
80 pthread_mutex_t sidechannel_thread_mutex;
81 pthread_cond_t sidechannel_thread_cond;
82 int sidechannel_thread_stop;
83 int sidechannel_thread_done;
84 } usb_globals_t;
85
86 /*
87 * Quirks: various printer quirks are handled by this structure and its flags.
88 *
89 * The quirks table used to be compiled into the backend but is now loaded from
90 * one or more files in the /usr/share/cups/usb directory.
91 */
92
93 #define USB_QUIRK_BLACKLIST 0x0001 /* Does not conform to the spec */
94 #define USB_QUIRK_NO_REATTACH 0x0002 /* After printing we cannot re-attach
95 the usblp kernel module */
96 #define USB_QUIRK_SOFT_RESET 0x0004 /* After printing do a soft reset
97 for clean-up */
98 #define USB_QUIRK_UNIDIR 0x0008 /* Requires unidirectional mode */
99 #define USB_QUIRK_USB_INIT 0x0010 /* Needs vendor USB init string */
100 #define USB_QUIRK_VENDOR_CLASS 0x0020 /* Descriptor uses vendor-specific
101 Class or SubClass */
102 #define USB_QUIRK_DELAY_CLOSE 0x0040 /* Delay close */
103 #define USB_QUIRK_WHITELIST 0x0000 /* no quirks */
104
105
106 typedef struct usb_quirk_s /* USB "quirk" information */
107 {
108 int vendor_id, /* Affected vendor ID */
109 product_id; /* Affected product ID or 0 for all */
110 unsigned quirks; /* Quirks bitfield */
111 } usb_quirk_t;
112
113
114
115
116 /*
117 * Globals...
118 */
119
120 cups_array_t *all_quirks; /* Array of printer quirks */
121 usb_globals_t g = { 0 }; /* Globals */
122 libusb_device **all_list; /* List of connected USB devices */
123
124
125 /*
126 * Local functions...
127 */
128
129 static int close_device(usb_printer_t *printer);
130 static int compare_quirks(usb_quirk_t *a, usb_quirk_t *b);
131 static usb_printer_t *find_device(usb_cb_t cb, const void *data);
132 static unsigned find_quirks(int vendor_id, int product_id);
133 static int get_device_id(usb_printer_t *printer, char *buffer,
134 size_t bufsize);
135 static int list_cb(usb_printer_t *printer, const char *device_uri,
136 const char *device_id, const void *data);
137 static void load_quirks(void);
138 static char *make_device_uri(usb_printer_t *printer,
139 const char *device_id,
140 char *uri, size_t uri_size);
141 static int open_device(usb_printer_t *printer, int verbose);
142 static int print_cb(usb_printer_t *printer, const char *device_uri,
143 const char *device_id, const void *data);
144 static void *read_thread(void *reference);
145 static void *sidechannel_thread(void *reference);
146 static void soft_reset(void);
147 static int soft_reset_printer(usb_printer_t *printer);
148
149
150 /*
151 * 'list_devices()' - List the available printers.
152 */
153
154 void
list_devices(void)155 list_devices(void)
156 {
157 load_quirks();
158
159 fputs("DEBUG: list_devices\n", stderr);
160 find_device(list_cb, NULL);
161 }
162
163
164 /*
165 * 'print_device()' - Print a file to a USB device.
166 */
167
168 int /* O - Exit status */
print_device(const char * uri,const char * hostname,const char * resource,char * options,int print_fd,int copies,int argc,char * argv[])169 print_device(const char *uri, /* I - Device URI */
170 const char *hostname, /* I - Hostname/manufacturer */
171 const char *resource, /* I - Resource/modelname */
172 char *options, /* I - Device options/serial number */
173 int print_fd, /* I - File descriptor to print */
174 int copies, /* I - Copies to print */
175 int argc, /* I - Number of command-line arguments (6 or 7) */
176 char *argv[]) /* I - Command-line arguments */
177 {
178 int bytes; /* Bytes written */
179 ssize_t total_bytes; /* Total bytes written */
180 struct sigaction action; /* Actions for POSIX signals */
181 int status = CUPS_BACKEND_OK,
182 /* Function results */
183 iostatus; /* Current IO status */
184 pthread_t read_thread_id, /* Read thread */
185 sidechannel_thread_id; /* Side-channel thread */
186 int have_sidechannel = 0, /* Was the side-channel thread started? */
187 have_backchannel = 0; /* Do we have a back channel? */
188 struct stat sidechannel_info; /* Side-channel file descriptor info */
189 unsigned char print_buffer[8192], /* Print data buffer */
190 *print_ptr; /* Pointer into print data buffer */
191 fd_set input_set; /* Input set for select() */
192 int nfds; /* Number of file descriptors */
193 struct timeval *timeout, /* Timeout pointer */
194 tv; /* Time value */
195 struct timespec cond_timeout; /* pthread condition timeout */
196 int num_opts; /* Number of options */
197 cups_option_t *opts; /* Options */
198 const char *val; /* Option value */
199
200
201 load_quirks();
202
203 /*
204 * See if the side-channel descriptor is valid...
205 */
206
207 have_sidechannel = !fstat(CUPS_SC_FD, &sidechannel_info) &&
208 S_ISSOCK(sidechannel_info.st_mode);
209
210 g.wait_eof = WAIT_EOF;
211
212 /*
213 * Connect to the printer...
214 */
215
216 fprintf(stderr, "DEBUG: Printing on printer with URI: %s\n", uri);
217 while ((g.printer = find_device(print_cb, uri)) == NULL)
218 {
219 _cupsLangPrintFilter(stderr, "INFO",
220 _("Waiting for printer to become available."));
221 sleep(5);
222 }
223
224 g.print_fd = print_fd;
225
226 /*
227 * Some devices need a reset after finishing a job, these devices are
228 * marked with the USB_QUIRK_SOFT_RESET quirk.
229 */
230 g.printer->reset_after_job = (g.printer->quirks & USB_QUIRK_SOFT_RESET ? 1 : 0);
231
232 /*
233 * If we are printing data from a print driver on stdin, ignore SIGTERM
234 * so that the driver can finish out any page data, e.g. to eject the
235 * current page. We only do this for stdin printing as otherwise there
236 * is no way to cancel a raw print job...
237 */
238
239 if (!print_fd)
240 {
241 memset(&action, 0, sizeof(action));
242
243 sigemptyset(&action.sa_mask);
244 action.sa_handler = SIG_IGN;
245 sigaction(SIGTERM, &action, NULL);
246 }
247
248 /*
249 * Start the side channel thread if the descriptor is valid...
250 */
251
252 pthread_mutex_init(&g.readwrite_lock_mutex, NULL);
253 pthread_cond_init(&g.readwrite_lock_cond, NULL);
254 g.readwrite_lock = 1;
255
256 if (have_sidechannel)
257 {
258 g.sidechannel_thread_stop = 0;
259 g.sidechannel_thread_done = 0;
260
261 pthread_cond_init(&g.sidechannel_thread_cond, NULL);
262 pthread_mutex_init(&g.sidechannel_thread_mutex, NULL);
263
264 if (pthread_create(&sidechannel_thread_id, NULL, sidechannel_thread, NULL))
265 {
266 fprintf(stderr, "DEBUG: Fatal USB error.\n");
267 _cupsLangPrintFilter(stderr, "ERROR",
268 _("There was an unrecoverable USB error."));
269 fputs("DEBUG: Couldn't create side-channel thread.\n", stderr);
270 close_device(g.printer);
271 return (CUPS_BACKEND_STOP);
272 }
273 }
274
275 /*
276 * Debug mode: If option "usb-unidir" is given, always deactivate
277 * backchannel
278 */
279
280 num_opts = cupsParseOptions(argv[5], 0, &opts);
281 val = cupsGetOption("usb-unidir", num_opts, opts);
282 if (val && strcasecmp(val, "no") && strcasecmp(val, "off") &&
283 strcasecmp(val, "false"))
284 {
285 g.printer->read_endp = -1;
286 fprintf(stderr, "DEBUG: Forced uni-directional communication "
287 "via \"usb-unidir\" option.\n");
288 }
289
290 /*
291 * Debug mode: If option "usb-no-reattach" is given, do not re-attach
292 * the usblp kernel module after the job has completed.
293 */
294
295 val = cupsGetOption("usb-no-reattach", num_opts, opts);
296 if (val && strcasecmp(val, "no") && strcasecmp(val, "off") &&
297 strcasecmp(val, "false"))
298 {
299 g.printer->usblp_attached = 0;
300 fprintf(stderr, "DEBUG: Forced not re-attaching the usblp kernel module "
301 "after the job via \"usb-no-reattach\" option.\n");
302 }
303
304 /*
305 * Get the read thread going...
306 */
307
308 if (g.printer->read_endp != -1)
309 {
310 have_backchannel = 1;
311
312 g.read_thread_stop = 0;
313 g.read_thread_done = 0;
314
315 pthread_cond_init(&g.read_thread_cond, NULL);
316 pthread_mutex_init(&g.read_thread_mutex, NULL);
317
318 if (pthread_create(&read_thread_id, NULL, read_thread, NULL))
319 {
320 fprintf(stderr, "DEBUG: Fatal USB error.\n");
321 _cupsLangPrintFilter(stderr, "ERROR",
322 _("There was an unrecoverable USB error."));
323 fputs("DEBUG: Couldn't create read thread.\n", stderr);
324 close_device(g.printer);
325 return (CUPS_BACKEND_STOP);
326 }
327 }
328 else
329 fprintf(stderr, "DEBUG: Uni-directional device/mode, back channel "
330 "deactivated.\n");
331
332 /*
333 * The main thread sends the print file...
334 */
335
336 g.drain_output = 0;
337 g.print_bytes = 0;
338 total_bytes = 0;
339 print_ptr = print_buffer;
340
341 while (status == CUPS_BACKEND_OK && copies-- > 0)
342 {
343 _cupsLangPrintFilter(stderr, "INFO", _("Sending data to printer."));
344
345 if (print_fd != STDIN_FILENO)
346 {
347 fputs("PAGE: 1 1\n", stderr);
348 lseek(print_fd, 0, SEEK_SET);
349 }
350
351 while (status == CUPS_BACKEND_OK)
352 {
353 FD_ZERO(&input_set);
354
355 if (!g.print_bytes)
356 FD_SET(print_fd, &input_set);
357
358 /*
359 * Calculate select timeout...
360 * If we have data waiting to send timeout is 100ms.
361 * else if we're draining print_fd timeout is 0.
362 * else we're waiting forever...
363 */
364
365 if (g.print_bytes)
366 {
367 tv.tv_sec = 0;
368 tv.tv_usec = 100000; /* 100ms */
369 timeout = &tv;
370 }
371 else if (g.drain_output)
372 {
373 tv.tv_sec = 0;
374 tv.tv_usec = 0;
375 timeout = &tv;
376 }
377 else
378 timeout = NULL;
379
380 /*
381 * I/O is unlocked around select...
382 */
383
384 pthread_mutex_lock(&g.readwrite_lock_mutex);
385 g.readwrite_lock = 0;
386 pthread_cond_signal(&g.readwrite_lock_cond);
387 pthread_mutex_unlock(&g.readwrite_lock_mutex);
388
389 nfds = select(print_fd + 1, &input_set, NULL, NULL, timeout);
390
391 /*
392 * Reacquire the lock...
393 */
394
395 pthread_mutex_lock(&g.readwrite_lock_mutex);
396 while (g.readwrite_lock)
397 pthread_cond_wait(&g.readwrite_lock_cond, &g.readwrite_lock_mutex);
398 g.readwrite_lock = 1;
399 pthread_mutex_unlock(&g.readwrite_lock_mutex);
400
401 if (nfds < 0)
402 {
403 if (errno == EINTR && total_bytes == 0)
404 {
405 fputs("DEBUG: Received an interrupt before any bytes were "
406 "written, aborting.\n", stderr);
407 close_device(g.printer);
408 return (CUPS_BACKEND_OK);
409 }
410 else if (errno != EAGAIN && errno != EINTR)
411 {
412 _cupsLangPrintFilter(stderr, "ERROR",
413 _("Unable to read print data."));
414 perror("DEBUG: select");
415 close_device(g.printer);
416 return (CUPS_BACKEND_FAILED);
417 }
418 }
419
420 /*
421 * If drain output has finished send a response...
422 */
423
424 if (g.drain_output && !nfds && !g.print_bytes)
425 {
426 /* Send a response... */
427 cupsSideChannelWrite(CUPS_SC_CMD_DRAIN_OUTPUT, CUPS_SC_STATUS_OK, NULL, 0, 1.0);
428 g.drain_output = 0;
429 }
430
431 /*
432 * Check if we have print data ready...
433 */
434
435 if (FD_ISSET(print_fd, &input_set))
436 {
437 g.print_bytes = read(print_fd, print_buffer, sizeof(print_buffer));
438
439 if (g.print_bytes < 0)
440 {
441 /*
442 * Read error - bail if we don't see EAGAIN or EINTR...
443 */
444
445 if (errno != EAGAIN && errno != EINTR)
446 {
447 _cupsLangPrintFilter(stderr, "ERROR",
448 _("Unable to read print data."));
449 perror("DEBUG: read");
450 close_device(g.printer);
451 return (CUPS_BACKEND_FAILED);
452 }
453
454 g.print_bytes = 0;
455 }
456 else if (g.print_bytes == 0)
457 {
458 /*
459 * End of file, break out of the loop...
460 */
461
462 break;
463 }
464
465 print_ptr = print_buffer;
466
467 fprintf(stderr, "DEBUG: Read %d bytes of print data...\n",
468 (int)g.print_bytes);
469 }
470
471 if (g.print_bytes)
472 {
473 iostatus = libusb_bulk_transfer(g.printer->handle,
474 g.printer->write_endp,
475 print_buffer, g.print_bytes,
476 &bytes, 0);
477 /*
478 * Ignore timeout errors, but retain the number of bytes written to
479 * avoid sending duplicate data...
480 */
481
482 if (iostatus == LIBUSB_ERROR_TIMEOUT)
483 {
484 fputs("DEBUG: Got USB transaction timeout during write.\n", stderr);
485 iostatus = 0;
486 }
487
488 /*
489 * If we've stalled, retry the write...
490 */
491
492 else if (iostatus == LIBUSB_ERROR_PIPE)
493 {
494 fputs("DEBUG: Got USB pipe stalled during write.\n", stderr);
495
496 iostatus = libusb_bulk_transfer(g.printer->handle,
497 g.printer->write_endp,
498 print_buffer, g.print_bytes,
499 &bytes, 0);
500 }
501
502 /*
503 * Retry a write after an aborted write since we probably just got
504 * SIGTERM...
505 */
506
507 else if (iostatus == LIBUSB_ERROR_INTERRUPTED)
508 {
509 fputs("DEBUG: Got USB return aborted during write.\n", stderr);
510
511 iostatus = libusb_bulk_transfer(g.printer->handle,
512 g.printer->write_endp,
513 print_buffer, g.print_bytes,
514 &bytes, 0);
515 }
516
517 if (iostatus)
518 {
519 /*
520 * Write error - bail if we don't see an error we can retry...
521 */
522
523 _cupsLangPrintFilter(stderr, "ERROR",
524 _("Unable to send data to printer."));
525 fprintf(stderr, "DEBUG: libusb write operation returned %x.\n",
526 iostatus);
527
528 status = CUPS_BACKEND_FAILED;
529 break;
530 }
531 else if (bytes > 0)
532 {
533 fprintf(stderr, "DEBUG: Wrote %d bytes of print data...\n",
534 (int)bytes);
535
536 g.print_bytes -= bytes;
537 print_ptr += bytes;
538 total_bytes += bytes;
539 }
540 }
541
542 if (print_fd != 0 && status == CUPS_BACKEND_OK)
543 fprintf(stderr, "DEBUG: Sending print file, " CUPS_LLFMT " bytes...\n",
544 CUPS_LLCAST total_bytes);
545 }
546 }
547
548 fprintf(stderr, "DEBUG: Sent " CUPS_LLFMT " bytes...\n",
549 CUPS_LLCAST total_bytes);
550
551 /*
552 * Signal the side channel thread to exit...
553 */
554
555 if (have_sidechannel)
556 {
557 close(CUPS_SC_FD);
558 pthread_mutex_lock(&g.readwrite_lock_mutex);
559 g.readwrite_lock = 0;
560 pthread_cond_signal(&g.readwrite_lock_cond);
561 pthread_mutex_unlock(&g.readwrite_lock_mutex);
562
563 g.sidechannel_thread_stop = 1;
564 pthread_mutex_lock(&g.sidechannel_thread_mutex);
565
566 if (!g.sidechannel_thread_done)
567 {
568 gettimeofday(&tv, NULL);
569 cond_timeout.tv_sec = tv.tv_sec + WAIT_SIDE_DELAY;
570 cond_timeout.tv_nsec = tv.tv_usec * 1000;
571
572 while (!g.sidechannel_thread_done)
573 {
574 if (pthread_cond_timedwait(&g.sidechannel_thread_cond,
575 &g.sidechannel_thread_mutex,
576 &cond_timeout) != 0)
577 break;
578 }
579 }
580
581 pthread_mutex_unlock(&g.sidechannel_thread_mutex);
582 }
583
584 /*
585 * Signal the read thread to exit then wait 7 seconds for it to complete...
586 */
587
588 if (have_backchannel)
589 {
590 g.read_thread_stop = 1;
591
592 pthread_mutex_lock(&g.read_thread_mutex);
593
594 if (!g.read_thread_done)
595 {
596 fputs("DEBUG: Waiting for read thread to exit...\n", stderr);
597
598 gettimeofday(&tv, NULL);
599 cond_timeout.tv_sec = tv.tv_sec + WAIT_EOF_DELAY;
600 cond_timeout.tv_nsec = tv.tv_usec * 1000;
601
602 while (!g.read_thread_done)
603 {
604 if (pthread_cond_timedwait(&g.read_thread_cond, &g.read_thread_mutex,
605 &cond_timeout) != 0)
606 break;
607 }
608
609 /*
610 * If it didn't exit abort the pending read and wait an additional
611 * second...
612 */
613
614 if (!g.read_thread_done)
615 {
616 fputs("DEBUG: Read thread still active, aborting the pending read...\n",
617 stderr);
618
619 g.wait_eof = 0;
620
621 gettimeofday(&tv, NULL);
622 cond_timeout.tv_sec = tv.tv_sec + 1;
623 cond_timeout.tv_nsec = tv.tv_usec * 1000;
624
625 while (!g.read_thread_done)
626 {
627 if (pthread_cond_timedwait(&g.read_thread_cond, &g.read_thread_mutex,
628 &cond_timeout) != 0)
629 break;
630 }
631 }
632 }
633
634 pthread_mutex_unlock(&g.read_thread_mutex);
635 }
636
637 /*
638 * Close the connection and input file and general clean up...
639 */
640
641 if (g.printer->quirks & USB_QUIRK_DELAY_CLOSE)
642 sleep(1);
643
644 close_device(g.printer);
645
646 /*
647 * Clean up ....
648 */
649
650 libusb_free_device_list(all_list, 1);
651 libusb_exit(NULL);
652
653 return (status);
654 }
655
656
657 /*
658 * 'close_device()' - Close the connection to the USB printer.
659 */
660
661 static int /* I - 0 on success, -1 on failure */
close_device(usb_printer_t * printer)662 close_device(usb_printer_t *printer) /* I - Printer */
663 {
664 struct libusb_device_descriptor devdesc;
665 /* Current device descriptor */
666 struct libusb_config_descriptor *confptr;
667 /* Pointer to current configuration */
668
669
670 if (printer->handle)
671 {
672 /*
673 * Release interfaces before closing so that we know all data is written
674 * to the device...
675 */
676
677 int errcode; /* Return value of libusb function */
678 int number1, /* Interface number */
679 number2; /* Configuration number */
680
681 errcode =
682 libusb_get_config_descriptor(printer->device, printer->conf, &confptr);
683 if (errcode >= 0)
684 {
685 number1 = confptr->interface[printer->iface].
686 altsetting[printer->altset].bInterfaceNumber;
687 libusb_release_interface(printer->handle, number1);
688
689 number2 = confptr->bConfigurationValue;
690
691 libusb_free_config_descriptor(confptr);
692
693 /*
694 * If we have changed the configuration from one valid configuration
695 * to another, restore the old one
696 */
697 if (printer->origconf > 0 && printer->origconf != number2)
698 {
699 fprintf(stderr, "DEBUG: Restoring USB device configuration: %d -> %d\n",
700 number2, printer->origconf);
701 if ((errcode = libusb_set_configuration(printer->handle,
702 printer->origconf)) < 0)
703 {
704 if (errcode != LIBUSB_ERROR_BUSY)
705 {
706 errcode =
707 libusb_get_device_descriptor (printer->device, &devdesc);
708 if (errcode < 0)
709 fprintf(stderr,
710 "DEBUG: Failed to set configuration %d\n",
711 printer->origconf);
712 else
713 fprintf(stderr,
714 "DEBUG: Failed to set configuration %d for %04x:%04x\n",
715 printer->origconf, devdesc.idVendor, devdesc.idProduct);
716 }
717 }
718 }
719
720 /*
721 * Re-attach "usblp" kernel module if it was attached before using this
722 * device
723 */
724 if (printer->usblp_attached == 1)
725 if (libusb_attach_kernel_driver(printer->handle, number1) < 0)
726 {
727 errcode = libusb_get_device_descriptor (printer->device, &devdesc);
728 if (errcode < 0)
729 fprintf(stderr,
730 "DEBUG: Failed to re-attach \"usblp\" kernel module\n");
731 else
732 fprintf(stderr,
733 "DEBUG: Failed to re-attach \"usblp\" kernel module to "
734 "%04x:%04x\n", devdesc.idVendor, devdesc.idProduct);
735 }
736 }
737 else
738 fprintf(stderr,
739 "DEBUG: Failed to get configuration descriptor %d\n",
740 printer->conf);
741
742 /*
743 * Reset the device to clean up after the job
744 */
745
746 if (printer->reset_after_job == 1)
747 {
748 if ((errcode = libusb_reset_device(printer->handle)) < 0)
749 fprintf(stderr,
750 "DEBUG: Device reset failed, error code: %d\n",
751 errcode);
752 else
753 fprintf(stderr,
754 "DEBUG: Resetting printer.\n");
755 }
756
757 /*
758 * Close the interface and return...
759 */
760
761 libusb_close(printer->handle);
762 printer->handle = NULL;
763 }
764
765 return (0);
766 }
767
768
769 /*
770 * 'compare_quirks()' - Compare two quirks entries.
771 */
772
773 static int /* O - Result of comparison */
compare_quirks(usb_quirk_t * a,usb_quirk_t * b)774 compare_quirks(usb_quirk_t *a, /* I - First quirk entry */
775 usb_quirk_t *b) /* I - Second quirk entry */
776 {
777 int result; /* Result of comparison */
778
779 if ((result = b->vendor_id - a->vendor_id) == 0)
780 result = b->product_id - a->product_id;
781
782 return (result);
783 }
784
785
786 /*
787 * 'find_device()' - Find or enumerate USB printers.
788 */
789
790 static usb_printer_t * /* O - Found printer */
find_device(usb_cb_t cb,const void * data)791 find_device(usb_cb_t cb, /* I - Callback function */
792 const void *data) /* I - User data for callback */
793 {
794 libusb_device **list; /* List of connected USB devices */
795 libusb_device *device = NULL; /* Current device */
796 struct libusb_device_descriptor devdesc;
797 /* Current device descriptor */
798 struct libusb_config_descriptor *confptr = NULL;
799 /* Pointer to current configuration */
800 const struct libusb_interface *ifaceptr = NULL;
801 /* Pointer to current interface */
802 const struct libusb_interface_descriptor *altptr = NULL;
803 /* Pointer to current alternate setting */
804 const struct libusb_endpoint_descriptor *endpptr = NULL;
805 /* Pointer to current endpoint */
806 ssize_t err = 0, /* Error code */
807 numdevs, /* number of connected devices */
808 i = 0;
809 uint8_t conf, /* Current configuration */
810 iface, /* Current interface */
811 altset, /* Current alternate setting */
812 protocol, /* Current protocol */
813 endp, /* Current endpoint */
814 read_endp, /* Current read endpoint */
815 write_endp; /* Current write endpoint */
816 char device_id[1024],/* IEEE-1284 device ID */
817 device_uri[1024];
818 /* Device URI */
819 static usb_printer_t printer; /* Current printer */
820
821
822 /*
823 * Initialize libusb...
824 */
825
826 err = libusb_init(NULL);
827 if (err)
828 {
829 fprintf(stderr, "ERROR: Unable to initialize USB access via libusb, libusb error %i (%s)\n", (int)err, libusb_strerror((int)err));
830 return (NULL);
831 }
832
833 numdevs = libusb_get_device_list(NULL, &list);
834 fprintf(stderr, "DEBUG: libusb_get_device_list=%d\n", (int)numdevs);
835
836 /*
837 * Then loop through the devices it found...
838 */
839
840 if (numdevs > 0)
841 for (i = 0; i < numdevs; i++)
842 {
843 device = list[i];
844
845 /*
846 * Ignore devices with no configuration data and anything that is not
847 * a printer...
848 */
849
850 if (libusb_get_device_descriptor(device, &devdesc) < 0)
851 continue;
852
853 if (!devdesc.bNumConfigurations || !devdesc.idVendor ||
854 !devdesc.idProduct)
855 continue;
856
857 printer.quirks = find_quirks(devdesc.idVendor, devdesc.idProduct);
858
859 /*
860 * Ignore blacklisted printers...
861 */
862
863 if (printer.quirks & USB_QUIRK_BLACKLIST)
864 continue;
865
866 for (conf = 0; conf < devdesc.bNumConfigurations; conf ++)
867 {
868 if (libusb_get_config_descriptor(device, conf, &confptr) < 0)
869 continue;
870 for (iface = 0, ifaceptr = confptr->interface;
871 iface < confptr->bNumInterfaces;
872 iface ++, ifaceptr ++)
873 {
874 /*
875 * Some printers offer multiple interfaces...
876 */
877
878 protocol = 0;
879
880 for (altset = 0, altptr = ifaceptr->altsetting;
881 altset < ifaceptr->num_altsetting; // lgtm [cpp/comparison-with-wider-type]
882 altset ++, altptr ++)
883 {
884 /*
885 * Currently we only support unidirectional and bidirectional
886 * printers. Future versions of this code will support the
887 * 1284.4 (packet mode) protocol as well.
888 */
889
890 if (((altptr->bInterfaceClass != LIBUSB_CLASS_PRINTER ||
891 altptr->bInterfaceSubClass != 1) &&
892 ((printer.quirks & USB_QUIRK_VENDOR_CLASS) == 0)) ||
893 (altptr->bInterfaceProtocol != 1 && /* Unidirectional */
894 altptr->bInterfaceProtocol != 2) || /* Bidirectional */
895 altptr->bInterfaceProtocol < protocol)
896 continue;
897
898 if (printer.quirks & USB_QUIRK_VENDOR_CLASS)
899 fprintf(stderr, "DEBUG: Printer does not report class 7 and/or "
900 "subclass 1 but works as a printer anyway\n");
901
902 read_endp = 0xff;
903 write_endp = 0xff;
904
905 for (endp = 0, endpptr = altptr->endpoint;
906 endp < altptr->bNumEndpoints;
907 endp ++, endpptr ++)
908 if ((endpptr->bmAttributes & LIBUSB_TRANSFER_TYPE_MASK) ==
909 LIBUSB_TRANSFER_TYPE_BULK)
910 {
911 if (endpptr->bEndpointAddress & LIBUSB_ENDPOINT_DIR_MASK)
912 read_endp = endp;
913 else
914 write_endp = endp;
915 }
916
917 if (write_endp != 0xff)
918 {
919 /*
920 * Save the best match so far...
921 */
922
923 protocol = altptr->bInterfaceProtocol;
924 printer.altset = altset;
925 printer.write_endp = write_endp;
926 if (protocol > 1)
927 printer.read_endp = read_endp;
928 else
929 printer.read_endp = -1;
930 }
931 }
932
933 if (protocol > 0)
934 {
935 printer.device = device;
936 printer.conf = conf;
937 printer.iface = iface;
938 printer.protocol = protocol;
939 printer.handle = NULL;
940
941 if (!open_device(&printer, data != NULL))
942 {
943 get_device_id(&printer, device_id, sizeof(device_id));
944 make_device_uri(&printer, device_id, device_uri,
945 sizeof(device_uri));
946
947 fprintf(stderr, "DEBUG2: Printer found with device ID: %s "
948 "Device URI: %s\n",
949 device_id, device_uri);
950
951 if ((*cb)(&printer, device_uri, device_id, data))
952 {
953 fprintf(stderr, "DEBUG: Device protocol: %d\n",
954 printer.protocol);
955 if (printer.quirks & USB_QUIRK_UNIDIR)
956 {
957 printer.read_endp = -1;
958 fprintf(stderr, "DEBUG: Printer reports bi-di support "
959 "but in reality works only uni-directionally\n");
960 }
961 if (printer.read_endp != -1)
962 {
963 printer.read_endp = confptr->interface[printer.iface].
964 altsetting[printer.altset].
965 endpoint[printer.read_endp].
966 bEndpointAddress;
967 }
968 else
969 fprintf(stderr, "DEBUG: Uni-directional USB communication "
970 "only!\n");
971 printer.write_endp = confptr->interface[printer.iface].
972 altsetting[printer.altset].
973 endpoint[printer.write_endp].
974 bEndpointAddress;
975 if (printer.quirks & USB_QUIRK_NO_REATTACH)
976 {
977 printer.usblp_attached = 0;
978 fprintf(stderr, "DEBUG: Printer does not like usblp "
979 "kernel module to be re-attached after job\n");
980 }
981 libusb_free_config_descriptor(confptr);
982 return (&printer);
983 }
984
985 close_device(&printer);
986 }
987 }
988 }
989 libusb_free_config_descriptor(confptr);
990 }
991 }
992
993 /*
994 * If we get this far without returning, then we haven't found a printer
995 * to print to...
996 */
997
998 /*
999 * Clean up ....
1000 */
1001
1002 if (numdevs >= 0)
1003 libusb_free_device_list(list, 1);
1004 libusb_exit(NULL);
1005
1006 return (NULL);
1007 }
1008
1009
1010 /*
1011 * 'find_quirks()' - Find the quirks for the given printer, if any.
1012 *
1013 * First looks for an exact match, then looks for the vendor ID wildcard match.
1014 */
1015
1016 static unsigned /* O - Quirks flags */
find_quirks(int vendor_id,int product_id)1017 find_quirks(int vendor_id, /* I - Vendor ID */
1018 int product_id) /* I - Product ID */
1019 {
1020 usb_quirk_t key, /* Search key */
1021 *match; /* Matching quirk entry */
1022
1023
1024 key.vendor_id = vendor_id;
1025 key.product_id = product_id;
1026
1027 if ((match = cupsArrayFind(all_quirks, &key)) != NULL)
1028 return (match->quirks);
1029
1030 key.product_id = 0;
1031
1032 if ((match = cupsArrayFind(all_quirks, &key)) != NULL)
1033 return (match->quirks);
1034
1035 return (USB_QUIRK_WHITELIST);
1036 }
1037
1038
1039 /*
1040 * 'get_device_id()' - Get the IEEE-1284 device ID for the printer.
1041 */
1042
1043 static int /* O - 0 on success, -1 on error */
get_device_id(usb_printer_t * printer,char * buffer,size_t bufsize)1044 get_device_id(usb_printer_t *printer, /* I - Printer */
1045 char *buffer, /* I - String buffer */
1046 size_t bufsize) /* I - Number of bytes in buffer */
1047 {
1048 int length; /* Length of device ID */
1049
1050
1051 if (libusb_control_transfer(printer->handle,
1052 LIBUSB_REQUEST_TYPE_CLASS | LIBUSB_ENDPOINT_IN |
1053 LIBUSB_RECIPIENT_INTERFACE,
1054 0, printer->conf,
1055 (printer->iface << 8) | printer->altset,
1056 (unsigned char *)buffer, bufsize, 5000) < 0)
1057 {
1058 *buffer = '\0';
1059 return (-1);
1060 }
1061
1062 /*
1063 * Extract the length of the device ID string from the first two
1064 * bytes. The 1284 spec says the length is stored MSB first...
1065 */
1066
1067 length = (int)((((unsigned)buffer[0] & 255) << 8) | ((unsigned)buffer[1] & 255));
1068
1069 /*
1070 * Check to see if the length is larger than our buffer or less than 14 bytes
1071 * (the minimum valid device ID is "MFG:x;MDL:y;" with 2 bytes for the length).
1072 *
1073 * If the length is out-of-range, assume that the vendor incorrectly
1074 * implemented the 1284 spec and re-read the length as LSB first,..
1075 */
1076
1077 if (length > bufsize || length < 14)
1078 length = (int)((((unsigned)buffer[1] & 255) << 8) | ((unsigned)buffer[0] & 255));
1079
1080 if (length > bufsize)
1081 length = bufsize;
1082
1083 if (length < 14)
1084 {
1085 /*
1086 * Invalid device ID, clear it!
1087 */
1088
1089 *buffer = '\0';
1090 return (-1);
1091 }
1092
1093 length -= 2;
1094
1095 /*
1096 * Copy the device ID text to the beginning of the buffer and
1097 * nul-terminate.
1098 */
1099
1100 memmove(buffer, buffer + 2, (size_t)length);
1101 buffer[length] = '\0';
1102
1103 return (0);
1104 }
1105
1106
1107 /*
1108 * 'list_cb()' - List USB printers for discovery.
1109 */
1110
1111 static int /* O - 0 to continue, 1 to stop */
list_cb(usb_printer_t * printer,const char * device_uri,const char * device_id,const void * data)1112 list_cb(usb_printer_t *printer, /* I - Printer */
1113 const char *device_uri, /* I - Device URI */
1114 const char *device_id, /* I - IEEE-1284 device ID */
1115 const void *data) /* I - User data (not used) */
1116 {
1117 char make_model[1024]; /* Make and model */
1118
1119
1120 /*
1121 * Get the device URI and make/model strings...
1122 */
1123
1124 if (backendGetMakeModel(device_id, make_model, sizeof(make_model)))
1125 strlcpy(make_model, "Unknown", sizeof(make_model));
1126
1127 /*
1128 * Report the printer...
1129 */
1130
1131 cupsBackendReport("direct", device_uri, make_model, make_model, device_id,
1132 NULL);
1133
1134 /*
1135 * Keep going...
1136 */
1137
1138 return (0);
1139 }
1140
1141
1142 /*
1143 * 'load_quirks()' - Load all quirks files in the /usr/share/cups/usb directory.
1144 */
1145
1146 static void
load_quirks(void)1147 load_quirks(void)
1148 {
1149 const char *datadir; /* CUPS_DATADIR environment variable */
1150 char filename[1024], /* Filename */
1151 line[1024]; /* Line from file */
1152 cups_dir_t *dir; /* Directory */
1153 cups_dentry_t *dent; /* Directory entry */
1154 cups_file_t *fp; /* Quirks file */
1155 usb_quirk_t *quirk; /* New quirk */
1156
1157
1158 all_quirks = cupsArrayNew((cups_array_func_t)compare_quirks, NULL);
1159
1160 if ((datadir = getenv("CUPS_DATADIR")) == NULL)
1161 datadir = CUPS_DATADIR;
1162
1163 snprintf(filename, sizeof(filename), "%s/usb", datadir);
1164 if ((dir = cupsDirOpen(filename)) == NULL)
1165 {
1166 perror(filename);
1167 return;
1168 }
1169
1170 fprintf(stderr, "DEBUG: Loading USB quirks from \"%s\".\n", filename);
1171
1172 while ((dent = cupsDirRead(dir)) != NULL)
1173 {
1174 if (!S_ISREG(dent->fileinfo.st_mode))
1175 continue;
1176
1177 snprintf(filename, sizeof(filename), "%s/usb/%s", datadir, dent->filename);
1178 if ((fp = cupsFileOpen(filename, "r")) == NULL)
1179 {
1180 perror(filename);
1181 continue;
1182 }
1183
1184 while (cupsFileGets(fp, line, sizeof(line)))
1185 {
1186 /*
1187 * Skip blank and comment lines...
1188 */
1189
1190 if (line[0] == '#' || !line[0])
1191 continue;
1192
1193 /*
1194 * Add a quirk...
1195 */
1196
1197 if ((quirk = calloc(1, sizeof(usb_quirk_t))) == NULL)
1198 {
1199 perror("DEBUG: Unable to allocate memory for quirk");
1200 break;
1201 }
1202
1203 if (sscanf(line, "%x%x", &quirk->vendor_id, &quirk->product_id) < 1)
1204 {
1205 fprintf(stderr, "DEBUG: Bad line: %s\n", line);
1206 free(quirk);
1207 continue;
1208 }
1209
1210 if (strstr(line, " blacklist"))
1211 quirk->quirks |= USB_QUIRK_BLACKLIST;
1212
1213 if (strstr(line, " delay-close"))
1214 quirk->quirks |= USB_QUIRK_DELAY_CLOSE;
1215
1216 if (strstr(line, " no-reattach"))
1217 quirk->quirks |= USB_QUIRK_NO_REATTACH;
1218
1219 if (strstr(line, " soft-reset"))
1220 quirk->quirks |= USB_QUIRK_SOFT_RESET;
1221
1222 if (strstr(line, " unidir"))
1223 quirk->quirks |= USB_QUIRK_UNIDIR;
1224
1225 if (strstr(line, " usb-init"))
1226 quirk->quirks |= USB_QUIRK_USB_INIT;
1227
1228 if (strstr(line, " vendor-class"))
1229 quirk->quirks |= USB_QUIRK_VENDOR_CLASS;
1230
1231 cupsArrayAdd(all_quirks, quirk);
1232 }
1233
1234 cupsFileClose(fp);
1235 }
1236
1237 fprintf(stderr, "DEBUG: Loaded %d quirks.\n", cupsArrayCount(all_quirks));
1238
1239 cupsDirClose(dir);
1240 }
1241
1242
1243 /*
1244 * 'make_device_uri()' - Create a device URI for a USB printer.
1245 */
1246
1247 static char * /* O - Device URI */
make_device_uri(usb_printer_t * printer,const char * device_id,char * uri,size_t uri_size)1248 make_device_uri(
1249 usb_printer_t *printer, /* I - Printer */
1250 const char *device_id, /* I - IEEE-1284 device ID */
1251 char *uri, /* I - Device URI buffer */
1252 size_t uri_size) /* I - Size of device URI buffer */
1253 {
1254 struct libusb_device_descriptor devdesc;
1255 /* Current device descriptor */
1256 char options[1024]; /* Device URI options */
1257 int num_values; /* Number of 1284 parameters */
1258 cups_option_t *values; /* 1284 parameters */
1259 const char *mfg, /* Manufacturer */
1260 *mdl, /* Model */
1261 *des = NULL, /* Description */
1262 *sern; /* Serial number */
1263 size_t mfglen; /* Length of manufacturer string */
1264 char tempmfg[256], /* Temporary manufacturer string */
1265 tempsern[256], /* Temporary serial number string */
1266 *tempptr; /* Pointer into temp string */
1267
1268
1269 /*
1270 * Get the make, model, and serial numbers...
1271 */
1272
1273 num_values = _cupsGet1284Values(device_id, &values);
1274
1275 if ((sern = cupsGetOption("SERIALNUMBER", num_values, values)) == NULL)
1276 if ((sern = cupsGetOption("SERN", num_values, values)) == NULL)
1277 if ((sern = cupsGetOption("SN", num_values, values)) == NULL &&
1278 ((libusb_get_device_descriptor(printer->device, &devdesc) >= 0) &&
1279 devdesc.iSerialNumber))
1280 {
1281 /*
1282 * Try getting the serial number from the device itself...
1283 */
1284
1285 int length =
1286 libusb_get_string_descriptor_ascii(printer->handle,
1287 devdesc.iSerialNumber,
1288 (unsigned char *)tempsern,
1289 sizeof(tempsern) - 1);
1290 if (length > 0)
1291 {
1292 tempsern[length] = '\0';
1293 sern = tempsern;
1294 }
1295 }
1296
1297 if ((mfg = cupsGetOption("MANUFACTURER", num_values, values)) == NULL)
1298 mfg = cupsGetOption("MFG", num_values, values);
1299
1300 if ((mdl = cupsGetOption("MODEL", num_values, values)) == NULL)
1301 mdl = cupsGetOption("MDL", num_values, values);
1302
1303 /*
1304 * To maintain compatibility with the original character device backend on
1305 * Linux and *BSD, map manufacturer names...
1306 */
1307
1308 if (mfg)
1309 {
1310 if (!_cups_strcasecmp(mfg, "Hewlett-Packard"))
1311 mfg = "HP";
1312 else if (!_cups_strcasecmp(mfg, "Lexmark International"))
1313 mfg = "Lexmark";
1314 }
1315 else
1316 {
1317 /*
1318 * No manufacturer? Use the model string or description...
1319 */
1320
1321 if (mdl)
1322 _ppdNormalizeMakeAndModel(mdl, tempmfg, sizeof(tempmfg));
1323 else if ((des = cupsGetOption("DESCRIPTION", num_values, values)) != NULL ||
1324 (des = cupsGetOption("DES", num_values, values)) != NULL)
1325 _ppdNormalizeMakeAndModel(des, tempmfg, sizeof(tempmfg));
1326 else
1327 strlcpy(tempmfg, "Unknown", sizeof(tempmfg));
1328
1329 if ((tempptr = strchr(tempmfg, ' ')) != NULL)
1330 *tempptr = '\0';
1331
1332 mfg = tempmfg;
1333 }
1334
1335 if (!mdl)
1336 {
1337 /*
1338 * No model? Use description...
1339 */
1340 if (des)
1341 mdl = des; /* We remove the manufacturer name below */
1342 else if (!strncasecmp(mfg, "Unknown", 7))
1343 mdl = "Printer";
1344 else
1345 mdl = "Unknown Model";
1346 }
1347
1348 mfglen = strlen(mfg);
1349
1350 if (!strncasecmp(mdl, mfg, mfglen) && _cups_isspace(mdl[mfglen]))
1351 {
1352 mdl += mfglen + 1;
1353
1354 while (_cups_isspace(*mdl))
1355 mdl ++;
1356 }
1357
1358 /*
1359 * Generate the device URI from the manufacturer, model, serial number,
1360 * and interface number...
1361 */
1362
1363 if (sern)
1364 {
1365 if (printer->iface > 0)
1366 snprintf(options, sizeof(options), "?serial=%s&interface=%d", sern,
1367 printer->iface);
1368 else
1369 snprintf(options, sizeof(options), "?serial=%s", sern);
1370 }
1371 else if (printer->iface > 0)
1372 snprintf(options, sizeof(options), "?interface=%d", printer->iface);
1373 else
1374 options[0] = '\0';
1375
1376 httpAssembleURIf(HTTP_URI_CODING_ALL, uri, uri_size, "usb", NULL, mfg, 0,
1377 "/%s%s", mdl, options);
1378
1379 cupsFreeOptions(num_values, values);
1380
1381 return (uri);
1382 }
1383
1384
1385 /*
1386 * 'open_device()' - Open a connection to the USB printer.
1387 */
1388
1389 static int /* O - 0 on success, -1 on error */
open_device(usb_printer_t * printer,int verbose)1390 open_device(usb_printer_t *printer, /* I - Printer */
1391 int verbose) /* I - Update connecting-to-device state? */
1392 {
1393 struct libusb_device_descriptor devdesc;
1394 /* Current device descriptor */
1395 struct libusb_config_descriptor *confptr = NULL;
1396 /* Pointer to current configuration */
1397 int number1 = -1, /* Configuration/interface/altset */
1398 number2 = -1, /* numbers */
1399 errcode = 0;
1400 char current; /* Current configuration */
1401
1402
1403 /*
1404 * Return immediately if we are already connected...
1405 */
1406
1407 if (printer->handle)
1408 return (0);
1409
1410 /*
1411 * Try opening the printer...
1412 */
1413
1414 if ((errcode = libusb_open(printer->device, &printer->handle)) < 0)
1415 {
1416 fprintf(stderr, "DEBUG: Failed to open device, code: %d\n",
1417 errcode);
1418 return (-1);
1419 }
1420
1421 printer->usblp_attached = 0;
1422 printer->reset_after_job = 0;
1423
1424 if (verbose)
1425 fputs("STATE: +connecting-to-device\n", stderr);
1426
1427 if ((errcode = libusb_get_device_descriptor(printer->device, &devdesc)) < 0)
1428 {
1429 fprintf(stderr, "DEBUG: Failed to get device descriptor, code: %d\n",
1430 errcode);
1431 goto error;
1432 }
1433
1434 /*
1435 * Get the "usblp" kernel module out of the way. This backend only
1436 * works without the module attached.
1437 */
1438
1439 errcode = libusb_kernel_driver_active(printer->handle, printer->iface);
1440 if (errcode == 0)
1441 printer->usblp_attached = 0;
1442 else if (errcode == 1)
1443 {
1444 printer->usblp_attached = 1;
1445 if ((errcode =
1446 libusb_detach_kernel_driver(printer->handle, printer->iface)) < 0)
1447 {
1448 fprintf(stderr, "DEBUG: Failed to detach \"usblp\" module from %04x:%04x\n",
1449 devdesc.idVendor, devdesc.idProduct);
1450 goto error;
1451 }
1452 }
1453 else
1454 {
1455 printer->usblp_attached = 0;
1456
1457 if (errcode != LIBUSB_ERROR_NOT_SUPPORTED)
1458 {
1459 fprintf(stderr,
1460 "DEBUG: Failed to check whether %04x:%04x has the \"usblp\" "
1461 "kernel module attached\n", devdesc.idVendor, devdesc.idProduct);
1462 goto error;
1463 }
1464 }
1465
1466 /*
1467 * Set the desired configuration, but only if it needs changing. Some
1468 * printers (e.g., Samsung) don't like libusb_set_configuration. It will
1469 * succeed, but the following print job is sometimes silently lost by the
1470 * printer.
1471 */
1472
1473 if (libusb_control_transfer(printer->handle,
1474 LIBUSB_REQUEST_TYPE_STANDARD | LIBUSB_ENDPOINT_IN |
1475 LIBUSB_RECIPIENT_DEVICE,
1476 8, /* GET_CONFIGURATION */
1477 0, 0, (unsigned char *)¤t, 1, 5000) < 0)
1478 current = 0; /* Assume not configured */
1479
1480 printer->origconf = current;
1481
1482 if ((errcode =
1483 libusb_get_config_descriptor (printer->device, printer->conf, &confptr))
1484 < 0)
1485 {
1486 fprintf(stderr, "DEBUG: Failed to get config descriptor for %04x:%04x\n",
1487 devdesc.idVendor, devdesc.idProduct);
1488 goto error;
1489 }
1490 number1 = confptr->bConfigurationValue;
1491
1492 if (number1 != current)
1493 {
1494 fprintf(stderr, "DEBUG: Switching USB device configuration: %d -> %d\n",
1495 current, number1);
1496 if ((errcode = libusb_set_configuration(printer->handle, number1)) < 0)
1497 {
1498 /*
1499 * If the set fails, chances are that the printer only supports a
1500 * single configuration. Technically these printers don't conform to
1501 * the USB printer specification, but otherwise they'll work...
1502 */
1503
1504 if (errcode != LIBUSB_ERROR_BUSY)
1505 fprintf(stderr, "DEBUG: Failed to set configuration %d for %04x:%04x\n",
1506 number1, devdesc.idVendor, devdesc.idProduct);
1507 }
1508 }
1509
1510 /*
1511 * Claim interfaces as needed...
1512 */
1513
1514 number1 = confptr->interface[printer->iface].
1515 altsetting[printer->altset].bInterfaceNumber;
1516
1517 while ((errcode = libusb_claim_interface(printer->handle, number1)) < 0)
1518 {
1519 if (errcode != LIBUSB_ERROR_BUSY)
1520 {
1521 fprintf(stderr,
1522 "DEBUG: Failed to claim interface %d for %04x:%04x: %s\n",
1523 number1, devdesc.idVendor, devdesc.idProduct, strerror(errno));
1524
1525 goto error;
1526 }
1527 else if ((errcode = libusb_detach_kernel_driver(printer->handle, printer->iface)) < 0)
1528 {
1529 fprintf(stderr,
1530 "DEBUG: Failed to detach \"usblp\" module from %04x:%04x\n",
1531 devdesc.idVendor, devdesc.idProduct);
1532
1533 goto error;
1534 }
1535
1536 sleep (1);
1537 }
1538
1539 /*
1540 * Set alternate setting, but only if there is more than one option. Some
1541 * printers (e.g., Samsung) don't like usb_set_altinterface.
1542 */
1543
1544 if (confptr->interface[printer->iface].num_altsetting > 1)
1545 {
1546 number1 = confptr->interface[printer->iface].
1547 altsetting[printer->altset].bInterfaceNumber;
1548 number2 = confptr->interface[printer->iface].
1549 altsetting[printer->altset].bAlternateSetting;
1550
1551 while ((errcode =
1552 libusb_set_interface_alt_setting(printer->handle, number1, number2))
1553 < 0)
1554 {
1555 if (errcode != LIBUSB_ERROR_BUSY)
1556 {
1557 fprintf(stderr,
1558 "DEBUG: Failed to set alternate interface %d for %04x:%04x: "
1559 "%s\n",
1560 number2, devdesc.idVendor, devdesc.idProduct, strerror(errno));
1561
1562 goto error;
1563 }
1564 }
1565 }
1566
1567 libusb_free_config_descriptor(confptr);
1568
1569 if (verbose)
1570 fputs("STATE: -connecting-to-device\n", stderr);
1571
1572 return (0);
1573
1574 /*
1575 * If we get here, there was a hard error...
1576 */
1577
1578 error:
1579
1580 if (verbose)
1581 fputs("STATE: -connecting-to-device\n", stderr);
1582
1583 libusb_close(printer->handle);
1584 printer->handle = NULL;
1585
1586 return (-1);
1587 }
1588
1589
1590 /*
1591 * 'print_cb()' - Find a USB printer for printing.
1592 */
1593
1594 static int /* O - 0 to continue, 1 to stop (found) */
print_cb(usb_printer_t * printer,const char * device_uri,const char * device_id,const void * data)1595 print_cb(usb_printer_t *printer, /* I - Printer */
1596 const char *device_uri, /* I - Device URI */
1597 const char *device_id, /* I - IEEE-1284 device ID */
1598 const void *data) /* I - User data (make, model, S/N) */
1599 {
1600 char requested_uri[1024], /* Requested URI */
1601 *requested_ptr, /* Pointer into requested URI */
1602 detected_uri[1024], /* Detected URI */
1603 *detected_ptr; /* Pointer into detected URI */
1604
1605
1606 /*
1607 * If we have an exact match, stop now...
1608 */
1609
1610 if (!strcmp((char *)data, device_uri))
1611 return (1);
1612
1613 /*
1614 * Work on copies of the URIs...
1615 */
1616
1617 strlcpy(requested_uri, (char *)data, sizeof(requested_uri));
1618 strlcpy(detected_uri, device_uri, sizeof(detected_uri));
1619
1620 /*
1621 * libusb-discovered URIs can have an "interface" specification and this
1622 * never happens for usblp-discovered URIs, so remove the "interface"
1623 * specification from the URI which we are checking currently. This way a
1624 * queue for a usblp-discovered printer can now be accessed via libusb.
1625 *
1626 * Similarly, strip "?serial=NNN...NNN" as needed.
1627 */
1628
1629 if ((requested_ptr = strstr(requested_uri, "?interface=")) == NULL)
1630 requested_ptr = strstr(requested_uri, "&interface=");
1631 if ((detected_ptr = strstr(detected_uri, "?interface=")) == NULL)
1632 detected_ptr = strstr(detected_uri, "&interface=");
1633
1634 if (!requested_ptr && detected_ptr)
1635 {
1636 /*
1637 * Strip "[?&]interface=nnn" from the detected printer.
1638 */
1639
1640 *detected_ptr = '\0';
1641 }
1642 else if (requested_ptr && !detected_ptr)
1643 {
1644 /*
1645 * Strip "[?&]interface=nnn" from the requested printer.
1646 */
1647
1648 *requested_ptr = '\0';
1649 }
1650
1651 if ((requested_ptr = strstr(requested_uri, "?serial=?")) != NULL)
1652 {
1653 /*
1654 * Strip "?serial=?" from the requested printer. This is a special
1655 * case, as "?serial=?" means no serial number and not the serial
1656 * number '?'. This is not covered by the checks below...
1657 */
1658
1659 *requested_ptr = '\0';
1660 }
1661
1662 if ((requested_ptr = strstr(requested_uri, "?serial=")) == NULL &&
1663 (detected_ptr = strstr(detected_uri, "?serial=")) != NULL)
1664 {
1665 /*
1666 * Strip "?serial=nnn" from the detected printer.
1667 */
1668
1669 *detected_ptr = '\0';
1670 }
1671 else if (requested_ptr && !detected_ptr)
1672 {
1673 /*
1674 * Strip "?serial=nnn" from the requested printer.
1675 */
1676
1677 *requested_ptr = '\0';
1678 }
1679
1680 return (!strcmp(requested_uri, detected_uri));
1681 }
1682
1683
1684 /*
1685 * 'read_thread()' - Thread to read the backchannel data on.
1686 */
1687
read_thread(void * reference)1688 static void *read_thread(void *reference)
1689 {
1690 unsigned char readbuffer[512];
1691 int rbytes;
1692 int readstatus;
1693 struct timeval now,
1694 delay,
1695 end,
1696 timeleft;
1697
1698
1699 (void)reference;
1700
1701 /*
1702 * Read frequency: once every 250 milliseconds.
1703 */
1704
1705 delay.tv_sec = 0;
1706 delay.tv_usec = 250000;
1707
1708 do
1709 {
1710 /*
1711 * Remember when we started so we can throttle the loop after the read
1712 * call...
1713 */
1714
1715 gettimeofday(&now, NULL);
1716
1717 /*
1718 * Calculate what 250 milliSeconds are in absolute time...
1719 */
1720
1721 timeradd(&now, &delay, &end);
1722
1723 rbytes = sizeof(readbuffer);
1724 readstatus = libusb_bulk_transfer(g.printer->handle,
1725 g.printer->read_endp,
1726 readbuffer, rbytes,
1727 &rbytes, 60000);
1728 if (readstatus == LIBUSB_SUCCESS && rbytes > 0)
1729 {
1730 fprintf(stderr, "DEBUG: Read %d bytes of back-channel data...\n",
1731 (int)rbytes);
1732 cupsBackChannelWrite((const char *)readbuffer, (size_t)rbytes, 1.0);
1733 }
1734 else if (readstatus == LIBUSB_ERROR_TIMEOUT)
1735 fputs("DEBUG: Got USB transaction timeout during read.\n", stderr);
1736 else if (readstatus == LIBUSB_ERROR_PIPE)
1737 fputs("DEBUG: Got USB pipe stalled during read.\n", stderr);
1738 else if (readstatus == LIBUSB_ERROR_INTERRUPTED)
1739 fputs("DEBUG: Got USB return aborted during read.\n", stderr);
1740
1741 /*
1742 * Make sure this loop executes no more than once every 250 miliseconds...
1743 */
1744
1745 if ((g.wait_eof || !g.read_thread_stop))
1746 {
1747 gettimeofday(&now, NULL);
1748 if (timercmp(&now, &end, <))
1749 {
1750 timersub(&end, &now, &timeleft);
1751 usleep(1000000 * timeleft.tv_sec + timeleft.tv_usec);
1752 }
1753 }
1754 } while (g.wait_eof || !g.read_thread_stop);
1755
1756 /*
1757 * Let the main thread know that we have completed the read thread...
1758 */
1759
1760 pthread_mutex_lock(&g.read_thread_mutex);
1761 g.read_thread_done = 1;
1762 pthread_cond_signal(&g.read_thread_cond);
1763 pthread_mutex_unlock(&g.read_thread_mutex);
1764
1765 return (NULL);
1766 }
1767
1768
1769 /*
1770 * 'sidechannel_thread()' - Handle side-channel requests.
1771 */
1772
1773 static void*
sidechannel_thread(void * reference)1774 sidechannel_thread(void *reference)
1775 {
1776 cups_sc_command_t command; /* Request command */
1777 cups_sc_status_t status; /* Request/response status */
1778 char data[2048]; /* Request/response data */
1779 int datalen; /* Request/response data size */
1780
1781
1782 (void)reference;
1783
1784 do
1785 {
1786 datalen = sizeof(data);
1787
1788 if (cupsSideChannelRead(&command, &status, data, &datalen, 1.0))
1789 {
1790 if (status == CUPS_SC_STATUS_TIMEOUT)
1791 continue;
1792 else
1793 break;
1794 }
1795
1796 switch (command)
1797 {
1798 case CUPS_SC_CMD_SOFT_RESET: /* Do a soft reset */
1799 fputs("DEBUG: CUPS_SC_CMD_SOFT_RESET received from driver...\n",
1800 stderr);
1801
1802 soft_reset();
1803 cupsSideChannelWrite(command, CUPS_SC_STATUS_OK, NULL, 0, 1.0);
1804 fputs("DEBUG: Returning status CUPS_STATUS_OK with no bytes...\n",
1805 stderr);
1806 break;
1807
1808 case CUPS_SC_CMD_DRAIN_OUTPUT: /* Drain all pending output */
1809 fputs("DEBUG: CUPS_SC_CMD_DRAIN_OUTPUT received from driver...\n",
1810 stderr);
1811
1812 g.drain_output = 1;
1813 break;
1814
1815 case CUPS_SC_CMD_GET_BIDI: /* Is the connection bidirectional? */
1816 fputs("DEBUG: CUPS_SC_CMD_GET_BIDI received from driver...\n",
1817 stderr);
1818
1819 data[0] = (g.printer->protocol >= 2 ? 1 : 0);
1820 cupsSideChannelWrite(command, CUPS_SC_STATUS_OK, data, 1, 1.0);
1821
1822 fprintf(stderr,
1823 "DEBUG: Returned CUPS_SC_STATUS_OK with 1 byte (%02X)...\n",
1824 data[0]);
1825 break;
1826
1827 case CUPS_SC_CMD_GET_DEVICE_ID: /* Return IEEE-1284 device ID */
1828 fputs("DEBUG: CUPS_SC_CMD_GET_DEVICE_ID received from driver...\n",
1829 stderr);
1830
1831 datalen = sizeof(data);
1832 if (get_device_id(g.printer, data, sizeof(data)))
1833 {
1834 status = CUPS_SC_STATUS_IO_ERROR;
1835 datalen = 0;
1836 }
1837 else
1838 {
1839 status = CUPS_SC_STATUS_OK;
1840 datalen = strlen(data);
1841 }
1842 cupsSideChannelWrite(command, CUPS_SC_STATUS_OK, data, datalen, 1.0);
1843
1844 if (datalen < sizeof(data))
1845 data[datalen] = '\0';
1846 else
1847 data[sizeof(data) - 1] = '\0';
1848
1849 fprintf(stderr,
1850 "DEBUG: Returning CUPS_SC_STATUS_OK with %d bytes (%s)...\n",
1851 datalen, data);
1852 break;
1853
1854 case CUPS_SC_CMD_GET_STATE: /* Return device state */
1855 fputs("DEBUG: CUPS_SC_CMD_GET_STATE received from driver...\n",
1856 stderr);
1857
1858 data[0] = CUPS_SC_STATE_ONLINE;
1859 cupsSideChannelWrite(command, CUPS_SC_STATUS_OK, data, 1, 1.0);
1860
1861 fprintf(stderr,
1862 "DEBUG: Returned CUPS_SC_STATUS_OK with 1 byte (%02X)...\n",
1863 data[0]);
1864 break;
1865
1866 case CUPS_SC_CMD_GET_CONNECTED: /* Return whether device is
1867 connected */
1868 fputs("DEBUG: CUPS_SC_CMD_GET_CONNECTED received from driver...\n",
1869 stderr);
1870
1871 data[0] = (g.printer->handle ? 1 : 0);
1872 cupsSideChannelWrite(command, CUPS_SC_STATUS_OK, data, 1, 1.0);
1873
1874 fprintf(stderr,
1875 "DEBUG: Returned CUPS_SC_STATUS_OK with 1 byte (%02X)...\n",
1876 data[0]);
1877 break;
1878
1879 default:
1880 fprintf(stderr, "DEBUG: Unknown side-channel command (%d) received "
1881 "from driver...\n", command);
1882
1883 cupsSideChannelWrite(command, CUPS_SC_STATUS_NOT_IMPLEMENTED,
1884 NULL, 0, 1.0);
1885
1886 fputs("DEBUG: Returned CUPS_SC_STATUS_NOT_IMPLEMENTED with no bytes...\n",
1887 stderr);
1888 break;
1889 }
1890 }
1891 while (!g.sidechannel_thread_stop);
1892
1893 pthread_mutex_lock(&g.sidechannel_thread_mutex);
1894 g.sidechannel_thread_done = 1;
1895 pthread_cond_signal(&g.sidechannel_thread_cond);
1896 pthread_mutex_unlock(&g.sidechannel_thread_mutex);
1897
1898 return (NULL);
1899 }
1900
1901
1902 /*
1903 * 'soft_reset()' - Send a soft reset to the device.
1904 */
1905
1906 static void
soft_reset(void)1907 soft_reset(void)
1908 {
1909 fd_set input_set; /* Input set for select() */
1910 struct timeval tv; /* Time value */
1911 char buffer[2048]; /* Buffer */
1912 struct timespec cond_timeout; /* pthread condition timeout */
1913
1914
1915 /*
1916 * Send an abort once a second until the I/O lock is released by the main
1917 * thread...
1918 */
1919
1920 pthread_mutex_lock(&g.readwrite_lock_mutex);
1921 while (g.readwrite_lock)
1922 {
1923 gettimeofday(&tv, NULL);
1924 cond_timeout.tv_sec = tv.tv_sec + 1;
1925 cond_timeout.tv_nsec = tv.tv_usec * 1000;
1926
1927 while (g.readwrite_lock)
1928 {
1929 if (pthread_cond_timedwait(&g.readwrite_lock_cond,
1930 &g.readwrite_lock_mutex,
1931 &cond_timeout) != 0)
1932 break;
1933 }
1934 }
1935
1936 g.readwrite_lock = 1;
1937 pthread_mutex_unlock(&g.readwrite_lock_mutex);
1938
1939 /*
1940 * Flush bytes waiting on print_fd...
1941 */
1942
1943 g.print_bytes = 0;
1944
1945 FD_ZERO(&input_set);
1946 FD_SET(g.print_fd, &input_set);
1947
1948 tv.tv_sec = 0;
1949 tv.tv_usec = 0;
1950
1951 while (select(g.print_fd+1, &input_set, NULL, NULL, &tv) > 0)
1952 if (read(g.print_fd, buffer, sizeof(buffer)) <= 0)
1953 break;
1954
1955 /*
1956 * Send the reset...
1957 */
1958
1959 soft_reset_printer(g.printer);
1960
1961 /*
1962 * Release the I/O lock...
1963 */
1964
1965 pthread_mutex_lock(&g.readwrite_lock_mutex);
1966 g.readwrite_lock = 0;
1967 pthread_cond_signal(&g.readwrite_lock_cond);
1968 pthread_mutex_unlock(&g.readwrite_lock_mutex);
1969 }
1970
1971
1972 /*
1973 * 'soft_reset_printer()' - Do the soft reset request specific to printers
1974 *
1975 * This soft reset is specific to the printer device class and is much less
1976 * invasive than the general USB reset libusb_reset_device(). Especially it
1977 * does never happen that the USB addressing and configuration changes. What
1978 * is actually done is that all buffers get flushed and the bulk IN and OUT
1979 * pipes get reset to their default states. This clears all stall conditions.
1980 * See http://cholla.mmto.org/computers/linux/usb/usbprint11.pdf
1981 */
1982
1983 static int /* O - 0 on success, < 0 on error */
soft_reset_printer(usb_printer_t * printer)1984 soft_reset_printer(
1985 usb_printer_t *printer) /* I - Printer */
1986 {
1987 struct libusb_config_descriptor *confptr = NULL;
1988 /* Pointer to current configuration */
1989 int interface, /* Interface to reset */
1990 errcode; /* Error code */
1991
1992
1993 if (libusb_get_config_descriptor(printer->device, printer->conf,
1994 &confptr) < 0)
1995 interface = printer->iface;
1996 else
1997 interface = confptr->interface[printer->iface].
1998 altsetting[printer->altset].bInterfaceNumber;
1999
2000 libusb_free_config_descriptor(confptr);
2001
2002 if ((errcode = libusb_control_transfer(printer->handle,
2003 LIBUSB_REQUEST_TYPE_CLASS |
2004 LIBUSB_ENDPOINT_OUT |
2005 LIBUSB_RECIPIENT_OTHER,
2006 2, 0, interface, NULL, 0, 5000)) < 0)
2007 errcode = libusb_control_transfer(printer->handle,
2008 LIBUSB_REQUEST_TYPE_CLASS |
2009 LIBUSB_ENDPOINT_OUT |
2010 LIBUSB_RECIPIENT_INTERFACE,
2011 2, 0, interface, NULL, 0, 5000);
2012
2013 return (errcode);
2014 }
2015