/*

 * Copyright 2005-2016 Apple Inc. All rights reserved.

 *

 * IMPORTANT:  This Apple software is supplied to you by Apple Computer,

 * Inc. ("Apple") in consideration of your agreement to the following

 * terms, and your use, installation, modification or redistribution of

 * this Apple software constitutes acceptance of these terms.  If you do

 * not agree with these terms, please do not use, install, modify or

 * redistribute this Apple software.

 *

 * In consideration of your agreement to abide by the following terms, and

 * subject to these terms, Apple grants you a personal, non-exclusive

 * license, under Apple's copyrights in this original Apple software (the

 * "Apple Software"), to use, reproduce, modify and redistribute the Apple

 * Software, with or without modifications, in source and/or binary forms;

 * provided that if you redistribute the Apple Software in its entirety and

 * without modifications, you must retain this notice and the following

 * text and disclaimers in all such redistributions of the Apple Software.

 * Neither the name, trademarks, service marks or logos of Apple Computer,

 * Inc. may be used to endorse or promote products derived from the Apple

 * Software without specific prior written permission from Apple.  Except

 * as expressly stated in this notice, no other rights or licenses, express

 * or implied, are granted by Apple herein, including but not limited to

 * any patent rights that may be infringed by your derivative works or by

 * other works in which the Apple Software may be incorporated.

 *

 * The Apple Software is provided by Apple on an "AS IS" basis.  APPLE

 * MAKES NO WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION

 * THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS

 * FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND

 * OPERATION ALONE OR IN COMBINATION WITH YOUR PRODUCTS.

 *

 * IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL

 * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION,

 * MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED

 * AND WHETHER UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE),

 * STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE

 * POSSIBILITY OF SUCH DAMAGE.

 */

/*

 * Include necessary headers.

 */

#include <stdio.h>

#include <stdlib.h>

#include <errno.h>

#include <signal.h>

#include <fcntl.h>

#include <termios.h>

#include <unistd.h>

#include <sys/stat.h>

#include <sys/sysctl.h>

#include <libgen.h>

#include <mach/mach.h>

#include <mach/mach_error.h>

#include <mach/mach_time.h>

#include <cups/debug-private.h>

#include <cups/file-private.h>

#include <cups/sidechannel.h>

#include <cups/language-private.h>

#include <cups/ppd-private.h>

#include "backend-private.h"

#include <CoreFoundation/CoreFoundation.h>

#include <IOKit/usb/IOUSBLib.h>

#include <IOKit/IOCFPlugIn.h>

#include <libproc.h>

#include <asl.h>

#include <spawn.h>

#include <pthread.h>

/*

 * Include necessary headers.

 */

extern char **environ;

/*

 * 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 DEBUG_WRITES 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_DELAY			7

#define WAIT_SIDE_DELAY			3

#define DEFAULT_TIMEOUT			5000L

#define	USB_INTERFACE_KIND		CFUUIDGetUUIDBytes(kIOUSBInterfaceInterfaceID245)

#define kUSBLanguageEnglish		0x409

#define PRINTER_POLLING_INTERVAL	5			/* seconds */

#define INITIAL_LOG_INTERVAL		PRINTER_POLLING_INTERVAL

#define SUBSEQUENT_LOG_INTERVAL		3 * INITIAL_LOG_INTERVAL

#define kUSBPrinterClassTypeID		CFUUIDGetConstantUUIDWithBytes(NULL, 0x06, 0x04, 0x7D, 0x16, 0x53, 0xA2, 0x11, 0xD6, 0x92, 0x06, 0x00, 0x30, 0x65, 0x52, 0x45, 0x92)

#define	kUSBPrinterClassInterfaceID	CFUUIDGetConstantUUIDWithBytes(NULL, 0x03, 0x34, 0x6D, 0x74, 0x53, 0xA3, 0x11, 0xD6, 0x9E, 0xA1, 0x76, 0x30, 0x65, 0x52, 0x45, 0x92)

#define kUSBClassDriverProperty		CFSTR("USB Printing Class")

#define kUSBGenericTOPrinterClassDriver	CFSTR("/System/Library/Printers/Libraries/USBGenericPrintingClass.plugin")

#define kUSBPrinterClassDeviceNotOpen	-9664	/*kPMInvalidIOMContext*/

#define CRSetCrashLogMessage(m) _crc_make_setter(message, m)

#define _crc_make_setter(attr, arg) (gCRAnnotations.attr = (uint64_t)(unsigned long)(arg))

#define CRASH_REPORTER_CLIENT_HIDDEN __attribute__((visibility("hidden")))

#define CRASHREPORTER_ANNOTATIONS_VERSION 4

#define CRASHREPORTER_ANNOTATIONS_SECTION "__crash_info"

struct crashreporter_annotations_t {

	uint64_t version;		// unsigned long

	uint64_t message;		// char *

	uint64_t signature_string;	// char *

	uint64_t backtrace;		// char *

	uint64_t message2;		// char *

	uint64_t thread;		// uint64_t

	uint64_t dialog_mode;		// unsigned int

};

CRASH_REPORTER_CLIENT_HIDDEN

struct crashreporter_annotations_t gCRAnnotations

	__attribute__((section("__DATA," CRASHREPORTER_ANNOTATIONS_SECTION)))

	= { CRASHREPORTER_ANNOTATIONS_VERSION, 0, 0, 0, 0, 0, 0 };

/*

 * Section 5.3 USB Printing Class spec

 */

#define kUSBPrintingSubclass			1

#define kUSBPrintingProtocolNoOpen		0

#define kUSBPrintingProtocolUnidirectional	1

#define kUSBPrintingProtocolBidirectional	2

#define kUSBPrintingProtocolIPP			4

typedef IOUSBInterfaceInterface245	**printer_interface_t;

typedef struct iodevice_request_s	/**** Device request ****/

{

  UInt8		requestType;

  UInt8		request;

  UInt16	value;

  UInt16	index;

  UInt16	length;

  void		*buffer;

} iodevice_request_t;

typedef union				/**** Centronics status byte ****/

{

  char		b;

  struct

  {

    unsigned	reserved0:2;

    unsigned	paperError:1;

    unsigned	select:1;

    unsigned	notError:1;

    unsigned	reserved1:3;

  } status;

} centronics_status_t;

typedef struct classdriver_s		/**** g.classdriver context ****/

{

  IUNKNOWN_C_GUTS;

  CFPlugInRef		plugin;			/* release plugin */

  IUnknownVTbl		**factory;		/* Factory */

  void			*vendorReference;	/* vendor class specific usage */

  UInt32		location;		/* unique location in bus topology */

  UInt8			interfaceNumber;	/* Interface number */

  UInt16		vendorID;		/* Vendor id */

  UInt16		productID;		/* Product id */

  printer_interface_t	interface;		/* identify the device to IOKit */

  UInt8			outpipe;		/* mandatory bulkOut pipe */

  UInt8			inpipe;			/* optional bulkIn pipe */

  /* general class requests */

  kern_return_t (*DeviceRequest)(struct classdriver_s **printer, iodevice_request_t *iorequest, UInt16 timeout);

  kern_return_t	(*GetString)(struct classdriver_s **printer, UInt8 whichString, UInt16 language, UInt16 timeout, CFStringRef *result);

  /* standard printer class requests */

  kern_return_t	(*SoftReset)(struct classdriver_s **printer, UInt16 timeout);

  kern_return_t	(*GetCentronicsStatus)(struct classdriver_s **printer, centronics_status_t *result, UInt16 timeout);

  kern_return_t	(*GetDeviceID)(struct classdriver_s **printer, CFStringRef *devid, UInt16 timeout);

  /* standard bulk device requests */

  kern_return_t (*ReadPipe)(struct classdriver_s **printer, UInt8 *buffer, UInt32 *count);

  kern_return_t (*WritePipe)(struct classdriver_s **printer, UInt8 *buffer, UInt32 *count, Boolean eoj);

  /* interface requests */

  kern_return_t (*Open)(struct classdriver_s **printer, UInt32 location, UInt8 protocol);

  kern_return_t (*Abort)(struct classdriver_s **printer);

  kern_return_t (*Close)(struct classdriver_s **printer);

  /* initialize and terminate */

  kern_return_t (*Initialize)(struct classdriver_s **printer, struct classdriver_s **baseclass);

  kern_return_t (*Terminate)(struct classdriver_s **printer);

} classdriver_t;

typedef Boolean (*iterator_callback_t)(io_service_t obj, printer_interface_t printerIntf, void *refcon);

typedef struct iterator_reference_s	/**** Iterator reference data */

{

  iterator_callback_t callback;

  void		*userdata;

  Boolean	keepRunning;

} iterator_reference_t;

typedef struct globals_s

{

  io_service_t		printer_obj;

  classdriver_t		**classdriver;

  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;

  CFStringRef		make;

  CFStringRef		model;

  CFStringRef		serial;

  UInt32		location;

  UInt8			interfaceNum;

  UInt8			alternateSetting;

  UInt8                 interfaceProtocol;

  CFRunLoopTimerRef 	status_timer;

  int			print_fd;	/* File descriptor to print */

  ssize_t		print_bytes;	/* Print bytes read */

#if DEBUG_WRITES

  ssize_t		debug_bytes;	/* Current bytes to read */

#endif /* DEBUG_WRITES */

  Boolean		use_generic_class_driver;

  Boolean		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...

 */

globals_t g = { 0 };			/* Globals */

int Iterating = 0;			/* Are we iterating the bus? */

/*

 * Local functions...

 */

static Boolean list_device_cb(io_service_t obj, printer_interface_t printerIntf, void *refcon);

static Boolean find_device_cb(io_service_t obj, printer_interface_t printerIntf, void *refcon);

static CFStringRef cfstr_create_trim(const char *cstr);

static CFStringRef copy_value_for_key(CFStringRef deviceID, CFStringRef *keys);

static kern_return_t load_classdriver(CFStringRef driverPath, printer_interface_t interface, classdriver_t ***printerDriver);

static kern_return_t load_printerdriver(CFStringRef *driverBundlePath);

static kern_return_t registry_close(void);

static kern_return_t registry_open(CFStringRef *driverBundlePath);

static kern_return_t unload_classdriver(classdriver_t ***classdriver);

static void *read_thread(void *reference);

static void *sidechannel_thread(void *reference);

static void device_added(void *userdata, io_iterator_t iterator);

static void get_device_id(cups_sc_status_t *status, char *data, int *datalen);

static void iterate_printers(iterator_callback_t callBack, void *userdata);

static void parse_options(char *options, char *serial, int serial_size, UInt32 *location, Boolean *wait_eof);

static void setup_cfLanguage(void);

static void soft_reset(void);

static void status_timer_cb(CFRunLoopTimerRef timer, void *info);

#define IS_64BIT 1

#define IS_NOT_64BIT 0

#if defined(__i386__) || defined(__x86_64__)

static pid_t	child_pid;		/* Child PID */

static void run_legacy_backend(int argc, char *argv[], int fd) __attribute__((noreturn));	/* Starts child backend process running as a ppc executable */

#endif /* __i386__ || __x86_64__ */

static void sigterm_handler(int sig);	/* SIGTERM handler */

static void sigquit_handler(int sig, siginfo_t *si, void *unused) __attribute__((noreturn));

#ifdef PARSE_PS_ERRORS

static const char *next_line (const char *buffer);

static void parse_pserror (char *sockBuffer, int len);

#endif /* PARSE_PS_ERRORS */

static printer_interface_t usb_printer_interface_interface(io_service_t usbClass);

static CFStringRef copy_printer_interface_deviceid(printer_interface_t printer, UInt8 alternateSetting);

static CFStringRef copy_printer_interface_indexed_description(printer_interface_t  printer, UInt8 index, UInt16 language);

static CFStringRef deviceIDCopyManufacturer(CFStringRef deviceID);

static CFStringRef deviceIDCopyModel(CFStringRef deviceID);

static CFStringRef deviceIDCopySerialNumber(CFStringRef deviceID);

#pragma mark -

/*

 * 'list_devices()' - List all USB devices.

 */

void list_devices()

{

  iterate_printers(list_device_cb, NULL);

}

/*

 * 'print_device()' - Print a file to a USB device.

 */

int					/* O - Exit status */

print_device(const char *uri,		/* I - Device URI */

             const char *hostname,	/* I - Hostname/manufacturer */

             const char *resource,	/* I - Resource/modelname */

	     char       *options,	/* I - Device options/serial number */

	     int        print_fd,	/* I - File descriptor to print */

	     int        copies,		/* I - Copies to print */

	     int	argc,		/* I - Number of command-line arguments (6 or 7) */

	     char	*argv[])	/* I - Command-line arguments */

{

  char		  serial[1024];		/* Serial number buffer */

  OSStatus	  status;		/* Function results */

  IOReturn	  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 */

  char		  print_buffer[8192],	/* Print data buffer */

		  *print_ptr;		/* Pointer into print data buffer */

  UInt32	  location;		/* Unique location in bus topology */

  fd_set	  input_set;		/* Input set for select() */

  CFStringRef	  driverBundlePath;	/* Class driver path */

  int		  countdown,		/* Logging interval */

		  nfds;			/* Number of file descriptors */

  ssize_t	  total_bytes;		/* Total bytes written */

  UInt32	  bytes;		/* Bytes written */

  struct timeval  *timeout,		/* Timeout pointer */

		  tv;			/* Time value */

  struct timespec cond_timeout;		/* pthread condition timeout */

  struct sigaction action;		/* Actions for POSIX signals */

  (void)uri;

 /*

  * Catch SIGQUIT to determine who is sending it...

  */

  memset(&action, 0, sizeof(action));

  action.sa_sigaction = sigquit_handler;

  action.sa_flags = SA_SIGINFO;

  sigaction(SIGQUIT, &action, NULL);

 /*

  * See if the side-channel descriptor is valid...

  */

  have_sidechannel = !fstat(CUPS_SC_FD, &sidechannel_info) &&

                     S_ISSOCK(sidechannel_info.st_mode);

 /*

  * Localize using CoreFoundation...

  */

  setup_cfLanguage();

  parse_options(options, serial, sizeof(serial), &location, &g.wait_eof);

  if (resource[0] == '/')

    resource++;

  g.print_fd	= print_fd;

  g.make	= cfstr_create_trim(hostname);

  g.model	= cfstr_create_trim(resource);

  g.serial	= cfstr_create_trim(serial);

  g.location	= location;

  if (!g.make || !g.model)

  {

    fprintf(stderr, "DEBUG: Fatal USB error.\n");

    _cupsLangPrintFilter(stderr, "ERROR",

                         _("There was an unrecoverable USB error."));

    if (!g.make)

      fputs("DEBUG: USB make string is NULL\n", stderr);

    if (!g.model)

      fputs("DEBUG: USB model string is NULL\n", stderr);

    return (CUPS_BACKEND_STOP);

  }

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

  countdown = INITIAL_LOG_INTERVAL;

  do

  {

    if (g.printer_obj)

    {

      IOObjectRelease(g.printer_obj);

      unload_classdriver(&g.classdriver);

      g.printer_obj = 0x0;

      g.classdriver = 0x0;

    }

    fprintf(stderr, "DEBUG: Looking for '%s %s'\n", hostname, resource);

    do

    {

      iterate_printers(find_device_cb, NULL);

      if (g.printer_obj != 0x0)

        break;

      _cupsLangPrintFilter(stderr, "INFO", _("Waiting for printer to become available."));

      sleep(5);

    } while (true);

    fputs("DEBUG: Opening connection\n", stderr);

    driverBundlePath = NULL;

    status = registry_open(&driverBundlePath);

#if defined(__i386__) || defined(__x86_64__)

    /*

     * If we were unable to load the class drivers for this printer it's

     * probably because they're ppc or i386. In this case try to run this

     * backend as i386 or ppc executables so we can use them...

     */

    if (status == -2)

    {

      run_legacy_backend(argc, argv, print_fd);

      /* Never returns here */

    }

#endif /* __i386__ || __x86_64__ */

    if (status ==  -2)

    {

     /*

      * If we still were unable to load the class drivers for this printer log

      * the error and stop the queue...

      */

      if (driverBundlePath == NULL || !CFStringGetCString(driverBundlePath, print_buffer, sizeof(print_buffer), kCFStringEncodingUTF8))

        strlcpy(print_buffer, "USB class driver", sizeof(print_buffer));

      fputs("STATE: +apple-missing-usbclassdriver-error\n", stderr);

      _cupsLangPrintFilter(stderr, "ERROR",

			   _("There was an unrecoverable USB error."));

      fprintf(stderr, "DEBUG: Could not load %s\n", print_buffer);

      if (driverBundlePath)

	CFRelease(driverBundlePath);

      return (CUPS_BACKEND_STOP);

    }

    if (driverBundlePath)

      CFRelease(driverBundlePath);

    if (status != noErr)

    {

      sleep(PRINTER_POLLING_INTERVAL);

      countdown -= PRINTER_POLLING_INTERVAL;

      if (countdown <= 0)

      {

	_cupsLangPrintFilter(stderr, "INFO",

		             _("Waiting for printer to become available."));

	fprintf(stderr, "DEBUG: USB printer status: 0x%08x\n", (int)status);

	countdown = SUBSEQUENT_LOG_INTERVAL;	/* subsequent log entries, every 15 seconds */

      }

    }

  } while (status != noErr);

  fputs("STATE: -connecting-to-device\n", stderr);

  /*

   * Now that we are "connected" to the port, ignore SIGTERM so that we

   * can finish out any page data the driver sends (e.g. to eject the

   * current page...  Only ignore SIGTERM if we are printing data from

   * stdin (otherwise you can't cancel raw jobs...)

   */

  if (!print_fd)

  {

    memset(&action, 0, sizeof(action));

    sigemptyset(&action.sa_mask);

    action.sa_handler = SIG_IGN;

    sigaction(SIGTERM, &action, NULL);

  }

 /*

  * 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);

      registry_close();

      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);

    registry_close();

    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 == noErr && 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);

    }

    while (status == noErr)

    {

      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);

     /*

      * 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)

	{

	  fputs("DEBUG: Received an interrupt before any bytes were "

	        "written, aborting\n", stderr);

          registry_close();

          return (CUPS_BACKEND_OK);

	}

	else if (errno != EAGAIN && errno != EINTR)

	{

	  _cupsLangPrintFilter(stderr, "ERROR",

	                       _("Unable to read print data."));

	  perror("DEBUG: select");

	  registry_close();

          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 read print data."));

	    perror("DEBUG: read");

	    registry_close();

	    return (CUPS_BACKEND_FAILED);

	  }

	  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)

      {

	bytes    = (UInt32)g.print_bytes;

	iostatus = (*g.classdriver)->WritePipe(g.classdriver, (UInt8*)print_ptr, &bytes, 0);

       /*

	* Ignore timeout errors, but retain the number of bytes written to

	* avoid sending duplicate data...

	*/

	if (iostatus == kIOUSBTransactionTimeout)

	{

	  fputs("DEBUG: Got USB transaction timeout during write\n", stderr);

	  iostatus = 0;

	}

       /*

        * If we've stalled, retry the write...

	*/

	else if (iostatus == kIOUSBPipeStalled)

	{

	  fputs("DEBUG: Got USB pipe stalled during write\n", stderr);

	  bytes    = (UInt32)g.print_bytes;

	  iostatus = (*g.classdriver)->WritePipe(g.classdriver, (UInt8*)print_ptr, &bytes, 0);

	}

       /*

	* Retry a write after an aborted write since we probably just got

	* SIGTERM...

	*/

	else if (iostatus == kIOReturnAborted)

	{

	  fputs("DEBUG: Got USB return aborted during write\n", stderr);

	  IOReturn err = (*g.classdriver)->Abort(g.classdriver);

	  fprintf(stderr, "DEBUG: USB class driver Abort returned %x\n", err);

#if DEBUG_WRITES

          sleep(5);

#endif /* DEBUG_WRITES */

	  bytes    = (UInt32)g.print_bytes;

	  iostatus = (*g.classdriver)->WritePipe(g.classdriver, (UInt8*)print_ptr, &bytes, 0);

        }

	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: USB class driver WritePipe returned %x\n",

	          iostatus);

	  IOReturn err = (*g.classdriver)->Abort(g.classdriver);

	  fprintf(stderr, "DEBUG: USB class driver Abort returned %x\n",

	          err);

	  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 == noErr)

	fprintf(stderr, "DEBUG: Sending print file, %lld bytes...\n",

		(off_t)total_bytes);

    }

  }

  fprintf(stderr, "DEBUG: Sent %lld bytes...\n", (off_t)total_bytes);

  fputs("STATE: +cups-waiting-for-job-completed\n", stderr);

 /*

  * 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 (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;

      (*g.classdriver)->Abort(g.classdriver);

      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);

 /*

  * Close the connection and input file and general clean up...

  */

  registry_close();

  if (print_fd != STDIN_FILENO)

    close(print_fd);