Update ipp documentation to reflect the behavior of configuring WiFi on IPP USB printers.

[thirdparty/cups.git] / backend / usb-darwin.c

/*
 * USB backend for macOS.
 *
 * Copyright © 2005-2021 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(__arm64e__)
static pid_t    child_pid;              /* Child PID */
static void run_legacy_backend(int argc, char *argv[], int fd) _CUPS_NORETURN;  /* Starts child backend process running as a x86_64 executable */
static void sigterm_handler(int sig);    /* SIGTERM handler */
#endif /* __arm64e__ */
static void sigquit_handler(int sig, siginfo_t *si, void *unused) _CUPS_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;
  (void)argc;
  (void)argv;

 /*
  * 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(__arm64e__)
    /*
     * If we were unable to load the class drivers for this printer it's
     * probably because they're x86_64 (or older). In this case try to run this
     * backend as x86_64 so we can use them...
     */
    if (status == -2)
    {
      run_legacy_backend(argc, argv, print_fd);
      /* Never returns here */
    }
#endif /* __arm64e__ */

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

  if (g.make != NULL)
    CFRelease(g.make);

  if (g.model != NULL)
    CFRelease(g.model);

  if (g.serial != NULL)
    CFRelease(g.serial);

  if (g.printer_obj != 0x0)
    IOObjectRelease(g.printer_obj);

  return status;
}


/*
 * 'read_thread()' - Thread to read the backchannel data on.
 */

static void *read_thread(void *reference)
{
  UInt8                         readbuffer[512];
  UInt32                        rbytes;
  kern_return_t                 readstatus;
  struct mach_timebase_info     timeBaseInfo;
  uint64_t                      start,
                                delay;


  (void)reference;

  /* Calculate what 250 milliSeconds are in mach absolute time...
   */
  mach_timebase_info(&timeBaseInfo);
  delay = ((uint64_t)250000000 * (uint64_t)timeBaseInfo.denom) / (uint64_t)timeBaseInfo.numer;

  do
  {
   /*
    * Remember when we started so we can throttle the loop after the read call...
    */

    start = mach_absolute_time();

    rbytes = sizeof(readbuffer);
    readstatus = (*g.classdriver)->ReadPipe(g.classdriver, readbuffer, &rbytes);
    if (readstatus == kIOReturnSuccess && rbytes > 0)
    {
      fprintf(stderr, "DEBUG: Read %d bytes of back-channel data...\n",
              (int)rbytes);
      cupsBackChannelWrite((char*)readbuffer, rbytes, 1.0);

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

#ifdef PARSE_PS_ERRORS
      parse_pserror(readbuffer, rbytes);
#endif
    }
    else if (readstatus == kIOUSBTransactionTimeout)
      fputs("DEBUG: Got USB transaction timeout during read\n", stderr);
    else if (readstatus == kIOUSBPipeStalled)
      fputs("DEBUG: Got USB pipe stalled during read\n", stderr);
    else if (readstatus == kIOReturnAborted)
      fputs("DEBUG: Got USB return aborted during read\n", stderr);

   /*
    * Make sure this loop executes no more than once every 250 miliseconds...
    */

    if ((readstatus != kIOReturnSuccess || rbytes == 0) && (g.wait_eof || !g.read_thread_stop))
      mach_wait_until(start + delay);

  } while (g.wait_eof || !g.read_thread_stop);  /* Abort from main thread tests error here */

  /* Workaround for usb race condition. <rdar://problem/21882551> */
  if (!g.wait_eof && g.use_generic_class_driver)
  {
     const char *pdl = getenv("FINAL_CONTENT_TYPE");
     if (pdl && strcmp(pdl, "application/vnd.cups-postscript") == 0)
     {
       while (readstatus == kIOReturnSuccess && ((rbytes > 0 && readbuffer[rbytes-1] != 0x4) || rbytes == 0))
       {
         start = mach_absolute_time();

         rbytes = sizeof(readbuffer);
         readstatus = (*g.classdriver)->ReadPipe(g.classdriver, readbuffer, &rbytes);
         if (readstatus == kIOReturnSuccess && rbytes > 0 && readbuffer[rbytes-1] == 0x4)
           break;

         /* Make sure this loop executes no more than once every 250 miliseconds... */
         mach_wait_until(start + delay);
       }
     }
  }

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

          if ((*g.classdriver)->SoftReset != NULL)
          {
            soft_reset();
            cupsSideChannelWrite(command, CUPS_SC_STATUS_OK, NULL, 0, 1.0);
            fputs("DEBUG: Returning status CUPS_STATUS_OK with no bytes...\n",
                  stderr);
          }
          else
          {
            cupsSideChannelWrite(command, CUPS_SC_STATUS_NOT_IMPLEMENTED,
                                 NULL, 0, 1.0);
            fputs("DEBUG: Returning status CUPS_STATUS_NOT_IMPLEMENTED 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] = (char)g.bidi_flag;
          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);
          get_device_id(&status, data, &datalen);
          cupsSideChannelWrite(command, CUPS_SC_STATUS_OK, data, datalen, 1.0);

          if ((size_t)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;

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


#pragma mark -
/*
 * 'iterate_printers()' - Iterate over all the printers.
 */
static void iterate_printers(iterator_callback_t callBack, void *userdata)
{
  Iterating = 1;

  iterator_reference_t reference = { callBack, userdata, true };

  IONotificationPortRef addNotification = IONotificationPortCreate(kIOMasterPortDefault);

  int printingClass = kUSBPrintingClass;
  int printingSubclass = kUSBPrintingSubclass;

  CFNumberRef interfaceClass = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &printingClass);
  CFNumberRef interfaceSubClass = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &printingSubclass);

  CFMutableDictionaryRef usbPrinterMatchDictionary = IOServiceMatching(kIOUSBInterfaceClassName);
  CFDictionaryAddValue(usbPrinterMatchDictionary, CFSTR("bInterfaceClass"), interfaceClass);
  CFDictionaryAddValue(usbPrinterMatchDictionary, CFSTR("bInterfaceSubClass"), interfaceSubClass);

  CFRelease(interfaceClass);
  CFRelease(interfaceSubClass);

  io_iterator_t add_iterator = IO_OBJECT_NULL;
  IOServiceAddMatchingNotification(addNotification, kIOMatchedNotification,
                usbPrinterMatchDictionary, &device_added, &reference, &add_iterator);
  if (add_iterator != IO_OBJECT_NULL)
  {
    device_added (&reference, add_iterator);
    if (reference.keepRunning)
    {
      CFRunLoopAddSource(CFRunLoopGetCurrent(), IONotificationPortGetRunLoopSource(addNotification), kCFRunLoopDefaultMode);
      CFRunLoopRun();
    }
    IOObjectRelease(add_iterator);
  }
  Iterating = 0;
}


/*
 * 'device_added()' - Device added notifier.
 */
static void device_added(void *userdata, io_iterator_t iterator)
{
  iterator_reference_t *reference = userdata;
  io_service_t intf;

  while (reference->keepRunning && (intf = IOIteratorNext(iterator)) != 0x0)
  {
    printer_interface_t printerIntf = usb_printer_interface_interface(intf);
    if (printerIntf != NULL)
    {
      UInt8 intfClass = 0, intfSubClass = 0;

      (*printerIntf)->GetInterfaceClass(printerIntf, &intfClass);
      (*printerIntf)->GetInterfaceSubClass(printerIntf, &intfSubClass);
      if (intfClass == kUSBPrintingInterfaceClass && intfSubClass == kUSBPrintingSubclass)
        reference->keepRunning = reference->callback(intf, printerIntf, userdata);
        (*printerIntf)->Release(printerIntf);
      }
      IOObjectRelease(intf);
    }

    if (reference->keepRunning && reference->callback)
      reference->keepRunning = reference->callback(IO_OBJECT_NULL, NULL, reference->userdata);

    if (!reference->keepRunning)
      CFRunLoopStop(CFRunLoopGetCurrent());
}

/*
 * 'list_device_cb()' - list_device iterator callback.
 */
static Boolean list_device_cb(io_service_t obj, printer_interface_t printerIntf, void *refcon)
{
  (void)refcon;

  if (obj != IO_OBJECT_NULL)
  {
    CFStringRef deviceIDString = NULL;
    CFStringRef make = NULL;
    CFStringRef model = NULL;
    CFStringRef serial = NULL;
    UInt32 intfLocation;

    deviceIDString = copy_printer_interface_deviceid(printerIntf, 0);
    if (deviceIDString == NULL)
      goto list_device_done;

    make = deviceIDCopyManufacturer(deviceIDString);
    model = deviceIDCopyModel(deviceIDString);
    serial = deviceIDCopySerialNumber(deviceIDString);

    char uristr[1024], makestr[1024], modelstr[1024], serialstr[1024];
    char optionsstr[1024], idstr[1024], make_modelstr[1024];

    CFStringGetCString(deviceIDString, idstr, sizeof(idstr), kCFStringEncodingUTF8);
    backendGetMakeModel(idstr, make_modelstr, sizeof(make_modelstr));

    modelstr[0] = '/';

    if (make  == NULL || !CFStringGetCString(make, makestr, sizeof(makestr), kCFStringEncodingUTF8))
      strlcpy(makestr, "Unknown", sizeof(makestr));

    if (model == NULL || !CFStringGetCString(model, &modelstr[1], sizeof(modelstr)-1, kCFStringEncodingUTF8))
      strlcpy(modelstr + 1, "Printer", sizeof(modelstr) - 1);

    optionsstr[0] = '\0';
    if (serial != NULL && CFStringGetCString(serial, serialstr, sizeof(serialstr), kCFStringEncodingUTF8))
      snprintf(optionsstr, sizeof(optionsstr), "?serial=%s", serialstr);
    else if ((*printerIntf)->GetLocationID(printerIntf, &intfLocation) == kIOReturnSuccess)
      snprintf(optionsstr, sizeof(optionsstr), "?location=%x", (unsigned)intfLocation);

    httpAssembleURI(HTTP_URI_CODING_ALL, uristr, sizeof(uristr), "usb", NULL, makestr, 0, modelstr);
    strlcat(uristr, optionsstr, sizeof(uristr));

    cupsBackendReport("direct", uristr, make_modelstr, make_modelstr, idstr,
                          NULL);
  list_device_done:

    if (make != NULL) CFRelease(make);
    if (model != NULL) CFRelease(model);
    if (serial != NULL) CFRelease(serial);
  }
  return obj != IO_OBJECT_NULL;
}

/*
 * 'find_device_cb()' - print_device iterator callback.
 */
static Boolean find_device_cb(io_service_t obj, printer_interface_t printerIntf, void *refcon)
{
  (void)refcon;

  Boolean keepLooking = true;

  if (obj != IO_OBJECT_NULL)
  {
    CFStringRef deviceIDString = NULL;
    CFStringRef make = NULL;
    CFStringRef model = NULL;
    CFStringRef serial = NULL;

    deviceIDString = copy_printer_interface_deviceid(printerIntf, 0);
    if (deviceIDString == NULL)
      goto find_device_done;

    make = deviceIDCopyManufacturer(deviceIDString);
    model = deviceIDCopyModel(deviceIDString);
    serial = deviceIDCopySerialNumber(deviceIDString);

    if (make && CFStringCompare(make, g.make, kCFCompareCaseInsensitive) == kCFCompareEqualTo)
    {
      if (model && CFStringCompare(model, g.model, kCFCompareCaseInsensitive) == kCFCompareEqualTo)
      {
        UInt8 intfAltSetting = 0, intfNumber = 0, intfProtocol = 0;
        UInt32 intfLocation = 0;

        (*printerIntf)->GetInterfaceProtocol(printerIntf, &intfProtocol);
        (*printerIntf)->GetAlternateSetting(printerIntf, &intfAltSetting);
        (*printerIntf)->GetInterfaceNumber(printerIntf, &intfNumber);
        (*printerIntf)->GetLocationID(printerIntf, &intfLocation);

        if (intfProtocol == kUSBPrintingProtocolIPP)
            return keepLooking;

        if (g.serial != NULL && CFStringGetLength(g.serial) > 0)
        {
          if (serial != NULL && CFStringCompare(serial, g.serial, kCFCompareCaseInsensitive) == kCFCompareEqualTo)
          {
            g.interfaceProtocol = intfProtocol;
            g.location = intfLocation;
            g.alternateSetting = intfAltSetting;
            g.printer_obj = obj;
            IOObjectRetain(obj);
            keepLooking = false;
          }
        }
        else
        {
          if (g.printer_obj != 0)
            IOObjectRelease(g.printer_obj);

            if (g.location == 0 || g.location == intfLocation)
                keepLooking = false;

            g.location = intfLocation;
            g.alternateSetting = intfAltSetting;
            g.interfaceProtocol = intfProtocol;
            g.printer_obj = obj;
            IOObjectRetain(obj);
        }

        if (!keepLooking)
          g.interfaceNum = intfNumber;
      }
    }

  find_device_done:
    if (deviceIDString != NULL) CFRelease(deviceIDString);
    if (make != NULL) CFRelease(make);
    if (model != NULL) CFRelease(model);
    if (serial != NULL) CFRelease(serial);
  }
  else
  {
    keepLooking = (g.printer_obj == 0 && g.interfaceProtocol != kUSBPrintingProtocolIPP);
    if (obj == IO_OBJECT_NULL && keepLooking)
    {
      CFRunLoopTimerContext context = { 0, refcon, NULL, NULL, NULL };
      CFRunLoopTimerRef timer = CFRunLoopTimerCreate(NULL, CFAbsoluteTimeGetCurrent() + 1.0, 10, 0x0, 0x0, status_timer_cb, &context);
      if (timer != NULL)
      {
        CFRunLoopAddTimer(CFRunLoopGetCurrent(), timer, kCFRunLoopDefaultMode);
        g.status_timer = timer;
      }
    }
  }

  if (!keepLooking && g.status_timer != NULL)
  {
    fputs("STATE: -offline-report\n", stderr);
    _cupsLangPrintFilter(stderr, "INFO", _("The printer is now online."));
    CFRunLoopRemoveTimer(CFRunLoopGetCurrent(), g.status_timer, kCFRunLoopDefaultMode);
    CFRelease(g.status_timer);
    g.status_timer = NULL;
  }

  return keepLooking;
}

static CFStringRef deviceIDCopySerialNumber(CFStringRef deviceID)
{
    CFStringRef serialKeys[] = { CFSTR("SN:"),  CFSTR("SERN:"), NULL };

    return copy_value_for_key(deviceID, serialKeys);
}

static CFStringRef deviceIDCopyModel(CFStringRef deviceID)
{
    CFStringRef modelKeys[] = { CFSTR("MDL:"), CFSTR("MODEL:"), NULL };
    return copy_value_for_key(deviceID, modelKeys);
}

static CFStringRef deviceIDCopyManufacturer(CFStringRef deviceID)
{
    CFStringRef makeKeys[]   = { CFSTR("MFG:"), CFSTR("MANUFACTURER:"), NULL };
    return copy_value_for_key(deviceID, makeKeys);
}

/*
 * 'status_timer_cb()' - Status timer callback.
 */

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

  fputs("STATE: +offline-report\n", stderr);
  _cupsLangPrintFilter(stderr, "INFO", _("The printer is offline."));

  if (getenv("CLASS") != NULL)
  {
   /*
    * If the CLASS environment variable is set, the job was submitted
    * to a class and not to a specific queue.  In this case, we want
    * to abort immediately so that the job can be requeued on the next
    * available printer in the class.
    *
    * Sleep 5 seconds to keep the job from requeuing too rapidly...
    */

    sleep(5);

    exit(CUPS_BACKEND_FAILED);
  }
}


#pragma mark -
/*
 * 'load_classdriver()' - Load a classdriver.
 */

static kern_return_t load_classdriver(CFStringRef           driverPath,
                                      printer_interface_t   interface,
                                      classdriver_t         ***printerDriver)
{
  kern_return_t kr = kUSBPrinterClassDeviceNotOpen;
  classdriver_t **driver = NULL;
  CFStringRef   bundle = driverPath ? driverPath : kUSBGenericTOPrinterClassDriver;
  char          bundlestr[1024];        /* Bundle path */
  CFURLRef      url;                    /* URL for driver */
  CFPlugInRef   plugin = NULL;          /* Plug-in address */


  CFStringGetCString(bundle, bundlestr, sizeof(bundlestr), kCFStringEncodingUTF8);

 /*
  * Validate permissions for the class driver...
  */

  _cups_fc_result_t result = _cupsFileCheck(bundlestr,
                                            _CUPS_FILE_CHECK_DIRECTORY, 1,
                                            Iterating ? NULL : _cupsFileCheckFilter, NULL);

  if (result && driverPath)
    return (load_classdriver(NULL, interface, printerDriver));
  else if (result)
    return (kr);

 /*
  * Try loading the class driver...
  */

  url = CFURLCreateWithFileSystemPath(NULL, bundle, kCFURLPOSIXPathStyle, true);

  if (url)
  {
    plugin = CFPlugInCreate(NULL, url);
    CFRelease(url);
  }
  else
    plugin = NULL;

  if (plugin)
  {
    CFArrayRef factories = CFPlugInFindFactoriesForPlugInTypeInPlugIn(kUSBPrinterClassTypeID, plugin);
    if (factories != NULL && CFArrayGetCount(factories) > 0)
    {
      CFUUIDRef factoryID = CFArrayGetValueAtIndex(factories, 0);
      IUnknownVTbl **iunknown = CFPlugInInstanceCreate(NULL, factoryID, kUSBPrinterClassTypeID);
      if (iunknown != NULL)
      {
        kr = (*iunknown)->QueryInterface(iunknown, CFUUIDGetUUIDBytes(kUSBPrinterClassInterfaceID), (LPVOID *)&driver);
        if (kr == kIOReturnSuccess && driver != NULL)
        {
          classdriver_t **genericDriver = NULL;
          if (driverPath != NULL && CFStringCompare(driverPath, kUSBGenericTOPrinterClassDriver, 0) != kCFCompareEqualTo)
            kr = load_classdriver(NULL, interface, &genericDriver);

          if (kr == kIOReturnSuccess)
          {
            (*driver)->interface = interface;
            (*driver)->Initialize(driver, genericDriver);

            (*driver)->plugin = plugin;
            (*driver)->interface = interface;
            *printerDriver = driver;
          }
        }
        (*iunknown)->Release(iunknown);
      }
      CFRelease(factories);
    }
  }

  fprintf(stderr, "DEBUG: load_classdriver(%s) (kr:0x%08x)\n", bundlestr, (int)kr);

  return (kr);
}


/*
 * 'unload_classdriver()' - Unload a classdriver.
 */

static kern_return_t unload_classdriver(classdriver_t ***classdriver)
{
  if (*classdriver != NULL)
  {
    (**classdriver)->Release(*classdriver);
    *classdriver = NULL;
  }

  return kIOReturnSuccess;
}


/*
 * 'load_printerdriver()' - Load vendor's classdriver.
 *
 * If driverBundlePath is not NULL on return it is the callers responsbility to release it!
 */

static kern_return_t load_printerdriver(CFStringRef *driverBundlePath)
{
  IOCFPlugInInterface   **iodev = NULL;
  SInt32                score;
  kern_return_t         kr;
  printer_interface_t   interface;

  kr = IOCreatePlugInInterfaceForService(g.printer_obj, kIOUSBInterfaceUserClientTypeID, kIOCFPlugInInterfaceID, &iodev, &score);
  if (kr == kIOReturnSuccess)
  {
    if ((*iodev)->QueryInterface(iodev, USB_INTERFACE_KIND, (LPVOID *) &interface) == noErr)
    {
      *driverBundlePath = IORegistryEntryCreateCFProperty(g.printer_obj, kUSBClassDriverProperty, NULL, kNilOptions);

      g.use_generic_class_driver = (*driverBundlePath == NULL || (CFStringCompare(*driverBundlePath, kUSBGenericTOPrinterClassDriver, 0x0) == kCFCompareEqualTo));
      kr = load_classdriver(*driverBundlePath, interface, &g.classdriver);

      if (kr != kIOReturnSuccess)
        (*interface)->Release(interface);
    }
    IODestroyPlugInInterface(iodev);
  }
  return kr;
}

static printer_interface_t usb_printer_interface_interface(io_service_t usbClass)
{
        printer_interface_t  intf = NULL;
        IOCFPlugInInterface **plugin = NULL;
        SInt32  score;
        int kr = IOCreatePlugInInterfaceForService(usbClass, kIOUSBInterfaceUserClientTypeID, kIOCFPlugInInterfaceID, &plugin, &score);
        if (kr == kIOReturnSuccess)
        {
                (*plugin)->QueryInterface(plugin, USB_INTERFACE_KIND, (LPVOID *)&intf);
                IODestroyPlugInInterface(plugin);
        }

        return intf;
}

static CFStringRef copy_printer_interface_deviceid(printer_interface_t printer, UInt8 alternateSetting)
{
        // I have tried to make this function as neat as I can, but the possibility of needing to resend
        // a request to get the entire string makes it hideous...
        //
        // We package the job of sending a request up into the block (^sendRequest), which takes the size
        // it should allocate for the message buffer. It frees the current buffer if one is set and
        // allocates one of the specified size, then performs the request. We can then easily retry by
        // calling the block again if we fail to get the whole string the first time around.

        #define kUSBPrintClassGetDeviceID           0
        #define kDefaultNoDataTimeout               5000L
        #define pack_device_id_wIndex(intf, alt)  ((UInt16)((((UInt16)(intf)) << 8) | ((UInt8)(alt))))

        if (printer == NULL)
                        return NULL;


        IOReturn err        = kIOReturnError;
        UInt8    configurationIndex     = 0;
        UInt8    interfaceNumber        = 0;
        size_t   bufferLength           = 256;
        CFStringRef ret             = NULL;

        if ((*printer)->GetConfigurationValue( printer, &configurationIndex) == kIOReturnSuccess &&
                        (*printer)->GetInterfaceNumber( printer, &interfaceNumber) == kIOReturnSuccess)
        {
                __block IOUSBDevRequestTO       request;
                IOReturn (^sendRequest)(size_t) = ^ (size_t size)
                {
                        if (request.pData)
                        {
                                free(request.pData);
                                request.wLength = 0;
                                request.pData = NULL;
                        }

                        IOReturn berr = kIOReturnError;
                        char *buffer = malloc(size);
                        if (buffer == NULL)
                                return kIOReturnNoMemory;

                        request.wLength = HostToUSBWord(size);
                        request.pData = buffer;
                        berr = (*printer)->ControlRequestTO(printer, (UInt8)0, &request);
                        return berr;
                };

                /* This request takes the 0 based configuration index. IOKit returns a 1 based configuration index */
                configurationIndex -= 1;

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

                request.bmRequestType           = USBmakebmRequestType(kUSBIn, kUSBClass, kUSBInterface);
                request.bRequest                        = kUSBPrintClassGetDeviceID;
                request.wValue                          = HostToUSBWord(configurationIndex);
                request.wIndex                          = HostToUSBWord(pack_device_id_wIndex(interfaceNumber, alternateSetting));
                request.noDataTimeout           = kDefaultNoDataTimeout;
                request.completionTimeout       = 0; // Copying behavior from Generic Class Driver

                err = sendRequest(bufferLength);

                if (err == kIOReturnSuccess && request.wLenDone > 1)
                {
                        UInt16 actualLength = OSSwapBigToHostInt16(*((UInt16 *)request.pData));

                        if (actualLength > 2 && actualLength <= bufferLength - 2)
                        {
                                ret = CFStringCreateWithBytes(NULL, (const UInt8 *)request.pData + 2, actualLength - 2, kCFStringEncodingUTF8, false);
                        }
                        else if (actualLength > 2) {
                                err = sendRequest(actualLength);
                                if (err == kIOReturnSuccess && request.wLenDone > 0)
                                {
                                        actualLength = OSSwapBigToHostInt16(*((UInt16 *)request.pData));
                                        ret = CFStringCreateWithBytes(NULL, (const UInt8 *)request.pData + 2, actualLength - 2, kCFStringEncodingUTF8, false);
                                }
                        }
                }

                if (request.pData)
                        free(request.pData);
        }

        CFStringRef manufacturer = deviceIDCopyManufacturer(ret);
        CFStringRef model = deviceIDCopyModel(ret);
        CFStringRef serial = deviceIDCopySerialNumber(ret);

        if (manufacturer == NULL || serial == NULL || model == NULL)
        {
                IOUSBDevRequestTO               request;
                IOUSBDeviceDescriptor   desc;

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

                request.bmRequestType = USBmakebmRequestType( kUSBIn,  kUSBStandard, kUSBDevice );
                request.bRequest = kUSBRqGetDescriptor;
                request.wValue = kUSBDeviceDesc << 8;
                request.wIndex = 0;
                request.wLength = sizeof(desc);
                request.pData = &desc;
                request.completionTimeout = 0;
                request.noDataTimeout = 60L;

                err = (*printer)->ControlRequestTO(printer, 0, &request);
                if (err == kIOReturnSuccess)
                {
                        CFMutableStringRef extras = CFStringCreateMutable(NULL, 0);
                        if (manufacturer == NULL)
                        {
                                manufacturer = copy_printer_interface_indexed_description(printer, desc.iManufacturer, kUSBLanguageEnglish);
                                if (manufacturer && CFStringGetLength(manufacturer) > 0)
                                        CFStringAppendFormat(extras, NULL, CFSTR("MFG:%@;"), manufacturer);
                        }

                        if (model == NULL)
                        {
                                model = copy_printer_interface_indexed_description(printer, desc.iProduct, kUSBLanguageEnglish);
                                if (model && CFStringGetLength(model) > 0)
                                        CFStringAppendFormat(extras, NULL, CFSTR("MDL:%@;"), model);
                        }

                        if (desc.iSerialNumber != 0)
                        {
                                // Always look at the USB serial number since some printers
                                // incorrectly include a bogus static serial number in their
                                // IEEE-1284 device ID string...
                                CFStringRef userial = copy_printer_interface_indexed_description(printer, desc.iSerialNumber, kUSBLanguageEnglish);
                                if (userial && CFStringGetLength(userial) > 0 && (serial == NULL || CFStringCompare(serial, userial, kCFCompareCaseInsensitive) != kCFCompareEqualTo))
                                {
                                        if (serial != NULL)
                                        {
                                                // 1284 serial number doesn't match USB serial number, so  replace the existing SERN: in device ID
                                                CFRange range = CFStringFind(ret, serial, 0);
                                                CFMutableStringRef deviceIDString = CFStringCreateMutableCopy(NULL, 0, ret);
                                                CFStringReplace(deviceIDString, range, userial);
                                                CFRelease(ret);
                                                ret = deviceIDString;

                                                CFRelease(serial);
                                        }
                                        else
                                        {
                                                // No 1284 serial number so add SERN: with USB serial number to device ID
                                                CFStringAppendFormat(extras, NULL, CFSTR("SERN:%@;"), userial);
                                        }
                                        serial = userial;
                                }
                                else if (userial != NULL)
                                        CFRelease(userial);
                        }

                        if (ret != NULL)
                        {
                                CFStringAppend(extras, ret);
                                CFRelease(ret);
                        }
      ret = extras;
                }
        }

        if (ret != NULL)
        {
                /* Remove special characters from the serial number */
                CFRange range = (serial != NULL ? CFStringFind(serial, CFSTR("+"), 0) : CFRangeMake(0, 0));
                if (range.length == 1)
                {
                        range = CFStringFind(ret, serial, 0);

                        CFMutableStringRef deviceIDString = CFStringCreateMutableCopy(NULL, 0, ret);
                        CFRelease(ret);

                        ret = deviceIDString;
                        CFStringFindAndReplace(deviceIDString, CFSTR("+"), CFSTR(""), range, 0);
                }
        }

        if (manufacturer != NULL)
                CFRelease(manufacturer);

        if (model != NULL)
                CFRelease(model);

        if (serial != NULL)
                CFRelease(serial);

        if (ret != NULL && CFStringGetLength(ret) == 0)
        {
                CFRelease(ret);
                return NULL;
        }

        return ret;
}

static CFStringRef copy_printer_interface_indexed_description(printer_interface_t  printer, UInt8 index, UInt16 language)
{
        IOReturn err;
        UInt8 description[256]; // Max possible descriptor length
        IOUSBDevRequestTO       request;

        memset(description, 0, 2);

        request.bmRequestType = USBmakebmRequestType(kUSBIn, kUSBStandard, kUSBDevice);
        request.bRequest = kUSBRqGetDescriptor;
        request.wValue = (kUSBStringDesc << 8) | index;
        request.wIndex = language;
        request.wLength = 2;
        request.pData = &description;
        request.completionTimeout = 0;
        request.noDataTimeout = 60L;

        err = (*printer)->ControlRequestTO(printer, 0, &request);
        if (err != kIOReturnSuccess && err != kIOReturnOverrun)
        {
                memset(description, 0, request.wLength);

                // Let's try again full length. Here's why:
                //      On USB 2.0 controllers, we will not get an overrun error.  We just get a "babble" error
                //      and no valid data.  So, if we ask for the max size, we will either get it, or we'll get an underrun.
                //      It looks like we get it w/out an underrun

                request.bmRequestType = USBmakebmRequestType(kUSBIn, kUSBStandard, kUSBDevice);
                request.bRequest = kUSBRqGetDescriptor;
                request.wValue = (kUSBStringDesc << 8) | index;
                request.wIndex = language;
                request.wLength = sizeof description;
                request.pData = &description;
                request.completionTimeout = 0;
                request.noDataTimeout = 60L;

                err = (*printer)->ControlRequestTO(printer, 0, &request);
                if (err != kIOReturnSuccess && err != kIOReturnUnderrun)
                        return NULL;
        }

        unsigned int length = description[0];
        if (length == 0)
                return CFStringCreateWithCString(NULL, "", kCFStringEncodingUTF8);

        if (description[1] != kUSBStringDesc)
                return NULL;

        request.bmRequestType = USBmakebmRequestType(kUSBIn, kUSBStandard, kUSBDevice);
        request.bRequest = kUSBRqGetDescriptor;
        request.wValue = (kUSBStringDesc << 8) | index;
        request.wIndex = language;

        memset(description, 0, length);
        request.wLength = (UInt16)length;
        request.pData = &description;
        request.completionTimeout = 0;
        request.noDataTimeout = 60L;

        err = (*printer)->ControlRequestTO(printer, 0, &request);
        if (err != kIOReturnSuccess)
                return NULL;

        if (description[1] != kUSBStringDesc)
                return NULL;

        if ((description[0] & 1) != 0)
                description[0] &= 0xfe;

        char buffer[258] = {0};
        unsigned int maxLength = sizeof buffer;
        if (description[0] > 1)
        {
                length = (description[0]-2)/2;

                if (length > maxLength - 1)
                        length = maxLength -1;

                for (unsigned i = 0; i < length; i++)
                        buffer[i] = (char) description[2*i+2];

                buffer[length] = 0;
        }

        return CFStringCreateWithCString(NULL, buffer, kCFStringEncodingUTF8);
}

/*
 * 'registry_open()' - Open a connection to the printer.
 */

static kern_return_t registry_open(CFStringRef *driverBundlePath)
{
  g.bidi_flag = 0;      /* 0=unidirectional */

  kern_return_t kr = load_printerdriver(driverBundlePath);
  if (kr != kIOReturnSuccess)
    kr = -2;

  if (g.classdriver != NULL)
  {
        (*g.classdriver)->interfaceNumber = g.interfaceNum;
    kr = (*g.classdriver)->Open(g.classdriver, g.location, kUSBPrintingProtocolBidirectional);
    if (kr != kIOReturnSuccess || (*g.classdriver)->interface == NULL)
    {
      kr = (*g.classdriver)->Open(g.classdriver, g.location, kUSBPrintingProtocolUnidirectional);
      if (kr == kIOReturnSuccess)
      {
        if ((*g.classdriver)->interface == NULL)
        {
          (*g.classdriver)->Close(g.classdriver);
          kr = -1;
        }
      }
    }
    else
      g.bidi_flag = 1;  /* 1=bidirectional */
  }

  if (kr != kIOReturnSuccess)
    unload_classdriver(&g.classdriver);

  return kr;
}


/*
 * 'registry_close()' - Close the connection to the printer.
 */

static kern_return_t registry_close(void)
{
  if (g.classdriver != NULL)
    (*g.classdriver)->Close(g.classdriver);

  unload_classdriver(&g.classdriver);
  return kIOReturnSuccess;
}

#pragma mark -
/*
 * 'copy_value_for_key()' - Copy value string associated with a key.
 */

static CFStringRef copy_value_for_key(CFStringRef deviceID,
                                      CFStringRef *keys)
{
  CFStringRef   value = NULL;
  CFArrayRef    kvPairs = deviceID != NULL ? CFStringCreateArrayBySeparatingStrings(NULL, deviceID, CFSTR(";")) : NULL;
  CFIndex       max = kvPairs != NULL ? CFArrayGetCount(kvPairs) : 0;
  CFIndex       idx = 0;

  while (idx < max && value == NULL)
  {
    CFStringRef kvpair = CFArrayGetValueAtIndex(kvPairs, idx);
    CFIndex idxx = 0;
    while (keys[idxx] != NULL && value == NULL)
    {
      CFRange range = CFStringFind(kvpair, keys[idxx], kCFCompareCaseInsensitive);
      if (range.length != -1)
      {
        if (range.location != 0)
        {
          CFMutableStringRef theString = CFStringCreateMutableCopy(NULL, 0, kvpair);
          CFStringTrimWhitespace(theString);
          range = CFStringFind(theString, keys[idxx], kCFCompareCaseInsensitive);
          if (range.location == 0)
            value = CFStringCreateWithSubstring(NULL, theString, CFRangeMake(range.length, CFStringGetLength(theString) - range.length));

          CFRelease(theString);
        }
        else
        {
          CFStringRef theString = CFStringCreateWithSubstring(NULL, kvpair, CFRangeMake(range.length, CFStringGetLength(kvpair) - range.length));
          CFMutableStringRef theString2 = CFStringCreateMutableCopy(NULL, 0, theString);
          CFRelease(theString);

          CFStringTrimWhitespace(theString2);
          value = theString2;
        }
      }
      idxx++;
    }
    idx++;
  }

  if (kvPairs != NULL)
    CFRelease(kvPairs);
  return value;
}


/*
 * 'cfstr_create_trim()' - Create CFString and trim whitespace characters.
 */

CFStringRef cfstr_create_trim(const char *cstr)
{
  CFStringRef           cfstr;
  CFMutableStringRef    cfmutablestr = NULL;

  if ((cfstr = CFStringCreateWithCString(NULL, cstr, kCFStringEncodingUTF8)) != NULL)
  {
    if ((cfmutablestr = CFStringCreateMutableCopy(NULL, 1024, cfstr)) != NULL)
      CFStringTrimWhitespace(cfmutablestr);

    CFRelease(cfstr);
  }
  return (CFStringRef) cfmutablestr;
}


#pragma mark -
/*
 * 'parse_options()' - Parse URI options.
 */

static void parse_options(char *options,
                          char *serial,
                          int serial_size,
                          UInt32 *location,
                          Boolean *wait_eof)
{
  char  sep,                            /* Separator character */
        *name,                          /* Name of option */
        *value;                         /* Value of option */


  if (serial)
    *serial = '\0';
  if (location)
    *location = 0;

  if (!options)
    return;

  while (*options)
  {
   /*
    * Get the name...
    */

    name = options;

    while (*options && *options != '=' && *options != '+' && *options != '&')
      options ++;

    if ((sep = *options) != '\0')
      *options++ = '\0';

    if (sep == '=')
    {
     /*
      * Get the value...
      */

      value = options;

      while (*options && *options != '+' && *options != '&')
        options ++;

      if (*options)
        *options++ = '\0';
    }
    else
      value = (char *)"";

   /*
    * Process the option...
    */

    if (!_cups_strcasecmp(name, "waiteof"))
    {
      if (!_cups_strcasecmp(value, "on") ||
          !_cups_strcasecmp(value, "yes") ||
          !_cups_strcasecmp(value, "true"))
        *wait_eof = true;
      else if (!_cups_strcasecmp(value, "off") ||
               !_cups_strcasecmp(value, "no") ||
               !_cups_strcasecmp(value, "false"))
        *wait_eof = false;
      else
        _cupsLangPrintFilter(stderr, "WARNING",
                             _("Boolean expected for waiteof option \"%s\"."),
                             value);
    }
    else if (!_cups_strcasecmp(name, "serial"))
      strlcpy(serial, value, (size_t)serial_size);
    else if (!_cups_strcasecmp(name, "location") && location)
      *location = (UInt32)strtoul(value, NULL, 16);
  }
}


/*!
 * @function    setup_cfLanguage
 * @abstract    Convert the contents of the CUPS 'APPLE_LANGUAGE' environment
 *              variable into a one element CF array of languages.
 *
 * @discussion  Each submitted job comes with a natural language. CUPS passes
 *              that language in an environment variable. We take that language
 *              and jam it into the AppleLanguages array so that CF will use
 *              it when reading localized resources. We need to do this before
 *              any CF code reads and caches the languages array, so this function
 *              should be called early in main()
 */
static void setup_cfLanguage(void)
{
  CFStringRef   lang[1] = {NULL};
  CFArrayRef    langArray = NULL;
  const char    *requestedLang = NULL;

  if ((requestedLang = getenv("APPLE_LANGUAGE")) == NULL)
    requestedLang = getenv("LANG");

  if (requestedLang != NULL)
  {
    lang[0] = CFStringCreateWithCString(kCFAllocatorDefault, requestedLang, kCFStringEncodingUTF8);
    langArray = CFArrayCreate(kCFAllocatorDefault, (const void **)lang, sizeof(lang) / sizeof(lang[0]), &kCFTypeArrayCallBacks);

    CFPreferencesSetValue(CFSTR("AppleLanguages"), langArray, kCFPreferencesCurrentApplication, kCFPreferencesAnyUser, kCFPreferencesAnyHost);
    fprintf(stderr, "DEBUG: usb: AppleLanguages=\"%s\"\n", requestedLang);

    CFRelease(lang[0]);
    CFRelease(langArray);
  }
  else
    fputs("DEBUG: usb: LANG and APPLE_LANGUAGE environment variables missing.\n", stderr);
}

#pragma mark -
#if defined(__arm64e__)
/*!
 * @function    run_legacy_backend
 *
 * @abstract    Starts child backend process running as a x86_64 executable.
 *
 * @result      Never returns; always calls exit().
 *
 * @discussion
 */
static void run_legacy_backend(int argc,
                               char *argv[],
                               int fd)
{
  int   i;
  int   exitstatus = 0;
  int   childstatus;
  pid_t waitpid_status;
  char  *my_argv[32];
  char  *usb_legacy_status;


 /*
  * If we're running as ARM and couldn't load the class driver
  * (because it's x86_64, i386 or ppc), then try to re-exec ourselves in x86_64
  * mode to try again. If we don't have that architecture we may be
  * running with the same architecture again so guard against this by setting
  * and testing an environment variable...
  */

  usb_legacy_status = getenv("USB_LEGACY_STATUS");

  if (!usb_legacy_status)
  {
   /*
    * Setup a SIGTERM handler then block it before forking...
    */

    int                 err;            /* posix_spawn result */
    struct sigaction    action;         /* POSIX signal action */
    sigset_t            newmask,        /* New signal mask */
                        oldmask;        /* Old signal mask */
    char                usbpath[1024];  /* Path to USB backend */
    const char          *cups_serverbin;/* Path to CUPS binaries */


    memset(&action, 0, sizeof(action));
    sigaddset(&action.sa_mask, SIGTERM);
    action.sa_handler = sigterm_handler;
    sigaction(SIGTERM, &action, NULL);

    sigemptyset(&newmask);
    sigaddset(&newmask, SIGTERM);
    sigprocmask(SIG_BLOCK, &newmask, &oldmask);

   /*
    * Set the environment variable...
    */

    setenv("USB_LEGACY_STATUS", "1", false);

   /*
    * Tell the kernel to use the specified CPU architecture...
    */

    cpu_type_t cpu = CPU_TYPE_X86_64;
    size_t ocount = 1;
    posix_spawnattr_t attrs;

    if (!posix_spawnattr_init(&attrs))
    {
      posix_spawnattr_setsigdefault(&attrs, &oldmask);
      if (posix_spawnattr_setbinpref_np(&attrs, 1, &cpu, &ocount) || ocount != 1)
      {
        perror("DEBUG: Unable to set binary preference to X86_64");
        _cupsLangPrintFilter(stderr, "ERROR",
                             _("Unable to use legacy USB class driver."));
        exit(CUPS_BACKEND_STOP);
      }
    }

   /*
    * Set up the arguments and call posix_spawn...
    */

    if ((cups_serverbin = getenv("CUPS_SERVERBIN")) == NULL)
      cups_serverbin = CUPS_SERVERBIN;
    snprintf(usbpath, sizeof(usbpath), "%s/backend/usb", cups_serverbin);

    for (i = 0; i < argc && i < (int)(sizeof(my_argv) / sizeof(my_argv[0])) - 1; i ++)
      my_argv[i] = argv[i];

    my_argv[i] = NULL;

    if ((err = posix_spawn(&child_pid, usbpath, NULL, &attrs, my_argv,
                           environ)) != 0)
    {
      fprintf(stderr, "DEBUG: Unable to exec %s: %s\n", usbpath,
              strerror(err));
      _cupsLangPrintFilter(stderr, "ERROR",
                           _("Unable to use legacy USB class driver."));
      exit(CUPS_BACKEND_STOP);
    }

   /*
    * Unblock signals...
    */

    sigprocmask(SIG_SETMASK, &oldmask, NULL);

   /*
    * Close the fds we won't be using then wait for the child backend to exit.
    */

    close(fd);
    close(1);

    fprintf(stderr, "DEBUG: Started usb(legacy) backend (PID %d)\n",
            (int)child_pid);

    while ((waitpid_status = waitpid(child_pid, &childstatus, 0)) == (pid_t)-1 && errno == EINTR)
      usleep(1000);

    if (WIFSIGNALED(childstatus))
    {
      exitstatus = CUPS_BACKEND_STOP;
      fprintf(stderr, "DEBUG: usb(legacy) backend %d crashed on signal %d\n",
              child_pid, WTERMSIG(childstatus));
    }
    else
    {
      if ((exitstatus = WEXITSTATUS(childstatus)) != 0)
        fprintf(stderr,
                "DEBUG: usb(legacy) backend %d stopped with status %d\n",
                child_pid, exitstatus);
      else
        fprintf(stderr, "DEBUG: usb(legacy) backend %d exited with no errors\n",
                child_pid);
    }
  }
  else
  {
    fputs("DEBUG: usb(legacy) backend running native again\n", stderr);
    exitstatus = CUPS_BACKEND_STOP;
  }

  exit(exitstatus);
}

/*
 * 'sigterm_handler()' - SIGTERM handler.
 */

static void
sigterm_handler(int sig)                /* I - Signal */
{
 /*
  * If we started a child process pass the signal on to it...
  */

  if (child_pid)
  {
   /*
    * If we started a child process pass the signal on to it...
    */

    int status;

    kill(child_pid, sig);
    while (waitpid(child_pid, &status, 0) < 0 && errno == EINTR);

    if (WIFEXITED(status))
      _exit(WEXITSTATUS(status));
    else if (status == SIGTERM || status == SIGKILL)
      _exit(0);
    else
    {
      backendMessage("DEBUG: Child crashed.\n");
      _exit(CUPS_BACKEND_STOP);
    }
  }
}
#endif /* __arm64e__ */


/*
 * 'sigquit_handler()' - SIGQUIT handler.
 */

static void sigquit_handler(int sig, siginfo_t *si, void *unused)
{
  char  *path;
  char  pathbuf[PROC_PIDPATHINFO_MAXSIZE];
  static char msgbuf[256] = "";


  (void)sig;
  (void)unused;

  if (proc_pidpath(si->si_pid, pathbuf, sizeof(pathbuf)) > 0 &&
      (path = basename(pathbuf)) != NULL)
    snprintf(msgbuf, sizeof(msgbuf), "SIGQUIT sent by %s(%d)", path, (int)si->si_pid);
  else
    snprintf(msgbuf, sizeof(msgbuf), "SIGQUIT sent by PID %d", (int)si->si_pid);

  CRSetCrashLogMessage(msgbuf);

  abort();
}


#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 trucnated 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... */
    strlcpy(gErrorBuffer, pLineEnd, sizeof(gErrorBuffer));
    gErrorBufferPtr = gErrorBuffer;
    pLineEnd = (char *)next_line((const char *)gErrorBuffer);
  }
}
#endif /* PARSE_PS_ERRORS */


/*
 * '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)
  {
    (*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.readwrite_lock)
    {
      if (pthread_cond_timedwait(&g.readwrite_lock_cond,
                                 &g.readwrite_lock_mutex,
                                 &cond_timeout) != 0)
        break;
    }
  }

  g.readwrite_lock = 1;
  pthread_mutex_unlock(&g.readwrite_lock_mutex);

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

  (*g.classdriver)->SoftReset(g.classdriver, DEFAULT_TIMEOUT);

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


/*
 * 'get_device_id()' - Return IEEE-1284 device ID.
 */

static void get_device_id(cups_sc_status_t *status,
                          char *data,
                          int *datalen)
{
  CFStringRef deviceIDString = NULL;

  if (g.printer_obj != IO_OBJECT_NULL)
  {
    printer_interface_t printerIntf = usb_printer_interface_interface(g.printer_obj);
    if (printerIntf)
    {
      deviceIDString = copy_printer_interface_deviceid(printerIntf, g.alternateSetting);
      (*printerIntf)->Release(printerIntf);
    }
  }


  if (deviceIDString)
  {
    if (CFStringGetCString(deviceIDString, data, *datalen, kCFStringEncodingUTF8))
      *datalen = (int)strlen(data);
    else
      *datalen = 0;

    CFRelease(deviceIDString);
  }
  else
  {
    *datalen = 0;
  }

  *status  = CUPS_SC_STATUS_OK;
}