← Back to branch summary

~ubuntu-branches/ubuntu/utopic/cups/utopic

« back to all changes in this revision

Viewing changes to .pc/prevent-USB-timeouts-causing-incorrect-print-output.patch/backend/usb-libusb.c

  • Committer: Package Import Robot
  • Author(s): Didier Raboud, Till Kamppeter, Steve Langasek, Didier Raboud
  • Date: 2014-01-03 18:42:39 UTC
  • mfrom: (99.2.3 sid)
  • Revision ID: package-import@ubuntu.com-20140103184239-85wju2l7weie4dgo
Tags: 1.7.0-1
https://launchpad.net/bugs/1157972
https://launchpad.net/bugs/1229766
http://bugs.debian.org/731608
* New 1.7.0 upstream release

[ Till Kamppeter ]
* Refresh most patches with quilt
* Removed usb-backend-do-not-crash-if-usb-disabled-in-bios and
  cupsd-no-crash-on-avahi-threaded-poll-shutdown patches as they got
  applied upstream
* Removed drop-arch-specifics-from-doc patch as it is not needed
  anymore
* Updated drop_unnecessary_dependencies, manpage-hyphen-minus,
  manpage-translations and ppd-poll-with-client-conf patches manually
  to apply to the new CUPS version
* Added error counting exception from
  usb-backend-do-not-crash-if-usb-disabled-in-bios to
  tests-ignore-warnings
* Install the newly added ippfind utility and its manpage in
  cups-client
* Added pwg.h to libcups2-dev package
* Call dh_auto_clean only if the file Makedefs is present, to avoid a
  FTBFS
* Added color management extensions from Joe Simon's GSoC 2013
  project.
* Patch cups-files.conf to activate CUPS daemon syncing of files when
  closing, so that config files (like printers.conf) do not
  mysteriously disappear (LP: #1157972)
* In the AppArmor profile, allow execution of programs in
  /etc/cups/interfaces/, needed to make CUPS working with queues based
  on System V interface scripts, especially PPD-less queues
  auto-generated by cups-browsed from cups-filters 1.0.41 on.
* Silenced AppArmor noise from udev.conf in syslog (LP: #1229766)

[ Steve Langasek ]
* Add cups-filters (>= 1.0.42) as alternative to foomatic-filters
  (which is deprecated) in package relationships

[ Didier Raboud ]
* Remove Roger Leigh from uploaders on his request with thanks for his
  past work!
* Switch avahi LSB Should-Start dependency to be avahi-daemon; also
  bump package relationship to >= 0.6.31-3~ (Closes: #731608)
* Refresh the manpage translation files
* Move the USB backend quirk rules file to cups-server-common
* Add 38 new 1.7.0 libcups2 symbols
* Mark one C++ libcupsppdc1 symbol as optional as it isn't exported in
  1.7.0 anymore
* Import Fedora patches:
  - to avoid sign-extending CRCs in gz decompression
  - to build with full read-only relocations
  - to fix job history logging (upstream patch)
  - to set the internal default for SyncOnClose to Yes, instead of
    only configuring it to Yes
  - to fix a stringpool corruption issue
  - to prevent USB timeouts causing incorrect print output
* Import Fedora patch updates:
  - to dont-use-dbus-from-two-threads patch so it removes a call to
    avahi_threaded_poll_stop()
  - to avoid_stale_lockfile_in_dbus_notifier patch to call _exit when
    handling SIGTERM
* Move manpage-translations patch at the very end of the patch series
  to have it include all our patches

Show diffs side-by-side

added added

removed removed

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