1/* 2 * "$Id: usb-libusb.c 11645 2014-02-27 16:35:53Z msweet $" 3 * 4 * LIBUSB interface code for CUPS. 5 * 6 * Copyright 2007-2014 by Apple Inc. 7 * 8 * These coded instructions, statements, and computer programs are the 9 * property of Apple Inc. and are protected by Federal copyright 10 * law. Distribution and use rights are outlined in the file "LICENSE.txt" 11 * which should have been included with this file. If this file is 12 * file is missing or damaged, see the license at "http://www.cups.org/". 13 */ 14 15/* 16 * Include necessary headers... 17 */ 18 19#include <libusb.h> 20#include <cups/cups-private.h> 21#include <cups/dir.h> 22#include <pthread.h> 23#include <sys/select.h> 24#include <sys/types.h> 25#include <sys/stat.h> 26#include <sys/time.h> 27#include <unistd.h> 28 29 30/* 31 * WAIT_EOF_DELAY is number of seconds we'll wait for responses from 32 * the printer after we've finished sending all the data 33 */ 34 35#define WAIT_EOF 0 36#define WAIT_EOF_DELAY 7 37#define WAIT_SIDE_DELAY 3 38#define DEFAULT_TIMEOUT 5000L 39 40 41/* 42 * Local types... 43 */ 44 45typedef struct usb_printer_s /**** USB Printer Data ****/ 46{ 47 struct libusb_device *device; /* Device info */ 48 int conf, /* Configuration */ 49 origconf, /* Original configuration */ 50 iface, /* Interface */ 51 altset, /* Alternate setting */ 52 write_endp, /* Write endpoint */ 53 read_endp, /* Read endpoint */ 54 protocol, /* Protocol: 1 = Uni-di, 2 = Bi-di. */ 55 usblp_attached, /* "usblp" kernel module attached? */ 56 reset_after_job;/* Set to 1 by print_device() */ 57 unsigned quirks; /* Quirks flags */ 58 struct libusb_device_handle *handle; /* Open handle to device */ 59} usb_printer_t; 60 61typedef int (*usb_cb_t)(usb_printer_t *, const char *, const char *, 62 const void *); 63 64typedef struct usb_globals_s /* Global USB printer information */ 65{ 66 usb_printer_t *printer; /* Printer */ 67 68 pthread_mutex_t read_thread_mutex; 69 pthread_cond_t read_thread_cond; 70 int read_thread_stop; 71 int read_thread_done; 72 73 pthread_mutex_t readwrite_lock_mutex; 74 pthread_cond_t readwrite_lock_cond; 75 int readwrite_lock; 76 77 int print_fd; /* File descriptor to print */ 78 ssize_t print_bytes; /* Print bytes read */ 79 80 int wait_eof; 81 int drain_output; /* Drain all pending output */ 82 int bidi_flag; /* 0=unidirectional, 1=bidirectional */ 83 84 pthread_mutex_t sidechannel_thread_mutex; 85 pthread_cond_t sidechannel_thread_cond; 86 int sidechannel_thread_stop; 87 int sidechannel_thread_done; 88} usb_globals_t; 89 90/* 91 * Quirks: various printer quirks are handled by this structure and its flags. 92 * 93 * The quirks table used to be compiled into the backend but is now loaded from 94 * one or more files in the /usr/share/cups/usb directory. 95 */ 96 97#define USB_QUIRK_BLACKLIST 0x0001 /* Does not conform to the spec */ 98#define USB_QUIRK_NO_REATTACH 0x0002 /* After printing we cannot re-attach 99 the usblp kernel module */ 100#define USB_QUIRK_SOFT_RESET 0x0004 /* After printing do a soft reset 101 for clean-up */ 102#define USB_QUIRK_UNIDIR 0x0008 /* Requires unidirectional mode */ 103#define USB_QUIRK_USB_INIT 0x0010 /* Needs vendor USB init string */ 104#define USB_QUIRK_VENDOR_CLASS 0x0020 /* Descriptor uses vendor-specific 105 Class or SubClass */ 106#define USB_QUIRK_WHITELIST 0x0000 /* no quirks */ 107 108 109typedef 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 123cups_array_t *all_quirks; /* Array of printer quirks */ 124usb_globals_t g = { 0 }; /* Globals */ 125libusb_device **all_list; /* List of connected USB devices */ 126 127 128/* 129 * Local functions... 130 */ 131 132static int close_device(usb_printer_t *printer); 133static int compare_quirks(usb_quirk_t *a, usb_quirk_t *b); 134static usb_printer_t *find_device(usb_cb_t cb, const void *data); 135static unsigned find_quirks(int vendor_id, int product_id); 136static int get_device_id(usb_printer_t *printer, char *buffer, 137 size_t bufsize); 138static int list_cb(usb_printer_t *printer, const char *device_uri, 139 const char *device_id, const void *data); 140static void load_quirks(void); 141static char *make_device_uri(usb_printer_t *printer, 142 const char *device_id, 143 char *uri, size_t uri_size); 144static int open_device(usb_printer_t *printer, int verbose); 145static int print_cb(usb_printer_t *printer, const char *device_uri, 146 const char *device_id, const void *data); 147static void *read_thread(void *reference); 148static void *sidechannel_thread(void *reference); 149static void soft_reset(void); 150static int soft_reset_printer(usb_printer_t *printer); 151 152 153/* 154 * 'list_devices()' - List the available printers. 155 */ 156 157void 158list_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 171int /* O - Exit status */ 172print_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 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 661static int /* I - 0 on success, -1 on failure */ 662close_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 773static int /* O - Result of comparison */ 774compare_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 790static usb_printer_t * /* O - Found printer */ 791find_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, "DEBUG: Unable to initialize USB access via libusb, " 830 "libusb error %i\n", (int)err); 831 return (NULL); 832 } 833 834 numdevs = libusb_get_device_list(NULL, &list); 835 fprintf(stderr, "DEBUG: libusb_get_device_list=%d\n", (int)numdevs); 836 837 /* 838 * Then loop through the devices it found... 839 */ 840 841 if (numdevs > 0) 842 for (i = 0; i < numdevs; i++) 843 { 844 device = list[i]; 845 846 /* 847 * Ignore devices with no configuration data and anything that is not 848 * a printer... 849 */ 850 851 if (libusb_get_device_descriptor(device, &devdesc) < 0) 852 continue; 853 854 if (!devdesc.bNumConfigurations || !devdesc.idVendor || 855 !devdesc.idProduct) 856 continue; 857 858 printer.quirks = find_quirks(devdesc.idVendor, devdesc.idProduct); 859 860 /* 861 * Ignore blacklisted printers... 862 */ 863 864 if (printer.quirks & USB_QUIRK_BLACKLIST) 865 continue; 866 867 for (conf = 0; conf < devdesc.bNumConfigurations; conf ++) 868 { 869 if (libusb_get_config_descriptor(device, conf, &confptr) < 0) 870 continue; 871 for (iface = 0, ifaceptr = confptr->interface; 872 iface < confptr->bNumInterfaces; 873 iface ++, ifaceptr ++) 874 { 875 /* 876 * Some printers offer multiple interfaces... 877 */ 878 879 protocol = 0; 880 881 for (altset = 0, altptr = ifaceptr->altsetting; 882 altset < ifaceptr->num_altsetting; 883 altset ++, altptr ++) 884 { 885 /* 886 * Currently we only support unidirectional and bidirectional 887 * printers. Future versions of this code will support the 888 * 1284.4 (packet mode) protocol as well. 889 */ 890 891 if (((altptr->bInterfaceClass != LIBUSB_CLASS_PRINTER || 892 altptr->bInterfaceSubClass != 1) && 893 ((printer.quirks & USB_QUIRK_VENDOR_CLASS) == 0)) || 894 (altptr->bInterfaceProtocol != 1 && /* Unidirectional */ 895 altptr->bInterfaceProtocol != 2) || /* Bidirectional */ 896 altptr->bInterfaceProtocol < protocol) 897 continue; 898 899 if (printer.quirks & USB_QUIRK_VENDOR_CLASS) 900 fprintf(stderr, "DEBUG: Printer does not report class 7 and/or " 901 "subclass 1 but works as a printer anyway\n"); 902 903 read_endp = 0xff; 904 write_endp = 0xff; 905 906 for (endp = 0, endpptr = altptr->endpoint; 907 endp < altptr->bNumEndpoints; 908 endp ++, endpptr ++) 909 if ((endpptr->bmAttributes & LIBUSB_TRANSFER_TYPE_MASK) == 910 LIBUSB_TRANSFER_TYPE_BULK) 911 { 912 if (endpptr->bEndpointAddress & LIBUSB_ENDPOINT_DIR_MASK) 913 read_endp = endp; 914 else 915 write_endp = endp; 916 } 917 918 if (write_endp >= 0) 919 { 920 /* 921 * Save the best match so far... 922 */ 923 924 protocol = altptr->bInterfaceProtocol; 925 printer.altset = altset; 926 printer.write_endp = write_endp; 927 if (protocol > 1) 928 printer.read_endp = read_endp; 929 else 930 printer.read_endp = -1; 931 } 932 } 933 934 if (protocol > 0) 935 { 936 printer.device = device; 937 printer.conf = conf; 938 printer.iface = iface; 939 printer.protocol = protocol; 940 printer.handle = NULL; 941 942 if (!open_device(&printer, data != NULL)) 943 { 944 get_device_id(&printer, device_id, sizeof(device_id)); 945 make_device_uri(&printer, device_id, device_uri, 946 sizeof(device_uri)); 947 948 fprintf(stderr, "DEBUG2: Printer found with device ID: %s " 949 "Device URI: %s\n", 950 device_id, device_uri); 951 952 if ((*cb)(&printer, device_uri, device_id, data)) 953 { 954 fprintf(stderr, "DEBUG: Device protocol: %d\n", 955 printer.protocol); 956 if (printer.quirks & USB_QUIRK_UNIDIR) 957 { 958 printer.read_endp = -1; 959 fprintf(stderr, "DEBUG: Printer reports bi-di support " 960 "but in reality works only uni-directionally\n"); 961 } 962 if (printer.read_endp != -1) 963 { 964 printer.read_endp = confptr->interface[printer.iface]. 965 altsetting[printer.altset]. 966 endpoint[printer.read_endp]. 967 bEndpointAddress; 968 } 969 else 970 fprintf(stderr, "DEBUG: Uni-directional USB communication " 971 "only!\n"); 972 printer.write_endp = confptr->interface[printer.iface]. 973 altsetting[printer.altset]. 974 endpoint[printer.write_endp]. 975 bEndpointAddress; 976 if (printer.quirks & USB_QUIRK_NO_REATTACH) 977 { 978 printer.usblp_attached = 0; 979 fprintf(stderr, "DEBUG: Printer does not like usblp " 980 "kernel module to be re-attached after job\n"); 981 } 982 libusb_free_config_descriptor(confptr); 983 return (&printer); 984 } 985 986 close_device(&printer); 987 } 988 } 989 } 990 libusb_free_config_descriptor(confptr); 991 } 992 } 993 994 /* 995 * If we get this far without returning, then we haven't found a printer 996 * to print to... 997 */ 998 999 /* 1000 * Clean up .... 1001 */ 1002 1003 if (numdevs >= 0) 1004 libusb_free_device_list(list, 1); 1005 libusb_exit(NULL); 1006 1007 return (NULL); 1008} 1009 1010 1011/* 1012 * 'find_quirks()' - Find the quirks for the given printer, if any. 1013 * 1014 * First looks for an exact match, then looks for the vendor ID wildcard match. 1015 */ 1016 1017static unsigned /* O - Quirks flags */ 1018find_quirks(int vendor_id, /* I - Vendor ID */ 1019 int product_id) /* I - Product ID */ 1020{ 1021 usb_quirk_t key, /* Search key */ 1022 *match; /* Matching quirk entry */ 1023 1024 1025 key.vendor_id = vendor_id; 1026 key.product_id = product_id; 1027 1028 if ((match = cupsArrayFind(all_quirks, &key)) != NULL) 1029 return (match->quirks); 1030 1031 key.product_id = 0; 1032 1033 if ((match = cupsArrayFind(all_quirks, &key)) != NULL) 1034 return (match->quirks); 1035 1036 return (USB_QUIRK_WHITELIST); 1037} 1038 1039 1040/* 1041 * 'get_device_id()' - Get the IEEE-1284 device ID for the printer. 1042 */ 1043 1044static int /* O - 0 on success, -1 on error */ 1045get_device_id(usb_printer_t *printer, /* I - Printer */ 1046 char *buffer, /* I - String buffer */ 1047 size_t bufsize) /* I - Number of bytes in buffer */ 1048{ 1049 int length; /* Length of device ID */ 1050 1051 1052 if (libusb_control_transfer(printer->handle, 1053 LIBUSB_REQUEST_TYPE_CLASS | LIBUSB_ENDPOINT_IN | 1054 LIBUSB_RECIPIENT_INTERFACE, 1055 0, printer->conf, 1056 (printer->iface << 8) | printer->altset, 1057 (unsigned char *)buffer, bufsize, 5000) < 0) 1058 { 1059 *buffer = '\0'; 1060 return (-1); 1061 } 1062 1063 /* 1064 * Extract the length of the device ID string from the first two 1065 * bytes. The 1284 spec says the length is stored MSB first... 1066 */ 1067 1068 length = (int)((((unsigned)buffer[0] & 255) << 8) | ((unsigned)buffer[1] & 255)); 1069 1070 /* 1071 * Check to see if the length is larger than our buffer or less than 14 bytes 1072 * (the minimum valid device ID is "MFG:x;MDL:y;" with 2 bytes for the length). 1073 * 1074 * If the length is out-of-range, assume that the vendor incorrectly 1075 * implemented the 1284 spec and re-read the length as LSB first,.. 1076 */ 1077 1078 if (length > bufsize || length < 14) 1079 length = (int)((((unsigned)buffer[1] & 255) << 8) | ((unsigned)buffer[0] & 255)); 1080 1081 if (length > bufsize) 1082 length = bufsize; 1083 1084 if (length < 14) 1085 { 1086 /* 1087 * Invalid device ID, clear it! 1088 */ 1089 1090 *buffer = '\0'; 1091 return (-1); 1092 } 1093 1094 length -= 2; 1095 1096 /* 1097 * Copy the device ID text to the beginning of the buffer and 1098 * nul-terminate. 1099 */ 1100 1101 memmove(buffer, buffer + 2, (size_t)length); 1102 buffer[length] = '\0'; 1103 1104 return (0); 1105} 1106 1107 1108/* 1109 * 'list_cb()' - List USB printers for discovery. 1110 */ 1111 1112static int /* O - 0 to continue, 1 to stop */ 1113list_cb(usb_printer_t *printer, /* I - Printer */ 1114 const char *device_uri, /* I - Device URI */ 1115 const char *device_id, /* I - IEEE-1284 device ID */ 1116 const void *data) /* I - User data (not used) */ 1117{ 1118 char make_model[1024]; /* Make and model */ 1119 1120 1121 /* 1122 * Get the device URI and make/model strings... 1123 */ 1124 1125 if (backendGetMakeModel(device_id, make_model, sizeof(make_model))) 1126 strlcpy(make_model, "Unknown", sizeof(make_model)); 1127 1128 /* 1129 * Report the printer... 1130 */ 1131 1132 cupsBackendReport("direct", device_uri, make_model, make_model, device_id, 1133 NULL); 1134 1135 /* 1136 * Keep going... 1137 */ 1138 1139 return (0); 1140} 1141 1142 1143/* 1144 * 'load_quirks()' - Load all quirks files in the /usr/share/cups/usb directory. 1145 */ 1146 1147static void 1148load_quirks(void) 1149{ 1150 const char *datadir; /* CUPS_DATADIR environment variable */ 1151 char filename[1024], /* Filename */ 1152 line[1024]; /* Line from file */ 1153 cups_dir_t *dir; /* Directory */ 1154 cups_dentry_t *dent; /* Directory entry */ 1155 cups_file_t *fp; /* Quirks file */ 1156 usb_quirk_t *quirk; /* New quirk */ 1157 1158 1159 all_quirks = cupsArrayNew((cups_array_func_t)compare_quirks, NULL); 1160 1161 if ((datadir = getenv("CUPS_DATADIR")) == NULL) 1162 datadir = CUPS_DATADIR; 1163 1164 snprintf(filename, sizeof(filename), "%s/usb", datadir); 1165 if ((dir = cupsDirOpen(filename)) == NULL) 1166 { 1167 perror(filename); 1168 return; 1169 } 1170 1171 fprintf(stderr, "DEBUG: Loading USB quirks from \"%s\".\n", filename); 1172 1173 while ((dent = cupsDirRead(dir)) != NULL) 1174 { 1175 if (!S_ISREG(dent->fileinfo.st_mode)) 1176 continue; 1177 1178 snprintf(filename, sizeof(filename), "%s/usb/%s", datadir, dent->filename); 1179 if ((fp = cupsFileOpen(filename, "r")) == NULL) 1180 { 1181 perror(filename); 1182 continue; 1183 } 1184 1185 while (cupsFileGets(fp, line, sizeof(line))) 1186 { 1187 /* 1188 * Skip blank and comment lines... 1189 */ 1190 1191 if (line[0] == '#' || !line[0]) 1192 continue; 1193 1194 /* 1195 * Add a quirk... 1196 */ 1197 1198 if ((quirk = calloc(1, sizeof(usb_quirk_t))) == NULL) 1199 { 1200 perror("DEBUG: Unable to allocate memory for quirk"); 1201 break; 1202 } 1203 1204 if (sscanf(line, "%x%x", &quirk->vendor_id, &quirk->product_id) < 1) 1205 { 1206 fprintf(stderr, "DEBUG: Bad line: %s\n", line); 1207 free(quirk); 1208 continue; 1209 } 1210 1211 if (strstr(line, " blacklist")) 1212 quirk->quirks |= USB_QUIRK_BLACKLIST; 1213 1214 if (strstr(line, " no-reattach")) 1215 quirk->quirks |= USB_QUIRK_NO_REATTACH; 1216 1217 if (strstr(line, " soft-reset")) 1218 quirk->quirks |= USB_QUIRK_SOFT_RESET; 1219 1220 if (strstr(line, " unidir")) 1221 quirk->quirks |= USB_QUIRK_UNIDIR; 1222 1223 if (strstr(line, " usb-init")) 1224 quirk->quirks |= USB_QUIRK_USB_INIT; 1225 1226 if (strstr(line, " vendor-class")) 1227 quirk->quirks |= USB_QUIRK_VENDOR_CLASS; 1228 1229 cupsArrayAdd(all_quirks, quirk); 1230 } 1231 1232 cupsFileClose(fp); 1233 } 1234 1235 fprintf(stderr, "DEBUG: Loaded %d quirks.\n", cupsArrayCount(all_quirks)); 1236 1237 cupsDirClose(dir); 1238} 1239 1240 1241/* 1242 * 'make_device_uri()' - Create a device URI for a USB printer. 1243 */ 1244 1245static char * /* O - Device URI */ 1246make_device_uri( 1247 usb_printer_t *printer, /* I - Printer */ 1248 const char *device_id, /* I - IEEE-1284 device ID */ 1249 char *uri, /* I - Device URI buffer */ 1250 size_t uri_size) /* I - Size of device URI buffer */ 1251{ 1252 struct libusb_device_descriptor devdesc; 1253 /* Current device descriptor */ 1254 char options[1024]; /* Device URI options */ 1255 int num_values; /* Number of 1284 parameters */ 1256 cups_option_t *values; /* 1284 parameters */ 1257 const char *mfg, /* Manufacturer */ 1258 *mdl, /* Model */ 1259 *des = NULL, /* Description */ 1260 *sern; /* Serial number */ 1261 size_t mfglen; /* Length of manufacturer string */ 1262 char tempmfg[256], /* Temporary manufacturer string */ 1263 tempsern[256], /* Temporary serial number string */ 1264 *tempptr; /* Pointer into temp string */ 1265 1266 1267 /* 1268 * Get the make, model, and serial numbers... 1269 */ 1270 1271 num_values = _cupsGet1284Values(device_id, &values); 1272 1273 if ((sern = cupsGetOption("SERIALNUMBER", num_values, values)) == NULL) 1274 if ((sern = cupsGetOption("SERN", num_values, values)) == NULL) 1275 if ((sern = cupsGetOption("SN", num_values, values)) == NULL && 1276 ((libusb_get_device_descriptor(printer->device, &devdesc) >= 0) && 1277 devdesc.iSerialNumber)) 1278 { 1279 /* 1280 * Try getting the serial number from the device itself... 1281 */ 1282 1283 int length = 1284 libusb_get_string_descriptor_ascii(printer->handle, 1285 devdesc.iSerialNumber, 1286 (unsigned char *)tempsern, 1287 sizeof(tempsern) - 1); 1288 if (length > 0) 1289 { 1290 tempsern[length] = '\0'; 1291 sern = tempsern; 1292 } 1293 } 1294 1295 if ((mfg = cupsGetOption("MANUFACTURER", num_values, values)) == NULL) 1296 mfg = cupsGetOption("MFG", num_values, values); 1297 1298 if ((mdl = cupsGetOption("MODEL", num_values, values)) == NULL) 1299 mdl = cupsGetOption("MDL", num_values, values); 1300 1301 /* 1302 * To maintain compatibility with the original character device backend on 1303 * Linux and *BSD, map manufacturer names... 1304 */ 1305 1306 if (mfg) 1307 { 1308 if (!_cups_strcasecmp(mfg, "Hewlett-Packard")) 1309 mfg = "HP"; 1310 else if (!_cups_strcasecmp(mfg, "Lexmark International")) 1311 mfg = "Lexmark"; 1312 } 1313 else 1314 { 1315 /* 1316 * No manufacturer? Use the model string or description... 1317 */ 1318 1319 if (mdl) 1320 _ppdNormalizeMakeAndModel(mdl, tempmfg, sizeof(tempmfg)); 1321 else if ((des = cupsGetOption("DESCRIPTION", num_values, values)) != NULL || 1322 (des = cupsGetOption("DES", num_values, values)) != NULL) 1323 _ppdNormalizeMakeAndModel(des, tempmfg, sizeof(tempmfg)); 1324 else 1325 strlcpy(tempmfg, "Unknown", sizeof(tempmfg)); 1326 1327 if ((tempptr = strchr(tempmfg, ' ')) != NULL) 1328 *tempptr = '\0'; 1329 1330 mfg = tempmfg; 1331 } 1332 1333 if (!mdl) 1334 { 1335 /* 1336 * No model? Use description... 1337 */ 1338 if (des) 1339 mdl = des; /* We remove the manufacturer name below */ 1340 else if (!strncasecmp(mfg, "Unknown", 7)) 1341 mdl = "Printer"; 1342 else 1343 mdl = "Unknown Model"; 1344 } 1345 1346 mfglen = strlen(mfg); 1347 1348 if (!strncasecmp(mdl, mfg, mfglen) && _cups_isspace(mdl[mfglen])) 1349 { 1350 mdl += mfglen + 1; 1351 1352 while (_cups_isspace(*mdl)) 1353 mdl ++; 1354 } 1355 1356 /* 1357 * Generate the device URI from the manufacturer, model, serial number, 1358 * and interface number... 1359 */ 1360 1361 if (sern) 1362 { 1363 if (printer->iface > 0) 1364 snprintf(options, sizeof(options), "?serial=%s&interface=%d", sern, 1365 printer->iface); 1366 else 1367 snprintf(options, sizeof(options), "?serial=%s", sern); 1368 } 1369 else if (printer->iface > 0) 1370 snprintf(options, sizeof(options), "?interface=%d", printer->iface); 1371 else 1372 options[0] = '\0'; 1373 1374 httpAssembleURIf(HTTP_URI_CODING_ALL, uri, uri_size, "usb", NULL, mfg, 0, 1375 "/%s%s", mdl, options); 1376 1377 cupsFreeOptions(num_values, values); 1378 1379 return (uri); 1380} 1381 1382 1383/* 1384 * 'open_device()' - Open a connection to the USB printer. 1385 */ 1386 1387static int /* O - 0 on success, -1 on error */ 1388open_device(usb_printer_t *printer, /* I - Printer */ 1389 int verbose) /* I - Update connecting-to-device state? */ 1390{ 1391 struct libusb_device_descriptor devdesc; 1392 /* Current device descriptor */ 1393 struct libusb_config_descriptor *confptr = NULL; 1394 /* Pointer to current configuration */ 1395 int number1 = -1, /* Configuration/interface/altset */ 1396 number2 = -1, /* numbers */ 1397 errcode = 0; 1398 char current; /* Current configuration */ 1399 1400 1401 /* 1402 * Return immediately if we are already connected... 1403 */ 1404 1405 if (printer->handle) 1406 return (0); 1407 1408 /* 1409 * Try opening the printer... 1410 */ 1411 1412 if ((errcode = libusb_open(printer->device, &printer->handle)) < 0) 1413 { 1414 fprintf(stderr, "DEBUG: Failed to open device, code: %d\n", 1415 errcode); 1416 return (-1); 1417 } 1418 1419 printer->usblp_attached = 0; 1420 printer->reset_after_job = 0; 1421 1422 if (verbose) 1423 fputs("STATE: +connecting-to-device\n", stderr); 1424 1425 if ((errcode = libusb_get_device_descriptor(printer->device, &devdesc)) < 0) 1426 { 1427 fprintf(stderr, "DEBUG: Failed to get device descriptor, code: %d\n", 1428 errcode); 1429 goto error; 1430 } 1431 1432 /* 1433 * Get the "usblp" kernel module out of the way. This backend only 1434 * works without the module attached. 1435 */ 1436 1437 errcode = libusb_kernel_driver_active(printer->handle, printer->iface); 1438 if (errcode == 0) 1439 printer->usblp_attached = 0; 1440 else if (errcode == 1) 1441 { 1442 printer->usblp_attached = 1; 1443 if ((errcode = 1444 libusb_detach_kernel_driver(printer->handle, printer->iface)) < 0) 1445 { 1446 fprintf(stderr, "DEBUG: Failed to detach \"usblp\" module from %04x:%04x\n", 1447 devdesc.idVendor, devdesc.idProduct); 1448 goto error; 1449 } 1450 } 1451 else 1452 { 1453 printer->usblp_attached = 0; 1454 fprintf(stderr, "DEBUG: Failed to check whether %04x:%04x has the \"usblp\" kernel module attached\n", 1455 devdesc.idVendor, devdesc.idProduct); 1456 goto error; 1457 } 1458 1459 /* 1460 * Set the desired configuration, but only if it needs changing. Some 1461 * printers (e.g., Samsung) don't like libusb_set_configuration. It will 1462 * succeed, but the following print job is sometimes silently lost by the 1463 * printer. 1464 */ 1465 1466 if (libusb_control_transfer(printer->handle, 1467 LIBUSB_REQUEST_TYPE_STANDARD | LIBUSB_ENDPOINT_IN | 1468 LIBUSB_RECIPIENT_DEVICE, 1469 8, /* GET_CONFIGURATION */ 1470 0, 0, (unsigned char *)¤t, 1, 5000) < 0) 1471 current = 0; /* Assume not configured */ 1472 1473 printer->origconf = current; 1474 1475 if ((errcode = 1476 libusb_get_config_descriptor (printer->device, printer->conf, &confptr)) 1477 < 0) 1478 { 1479 fprintf(stderr, "DEBUG: Failed to get config descriptor for %04x:%04x\n", 1480 devdesc.idVendor, devdesc.idProduct); 1481 goto error; 1482 } 1483 number1 = confptr->bConfigurationValue; 1484 1485 if (number1 != current) 1486 { 1487 fprintf(stderr, "DEBUG: Switching USB device configuration: %d -> %d\n", 1488 current, number1); 1489 if ((errcode = libusb_set_configuration(printer->handle, number1)) < 0) 1490 { 1491 /* 1492 * If the set fails, chances are that the printer only supports a 1493 * single configuration. Technically these printers don't conform to 1494 * the USB printer specification, but otherwise they'll work... 1495 */ 1496 1497 if (errcode != LIBUSB_ERROR_BUSY) 1498 fprintf(stderr, "DEBUG: Failed to set configuration %d for %04x:%04x\n", 1499 number1, devdesc.idVendor, devdesc.idProduct); 1500 } 1501 } 1502 1503 /* 1504 * Claim interfaces as needed... 1505 */ 1506 1507 number1 = confptr->interface[printer->iface]. 1508 altsetting[printer->altset].bInterfaceNumber; 1509 1510 while ((errcode = libusb_claim_interface(printer->handle, number1)) < 0) 1511 { 1512 if (errcode != LIBUSB_ERROR_BUSY) 1513 { 1514 fprintf(stderr, 1515 "DEBUG: Failed to claim interface %d for %04x:%04x: %s\n", 1516 number1, devdesc.idVendor, devdesc.idProduct, strerror(errno)); 1517 1518 goto error; 1519 } 1520 } 1521 1522 /* 1523 * Set alternate setting, but only if there is more than one option. Some 1524 * printers (e.g., Samsung) don't like usb_set_altinterface. 1525 */ 1526 1527 if (confptr->interface[printer->iface].num_altsetting > 1) 1528 { 1529 number1 = confptr->interface[printer->iface]. 1530 altsetting[printer->altset].bInterfaceNumber; 1531 number2 = confptr->interface[printer->iface]. 1532 altsetting[printer->altset].bAlternateSetting; 1533 1534 while ((errcode = 1535 libusb_set_interface_alt_setting(printer->handle, number1, number2)) 1536 < 0) 1537 { 1538 if (errcode != LIBUSB_ERROR_BUSY) 1539 { 1540 fprintf(stderr, 1541 "DEBUG: Failed to set alternate interface %d for %04x:%04x: " 1542 "%s\n", 1543 number2, devdesc.idVendor, devdesc.idProduct, strerror(errno)); 1544 1545 goto error; 1546 } 1547 } 1548 } 1549 1550 libusb_free_config_descriptor(confptr); 1551 1552 if (verbose) 1553 fputs("STATE: -connecting-to-device\n", stderr); 1554 1555 return (0); 1556 1557 /* 1558 * If we get here, there was a hard error... 1559 */ 1560 1561 error: 1562 1563 if (verbose) 1564 fputs("STATE: -connecting-to-device\n", stderr); 1565 1566 libusb_close(printer->handle); 1567 printer->handle = NULL; 1568 1569 return (-1); 1570} 1571 1572 1573/* 1574 * 'print_cb()' - Find a USB printer for printing. 1575 */ 1576 1577static int /* O - 0 to continue, 1 to stop (found) */ 1578print_cb(usb_printer_t *printer, /* I - Printer */ 1579 const char *device_uri, /* I - Device URI */ 1580 const char *device_id, /* I - IEEE-1284 device ID */ 1581 const void *data) /* I - User data (make, model, S/N) */ 1582{ 1583 char requested_uri[1024], /* Requested URI */ 1584 *requested_ptr, /* Pointer into requested URI */ 1585 detected_uri[1024], /* Detected URI */ 1586 *detected_ptr; /* Pointer into detected URI */ 1587 1588 1589 /* 1590 * If we have an exact match, stop now... 1591 */ 1592 1593 if (!strcmp((char *)data, device_uri)) 1594 return (1); 1595 1596 /* 1597 * Work on copies of the URIs... 1598 */ 1599 1600 strlcpy(requested_uri, (char *)data, sizeof(requested_uri)); 1601 strlcpy(detected_uri, device_uri, sizeof(detected_uri)); 1602 1603 /* 1604 * libusb-discovered URIs can have an "interface" specification and this 1605 * never happens for usblp-discovered URIs, so remove the "interface" 1606 * specification from the URI which we are checking currently. This way a 1607 * queue for a usblp-discovered printer can now be accessed via libusb. 1608 * 1609 * Similarly, strip "?serial=NNN...NNN" as needed. 1610 */ 1611 1612 if ((requested_ptr = strstr(requested_uri, "?interface=")) == NULL) 1613 requested_ptr = strstr(requested_uri, "&interface="); 1614 if ((detected_ptr = strstr(detected_uri, "?interface=")) == NULL) 1615 detected_ptr = strstr(detected_uri, "&interface="); 1616 1617 if (!requested_ptr && detected_ptr) 1618 { 1619 /* 1620 * Strip "[?&]interface=nnn" from the detected printer. 1621 */ 1622 1623 *detected_ptr = '\0'; 1624 } 1625 else if (requested_ptr && !detected_ptr) 1626 { 1627 /* 1628 * Strip "[?&]interface=nnn" from the requested printer. 1629 */ 1630 1631 *requested_ptr = '\0'; 1632 } 1633 1634 if ((requested_ptr = strstr(requested_uri, "?serial=?")) != NULL) 1635 { 1636 /* 1637 * Strip "?serial=?" from the requested printer. This is a special 1638 * case, as "?serial=?" means no serial number and not the serial 1639 * number '?'. This is not covered by the checks below... 1640 */ 1641 1642 *requested_ptr = '\0'; 1643 } 1644 1645 if ((requested_ptr = strstr(requested_uri, "?serial=")) == NULL && 1646 (detected_ptr = strstr(detected_uri, "?serial=")) != NULL) 1647 { 1648 /* 1649 * Strip "?serial=nnn" from the detected printer. 1650 */ 1651 1652 *detected_ptr = '\0'; 1653 } 1654 else if (requested_ptr && !detected_ptr) 1655 { 1656 /* 1657 * Strip "?serial=nnn" from the requested printer. 1658 */ 1659 1660 *requested_ptr = '\0'; 1661 } 1662 1663 return (!strcmp(requested_uri, detected_uri)); 1664} 1665 1666 1667/* 1668 * 'read_thread()' - Thread to read the backchannel data on. 1669 */ 1670 1671static void *read_thread(void *reference) 1672{ 1673 unsigned char readbuffer[512]; 1674 int rbytes; 1675 int readstatus; 1676 struct timeval now, 1677 delay, 1678 end, 1679 timeleft; 1680 1681 1682 (void)reference; 1683 1684 /* 1685 * Read frequency: once every 250 milliseconds. 1686 */ 1687 1688 delay.tv_sec = 0; 1689 delay.tv_usec = 250000; 1690 1691 do 1692 { 1693 /* 1694 * Remember when we started so we can throttle the loop after the read 1695 * call... 1696 */ 1697 1698 gettimeofday(&now, NULL); 1699 1700 /* 1701 * Calculate what 250 milliSeconds are in absolute time... 1702 */ 1703 1704 timeradd(&now, &delay, &end); 1705 1706 rbytes = sizeof(readbuffer); 1707 readstatus = libusb_bulk_transfer(g.printer->handle, 1708 g.printer->read_endp, 1709 readbuffer, rbytes, 1710 &rbytes, 60000); 1711 if (readstatus == LIBUSB_SUCCESS && rbytes > 0) 1712 { 1713 fprintf(stderr, "DEBUG: Read %d bytes of back-channel data...\n", 1714 (int)rbytes); 1715 cupsBackChannelWrite((const char *)readbuffer, (size_t)rbytes, 1.0); 1716 } 1717 else if (readstatus == LIBUSB_ERROR_TIMEOUT) 1718 fputs("DEBUG: Got USB transaction timeout during read.\n", stderr); 1719 else if (readstatus == LIBUSB_ERROR_PIPE) 1720 fputs("DEBUG: Got USB pipe stalled during read.\n", stderr); 1721 else if (readstatus == LIBUSB_ERROR_INTERRUPTED) 1722 fputs("DEBUG: Got USB return aborted during read.\n", stderr); 1723 1724 /* 1725 * Make sure this loop executes no more than once every 250 miliseconds... 1726 */ 1727 1728 if ((readstatus != LIBUSB_SUCCESS || rbytes == 0) && 1729 (g.wait_eof || !g.read_thread_stop)) 1730 { 1731 gettimeofday(&now, NULL); 1732 if (timercmp(&now, &end, <)) 1733 { 1734 timersub(&end, &now, &timeleft); 1735 usleep(1000000 * timeleft.tv_sec + timeleft.tv_usec); 1736 } 1737 } 1738 } while (g.wait_eof || !g.read_thread_stop); 1739 1740 /* 1741 * Let the main thread know that we have completed the read thread... 1742 */ 1743 1744 pthread_mutex_lock(&g.read_thread_mutex); 1745 g.read_thread_done = 1; 1746 pthread_cond_signal(&g.read_thread_cond); 1747 pthread_mutex_unlock(&g.read_thread_mutex); 1748 1749 return (NULL); 1750} 1751 1752 1753/* 1754 * 'sidechannel_thread()' - Handle side-channel requests. 1755 */ 1756 1757static void* 1758sidechannel_thread(void *reference) 1759{ 1760 cups_sc_command_t command; /* Request command */ 1761 cups_sc_status_t status; /* Request/response status */ 1762 char data[2048]; /* Request/response data */ 1763 int datalen; /* Request/response data size */ 1764 1765 1766 (void)reference; 1767 1768 do 1769 { 1770 datalen = sizeof(data); 1771 1772 if (cupsSideChannelRead(&command, &status, data, &datalen, 1.0)) 1773 { 1774 if (status == CUPS_SC_STATUS_TIMEOUT) 1775 continue; 1776 else 1777 break; 1778 } 1779 1780 switch (command) 1781 { 1782 case CUPS_SC_CMD_SOFT_RESET: /* Do a soft reset */ 1783 fputs("DEBUG: CUPS_SC_CMD_SOFT_RESET received from driver...\n", 1784 stderr); 1785 1786 soft_reset(); 1787 cupsSideChannelWrite(command, CUPS_SC_STATUS_OK, NULL, 0, 1.0); 1788 fputs("DEBUG: Returning status CUPS_STATUS_OK with no bytes...\n", 1789 stderr); 1790 break; 1791 1792 case CUPS_SC_CMD_DRAIN_OUTPUT: /* Drain all pending output */ 1793 fputs("DEBUG: CUPS_SC_CMD_DRAIN_OUTPUT received from driver...\n", 1794 stderr); 1795 1796 g.drain_output = 1; 1797 break; 1798 1799 case CUPS_SC_CMD_GET_BIDI: /* Is the connection bidirectional? */ 1800 fputs("DEBUG: CUPS_SC_CMD_GET_BIDI received from driver...\n", 1801 stderr); 1802 1803 data[0] = (g.printer->protocol >= 2 ? 1 : 0); 1804 cupsSideChannelWrite(command, CUPS_SC_STATUS_OK, data, 1, 1.0); 1805 1806 fprintf(stderr, 1807 "DEBUG: Returned CUPS_SC_STATUS_OK with 1 byte (%02X)...\n", 1808 data[0]); 1809 break; 1810 1811 case CUPS_SC_CMD_GET_DEVICE_ID: /* Return IEEE-1284 device ID */ 1812 fputs("DEBUG: CUPS_SC_CMD_GET_DEVICE_ID received from driver...\n", 1813 stderr); 1814 1815 datalen = sizeof(data); 1816 if (get_device_id(g.printer, data, sizeof(data))) 1817 { 1818 status = CUPS_SC_STATUS_IO_ERROR; 1819 datalen = 0; 1820 } 1821 else 1822 { 1823 status = CUPS_SC_STATUS_OK; 1824 datalen = strlen(data); 1825 } 1826 cupsSideChannelWrite(command, CUPS_SC_STATUS_OK, data, datalen, 1.0); 1827 1828 if (datalen < sizeof(data)) 1829 data[datalen] = '\0'; 1830 else 1831 data[sizeof(data) - 1] = '\0'; 1832 1833 fprintf(stderr, 1834 "DEBUG: Returning CUPS_SC_STATUS_OK with %d bytes (%s)...\n", 1835 datalen, data); 1836 break; 1837 1838 case CUPS_SC_CMD_GET_STATE: /* Return device state */ 1839 fputs("DEBUG: CUPS_SC_CMD_GET_STATE received from driver...\n", 1840 stderr); 1841 1842 data[0] = CUPS_SC_STATE_ONLINE; 1843 cupsSideChannelWrite(command, CUPS_SC_STATUS_OK, data, 1, 1.0); 1844 1845 fprintf(stderr, 1846 "DEBUG: Returned CUPS_SC_STATUS_OK with 1 byte (%02X)...\n", 1847 data[0]); 1848 break; 1849 1850 case CUPS_SC_CMD_GET_CONNECTED: /* Return whether device is 1851 connected */ 1852 fputs("DEBUG: CUPS_SC_CMD_GET_CONNECTED received from driver...\n", 1853 stderr); 1854 1855 data[0] = (g.printer->handle ? 1 : 0); 1856 cupsSideChannelWrite(command, CUPS_SC_STATUS_OK, data, 1, 1.0); 1857 1858 fprintf(stderr, 1859 "DEBUG: Returned CUPS_SC_STATUS_OK with 1 byte (%02X)...\n", 1860 data[0]); 1861 break; 1862 1863 default: 1864 fprintf(stderr, "DEBUG: Unknown side-channel command (%d) received " 1865 "from driver...\n", command); 1866 1867 cupsSideChannelWrite(command, CUPS_SC_STATUS_NOT_IMPLEMENTED, 1868 NULL, 0, 1.0); 1869 1870 fputs("DEBUG: Returned CUPS_SC_STATUS_NOT_IMPLEMENTED with no bytes...\n", 1871 stderr); 1872 break; 1873 } 1874 } 1875 while (!g.sidechannel_thread_stop); 1876 1877 pthread_mutex_lock(&g.sidechannel_thread_mutex); 1878 g.sidechannel_thread_done = 1; 1879 pthread_cond_signal(&g.sidechannel_thread_cond); 1880 pthread_mutex_unlock(&g.sidechannel_thread_mutex); 1881 1882 return (NULL); 1883} 1884 1885 1886/* 1887 * 'soft_reset()' - Send a soft reset to the device. 1888 */ 1889 1890static void 1891soft_reset(void) 1892{ 1893 fd_set input_set; /* Input set for select() */ 1894 struct timeval tv; /* Time value */ 1895 char buffer[2048]; /* Buffer */ 1896 struct timespec cond_timeout; /* pthread condition timeout */ 1897 1898 1899 /* 1900 * Send an abort once a second until the I/O lock is released by the main 1901 * thread... 1902 */ 1903 1904 pthread_mutex_lock(&g.readwrite_lock_mutex); 1905 while (g.readwrite_lock) 1906 { 1907 gettimeofday(&tv, NULL); 1908 cond_timeout.tv_sec = tv.tv_sec + 1; 1909 cond_timeout.tv_nsec = tv.tv_usec * 1000; 1910 1911 while (g.readwrite_lock) 1912 { 1913 if (pthread_cond_timedwait(&g.readwrite_lock_cond, 1914 &g.readwrite_lock_mutex, 1915 &cond_timeout) != 0) 1916 break; 1917 } 1918 } 1919 1920 g.readwrite_lock = 1; 1921 pthread_mutex_unlock(&g.readwrite_lock_mutex); 1922 1923 /* 1924 * Flush bytes waiting on print_fd... 1925 */ 1926 1927 g.print_bytes = 0; 1928 1929 FD_ZERO(&input_set); 1930 FD_SET(g.print_fd, &input_set); 1931 1932 tv.tv_sec = 0; 1933 tv.tv_usec = 0; 1934 1935 while (select(g.print_fd+1, &input_set, NULL, NULL, &tv) > 0) 1936 if (read(g.print_fd, buffer, sizeof(buffer)) <= 0) 1937 break; 1938 1939 /* 1940 * Send the reset... 1941 */ 1942 1943 soft_reset_printer(g.printer); 1944 1945 /* 1946 * Release the I/O lock... 1947 */ 1948 1949 pthread_mutex_lock(&g.readwrite_lock_mutex); 1950 g.readwrite_lock = 0; 1951 pthread_cond_signal(&g.readwrite_lock_cond); 1952 pthread_mutex_unlock(&g.readwrite_lock_mutex); 1953} 1954 1955 1956/* 1957 * 'soft_reset_printer()' - Do the soft reset request specific to printers 1958 * 1959 * This soft reset is specific to the printer device class and is much less 1960 * invasive than the general USB reset libusb_reset_device(). Especially it 1961 * does never happen that the USB addressing and configuration changes. What 1962 * is actually done is that all buffers get flushed and the bulk IN and OUT 1963 * pipes get reset to their default states. This clears all stall conditions. 1964 * See http://cholla.mmto.org/computers/linux/usb/usbprint11.pdf 1965 */ 1966 1967static int /* O - 0 on success, < 0 on error */ 1968soft_reset_printer( 1969 usb_printer_t *printer) /* I - Printer */ 1970{ 1971 struct libusb_config_descriptor *confptr = NULL; 1972 /* Pointer to current configuration */ 1973 int interface, /* Interface to reset */ 1974 errcode; /* Error code */ 1975 1976 1977 if (libusb_get_config_descriptor(printer->device, printer->conf, 1978 &confptr) < 0) 1979 interface = printer->iface; 1980 else 1981 interface = confptr->interface[printer->iface]. 1982 altsetting[printer->altset].bInterfaceNumber; 1983 1984 libusb_free_config_descriptor(confptr); 1985 1986 if ((errcode = libusb_control_transfer(printer->handle, 1987 LIBUSB_REQUEST_TYPE_CLASS | 1988 LIBUSB_ENDPOINT_OUT | 1989 LIBUSB_RECIPIENT_OTHER, 1990 2, 0, interface, NULL, 0, 5000)) < 0) 1991 errcode = libusb_control_transfer(printer->handle, 1992 LIBUSB_REQUEST_TYPE_CLASS | 1993 LIBUSB_ENDPOINT_OUT | 1994 LIBUSB_RECIPIENT_INTERFACE, 1995 2, 0, interface, NULL, 0, 5000); 1996 1997 return (errcode); 1998} 1999 2000 2001/* 2002 * End of "$Id: usb-libusb.c 11645 2014-02-27 16:35:53Z msweet $". 2003 */ 2004 2005