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