2 * "$Id: usb-darwin.c 9887 2011-08-11 22:04:59Z mike $"
4 * Copyright 2005-2011 Apple Inc. All rights reserved.
6 * IMPORTANT: This Apple software is supplied to you by Apple Computer,
7 * Inc. ("Apple") in consideration of your agreement to the following
8 * terms, and your use, installation, modification or redistribution of
9 * this Apple software constitutes acceptance of these terms. If you do
10 * not agree with these terms, please do not use, install, modify or
11 * redistribute this Apple software.
13 * In consideration of your agreement to abide by the following terms, and
14 * subject to these terms, Apple grants you a personal, non-exclusive
15 * license, under Apple's copyrights in this original Apple software (the
16 * "Apple Software"), to use, reproduce, modify and redistribute the Apple
17 * Software, with or without modifications, in source and/or binary forms;
18 * provided that if you redistribute the Apple Software in its entirety and
19 * without modifications, you must retain this notice and the following
20 * text and disclaimers in all such redistributions of the Apple Software.
21 * Neither the name, trademarks, service marks or logos of Apple Computer,
22 * Inc. may be used to endorse or promote products derived from the Apple
23 * Software without specific prior written permission from Apple. Except
24 * as expressly stated in this notice, no other rights or licenses, express
25 * or implied, are granted by Apple herein, including but not limited to
26 * any patent rights that may be infringed by your derivative works or by
27 * other works in which the Apple Software may be incorporated.
29 * The Apple Software is provided by Apple on an "AS IS" basis. APPLE
30 * MAKES NO WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION
31 * THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS
32 * FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND
33 * OPERATION ALONE OR IN COMBINATION WITH YOUR PRODUCTS.
35 * IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL
36 * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
37 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
38 * INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION,
39 * MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED
40 * AND WHETHER UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE),
41 * STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE
42 * POSSIBILITY OF SUCH DAMAGE.
46 * list_devices() - List all USB devices.
47 * print_device() - Print a file to a USB device.
48 * read_thread() - Thread to read the backchannel data on.
49 * sidechannel_thread() - Handle side-channel requests.
50 * iterate_printers() - Iterate over all the printers.
51 * device_added() - Device added notifier.
52 * list_device_cb() - list_device iterator callback.
53 * find_device_cb() - print_device iterator callback.
54 * status_timer_cb() - Status timer callback.
55 * copy_deviceinfo() - Copy strings from the 1284 device ID.
56 * release_deviceinfo() - Release deviceinfo strings.
57 * load_classdriver() - Load a classdriver.
58 * unload_classdriver() - Unload a classdriver.
59 * load_printerdriver() - Load vendor's classdriver.
60 * registry_open() - Open a connection to the printer.
61 * registry_close() - Close the connection to the printer.
62 * copy_deviceid() - Copy the 1284 device id string.
63 * copy_devicestring() - Copy the 1284 device id string.
64 * copy_value_for_key() - Copy value string associated with a key.
65 * cfstr_create_trim() - Create CFString and trim whitespace characters.
66 * parse_options() - Parse URI options.
67 * sigterm_handler() - SIGTERM handler.
68 * next_line() - Find the next line in a buffer.
69 * parse_pserror() - Scan the backchannel data for postscript errors.
70 * soft_reset() - Send a soft reset to the device.
71 * get_device_id() - Return IEEE-1284 device ID.
75 * Include necessary headers.
86 #include <sys/sysctl.h>
88 #include <mach/mach.h>
89 #include <mach/mach_error.h>
90 #include <mach/mach_time.h>
91 #include <cups/debug-private.h>
92 #include <cups/file-private.h>
93 #include <cups/sidechannel.h>
94 #include <cups/language-private.h>
95 #include "backend-private.h"
96 #include <CoreFoundation/CoreFoundation.h>
97 #include <IOKit/usb/IOUSBLib.h>
98 #include <IOKit/IOCFPlugIn.h>
103 extern char **environ;
107 * DEBUG_WRITES, if defined, causes the backend to write data to the printer in
108 * 512 byte increments, up to 8192 bytes, to make debugging with a USB bus
112 #define DEBUG_WRITES 0
115 * WAIT_EOF_DELAY is number of seconds we'll wait for responses from
116 * the printer after we've finished sending all the data
118 #define WAIT_EOF_DELAY 7
119 #define WAIT_SIDE_DELAY 3
120 #define DEFAULT_TIMEOUT 5000L
122 #define USB_INTERFACE_KIND CFUUIDGetUUIDBytes(kIOUSBInterfaceInterfaceID190)
123 #define kUSBLanguageEnglish 0x409
125 #define PRINTER_POLLING_INTERVAL 5 /* seconds */
126 #define INITIAL_LOG_INTERVAL PRINTER_POLLING_INTERVAL
127 #define SUBSEQUENT_LOG_INTERVAL 3 * INITIAL_LOG_INTERVAL
129 #define kUSBPrinterClassTypeID CFUUIDGetConstantUUIDWithBytes(NULL, 0x06, 0x04, 0x7D, 0x16, 0x53, 0xA2, 0x11, 0xD6, 0x92, 0x06, 0x00, 0x30, 0x65, 0x52, 0x45, 0x92)
130 #define kUSBPrinterClassInterfaceID CFUUIDGetConstantUUIDWithBytes(NULL, 0x03, 0x34, 0x6D, 0x74, 0x53, 0xA3, 0x11, 0xD6, 0x9E, 0xA1, 0x76, 0x30, 0x65, 0x52, 0x45, 0x92)
132 #define kUSBClassDriverProperty CFSTR("USB Printing Class")
134 #define kUSBGenericTOPrinterClassDriver CFSTR("/System/Library/Printers/Libraries/USBGenericPrintingClass.plugin")
135 #define kUSBPrinterClassDeviceNotOpen -9664 /*kPMInvalidIOMContext*/
139 * Section 5.3 USB Printing Class spec
141 #define kUSBPrintingSubclass 1
142 #define kUSBPrintingProtocolNoOpen 0
143 #define kUSBPrintingProtocolUnidirectional 1
144 #define kUSBPrintingProtocolBidirectional 2
146 typedef IOUSBInterfaceInterface190 **printer_interface_t;
148 typedef struct iodevice_request_s /**** Device request ****/
156 } iodevice_request_t;
158 typedef union /**** Centronics status byte ****/
163 unsigned reserved0:2;
164 unsigned paperError:1;
167 unsigned reserved1:3;
169 } centronics_status_t;
171 typedef struct classdriver_s /**** g.classdriver context ****/
174 CFPlugInRef plugin; /* release plugin */
175 IUnknownVTbl **factory; /* Factory */
176 void *vendorReference; /* vendor class specific usage */
177 UInt32 location; /* unique location in bus topology */
178 UInt8 interfaceNumber; /* Interface number */
179 UInt16 vendorID; /* Vendor id */
180 UInt16 productID; /* Product id */
181 printer_interface_t interface; /* identify the device to IOKit */
182 UInt8 outpipe; /* mandatory bulkOut pipe */
183 UInt8 inpipe; /* optional bulkIn pipe */
185 /* general class requests */
186 kern_return_t (*DeviceRequest)(struct classdriver_s **printer, iodevice_request_t *iorequest, UInt16 timeout);
187 kern_return_t (*GetString)(struct classdriver_s **printer, UInt8 whichString, UInt16 language, UInt16 timeout, CFStringRef *result);
189 /* standard printer class requests */
190 kern_return_t (*SoftReset)(struct classdriver_s **printer, UInt16 timeout);
191 kern_return_t (*GetCentronicsStatus)(struct classdriver_s **printer, centronics_status_t *result, UInt16 timeout);
192 kern_return_t (*GetDeviceID)(struct classdriver_s **printer, CFStringRef *devid, UInt16 timeout);
194 /* standard bulk device requests */
195 kern_return_t (*ReadPipe)(struct classdriver_s **printer, UInt8 *buffer, UInt32 *count);
196 kern_return_t (*WritePipe)(struct classdriver_s **printer, UInt8 *buffer, UInt32 *count, Boolean eoj);
198 /* interface requests */
199 kern_return_t (*Open)(struct classdriver_s **printer, UInt32 location, UInt8 protocol);
200 kern_return_t (*Abort)(struct classdriver_s **printer);
201 kern_return_t (*Close)(struct classdriver_s **printer);
203 /* initialize and terminate */
204 kern_return_t (*Initialize)(struct classdriver_s **printer, struct classdriver_s **baseclass);
205 kern_return_t (*Terminate)(struct classdriver_s **printer);
209 typedef Boolean (*iterator_callback_t)(void *refcon, io_service_t obj);
211 typedef struct iterator_reference_s /**** Iterator reference data */
213 iterator_callback_t callback;
216 } iterator_reference_t;
218 typedef struct globals_s
220 io_service_t printer_obj;
221 classdriver_t **classdriver;
223 pthread_mutex_t read_thread_mutex;
224 pthread_cond_t read_thread_cond;
225 int read_thread_stop;
226 int read_thread_done;
228 pthread_mutex_t readwrite_lock_mutex;
229 pthread_cond_t readwrite_lock_cond;
238 CFRunLoopTimerRef status_timer;
240 int print_fd; /* File descriptor to print */
241 ssize_t print_bytes; /* Print bytes read */
243 ssize_t debug_bytes; /* Current bytes to read */
244 #endif /* DEBUG_WRITES */
247 int drain_output; /* Drain all pending output */
248 int bidi_flag; /* 0=unidirectional, 1=bidirectional */
250 pthread_mutex_t sidechannel_thread_mutex;
251 pthread_cond_t sidechannel_thread_cond;
252 int sidechannel_thread_stop;
253 int sidechannel_thread_done;
261 globals_t g = { 0 }; /* Globals */
268 static Boolean find_device_cb(void *refcon, io_service_t obj);
269 static Boolean list_device_cb(void *refcon, io_service_t obj);
270 static CFStringRef cfstr_create_trim(const char *cstr);
271 static CFStringRef copy_value_for_key(CFStringRef deviceID, CFStringRef *keys);
272 static kern_return_t load_classdriver(CFStringRef driverPath, printer_interface_t interface, classdriver_t ***printerDriver);
273 static kern_return_t load_printerdriver(CFStringRef *driverBundlePath);
274 static kern_return_t registry_close(void);
275 static kern_return_t registry_open(CFStringRef *driverBundlePath);
276 static kern_return_t unload_classdriver(classdriver_t ***classdriver);
277 static OSStatus copy_deviceid(classdriver_t **printer, CFStringRef *deviceID);
278 static void *read_thread(void *reference);
279 static void *sidechannel_thread(void *reference);
280 static void copy_deviceinfo(CFStringRef deviceIDString, CFStringRef *make, CFStringRef *model, CFStringRef *serial);
281 static void copy_devicestring(io_service_t usbInterface, CFStringRef *deviceID, UInt32 *deviceLocation, UInt8 *interfaceNum);
282 static void device_added(void *userdata, io_iterator_t iterator);
283 static void get_device_id(cups_sc_status_t *status, char *data, int *datalen);
284 static void iterate_printers(iterator_callback_t callBack, void *userdata);
285 static void parse_options(char *options, char *serial, int serial_size, UInt32 *location, Boolean *wait_eof);
286 static void release_deviceinfo(CFStringRef *make, CFStringRef *model, CFStringRef *serial);
287 static void setup_cfLanguage(void);
288 static void soft_reset(void);
289 static void status_timer_cb(CFRunLoopTimerRef timer, void *info);
291 #if defined(__i386__) || defined(__x86_64__)
292 static pid_t child_pid; /* Child PID */
293 static void run_legacy_backend(int argc, char *argv[], int fd); /* Starts child backend process running as a ppc executable */
294 #endif /* __i386__ || __x86_64__ */
295 static void sigterm_handler(int sig); /* SIGTERM handler */
297 #ifdef PARSE_PS_ERRORS
298 static const char *next_line (const char *buffer);
299 static void parse_pserror (char *sockBuffer, int len);
300 #endif /* PARSE_PS_ERRORS */
305 * 'list_devices()' - List all USB devices.
310 iterate_printers(list_device_cb, NULL);
315 * 'print_device()' - Print a file to a USB device.
318 int /* O - Exit status */
319 print_device(const char *uri, /* I - Device URI */
320 const char *hostname, /* I - Hostname/manufacturer */
321 const char *resource, /* I - Resource/modelname */
322 char *options, /* I - Device options/serial number */
323 int print_fd, /* I - File descriptor to print */
324 int copies, /* I - Copies to print */
325 int argc, /* I - Number of command-line arguments (6 or 7) */
326 char *argv[]) /* I - Command-line arguments */
328 char serial[1024]; /* Serial number buffer */
329 OSStatus status; /* Function results */
330 IOReturn iostatus; /* Current IO status */
331 pthread_t read_thread_id, /* Read thread */
332 sidechannel_thread_id;/* Side-channel thread */
333 int have_sidechannel = 0; /* Was the side-channel thread started? */
334 struct stat sidechannel_info; /* Side-channel file descriptor info */
335 char print_buffer[8192], /* Print data buffer */
336 *print_ptr; /* Pointer into print data buffer */
337 UInt32 location; /* Unique location in bus topology */
338 fd_set input_set; /* Input set for select() */
339 CFStringRef driverBundlePath; /* Class driver path */
340 int countdown, /* Logging interval */
341 nfds; /* Number of file descriptors */
342 ssize_t total_bytes; /* Total bytes written */
343 UInt32 bytes; /* Bytes written */
344 struct timeval *timeout, /* Timeout pointer */
346 struct timespec cond_timeout; /* pthread condition timeout */
352 * See if the side-channel descriptor is valid...
355 have_sidechannel = !fstat(CUPS_SC_FD, &sidechannel_info) &&
356 S_ISSOCK(sidechannel_info.st_mode);
359 * Localize using CoreFoundation...
364 parse_options(options, serial, sizeof(serial), &location, &g.wait_eof);
366 if (resource[0] == '/')
369 g.print_fd = print_fd;
370 g.make = cfstr_create_trim(hostname);
371 g.model = cfstr_create_trim(resource);
372 g.serial = cfstr_create_trim(serial);
373 g.location = location;
375 if (!g.make || !g.model)
377 fprintf(stderr, "DEBUG: Fatal USB error.\n");
378 _cupsLangPrintFilter(stderr, "ERROR",
379 _("There was an unrecoverable USB error."));
382 fputs("DEBUG: USB make string is NULL\n", stderr);
384 fputs("DEBUG: USB model string is NULL\n", stderr);
386 return (CUPS_BACKEND_STOP);
389 fputs("STATE: +connecting-to-device\n", stderr);
391 countdown = INITIAL_LOG_INTERVAL;
397 IOObjectRelease(g.printer_obj);
398 unload_classdriver(&g.classdriver);
403 fprintf(stderr, "DEBUG: Looking for '%s %s'\n", hostname, resource);
405 iterate_printers(find_device_cb, NULL);
407 fputs("DEBUG: Opening connection\n", stderr);
409 driverBundlePath = NULL;
411 status = registry_open(&driverBundlePath);
413 #if defined(__i386__) || defined(__x86_64__)
415 * If we were unable to load the class drivers for this printer it's
416 * probably because they're ppc or i386. In this case try to run this
417 * backend as i386 or ppc executables so we can use them...
421 run_legacy_backend(argc, argv, print_fd);
422 /* Never returns here */
424 #endif /* __i386__ || __x86_64__ */
429 * If we still were unable to load the class drivers for this printer log
430 * the error and stop the queue...
433 if (driverBundlePath == NULL || !CFStringGetCString(driverBundlePath, print_buffer, sizeof(print_buffer), kCFStringEncodingUTF8))
434 strlcpy(print_buffer, "USB class driver", sizeof(print_buffer));
436 fputs("STATE: +apple-missing-usbclassdriver-error\n", stderr);
437 _cupsLangPrintFilter(stderr, "ERROR",
438 _("There was an unrecoverable USB error."));
439 fprintf(stderr, "DEBUG: Could not load %s\n", print_buffer);
441 if (driverBundlePath)
442 CFRelease(driverBundlePath);
444 return (CUPS_BACKEND_STOP);
447 if (driverBundlePath)
448 CFRelease(driverBundlePath);
452 sleep(PRINTER_POLLING_INTERVAL);
453 countdown -= PRINTER_POLLING_INTERVAL;
456 _cupsLangPrintFilter(stderr, "INFO",
457 _("Waiting for printer to become available."));
458 fprintf(stderr, "DEBUG: USB printer status: 0x%08x\n", (int)status);
459 countdown = SUBSEQUENT_LOG_INTERVAL; /* subsequent log entries, every 15 seconds */
462 } while (status != noErr);
464 fputs("STATE: -connecting-to-device\n", stderr);
467 * Now that we are "connected" to the port, ignore SIGTERM so that we
468 * can finish out any page data the driver sends (e.g. to eject the
469 * current page... Only ignore SIGTERM if we are printing data from
470 * stdin (otherwise you can't cancel raw jobs...)
475 struct sigaction action; /* POSIX signal action */
478 memset(&action, 0, sizeof(action));
480 sigemptyset(&action.sa_mask);
481 action.sa_handler = SIG_IGN;
482 sigaction(SIGTERM, &action, NULL);
486 * Start the side channel thread if the descriptor is valid...
489 pthread_mutex_init(&g.readwrite_lock_mutex, NULL);
490 pthread_cond_init(&g.readwrite_lock_cond, NULL);
491 g.readwrite_lock = 1;
493 if (have_sidechannel)
495 g.sidechannel_thread_stop = 0;
496 g.sidechannel_thread_done = 0;
498 pthread_cond_init(&g.sidechannel_thread_cond, NULL);
499 pthread_mutex_init(&g.sidechannel_thread_mutex, NULL);
501 if (pthread_create(&sidechannel_thread_id, NULL, sidechannel_thread, NULL))
503 fprintf(stderr, "DEBUG: Fatal USB error.\n");
504 _cupsLangPrintFilter(stderr, "ERROR",
505 _("There was an unrecoverable USB error."));
506 fputs("DEBUG: Couldn't create side-channel thread\n", stderr);
508 return (CUPS_BACKEND_STOP);
513 * Get the read thread going...
516 g.read_thread_stop = 0;
517 g.read_thread_done = 0;
519 pthread_cond_init(&g.read_thread_cond, NULL);
520 pthread_mutex_init(&g.read_thread_mutex, NULL);
522 if (pthread_create(&read_thread_id, NULL, read_thread, NULL))
524 fprintf(stderr, "DEBUG: Fatal USB error.\n");
525 _cupsLangPrintFilter(stderr, "ERROR",
526 _("There was an unrecoverable USB error."));
527 fputs("DEBUG: Couldn't create read thread\n", stderr);
529 return (CUPS_BACKEND_STOP);
533 * The main thread sends the print file...
539 print_ptr = print_buffer;
541 while (status == noErr && copies-- > 0)
543 _cupsLangPrintFilter(stderr, "INFO", _("Sending data to printer."));
545 if (print_fd != STDIN_FILENO)
547 fputs("PAGE: 1 1\n", stderr);
548 lseek(print_fd, 0, SEEK_SET);
551 while (status == noErr)
556 FD_SET(print_fd, &input_set);
559 * Calculate select timeout...
560 * If we have data waiting to send timeout is 100ms.
561 * else if we're draining print_fd timeout is 0.
562 * else we're waiting forever...
568 tv.tv_usec = 100000; /* 100ms */
571 else if (g.drain_output)
581 * I/O is unlocked around select...
584 pthread_mutex_lock(&g.readwrite_lock_mutex);
585 g.readwrite_lock = 0;
586 pthread_cond_signal(&g.readwrite_lock_cond);
587 pthread_mutex_unlock(&g.readwrite_lock_mutex);
589 nfds = select(print_fd + 1, &input_set, NULL, NULL, timeout);
592 * Reacquire the lock...
595 pthread_mutex_lock(&g.readwrite_lock_mutex);
596 while (g.readwrite_lock)
597 pthread_cond_wait(&g.readwrite_lock_cond, &g.readwrite_lock_mutex);
598 g.readwrite_lock = 1;
599 pthread_mutex_unlock(&g.readwrite_lock_mutex);
603 if (errno == EINTR && total_bytes == 0)
605 fputs("DEBUG: Received an interrupt before any bytes were "
606 "written, aborting\n", stderr);
608 return (CUPS_BACKEND_OK);
610 else if (errno != EAGAIN && errno != EINTR)
612 _cupsLangPrintFilter(stderr, "ERROR",
613 _("Unable to read print data."));
614 perror("DEBUG: select");
616 return (CUPS_BACKEND_FAILED);
621 * If drain output has finished send a response...
624 if (g.drain_output && !nfds && !g.print_bytes)
626 /* Send a response... */
627 cupsSideChannelWrite(CUPS_SC_CMD_DRAIN_OUTPUT, CUPS_SC_STATUS_OK, NULL, 0, 1.0);
632 * Check if we have print data ready...
635 if (FD_ISSET(print_fd, &input_set))
638 g.debug_bytes += 512;
639 if (g.debug_bytes > sizeof(print_buffer))
642 g.print_bytes = read(print_fd, print_buffer, g.debug_bytes);
645 g.print_bytes = read(print_fd, print_buffer, sizeof(print_buffer));
646 #endif /* DEBUG_WRITES */
648 if (g.print_bytes < 0)
651 * Read error - bail if we don't see EAGAIN or EINTR...
654 if (errno != EAGAIN && errno != EINTR)
656 _cupsLangPrintFilter(stderr, "ERROR",
657 _("Unable to read print data."));
658 perror("DEBUG: read");
660 return (CUPS_BACKEND_FAILED);
665 else if (g.print_bytes == 0)
668 * End of file, break out of the loop...
674 print_ptr = print_buffer;
676 fprintf(stderr, "DEBUG: Read %d bytes of print data...\n",
682 bytes = g.print_bytes;
683 iostatus = (*g.classdriver)->WritePipe(g.classdriver, (UInt8*)print_ptr, &bytes, 0);
686 * Ignore timeout errors, but retain the number of bytes written to
687 * avoid sending duplicate data (<rdar://problem/6254911>)...
690 if (iostatus == kIOUSBTransactionTimeout)
692 fputs("DEBUG: Got USB transaction timeout during write\n", stderr);
697 * If we've stalled, retry the write...
700 else if (iostatus == kIOUSBPipeStalled)
702 fputs("DEBUG: Got USB pipe stalled during write\n", stderr);
704 bytes = g.print_bytes;
705 iostatus = (*g.classdriver)->WritePipe(g.classdriver, (UInt8*)print_ptr, &bytes, 0);
709 * Retry a write after an aborted write since we probably just got
710 * SIGTERM (<rdar://problem/6860126>)...
713 else if (iostatus == kIOReturnAborted)
715 fputs("DEBUG: Got USB return aborted during write\n", stderr);
717 IOReturn err = (*g.classdriver)->Abort(g.classdriver);
718 fprintf(stderr, "DEBUG: USB class driver Abort returned %x\n", err);
722 #endif /* DEBUG_WRITES */
724 bytes = g.print_bytes;
725 iostatus = (*g.classdriver)->WritePipe(g.classdriver, (UInt8*)print_ptr, &bytes, 0);
731 * Write error - bail if we don't see an error we can retry...
734 _cupsLangPrintFilter(stderr, "ERROR",
735 _("Unable to send data to printer."));
736 fprintf(stderr, "DEBUG: USB class driver WritePipe returned %x\n",
739 IOReturn err = (*g.classdriver)->Abort(g.classdriver);
740 fprintf(stderr, "DEBUG: USB class driver Abort returned %x\n",
743 status = CUPS_BACKEND_FAILED;
748 fprintf(stderr, "DEBUG: Wrote %d bytes of print data...\n", (int)bytes);
750 g.print_bytes -= bytes;
752 total_bytes += bytes;
756 if (print_fd != 0 && status == noErr)
757 fprintf(stderr, "DEBUG: Sending print file, %lld bytes...\n",
762 fprintf(stderr, "DEBUG: Sent %lld bytes...\n", (off_t)total_bytes);
765 * Signal the side channel thread to exit...
768 if (have_sidechannel)
771 pthread_mutex_lock(&g.readwrite_lock_mutex);
772 g.readwrite_lock = 0;
773 pthread_cond_signal(&g.readwrite_lock_cond);
774 pthread_mutex_unlock(&g.readwrite_lock_mutex);
776 g.sidechannel_thread_stop = 1;
777 pthread_mutex_lock(&g.sidechannel_thread_mutex);
779 if (!g.sidechannel_thread_done)
781 gettimeofday(&tv, NULL);
782 cond_timeout.tv_sec = tv.tv_sec + WAIT_SIDE_DELAY;
783 cond_timeout.tv_nsec = tv.tv_usec * 1000;
785 while (!g.sidechannel_thread_done)
787 if (pthread_cond_timedwait(&g.sidechannel_thread_cond,
788 &g.sidechannel_thread_mutex,
794 pthread_mutex_unlock(&g.sidechannel_thread_mutex);
798 * Signal the read thread to exit then wait 7 seconds for it to complete...
801 g.read_thread_stop = 1;
803 pthread_mutex_lock(&g.read_thread_mutex);
805 if (!g.read_thread_done)
807 fputs("DEBUG: Waiting for read thread to exit...\n", stderr);
809 gettimeofday(&tv, NULL);
810 cond_timeout.tv_sec = tv.tv_sec + WAIT_EOF_DELAY;
811 cond_timeout.tv_nsec = tv.tv_usec * 1000;
813 while (!g.read_thread_done)
815 if (pthread_cond_timedwait(&g.read_thread_cond, &g.read_thread_mutex,
821 * If it didn't exit abort the pending read and wait an additional second...
824 if (!g.read_thread_done)
826 fputs("DEBUG: Read thread still active, aborting the pending read...\n",
831 (*g.classdriver)->Abort(g.classdriver);
833 gettimeofday(&tv, NULL);
834 cond_timeout.tv_sec = tv.tv_sec + 1;
835 cond_timeout.tv_nsec = tv.tv_usec * 1000;
837 while (!g.read_thread_done)
839 if (pthread_cond_timedwait(&g.read_thread_cond, &g.read_thread_mutex,
846 pthread_mutex_unlock(&g.read_thread_mutex);
849 * Close the connection and input file and general clean up...
854 if (print_fd != STDIN_FILENO)
863 if (g.serial != NULL)
866 if (g.printer_obj != 0x0)
867 IOObjectRelease(g.printer_obj);
874 * 'read_thread()' - Thread to read the backchannel data on.
877 static void *read_thread(void *reference)
879 UInt8 readbuffer[512];
881 kern_return_t readstatus;
882 struct mach_timebase_info timeBaseInfo;
889 /* Calculate what 250 milliSeconds are in mach absolute time...
891 mach_timebase_info(&timeBaseInfo);
892 delay = ((uint64_t)250000000 * (uint64_t)timeBaseInfo.denom) / (uint64_t)timeBaseInfo.numer;
897 * Remember when we started so we can throttle the loop after the read call...
900 start = mach_absolute_time();
902 rbytes = sizeof(readbuffer);
903 readstatus = (*g.classdriver)->ReadPipe(g.classdriver, readbuffer, &rbytes);
904 if (readstatus == kIOReturnSuccess && rbytes > 0)
906 fprintf(stderr, "DEBUG: Read %d bytes of back-channel data...\n",
908 cupsBackChannelWrite((char*)readbuffer, rbytes, 1.0);
910 /* cntrl-d is echoed by the printer.
912 * Xerox Phaser 6250D doesn't echo the cntrl-d.
913 * Xerox Phaser 6250D doesn't always send the product query.
915 if (g.wait_eof && readbuffer[rbytes-1] == 0x4)
918 #ifdef PARSE_PS_ERRORS
919 parse_pserror(readbuffer, rbytes);
922 else if (readstatus == kIOUSBTransactionTimeout)
923 fputs("DEBUG: Got USB transaction timeout during read\n", stderr);
924 else if (readstatus == kIOUSBPipeStalled)
925 fputs("DEBUG: Got USB pipe stalled during read\n", stderr);
926 else if (readstatus == kIOReturnAborted)
927 fputs("DEBUG: Got USB return aborted during read\n", stderr);
930 * Make sure this loop executes no more than once every 250 miliseconds...
933 if ((readstatus != kIOReturnSuccess || rbytes == 0) && (g.wait_eof || !g.read_thread_stop))
934 mach_wait_until(start + delay);
936 } while (g.wait_eof || !g.read_thread_stop); /* Abort from main thread tests error here */
939 * Let the main thread know that we have completed the read thread...
942 pthread_mutex_lock(&g.read_thread_mutex);
943 g.read_thread_done = 1;
944 pthread_cond_signal(&g.read_thread_cond);
945 pthread_mutex_unlock(&g.read_thread_mutex);
952 * 'sidechannel_thread()' - Handle side-channel requests.
956 sidechannel_thread(void *reference)
958 cups_sc_command_t command; /* Request command */
959 cups_sc_status_t status; /* Request/response status */
960 char data[2048]; /* Request/response data */
961 int datalen; /* Request/response data size */
968 datalen = sizeof(data);
970 if (cupsSideChannelRead(&command, &status, data, &datalen, 1.0))
972 if (status == CUPS_SC_STATUS_TIMEOUT)
980 case CUPS_SC_CMD_SOFT_RESET: /* Do a soft reset */
981 fputs("DEBUG: CUPS_SC_CMD_SOFT_RESET received from driver...\n",
984 if ((*g.classdriver)->SoftReset != NULL)
987 cupsSideChannelWrite(command, CUPS_SC_STATUS_OK, NULL, 0, 1.0);
988 fputs("DEBUG: Returning status CUPS_STATUS_OK with no bytes...\n",
993 cupsSideChannelWrite(command, CUPS_SC_STATUS_NOT_IMPLEMENTED,
995 fputs("DEBUG: Returning status CUPS_STATUS_NOT_IMPLEMENTED with "
996 "no bytes...\n", stderr);
1000 case CUPS_SC_CMD_DRAIN_OUTPUT: /* Drain all pending output */
1001 fputs("DEBUG: CUPS_SC_CMD_DRAIN_OUTPUT received from driver...\n",
1007 case CUPS_SC_CMD_GET_BIDI: /* Is the connection bidirectional? */
1008 fputs("DEBUG: CUPS_SC_CMD_GET_BIDI received from driver...\n",
1011 data[0] = g.bidi_flag;
1012 cupsSideChannelWrite(command, CUPS_SC_STATUS_OK, data, 1, 1.0);
1015 "DEBUG: Returned CUPS_SC_STATUS_OK with 1 byte (%02X)...\n",
1019 case CUPS_SC_CMD_GET_DEVICE_ID: /* Return IEEE-1284 device ID */
1020 fputs("DEBUG: CUPS_SC_CMD_GET_DEVICE_ID received from driver...\n",
1023 datalen = sizeof(data);
1024 get_device_id(&status, data, &datalen);
1025 cupsSideChannelWrite(command, CUPS_SC_STATUS_OK, data, datalen, 1.0);
1027 if (datalen < sizeof(data))
1028 data[datalen] = '\0';
1030 data[sizeof(data) - 1] = '\0';
1033 "DEBUG: Returning CUPS_SC_STATUS_OK with %d bytes (%s)...\n",
1037 case CUPS_SC_CMD_GET_STATE: /* Return device state */
1038 fputs("DEBUG: CUPS_SC_CMD_GET_STATE received from driver...\n",
1041 data[0] = CUPS_SC_STATE_ONLINE;
1042 cupsSideChannelWrite(command, CUPS_SC_STATUS_OK, data, 1, 1.0);
1045 "DEBUG: Returned CUPS_SC_STATUS_OK with 1 byte (%02X)...\n",
1050 fprintf(stderr, "DEBUG: Unknown side-channel command (%d) received "
1051 "from driver...\n", command);
1053 cupsSideChannelWrite(command, CUPS_SC_STATUS_NOT_IMPLEMENTED,
1056 fputs("DEBUG: Returned CUPS_SC_STATUS_NOT_IMPLEMENTED with no bytes...\n",
1061 while (!g.sidechannel_thread_stop);
1063 pthread_mutex_lock(&g.sidechannel_thread_mutex);
1064 g.sidechannel_thread_done = 1;
1065 pthread_cond_signal(&g.sidechannel_thread_cond);
1066 pthread_mutex_unlock(&g.sidechannel_thread_mutex);
1074 * 'iterate_printers()' - Iterate over all the printers.
1077 static void iterate_printers(iterator_callback_t callBack,
1080 mach_port_t masterPort = 0x0;
1081 kern_return_t kr = IOMasterPort (bootstrap_port, &masterPort);
1083 if (kr == kIOReturnSuccess && masterPort != 0x0)
1085 io_iterator_t addIterator = 0x0;
1087 iterator_reference_t reference = { callBack, userdata, true };
1088 IONotificationPortRef addNotification = IONotificationPortCreate(masterPort);
1090 int klass = kUSBPrintingClass;
1091 int subklass = kUSBPrintingSubclass;
1093 CFNumberRef usb_klass = CFNumberCreate(NULL, kCFNumberIntType, &klass);
1094 CFNumberRef usb_subklass = CFNumberCreate(NULL, kCFNumberIntType, &subklass);
1095 CFMutableDictionaryRef usbPrinterMatchDictionary = IOServiceMatching(kIOUSBInterfaceClassName);
1097 CFDictionaryAddValue(usbPrinterMatchDictionary, CFSTR("bInterfaceClass"), usb_klass);
1098 CFDictionaryAddValue(usbPrinterMatchDictionary, CFSTR("bInterfaceSubClass"), usb_subklass);
1100 CFRelease(usb_klass);
1101 CFRelease(usb_subklass);
1103 kr = IOServiceAddMatchingNotification(addNotification, kIOMatchedNotification, usbPrinterMatchDictionary, &device_added, &reference, &addIterator);
1104 if (addIterator != 0x0)
1106 device_added (&reference, addIterator);
1108 if (reference.keepRunning)
1110 CFRunLoopAddSource(CFRunLoopGetCurrent(), IONotificationPortGetRunLoopSource(addNotification), kCFRunLoopDefaultMode);
1113 IOObjectRelease(addIterator);
1115 mach_port_deallocate(mach_task_self(), masterPort);
1121 * 'device_added()' - Device added notifier.
1124 static void device_added(void *userdata,
1125 io_iterator_t iterator)
1127 iterator_reference_t *reference = userdata;
1130 while (reference->keepRunning && (obj = IOIteratorNext(iterator)) != 0x0)
1132 if (reference->callback != NULL)
1133 reference->keepRunning = reference->callback(reference->userdata, obj);
1135 IOObjectRelease(obj);
1138 /* One last call to the call back now that we are not longer have printers left to iterate...
1140 if (reference->keepRunning)
1141 reference->keepRunning = reference->callback(reference->userdata, 0x0);
1143 if (!reference->keepRunning)
1144 CFRunLoopStop(CFRunLoopGetCurrent());
1149 * 'list_device_cb()' - list_device iterator callback.
1152 static Boolean list_device_cb(void *refcon,
1155 Boolean keepRunning = (obj != 0x0);
1162 CFStringRef deviceIDString = NULL;
1163 UInt32 deviceLocation = 0;
1164 UInt8 interfaceNum = 0;
1166 copy_devicestring(obj, &deviceIDString, &deviceLocation, &interfaceNum);
1167 if (deviceIDString != NULL)
1169 CFStringRef make = NULL, model = NULL, serial = NULL;
1170 char uristr[1024], makestr[1024], modelstr[1024], serialstr[1024];
1171 char optionsstr[1024], idstr[1024], make_modelstr[1024];
1173 copy_deviceinfo(deviceIDString, &make, &model, &serial);
1174 CFStringGetCString(deviceIDString, idstr, sizeof(idstr),
1175 kCFStringEncodingUTF8);
1176 backendGetMakeModel(idstr, make_modelstr, sizeof(make_modelstr));
1181 !CFStringGetCString(make, makestr, sizeof(makestr),
1182 kCFStringEncodingUTF8))
1183 strcpy(makestr, "Unknown");
1186 !CFStringGetCString(model, &modelstr[1], sizeof(modelstr)-1,
1187 kCFStringEncodingUTF8))
1188 strcpy(modelstr + 1, "Printer");
1190 optionsstr[0] = '\0';
1193 CFStringGetCString(serial, serialstr, sizeof(serialstr), kCFStringEncodingUTF8);
1194 snprintf(optionsstr, sizeof(optionsstr), "?serial=%s", serialstr);
1196 else if (deviceLocation != 0)
1197 snprintf(optionsstr, sizeof(optionsstr), "?location=%x", (unsigned)deviceLocation);
1199 httpAssembleURI(HTTP_URI_CODING_ALL, uristr, sizeof(uristr), "usb", NULL, makestr, 0, modelstr);
1200 strlcat(uristr, optionsstr, sizeof(uristr));
1202 cupsBackendReport("direct", uristr, make_modelstr, make_modelstr, idstr,
1205 release_deviceinfo(&make, &model, &serial);
1206 CFRelease(deviceIDString);
1215 * 'find_device_cb()' - print_device iterator callback.
1218 static Boolean find_device_cb(void *refcon,
1221 Boolean keepLooking = true;
1225 CFStringRef idString = NULL;
1226 UInt32 location = -1;
1227 UInt8 interfaceNum = 0;
1229 copy_devicestring(obj, &idString, &location, &interfaceNum);
1230 if (idString != NULL)
1232 CFStringRef make = NULL, model = NULL, serial = NULL;
1234 copy_deviceinfo(idString, &make, &model, &serial);
1235 if (make && CFStringCompare(make, g.make, kCFCompareCaseInsensitive) == kCFCompareEqualTo)
1237 if (model && CFStringCompare(model, g.model, kCFCompareCaseInsensitive) == kCFCompareEqualTo)
1239 if (g.serial != NULL && CFStringGetLength(g.serial) > 0)
1241 if (serial != NULL && CFStringCompare(serial, g.serial, kCFCompareCaseInsensitive) == kCFCompareEqualTo)
1243 IOObjectRetain(obj);
1244 g.printer_obj = obj;
1245 keepLooking = false;
1250 if (g.printer_obj != 0)
1251 IOObjectRelease(g.printer_obj);
1253 g.printer_obj = obj;
1254 IOObjectRetain(obj);
1256 if (g.location == 0 || g.location == location)
1257 keepLooking = false;
1260 g.interfaceNum = interfaceNum;
1264 release_deviceinfo(&make, &model, &serial);
1265 CFRelease(idString);
1270 keepLooking = (g.printer_obj == 0);
1271 if (obj == 0x0 && keepLooking)
1273 CFRunLoopTimerContext context = { 0, refcon, NULL, NULL, NULL };
1274 CFRunLoopTimerRef timer = CFRunLoopTimerCreate(NULL, CFAbsoluteTimeGetCurrent() + 1.0, 10, 0x0, 0x0, status_timer_cb, &context);
1277 CFRunLoopAddTimer(CFRunLoopGetCurrent(), timer, kCFRunLoopDefaultMode);
1278 g.status_timer = timer;
1283 if (!keepLooking && g.status_timer != NULL)
1285 fputs("STATE: -offline-report\n", stderr);
1286 _cupsLangPrintFilter(stderr, "INFO", _("Printer is now online."));
1287 CFRunLoopRemoveTimer(CFRunLoopGetCurrent(), g.status_timer, kCFRunLoopDefaultMode);
1288 CFRelease(g.status_timer);
1289 g.status_timer = NULL;
1297 * 'status_timer_cb()' - Status timer callback.
1300 static void status_timer_cb(CFRunLoopTimerRef timer,
1306 fputs("STATE: +offline-report\n", stderr);
1307 _cupsLangPrintFilter(stderr, "INFO", _("Printer is offline."));
1309 if (getenv("CLASS") != NULL)
1312 * If the CLASS environment variable is set, the job was submitted
1313 * to a class and not to a specific queue. In this case, we want
1314 * to abort immediately so that the job can be requeued on the next
1315 * available printer in the class.
1317 * Sleep 5 seconds to keep the job from requeuing too rapidly...
1322 exit(CUPS_BACKEND_FAILED);
1329 * 'copy_deviceinfo()' - Copy strings from the 1284 device ID.
1332 static void copy_deviceinfo(CFStringRef deviceIDString,
1335 CFStringRef *serial)
1337 CFStringRef modelKeys[] = { CFSTR("MDL:"), CFSTR("MODEL:"), NULL };
1338 CFStringRef makeKeys[] = { CFSTR("MFG:"), CFSTR("MANUFACTURER:"), NULL };
1339 CFStringRef serialKeys[] = { CFSTR("SN:"), CFSTR("SERN:"), NULL };
1342 *make = copy_value_for_key(deviceIDString, makeKeys);
1345 *model = copy_value_for_key(deviceIDString, modelKeys);
1348 *serial = copy_value_for_key(deviceIDString, serialKeys);
1353 * 'release_deviceinfo()' - Release deviceinfo strings.
1356 static void release_deviceinfo(CFStringRef *make,
1358 CFStringRef *serial)
1360 if (make != NULL && *make != NULL)
1366 if (model != NULL && *model != NULL)
1372 if (serial != NULL && *serial != NULL)
1382 * 'load_classdriver()' - Load a classdriver.
1385 static kern_return_t load_classdriver(CFStringRef driverPath,
1386 printer_interface_t interface,
1387 classdriver_t ***printerDriver)
1389 kern_return_t kr = kUSBPrinterClassDeviceNotOpen;
1390 classdriver_t **driver = NULL;
1391 CFStringRef bundle = driverPath ? driverPath : kUSBGenericTOPrinterClassDriver;
1392 char bundlestr[1024]; /* Bundle path */
1393 CFURLRef url; /* URL for driver */
1394 CFPlugInRef plugin = NULL; /* Plug-in address */
1397 CFStringGetCString(bundle, bundlestr, sizeof(bundlestr), kCFStringEncodingUTF8);
1400 * Validate permissions for the class driver...
1403 _cups_fc_result_t result = _cupsFileCheck(bundlestr,
1404 _CUPS_FILE_CHECK_DIRECTORY, 1,
1405 _cupsFileCheckFilter, NULL);
1407 if (result && driverPath)
1408 return (load_classdriver(NULL, interface, printerDriver));
1413 * Try loading the class driver...
1416 url = CFURLCreateWithFileSystemPath(NULL, bundle, kCFURLPOSIXPathStyle, true);
1420 plugin = CFPlugInCreate(NULL, url);
1428 CFArrayRef factories = CFPlugInFindFactoriesForPlugInTypeInPlugIn(kUSBPrinterClassTypeID, plugin);
1429 if (factories != NULL && CFArrayGetCount(factories) > 0)
1431 CFUUIDRef factoryID = CFArrayGetValueAtIndex(factories, 0);
1432 IUnknownVTbl **iunknown = CFPlugInInstanceCreate(NULL, factoryID, kUSBPrinterClassTypeID);
1433 if (iunknown != NULL)
1435 kr = (*iunknown)->QueryInterface(iunknown, CFUUIDGetUUIDBytes(kUSBPrinterClassInterfaceID), (LPVOID *)&driver);
1436 if (kr == kIOReturnSuccess && driver != NULL)
1438 classdriver_t **genericDriver = NULL;
1439 if (driverPath != NULL && CFStringCompare(driverPath, kUSBGenericTOPrinterClassDriver, 0) != kCFCompareEqualTo)
1440 kr = load_classdriver(NULL, interface, &genericDriver);
1442 if (kr == kIOReturnSuccess)
1444 (*driver)->interface = interface;
1445 (*driver)->Initialize(driver, genericDriver);
1447 (*driver)->plugin = plugin;
1448 (*driver)->interface = interface;
1449 *printerDriver = driver;
1452 (*iunknown)->Release(iunknown);
1454 CFRelease(factories);
1458 fprintf(stderr, "DEBUG: load_classdriver(%s) (kr:0x%08x)\n", bundlestr, (int)kr);
1465 * 'unload_classdriver()' - Unload a classdriver.
1468 static kern_return_t unload_classdriver(classdriver_t ***classdriver)
1470 if (*classdriver != NULL)
1472 (**classdriver)->Release(*classdriver);
1473 *classdriver = NULL;
1476 return kIOReturnSuccess;
1481 * 'load_printerdriver()' - Load vendor's classdriver.
1483 * If driverBundlePath is not NULL on return it is the callers responsbility to release it!
1486 static kern_return_t load_printerdriver(CFStringRef *driverBundlePath)
1488 IOCFPlugInInterface **iodev = NULL;
1491 printer_interface_t interface;
1494 kr = IOCreatePlugInInterfaceForService(g.printer_obj, kIOUSBInterfaceUserClientTypeID, kIOCFPlugInInterfaceID, &iodev, &score);
1495 if (kr == kIOReturnSuccess)
1497 if ((res = (*iodev)->QueryInterface(iodev, USB_INTERFACE_KIND, (LPVOID *) &interface)) == noErr)
1499 *driverBundlePath = IORegistryEntryCreateCFProperty(g.printer_obj, kUSBClassDriverProperty, NULL, kNilOptions);
1501 kr = load_classdriver(*driverBundlePath, interface, &g.classdriver);
1503 if (kr != kIOReturnSuccess)
1504 (*interface)->Release(interface);
1506 IODestroyPlugInInterface(iodev);
1513 * 'registry_open()' - Open a connection to the printer.
1516 static kern_return_t registry_open(CFStringRef *driverBundlePath)
1518 g.bidi_flag = 0; /* 0=unidirectional */
1520 kern_return_t kr = load_printerdriver(driverBundlePath);
1521 if (kr != kIOReturnSuccess)
1524 if (g.classdriver != NULL)
1526 (*g.classdriver)->interfaceNumber = g.interfaceNum;
1527 kr = (*g.classdriver)->Open(g.classdriver, g.location, kUSBPrintingProtocolBidirectional);
1528 if (kr != kIOReturnSuccess || (*g.classdriver)->interface == NULL)
1530 kr = (*g.classdriver)->Open(g.classdriver, g.location, kUSBPrintingProtocolUnidirectional);
1531 if (kr == kIOReturnSuccess)
1533 if ((*g.classdriver)->interface == NULL)
1535 (*g.classdriver)->Close(g.classdriver);
1541 g.bidi_flag = 1; /* 1=bidirectional */
1544 if (kr != kIOReturnSuccess)
1545 unload_classdriver(&g.classdriver);
1552 * 'registry_close()' - Close the connection to the printer.
1555 static kern_return_t registry_close(void)
1557 if (g.classdriver != NULL)
1558 (*g.classdriver)->Close(g.classdriver);
1560 unload_classdriver(&g.classdriver);
1561 return kIOReturnSuccess;
1566 * 'copy_deviceid()' - Copy the 1284 device id string.
1569 static OSStatus copy_deviceid(classdriver_t **classdriver,
1570 CFStringRef *deviceID)
1572 CFStringRef devID = NULL,
1576 deviceSerial = NULL;
1578 OSStatus err = (*classdriver)->GetDeviceID(classdriver, &devID, DEFAULT_TIMEOUT);
1580 copy_deviceinfo(devID, &deviceMake, &deviceModel, &deviceSerial);
1582 if (deviceMake == NULL || deviceModel == NULL || deviceSerial == NULL)
1584 IOUSBDeviceDescriptor desc;
1585 iodevice_request_t request;
1587 request.requestType = USBmakebmRequestType(kUSBIn, kUSBStandard, kUSBDevice);
1588 request.request = kUSBRqGetDescriptor;
1589 request.value = (kUSBDeviceDesc << 8) | 0;
1591 request.length = sizeof(desc);
1592 request.buffer = &desc;
1593 err = (*classdriver)->DeviceRequest(classdriver, &request, DEFAULT_TIMEOUT);
1594 if (err == kIOReturnSuccess)
1596 CFMutableStringRef newDevID = CFStringCreateMutable(NULL, 0);
1598 if (deviceMake == NULL)
1600 CFStringRef data = NULL;
1601 err = (*classdriver)->GetString(classdriver, desc.iManufacturer, kUSBLanguageEnglish, DEFAULT_TIMEOUT, &data);
1604 CFStringAppendFormat(newDevID, NULL, CFSTR("MFG:%@;"), data);
1609 if (deviceModel == NULL)
1611 CFStringRef data = NULL;
1612 err = (*classdriver)->GetString(classdriver, desc.iProduct, kUSBLanguageEnglish, DEFAULT_TIMEOUT, &data);
1615 CFStringAppendFormat(newDevID, NULL, CFSTR("MDL:%@;"), data);
1620 if (deviceSerial == NULL && desc.iSerialNumber != 0)
1622 CFStringRef data = NULL;
1623 err = (*classdriver)->GetString(classdriver, desc.iSerialNumber, kUSBLanguageEnglish, DEFAULT_TIMEOUT, &data);
1626 CFStringAppendFormat(newDevID, NULL, CFSTR("SERN:%@;"), data);
1633 CFStringAppend(newDevID, devID);
1637 *deviceID = newDevID;
1644 release_deviceinfo(&deviceMake, &deviceModel, &deviceSerial);
1651 * 'copy_devicestring()' - Copy the 1284 device id string.
1654 static void copy_devicestring(io_service_t usbInterface,
1655 CFStringRef *deviceID,
1656 UInt32 *deviceLocation,
1657 UInt8 *interfaceNumber )
1659 IOCFPlugInInterface **iodev = NULL;
1662 printer_interface_t interface;
1664 classdriver_t **klassDriver = NULL;
1665 CFStringRef driverBundlePath;
1667 if ((kr = IOCreatePlugInInterfaceForService(usbInterface,
1668 kIOUSBInterfaceUserClientTypeID,
1669 kIOCFPlugInInterfaceID,
1670 &iodev, &score)) == kIOReturnSuccess)
1672 if ((res = (*iodev)->QueryInterface(iodev, USB_INTERFACE_KIND, (LPVOID *)
1673 &interface)) == noErr)
1675 (*interface)->GetLocationID(interface, deviceLocation);
1676 (*interface)->GetInterfaceNumber(interface, interfaceNumber);
1678 driverBundlePath = IORegistryEntryCreateCFProperty(usbInterface,
1679 kUSBClassDriverProperty,
1682 kr = load_classdriver(driverBundlePath, interface, &klassDriver);
1684 if (kr != kIOReturnSuccess && driverBundlePath != NULL)
1685 kr = load_classdriver(NULL, interface, &klassDriver);
1687 if (kr == kIOReturnSuccess && klassDriver != NULL)
1688 kr = copy_deviceid(klassDriver, deviceID);
1690 unload_classdriver(&klassDriver);
1692 if (driverBundlePath != NULL)
1693 CFRelease(driverBundlePath);
1695 /* (*interface)->Release(interface); */
1697 IODestroyPlugInInterface(iodev);
1704 * 'copy_value_for_key()' - Copy value string associated with a key.
1707 static CFStringRef copy_value_for_key(CFStringRef deviceID,
1710 CFStringRef value = NULL;
1711 CFArrayRef kvPairs = deviceID != NULL ? CFStringCreateArrayBySeparatingStrings(NULL, deviceID, CFSTR(";")) : NULL;
1712 CFIndex max = kvPairs != NULL ? CFArrayGetCount(kvPairs) : 0;
1715 while (idx < max && value == NULL)
1717 CFStringRef kvpair = CFArrayGetValueAtIndex(kvPairs, idx);
1719 while (keys[idxx] != NULL && value == NULL)
1721 CFRange range = CFStringFind(kvpair, keys[idxx], kCFCompareCaseInsensitive);
1722 if (range.length != -1)
1724 if (range.location != 0)
1726 CFMutableStringRef theString = CFStringCreateMutableCopy(NULL, 0, kvpair);
1727 CFStringTrimWhitespace(theString);
1728 range = CFStringFind(theString, keys[idxx], kCFCompareCaseInsensitive);
1729 if (range.location == 0)
1730 value = CFStringCreateWithSubstring(NULL, theString, CFRangeMake(range.length, CFStringGetLength(theString) - range.length));
1732 CFRelease(theString);
1736 CFStringRef theString = CFStringCreateWithSubstring(NULL, kvpair, CFRangeMake(range.length, CFStringGetLength(kvpair) - range.length));
1737 CFMutableStringRef theString2 = CFStringCreateMutableCopy(NULL, 0, theString);
1738 CFRelease(theString);
1740 CFStringTrimWhitespace(theString2);
1749 if (kvPairs != NULL)
1756 * 'cfstr_create_trim()' - Create CFString and trim whitespace characters.
1759 CFStringRef cfstr_create_trim(const char *cstr)
1762 CFMutableStringRef cfmutablestr = NULL;
1764 if ((cfstr = CFStringCreateWithCString(NULL, cstr, kCFStringEncodingUTF8)) != NULL)
1766 if ((cfmutablestr = CFStringCreateMutableCopy(NULL, 1024, cfstr)) != NULL)
1767 CFStringTrimWhitespace(cfmutablestr);
1771 return (CFStringRef) cfmutablestr;
1777 * 'parse_options()' - Parse URI options.
1780 static void parse_options(char *options,
1786 char sep, /* Separator character */
1787 *name, /* Name of option */
1788 *value; /* Value of option */
1807 while (*options && *options != '=' && *options != '+' && *options != '&')
1810 if ((sep = *options) != '\0')
1821 while (*options && *options != '+' && *options != '&')
1831 * Process the option...
1834 if (!_cups_strcasecmp(name, "waiteof"))
1836 if (!_cups_strcasecmp(value, "on") ||
1837 !_cups_strcasecmp(value, "yes") ||
1838 !_cups_strcasecmp(value, "true"))
1840 else if (!_cups_strcasecmp(value, "off") ||
1841 !_cups_strcasecmp(value, "no") ||
1842 !_cups_strcasecmp(value, "false"))
1845 _cupsLangPrintFilter(stderr, "WARNING",
1846 _("Boolean expected for waiteof option \"%s\"."),
1849 else if (!_cups_strcasecmp(name, "serial"))
1850 strlcpy(serial, value, serial_size);
1851 else if (!_cups_strcasecmp(name, "location") && location)
1852 *location = strtol(value, NULL, 16);
1858 * @function setup_cfLanguage
1859 * @abstract Convert the contents of the CUPS 'APPLE_LANGUAGE' environment
1860 * variable into a one element CF array of languages.
1862 * @discussion Each submitted job comes with a natural language. CUPS passes
1863 * that language in an environment variable. We take that language
1864 * and jam it into the AppleLanguages array so that CF will use
1865 * it when reading localized resources. We need to do this before
1866 * any CF code reads and caches the languages array, so this function
1867 * should be called early in main()
1869 static void setup_cfLanguage(void)
1871 CFStringRef lang[1] = {NULL};
1872 CFArrayRef langArray = NULL;
1873 const char *requestedLang = NULL;
1875 if ((requestedLang = getenv("APPLE_LANGUAGE")) == NULL)
1876 requestedLang = getenv("LANG");
1878 if (requestedLang != NULL)
1880 lang[0] = CFStringCreateWithCString(kCFAllocatorDefault, requestedLang, kCFStringEncodingUTF8);
1881 langArray = CFArrayCreate(kCFAllocatorDefault, (const void **)lang, sizeof(lang) / sizeof(lang[0]), &kCFTypeArrayCallBacks);
1883 CFPreferencesSetValue(CFSTR("AppleLanguages"), langArray, kCFPreferencesCurrentApplication, kCFPreferencesAnyUser, kCFPreferencesAnyHost);
1884 fprintf(stderr, "DEBUG: usb: AppleLanguages=\"%s\"\n", requestedLang);
1887 CFRelease(langArray);
1890 fputs("DEBUG: usb: LANG and APPLE_LANGUAGE environment variables missing.\n", stderr);
1894 #if defined(__i386__) || defined(__x86_64__)
1896 * @function run_legacy_backend
1898 * @abstract Starts child backend process running as a ppc or i386 executable.
1900 * @result Never returns; always calls exit().
1904 static void run_legacy_backend(int argc,
1911 pid_t waitpid_status;
1913 char *usb_legacy_status;
1916 * If we're running as x86_64 or i386 and couldn't load the class driver
1917 * (because it's ppc or i386), then try to re-exec ourselves in ppc or i386
1918 * mode to try again. If we don't have a ppc or i386 architecture we may be
1919 * running with the same architecture again so guard against this by setting
1920 * and testing an environment variable...
1924 usb_legacy_status = getenv("USB_I386_STATUS");
1926 usb_legacy_status = getenv("USB_PPC_STATUS");
1927 # endif /* __x86_64__ */
1929 if (!usb_legacy_status)
1932 * Setup a SIGTERM handler then block it before forking...
1935 int err; /* posix_spawn result */
1936 struct sigaction action; /* POSIX signal action */
1937 sigset_t newmask, /* New signal mask */
1938 oldmask; /* Old signal mask */
1939 char usbpath[1024]; /* Path to USB backend */
1940 const char *cups_serverbin;/* Path to CUPS binaries */
1943 memset(&action, 0, sizeof(action));
1944 sigaddset(&action.sa_mask, SIGTERM);
1945 action.sa_handler = sigterm_handler;
1946 sigaction(SIGTERM, &action, NULL);
1948 sigemptyset(&newmask);
1949 sigaddset(&newmask, SIGTERM);
1950 sigprocmask(SIG_BLOCK, &newmask, &oldmask);
1953 * Set the environment variable...
1957 setenv("USB_I386_STATUS", "1", false);
1959 setenv("USB_PPC_STATUS", "1", false);
1960 # endif /* __x86_64__ */
1963 * Tell the kernel to use the specified CPU architecture...
1967 cpu_type_t cpu = CPU_TYPE_I386;
1969 cpu_type_t cpu = CPU_TYPE_POWERPC;
1970 # endif /* __x86_64__ */
1972 posix_spawnattr_t attrs;
1974 if (!posix_spawnattr_init(&attrs))
1976 posix_spawnattr_setsigdefault(&attrs, &oldmask);
1977 if (posix_spawnattr_setbinpref_np(&attrs, 1, &cpu, &ocount) || ocount != 1)
1980 perror("DEBUG: Unable to set binary preference to i386");
1982 perror("DEBUG: Unable to set binary preference to ppc");
1983 # endif /* __x86_64__ */
1984 _cupsLangPrintFilter(stderr, "ERROR",
1985 _("Unable to use legacy USB class driver."));
1986 exit(CUPS_BACKEND_STOP);
1991 * Set up the arguments and call posix_spawn...
1994 if ((cups_serverbin = getenv("CUPS_SERVERBIN")) == NULL)
1995 cups_serverbin = CUPS_SERVERBIN;
1996 snprintf(usbpath, sizeof(usbpath), "%s/backend/usb", cups_serverbin);
1998 for (i = 0; i < argc && i < (sizeof(my_argv) / sizeof(my_argv[0])) - 1; i ++)
1999 my_argv[i] = argv[i];
2003 if ((err = posix_spawn(&child_pid, usbpath, NULL, &attrs, my_argv,
2006 fprintf(stderr, "DEBUG: Unable to exec %s: %s\n", usbpath,
2008 _cupsLangPrintFilter(stderr, "ERROR",
2009 _("Unable to use legacy USB class driver."));
2010 exit(CUPS_BACKEND_STOP);
2014 * Unblock signals...
2017 sigprocmask(SIG_SETMASK, &oldmask, NULL);
2020 * Close the fds we won't be using then wait for the child backend to exit.
2026 fprintf(stderr, "DEBUG: Started usb(legacy) backend (PID %d)\n",
2029 while ((waitpid_status = waitpid(child_pid, &childstatus, 0)) == (pid_t)-1 && errno == EINTR)
2032 if (WIFSIGNALED(childstatus))
2034 exitstatus = CUPS_BACKEND_STOP;
2035 fprintf(stderr, "DEBUG: usb(legacy) backend %d crashed on signal %d\n",
2036 child_pid, WTERMSIG(childstatus));
2040 if ((exitstatus = WEXITSTATUS(childstatus)) != 0)
2042 "DEBUG: usb(legacy) backend %d stopped with status %d\n",
2043 child_pid, exitstatus);
2045 fprintf(stderr, "DEBUG: usb(legacy) backend %d exited with no errors\n",
2051 fputs("DEBUG: usb(legacy) backend running native again\n", stderr);
2052 exitstatus = CUPS_BACKEND_STOP;
2057 #endif /* __i386__ || __x86_64__ */
2061 * 'sigterm_handler()' - SIGTERM handler.
2065 sigterm_handler(int sig) /* I - Signal */
2067 #if defined(__i386__) || defined(__x86_64__)
2069 * If we started a child process pass the signal on to it...
2075 * If we started a child process pass the signal on to it...
2080 kill(child_pid, sig);
2081 while (waitpid(child_pid, &status, 0) < 0 && errno == EINTR);
2083 if (WIFEXITED(status))
2084 exit(WEXITSTATUS(status));
2085 else if (status == SIGTERM || status == SIGKILL)
2089 fprintf(stderr, "DEBUG: Child crashed on signal %d\n", status);
2090 exit(CUPS_BACKEND_STOP);
2093 #endif /* __i386__ || __x86_64__ */
2097 #ifdef PARSE_PS_ERRORS
2099 * 'next_line()' - Find the next line in a buffer.
2102 static const char *next_line (const char *buffer)
2104 const char *cptr, *lptr = NULL;
2106 for (cptr = buffer; *cptr && lptr == NULL; cptr++)
2107 if (*cptr == '\n' || *cptr == '\r')
2114 * 'parse_pserror()' - Scan the backchannel data for postscript errors.
2117 static void parse_pserror(char *sockBuffer,
2120 static char gErrorBuffer[1024] = "";
2121 static char *gErrorBufferPtr = gErrorBuffer;
2122 static char *gErrorBufferEndPtr = gErrorBuffer + sizeof(gErrorBuffer);
2124 char *pCommentBegin, *pCommentEnd, *pLineEnd;
2129 if (gErrorBufferPtr + len > gErrorBufferEndPtr - 1)
2130 gErrorBufferPtr = gErrorBuffer;
2131 if (len > sizeof(gErrorBuffer) - 1)
2132 len = sizeof(gErrorBuffer) - 1;
2134 memcpy(gErrorBufferPtr, (const void *)sockBuffer, len);
2135 gErrorBufferPtr += len;
2136 *(gErrorBufferPtr + 1) = '\0';
2138 pLineEnd = (char *)next_line((const char *)gErrorBuffer);
2139 while (pLineEnd != NULL)
2143 pCommentBegin = strstr(gErrorBuffer,"%%[");
2144 pCommentEnd = strstr(gErrorBuffer, "]%%");
2145 if (pCommentBegin != gErrorBuffer && pCommentEnd != NULL)
2147 pCommentEnd += 3; /* Skip past "]%%" */
2148 *pCommentEnd = '\0'; /* There's always room for the nul */
2150 if (_cups_strncasecmp(pCommentBegin, "%%[ Error:", 10) == 0)
2152 else if (_cups_strncasecmp(pCommentBegin, "%%[ Flushing", 12) == 0)
2157 if ((logstrlen = snprintf(logstr, sizeof(logstr), "%s: %s\n", logLevel, pCommentBegin)) >= sizeof(logstr))
2159 /* If the string was trucnated make sure it has a linefeed before the nul */
2160 logstrlen = sizeof(logstr) - 1;
2161 logstr[logstrlen - 1] = '\n';
2163 write(STDERR_FILENO, logstr, logstrlen);
2166 /* move everything over... */
2167 strcpy(gErrorBuffer, pLineEnd);
2168 gErrorBufferPtr = gErrorBuffer;
2169 pLineEnd = (char *)next_line((const char *)gErrorBuffer);
2172 #endif /* PARSE_PS_ERRORS */
2176 * 'soft_reset()' - Send a soft reset to the device.
2179 static void soft_reset(void)
2181 fd_set input_set; /* Input set for select() */
2182 struct timeval tv; /* Time value */
2183 char buffer[2048]; /* Buffer */
2184 struct timespec cond_timeout; /* pthread condition timeout */
2187 * Send an abort once a second until the I/O lock is released by the main thread...
2190 pthread_mutex_lock(&g.readwrite_lock_mutex);
2191 while (g.readwrite_lock)
2193 (*g.classdriver)->Abort(g.classdriver);
2195 gettimeofday(&tv, NULL);
2196 cond_timeout.tv_sec = tv.tv_sec + 1;
2197 cond_timeout.tv_nsec = tv.tv_usec * 1000;
2199 while (g.readwrite_lock)
2201 if (pthread_cond_timedwait(&g.readwrite_lock_cond,
2202 &g.readwrite_lock_mutex,
2203 &cond_timeout) != 0)
2208 g.readwrite_lock = 1;
2209 pthread_mutex_unlock(&g.readwrite_lock_mutex);
2212 * Flush bytes waiting on print_fd...
2217 FD_ZERO(&input_set);
2218 FD_SET(g.print_fd, &input_set);
2223 while (select(g.print_fd+1, &input_set, NULL, NULL, &tv) > 0)
2224 if (read(g.print_fd, buffer, sizeof(buffer)) <= 0)
2231 (*g.classdriver)->SoftReset(g.classdriver, DEFAULT_TIMEOUT);
2234 * Release the I/O lock...
2237 pthread_mutex_lock(&g.readwrite_lock_mutex);
2238 g.readwrite_lock = 0;
2239 pthread_cond_signal(&g.readwrite_lock_cond);
2240 pthread_mutex_unlock(&g.readwrite_lock_mutex);
2245 * 'get_device_id()' - Return IEEE-1284 device ID.
2248 static void get_device_id(cups_sc_status_t *status,
2252 CFStringRef deviceIDString = NULL;
2255 copy_deviceid(g.classdriver, &deviceIDString);
2259 CFStringGetCString(deviceIDString, data, *datalen, kCFStringEncodingUTF8);
2260 *datalen = strlen(data);
2261 CFRelease(deviceIDString);
2263 *status = CUPS_SC_STATUS_OK;
2268 * End of "$Id: usb-darwin.c 9887 2011-08-11 22:04:59Z mike $".