backend/usb-libusb.c

   1 /*
   2  * "$Id$"
   3  *
   4  *   Libusb interface code for CUPS.
   5  *
   6  *   Copyright 2007-2010 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  * Contents:
  15  *
  16  *   list_devices()    - List the available printers.
  17  *   print_device()    - Print a file to a USB device.
  18  *   close_device()    - Close the connection to the USB printer.
  19  *   find_device()     - Find or enumerate USB printers.
  20  *   get_device_id()   - Get the IEEE-1284 device ID for the printer.
  21  *   list_cb()         - List USB printers for discovery.
  22  *   make_device_uri() - Create a device URI for a USB printer.
  23  *   open_device()     - Open a connection to the USB printer.
  24  *   print_cb()        - Find a USB printer for printing.
  25  *   side_cb()         - Handle side-channel requests.
  26  */
  27
  28 /*
  29  * Include necessary headers...
  30  */
  31
  32 #include <usb.h>
  33 #include <poll.h>
  34 #include <cups/cups-private.h>
  35
  36
  37 /*
  38  * Local types...
  39  */
  40
  41 typedef struct usb_printer_s            /**** USB Printer Data ****/
  42 {
  43   struct usb_device     *device;        /* Device info */
  44   int                   conf,           /* Configuration */
  45                         iface,          /* Interface */
  46                         altset,         /* Alternate setting */
  47                         write_endp,     /* Write endpoint */
  48                         read_endp;      /* Read endpoint */
  49   struct usb_dev_handle *handle;        /* Open handle to device */
  50 } usb_printer_t;
  51
  52 typedef int (*usb_cb_t)(usb_printer_t *, const char *, const char *,
  53                         const void *);
  54
  55
  56 /*
  57  * Local functions...
  58  */
  59
  60 static int              close_device(usb_printer_t *printer);
  61 static usb_printer_t    *find_device(usb_cb_t cb, const void *data);
  62 static int              get_device_id(usb_printer_t *printer, char *buffer,
  63                                       size_t bufsize);
  64 static int              list_cb(usb_printer_t *printer, const char *device_uri,
  65                                 const char *device_id, const void *data);
  66 static char             *make_device_uri(usb_printer_t *printer,
  67                                          const char *device_id,
  68                                          char *uri, size_t uri_size);
  69 static int              open_device(usb_printer_t *printer, int verbose);
  70 static int              print_cb(usb_printer_t *printer, const char *device_uri,
  71                                  const char *device_id, const void *data);
  72 static ssize_t          side_cb(usb_printer_t *printer, int print_fd);
  73
  74
  75 /*
  76  * 'list_devices()' - List the available printers.
  77  */
  78
  79 void
  80 list_devices(void)
  81 {
  82   fputs("DEBUG: list_devices\n", stderr);
  83   find_device(list_cb, NULL);
  84 }
  85
  86
  87 /*
  88  * 'print_device()' - Print a file to a USB device.
  89  */
  90
  91 int                                     /* O - Exit status */
  92 print_device(const char *uri,           /* I - Device URI */
  93              const char *hostname,      /* I - Hostname/manufacturer */
  94              const char *resource,      /* I - Resource/modelname */
  95              char       *options,       /* I - Device options/serial number */
  96              int        print_fd,       /* I - File descriptor to print */
  97              int        copies,         /* I - Copies to print */
  98              int        argc,           /* I - Number of command-line arguments (6 or 7) */
  99              char       *argv[])        /* I - Command-line arguments */
 100 {
 101   usb_printer_t *printer;               /* Printer */
 102   ssize_t       bytes,                  /* Bytes read/written */
 103                 tbytes;                 /* Total bytes written */
 104   char          buffer[8192];           /* Print data buffer */
 105   struct sigaction action;              /* Actions for POSIX signals */
 106   struct pollfd pfds[2];                /* Poll descriptors */
 107
 108
 109   fputs("DEBUG: print_device\n", stderr);
 110
 111  /*
 112   * Connect to the printer...
 113   */
 114
 115   while ((printer = find_device(print_cb, uri)) == NULL)
 116   {
 117     _cupsLangPrintFilter(stderr, "INFO",
 118                          _("Waiting for printer to become available."));
 119     sleep(5);
 120   }
 121
 122
 123  /*
 124   * If we are printing data from a print driver on stdin, ignore SIGTERM
 125   * so that the driver can finish out any page data, e.g. to eject the
 126   * current page.  We only do this for stdin printing as otherwise there
 127   * is no way to cancel a raw print job...
 128   */
 129
 130   if (!print_fd)
 131   {
 132     memset(&action, 0, sizeof(action));
 133
 134     sigemptyset(&action.sa_mask);
 135     action.sa_handler = SIG_IGN;
 136     sigaction(SIGTERM, &action, NULL);
 137   }
 138
 139   tbytes = 0;
 140
 141   pfds[0].fd     = print_fd;
 142   pfds[0].events = POLLIN;
 143   pfds[1].fd     = CUPS_SC_FD;
 144   pfds[1].events = POLLIN;
 145
 146   while (copies > 0 && tbytes >= 0)
 147   {
 148     copies --;
 149
 150     if (print_fd != 0)
 151     {
 152       fputs("PAGE: 1 1\n", stderr);
 153       lseek(print_fd, 0, SEEK_SET);
 154     }
 155
 156    /*
 157     * TODO: Add back-channel support, along with better write error handling.
 158     */
 159
 160     while (poll(pfds, 2, -1) > 0)
 161     {
 162      /*
 163       * CUPS STR #3318: USB process hangs on end-of-file, making further
 164       *                 printing impossible
 165       *
 166       * From a strict interpretation of POSIX poll(), POLLHUP should never be
 167       * set without POLLIN, since POLLIN is the event you request.  That said,
 168       * it appears that some versions of Linux break this.
 169       */
 170
 171       if (pfds[0].revents & (POLLIN | POLLHUP))
 172       {
 173         if ((bytes = read(print_fd, buffer, sizeof(buffer))) > 0)
 174         {
 175           if (usb_bulk_write(printer->handle, printer->write_endp, buffer,
 176                                 bytes, 3600000) < 0)
 177           {
 178             _cupsLangPrintFilter(stderr, "ERROR",
 179                                  _("Unable to send data to printer."));
 180             tbytes = -1;
 181             break;
 182           }
 183
 184           tbytes += bytes;
 185         }
 186         else if (bytes == 0 || (bytes < 0 && errno != EAGAIN && errno != EINTR))
 187           break;
 188       }
 189
 190       if (pfds[1].revents & (POLLIN | POLLHUP))
 191       {
 192         if ((bytes = side_cb(printer, print_fd)) < 0)
 193           pfds[1].events = 0;           /* Filter has gone away... */
 194         else
 195           tbytes += bytes;
 196       }
 197     }
 198   }
 199
 200  /*
 201   * Close our connection and return...
 202   */
 203
 204   close_device(printer);
 205
 206   return (CUPS_BACKEND_OK);
 207 }
 208
 209
 210 /*
 211  * 'close_device()' - Close the connection to the USB printer.
 212  */
 213
 214 static int                              /* I - 0 on success, -1 on failure */
 215 close_device(usb_printer_t *printer)    /* I - Printer */
 216 {
 217   if (printer->handle)
 218   {
 219    /*
 220     * Release interfaces before closing so that we know all data is written
 221     * to the device...
 222     */
 223
 224     int number = printer->device->config[printer->conf].
 225                      interface[printer->iface].
 226                      altsetting[printer->altset].bInterfaceNumber;
 227     usb_release_interface(printer->handle, number);
 228
 229     if (number != 0)
 230       usb_release_interface(printer->handle, 0);
 231
 232    /*
 233     * Close the interface and return...
 234     */
 235
 236     usb_close(printer->handle);
 237     printer->handle = NULL;
 238   }
 239
 240   return (0);
 241 }
 242
 243
 244 /*
 245  * 'find_device()' - Find or enumerate USB printers.
 246  */
 247
 248 static usb_printer_t *                  /* O - Found printer */
 249 find_device(usb_cb_t   cb,              /* I - Callback function */
 250             const void *data)           /* I - User data for callback */
 251 {
 252   struct usb_bus        *bus;           /* Current bus */
 253   struct usb_device     *device;        /* Current device */
 254   struct usb_config_descriptor *confptr;/* Pointer to current configuration */
 255   struct usb_interface  *ifaceptr;      /* Pointer to current interface */
 256   struct usb_interface_descriptor *altptr;
 257                                         /* Pointer to current alternate setting */
 258   struct usb_endpoint_descriptor *endpptr;
 259                                         /* Pointer to current endpoint */
 260   int                   conf,           /* Current configuration */
 261                         iface,          /* Current interface */
 262                         altset,         /* Current alternate setting */
 263                         protocol,       /* Current protocol */
 264                         endp,           /* Current endpoint */
 265                         read_endp,      /* Current read endpoint */
 266                         write_endp;     /* Current write endpoint */
 267   char                  device_id[1024],/* IEEE-1284 device ID */
 268                         device_uri[1024];
 269                                         /* Device URI */
 270   static usb_printer_t  printer;        /* Current printer */
 271
 272
 273  /*
 274   * Initialize libusb...
 275   */
 276
 277   usb_init();
 278   fprintf(stderr, "DEBUG: usb_find_busses=%d\n", usb_find_busses());
 279   fprintf(stderr, "DEBUG: usb_find_devices=%d\n", usb_find_devices());
 280
 281  /*
 282   * Then loop through the devices it found...
 283   */
 284
 285   for (bus = usb_get_busses(); bus; bus = bus->next)
 286     for (device = bus->devices; device; device = device->next)
 287     {
 288      /*
 289       * Ignore devices with no configuration data and anything that is not
 290       * a printer...
 291       */
 292
 293       if (!device->config || !device->descriptor.idVendor ||
 294           !device->descriptor.idProduct)
 295         continue;
 296
 297       for (conf = 0, confptr = device->config;
 298            conf < device->descriptor.bNumConfigurations;
 299            conf ++, confptr ++)
 300         for (iface = 0, ifaceptr = confptr->interface;
 301              iface < confptr->bNumInterfaces;
 302              iface ++, ifaceptr ++)
 303         {
 304          /*
 305           * Some printers offer multiple interfaces...
 306           */
 307
 308           protocol   = 0;
 309
 310           for (altset = 0, altptr = ifaceptr->altsetting;
 311                altset < ifaceptr->num_altsetting;
 312                altset ++, altptr ++)
 313           {
 314            /*
 315             * Currently we only support unidirectional and bidirectional
 316             * printers.  Future versions of this code will support the
 317             * 1284.4 (packet mode) protocol as well.
 318             */
 319
 320             if (altptr->bInterfaceClass != USB_CLASS_PRINTER ||
 321                 altptr->bInterfaceSubClass != 1 ||
 322                 (altptr->bInterfaceProtocol != 1 &&     /* Unidirectional */
 323                  altptr->bInterfaceProtocol != 2) ||    /* Bidirectional */
 324                 altptr->bInterfaceProtocol < protocol)
 325               continue;
 326
 327             read_endp  = -1;
 328             write_endp = -1;
 329
 330             for (endp = 0, endpptr = altptr->endpoint;
 331                  endp < altptr->bNumEndpoints;
 332                  endp ++, endpptr ++)
 333               if ((endpptr->bmAttributes & USB_ENDPOINT_TYPE_MASK) ==
 334                       USB_ENDPOINT_TYPE_BULK)
 335               {
 336                 if (endpptr->bEndpointAddress & USB_ENDPOINT_DIR_MASK)
 337                   read_endp = endp;
 338                 else
 339                   write_endp = endp;
 340               }
 341
 342             if (write_endp >= 0)
 343             {
 344              /*
 345               * Save the best match so far...
 346               */
 347
 348               protocol           = altptr->bInterfaceProtocol;
 349               printer.altset     = altset;
 350               printer.write_endp = write_endp;
 351               printer.read_endp  = read_endp;
 352             }
 353           }
 354
 355           if (protocol > 0)
 356           {
 357             printer.device = device;
 358             printer.conf   = conf;
 359             printer.iface  = iface;
 360             printer.handle = NULL;
 361
 362             if (!open_device(&printer, data != NULL))
 363             {
 364               if (!get_device_id(&printer, device_id, sizeof(device_id)))
 365               {
 366                 make_device_uri(&printer, device_id, device_uri,
 367                                 sizeof(device_uri));
 368
 369                 if ((*cb)(&printer, device_uri, device_id, data))
 370                 {
 371                   printer.read_endp  = printer.device->config[printer.conf].
 372                                            interface[printer.iface].
 373                                            altsetting[printer.altset].
 374                                            endpoint[printer.read_endp].
 375                                            bEndpointAddress;
 376                   printer.write_endp = printer.device->config[printer.conf].
 377                                            interface[printer.iface].
 378                                            altsetting[printer.altset].
 379                                            endpoint[printer.write_endp].
 380                                            bEndpointAddress;
 381                   return (&printer);
 382                 }
 383               }
 384
 385               close_device(&printer);
 386             }
 387           }
 388         }
 389     }
 390
 391  /*
 392   * If we get this far without returning, then we haven't found a printer
 393   * to print to...
 394   */
 395
 396   return (NULL);
 397 }
 398
 399
 400 /*
 401  * 'get_device_id()' - Get the IEEE-1284 device ID for the printer.
 402  */
 403
 404 static int                              /* O - 0 on success, -1 on error */
 405 get_device_id(usb_printer_t *printer,   /* I - Printer */
 406               char          *buffer,    /* I - String buffer */
 407               size_t        bufsize)    /* I - Number of bytes in buffer */
 408 {
 409   int   length;                         /* Length of device ID */
 410
 411
 412   if (usb_control_msg(printer->handle,
 413                       USB_TYPE_CLASS | USB_ENDPOINT_IN | USB_RECIP_INTERFACE,
 414                       0, printer->conf, printer->iface,
 415                       buffer, bufsize, 5000) < 0)
 416   {
 417     *buffer = '\0';
 418     return (-1);
 419   }
 420
 421  /*
 422   * Extract the length of the device ID string from the first two
 423   * bytes.  The 1284 spec says the length is stored MSB first...
 424   */
 425
 426   length = (((unsigned)buffer[0] & 255) << 8) +
 427            ((unsigned)buffer[1] & 255);
 428
 429  /*
 430   * Check to see if the length is larger than our buffer; first
 431   * assume that the vendor incorrectly implemented the 1284 spec,
 432   * and then limit the length to the size of our buffer...
 433   */
 434
 435   if (length > bufsize)
 436     length = (((unsigned)buffer[1] & 255) << 8) +
 437              ((unsigned)buffer[0] & 255);
 438
 439   if (length > bufsize)
 440     length = bufsize;
 441
 442   length -= 2;
 443
 444  /*
 445   * Copy the device ID text to the beginning of the buffer and
 446   * nul-terminate.
 447   */
 448
 449   memmove(buffer, buffer + 2, length);
 450   buffer[length] = '\0';
 451
 452   return (0);
 453 }
 454
 455
 456 /*
 457  * 'list_cb()' - List USB printers for discovery.
 458  */
 459
 460 static int                              /* O - 0 to continue, 1 to stop */
 461 list_cb(usb_printer_t *printer,         /* I - Printer */
 462         const char    *device_uri,      /* I - Device URI */
 463         const char    *device_id,       /* I - IEEE-1284 device ID */
 464         const void    *data)            /* I - User data (not used) */
 465 {
 466   char  make_model[1024];               /* Make and model */
 467
 468
 469  /*
 470   * Get the device URI and make/model strings...
 471   */
 472
 473   backendGetMakeModel(device_id, make_model, sizeof(make_model));
 474
 475  /*
 476   * Report the printer...
 477   */
 478
 479   cupsBackendReport("direct", device_uri, make_model, make_model, device_id,
 480                     NULL);
 481
 482  /*
 483   * Keep going...
 484   */
 485
 486   return (0);
 487 }
 488
 489
 490 /*
 491  * 'make_device_uri()' - Create a device URI for a USB printer.
 492  */
 493
 494 static char *                           /* O - Device URI */
 495 make_device_uri(
 496     usb_printer_t *printer,             /* I - Printer */
 497     const char    *device_id,           /* I - IEEE-1284 device ID */
 498     char          *uri,                 /* I - Device URI buffer */
 499     size_t        uri_size)             /* I - Size of device URI buffer */
 500 {
 501   char          options[1024];          /* Device URI options */
 502   int           num_values;             /* Number of 1284 parameters */
 503   cups_option_t *values;                /* 1284 parameters */
 504   const char    *mfg,                   /* Manufacturer */
 505                 *mdl,                   /* Model */
 506                 *des,                   /* Description */
 507                 *sern;                  /* Serial number */
 508   char          tempmfg[256],           /* Temporary manufacturer string */
 509                 tempsern[256],          /* Temporary serial number string */
 510                 *tempptr;               /* Pointer into temp string */
 511
 512
 513  /*
 514   * Get the make, model, and serial numbers...
 515   */
 516
 517   num_values = _cupsGet1284Values(device_id, &values);
 518
 519   if ((sern = cupsGetOption("SERIALNUMBER", num_values, values)) == NULL)
 520     if ((sern = cupsGetOption("SERN", num_values, values)) == NULL)
 521       if ((sern = cupsGetOption("SN", num_values, values)) == NULL &&
 522           printer->device->descriptor.iSerialNumber)
 523       {
 524        /*
 525         * Try getting the serial number from the device itself...
 526         */
 527
 528         int length = usb_get_string_simple(printer->handle,
 529                                            printer->device->descriptor.
 530                                                iSerialNumber,
 531                                            tempsern, sizeof(tempsern) - 1);
 532         if (length > 0)
 533         {
 534           tempsern[length] = '\0';
 535           sern             = tempsern;
 536         }
 537       }
 538
 539   if ((mfg = cupsGetOption("MANUFACTURER", num_values, values)) == NULL)
 540     mfg = cupsGetOption("MFG", num_values, values);
 541
 542   if ((mdl = cupsGetOption("MODEL", num_values, values)) == NULL)
 543     mdl = cupsGetOption("MDL", num_values, values);
 544
 545 #ifdef __APPLE__
 546  /*
 547   * To maintain compatibility with the original IOKit-based backend on Mac OS X,
 548   * don't map manufacturer names...
 549   */
 550
 551   if (!mfg)
 552
 553 #else
 554  /*
 555   * To maintain compatibility with the original character device backend on
 556   * Linux and *BSD, map manufacturer names...
 557   */
 558
 559   if (mfg)
 560   {
 561     if (!strcasecmp(mfg, "Hewlett-Packard"))
 562       mfg = "HP";
 563     else if (!strcasecmp(mfg, "Lexmark International"))
 564       mfg = "Lexmark";
 565   }
 566   else
 567 #endif /* __APPLE__ */
 568   {
 569    /*
 570     * No manufacturer?  Use the model string or description...
 571     */
 572
 573     if (mdl)
 574       _ppdNormalizeMakeAndModel(mdl, tempmfg, sizeof(tempmfg));
 575     else if ((des = cupsGetOption("DESCRIPTION", num_values, values)) != NULL ||
 576              (des = cupsGetOption("DES", num_values, values)) != NULL)
 577       _ppdNormalizeMakeAndModel(des, tempmfg, sizeof(tempmfg));
 578     else
 579       strlcpy(tempmfg, "Unknown", sizeof(tempmfg));
 580
 581     if ((tempptr = strchr(tempmfg, ' ')) != NULL)
 582       *tempptr = '\0';
 583
 584     mfg = tempmfg;
 585   }
 586
 587  /*
 588   * Generate the device URI from the manufacturer, model, serial number,
 589   * and interface number...
 590   */
 591
 592   if (sern)
 593   {
 594     if (printer->iface > 0)
 595       snprintf(options, sizeof(options), "?serial=%s&interface=%d", sern,
 596                printer->iface);
 597     else
 598       snprintf(options, sizeof(options), "?serial=%s", sern);
 599   }
 600   else if (printer->iface > 0)
 601     snprintf(options, sizeof(options), "?interface=%d", printer->iface);
 602   else
 603     options[0] = '\0';
 604
 605   httpAssembleURIf(HTTP_URI_CODING_ALL, uri, uri_size, "usb", NULL, mfg, 0,
 606                    "/%s%s", mdl, options);
 607
 608   cupsFreeOptions(num_values, values);
 609
 610   return (uri);
 611 }
 612
 613
 614 /*
 615  * 'open_device()' - Open a connection to the USB printer.
 616  */
 617
 618 static int                              /* O - 0 on success, -1 on error */
 619 open_device(usb_printer_t *printer,     /* I - Printer */
 620             int           verbose)      /* I - Update connecting-to-device state? */
 621 {
 622   int   number;                         /* Configuration/interface/altset numbers */
 623
 624
 625  /*
 626   * Return immediately if we are already connected...
 627   */
 628
 629   if (printer->handle)
 630     return (0);
 631
 632  /*
 633   * Try opening the printer...
 634   */
 635
 636   if ((printer->handle = usb_open(printer->device)) == NULL)
 637     return (-1);
 638
 639  /*
 640   * Then set the desired configuration...
 641   */
 642
 643   if (verbose)
 644     fputs("STATE: +connecting-to-device\n", stderr);
 645
 646   number = printer->device->config[printer->conf].bConfigurationValue;
 647
 648   if (usb_set_configuration(printer->handle, number) < 0)
 649   {
 650    /*
 651     * If the set fails, chances are that the printer only supports a
 652     * single configuration.  Technically these printers don't conform to
 653     * the USB printer specification, but otherwise they'll work...
 654     */
 655
 656     if (errno != EBUSY)
 657       fprintf(stderr, "DEBUG: Failed to set configuration %d for %04x:%04x\n",
 658               number, printer->device->descriptor.idVendor,
 659               printer->device->descriptor.idProduct);
 660   }
 661
 662  /*
 663   * Claim interfaces as needed...
 664   */
 665
 666   number = printer->device->config[printer->conf].interface[printer->iface].
 667                altsetting[printer->altset].bInterfaceNumber;
 668   while (usb_claim_interface(printer->handle, number) < 0)
 669   {
 670     if (errno != EBUSY)
 671       fprintf(stderr, "DEBUG: Failed to claim interface %d for %04x:%04x: %s\n",
 672               number, printer->device->descriptor.idVendor,
 673               printer->device->descriptor.idProduct, strerror(errno));
 674
 675     goto error;
 676   }
 677
 678   if (number != 0)
 679     while (usb_claim_interface(printer->handle, 0) < 0)
 680     {
 681       if (errno != EBUSY)
 682         fprintf(stderr, "DEBUG: Failed to claim interface 0 for %04x:%04x: %s\n",
 683                 printer->device->descriptor.idVendor,
 684                 printer->device->descriptor.idProduct, strerror(errno));
 685
 686       goto error;
 687     }
 688
 689  /*
 690   * Set alternate setting...
 691   */
 692
 693   number = printer->device->config[printer->conf].interface[printer->iface].
 694                altsetting[printer->altset].bAlternateSetting;
 695   while (usb_set_altinterface(printer->handle, number) < 0)
 696   {
 697     if (errno != EBUSY)
 698       fprintf(stderr,
 699               "DEBUG: Failed to set alternate interface %d for %04x:%04x: %s\n",
 700               number, printer->device->descriptor.idVendor,
 701               printer->device->descriptor.idProduct, strerror(errno));
 702
 703     goto error;
 704   }
 705
 706   if (verbose)
 707     fputs("STATE: -connecting-to-device\n", stderr);
 708
 709   return (0);
 710
 711  /*
 712   * If we get here, there was a hard error...
 713   */
 714
 715   error:
 716
 717   if (verbose)
 718     fputs("STATE: -connecting-to-device\n", stderr);
 719
 720   usb_close(printer->handle);
 721   printer->handle = NULL;
 722
 723   return (-1);
 724 }
 725
 726
 727 /*
 728  * 'print_cb()' - Find a USB printer for printing.
 729  */
 730
 731 static int                              /* O - 0 to continue, 1 to stop (found) */
 732 print_cb(usb_printer_t *printer,        /* I - Printer */
 733          const char    *device_uri,     /* I - Device URI */
 734          const char    *device_id,      /* I - IEEE-1284 device ID */
 735          const void    *data)           /* I - User data (make, model, S/N) */
 736 {
 737   return (!strcmp((char *)data, device_uri));
 738 }
 739
 740
 741 /*
 742  * 'side_cb()' - Handle side-channel requests.
 743  */
 744
 745 static ssize_t                          /* O - Number of bytes written */
 746 side_cb(usb_printer_t *printer,         /* I - Printer */
 747         int           print_fd)         /* I - File to print */
 748 {
 749   ssize_t               bytes,          /* Bytes read/written */
 750                         tbytes;         /* Total bytes written */
 751   char                  buffer[8192];   /* Print data buffer */
 752   struct pollfd         pfd;            /* Poll descriptor */
 753   cups_sc_command_t     command;        /* Request command */
 754   cups_sc_status_t      status;         /* Request/response status */
 755   char                  data[2048];     /* Request/response data */
 756   int                   datalen;        /* Request/response data size */
 757
 758
 759   tbytes  = 0;
 760   datalen = sizeof(data);
 761
 762   if (cupsSideChannelRead(&command, &status, data, &datalen, 1.0))
 763     return (-1);
 764
 765   switch (command)
 766   {
 767     case CUPS_SC_CMD_DRAIN_OUTPUT :
 768         pfd.fd     = print_fd;
 769         pfd.events = POLLIN;
 770
 771         while (poll(&pfd, 1, 1000) > 0)
 772         {
 773           if ((bytes = read(print_fd, buffer, sizeof(buffer))) > 0)
 774           {
 775             while (usb_bulk_write(printer->handle, printer->write_endp, buffer,
 776                                   bytes, 5000) < 0)
 777             {
 778               _cupsLangPrintFilter(stderr, "ERROR",
 779                                    _("Unable to send data to printer."));
 780               tbytes = -1;
 781               break;
 782             }
 783
 784             tbytes += bytes;
 785           }
 786           else if (bytes < 0 && errno != EAGAIN && errno != EINTR)
 787             break;
 788         }
 789
 790         if (tbytes < 0)
 791           status = CUPS_SC_STATUS_IO_ERROR;
 792         else
 793           status = CUPS_SC_STATUS_OK;
 794
 795         datalen = 0;
 796         break;
 797
 798     case CUPS_SC_CMD_GET_BIDI :
 799         status  = CUPS_SC_STATUS_OK;
 800         data[0] = 0;                    /* TODO: Change to 1 when read supported */
 801         datalen = 1;
 802         break;
 803
 804     case CUPS_SC_CMD_GET_DEVICE_ID :
 805         if (get_device_id(printer, data, sizeof(data)))
 806         {
 807           status  = CUPS_SC_STATUS_IO_ERROR;
 808           datalen = 0;
 809         }
 810         else
 811         {
 812           status  = CUPS_SC_STATUS_OK;
 813           datalen = strlen(data);
 814         }
 815         break;
 816
 817     default :
 818         status  = CUPS_SC_STATUS_NOT_IMPLEMENTED;
 819         datalen = 0;
 820         break;
 821   }
 822
 823   cupsSideChannelWrite(command, status, data, datalen, 1.0);
 824
 825   return (tbytes);
 826 }
 827
 828
 829 /*
 830  * End of "$Id$".
 831  */
 832