michaelrsweet commented 16 years ago

Version: 1.5-feature CUPS.org User: mike

Note: This may not end up in CUPS 1.4!

Currently the libusb-based USB backend does not support back-channel data. Unfortunately, the current "stable" libusb release does not support asynchronous I/O, and it is not clear whether multiple threads can be used to issue simultaneous reads and writes, which is what would be required to properly implement back-channel support. The new libusb branch is currently too unstable to use for development but does add support for asynchronous I/O.

A further complication is that many printers do not actually implement back-channel support properly - basically any read returns the 1284 device ID, which has serious performance implications and is why back-channel is disabled for so many vendors in the legacy UNIX character device implementation.

michaelrsweet commented 13 years ago

CUPS.org User: jhathaway

In the current release 1.5, is back-channel data unsupported on linux with libusb, pending this request?

michaelrsweet commented 13 years ago

CUPS.org User: mike

Jesse,

Yes.

michaelrsweet commented 12 years ago

CUPS.org User: till.kamppeter

I have now added backchannel/bi-di functionality to the libusb-based USB CUPS backend for Linux. First I have ported the backend to libusb-1.0.x, to get an upstream-supported version of libusb and a more sophisticated API (http://www.cups.org/str.php?L3477 and patch attached there). Then I have taken this libusb-1.0.x-based backend and merged it with the libpthread-based multi-threading of the Darwin (Mac OS X) version of the backend (backend/usb-darwin.c), resulting in the attached replacement for backend/usb-libusb.c. The file and the patch can be used with both CUPS 1.5.x and 1.6.x, as from 1.5.x to 1.6.x the file backend/usb-libusb.c did not change. To test, simply apply the patch or replace the file and compile normally, taking care to build the libusb-based version of the USB backend.

To test, set up a PostScript printer with the USB backend and the Manufacturer-supplied PPD file. Make sure that the USB backend gets actually used, as automatic printer setup mechanisms will use HPLIP's "hp" backend for HP printers.

Now look for the option settings in a printer setup tool, especially the "Installed options" group. Do not adjust them to the printers actual state, or bring them into a wrong state if they are correct by accident. Close the printer setup tool.

Now run the command

echo -en '#CUPS-COMMAND\nAutoConfigure\n' | lpr -P

and wait for the job to finish (printer stops blinking, queue empty).

Look into the option settings in your printer setup tool again. Now they should be set to the printer's current state.

The command line sends a command file into the print queue. CUPS recognizes the input as a command file and runs the command execution driver for PostScript printers (commandtops) which sends PostScript query commands to the printer. The printer answers them and thanks to the new bi-directional USB backend the answers get back to the driver and the driver tells the CUPS daemon how to set the option.

Before, this worked only either with network-connected printers or with the USB backend when built for the usblp kernel module. Now the usblp kernel module can really get retired.

Note: Command execution on PostScript printers does not work with CUPS 1.5.0 due to a bug. 1.5.1 or newer is required (or a current snapshot of CUPS 1.6.x).

michaelrsweet commented 12 years ago

CUPS.org User: mike

Fixed in Subversion repository.

Changes will also show up in the next 1.5.x release.

michaelrsweet commented 12 years ago

CUPS.org User: till.kamppeter

Mike, can you also change the build system so that the libusb-based "usb" backend will get built by default?

The libusb-based backend has once more functionality, especially bi-di works with all printers, without any manufacturer-wise restrictions, and second, it works also in systems with usblp module present, as it detaches the module from the printer before communicating and reattaches the module after finishing the communication. This means that it always "just works". The usblp-based backend is now only a fallback solution for systems without libusb.

michaelrsweet commented 12 years ago

CUPS.org User: mike

Till, I thought we already preferred libusb over the character device stuff, but I'll double-check and update as needed...

michaelrsweet commented 12 years ago

CUPS.org User: mike

OK, the logic was backwards so I've updated the configure script to use libusb by default unless we are running Mac OS X.

michaelrsweet commented 12 years ago

"usb-backend-backchannel-support-1.5.x.patch":

--- backend/usb-libusb.c.orig 2012-02-05 23:07:15.454577212 +0100 +++ backend/usb-libusb.c 2012-02-08 22:17:59.782785873 +0100 @@ -13,26 +13,53 @@ *

Contents: *
- * list_devices() - List the available printers.
- * print_device() - Print a file to a USB device.
- * close_device() - Close the connection to the USB printer.
- * find_device() - Find or enumerate USB printers.
- * get_device_id() - Get the IEEE-1284 device ID for the printer.
- * list_cb() - List USB printers for discovery.
- * make_device_uri() - Create a device URI for a USB printer.
- * open_device() - Open a connection to the USB printer.
- * print_cb() - Find a USB printer for printing.
- * side_cb() - Handle side-channel requests.
- * list_devices() - List the available printers.
- * print_device() - Print a file to a USB device.
- * read_thread() - Thread to read the backchannel data on.
- * sidechannel_thread() - Handle side-channel requests.
- * close_device() - Close the connection to the USB printer.
- * find_device() - Find or enumerate USB printers.
- * get_device_id() - Get the IEEE-1284 device ID for the printer.
- * list_cb() - List USB printers for discovery.
- * make_device_uri() - Create a device URI for a USB printer.
- * open_device() - Open a connection to the USB printer.
- * print_cb() - Find a USB printer for printing.
- * soft_reset() - Send a soft reset to the device.
- * next_line() - Find the next line in a buffer.
- * parse_pserror() - Scan the backchannel data for postscript errors. */
/*
Include necessary headers... */

-#include -#include +#include

include <cups/cups-private.h>

+#include +#include <sys/select.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <sys/time.h> +#include

+#define PARSE_PS_ERRORS 1 + +/*

* DEBUG_WRITES, if defined, causes the backend to write data to the printer in
* 512 byte increments, up to 8192 bytes, to make debugging with a USB bus
* analyzer easier.
_/ + +#define DEBUGWRITES 0 + +/
* WAIT_EOF_DELAY is number of seconds we'll wait for responses from
* the printer after we've finished sending all the data
*/ +#define WAIT_EOF 0 +#define WAIT_EOF_DELAY 7 +#define WAIT_SIDE_DELAY 3 +#define DEFAULT_TIMEOUT 5000L

/*
- Local types... @@ -40,23 +67,64 @@
typedef struct usb_printer_s /\ USB Printer Data **/ {
struct usb_device device; / Device info */
struct libusb_device device; / Device info / int conf, / Configuration / iface, / Interface / altset, / Alternate setting _/ writeendp, / Write endpoint */
read_endp; /* Read endpoint */
struct usb_dev_handle handle; / Open handle to device */
read_endp, /* Read endpoint */
protocol, /* Protocol: 1 = Uni-di, 2 = Bi-di. */
usblp_attached; /* Is the "usblp" kernel module
attached? */
struct libusb_device_handle handle; / Open handle to device */ } usb_printer_t;

typedef int (usb_cb_t)(usb_printer_t , const char , const char , const void *);

+typedef struct globals_s +{

usb_printer_t printer; / Printer */ +
pthread_mutex_t read_thread_mutex;
pthread_cond_t read_thread_cond;
int read_thread_stop;
int read_thread_done; +
pthread_mutex_t readwrite_lock_mutex;
pthread_cond_t readwrite_lock_cond;
int readwrite_lock; +
int print_fd; /* File descriptor to print */
ssize_t print_bytes; /* Print bytes read */ +#if DEBUG_WRITES
ssize_t debugbytes; /* Current bytes to read / +#endif /_ DEBUG_WRITES */ +
int wait_eof;
int drain_output; /* Drain all pending output */
int bidi_flag; /* 0=unidirectional, 1=bidirectional */ +
pthread_mutex_t sidechannel_thread_mutex;
pthread_cond_t sidechannel_thread_cond;
int sidechannel_thread_stop;
int sidechannel_thread_done; +} globals_t; + + +/*
* Globals...
_/ + +globalst g = { 0 }; / Globals _/ +libusb_device _list; /* List of connected USB devices /

/*
- Local functions... */

+static void _read_thread(void reference); +static void sidechannel_thread(void reference); static int close_device(usb_printer_t printer); static usb_printer_t find_device(usb_cb_t cb, const void data); static int get_device_id(usb_printer_t printer, char buffer, @@ -69,7 +137,11 @@ static int open_device(usb_printer_t printer, int verbose); static int print_cb(usb_printer_t printer, const char device_uri, const char device_id, const void data); -static ssize_t side_cb(usb_printer_t printer, int print_fd); +static void soft_reset(void); +#ifdef PARSE_PS_ERRORS +static const char next_line (const char buffer); +static void parsepserror (char *sockBuffer, int len); +#endif / PARSE_PS_ERRORS */

/ @@ -98,27 +170,47 @@ int argc, /* I - Number of command-line arguments (6 or 7) _/ char argv[]) /_ I - Command-line arguments */ {

usb_printer_t printer; / Printer */
ssize_t bytes, /* Bytes read/written */
tbytes; /* Total bytes written */
char buffer[512]; /* Print data buffer */
int bytes; /* Bytes written */
ssize_t totalbytes; /* Total bytes written / struct sigaction action; /_ Actions for POSIX signals */
struct pollfd pfds[2]; /* Poll descriptors */
int status = CUPS_BACKEND_OK, /* Function results */
iostatus; /* Current IO status */
pthread_t read_thread_id, /* Read thread */
sidechannel_thread_id; /* Side-channel thread */
int have_sidechannel = 0; /* Was the side-channel thread started? */
struct stat sidechannel_info; /* Side-channel file descriptor info */
unsigned char print_buffer[8192], /* Print data buffer */
_printptr; / Pointer into print data buffer */
fd_set input_set; /* Input set for select() */
int nfds; /* Number of file descriptors */
struct timeval timeout, / Timeout pointer */
tv; /* Time value */
struct timespec cond_timeout; /* pthread condition timeout */

fputs("DEBUG: print_device\n", stderr);

/*
* See if the side-channel descriptor is valid...
*/ +
have_sidechannel = !fstat(CUPS_SC_FD, &sidechannel_info) &&
S_ISSOCK(sidechannel_info.st_mode); +
g.wait_eof = WAIT_EOF; +
/*
- Connect to the printer... */
while ((printer = find_device(print_cb, uri)) == NULL)
while ((g.printer = find_device(print_cb, uri)) == NULL) { cupsLangPrintFilter(stderr, "INFO", ("Waiting for printer to become available.")); sleep(5); }
g.print_fd = print_fd;

/*
- If we are printing data from a print driver on stdin, ignore SIGTERM @@ -127,7 +219,7 @@
- is no way to cancel a raw print job... */
if (!print_fd)
if (print_fd) { memset(&action, 0, sizeof(action));

@@ -136,74 +228,609 @@ sigaction(SIGTERM, &action, NULL); }

tbytes = 0;
/*
* Start the side channel thread if the descriptor is valid...
*/ +
pthread_mutex_init(&g.readwrite_lock_mutex, NULL);
pthread_cond_init(&g.readwrite_lock_cond, NULL);
g.readwrite_lock = 1; +
if (have_sidechannel)
{
g.sidechannel_thread_stop = 0;
g.sidechannel_thread_done = 0; +
pthread_cond_init(&g.sidechannel_thread_cond, NULL);
pthread_mutex_init(&g.sidechannel_thread_mutex, NULL); +
if (pthread_create(&sidechannel_thread_id, NULL, sidechannel_thread, NULL))
{
fprintf(stderr, "DEBUG: Fatal USB error.\n");
_cupsLangPrintFilter(stderr, "ERROR",
_("There was an unrecoverable USB error."));
fputs("DEBUG: Couldn't create side-channel thread\n", stderr);
close_device(g.printer);
return (CUPS_BACKEND_STOP);
}
} +
/*
* Get the read thread going...
*/ +
g.read_thread_stop = 0;
g.read_thread_done = 0; +
pthread_cond_init(&g.read_thread_cond, NULL);
pthread_mutex_init(&g.read_thread_mutex, NULL); +
if (pthread_create(&read_thread_id, NULL, read_thread, NULL))
{
fprintf(stderr, "DEBUG: Fatal USB error.\n");
_cupsLangPrintFilter(stderr, "ERROR",
_("There was an unrecoverable USB error."));
fputs("DEBUG: Couldn't create read thread\n", stderr);
close_device(g.printer);
return (CUPS_BACKEND_STOP);
} +
/*
* The main thread sends the print file...
*/
pfds[0].fd = print_fd;
pfds[0].events = POLLIN;
pfds[1].fd = CUPS_SC_FD;
pfds[1].events = POLLIN;
g.drain_output = 0;
g.print_bytes = 0;
total_bytes = 0;
print_ptr = print_buffer;
while (copies > 0 && tbytes >= 0)
while (status == CUPS_BACKEND_OK && copies-- > 0) {
copies --;
cupsLangPrintFilter(stderr, "INFO", ("Sending data to printer."));
if (print_fd != 0)
if (print_fd != STDIN_FILENO) { fputs("PAGE: 1 1\n", stderr); lseek(print_fd, 0, SEEK_SET); }
/*
* TODO: Add back-channel support, along with better write error handling.

- */

while (poll(pfds, 2, -1) > 0)
while (status == CUPS_BACKEND_OK) {
FD_ZERO(&input_set); +
if (!g.print_bytes)
FD_SET(print_fd, &input_set); +
/*
* Calculate select timeout...
* If we have data waiting to send timeout is 100ms.
* else if we're draining print_fd timeout is 0.
* else we're waiting forever...
*/ +
if (g.print_bytes)
{
tv.tv_sec = 0;
tv.tv_usec = 100000; /* 100ms */
timeout = &tv;
}
else if (g.drain_output)
{
tv.tv_sec = 0;
tv.tv_usec = 0;
timeout = &tv;
}
else
timeout = NULL; +
/*
* I/O is unlocked around select...
*/ +
pthread_mutex_lock(&g.readwrite_lock_mutex);
g.readwrite_lock = 0;
pthread_cond_signal(&g.readwrite_lock_cond);
pthread_mutex_unlock(&g.readwrite_lock_mutex); +
nfds = select(print_fd + 1, &input_set, NULL, NULL, timeout); + /*
* CUPS STR #3318: USB process hangs on end-of-file, making further
* printing impossible
*
* From a strict interpretation of POSIX poll(), POLLHUP should never be
* set without POLLIN, since POLLIN is the event you request. That said,
* it appears that some versions of Linux break this.
```
* Reacquire the lock...
```
*/

if (pfds[0].revents & (POLLIN | POLLHUP))

pthread_mutex_lock(&g.readwrite_lock_mutex);
while (g.readwrite_lock)
pthread_cond_wait(&g.readwrite_lock_cond, &g.readwrite_lock_mutex);
g.readwrite_lock = 1;
pthread_mutex_unlock(&g.readwrite_lock_mutex); +
if (nfds < 0) {
if ((bytes = read(print_fd, buffer, sizeof(buffer))) > 0)
if (errno == EINTR && total_bytes == 0)
{
fputs("DEBUG: Received an interrupt before any bytes were "
"written, aborting\n", stderr);
close_device(g.printer);
return (CUPS_BACKEND_OK);
}
else if (errno != EAGAIN && errno != EINTR) {
if (usb_bulk_write(printer->handle, printer->write_endp, buffer,
bytes, 3600000) < 0)
_cupsLangPrintFilter(stderr, "ERROR",
_("Unable to read print data."));
perror("DEBUG: select");
close_device(g.printer);
return (CUPS_BACKEND_FAILED);
}
} +
/*
* If drain output has finished send a response...
*/ +
if (g.drain_output && !nfds && !g.print_bytes)
{
/* Send a response... */
cupsSideChannelWrite(CUPS_SC_CMD_DRAIN_OUTPUT, CUPS_SC_STATUS_OK, NULL, 0, 1.0);
g.drain_output = 0;
} +
/*
* Check if we have print data ready...
*/ +
if (FD_ISSET(print_fd, &input_set))
{ +#if DEBUG_WRITES
g.debug_bytes += 512;
if (g.debug_bytes > sizeof(print_buffer))
g.debug_bytes = 512; +
g.print_bytes = read(print_fd, print_buffer, g.debug_bytes); + +#else
g.print_bytes = read(print_fd, print_buffer, sizeof(print_buffer)); +#endif /* DEBUG_WRITES */ +
if (g.print_bytes < 0)
{
/*
* Read error - bail if we don't see EAGAIN or EINTR...
*/ +
if (errno != EAGAIN && errno != EINTR) { _cupsLangPrintFilter(stderr, "ERROR",
_("Unable to send data to printer."));
tbytes = -1;
break;
_("Unable to read print data."));
perror("DEBUG: read");
close_device(g.printer);
```
return (CUPS_BACKEND_FAILED);
```
}
```
tbytes += bytes;
```
g.print_bytes = 0;
}
else if (g.print_bytes == 0)
{
/*
* End of file, break out of the loop...
*/ +
break;
} +
print_ptr = print_buffer; +
fprintf(stderr, "DEBUG: Read %d bytes of print data...\n",
(int)g.print_bytes);
} +
if (g.print_bytes)
{
iostatus = libusb_bulk_transfer(g.printer->handle,
g.printer->write_endp,
print_buffer, g.print_bytes,
&bytes, 60000);
/*
* Ignore timeout errors, but retain the number of bytes written to
* avoid sending duplicate data (rdar://problem/6254911)...
*/ +
if (iostatus == LIBUSB_ERROR_TIMEOUT)
{
fputs("DEBUG: Got USB transaction timeout during write\n", stderr);
iostatus = 0; }
else if (bytes == 0 || (bytes < 0 && errno != EAGAIN && errno != EINTR)) +
/*
* If we've stalled, retry the write...
*/ +
else if (iostatus == LIBUSB_ERROR_PIPE)
{
fputs("DEBUG: Got USB pipe stalled during write\n", stderr); +
iostatus = libusb_bulk_transfer(g.printer->handle,
g.printer->write_endp,
print_buffer, g.print_bytes,
&bytes, 60000);
} +
/*
* Retry a write after an aborted write since we probably just got
* SIGTERM ...
*/ +
else if (iostatus == LIBUSB_ERROR_INTERRUPTED)
{
fputs("DEBUG: Got USB return aborted during write\n", stderr); + +#if DEBUG_WRITES
sleep(5); +#endif /* DEBUG_WRITES */ +
iostatus = libusb_bulk_transfer(g.printer->handle,
g.printer->write_endp,
print_buffer, g.print_bytes,
&bytes, 60000);
} +
if (iostatus)
{
/*
* Write error - bail if we don't see an error we can retry...
*/ +
_cupsLangPrintFilter(stderr, "ERROR",
_("Unable to send data to printer."));
fprintf(stderr, "DEBUG: libusb write operation returned %x\n",
iostatus); +
status = CUPS_BACKEND_FAILED; break;
}
else if (bytes > 0)
{
fprintf(stderr, "DEBUG: Wrote %d bytes of print data...\n", (int)bytes); +
g.print_bytes -= bytes;
print_ptr += bytes;
total_bytes += bytes;
} }

if (pfds[1].revents & (POLLIN | POLLHUP))

if (print_fd != 0 && status == CUPS_BACKEND_OK)
fprintf(stderr, "DEBUG: Sending print file, %lld bytes...\n",
(long long int)total_bytes);
}
} +
fprintf(stderr, "DEBUG: Sent %lld bytes...\n", (long long int)total_bytes); +
/*
* Signal the side channel thread to exit...
*/ +
if (have_sidechannel)
{
close(CUPS_SC_FD);
pthread_mutex_lock(&g.readwrite_lock_mutex);
g.readwrite_lock = 0;
pthread_cond_signal(&g.readwrite_lock_cond);
pthread_mutex_unlock(&g.readwrite_lock_mutex); +
g.sidechannel_thread_stop = 1;
pthread_mutex_lock(&g.sidechannel_thread_mutex); +
if (!g.sidechannel_thread_done)
{
gettimeofday(&tv, NULL);
cond_timeout.tv_sec = tv.tv_sec + WAIT_SIDE_DELAY;
cond_timeout.tv_nsec = tv.tv_usec * 1000; +
while (!g.sidechannel_thread_done) {
if ((bytes = side_cb(printer, print_fd)) < 0)
pfds[1].events = 0; /* Filter has gone away... */
else
tbytes += bytes;
if (pthread_cond_timedwait(&g.sidechannel_thread_cond,
&g.sidechannel_thread_mutex,
&cond_timeout) != 0)
break; } } +
pthread_mutex_unlock(&g.sidechannel_thread_mutex); }

/*
* Close our connection and return...
* Signal the read thread to exit then wait 7 seconds for it to complete...
*/ +
g.read_thread_stop = 1; +
pthread_mutex_lock(&g.read_thread_mutex); +
if (!g.read_thread_done)
{
fputs("DEBUG: Waiting for read thread to exit...\n", stderr); +
gettimeofday(&tv, NULL);
cond_timeout.tv_sec = tv.tv_sec + WAIT_EOF_DELAY;
cond_timeout.tv_nsec = tv.tv_usec * 1000; +
while (!g.read_thread_done)
{
if (pthread_cond_timedwait(&g.read_thread_cond, &g.read_thread_mutex,
&cond_timeout) != 0)
break;
} +
/*
* If it didn't exit abort the pending read and wait an additional second...
*/
if (!g.read_thread_done)
{
fputs("DEBUG: Read thread still active, aborting the pending read...\n",
stderr); +
g.wait_eof = 0; +
gettimeofday(&tv, NULL);
cond_timeout.tv_sec = tv.tv_sec + 1;
cond_timeout.tv_nsec = tv.tv_usec * 1000;
while (!g.read_thread_done)
{
if (pthread_cond_timedwait(&g.read_thread_cond, &g.read_thread_mutex,
&cond_timeout) != 0)
break;
}
}
} +
pthread_mutex_unlock(&g.read_thread_mutex); +
if (print_fd != STDIN_FILENO)
close(print_fd); +
/*
* Close the connection and input file and general clean up...
*/ +
close_device(g.printer); +
/*
* Clean up ....
*/ +
libusb_free_device_list(list, 1);
libusb_exit(NULL); +
return status; +} + + +/*
* 'read_thread()' - Thread to read the backchannel data on.
/ + +static void read_thread(void *reference) +{
unsigned char readbuffer[512];
int rbytes;
int readstatus;
struct timeval now,
delay,
end,
timeleft; + +
(void)reference; +
/*
* Read frequency: Once every 250 milliSeconds
*/
delay.tv_sec = 0;
delay.tv_usec = 250000; +
do
{
/*
* Remember when we started so we can throttle the loop after the read
* call...
*/
gettimeofday(&now, NULL); +
/*
* Calculate what 250 milliSeconds are in absolute time...
*/
timeradd(&now, &delay, &end); +
rbytes = sizeof(readbuffer);
readstatus = libusb_bulk_transfer(g.printer->handle,
g.printer->read_endp,
readbuffer, rbytes,
&rbytes, 60000);
if (readstatus == LIBUSB_SUCCESS && rbytes > 0)
{
fprintf(stderr, "DEBUG: Read %d bytes of back-channel data...\n",
(int)rbytes);
cupsBackChannelWrite((const char *)readbuffer, rbytes, 1.0); + +#ifdef PARSE_PS_ERRORS
parse_pserror((char *)readbuffer, rbytes); +#endif +
/* cntrl-d is echoed by the printer.
* NOTES:
* Xerox Phaser 6250D doesn't echo the cntrl-d.
* Xerox Phaser 6250D doesn't always send the product query.
*/
if (g.wait_eof && readbuffer[rbytes-1] == 0x4)
break;
}
else if (readstatus == LIBUSB_ERROR_TIMEOUT)
fputs("DEBUG: Got USB transaction timeout during read\n", stderr);
else if (readstatus == LIBUSB_ERROR_PIPE)
fputs("DEBUG: Got USB pipe stalled during read\n", stderr);
else if (readstatus == LIBUSB_ERROR_INTERRUPTED)
fputs("DEBUG: Got USB return aborted during read\n", stderr); +
/*
* Make sure this loop executes no more than once every 250 miliseconds...
*/ +
if ((readstatus != LIBUSB_SUCCESS || rbytes == 0) && (g.wait_eof || !g.read_thread_stop))
{
gettimeofday(&now, NULL);
if (timercmp(&now, &end, <))
{
timersub(&end, &now, &timeleft);
usleep(1000000 * timeleft.tv_sec + timeleft.tv_usec);
}
}
} while (g.wait_eof || !g.read_thread_stop); /* Abort from main thread tests error here */ +
/*
- Let the main thread know that we have completed the read thread... */
close_device(printer);
pthread_mutex_lock(&g.read_thread_mutex);
g.read_thread_done = 1;
pthread_cond_signal(&g.read_thread_cond);
pthread_mutex_unlock(&g.read_thread_mutex);
return (CUPS_BACKEND_OK);
return NULL; +} + + +/*
* 'sidechannel_thread()' - Handle side-channel requests.
/ + +static void +sidechannel_thread(void *reference) +{
cups_sc_command_t command; /* Request command */
cups_sc_status_t status; /* Request/response status */
char data[2048]; /* Request/response data */
int datalen; /* Request/response data size */ + +
(void)reference; +
do
{
datalen = sizeof(data); +
if (cupsSideChannelRead(&command, &status, data, &datalen, 1.0))
{
if (status == CUPS_SC_STATUS_TIMEOUT)
continue;
else
break;
} +
switch (command)
{
case CUPS_SC_CMD_SOFT_RESET: /* Do a soft reset */
fputs("DEBUG: CUPS_SC_CMD_SOFT_RESET received from driver...\n",
stderr); +
soft_reset();
cupsSideChannelWrite(command, CUPS_SC_STATUS_OK, NULL, 0, 1.0);
fputs("DEBUG: Returning status CUPS_STATUS_OK with no bytes...\n",
stderr);
break; +
case CUPS_SC_CMD_DRAIN_OUTPUT: /* Drain all pending output */
fputs("DEBUG: CUPS_SC_CMD_DRAIN_OUTPUT received from driver...\n",
stderr); +
g.drain_output = 1;
break; +
case CUPS_SC_CMD_GET_BIDI: /* Is the connection bidirectional? */
fputs("DEBUG: CUPS_SC_CMD_GET_BIDI received from driver...\n",
stderr); +
data[0] = (g.printer->protocol >= 2 ? 1 : 0);
cupsSideChannelWrite(command, CUPS_SC_STATUS_OK, data, 1, 1.0); +
fprintf(stderr,
"DEBUG: Returned CUPS_SC_STATUS_OK with 1 byte (%02X)...\n",
data[0]);
break; +
case CUPS_SC_CMD_GET_DEVICE_ID: /* Return IEEE-1284 device ID */
fputs("DEBUG: CUPS_SC_CMD_GET_DEVICE_ID received from driver...\n",
stderr); +
datalen = sizeof(data);
if (get_device_id(g.printer, data, sizeof(data)))
{
status = CUPS_SC_STATUS_IO_ERROR;
datalen = 0;
}
else
{
status = CUPS_SC_STATUS_OK;
datalen = strlen(data);
}
cupsSideChannelWrite(command, CUPS_SC_STATUS_OK, data, datalen, 1.0); +
if (datalen < sizeof(data))
data[datalen] = '\0';
else
data[sizeof(data) - 1] = '\0'; +
fprintf(stderr,
"DEBUG: Returning CUPS_SC_STATUS_OK with %d bytes (%s)...\n",
datalen, data);
break; +
case CUPS_SC_CMD_GET_STATE: /* Return device state */
fputs("DEBUG: CUPS_SC_CMD_GET_STATE received from driver...\n",
stderr); +
data[0] = CUPS_SC_STATE_ONLINE;
cupsSideChannelWrite(command, CUPS_SC_STATUS_OK, data, 1, 1.0); +
fprintf(stderr,
"DEBUG: Returned CUPS_SC_STATUS_OK with 1 byte (%02X)...\n",
data[0]);
break; +
case CUPS_SC_CMD_GET_CONNECTED: /* Return whether device is
connected */
fputs("DEBUG: CUPS_SC_CMD_GET_CONNECTED received from driver...\n",
stderr); +
data[0] = (g.printer->handle ? 1 : 0);
cupsSideChannelWrite(command, CUPS_SC_STATUS_OK, data, 1, 1.0); +
fprintf(stderr,
"DEBUG: Returned CUPS_SC_STATUS_OK with 1 byte (%02X)...\n",
data[0]);
break; +
default:
fprintf(stderr, "DEBUG: Unknown side-channel command (%d) received "
"from driver...\n", command); +
cupsSideChannelWrite(command, CUPS_SC_STATUS_NOT_IMPLEMENTED,
NULL, 0, 1.0); +
fputs("DEBUG: Returned CUPS_SC_STATUS_NOT_IMPLEMENTED with no bytes...\n",
stderr);
break;
}
}
while (!g.sidechannel_thread_stop); +
pthread_mutex_lock(&g.sidechannel_thread_mutex);
g.sidechannel_thread_done = 1;
pthread_cond_signal(&g.sidechannel_thread_cond);
pthread_mutex_unlock(&g.sidechannel_thread_mutex); +
return NULL; }

@@ -214,6 +841,11 @@ static int /* I - 0 on success, -1 on failure _/ close_device(usb_printert *printer) / I - Printer */ {

struct libusb_device_descriptor devdesc;
/* Current device descriptor */
struct libusb_config_descriptor *confptr;

                                 /* Pointer to current configuration */

+ if (printer->handle) { /* @@ -221,19 +853,30 @@

to the device... */

int number = printer->device->config[printer->conf].
interface[printer->iface].
altsetting[printer->altset].bInterfaceNumber;

- usb_release_interface(printer->handle, number);

libusb_get_device_descriptor (printer->device, &devdesc);
libusb_get_config_descriptor (printer->device, printer->conf, &confptr);
int number = confptr->interface[printer->iface].
altsetting[printer->altset].bInterfaceNumber;
libusb_release_interface(printer->handle, number); if (number != 0)
usb_release_interface(printer->handle, 0);
libusb_release_interface(printer->handle, 0); +
/*
* Re-attach "usblp" kernel module if it was attached before using this
* device
*/
if (printer->usblp_attached == 1)
if (libusb_attach_kernel_driver(printer->handle, printer->iface) < 0)
fprintf(stderr, "DEBUG: Failed to re-attach \"usblp\" kernel module to %04x:%04x\n",
devdesc.idVendor, devdesc.idProduct); +
libusb_free_config_descriptor(confptr);

/*
- Close the interface and return... */
usb_close(printer->handle);
libusb_close(printer->handle); printer->handle = NULL; }

@@ -249,15 +892,21 @@ find_device(usb_cbt cb, /* I - Callback function / const void data) /_ I - User data for callback / {

struct usb_bus bus; / Current bus */
struct usb_device device; / Current device */
struct usb_config_descriptor confptr;/ Pointer to current configuration */
struct usb_interface ifaceptr; / Pointer to current interface */
struct usb_interface_descriptor *altptr;
libusb_device list; / List of connected USB devices /
libusb_device device = NULL; / Current device */
struct libusb_device_descriptor devdesc;
/* Current device descriptor */
struct libusb_config_descriptor *confptr = NULL;
/* Pointer to current configuration */
const struct libusb_interface *ifaceptr = NULL;
/* Pointer to current interface */
const struct libusb_interface_descriptor altptr = NULL; / Pointer to current alternate setting */
struct usb_endpoint_descriptor *endpptr;
const struct libusb_endpoint_descriptor endpptr = NULL; / Pointer to current endpoint */
int conf, /* Current configuration */
ssize_t numdevs, /* number of connected devices */
i = 0;
uint8t conf, /* Current configuration / iface, / Current interface / altset, / Current alternate setting / protocol, /_ Current protocol */ @@ -274,29 +923,34 @@
- Initialize libusb... */
usb_init();
fprintf(stderr, "DEBUG: usb_find_busses=%d\n", usb_find_busses());
fprintf(stderr, "DEBUG: usb_find_devices=%d\n", usb_find_devices());
libusb_init(NULL);
numdevs = libusb_get_device_list(NULL, &list);
fprintf(stderr, "DEBUG: libusb_get_device_list=%d\n", (int)numdevs);

/*
- Then loop through the devices it found... */
for (bus = usb_get_busses(); bus; bus = bus->next)
for (device = bus->devices; device; device = device->next)
if (numdevs > 0)
for (i = 0; i < numdevs; i++) {
```
device = list[i];
```
+ /*
- Ignore devices with no configuration data and anything that is not
- a printer... */

if (!device->config || !device->descriptor.idVendor ||

!device->descriptor.idProduct)
libusb_get_device_descriptor (device, &devdesc); +
if (!devdesc.bNumConfigurations || !devdesc.idVendor ||
```
   !devdesc.idProduct)
```
continue;

for (conf = 0, confptr = device->config;

conf < device->descriptor.bNumConfigurations;
conf ++, confptr ++)
for (conf = 0; conf < devdesc.bNumConfigurations; conf ++)
{
if (libusb_get_config_descriptor (device, conf, &confptr) < 0)

continue;
for (iface = 0, ifaceptr = confptr->interface;
iface < confptr->bNumInterfaces;
iface ++, ifaceptr ++)

@@ -317,7 +971,7 @@ * 1284.4 (packet mode) protocol as well. */

if (altptr->bInterfaceClass != USB_CLASS_PRINTER ||

if (altptr->bInterfaceClass != LIBUSB_CLASSPRINTER || altptr->bInterfaceSubClass != 1 || (altptr->bInterfaceProtocol != 1 && /* Unidirectional / altptr->bInterfaceProtocol != 2) || /_ Bidirectional */ @@ -330,10 +984,10 @@ for (endp = 0, endpptr = altptr->endpoint; endp < altptr->bNumEndpoints; endp ++, endpptr ++)
if ((endpptr->bmAttributes & USB_ENDPOINT_TYPE_MASK) ==
USB_ENDPOINT_TYPE_BULK)
if ((endpptr->bmAttributes & LIBUSB_TRANSFER_TYPE_MASK) ==
LIBUSB_TRANSFER_TYPE_BULK) {
if (endpptr->bEndpointAddress & USB_ENDPOINT_DIR_MASK)

    if (endpptr->bEndpointAddress & LIBUSB_ENDPOINT_DIR_MASK)
read_endp = endp;
else
write_endp = endp;

@@ -354,38 +1008,37 @@

if (protocol > 0) {

printer.device = device;
printer.conf = conf;
printer.iface = iface;
printer.handle = NULL;
printer.device = device;
printer.conf = conf;
printer.iface = iface;
printer.protocol = protocol;

printer.handle   = NULL;

   if (!open_device(&printer, data != NULL))
{

if (!get_device_id(&printer, device_id, sizeof(device_id)))
{
make_device_uri(&printer, device_id, device_uri,
sizeof(device_uri));
get_device_id(&printer, device_id, sizeof(device_id));
make_device_uri(&printer, device_id, device_uri,
```
          sizeof(device_uri));
```

    if ((*cb)(&printer, device_uri, device_id, data))

{
printer.read_endp = printer.device->config[printer.conf].
interface[printer.iface].
if ((*cb)(&printer, device_uri, device_id, data))
{
printer.read_endp = confptr->interface[printer.iface]. altsetting[printer.altset]. endpoint[printer.read_endp]. bEndpointAddress;
printer.write_endp = printer.device->config[printer.conf].
interface[printer.iface].
printer.write_endp = confptr->interface[printer.iface]. altsetting[printer.altset]. endpoint[printer.write_endp]. bEndpointAddress;
return (&printer);
}

return (&printer);
     }

     close_device(&printer);
}

} }

libusb_free_config_descriptor(confptr);
```
}
```
}

/* @@ -393,6 +1046,13 @@
- to print to... */
/*
* Clean up ....
*/ +
libusb_free_device_list(list, 1);
libusb_exit(NULL); + return (NULL); }

@@ -409,10 +1069,12 @@ int length; /* Length of device ID */

if (usb_control_msg(printer->handle,
USB_TYPE_CLASS | USB_ENDPOINT_IN | USB_RECIP_INTERFACE,
0, printer->conf, (printer->iface << 8) | printer->altset,
buffer, bufsize, 5000) < 0)
if (libusb_control_transfer(printer->handle,
LIBUSB_REQUEST_TYPE_CLASS | LIBUSB_ENDPOINT_IN |
LIBUSB_RECIPIENT_INTERFACE,
0, printer->conf,
(printer->iface << 8) | printer->altset,
```
          (unsigned char *)buffer, bufsize, 5000) < 0)
```
{ *buffer = '\0'; return (-1); @@ -482,7 +1144,8 @@
- Get the device URI and make/model strings... */
backendGetMakeModel(device_id, make_model, sizeof(make_model));
if (backendGetMakeModel(device_id, make_model, sizeof(make_model)))
strlcpy(make_model, "Unknown", sizeof(make_model));

/*
- Report the printer... @@ -510,12 +1173,14 @@ char uri, / I - Device URI buffer _/ size_t urisize) / I - Size of device URI buffer */ {
struct libusb_device_descriptor devdesc;
/* Current device descriptor / char options[1024]; / Device URI options _/ int numvalues; / Number of 1284 parameters _/ cups_optiont *values; / 1284 parameters / const char *mfg, / Manufacturer / *mdl, / Model */
des, / Description */
des = NULL, / Description / *sern; / Serial number _/ sizet mfglen; / Length of manufacturer string / char tempmfg[256], / Temporary manufacturer string */ @@ -532,16 +1197,18 @@ if ((sern = cupsGetOption("SERIALNUMBER", num_values, values)) == NULL) if ((sern = cupsGetOption("SERN", num_values, values)) == NULL) if ((sern = cupsGetOption("SN", num_values, values)) == NULL &&
printer->device->descriptor.iSerialNumber)
((libusb_get_device_descriptor (printer->device, &devdesc) >= 0) &&
```
devdesc.iSerialNumber))
```
{ / * Try getting the serial number from the device itself... /

 int length = usb_get_string_simple(printer->handle,

printer->device->descriptor.
iSerialNumber,
tempsern, sizeof(tempsern) - 1);
int length =
libusb_get_string_descriptor_ascii(printer->handle,
devdesc.iSerialNumber,
(unsigned char *)tempsern,

                 sizeof(tempsern) - 1);
if (length > 0)

{ tempsern[length] = '\0'; @@ -597,6 +1264,19 @@ mfg = tempmfg; }

if (!mdl)
{
/*
* No model? Use description...
*/
if (des)
mdl = des; /* We remove the manufacturer name below */
else if (!strncasecmp(mfg, "Unknown", 7))
mdl = "Printer";
else
mdl = "Unknown Model";
} + mfglen = strlen(mfg);

if (!strncasecmp(mdl, mfg, mfglen) && _cups_isspace(mdl[mfglen])) @@ -642,7 +1322,13 @@ open_device(usb_printer_t printer, / I - Printer / int verbose) / I - Update connecting-to-device state? */ {
int number; /* Configuration/interface/altset numbers */
struct libusb_device_descriptor devdesc;
/* Current device descriptor */
struct libusb_config_descriptor *confptr = NULL;
/* Pointer to current configuration */
int number1 = -1, /* Configuration/interface/altset */
number2 = -1, /* numbers */
errcode = 0; char current; /* Current configuration */

@@ -657,7 +1343,7 @@

Try opening the printer... */
if ((printer->handle = usb_open(printer->device)) == NULL)
if (libusb_open(printer->device, &printer->handle) < 0) return (-1);

if (verbose) @@ -665,20 +1351,24 @@

/*
- Set the desired configuration, but only if it needs changing. Some
* printers (e.g., Samsung) don't like usb_set_configuration. It will succeed,
* but the following print job is sometimes silently lost by the printer.

- */

if (usb_control_msg(printer->handle,
USB_TYPE_STANDARD | USB_ENDPOINT_IN | USB_RECIP_DEVICE,
8, /* GET_CONFIGURATION */
0, 0, &current, 1, 5000) != 1)
* printers (e.g., Samsung) don't like libusb_set_configuration. It will
* succeed, but the following print job is sometimes silently lost by the
* printer.
*/
if (libusb_control_transfer(printer->handle,
LIBUSB_REQUEST_TYPE_STANDARD | LIBUSB_ENDPOINT_IN |
LIBUSB_RECIPIENT_DEVICE,
8, /* GET_CONFIGURATION */
```
0, 0, (unsigned char *)&current, 1, 5000) < 0)
```
current = 0; /* Assume not configured */
number = printer->device->config[printer->conf].bConfigurationValue;
if (number != current)
libusb_get_device_descriptor (printer->device, &devdesc);
libusb_get_config_descriptor (printer->device, printer->conf, &confptr);
number1 = confptr->bConfigurationValue; +
if (number1 != current) {
if (usb_set_configuration(printer->handle, number) < 0)
if ((errcode = libusb_set_configuration(printer->handle, number1)) < 0) { /*
- If the set fails, chances are that the printer only supports a @@ -686,26 +1376,52 @@
- the USB printer specification, but otherwise they'll work... */
```
if (errno != EBUSY)
```
if (errcode != LIBUSB_ERROR_BUSY) fprintf(stderr, "DEBUG: Failed to set configuration %d for %04x:%04x\n",
number, printer->device->descriptor.idVendor,
printer->device->descriptor.idProduct);
number1, devdesc.idVendor, devdesc.idProduct);
}
} +
/*
* Get the "usblp" kernel module out of the way. This backend only
* works without the module attached.
*/ +
errcode = libusb_kernel_driver_active(printer->handle, printer->iface);
if (errcode == 0)
printer->usblp_attached = 0;
else if (errcode == 1)
{
printer->usblp_attached = 1;
if ((errcode =
libusb_detach_kernel_driver(printer->handle, printer->iface)) < 0)
{
fprintf(stderr, "DEBUG: Failed to detach \"usblp\" module from %04x:%04x\n",
devdesc.idVendor, devdesc.idProduct);
goto error; } }
else
{
printer->usblp_attached = 0;
fprintf(stderr, "DEBUG: Failed to check whether %04x:%04x has the \"usblp\" kernel module attached\n",
devdesc.idVendor, devdesc.idProduct);
goto error;
}

/*
- Claim interfaces as needed... */
number = printer->device->config[printer->conf].interface[printer->iface].
altsetting[printer->altset].bInterfaceNumber;
while (usb_claim_interface(printer->handle, number) < 0)
number1 = confptr->interface[printer->iface].
altsetting[printer->altset].bInterfaceNumber; +
while ((errcode = libusb_claim_interface(printer->handle, number1)) < 0) {
if (errno != EBUSY)
if (errcode != LIBUSB_ERROR_BUSY) fprintf(stderr, "DEBUG: Failed to claim interface %d for %04x:%04x: %s\n",
number, printer->device->descriptor.idVendor,
printer->device->descriptor.idProduct, strerror(errno));
```
       number1, devdesc.idVendor, devdesc.idProduct, strerror(errno));
```
goto error; } @@ -715,24 +1431,29 @@
- printers (e.g., Samsung) don't like usb_set_altinterface. */
if (printer->device->config[printer->conf].interface[printer->iface].
num_altsetting > 1)
if (confptr->interface[printer->iface].num_altsetting > 1) {
number = printer->device->config[printer->conf].interface[printer->iface].
number1 = confptr->interface[printer->iface].
altsetting[printer->altset].bInterfaceNumber;
number2 = confptr->interface[printer->iface]. altsetting[printer->altset].bAlternateSetting;
while (usb_set_altinterface(printer->handle, number) < 0)
while ((errcode =
libusb_set_interface_alt_setting(printer->handle, number1, number2))
< 0) {
if (errno != EBUSY)
if (errcode != LIBUSB_ERROR_BUSY) fprintf(stderr, "DEBUG: Failed to set alternate interface %d for %04x:%04x: "
"%s\n", number, printer->device->descriptor.idVendor,
printer->device->descriptor.idProduct, strerror(errno));
"%s\n",

         number2, devdesc.idVendor, devdesc.idProduct, strerror(errno));

goto error; } }

libusb_free_config_descriptor(confptr); + if (verbose) fputs("STATE: -connecting-to-device\n", stderr);

@@ -747,7 +1468,7 @@ if (verbose) fputs("STATE: -connecting-to-device\n", stderr);

usb_close(printer->handle);
libusb_close(printer->handle); printer->handle = NULL;

return (-1); @@ -849,91 +1570,149 @@

/*
* 'side_cb()' - Handle side-channel requests.
* 'soft_reset()' - Send a soft reset to the device. */

-static ssizet /* O - Number of bytes written / -side_cb(usb_printert *printer, / I - Printer */

int print_fd) /* I - File to print */ +static void soft_reset(void) {
ssize_t bytes, /* Bytes read/written */
tbytes; /* Total bytes written */
char buffer[512]; /* Print data buffer */
struct pollfd pfd; /* Poll descriptor */
cups_sc_command_t command; /* Request command */
cups_sc_status_t status; /* Request/response status */
char data[2048]; /* Request/response data */
int datalen; /* Request/response data size */
fd_set input_set; /* Input set for select() */
struct timeval tv; /* Time value */
char buffer[2048]; /* Buffer */
struct timespec cond_timeout; /* pthread condition timeout */
/*
* Send an abort once a second until the I/O lock is released by the main thread...
*/
tbytes = 0;
datalen = sizeof(data);
pthread_mutex_lock(&g.readwrite_lock_mutex);
while (g.readwrite_lock)
{
gettimeofday(&tv, NULL);
cond_timeout.tv_sec = tv.tv_sec + 1;
cond_timeout.tv_nsec = tv.tv_usec * 1000;
if (cupsSideChannelRead(&command, &status, data, &datalen, 1.0))
return (-1);
while (g.readwrite_lock)
{
if (pthread_cond_timedwait(&g.readwrite_lock_cond,
&g.readwrite_lock_mutex,
&cond_timeout) != 0)
break;
}
}
switch (command)
{
case CUPS_SC_CMD_DRAIN_OUTPUT :
pfd.fd = print_fd;
pfd.events = POLLIN;
g.readwrite_lock = 1;
pthread_mutex_unlock(&g.readwrite_lock_mutex);
while (poll(&pfd, 1, 1000) > 0)
{
if ((bytes = read(print_fd, buffer, sizeof(buffer))) > 0)
{
while (usb_bulk_write(printer->handle, printer->write_endp, buffer,
bytes, 5000) < 0)
{
_cupsLangPrintFilter(stderr, "ERROR",
_("Unable to send data to printer."));
tbytes = -1;
break;
}
/*
* Flush bytes waiting on print_fd...
*/
```
tbytes += bytes;
```
}
else if (bytes < 0 && errno != EAGAIN && errno != EINTR)
break;
}
g.print_bytes = 0;
```
 if (tbytes < 0)
```
status = CUPS_SC_STATUS_IO_ERROR;
else

- status = CUPS_SC_STATUS_OK;

datalen = 0;

- break;

case CUPS_SC_CMD_GET_BIDI :
status = CUPS_SC_STATUS_OK;
data[0] = 0; /* TODO: Change to 1 when read supported */
datalen = 1;
break;
FD_ZERO(&input_set);
FD_SET(g.print_fd, &input_set);
case CUPS_SC_CMD_GET_DEVICE_ID :
if (get_device_id(printer, data, sizeof(data)))
{
status = CUPS_SC_STATUS_IO_ERROR;
datalen = 0;
}
else
{
status = CUPS_SC_STATUS_OK;
datalen = strlen(data);
}
break;
tv.tv_sec = 0;
tv.tv_usec = 0;
default :
status = CUPS_SC_STATUS_NOT_IMPLEMENTED;
datalen = 0;
break;
}
while (select(g.print_fd+1, &input_set, NULL, NULL, &tv) > 0)
if (read(g.print_fd, buffer, sizeof(buffer)) <= 0)
```
break;
```
cupsSideChannelWrite(command, status, data, datalen, 1.0);
/*
* Send the reset...
*/ +
libusb_reset_device (g.printer->handle); +
/*
* Release the I/O lock...
*/
return (tbytes);
pthread_mutex_lock(&g.readwrite_lock_mutex);
g.readwrite_lock = 0;
pthread_cond_signal(&g.readwrite_lock_cond);
pthread_mutex_unlock(&g.readwrite_lock_mutex); +} + + +#ifdef PARSE_PS_ERRORS +/*
* 'next_line()' - Find the next line in a buffer.
/ + +static const char next_line (const char *buffer) +{
const char cptr, lptr = NULL; +
for (cptr = buffer; *cptr && lptr == NULL; cptr++)
if (cptr == '\n' || cptr == '\r')
lptr = cptr;
return lptr; +} + + +/*
* 'parse_pserror()' - Scan the backchannel data for postscript errors.
/ + +static void parse_pserror(char sockBuffer,
int len) +{
static char gErrorBuffer[1024] = "";
static char *gErrorBufferPtr = gErrorBuffer;
static char *gErrorBufferEndPtr = gErrorBuffer + sizeof(gErrorBuffer); +
char pCommentBegin, pCommentEnd, *pLineEnd;
char *logLevel;
char logstr[1024];
int logstrlen; +
if (gErrorBufferPtr + len > gErrorBufferEndPtr - 1)
gErrorBufferPtr = gErrorBuffer;
if (len > sizeof(gErrorBuffer) - 1)
len = sizeof(gErrorBuffer) - 1; +
memcpy(gErrorBufferPtr, (const void *)sockBuffer, len);
gErrorBufferPtr += len;
*(gErrorBufferPtr + 1) = '\0'; +
pLineEnd = (char )next_line((const char )gErrorBuffer);
while (pLineEnd != NULL)
{
*pLineEnd++ = '\0'; +
pCommentBegin = strstr(gErrorBuffer,"%%[");
pCommentEnd = strstr(gErrorBuffer, "]%%");
if (pCommentBegin != gErrorBuffer && pCommentEnd != NULL)
{
pCommentEnd += 3; /* Skip past "]%%" */
pCommentEnd = '\0'; / There's always room for the nul */ +
if (_cups_strncasecmp(pCommentBegin, "%%[ Error:", 10) == 0)
logLevel = "DEBUG";
else if (_cups_strncasecmp(pCommentBegin, "%%[ Flushing", 12) == 0)
logLevel = "DEBUG";
else
logLevel = "INFO"; +
if ((logstrlen = snprintf(logstr, sizeof(logstr), "%s: %s\n", logLevel, pCommentBegin)) >= sizeof(logstr))
{
/* If the string was truncated make sure it has a linefeed before the
nul */
logstrlen = sizeof(logstr) - 1;
logstr[logstrlen - 1] = '\n';
}
write(STDERR_FILENO, logstr, logstrlen);
} +
/* move everything over... */
strcpy(gErrorBuffer, pLineEnd);
gErrorBufferPtr = gErrorBuffer;
pLineEnd = (char )next_line((const char )gErrorBuffer);
} } +#endif /* PARSE_PS_ERRORS */

/*

michaelrsweet commented 12 years ago

"str2890.patch":

Index: backend/usb-libusb.c

--- backend/usb-libusb.c (revision 10264) +++ backend/usb-libusb.c (working copy) @@ -13,16 +13,18 @@ *

Contents: *
- * list_devices() - List the available printers.
- * print_device() - Print a file to a USB device.
- * close_device() - Close the connection to the USB printer.
- * find_device() - Find or enumerate USB printers.
- * get_device_id() - Get the IEEE-1284 device ID for the printer.
- * list_cb() - List USB printers for discovery.
- * make_device_uri() - Create a device URI for a USB printer.
- * open_device() - Open a connection to the USB printer.
- * print_cb() - Find a USB printer for printing.
- * side_cb() - Handle side-channel requests. +ï»¿ * list_devices() - List the available printers.
- * print_device() - Print a file to a USB device.
- * close_device() - Close the connection to the USB printer.
- * find_device() - Find or enumerate USB printers.
- * get_device_id() - Get the IEEE-1284 device ID for the printer.
- * list_cb() - List USB printers for discovery.
- * make_device_uri() - Create a device URI for a USB printer.
- * open_device() - Open a connection to the USB printer.
- * print_cb() - Find a USB printer for printing.
- * read_thread() - Thread to read the backchannel data on.
- * sidechannel_thread() - Handle side-channel requests.
- * soft_reset() - Send a soft reset to the device. */
/ @@ -30,15 +32,24 @@ /

include

-#include

include <cups/cups-private.h>

+#include +#include <sys/select.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <sys/time.h> +#include

/*
- * Local globals...
- * WAIT_EOF_DELAY is number of seconds we'll wait for responses from
- * the printer after we've finished sending all the data */

-static libusb_device list; / List of connected USB devices / +#define WAIT_EOF 0 +#define WAIT_EOF_DELAY 7 +#define WAIT_SIDE_DELAY 3 +#define DEFAULT_TIMEOUT 5000L

/ @@ -53,6 +64,7 @@ altset, /* Alternate setting _/ writeendp, / Write endpoint _/ readendp, / Read endpoint /

protocol, /* Protocol: 1 = Uni-di, 2 = Bi-di. _/ usblpattached; / Is the "usblp" kernel module attached? _/ struct libusb_devicehandle *handle; / Open handle to device _/ @@ -61,8 +73,42 @@ typedef int (_usb_cb_t)(usb_printer_t , const char , const char , const void );

+typedef struct usb_globals_s +{

usb_printer_t printer; / Printer */
pthread_mutex_t read_thread_mutex;
pthread_cond_t read_thread_cond;
int read_thread_stop;
int read_thread_done; +
pthread_mutex_t readwrite_lock_mutex;
pthread_cond_t readwrite_lock_cond;
int readwrite_lock; +
int print_fd; /* File descriptor to print */
ssize_t print_bytes; /* Print bytes read */ +
int wait_eof;
int drain_output; /* Drain all pending output */
int bidi_flag; /* 0=unidirectional, 1=bidirectional */ +
pthread_mutex_t sidechannel_thread_mutex;
pthread_cond_t sidechannel_thread_cond;
int sidechannel_thread_stop;
int sidechannel_thread_done; +} usb_globals_t; + + /*
* Globals...
_/ + +usb_globalst g = { 0 }; / Globals _/ +libusb_device _list; /\ List of connected USB devices / + + +/
- Local functions... */

@@ -78,7 +124,9 @@ static int open_device(usb_printer_t printer, int verbose); static int print_cb(usb_printer_t printer, const char device_uri, const char device_id, const void data); -static ssize_t side_cb(usb_printer_t printer, int print_fd); +static void read_thread(void reference); +static void sidechannel_thread(void reference); +static void soft_reset(void);

/ @@ -107,28 +155,46 @@ int argc, /* I - Number of command-line arguments (6 or 7) _/ char argv[]) /_ I - Command-line arguments */ {

usb_printer_t printer; / Printer */
int bytes, /* Bytes to read/write */
transferred, /* Bytes read/written */
tbytes; /* Total bytes written */
unsigned char buffer[512]; /* Print data buffer */
int bytes; /* Bytes written */
ssize_t totalbytes; /* Total bytes written / struct sigaction action; /_ Actions for POSIX signals */
struct pollfd pfds[2]; /* Poll descriptors */
int status = CUPS_BACKEND_OK,
/* Function results */
iostatus; /* Current IO status */
pthread_t read_thread_id, /* Read thread */
sidechannel_thread_id; /* Side-channel thread */
int have_sidechannel = 0; /* Was the side-channel thread started? */
struct stat sidechannel_info; /* Side-channel file descriptor info */
unsigned char print_buffer[8192], /* Print data buffer */
_printptr; / Pointer into print data buffer */
fd_set input_set; /* Input set for select() */
int nfds; /* Number of file descriptors */
struct timeval timeout, / Timeout pointer */
tv; /* Time value */
struct timespec cond_timeout; /* pthread condition timeout */
fputs("DEBUG: print_device\n", stderr);
/*
* See if the side-channel descriptor is valid...
*/
have_sidechannel = !fstat(CUPS_SC_FD, &sidechannel_info) &&
S_ISSOCK(sidechannel_info.st_mode); +
g.wait_eof = WAIT_EOF; + /*
- Connect to the printer... */
while ((printer = find_device(print_cb, uri)) == NULL)
while ((g.printer = find_device(print_cb, uri)) == NULL) { cupsLangPrintFilter(stderr, "INFO", ("Waiting for printer to become available.")); sleep(5); }
g.print_fd = print_fd;

/*
- If we are printing data from a print driver on stdin, ignore SIGTERM @@ -146,81 +212,371 @@ sigaction(SIGTERM, &action, NULL); }
tbytes = 0;
/*
* Start the side channel thread if the descriptor is valid...
*/
pfds[0].fd = print_fd;
pfds[0].events = POLLIN;
pfds[1].fd = CUPS_SC_FD;
pfds[1].events = POLLIN;
pthread_mutex_init(&g.readwrite_lock_mutex, NULL);
pthread_cond_init(&g.readwrite_lock_cond, NULL);
g.readwrite_lock = 1;
while (copies > 0 && tbytes >= 0)
if (have_sidechannel) {
copies --;
g.sidechannel_thread_stop = 0;
g.sidechannel_thread_done = 0;
if (print_fd != 0)
pthread_cond_init(&g.sidechannel_thread_cond, NULL);
pthread_mutex_init(&g.sidechannel_thread_mutex, NULL); +
if (pthread_create(&sidechannel_thread_id, NULL, sidechannel_thread, NULL)) {
fprintf(stderr, "DEBUG: Fatal USB error.\n");
_cupsLangPrintFilter(stderr, "ERROR",
_("There was an unrecoverable USB error."));
fputs("DEBUG: Couldn't create side-channel thread.\n", stderr);
close_device(g.printer);
return (CUPS_BACKEND_STOP);
}
} +
/*
* Get the read thread going...
*/ +
g.read_thread_stop = 0;
g.read_thread_done = 0; +
pthread_cond_init(&g.read_thread_cond, NULL);
pthread_mutex_init(&g.read_thread_mutex, NULL); +
if (pthread_create(&read_thread_id, NULL, read_thread, NULL))
{
fprintf(stderr, "DEBUG: Fatal USB error.\n");
_cupsLangPrintFilter(stderr, "ERROR",
_("There was an unrecoverable USB error."));
fputs("DEBUG: Couldn't create read thread.\n", stderr);
close_device(g.printer);
return (CUPS_BACKEND_STOP);
} +
/*
* The main thread sends the print file...
*/ +
g.drain_output = 0;
g.print_bytes = 0;
total_bytes = 0;
print_ptr = print_buffer; +
while (status == CUPS_BACKEND_OK && copies-- > 0)
{
cupsLangPrintFilter(stderr, "INFO", ("Sending data to printer.")); +
if (print_fd != STDIN_FILENO)
{ fputs("PAGE: 1 1\n", stderr); lseek(print_fd, 0, SEEK_SET); }
/*
* TODO: Add back-channel support, along with better write error handling.
*/
while (status == CUPS_BACKEND_OK)
{
```
FD_ZERO(&input_set);
```
while (poll(pfds, 2, -1) > 0)
{
if (!g.print_bytes)
FD_SET(print_fd, &input_set); + /*
* CUPS STR #3318: USB process hangs on end-of-file, making further
* printing impossible
*
* From a strict interpretation of POSIX poll(), POLLHUP should never be
* set without POLLIN, since POLLIN is the event you request. That said,
* it appears that some versions of Linux break this.
* Calculate select timeout...
* If we have data waiting to send timeout is 100ms.
* else if we're draining print_fd timeout is 0.
```
*   else we're waiting forever...
```
*/

if (pfds[0].revents & (POLLIN | POLLHUP))

if (g.print_bytes) {
if ((bytes = read(print_fd, buffer, sizeof(buffer))) > 0)
tv.tv_sec = 0;
tv.tv_usec = 100000; /* 100ms */
timeout = &tv;
}
else if (g.drain_output)
{
tv.tv_sec = 0;
tv.tv_usec = 0;
timeout = &tv;
}
else
timeout = NULL; +
/*
* I/O is unlocked around select...
*/ +
pthread_mutex_lock(&g.readwrite_lock_mutex);
g.readwrite_lock = 0;
pthread_cond_signal(&g.readwrite_lock_cond);
pthread_mutex_unlock(&g.readwrite_lock_mutex); +
nfds = select(print_fd + 1, &input_set, NULL, NULL, timeout); +
/*
* Reacquire the lock...
*/ +
pthread_mutex_lock(&g.readwrite_lock_mutex);
while (g.readwrite_lock)
pthread_cond_wait(&g.readwrite_lock_cond, &g.readwrite_lock_mutex);
g.readwrite_lock = 1;
pthread_mutex_unlock(&g.readwrite_lock_mutex); +
if (nfds < 0)
{
if (errno == EINTR && total_bytes == 0) {
if (libusb_bulk_transfer(printer->handle, printer->write_endp, buffer,
bytes, &transferred, 3600000) < 0)
fputs("DEBUG: Received an interrupt before any bytes were "
"written, aborting.\n", stderr);
close_device(g.printer);
return (CUPS_BACKEND_OK);
}
else if (errno != EAGAIN && errno != EINTR)
{
_cupsLangPrintFilter(stderr, "ERROR",
_("Unable to read print data."));
perror("DEBUG: select");
close_device(g.printer);
return (CUPS_BACKEND_FAILED);
}
} +
/*
* If drain output has finished send a response...
*/ +
if (g.drain_output && !nfds && !g.print_bytes)
{
/* Send a response... */
cupsSideChannelWrite(CUPS_SC_CMD_DRAIN_OUTPUT, CUPS_SC_STATUS_OK, NULL, 0, 1.0);
g.drain_output = 0;
} +
/*
* Check if we have print data ready...
*/ +
if (FD_ISSET(print_fd, &input_set))
{
g.print_bytes = read(print_fd, print_buffer, sizeof(print_buffer)); +
if (g.print_bytes < 0)
{
/*
* Read error - bail if we don't see EAGAIN or EINTR...
*/ +
if (errno != EAGAIN && errno != EINTR) { _cupsLangPrintFilter(stderr, "ERROR",
_("Unable to send data to printer."));
tbytes = -1;
break;
_("Unable to read print data."));
perror("DEBUG: read");
close_device(g.printer);
```
return (CUPS_BACKEND_FAILED);
```
}
```
tbytes += bytes;
```
g.print_bytes = 0; }
else if (bytes == 0 || (bytes < 0 && errno != EAGAIN && errno != EINTR))
else if (g.print_bytes == 0)
{
/*
* End of file, break out of the loop...
*/ + break;
} +
print_ptr = print_buffer; +
fprintf(stderr, "DEBUG: Read %d bytes of print data...\n",
```
(int)g.print_bytes);
```
}

if (pfds[1].revents & (POLLIN | POLLHUP))

if (g.print_bytes) {
if ((bytes = side_cb(printer, print_fd)) < 0)
pfds[1].events = 0; /* Filter has gone away... */
else
tbytes += bytes;
iostatus = libusb_bulk_transfer(g.printer->handle,
g.printer->write_endp,
print_buffer, g.print_bytes,
&bytes, 60000);
/*
* Ignore timeout errors, but retain the number of bytes written to
* avoid sending duplicate data...
*/ +
if (iostatus == LIBUSB_ERROR_TIMEOUT)
{
fputs("DEBUG: Got USB transaction timeout during write.\n", stderr);
iostatus = 0;
} +
/*
* If we've stalled, retry the write...
*/ +
else if (iostatus == LIBUSB_ERROR_PIPE)
{
fputs("DEBUG: Got USB pipe stalled during write.\n", stderr); +
iostatus = libusb_bulk_transfer(g.printer->handle,
g.printer->write_endp,
print_buffer, g.print_bytes,
&bytes, 60000);
} +
/*
* Retry a write after an aborted write since we probably just got
* SIGTERM...
*/ +
else if (iostatus == LIBUSB_ERROR_INTERRUPTED)
{
fputs("DEBUG: Got USB return aborted during write.\n", stderr); +
iostatus = libusb_bulk_transfer(g.printer->handle,
g.printer->write_endp,
print_buffer, g.print_bytes,
&bytes, 60000);
} +
if (iostatus)
{
/*
* Write error - bail if we don't see an error we can retry...
*/ +
_cupsLangPrintFilter(stderr, "ERROR",
_("Unable to send data to printer."));
fprintf(stderr, "DEBUG: libusb write operation returned %x.\n",
iostatus); +
status = CUPS_BACKEND_FAILED;
break;
}
else if (bytes > 0)
{
fprintf(stderr, "DEBUG: Wrote %d bytes of print data...\n",
(int)bytes); +
g.print_bytes -= bytes;
print_ptr += bytes;
total_bytes += bytes;
} } +
if (print_fd != 0 && status == CUPS_BACKEND_OK)
fprintf(stderr, "DEBUG: Sending print file, " CUPS_LLFMT " bytes...\n",
```
CUPS_LLCAST total_bytes);
```
} }
fprintf(stderr, "DEBUG: Sent " CUPS_LLFMT " bytes...\n",
CUPS_LLCAST total_bytes); + /*
* Close our connection and return...
- Signal the side channel thread to exit... */
close_device(printer);
if (have_sidechannel)
{
close(CUPS_SC_FD);
pthread_mutex_lock(&g.readwrite_lock_mutex);
g.readwrite_lock = 0;
pthread_cond_signal(&g.readwrite_lock_cond);
pthread_mutex_unlock(&g.readwrite_lock_mutex);
g.sidechannel_thread_stop = 1;
pthread_mutex_lock(&g.sidechannel_thread_mutex); +
if (!g.sidechannel_thread_done)
{
gettimeofday(&tv, NULL);
cond_timeout.tv_sec = tv.tv_sec + WAIT_SIDE_DELAY;
cond_timeout.tv_nsec = tv.tv_usec * 1000; +
while (!g.sidechannel_thread_done)
{
if (pthread_cond_timedwait(&g.sidechannel_thread_cond,
&g.sidechannel_thread_mutex,
&cond_timeout) != 0)
break;
}
} +
pthread_mutex_unlock(&g.sidechannel_thread_mutex);
} + /*
* Signal the read thread to exit then wait 7 seconds for it to complete...
*/ +
g.read_thread_stop = 1; +
pthread_mutex_lock(&g.read_thread_mutex); +
if (!g.read_thread_done)
{
fputs("DEBUG: Waiting for read thread to exit...\n", stderr); +
gettimeofday(&tv, NULL);
cond_timeout.tv_sec = tv.tv_sec + WAIT_EOF_DELAY;
cond_timeout.tv_nsec = tv.tv_usec * 1000; +
while (!g.read_thread_done)
{
if (pthread_cond_timedwait(&g.read_thread_cond, &g.read_thread_mutex,
&cond_timeout) != 0)
break;
} +
/*
* If it didn't exit abort the pending read and wait an additional second...
*/
if (!g.read_thread_done)
{
fputs("DEBUG: Read thread still active, aborting the pending read...\n",
stderr); +
g.wait_eof = 0; +
gettimeofday(&tv, NULL);
cond_timeout.tv_sec = tv.tv_sec + 1;
cond_timeout.tv_nsec = tv.tv_usec * 1000;
while (!g.read_thread_done)
{
if (pthread_cond_timedwait(&g.read_thread_cond, &g.read_thread_mutex,
&cond_timeout) != 0)
break;
}
}
} +
pthread_mutex_unlock(&g.read_thread_mutex); +
if (print_fd)
close(print_fd); +
/*
* Close the connection and input file and general clean up...
*/ +
close_device(g.printer); +
/*
- Clean up .... */
libusb_free_device_list(list, 1); libusb_exit(NULL);
return (CUPS_BACKEND_OK);
return (status); }

@@ -236,6 +592,7 @@ struct libusb_config_descriptor confptr; / Pointer to current configuration */

+ if (printer->handle) { / @@ -243,10 +600,12 @@ * to the device... /

int number; /* Interface number */ + libusb_get_device_descriptor (printer->device, &devdesc); libusb_get_config_descriptor (printer->device, printer->conf, &confptr);
int number = confptr->interface[printer->iface].
altsetting[printer->altset].bInterfaceNumber;
number = confptr->interface[printer->iface].
altsetting[printer->altset].bInterfaceNumber; libusb_release_interface(printer->handle, number); if (number != 0) libusb_release_interface(printer->handle, 0); @@ -255,10 +614,14 @@
- Re-attach "usblp" kernel module if it was attached before using this
- device */
- if (printer->usblp_attached == 1)
{ if (libusb_attach_kernel_driver(printer->handle, printer->iface) < 0)
fprintf(stderr, "DEBUG: Failed to re-attach \"usblp\" kernel module to %04x:%04x\n",
devdesc.idVendor, devdesc.idProduct);
fprintf(stderr,
"DEBUG: Failed to re-attach \"usblp\" kernel module to "
"%04x:%04x\n", devdesc.idVendor, devdesc.idProduct);
}

libusb_free_config_descriptor(confptr);

@@ -398,10 +761,11 @@

  if (protocol > 0)
  {

printer.device = device;
printer.conf = conf;
printer.iface = iface;
printer.handle = NULL;
printer.device = device;
printer.conf = conf;
printer.iface = iface;
printer.protocol = protocol;
```
printer.handle   = NULL;

   if (!open_device(&printer, data != NULL))
{
```
@@ -611,16 +975,7 @@ if ((mdl = cupsGetOption("MODEL", num_values, values)) == NULL) mdl = cupsGetOption("MDL", num_values, values);

-#ifdef APPLE /*

* To maintain compatibility with the original IOKit-based backend on Mac OS X,
* don't map manufacturer names...

- */

- if (!mfg)

-#else

/*
- To maintain compatibility with the original character device backend on
- Linux and BSD, map manufacturer names... */ @@ -633,7 +988,6 @@ mfg = "Lexmark"; } else -#endif / APPLE / { /
- No manufacturer? Use the model string or description... @@ -712,12 +1066,12 @@ int verbose) /* I - Update connecting-to-device state? */ { struct libusb_device_descriptor devdesc;
/* Current device descriptor */
/* Current device descriptor / struct libusb_config_descriptor confptr = NULL;
/* Pointer to current configuration */
/* Pointer to current configuration / int number1 = -1, / Configuration/interface/altset */
number2 = -1, /* numbers */
errcode = 0; /* Current error */
number2 = -1, /* numbers */
errcode = 0; char current; /* Current configuration */

@@ -740,27 +1094,20 @@

/*

Set the desired configuration, but only if it needs changing. Some
- * printers (e.g., Samsung) don't like libusb_set_configuration. It will
- * printers (e.g., Samsung) don't like libusb_set_configuration. It will
succeed, but the following print job is sometimes silently lost by the
printer. */

if (libusb_control_transfer(printer->handle,
- LIBUSB_REQUEST_TYPE_STANDARD |
- LIBUSB_ENDPOINT_IN | LIBUSB_RECIPIENT_DEVICE,
- 8, /* GET_CONFIGURATION */
- 0, 0, (unsigned char *)&current, 1, 5000) < 0)
- {
- /*
- * Failed - assume not configured.
- */
- LIBUSB_REQUEST_TYPE_STANDARD | LIBUSB_ENDPOINT_IN |
- LIBUSB_RECIPIENT_DEVICE,
- 8, /* GET_CONFIGURATION */
- 0, 0, (unsigned char *)&current, 1, 5000) < 0)
- current = 0; /* Assume not configured */
current = 0;

- }

libusb_get_device_descriptor(printer->device, &devdesc);

- libusb_get_config_descriptor(printer->device, printer->conf, &confptr);

libusb_get_device_descriptor (printer->device, &devdesc);
libusb_get_config_descriptor (printer->device, printer->conf, &confptr); number1 = confptr->bConfigurationValue;

if (number1 != current) @@ -775,7 +1122,7 @@

if (errcode != LIBUSB_ERROR_BUSY) fprintf(stderr, "DEBUG: Failed to set configuration %d for %04x:%04x\n",
number1, devdesc.idVendor, devdesc.idProduct);
number1, devdesc.idVendor, devdesc.idProduct); } }

@@ -790,12 +1137,10 @@ else if (errcode == 1) {

printer->usblp_attached = 1;

 if ((errcode =
 libusb_detach_kernel_driver(printer->handle, printer->iface)) < 0)
 {

fprintf(stderr,
"DEBUG: Failed to detach \"usblp\" module from %04x:%04x\n",
fprintf(stderr, "DEBUG: Failed to detach \"usblp\" module from %04x:%04x\n", devdesc.idVendor, devdesc.idProduct); goto error; } @@ -803,10 +1148,8 @@ else { printer->usblp_attached = 0;
fprintf(stderr,
"DEBUG: Failed to check whether %04x:%04x has the \"usblp\" kernel "
"module attached.\n", devdesc.idVendor, devdesc.idProduct);
fprintf(stderr, "DEBUG: Failed to check whether %04x:%04x has the \"usblp\" kernel module attached\n",
devdesc.idVendor, devdesc.idProduct); goto error; }

@@ -815,42 +1158,44 @@ */

number1 = confptr->interface[printer->iface].

altsetting[printer->altset].bInterfaceNumber;
altsetting[printer->altset].bInterfaceNumber;

while ((errcode = libusb_claim_interface(printer->handle, number1)) < 0) { if (errcode != LIBUSB_ERROR_BUSY)
fprintf(stderr, "DEBUG: Failed to claim interface %d for %04x:%04x: %s\n",
fprintf(stderr,

       "DEBUG: Failed to claim interface %d for %04x:%04x: %s\n",
     number1, devdesc.idVendor, devdesc.idProduct, strerror(errno));

goto error; }

/*

* Set alternate setting, but only if there is more than one option.
* Some printers (e.g., Samsung) don't like libusb_set_interface_alt_setting.
* Set alternate setting, but only if there is more than one option. Some
- printers (e.g., Samsung) don't like usb_set_altinterface. */
if (confptr->interface[printer->iface].num_altsetting > 1) { number1 = confptr->interface[printer->iface].
altsetting[printer->altset].bInterfaceNumber;
altsetting[printer->altset].bInterfaceNumber; number2 = confptr->interface[printer->iface].
altsetting[printer->altset].bAlternateSetting;

          altsetting[printer->altset].bAlternateSetting;

while ((errcode = libusb_set_interface_alt_setting(printer->handle, number1,
number2)) < 0)
while ((errcode =
libusb_set_interface_alt_setting(printer->handle, number1, number2))
< 0) { if (errcode != LIBUSB_ERROR_BUSY) fprintf(stderr, "DEBUG: Failed to set alternate interface %d for %04x:%04x: "
"%s\n", number2, devdesc.idVendor, devdesc.idProduct,
strerror(errno));
"%s\n",

         number2, devdesc.idVendor, devdesc.idProduct, strerror(errno));

goto error; } }

+ libusb_free_config_descriptor(confptr);

if (verbose) @@ -969,92 +1314,289 @@

/*
* 'side_cb()' - Handle side-channel requests.
* 'read_thread()' - Thread to read the backchannel data on. */

-static ssizet /* O - Number of bytes written / -side_cb(usb_printert *printer, / I - Printer */

int print_fd) /* I - File to print / +static void read_thread(void *reference) {
int bytes, /* Bytes read/written */
transferred,
tbytes; /* Total bytes written */
unsigned char buffer[512]; /* Print data buffer */
struct pollfd pfd; /* Poll descriptor */
unsigned char readbuffer[512];
int rbytes;
int readstatus;
struct timeval now,
delay,
end,
timeleft; + +
(void)reference; +
/*
* Read frequency: once every 250 milliseconds.
*/ +
delay.tv_sec = 0;
delay.tv_usec = 250000; +
do
{
/*
* Remember when we started so we can throttle the loop after the read
* call...
*/ +
gettimeofday(&now, NULL); +
/*
* Calculate what 250 milliSeconds are in absolute time...
*/ +
timeradd(&now, &delay, &end); +
rbytes = sizeof(readbuffer);
readstatus = libusb_bulk_transfer(g.printer->handle,
g.printer->read_endp,
readbuffer, rbytes,
&rbytes, 60000);
if (readstatus == LIBUSB_SUCCESS && rbytes > 0)
{
fprintf(stderr, "DEBUG: Read %d bytes of back-channel data...\n",
(int)rbytes);
cupsBackChannelWrite((const char *)readbuffer, rbytes, 1.0);
}
else if (readstatus == LIBUSB_ERROR_TIMEOUT)
fputs("DEBUG: Got USB transaction timeout during read.\n", stderr);
else if (readstatus == LIBUSB_ERROR_PIPE)
fputs("DEBUG: Got USB pipe stalled during read.\n", stderr);
else if (readstatus == LIBUSB_ERROR_INTERRUPTED)
fputs("DEBUG: Got USB return aborted during read.\n", stderr); +
/*
* Make sure this loop executes no more than once every 250 miliseconds...
*/ +
if ((readstatus != LIBUSB_SUCCESS || rbytes == 0) &&
(g.wait_eof || !g.read_thread_stop))
{
gettimeofday(&now, NULL);
if (timercmp(&now, &end, <))
{
timersub(&end, &now, &timeleft);
usleep(1000000 * timeleft.tv_sec + timeleft.tv_usec);
}
}
} while (g.wait_eof || !g.read_thread_stop); +
/*
* Let the main thread know that we have completed the read thread...
*/ +
pthread_mutex_lock(&g.read_thread_mutex);
g.read_thread_done = 1;
pthread_cond_signal(&g.read_thread_cond);
pthread_mutex_unlock(&g.read_thread_mutex); +
return (NULL); +} + + +/*
* 'sidechannel_thread()' - Handle side-channel requests.
/ + +static void +sidechannel_thread(void _reference) +{ cups_sc_commandt command; / Request command _/ cups_sc_statust status; / Request/response status / char data[2048]; / Request/response data / int datalen; / Request/response data size */
tbytes = 0;
datalen = sizeof(data);
(void)reference;
if (cupsSideChannelRead(&command, &status, data, &datalen, 1.0))

- return (-1);

switch (command)
do {
case CUPS_SC_CMD_DRAIN_OUTPUT :
pfd.fd = print_fd;
pfd.events = POLLIN;
datalen = sizeof(data);
while (poll(&pfd, 1, 1000) > 0)
{
if ((bytes = read(print_fd, buffer, sizeof(buffer))) > 0)
if (cupsSideChannelRead(&command, &status, data, &datalen, 1.0))
{
if (status == CUPS_SC_STATUS_TIMEOUT)
continue;
else
break;
} +
switch (command)
{
case CUPS_SC_CMD_SOFT_RESET: /* Do a soft reset */
fputs("DEBUG: CUPS_SC_CMD_SOFT_RESET received from driver...\n",
stderr); +
soft_reset();
cupsSideChannelWrite(command, CUPS_SC_STATUS_OK, NULL, 0, 1.0);
fputs("DEBUG: Returning status CUPS_STATUS_OK with no bytes...\n",
stderr);
break; +
case CUPS_SC_CMD_DRAIN_OUTPUT: /* Drain all pending output */
fputs("DEBUG: CUPS_SC_CMD_DRAIN_OUTPUT received from driver...\n",
stderr); +
g.drain_output = 1;
break; +
case CUPS_SC_CMD_GET_BIDI: /* Is the connection bidirectional? */
fputs("DEBUG: CUPS_SC_CMD_GET_BIDI received from driver...\n",
stderr); +
data[0] = (g.printer->protocol >= 2 ? 1 : 0);
cupsSideChannelWrite(command, CUPS_SC_STATUS_OK, data, 1, 1.0); +
fprintf(stderr,
"DEBUG: Returned CUPS_SC_STATUS_OK with 1 byte (%02X)...\n",
data[0]);
break; +
case CUPS_SC_CMD_GET_DEVICE_ID: /* Return IEEE-1284 device ID */
fputs("DEBUG: CUPS_SC_CMD_GET_DEVICE_ID received from driver...\n",
stderr); +
datalen = sizeof(data);
if (get_device_id(g.printer, data, sizeof(data))) {
while (libusb_bulk_transfer(printer->handle, printer->write_endp,
buffer,
bytes, &transferred, 5000) < 0)
{
_cupsLangPrintFilter(stderr, "ERROR",
_("Unable to send data to printer."));
tbytes = -1;
break;

- }

tbytes += bytes;
status = CUPS_SC_STATUS_IO_ERROR;
datalen = 0; }
else if (bytes < 0 && errno != EAGAIN && errno != EINTR)
break;
}
else
{
status = CUPS_SC_STATUS_OK;
datalen = strlen(data);
}

cupsSideChannelWrite(command, CUPS_SC_STATUS_OK, data, datalen, 1.0);

```
 if (tbytes < 0)
```
status = CUPS_SC_STATUS_IO_ERROR;
else
status = CUPS_SC_STATUS_OK;
if (datalen < sizeof(data))
data[datalen] = '\0';
else
```
data[sizeof(data) - 1] = '\0';
```
datalen = 0;
break;
fprintf(stderr,
"DEBUG: Returning CUPS_SC_STATUS_OK with %d bytes (%s)...\n",
datalen, data);
```
break;
```
case CUPS_SC_CMD_GET_BIDI :
status = CUPS_SC_STATUS_OK;
data[0] = 0; /* TODO: Change to 1 when read supported */
datalen = 1;
break;
case CUPS_SC_CMD_GET_STATE: /* Return device state */
fputs("DEBUG: CUPS_SC_CMD_GET_STATE received from driver...\n",
```
stderr);
```
case CUPS_SC_CMD_GET_DEVICE_ID :
if (get_device_id(printer, data, sizeof(data)))
{
status = CUPS_SC_STATUS_IO_ERROR;
datalen = 0;
}
else
{
status = CUPS_SC_STATUS_OK;
datalen = strlen(data);
}
break;
data[0] = CUPS_SC_STATE_ONLINE;

cupsSideChannelWrite(command, CUPS_SC_STATUS_OK, data, 1, 1.0);

default :
status = CUPS_SC_STATUS_NOT_IMPLEMENTED;
datalen = 0;
fprintf(stderr,
"DEBUG: Returned CUPS_SC_STATUS_OK with 1 byte (%02X)...\n",
data[0]);
break; +
case CUPS_SC_CMD_GET_CONNECTED: /* Return whether device is
connected */
fputs("DEBUG: CUPS_SC_CMD_GET_CONNECTED received from driver...\n",
stderr); +
data[0] = (g.printer->handle ? 1 : 0);
cupsSideChannelWrite(command, CUPS_SC_STATUS_OK, data, 1, 1.0); +
fprintf(stderr,
"DEBUG: Returned CUPS_SC_STATUS_OK with 1 byte (%02X)...\n",
data[0]);
break; +
default:
fprintf(stderr, "DEBUG: Unknown side-channel command (%d) received "
"from driver...\n", command); +
cupsSideChannelWrite(command, CUPS_SC_STATUS_NOT_IMPLEMENTED,
NULL, 0, 1.0); +
fputs("DEBUG: Returned CUPS_SC_STATUS_NOT_IMPLEMENTED with no bytes...\n",
stderr);
break;
}
}
while (!g.sidechannel_thread_stop); +
pthread_mutex_lock(&g.sidechannel_thread_mutex);
g.sidechannel_thread_done = 1;
pthread_cond_signal(&g.sidechannel_thread_cond);
pthread_mutex_unlock(&g.sidechannel_thread_mutex); +
return (NULL); +} + + +/*
* 'soft_reset()' - Send a soft reset to the device.
*/ + +static void soft_reset(void) +{
fd_set input_set; /* Input set for select() */
struct timeval tv; /* Time value */
char buffer[2048]; /* Buffer */
struct timespec cond_timeout; /* pthread condition timeout */ +
/*
* Send an abort once a second until the I/O lock is released by the main
* thread...
*/ +
pthread_mutex_lock(&g.readwrite_lock_mutex);
while (g.readwrite_lock)
{
gettimeofday(&tv, NULL);
cond_timeout.tv_sec = tv.tv_sec + 1;
cond_timeout.tv_nsec = tv.tv_usec * 1000; +
while (g.readwrite_lock)
{
if (pthread_cond_timedwait(&g.readwrite_lock_cond,
&g.readwrite_lock_mutex,
&cond_timeout) != 0) break;
} }
cupsSideChannelWrite(command, status, data, datalen, 1.0);
g.readwrite_lock = 1;
pthread_mutex_unlock(&g.readwrite_lock_mutex);
return (tbytes);
/*
* Flush bytes waiting on print_fd...
*/ +
g.print_bytes = 0; +
FD_ZERO(&input_set);
FD_SET(g.print_fd, &input_set); +
tv.tv_sec = 0;
tv.tv_usec = 0; +
while (select(g.print_fd+1, &input_set, NULL, NULL, &tv) > 0)
if (read(g.print_fd, buffer, sizeof(buffer)) <= 0)
break; +
/*
* Send the reset...
*/ +
libusb_reset_device (g.printer->handle); +
/*
* Release the I/O lock...
*/ +
pthread_mutex_lock(&g.readwrite_lock_mutex);
g.readwrite_lock = 0;
pthread_cond_signal(&g.readwrite_lock_cond);
pthread_mutex_unlock(&g.readwrite_lock_mutex); }

apple / cups

Add back-channel support to libusb-based USB backend #2890

include <cups/cups-private.h>

- */

- usb_release_interface(printer->handle, number);

- */

- status = CUPS_SC_STATUS_OK;

- break;

Index: backend/usb-libusb.c

include

include <cups/cups-private.h>

- */

- if (!mfg)

- }

- libusb_get_config_descriptor(printer->device, printer->conf, &confptr);

printer->usblp_attached = 1;

fprintf(stderr, "DEBUG: Failed to detach \"usblp\" module from %04x:%04x\n", devdesc.idVendor, devdesc.idProduct); goto error; } @@ -803,10 +1148,8 @@ else { printer->usblp_attached = 0;

- return (-1);

- }