backend/usb-unix.c

   1 /*
   2  * USB port backend for CUPS.
   3  *
   4  * This file is included from "usb.c" when compiled on UNIX/Linux.
   5  *
   6  * Copyright © 2020-2024 by OpenPrinting.
   7  * Copyright © 2007-2013 by Apple Inc.
   8  * Copyright © 1997-2007 by Easy Software Products, all rights reserved.
   9  *
  10  * Licensed under Apache License v2.0.  See the file "LICENSE" for more
  11  * information.
  12  */
  13
  14 /*
  15  * Include necessary headers.
  16  */
  17
  18 #include <sys/select.h>
  19
  20
  21 /*
  22  * Local functions...
  23  */
  24
  25 static int      open_device(const char *uri, int *use_bc);
  26 static int      side_cb(int print_fd, int device_fd, int snmp_fd,
  27                         http_addr_t *addr, int use_bc);
  28
  29
  30 /*
  31  * 'print_device()' - Print a file to a USB device.
  32  */
  33
  34 int                                     /* O - Exit status */
  35 print_device(const char *uri,           /* I - Device URI */
  36              const char *hostname,      /* I - Hostname/manufacturer */
  37              const char *resource,      /* I - Resource/modelname */
  38              char       *options,       /* I - Device options/serial number */
  39              int        print_fd,       /* I - File descriptor to print */
  40              int        copies,         /* I - Copies to print */
  41              int        argc,           /* I - Number of command-line arguments (6 or 7) */
  42              char       *argv[])        /* I - Command-line arguments */
  43 {
  44   int           use_bc;                 /* Use backchannel path? */
  45   int           device_fd;              /* USB device */
  46   ssize_t       tbytes;                 /* Total number of bytes written */
  47   struct termios opts;                  /* Parallel port options */
  48
  49
  50   (void)argc;
  51   (void)argv;
  52
  53  /*
  54   * Open the USB port device...
  55   */
  56
  57   fputs("STATE: +connecting-to-device\n", stderr);
  58
  59   do
  60   {
  61 #if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
  62    /*
  63     * *BSD's ulpt driver currently does not support the
  64     * back-channel, incorrectly returns data ready on a select(),
  65     * and locks up on read()...
  66     */
  67
  68     use_bc = 0;
  69
  70 #elif defined(__sun)
  71    /*
  72     * CUPS STR #3028: Solaris' usbprn driver apparently does not support
  73     * select() or poll(), so we can't support backchannel...
  74     */
  75
  76     use_bc = 0;
  77
  78 #else
  79    /*
  80     * Disable backchannel data when printing to Brother, Canon, or
  81     * Minolta USB printers - apparently these printers will return
  82     * the IEEE-1284 device ID over and over and over when they get
  83     * a read request...
  84     */
  85
  86     use_bc = _cups_strcasecmp(hostname, "Brother") &&
  87              _cups_strcasecmp(hostname, "Canon") &&
  88              _cups_strncasecmp(hostname, "Konica", 6) &&
  89              _cups_strncasecmp(hostname, "Minolta", 7);
  90 #endif /* __FreeBSD__ || __NetBSD__ || __OpenBSD__ || __DragonFly__ */
  91
  92     if ((device_fd = open_device(uri, &use_bc)) == -1)
  93     {
  94       if (getenv("CLASS") != NULL)
  95       {
  96        /*
  97         * If the CLASS environment variable is set, the job was submitted
  98         * to a class and not to a specific queue.  In this case, we want
  99         * to abort immediately so that the job can be requeued on the next
 100         * available printer in the class.
 101         */
 102
 103         _cupsLangPrintFilter(stderr, "INFO",
 104                              _("Unable to contact printer, queuing on next "
 105                                "printer in class."));
 106
 107        /*
 108         * Sleep 5 seconds to keep the job from requeuing too rapidly...
 109         */
 110
 111         sleep(5);
 112
 113         return (CUPS_BACKEND_FAILED);
 114       }
 115
 116       if (errno == EBUSY)
 117       {
 118         _cupsLangPrintFilter(stderr, "INFO", _("The printer is in use."));
 119         sleep(10);
 120       }
 121       else if (errno == ENXIO || errno == EIO || errno == ENOENT ||
 122                errno == ENODEV)
 123       {
 124         sleep(30);
 125       }
 126       else
 127       {
 128         _cupsLangPrintError("ERROR", _("Unable to open device file"));
 129         return (CUPS_BACKEND_FAILED);
 130       }
 131     }
 132   }
 133   while (device_fd < 0);
 134
 135   fputs("STATE: -connecting-to-device\n", stderr);
 136
 137  /*
 138   * Set any options provided...
 139   */
 140
 141   tcgetattr(device_fd, &opts);
 142
 143   opts.c_lflag &= ~(unsigned)(ICANON | ECHO | ISIG);    /* Raw mode */
 144
 145   /**** No options supported yet ****/
 146
 147   tcsetattr(device_fd, TCSANOW, &opts);
 148
 149  /*
 150   * Finally, send the print file...
 151   */
 152
 153   tbytes = 0;
 154
 155   while (copies > 0 && tbytes >= 0)
 156   {
 157     copies --;
 158
 159     if (print_fd != 0)
 160     {
 161       fputs("PAGE: 1 1\n", stderr);
 162       lseek(print_fd, 0, SEEK_SET);
 163     }
 164
 165 #ifdef __sun
 166    /*
 167     * CUPS STR #3028: Solaris' usbprn driver apparently does not support
 168     * select() or poll(), so we can't support the sidechannel either...
 169     */
 170
 171     tbytes = backendRunLoop(print_fd, device_fd, -1, NULL, use_bc, 1, NULL);
 172
 173 #else
 174     tbytes = backendRunLoop(print_fd, device_fd, -1, NULL, use_bc, 1, side_cb);
 175 #endif /* __sun */
 176
 177     if (print_fd != 0 && tbytes >= 0)
 178       _cupsLangPrintFilter(stderr, "INFO", _("Print file sent."));
 179   }
 180
 181  /*
 182   * Close the USB port and return...
 183   */
 184
 185   close(device_fd);
 186
 187   return (CUPS_BACKEND_OK);
 188 }
 189
 190
 191 /*
 192  * 'list_devices()' - List all USB devices.
 193  */
 194
 195 void
 196 list_devices(void)
 197 {
 198 #ifdef __linux
 199   int   i;                              /* Looping var */
 200   int   fd;                             /* File descriptor */
 201   char  device[255],                    /* Device filename */
 202         device_id[1024],                /* Device ID string */
 203         device_uri[1024],               /* Device URI string */
 204         make_model[1024];               /* Make and model */
 205
 206
 207  /*
 208   * Try to open each USB device...
 209   */
 210
 211   for (i = 0; i < 16; i ++)
 212   {
 213    /*
 214     * Linux has a long history of changing the standard filenames used
 215     * for USB printer devices.  We get the honor of trying them all...
 216     */
 217
 218     snprintf(device, sizeof(device), "/dev/usblp%d", i);
 219
 220     if ((fd = open(device, O_RDWR | O_EXCL)) < 0)
 221     {
 222       if (errno != ENOENT)
 223         continue;
 224
 225       snprintf(device, sizeof(device), "/dev/usb/lp%d", i);
 226
 227       if ((fd = open(device, O_RDWR | O_EXCL)) < 0)
 228       {
 229         if (errno != ENOENT)
 230           continue;
 231
 232         snprintf(device, sizeof(device), "/dev/usb/usblp%d", i);
 233
 234         if ((fd = open(device, O_RDWR | O_EXCL)) < 0)
 235           continue;
 236       }
 237     }
 238
 239     if (!backendGetDeviceID(fd, device_id, sizeof(device_id),
 240                             make_model, sizeof(make_model),
 241                             "usb", device_uri, sizeof(device_uri)))
 242       cupsBackendReport("direct", device_uri, make_model, make_model,
 243                         device_id, NULL);
 244
 245     close(fd);
 246   }
 247 #elif defined(__sun) && defined(ECPPIOC_GETDEVID)
 248   int   i;                      /* Looping var */
 249   int   fd;                     /* File descriptor */
 250   char  device[255],            /* Device filename */
 251         device_id[1024],        /* Device ID string */
 252         device_uri[1024],       /* Device URI string */
 253         make_model[1024];       /* Make and model */
 254
 255
 256  /*
 257   * Open each USB device...
 258   */
 259
 260   for (i = 0; i < 8; i ++)
 261   {
 262     snprintf(device, sizeof(device), "/dev/usb/printer%d", i);
 263
 264     if ((fd = open(device, O_WRONLY | O_EXCL)) >= 0)
 265     {
 266       if (!backendGetDeviceID(fd, device_id, sizeof(device_id),
 267                               make_model, sizeof(make_model),
 268                               "usb", device_uri, sizeof(device_uri)))
 269         cupsBackendReport("direct", device_uri, make_model, make_model,
 270                           device_id, NULL);
 271
 272       close(fd);
 273     }
 274   }
 275 #elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) || defined(__FreeBSD_kernel__)
 276   int   i;                      /* Looping var */
 277   char  device[255];            /* Device filename */
 278
 279
 280   for (i = 0; i < 8; i ++)
 281   {
 282     snprintf(device, sizeof(device), "/dev/ulpt%d", i);
 283     if (!access(device, 0))
 284       printf("direct usb:%s \"Unknown\" \"USB Printer #%d\"\n", device, i + 1);
 285
 286     snprintf(device, sizeof(device), "/dev/unlpt%d", i);
 287     if (!access(device, 0))
 288       printf("direct usb:%s \"Unknown\" \"USB Printer #%d (no reset)\"\n", device, i + 1);
 289   }
 290 #endif
 291 }
 292
 293
 294 /*
 295  * 'open_device()' - Open a USB device...
 296  */
 297
 298 static int                              /* O - File descriptor or -1 on error */
 299 open_device(const char *uri,            /* I - Device URI */
 300             int        *use_bc)         /* O - Set to 0 for unidirectional */
 301 {
 302   int   fd;                             /* File descriptor */
 303
 304
 305  /*
 306   * The generic implementation just treats the URI as a device filename...
 307   * Specific operating systems may also support using the device serial
 308   * number and/or make/model.
 309   */
 310
 311   if (!strncmp(uri, "usb:/dev/", 9))
 312 #ifdef __linux
 313   {
 314    /*
 315     * Do not allow direct devices anymore...
 316     */
 317
 318     errno = ENODEV;
 319     return (-1);
 320   }
 321   else if (!strncmp(uri, "usb://", 6))
 322   {
 323    /*
 324     * For Linux, try looking up the device serial number or model...
 325     */
 326
 327     int         i;                      /* Looping var */
 328     int         busy;                   /* Are any ports busy? */
 329     char        device[255],            /* Device filename */
 330                 device_id[1024],        /* Device ID string */
 331                 make_model[1024],       /* Make and model */
 332                 device_uri[1024];       /* Device URI string */
 333
 334
 335    /*
 336     * Find the correct USB device...
 337     */
 338
 339     for (;;)
 340     {
 341       for (busy = 0, i = 0; i < 16; i ++)
 342       {
 343        /*
 344         * Linux has a long history of changing the standard filenames used
 345         * for USB printer devices.  We get the honor of trying them all...
 346         */
 347
 348         snprintf(device, sizeof(device), "/dev/usblp%d", i);
 349
 350         if ((fd = open(device, O_RDWR | O_EXCL)) < 0 && errno == ENOENT)
 351         {
 352           snprintf(device, sizeof(device), "/dev/usb/lp%d", i);
 353
 354           if ((fd = open(device, O_RDWR | O_EXCL)) < 0 && errno == ENOENT)
 355           {
 356             snprintf(device, sizeof(device), "/dev/usb/usblp%d", i);
 357
 358             if ((fd = open(device, O_RDWR | O_EXCL)) < 0 && errno == ENOENT)
 359               continue;
 360           }
 361         }
 362
 363         if (fd >= 0)
 364         {
 365           backendGetDeviceID(fd, device_id, sizeof(device_id),
 366                              make_model, sizeof(make_model),
 367                              "usb", device_uri, sizeof(device_uri));
 368         }
 369         else
 370         {
 371          /*
 372           * If the open failed because it was busy, flag it so we retry
 373           * as needed...
 374           */
 375
 376           if (errno == EBUSY)
 377             busy = 1;
 378
 379           device_uri[0] = '\0';
 380         }
 381
 382         if (!strcmp(uri, device_uri))
 383         {
 384          /*
 385           * Yes, return this file descriptor...
 386           */
 387
 388           fprintf(stderr, "DEBUG: Printer using device file \"%s\"...\n",
 389                   device);
 390
 391           return (fd);
 392         }
 393
 394        /*
 395         * This wasn't the one...
 396         */
 397
 398         if (fd >= 0)
 399           close(fd);
 400       }
 401
 402      /*
 403       * If we get here and at least one of the printer ports showed up
 404       * as "busy", then sleep for a bit and retry...
 405       */
 406
 407       if (busy)
 408         _cupsLangPrintFilter(stderr, "INFO", _("The printer is in use."));
 409
 410       sleep(5);
 411     }
 412   }
 413 #elif defined(__sun) && defined(ECPPIOC_GETDEVID)
 414   {
 415    /*
 416     * Do not allow direct devices anymore...
 417     */
 418
 419     errno = ENODEV;
 420     return (-1);
 421   }
 422   else if (!strncmp(uri, "usb://", 6))
 423   {
 424    /*
 425     * For Solaris, try looking up the device serial number or model...
 426     */
 427
 428     int         i;                      /* Looping var */
 429     int         busy;                   /* Are any ports busy? */
 430     char        device[255],            /* Device filename */
 431                 device_id[1024],        /* Device ID string */
 432                 make_model[1024],       /* Make and model */
 433                 device_uri[1024];       /* Device URI string */
 434
 435
 436    /*
 437     * Find the correct USB device...
 438     */
 439
 440     do
 441     {
 442       for (i = 0, busy = 0; i < 8; i ++)
 443       {
 444         snprintf(device, sizeof(device), "/dev/usb/printer%d", i);
 445
 446         if ((fd = open(device, O_WRONLY | O_EXCL)) >= 0)
 447           backendGetDeviceID(fd, device_id, sizeof(device_id),
 448                              make_model, sizeof(make_model),
 449                              "usb", device_uri, sizeof(device_uri));
 450         else
 451         {
 452          /*
 453           * If the open failed because it was busy, flag it so we retry
 454           * as needed...
 455           */
 456
 457           if (errno == EBUSY)
 458             busy = 1;
 459
 460           device_uri[0] = '\0';
 461         }
 462
 463         if (!strcmp(uri, device_uri))
 464         {
 465          /*
 466           * Yes, return this file descriptor...
 467           */
 468
 469           fputs("DEBUG: Setting use_bc to 0!\n", stderr);
 470
 471           *use_bc = 0;
 472
 473           return (fd);
 474         }
 475
 476        /*
 477         * This wasn't the one...
 478         */
 479
 480         if (fd >= 0)
 481           close(fd);
 482       }
 483
 484      /*
 485       * If we get here and at least one of the printer ports showed up
 486       * as "busy", then sleep for a bit and retry...
 487       */
 488
 489       if (busy)
 490       {
 491         _cupsLangPrintFilter(stderr, "INFO", _("The printer is in use."));
 492         sleep(5);
 493       }
 494     }
 495     while (busy);
 496
 497    /*
 498     * Couldn't find the printer, return "no such device or address"...
 499     */
 500
 501     errno = ENODEV;
 502
 503     return (-1);
 504   }
 505 #else
 506   {
 507     if (*use_bc)
 508       fd = open(uri + 4, O_RDWR | O_EXCL);
 509     else
 510       fd = -1;
 511
 512     if (fd < 0)
 513     {
 514       fd      = open(uri + 4, O_WRONLY | O_EXCL);
 515       *use_bc = 0;
 516     }
 517
 518     return (fd);
 519   }
 520 #endif /* __linux */
 521   else
 522   {
 523     errno = ENODEV;
 524     return (-1);
 525   }
 526 }
 527
 528
 529 /*
 530  * 'side_cb()' - Handle side-channel requests...
 531  */
 532
 533 static int                              /* O - 0 on success, -1 on error */
 534 side_cb(int         print_fd,           /* I - Print file */
 535         int         device_fd,          /* I - Device file */
 536         int         snmp_fd,            /* I - SNMP socket (unused) */
 537         http_addr_t *addr,              /* I - Device address (unused) */
 538         int         use_bc)             /* I - Using back-channel? */
 539 {
 540   cups_sc_command_t     command;        /* Request command */
 541   cups_sc_status_t      status;         /* Request/response status */
 542   char                  data[2048];     /* Request/response data */
 543   int                   datalen;        /* Request/response data size */
 544
 545
 546   (void)snmp_fd;
 547   (void)addr;
 548
 549   datalen = sizeof(data);
 550
 551   if (cupsSideChannelRead(&command, &status, data, &datalen, 1.0))
 552     return (-1);
 553
 554   switch (command)
 555   {
 556     case CUPS_SC_CMD_DRAIN_OUTPUT :
 557         if (backendDrainOutput(print_fd, device_fd))
 558           status = CUPS_SC_STATUS_IO_ERROR;
 559         else if (tcdrain(device_fd))
 560           status = CUPS_SC_STATUS_IO_ERROR;
 561         else
 562           status = CUPS_SC_STATUS_OK;
 563
 564         datalen = 0;
 565         break;
 566
 567     case CUPS_SC_CMD_GET_BIDI :
 568         status  = CUPS_SC_STATUS_OK;
 569         data[0] = use_bc;
 570         datalen = 1;
 571         break;
 572
 573     case CUPS_SC_CMD_GET_DEVICE_ID :
 574         memset(data, 0, sizeof(data));
 575
 576         if (backendGetDeviceID(device_fd, data, sizeof(data) - 1,
 577                                NULL, 0, NULL, NULL, 0))
 578         {
 579           status  = CUPS_SC_STATUS_NOT_IMPLEMENTED;
 580           datalen = 0;
 581         }
 582         else
 583         {
 584           status  = CUPS_SC_STATUS_OK;
 585           datalen = strlen(data);
 586         }
 587         break;
 588
 589     default :
 590         status  = CUPS_SC_STATUS_NOT_IMPLEMENTED;
 591         datalen = 0;
 592         break;
 593   }
 594
 595   return (cupsSideChannelWrite(command, status, data, datalen, 1.0));
 596 }