]> git.ipfire.org Git - thirdparty/cups.git/blob - cups/dest.c
projects / thirdparty / cups.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge changes from CUPS 1.6svn-r10510.
[thirdparty/cups.git] / cups / dest.c
1 /*
2 * "$Id: dest.c 9568 2011-02-25 06:13:56Z mike $"
3 *
4 * User-defined destination (and option) support for CUPS.
5 *
6 * Copyright 2007-2012 by Apple Inc.
7 * Copyright 1997-2007 by Easy Software Products.
8 *
9 * These coded instructions, statements, and computer programs are the
10 * property of Apple Inc. and are protected by Federal copyright
11 * law. Distribution and use rights are outlined in the file "LICENSE.txt"
12 * which should have been included with this file. If this file is
13 * file is missing or damaged, see the license at "http://www.cups.org/".
14 *
15 * This file is subject to the Apple OS-Developed Software exception.
16 *
17 * Contents:
18 *
19 * cupsAddDest() - Add a destination to the list of
20 * destinations.
21 * _cupsAppleCopyDefaultPaperID() - Get the default paper ID.
22 * _cupsAppleCopyDefaultPrinter() - Get the default printer at this location.
23 * _cupsAppleGetUseLastPrinter() - Get whether to use the last used printer.
24 * _cupsAppleSetDefaultPaperID() - Set the default paper id.
25 * _cupsAppleSetDefaultPrinter() - Set the default printer for this
26 * location.
27 * _cupsAppleSetUseLastPrinter() - Set whether to use the last used printer.
28 * cupsConnectDest() - Connect to the server for a destination.
29 * cupsConnectDestBlock() - Connect to the server for a destination.
30 * cupsCopyDest() - Copy a destination.
31 * cupsEnumDests() - Enumerate available destinations with a
32 * callback function.
33 * cupsEnumDestsBlock() - Enumerate available destinations with a
34 * block.
35 * cupsFreeDests() - Free the memory used by the list of
36 * destinations.
37 * cupsGetDest() - Get the named destination from the list.
38 * _cupsGetDestResource() - Get the resource path and URI for a
39 * destination.
40 * _cupsGetDests() - Get destinations from a server.
41 * cupsGetDests() - Get the list of destinations from the
42 * default server.
43 * cupsGetDests2() - Get the list of destinations from the
44 * specified server.
45 * cupsGetNamedDest() - Get options for the named destination.
46 * cupsRemoveDest() - Remove a destination from the destination
47 * list.
48 * cupsSetDefaultDest() - Set the default destination.
49 * cupsSetDests() - Save the list of destinations for the
50 * default server.
51 * cupsSetDests2() - Save the list of destinations for the
52 * specified server.
53 * _cupsUserDefault() - Get the user default printer from
54 * environment variables and location
55 * information.
56 * appleCopyLocations() - Copy the location history array.
57 * appleCopyNetwork() - Get the network ID for the current
58 * location.
59 * appleGetPaperSize() - Get the default paper size.
60 * appleGetPrinter() - Get a printer from the history array.
61 * cups_add_dest() - Add a destination to the array.
62 * cups_block_cb() - Enumeration callback for block API.
63 * cups_compare_dests() - Compare two destinations.
64 * cups_dnssd_browse_cb() - Browse for printers.
65 * cups_dnssd_browse_cb() - Browse for printers.
66 * cups_dnssd_client_cb() - Avahi client callback function.
67 * cups_dnssd_compare_device() - Compare two devices.
68 * cups_dnssd_free_device() - Free the memory used by a device.
69 * cups_dnssd_get_device() - Lookup a device and create it as needed.
70 * cups_dnssd_local_cb() - Browse for local printers.
71 * cups_dnssd_poll_cb() - Wait for input on the specified file
72 * descriptors.
73 * cups_dnssd_query_cb() - Process query data.
74 * cups_dnssd_resolve() - Resolve a Bonjour printer URI.
75 * cups_dnssd_resolve_cb() - See if we should continue resolving.
76 * cups_dnssd_unquote() - Unquote a name string.
77 * cups_find_dest() - Find a destination using a binary search.
78 * cups_get_default() - Get the default destination from an
79 * lpoptions file.
80 * cups_get_dests() - Get destinations from a file.
81 * cups_make_string() - Make a comma-separated string of values
82 * from an IPP attribute.
83 */
84
85 /*
86 * Include necessary headers...
87 */
88
89 #include "cups-private.h"
90 #include <sys/stat.h>
91
92 #ifdef HAVE_NOTIFY_H
93 # include <notify.h>
94 #endif /* HAVE_NOTIFY_H */
95
96 #ifdef HAVE_POLL
97 # include <poll.h>
98 #endif /* HAVE_POLL */
99
100 #ifdef HAVE_DNSSD
101 # include <dns_sd.h>
102 #endif /* HAVE_DNSSD */
103
104 #ifdef HAVE_AVAHI
105 # include <avahi-client/client.h>
106 # include <avahi-client/lookup.h>
107 # include <avahi-common/simple-watch.h>
108 # include <avahi-common/domain.h>
109 # include <avahi-common/error.h>
110 # include <avahi-common/malloc.h>
111 #define kDNSServiceMaxDomainName AVAHI_DOMAIN_NAME_MAX
112 #endif /* HAVE_AVAHI */
113
114
115 /*
116 * Constants...
117 */
118
119 #ifdef __APPLE__
120 # include <SystemConfiguration/SystemConfiguration.h>
121 # define kCUPSPrintingPrefs CFSTR("org.cups.PrintingPrefs")
122 # define kDefaultPaperIDKey CFSTR("DefaultPaperID")
123 # define kLastUsedPrintersKey CFSTR("LastUsedPrinters")
124 # define kLocationNetworkKey CFSTR("Network")
125 # define kLocationPrinterIDKey CFSTR("PrinterID")
126 # define kUseLastPrinter CFSTR("UseLastPrinter")
127 #endif /* __APPLE__ */
128
129
130 /*
131 * Types...
132 */
133
134 #if defined(HAVE_DNSSD) || defined(HAVE_AVAHI)
135 typedef enum _cups_dnssd_state_e /* Enumerated device state */
136 {
137 _CUPS_DNSSD_NEW,
138 _CUPS_DNSSD_QUERY,
139 _CUPS_DNSSD_PENDING,
140 _CUPS_DNSSD_ACTIVE,
141 _CUPS_DNSSD_LOCAL,
142 _CUPS_DNSSD_INCOMPATIBLE,
143 _CUPS_DNSSD_ERROR
144 } _cups_dnssd_state_t;
145
146 typedef struct _cups_dnssd_data_s /* Enumeration data */
147 {
148 # ifdef HAVE_DNSSD
149 DNSServiceRef main_ref; /* Main service reference */
150 # else /* HAVE_AVAHI */
151 AvahiSimplePoll *simple_poll; /* Polling interface */
152 AvahiClient *client; /* Client information */
153 int got_data; /* Did we get data? */
154 # endif /* HAVE_DNSSD */
155 cups_dest_cb_t cb; /* Callback */
156 void *user_data; /* User data pointer */
157 cups_ptype_t type, /* Printer type filter */
158 mask; /* Printer type mask */
159 cups_array_t *devices; /* Devices found so far */
160 } _cups_dnssd_data_t;
161
162 typedef struct _cups_dnssd_device_s /* Enumerated device */
163 {
164 _cups_dnssd_state_t state; /* State of device listing */
165 # ifdef HAVE_DNSSD
166 DNSServiceRef ref; /* Service reference for query */
167 # else /* HAVE_AVAHI */
168 AvahiRecordBrowser *ref; /* Browser for query */
169 # endif /* HAVE_DNSSD */
170 char *domain, /* Domain name */
171 *fullName, /* Full name */
172 *regtype; /* Registration type */
173 cups_ptype_t type; /* Device registration type */
174 cups_dest_t dest; /* Destination record */
175 } _cups_dnssd_device_t;
176
177 typedef struct _cups_dnssd_resolve_s /* Data for resolving URI */
178 {
179 int *cancel; /* Pointer to "cancel" variable */
180 struct timeval end_time; /* Ending time */
181 } _cups_dnssd_resolve_t;
182 #endif /* HAVE_DNSSD */
183
184
185 /*
186 * Local functions...
187 */
188
189 #ifdef __APPLE__
190 static CFArrayRef appleCopyLocations(void);
191 static CFStringRef appleCopyNetwork(void);
192 static char *appleGetPaperSize(char *name, int namesize);
193 static CFStringRef appleGetPrinter(CFArrayRef locations,
194 CFStringRef network, CFIndex *locindex);
195 #endif /* __APPLE__ */
196 static cups_dest_t *cups_add_dest(const char *name, const char *instance,
197 int *num_dests, cups_dest_t **dests);
198 #ifdef __BLOCKS__
199 static int cups_block_cb(cups_dest_block_t block, unsigned flags,
200 cups_dest_t *dest);
201 #endif /* __BLOCKS__ */
202 static int cups_compare_dests(cups_dest_t *a, cups_dest_t *b);
203 #if defined(HAVE_DNSSD) || defined(HAVE_AVAHI)
204 # ifdef HAVE_DNSSD
205 static void cups_dnssd_browse_cb(DNSServiceRef sdRef,
206 DNSServiceFlags flags,
207 uint32_t interfaceIndex,
208 DNSServiceErrorType errorCode,
209 const char *serviceName,
210 const char *regtype,
211 const char *replyDomain,
212 void *context);
213 # else /* HAVE_AVAHI */
214 static void cups_dnssd_browse_cb(AvahiServiceBrowser *browser,
215 AvahiIfIndex interface,
216 AvahiProtocol protocol,
217 AvahiBrowserEvent event,
218 const char *serviceName,
219 const char *regtype,
220 const char *replyDomain,
221 AvahiLookupResultFlags flags,
222 void *context);
223 static void cups_dnssd_client_cb(AvahiClient *client,
224 AvahiClientState state,
225 void *context);
226 # endif /* HAVE_DNSSD */
227 static int cups_dnssd_compare_devices(_cups_dnssd_device_t *a,
228 _cups_dnssd_device_t *b);
229 static void cups_dnssd_free_device(_cups_dnssd_device_t *device,
230 _cups_dnssd_data_t *data);
231 static _cups_dnssd_device_t *
232 cups_dnssd_get_device(_cups_dnssd_data_t *data,
233 const char *serviceName,
234 const char *regtype,
235 const char *replyDomain);
236 # ifdef HAVE_DNSSD
237 static void cups_dnssd_local_cb(DNSServiceRef sdRef,
238 DNSServiceFlags flags,
239 uint32_t interfaceIndex,
240 DNSServiceErrorType errorCode,
241 const char *serviceName,
242 const char *regtype,
243 const char *replyDomain,
244 void *context);
245 static void cups_dnssd_query_cb(DNSServiceRef sdRef,
246 DNSServiceFlags flags,
247 uint32_t interfaceIndex,
248 DNSServiceErrorType errorCode,
249 const char *fullName,
250 uint16_t rrtype, uint16_t rrclass,
251 uint16_t rdlen, const void *rdata,
252 uint32_t ttl, void *context);
253 # else /* HAVE_AVAHI */
254 static int cups_dnssd_poll_cb(struct pollfd *pollfds,
255 unsigned int num_pollfds,
256 int timeout, void *context);
257 static void cups_dnssd_query_cb(AvahiRecordBrowser *browser,
258 AvahiIfIndex interface,
259 AvahiProtocol protocol,
260 AvahiBrowserEvent event,
261 const char *name, uint16_t rrclass,
262 uint16_t rrtype, const void *rdata,
263 size_t rdlen,
264 AvahiLookupResultFlags flags,
265 void *context);
266 # endif /* HAVE_DNSSD */
267 static const char *cups_dnssd_resolve(cups_dest_t *dest, const char *uri,
268 int msec, int *cancel,
269 cups_dest_cb_t cb, void *user_data);
270 static int cups_dnssd_resolve_cb(void *context);
271 static void cups_dnssd_unquote(char *dst, const char *src,
272 size_t dstsize);
273 #endif /* HAVE_DNSSD || HAVE_AVAHI */
274 static int cups_find_dest(const char *name, const char *instance,
275 int num_dests, cups_dest_t *dests, int prev,
276 int *rdiff);
277 static char *cups_get_default(const char *filename, char *namebuf,
278 size_t namesize, const char **instance);
279 static int cups_get_dests(const char *filename, const char *match_name,
280 const char *match_inst, int user_default_set,
281 int num_dests, cups_dest_t **dests);
282 static char *cups_make_string(ipp_attribute_t *attr, char *buffer,
283 size_t bufsize);
284
285
286 /*
287 * 'cupsAddDest()' - Add a destination to the list of destinations.
288 *
289 * This function cannot be used to add a new class or printer queue,
290 * it only adds a new container of saved options for the named
291 * destination or instance.
292 *
293 * If the named destination already exists, the destination list is
294 * returned unchanged. Adding a new instance of a destination creates
295 * a copy of that destination's options.
296 *
297 * Use the @link cupsSaveDests@ function to save the updated list of
298 * destinations to the user's lpoptions file.
299 */
300
301 int /* O - New number of destinations */
302 cupsAddDest(const char *name, /* I - Destination name */
303 const char *instance, /* I - Instance name or @code NULL@ for none/primary */
304 int num_dests, /* I - Number of destinations */
305 cups_dest_t **dests) /* IO - Destinations */
306 {
307 int i; /* Looping var */
308 cups_dest_t *dest; /* Destination pointer */
309 cups_dest_t *parent = NULL; /* Parent destination */
310 cups_option_t *doption, /* Current destination option */
311 *poption; /* Current parent option */
312
313
314 if (!name || !dests)
315 return (0);
316
317 if (!cupsGetDest(name, instance, num_dests, *dests))
318 {
319 if (instance && !cupsGetDest(name, NULL, num_dests, *dests))
320 return (num_dests);
321
322 dest = cups_add_dest(name, instance, &num_dests, dests);
323
324 /*
325 * Find the base dest again now the array has been realloc'd.
326 */
327
328 parent = cupsGetDest(name, NULL, num_dests, *dests);
329
330 if (instance && parent && parent->num_options > 0)
331 {
332 /*
333 * Copy options from parent...
334 */
335
336 dest->options = calloc(sizeof(cups_option_t), parent->num_options);
337
338 if (dest->options)
339 {
340 dest->num_options = parent->num_options;
341
342 for (i = dest->num_options, doption = dest->options,
343 poption = parent->options;
344 i > 0;
345 i --, doption ++, poption ++)
346 {
347 doption->name = _cupsStrRetain(poption->name);
348 doption->value = _cupsStrRetain(poption->value);
349 }
350 }
351 }
352 }
353
354 return (num_dests);
355 }
356
357
358 #ifdef __APPLE__
359 /*
360 * '_cupsAppleCopyDefaultPaperID()' - Get the default paper ID.
361 */
362
363 CFStringRef /* O - Default paper ID */
364 _cupsAppleCopyDefaultPaperID(void)
365 {
366 return (CFPreferencesCopyAppValue(kDefaultPaperIDKey,
367 kCUPSPrintingPrefs));
368 }
369
370
371 /*
372 * '_cupsAppleCopyDefaultPrinter()' - Get the default printer at this location.
373 */
374
375 CFStringRef /* O - Default printer name */
376 _cupsAppleCopyDefaultPrinter(void)
377 {
378 CFStringRef network; /* Network location */
379 CFArrayRef locations; /* Location array */
380 CFStringRef locprinter; /* Current printer */
381
382
383 /*
384 * Use location-based defaults only if "use last printer" is selected in the
385 * system preferences...
386 */
387
388 if (!_cupsAppleGetUseLastPrinter())
389 {
390 DEBUG_puts("1_cupsAppleCopyDefaultPrinter: Not using last printer as "
391 "default.");
392 return (NULL);
393 }
394
395 /*
396 * Get the current location...
397 */
398
399 if ((network = appleCopyNetwork()) == NULL)
400 {
401 DEBUG_puts("1_cupsAppleCopyDefaultPrinter: Unable to get current "
402 "network.");
403 return (NULL);
404 }
405
406 /*
407 * Lookup the network in the preferences...
408 */
409
410 if ((locations = appleCopyLocations()) == NULL)
411 {
412 /*
413 * Missing or bad location array, so no location-based default...
414 */
415
416 DEBUG_puts("1_cupsAppleCopyDefaultPrinter: Missing or bad last used "
417 "printer array.");
418
419 CFRelease(network);
420
421 return (NULL);
422 }
423
424 DEBUG_printf(("1_cupsAppleCopyDefaultPrinter: Got locations, %d entries.",
425 (int)CFArrayGetCount(locations)));
426
427 if ((locprinter = appleGetPrinter(locations, network, NULL)) != NULL)
428 CFRetain(locprinter);
429
430 CFRelease(network);
431 CFRelease(locations);
432
433 return (locprinter);
434 }
435
436
437 /*
438 * '_cupsAppleGetUseLastPrinter()' - Get whether to use the last used printer.
439 */
440
441 int /* O - 1 to use last printer, 0 otherwise */
442 _cupsAppleGetUseLastPrinter(void)
443 {
444 Boolean uselast, /* Use last printer preference value */
445 uselast_set; /* Valid is set? */
446
447
448 if (getenv("CUPS_DISABLE_APPLE_DEFAULT"))
449 return (0);
450
451 uselast = CFPreferencesGetAppBooleanValue(kUseLastPrinter,
452 kCUPSPrintingPrefs,
453 &uselast_set);
454 if (!uselast_set)
455 return (1);
456 else
457 return (uselast);
458 }
459
460
461 /*
462 * '_cupsAppleSetDefaultPaperID()' - Set the default paper id.
463 */
464
465 void
466 _cupsAppleSetDefaultPaperID(
467 CFStringRef name) /* I - New paper ID */
468 {
469 CFPreferencesSetAppValue(kDefaultPaperIDKey, name, kCUPSPrintingPrefs);
470 CFPreferencesAppSynchronize(kCUPSPrintingPrefs);
471 notify_post("com.apple.printerPrefsChange");
472 }
473
474
475 /*
476 * '_cupsAppleSetDefaultPrinter()' - Set the default printer for this location.
477 */
478
479 void
480 _cupsAppleSetDefaultPrinter(
481 CFStringRef name) /* I - Default printer/class name */
482 {
483 CFStringRef network; /* Current network */
484 CFArrayRef locations; /* Old locations array */
485 CFIndex locindex; /* Index in locations array */
486 CFStringRef locprinter; /* Current printer */
487 CFMutableArrayRef newlocations; /* New locations array */
488 CFMutableDictionaryRef newlocation; /* New location */
489
490
491 /*
492 * Get the current location...
493 */
494
495 if ((network = appleCopyNetwork()) == NULL)
496 {
497 DEBUG_puts("1_cupsAppleSetDefaultPrinter: Unable to get current network...");
498 return;
499 }
500
501 /*
502 * Lookup the network in the preferences...
503 */
504
505 if ((locations = appleCopyLocations()) != NULL)
506 locprinter = appleGetPrinter(locations, network, &locindex);
507 else
508 {
509 locprinter = NULL;
510 locindex = -1;
511 }
512
513 if (!locprinter || CFStringCompare(locprinter, name, 0) != kCFCompareEqualTo)
514 {
515 /*
516 * Need to change the locations array...
517 */
518
519 if (locations)
520 {
521 newlocations = CFArrayCreateMutableCopy(kCFAllocatorDefault, 0,
522 locations);
523
524 if (locprinter)
525 CFArrayRemoveValueAtIndex(newlocations, locindex);
526 }
527 else
528 newlocations = CFArrayCreateMutable(kCFAllocatorDefault, 0,
529 &kCFTypeArrayCallBacks);
530
531 newlocation = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
532 &kCFTypeDictionaryKeyCallBacks,
533 &kCFTypeDictionaryValueCallBacks);
534
535 if (newlocation && newlocations)
536 {
537 /*
538 * Put the new location at the front of the array...
539 */
540
541 CFDictionaryAddValue(newlocation, kLocationNetworkKey, network);
542 CFDictionaryAddValue(newlocation, kLocationPrinterIDKey, name);
543 CFArrayInsertValueAtIndex(newlocations, 0, newlocation);
544
545 /*
546 * Limit the number of locations to 10...
547 */
548
549 while (CFArrayGetCount(newlocations) > 10)
550 CFArrayRemoveValueAtIndex(newlocations, 10);
551
552 /*
553 * Push the changes out...
554 */
555
556 CFPreferencesSetAppValue(kLastUsedPrintersKey, newlocations,
557 kCUPSPrintingPrefs);
558 CFPreferencesAppSynchronize(kCUPSPrintingPrefs);
559 notify_post("com.apple.printerPrefsChange");
560 }
561
562 if (newlocations)
563 CFRelease(newlocations);
564
565 if (newlocation)
566 CFRelease(newlocation);
567 }
568
569 if (locations)
570 CFRelease(locations);
571
572 CFRelease(network);
573 }
574
575
576 /*
577 * '_cupsAppleSetUseLastPrinter()' - Set whether to use the last used printer.
578 */
579
580 void
581 _cupsAppleSetUseLastPrinter(
582 int uselast) /* O - 1 to use last printer, 0 otherwise */
583 {
584 CFPreferencesSetAppValue(kUseLastPrinter,
585 uselast ? kCFBooleanTrue : kCFBooleanFalse,
586 kCUPSPrintingPrefs);
587 CFPreferencesAppSynchronize(kCUPSPrintingPrefs);
588 notify_post("com.apple.printerPrefsChange");
589 }
590 #endif /* __APPLE__ */
591
592
593 /*
594 * 'cupsConnectDest()' - Connect to the server for a destination.
595 *
596 * Connect to the destination, returning a new http_t connection object and
597 * optionally the resource path to use for the destination. These calls will
598 * block until a connection is made, the timeout expires, the integer pointed
599 * to by "cancel" is non-zero, or the callback function (or block) returns 0,
600 * The caller is responsible for calling httpClose() on the returned object.
601 *
602 * @since CUPS 1.6/OS X 10.8@
603 */
604
605 http_t * /* O - Connection to server or @code NULL@ */
606 cupsConnectDest(
607 cups_dest_t *dest, /* I - Destination */
608 unsigned flags, /* I - Connection flags */
609 int msec, /* I - Timeout in milliseconds */
610 int *cancel, /* I - Pointer to "cancel" variable */
611 char *resource, /* I - Resource buffer */
612 size_t resourcesize, /* I - Size of resource buffer */
613 cups_dest_cb_t cb, /* I - Callback function */
614 void *user_data) /* I - User data pointer */
615 {
616 const char *uri; /* Printer URI */
617 char scheme[32], /* URI scheme */
618 userpass[256], /* Username and password (unused) */
619 hostname[256], /* Hostname */
620 tempresource[1024]; /* Temporary resource buffer */
621 int port; /* Port number */
622 char portstr[16]; /* Port number string */
623 http_encryption_t encryption; /* Encryption to use */
624 http_addrlist_t *addrlist; /* Address list for server */
625 http_t *http; /* Connection to server */
626
627
628 /*
629 * Range check input...
630 */
631
632 if (!dest)
633 {
634 if (resource)
635 *resource = '\0';
636
637 _cupsSetError(IPP_INTERNAL_ERROR, strerror(EINVAL), 0);
638 return (NULL);
639 }
640
641 if (!resource || resourcesize < 1)
642 {
643 resource = tempresource;
644 resourcesize = sizeof(tempresource);
645 }
646
647 /*
648 * Grab the printer URI...
649 */
650
651 if ((uri = cupsGetOption("printer-uri-supported", dest->num_options,
652 dest->options)) == NULL)
653 {
654 _cupsSetError(IPP_INTERNAL_ERROR, strerror(ENOENT), 0);
655
656 if (cb)
657 (*cb)(user_data, CUPS_DEST_FLAGS_UNCONNECTED | CUPS_DEST_FLAGS_ERROR,
658 dest);
659
660 return (NULL);
661 }
662
663 #if defined(HAVE_DNSSD) || defined(HAVE_AVAHI)
664 if (strstr(uri, "._tcp"))
665 {
666 if ((uri = cups_dnssd_resolve(dest, uri, msec, cancel, cb,
667 user_data)) == NULL)
668 return (NULL);
669 }
670 #endif /* HAVE_DNSSD || HAVE_AVAHI */
671
672 if (httpSeparateURI(HTTP_URI_CODING_ALL, uri, scheme, sizeof(scheme),
673 userpass, sizeof(userpass), hostname, sizeof(hostname),
674 &port, resource, resourcesize) < HTTP_URI_OK)
675 {
676 _cupsSetError(IPP_INTERNAL_ERROR, _("Bad printer URI."), 1);
677
678 if (cb)
679 (*cb)(user_data, CUPS_DEST_FLAGS_UNCONNECTED | CUPS_DEST_FLAGS_ERROR,
680 dest);
681
682 return (NULL);
683 }
684
685 /*
686 * Lookup the address for the server...
687 */
688
689 if (cb)
690 (*cb)(user_data, CUPS_DEST_FLAGS_UNCONNECTED | CUPS_DEST_FLAGS_RESOLVING,
691 dest);
692
693 snprintf(portstr, sizeof(portstr), "%d", port);
694
695 if ((addrlist = httpAddrGetList(hostname, AF_UNSPEC, portstr)) == NULL)
696 {
697 if (cb)
698 (*cb)(user_data, CUPS_DEST_FLAGS_UNCONNECTED | CUPS_DEST_FLAGS_ERROR,
699 dest);
700
701 return (NULL);
702 }
703
704 if (cancel && *cancel)
705 {
706 httpAddrFreeList(addrlist);
707
708 if (cb)
709 (*cb)(user_data, CUPS_DEST_FLAGS_UNCONNECTED | CUPS_DEST_FLAGS_CANCELED,
710 dest);
711
712 return (NULL);
713 }
714
715 /*
716 * Create the HTTP object pointing to the server referenced by the URI...
717 */
718
719 if (!strcmp(scheme, "ipps") || port == 443)
720 encryption = HTTP_ENCRYPT_ALWAYS;
721 else
722 encryption = HTTP_ENCRYPT_IF_REQUESTED;
723
724 http = _httpCreate(hostname, port, addrlist, encryption, AF_UNSPEC);
725
726 /*
727 * Connect if requested...
728 */
729
730 if (flags & CUPS_DEST_FLAGS_UNCONNECTED)
731 {
732 if (cb)
733 (*cb)(user_data, CUPS_DEST_FLAGS_UNCONNECTED, dest);
734 }
735 else
736 {
737 if (cb)
738 (*cb)(user_data, CUPS_DEST_FLAGS_UNCONNECTED | CUPS_DEST_FLAGS_CONNECTING,
739 dest);
740
741 if (!httpReconnect2(http, msec, cancel) && cb)
742 {
743 if (cancel && *cancel)
744 (*cb)(user_data,
745 CUPS_DEST_FLAGS_UNCONNECTED | CUPS_DEST_FLAGS_CONNECTING, dest);
746 else
747 (*cb)(user_data, CUPS_DEST_FLAGS_UNCONNECTED | CUPS_DEST_FLAGS_ERROR,
748 dest);
749 }
750 else if (cb)
751 (*cb)(user_data, CUPS_DEST_FLAGS_NONE, dest);
752 }
753
754 return (http);
755 }
756
757
758 #ifdef __BLOCKS__
759 /*
760 * 'cupsConnectDestBlock()' - Connect to the server for a destination.
761 *
762 * Connect to the destination, returning a new http_t connection object and
763 * optionally the resource path to use for the destination. These calls will
764 * block until a connection is made, the timeout expires, the integer pointed
765 * to by "cancel" is non-zero, or the callback function (or block) returns 0,
766 * The caller is responsible for calling httpClose() on the returned object.
767 *
768 * @since CUPS 1.6/OS X 10.8@
769 */
770
771 http_t * /* O - Connection to server or @code NULL@ */
772 cupsConnectDestBlock(
773 cups_dest_t *dest, /* I - Destination */
774 unsigned flags, /* I - Connection flags */
775 int msec, /* I - Timeout in milliseconds */
776 int *cancel, /* I - Pointer to "cancel" variable */
777 char *resource, /* I - Resource buffer */
778 size_t resourcesize, /* I - Size of resource buffer */
779 cups_dest_block_t block) /* I - Callback block */
780 {
781 return (cupsConnectDest(dest, flags, msec, cancel, resource, resourcesize,
782 (cups_dest_cb_t)cups_block_cb, (void *)block));
783 }
784 #endif /* __BLOCKS__ */
785
786
787 /*
788 * 'cupsCopyDest()' - Copy a destination.
789 *
790 * Make a copy of the destination to an array of destinations (or just a single
791 * copy) - for use with the cupsEnumDests* functions. The caller is responsible
792 * for calling cupsFreeDests() on the returned object(s).
793 *
794 * @since CUPS 1.6/OS X 10.8@
795 */
796
797 int
798 cupsCopyDest(cups_dest_t *dest,
799 int num_dests,
800 cups_dest_t **dests)
801 {
802 int i; /* Looping var */
803 cups_dest_t *new_dest; /* New destination pointer */
804 cups_option_t *new_option, /* Current destination option */
805 *option; /* Current parent option */
806
807
808 /*
809 * Range check input...
810 */
811
812 if (!dest || num_dests < 0 || !dests)
813 return (num_dests);
814
815 /*
816 * See if the destination already exists...
817 */
818
819 if ((new_dest = cupsGetDest(dest->name, dest->instance, num_dests,
820 *dests)) != NULL)
821 {
822 /*
823 * Protect against copying destination to itself...
824 */
825
826 if (new_dest == dest)
827 return (num_dests);
828
829 /*
830 * Otherwise, free the options...
831 */
832
833 cupsFreeOptions(new_dest->num_options, new_dest->options);
834
835 new_dest->num_options = 0;
836 new_dest->options = NULL;
837 }
838 else
839 new_dest = cups_add_dest(dest->name, dest->instance, &num_dests, dests);
840
841 if (new_dest)
842 {
843 if ((new_dest->options = calloc(sizeof(cups_option_t),
844 dest->num_options)) == NULL)
845 return (cupsRemoveDest(dest->name, dest->instance, num_dests, dests));
846
847 new_dest->num_options = dest->num_options;
848
849 for (i = dest->num_options, option = dest->options,
850 new_option = new_dest->options;
851 i > 0;
852 i --, option ++, new_option ++)
853 {
854 new_option->name = _cupsStrRetain(option->name);
855 new_option->value = _cupsStrRetain(option->value);
856 }
857 }
858
859 return (num_dests);
860 }
861
862
863 /*
864 * 'cupsEnumDests()' - Enumerate available destinations with a callback function.
865 *
866 * Destinations are enumerated from one or more sources. The callback function
867 * receives the @code user_data@ pointer, destination name, instance, number of
868 * options, and options which can be used as input to the @link cupsAddDest@
869 * function. The function must return 1 to continue enumeration or 0 to stop.
870 *
871 * Enumeration happens on the current thread and does not return until all
872 * destinations have been enumerated or the callback function returns 0.
873 *
874 * @since CUPS 1.6/OS X 10.8@
875 */
876
877 int /* O - 1 on success, 0 on failure */
878 cupsEnumDests(
879 unsigned flags, /* I - Enumeration flags */
880 int msec, /* I - Timeout in milliseconds,
881 * -1 for indefinite */
882 int *cancel, /* I - Pointer to "cancel" variable */
883 cups_ptype_t type, /* I - Printer type bits */
884 cups_ptype_t mask, /* I - Mask for printer type bits */
885 cups_dest_cb_t cb, /* I - Callback function */
886 void *user_data) /* I - User data */
887 {
888 int i, /* Looping var */
889 num_dests; /* Number of destinations */
890 cups_dest_t *dests = NULL, /* Destinations */
891 *dest; /* Current destination */
892 #if defined(HAVE_DNSSD) || defined(HAVE_AVAHI)
893 int count, /* Number of queries started */
894 remaining; /* Remainder of timeout */
895 _cups_dnssd_data_t data; /* Data for callback */
896 _cups_dnssd_device_t *device; /* Current device */
897 # ifdef HAVE_DNSSD
898 int nfds, /* Number of files responded */
899 main_fd; /* File descriptor for lookups */
900 DNSServiceRef ipp_ref, /* IPP browser */
901 local_ipp_ref; /* Local IPP browser */
902 # ifdef HAVE_SSL
903 DNSServiceRef ipps_ref, /* IPPS browser */
904 local_ipps_ref; /* Local IPPS browser */
905 # endif /* HAVE_SSL */
906 # ifdef HAVE_POLL
907 struct pollfd pfd; /* Polling data */
908 # else
909 fd_set input; /* Input set for select() */
910 struct timeval timeout; /* Timeout for select() */
911 # endif /* HAVE_POLL */
912 # else /* HAVE_AVAHI */
913 int error; /* Error value */
914 AvahiServiceBrowser *ipp_ref; /* IPP browser */
915 # ifdef HAVE_SSL
916 AvahiServiceBrowser *ipps_ref; /* IPPS browser */
917 # endif /* HAVE_SSL */
918 # endif /* HAVE_DNSSD */
919 #endif /* HAVE_DNSSD || HAVE_AVAHI */
920
921 /*
922 * Range check input...
923 */
924
925 (void)flags;
926
927 if (!cb)
928 return (0);
929
930 /*
931 * Get the list of local printers and pass them to the callback function...
932 */
933
934 num_dests = _cupsGetDests(CUPS_HTTP_DEFAULT, CUPS_GET_PRINTERS, NULL, &dests,
935 type, mask);
936
937 for (i = num_dests, dest = dests;
938 i > 0 && (!cancel || !*cancel);
939 i --, dest ++)
940 if (!(*cb)(user_data, i > 1 ? CUPS_DEST_FLAGS_MORE : CUPS_DEST_FLAGS_NONE,
941 dest))
942 break;
943
944 cupsFreeDests(num_dests, dests);
945
946 if (i > 0 || msec == 0)
947 return (1);
948
949 #if defined(HAVE_DNSSD) || defined(HAVE_AVAHI)
950 /*
951 * Get Bonjour-shared printers...
952 */
953
954 data.type = type;
955 data.mask = mask;
956 data.devices = cupsArrayNew3((cups_array_func_t)cups_dnssd_compare_devices,
957 NULL, NULL, 0, NULL,
958 (cups_afree_func_t)cups_dnssd_free_device);
959
960 # ifdef HAVE_DNSSD
961 if (DNSServiceCreateConnection(&data.main_ref) != kDNSServiceErr_NoError)
962 return (0);
963
964 main_fd = DNSServiceRefSockFD(data.main_ref);
965
966 ipp_ref = data.main_ref;
967 DNSServiceBrowse(&ipp_ref, kDNSServiceFlagsShareConnection, 0,
968 "_ipp._tcp", NULL,
969 (DNSServiceBrowseReply)cups_dnssd_browse_cb, &data);
970
971 local_ipp_ref = data.main_ref;
972 DNSServiceBrowse(&local_ipp_ref, kDNSServiceFlagsShareConnection,
973 kDNSServiceInterfaceIndexLocalOnly,
974 "_ipp._tcp", NULL,
975 (DNSServiceBrowseReply)cups_dnssd_local_cb, &data);
976
977 # ifdef HAVE_SSL
978 ipps_ref = data.main_ref;
979 DNSServiceBrowse(&ipps_ref, kDNSServiceFlagsShareConnection, 0,
980 "_ipps._tcp", NULL,
981 (DNSServiceBrowseReply)cups_dnssd_browse_cb, &data);
982
983 local_ipps_ref = data.main_ref;
984 DNSServiceBrowse(&local_ipps_ref, kDNSServiceFlagsShareConnection,
985 kDNSServiceInterfaceIndexLocalOnly,
986 "_ipps._tcp", NULL,
987 (DNSServiceBrowseReply)cups_dnssd_local_cb, &data);
988 # endif /* HAVE_SSL */
989
990 # else /* HAVE_AVAHI */
991 if ((data.simple_poll = avahi_simple_poll_new()) == NULL)
992 {
993 DEBUG_puts("cupsEnumDests: Unable to create Avahi simple poll object.");
994 return (1);
995 }
996
997 avahi_simple_poll_set_func(data.simple_poll, cups_dnssd_poll_cb, &data);
998
999 data.client = avahi_client_new(avahi_simple_poll_get(data.simple_poll),
1000 0, cups_dnssd_client_cb, &data,
1001 &error);
1002 if (!data.client)
1003 {
1004 DEBUG_puts("cupsEnumDests: Unable to create Avahi client.");
1005 avahi_simple_poll_free(data.simple_poll);
1006 return (1);
1007 }
1008
1009 ipp_ref = avahi_service_browser_new(data.client, AVAHI_IF_UNSPEC,
1010 AVAHI_PROTO_UNSPEC, "_ipp._tcp", NULL,
1011 0, cups_dnssd_browse_cb, &data);
1012 # ifdef HAVE_SSL
1013 ipps_ref = avahi_service_browser_new(data.client, AVAHI_IF_UNSPEC,
1014 AVAHI_PROTO_UNSPEC, "_ipps._tcp", NULL,
1015 0, cups_dnssd_browse_cb, &data);
1016 # endif /* HAVE_SSL */
1017 # endif /* HAVE_DNSSD */
1018
1019 if (msec < 0)
1020 remaining = INT_MAX;
1021 else
1022 remaining = msec;
1023
1024 while (remaining > 0 && (!cancel || !*cancel))
1025 {
1026 /*
1027 * Check for input...
1028 */
1029
1030 # ifdef HAVE_DNSSD
1031 # ifdef HAVE_POLL
1032 pfd.fd = main_fd;
1033 pfd.events = POLLIN;
1034
1035 nfds = poll(&pfd, 1, remaining > 250 ? 250 : remaining);
1036
1037 # else
1038 FD_ZERO(&input);
1039 FD_SET(main_fd, &input);
1040
1041 timeout.tv_sec = 0;
1042 timeout.tv_usec = remaining > 250 ? 250000 : remaining * 1000;
1043
1044 nfds = select(main_fd + 1, &input, NULL, NULL, &timeout);
1045 # endif /* HAVE_POLL */
1046
1047 if (nfds > 0)
1048 DNSServiceProcessResult(data.main_ref);
1049 else if (nfds == 0)
1050 remaining -= 250;
1051
1052 # else /* HAVE_AVAHI */
1053 data.got_data = 0;
1054
1055 if ((error = avahi_simple_poll_iterate(data.simple_poll, 250)) > 0)
1056 {
1057 /*
1058 * We've been told to exit the loop. Perhaps the connection to
1059 * Avahi failed.
1060 */
1061
1062 break;
1063 }
1064
1065 if (!data.got_data)
1066 remaining -= 250;
1067 # endif /* HAVE_DNSSD */
1068
1069 for (device = (_cups_dnssd_device_t *)cupsArrayFirst(data.devices),
1070 count = 0;
1071 device;
1072 device = (_cups_dnssd_device_t *)cupsArrayNext(data.devices))
1073 {
1074 if (device->ref)
1075 count ++;
1076
1077 if (!device->ref && device->state == _CUPS_DNSSD_NEW)
1078 {
1079 DEBUG_printf(("1cupsEnumDests: Querying '%s'.", device->fullName));
1080
1081 # ifdef HAVE_DNSSD
1082 device->ref = data.main_ref;
1083
1084 if (DNSServiceQueryRecord(&(device->ref),
1085 kDNSServiceFlagsShareConnection,
1086 0, device->fullName,
1087 kDNSServiceType_TXT,
1088 kDNSServiceClass_IN,
1089 (DNSServiceQueryRecordReply)cups_dnssd_query_cb,
1090 &data) == kDNSServiceErr_NoError)
1091 {
1092 count ++;
1093 }
1094 else
1095 {
1096 device->ref = 0;
1097 device->state = _CUPS_DNSSD_ERROR;
1098
1099 DEBUG_puts("1cupsEnumDests: Query failed.");
1100 }
1101
1102 # else /* HAVE_AVAHI */
1103 if ((device->ref = avahi_record_browser_new(data.client,
1104 AVAHI_IF_UNSPEC,
1105 AVAHI_PROTO_UNSPEC,
1106 device->fullName,
1107 AVAHI_DNS_CLASS_IN,
1108 AVAHI_DNS_TYPE_TXT,
1109 0,
1110 cups_dnssd_query_cb,
1111 &data)) != NULL)
1112 {
1113 count ++;
1114 }
1115 else
1116 {
1117 device->state = _CUPS_DNSSD_ERROR;
1118
1119 DEBUG_printf(("1cupsEnumDests: Query failed: %s",
1120 avahi_strerror(avahi_client_errno(data.client))));
1121 }
1122 # endif /* HAVE_DNSSD */
1123 }
1124 else if (device->ref && device->state == _CUPS_DNSSD_PENDING)
1125 {
1126 if ((device->type & mask) == type)
1127 {
1128 if (!(*cb)(user_data, CUPS_DEST_FLAGS_NONE, &device->dest))
1129 {
1130 remaining = -1;
1131 break;
1132 }
1133 }
1134
1135 device->state = _CUPS_DNSSD_ACTIVE;
1136 }
1137 }
1138 }
1139
1140 cupsArrayDelete(data.devices);
1141
1142 # ifdef HAVE_DNSSD
1143 DNSServiceRefDeallocate(ipp_ref);
1144 DNSServiceRefDeallocate(local_ipp_ref);
1145
1146 # ifdef HAVE_SSL
1147 DNSServiceRefDeallocate(ipp_ref);
1148 DNSServiceRefDeallocate(local_ipp_ref);
1149 # endif /* HAVE_SSL */
1150
1151 DNSServiceRefDeallocate(data.main_ref);
1152
1153 # else /* HAVE_AVAHI */
1154 avahi_service_browser_free(ipp_ref);
1155 # ifdef HAVE_SSL
1156 avahi_service_browser_free(ipps_ref);
1157 # endif /* HAVE_SSL */
1158
1159 avahi_client_free(data.client);
1160 avahi_simple_poll_free(data.simple_poll);
1161 # endif /* HAVE_DNSSD */
1162 #endif /* HAVE_DNSSD || HAVE_DNSSD */
1163
1164 return (1);
1165 }
1166
1167
1168 # ifdef __BLOCKS__
1169 /*
1170 * 'cupsEnumDestsBlock()' - Enumerate available destinations with a block.
1171 *
1172 * Destinations are enumerated from one or more sources. The block receives the
1173 * destination name, instance, number of options, and options which can be used
1174 * as input to the @link cupsAddDest@ function. The block must return 1 to
1175 * continue enumeration or 0 to stop.
1176 *
1177 * Enumeration happens on the current thread and does not return until all
1178 * destinations have been enumerated or the block returns 0.
1179 *
1180 * @since CUPS 1.6/OS X 10.8@
1181 */
1182
1183 int /* O - 1 on success, 0 on failure */
1184 cupsEnumDestsBlock(
1185 unsigned flags, /* I - Enumeration flags */
1186 int timeout, /* I - Timeout in milliseconds, 0 for indefinite */
1187 int *cancel, /* I - Pointer to "cancel" variable */
1188 cups_ptype_t type, /* I - Printer type bits */
1189 cups_ptype_t mask, /* I - Mask for printer type bits */
1190 cups_dest_block_t block) /* I - Block */
1191 {
1192 return (cupsEnumDests(flags, timeout, cancel, type, mask,
1193 (cups_dest_cb_t)cups_block_cb, (void *)block));
1194 }
1195 # endif /* __BLOCKS__ */
1196
1197
1198 /*
1199 * 'cupsFreeDests()' - Free the memory used by the list of destinations.
1200 */
1201
1202 void
1203 cupsFreeDests(int num_dests, /* I - Number of destinations */
1204 cups_dest_t *dests) /* I - Destinations */
1205 {
1206 int i; /* Looping var */
1207 cups_dest_t *dest; /* Current destination */
1208
1209
1210 if (num_dests == 0 || dests == NULL)
1211 return;
1212
1213 for (i = num_dests, dest = dests; i > 0; i --, dest ++)
1214 {
1215 _cupsStrFree(dest->name);
1216 _cupsStrFree(dest->instance);
1217
1218 cupsFreeOptions(dest->num_options, dest->options);
1219 }
1220
1221 free(dests);
1222 }
1223
1224
1225 /*
1226 * 'cupsGetDest()' - Get the named destination from the list.
1227 *
1228 * Use the @link cupsGetDests@ or @link cupsGetDests2@ functions to get a
1229 * list of supported destinations for the current user.
1230 */
1231
1232 cups_dest_t * /* O - Destination pointer or @code NULL@ */
1233 cupsGetDest(const char *name, /* I - Destination name or @code NULL@ for the default destination */
1234 const char *instance, /* I - Instance name or @code NULL@ */
1235 int num_dests, /* I - Number of destinations */
1236 cups_dest_t *dests) /* I - Destinations */
1237 {
1238 int diff, /* Result of comparison */
1239 match; /* Matching index */
1240
1241
1242 if (num_dests <= 0 || !dests)
1243 return (NULL);
1244
1245 if (!name)
1246 {
1247 /*
1248 * NULL name for default printer.
1249 */
1250
1251 while (num_dests > 0)
1252 {
1253 if (dests->is_default)
1254 return (dests);
1255
1256 num_dests --;
1257 dests ++;
1258 }
1259 }
1260 else
1261 {
1262 /*
1263 * Lookup name and optionally the instance...
1264 */
1265
1266 match = cups_find_dest(name, instance, num_dests, dests, -1, &diff);
1267
1268 if (!diff)
1269 return (dests + match);
1270 }
1271
1272 return (NULL);
1273 }
1274
1275
1276 /*
1277 * '_cupsGetDestResource()' - Get the resource path and URI for a destination.
1278 */
1279
1280 const char * /* O - Printer URI */
1281 _cupsGetDestResource(
1282 cups_dest_t *dest, /* I - Destination */
1283 char *resource, /* I - Resource buffer */
1284 size_t resourcesize) /* I - Size of resource buffer */
1285 {
1286 const char *uri; /* Printer URI */
1287 char scheme[32], /* URI scheme */
1288 userpass[256], /* Username and password (unused) */
1289 hostname[256]; /* Hostname */
1290 int port; /* Port number */
1291
1292
1293 /*
1294 * Range check input...
1295 */
1296
1297 if (!dest || !resource || resourcesize < 1)
1298 {
1299 if (resource)
1300 *resource = '\0';
1301
1302 _cupsSetError(IPP_INTERNAL_ERROR, strerror(EINVAL), 0);
1303 return (NULL);
1304 }
1305
1306 /*
1307 * Grab the printer URI...
1308 */
1309
1310 if ((uri = cupsGetOption("printer-uri-supported", dest->num_options,
1311 dest->options)) == NULL)
1312 {
1313 if (resource)
1314 *resource = '\0';
1315
1316 _cupsSetError(IPP_INTERNAL_ERROR, strerror(ENOENT), 0);
1317
1318 return (NULL);
1319 }
1320
1321 #ifdef HAVE_DNSSD
1322 if (strstr(uri, "._tcp"))
1323 {
1324 if ((uri = cups_dnssd_resolve(dest, uri, 5000, NULL, NULL, NULL)) == NULL)
1325 return (NULL);
1326 }
1327 #endif /* HAVE_DNSSD */
1328
1329 if (httpSeparateURI(HTTP_URI_CODING_ALL, uri, scheme, sizeof(scheme),
1330 userpass, sizeof(userpass), hostname, sizeof(hostname),
1331 &port, resource, resourcesize) < HTTP_URI_OK)
1332 {
1333 _cupsSetError(IPP_INTERNAL_ERROR, _("Bad printer URI."), 1);
1334
1335 return (NULL);
1336 }
1337
1338 return (uri);
1339 }
1340
1341
1342 /*
1343 * '_cupsGetDests()' - Get destinations from a server.
1344 *
1345 * "op" is CUPS_GET_PRINTERS to get a full list, CUPS_GET_DEFAULT to get the
1346 * system-wide default printer, or IPP_GET_PRINTER_ATTRIBUTES for a known
1347 * printer.
1348 *
1349 * "name" is the name of an existing printer and is only used when "op" is
1350 * IPP_GET_PRINTER_ATTRIBUTES.
1351 *
1352 * "dest" is initialized to point to the array of destinations.
1353 *
1354 * 0 is returned if there are no printers, no default printer, or the named
1355 * printer does not exist, respectively.
1356 *
1357 * Free the memory used by the destination array using the @link cupsFreeDests@
1358 * function.
1359 *
1360 * Note: On OS X this function also gets the default paper from the system
1361 * preferences (~/L/P/org.cups.PrintingPrefs.plist) and includes it in the
1362 * options array for each destination that supports it.
1363 */
1364
1365 int /* O - Number of destinations */
1366 _cupsGetDests(http_t *http, /* I - Connection to server or
1367 * @code CUPS_HTTP_DEFAULT@ */
1368 ipp_op_t op, /* I - IPP operation */
1369 const char *name, /* I - Name of destination */
1370 cups_dest_t **dests, /* IO - Destinations */
1371 cups_ptype_t type, /* I - Printer type bits */
1372 cups_ptype_t mask) /* I - Printer type mask */
1373 {
1374 int num_dests = 0; /* Number of destinations */
1375 cups_dest_t *dest; /* Current destination */
1376 ipp_t *request, /* IPP Request */
1377 *response; /* IPP Response */
1378 ipp_attribute_t *attr; /* Current attribute */
1379 const char *printer_name; /* printer-name attribute */
1380 char uri[1024]; /* printer-uri value */
1381 int num_options; /* Number of options */
1382 cups_option_t *options; /* Options */
1383 #ifdef __APPLE__
1384 char media_default[41]; /* Default paper size */
1385 #endif /* __APPLE__ */
1386 char optname[1024], /* Option name */
1387 value[2048], /* Option value */
1388 *ptr; /* Pointer into name/value */
1389 static const char * const pattrs[] = /* Attributes we're interested in */
1390 {
1391 "auth-info-required",
1392 "device-uri",
1393 "job-sheets-default",
1394 "marker-change-time",
1395 "marker-colors",
1396 "marker-high-levels",
1397 "marker-levels",
1398 "marker-low-levels",
1399 "marker-message",
1400 "marker-names",
1401 "marker-types",
1402 #ifdef __APPLE__
1403 "media-supported",
1404 #endif /* __APPLE__ */
1405 "printer-commands",
1406 "printer-defaults",
1407 "printer-info",
1408 "printer-is-accepting-jobs",
1409 "printer-is-shared",
1410 "printer-location",
1411 "printer-make-and-model",
1412 "printer-name",
1413 "printer-state",
1414 "printer-state-change-time",
1415 "printer-state-reasons",
1416 "printer-type",
1417 "printer-uri-supported"
1418 };
1419
1420
1421 #ifdef __APPLE__
1422 /*
1423 * Get the default paper size...
1424 */
1425
1426 appleGetPaperSize(media_default, sizeof(media_default));
1427 #endif /* __APPLE__ */
1428
1429 /*
1430 * Build a CUPS_GET_PRINTERS or IPP_GET_PRINTER_ATTRIBUTES request, which
1431 * require the following attributes:
1432 *
1433 * attributes-charset
1434 * attributes-natural-language
1435 * requesting-user-name
1436 * printer-uri [for IPP_GET_PRINTER_ATTRIBUTES]
1437 */
1438
1439 request = ippNewRequest(op);
1440
1441 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
1442 "requested-attributes", sizeof(pattrs) / sizeof(pattrs[0]),
1443 NULL, pattrs);
1444
1445 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
1446 "requesting-user-name", NULL, cupsUser());
1447
1448 if (name && op != CUPS_GET_DEFAULT)
1449 {
1450 httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL,
1451 "localhost", ippPort(), "/printers/%s", name);
1452 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL,
1453 uri);
1454 }
1455 else if (mask)
1456 {
1457 ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_ENUM, "printer-type",
1458 type);
1459 ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_ENUM, "printer-type-mask",
1460 mask);
1461 }
1462
1463 /*
1464 * Do the request and get back a response...
1465 */
1466
1467 if ((response = cupsDoRequest(http, request, "/")) != NULL)
1468 {
1469 for (attr = response->attrs; attr != NULL; attr = attr->next)
1470 {
1471 /*
1472 * Skip leading attributes until we hit a printer...
1473 */
1474
1475 while (attr != NULL && attr->group_tag != IPP_TAG_PRINTER)
1476 attr = attr->next;
1477
1478 if (attr == NULL)
1479 break;
1480
1481 /*
1482 * Pull the needed attributes from this printer...
1483 */
1484
1485 printer_name = NULL;
1486 num_options = 0;
1487 options = NULL;
1488
1489 for (; attr && attr->group_tag == IPP_TAG_PRINTER; attr = attr->next)
1490 {
1491 if (attr->value_tag != IPP_TAG_INTEGER &&
1492 attr->value_tag != IPP_TAG_ENUM &&
1493 attr->value_tag != IPP_TAG_BOOLEAN &&
1494 attr->value_tag != IPP_TAG_TEXT &&
1495 attr->value_tag != IPP_TAG_TEXTLANG &&
1496 attr->value_tag != IPP_TAG_NAME &&
1497 attr->value_tag != IPP_TAG_NAMELANG &&
1498 attr->value_tag != IPP_TAG_KEYWORD &&
1499 attr->value_tag != IPP_TAG_RANGE &&
1500 attr->value_tag != IPP_TAG_URI)
1501 continue;
1502
1503 if (!strcmp(attr->name, "auth-info-required") ||
1504 !strcmp(attr->name, "device-uri") ||
1505 !strcmp(attr->name, "marker-change-time") ||
1506 !strcmp(attr->name, "marker-colors") ||
1507 !strcmp(attr->name, "marker-high-levels") ||
1508 !strcmp(attr->name, "marker-levels") ||
1509 !strcmp(attr->name, "marker-low-levels") ||
1510 !strcmp(attr->name, "marker-message") ||
1511 !strcmp(attr->name, "marker-names") ||
1512 !strcmp(attr->name, "marker-types") ||
1513 !strcmp(attr->name, "printer-commands") ||
1514 !strcmp(attr->name, "printer-info") ||
1515 !strcmp(attr->name, "printer-is-shared") ||
1516 !strcmp(attr->name, "printer-make-and-model") ||
1517 !strcmp(attr->name, "printer-state") ||
1518 !strcmp(attr->name, "printer-state-change-time") ||
1519 !strcmp(attr->name, "printer-type") ||
1520 !strcmp(attr->name, "printer-is-accepting-jobs") ||
1521 !strcmp(attr->name, "printer-location") ||
1522 !strcmp(attr->name, "printer-state-reasons") ||
1523 !strcmp(attr->name, "printer-uri-supported"))
1524 {
1525 /*
1526 * Add a printer description attribute...
1527 */
1528
1529 num_options = cupsAddOption(attr->name,
1530 cups_make_string(attr, value,
1531 sizeof(value)),
1532 num_options, &options);
1533 }
1534 #ifdef __APPLE__
1535 else if (!strcmp(attr->name, "media-supported"))
1536 {
1537 /*
1538 * See if we can set a default media size...
1539 */
1540
1541 int i; /* Looping var */
1542
1543 for (i = 0; i < attr->num_values; i ++)
1544 if (!_cups_strcasecmp(media_default, attr->values[i].string.text))
1545 {
1546 num_options = cupsAddOption("media", media_default, num_options,
1547 &options);
1548 break;
1549 }
1550 }
1551 #endif /* __APPLE__ */
1552 else if (!strcmp(attr->name, "printer-name") &&
1553 attr->value_tag == IPP_TAG_NAME)
1554 printer_name = attr->values[0].string.text;
1555 else if (strncmp(attr->name, "notify-", 7) &&
1556 (attr->value_tag == IPP_TAG_BOOLEAN ||
1557 attr->value_tag == IPP_TAG_ENUM ||
1558 attr->value_tag == IPP_TAG_INTEGER ||
1559 attr->value_tag == IPP_TAG_KEYWORD ||
1560 attr->value_tag == IPP_TAG_NAME ||
1561 attr->value_tag == IPP_TAG_RANGE) &&
1562 (ptr = strstr(attr->name, "-default")) != NULL)
1563 {
1564 /*
1565 * Add a default option...
1566 */
1567
1568 strlcpy(optname, attr->name, sizeof(optname));
1569 optname[ptr - attr->name] = '\0';
1570
1571 if (_cups_strcasecmp(optname, "media") ||
1572 !cupsGetOption("media", num_options, options))
1573 num_options = cupsAddOption(optname,
1574 cups_make_string(attr, value,
1575 sizeof(value)),
1576 num_options, &options);
1577 }
1578 }
1579
1580 /*
1581 * See if we have everything needed...
1582 */
1583
1584 if (!printer_name)
1585 {
1586 cupsFreeOptions(num_options, options);
1587
1588 if (attr == NULL)
1589 break;
1590 else
1591 continue;
1592 }
1593
1594 if ((dest = cups_add_dest(printer_name, NULL, &num_dests, dests)) != NULL)
1595 {
1596 dest->num_options = num_options;
1597 dest->options = options;
1598 }
1599 else
1600 cupsFreeOptions(num_options, options);
1601
1602 if (attr == NULL)
1603 break;
1604 }
1605
1606 ippDelete(response);
1607 }
1608
1609 /*
1610 * Return the count...
1611 */
1612
1613 return (num_dests);
1614 }
1615
1616
1617 /*
1618 * 'cupsGetDests()' - Get the list of destinations from the default server.
1619 *
1620 * Starting with CUPS 1.2, the returned list of destinations include the
1621 * printer-info, printer-is-accepting-jobs, printer-is-shared,
1622 * printer-make-and-model, printer-state, printer-state-change-time,
1623 * printer-state-reasons, and printer-type attributes as options. CUPS 1.4
1624 * adds the marker-change-time, marker-colors, marker-high-levels,
1625 * marker-levels, marker-low-levels, marker-message, marker-names,
1626 * marker-types, and printer-commands attributes as well.
1627 *
1628 * Use the @link cupsFreeDests@ function to free the destination list and
1629 * the @link cupsGetDest@ function to find a particular destination.
1630 */
1631
1632 int /* O - Number of destinations */
1633 cupsGetDests(cups_dest_t **dests) /* O - Destinations */
1634 {
1635 return (cupsGetDests2(CUPS_HTTP_DEFAULT, dests));
1636 }
1637
1638
1639 /*
1640 * 'cupsGetDests2()' - Get the list of destinations from the specified server.
1641 *
1642 * Starting with CUPS 1.2, the returned list of destinations include the
1643 * printer-info, printer-is-accepting-jobs, printer-is-shared,
1644 * printer-make-and-model, printer-state, printer-state-change-time,
1645 * printer-state-reasons, and printer-type attributes as options. CUPS 1.4
1646 * adds the marker-change-time, marker-colors, marker-high-levels,
1647 * marker-levels, marker-low-levels, marker-message, marker-names,
1648 * marker-types, and printer-commands attributes as well.
1649 *
1650 * Use the @link cupsFreeDests@ function to free the destination list and
1651 * the @link cupsGetDest@ function to find a particular destination.
1652 *
1653 * @since CUPS 1.1.21/OS X 10.4@
1654 */
1655
1656 int /* O - Number of destinations */
1657 cupsGetDests2(http_t *http, /* I - Connection to server or @code CUPS_HTTP_DEFAULT@ */
1658 cups_dest_t **dests) /* O - Destinations */
1659 {
1660 int i; /* Looping var */
1661 int num_dests; /* Number of destinations */
1662 cups_dest_t *dest; /* Destination pointer */
1663 const char *home; /* HOME environment variable */
1664 char filename[1024]; /* Local ~/.cups/lpoptions file */
1665 const char *defprinter; /* Default printer */
1666 char name[1024], /* Copy of printer name */
1667 *instance, /* Pointer to instance name */
1668 *user_default; /* User default printer */
1669 int num_reals; /* Number of real queues */
1670 cups_dest_t *reals; /* Real queues */
1671 _cups_globals_t *cg = _cupsGlobals(); /* Pointer to library globals */
1672
1673
1674 /*
1675 * Range check the input...
1676 */
1677
1678 if (!dests)
1679 {
1680 _cupsSetError(IPP_INTERNAL_ERROR, _("Bad NULL dests pointer"), 1);
1681 return (0);
1682 }
1683
1684 /*
1685 * Grab the printers and classes...
1686 */
1687
1688 *dests = (cups_dest_t *)0;
1689 num_dests = _cupsGetDests(http, CUPS_GET_PRINTERS, NULL, dests, 0, 0);
1690
1691 if (cupsLastError() >= IPP_REDIRECTION_OTHER_SITE)
1692 {
1693 cupsFreeDests(num_dests, *dests);
1694 *dests = (cups_dest_t *)0;
1695 return (0);
1696 }
1697
1698 /*
1699 * Make a copy of the "real" queues for a later sanity check...
1700 */
1701
1702 if (num_dests > 0)
1703 {
1704 num_reals = num_dests;
1705 reals = calloc(num_reals, sizeof(cups_dest_t));
1706
1707 if (reals)
1708 memcpy(reals, *dests, num_reals * sizeof(cups_dest_t));
1709 else
1710 num_reals = 0;
1711 }
1712 else
1713 {
1714 num_reals = 0;
1715 reals = NULL;
1716 }
1717
1718 /*
1719 * Grab the default destination...
1720 */
1721
1722 if ((user_default = _cupsUserDefault(name, sizeof(name))) != NULL)
1723 defprinter = name;
1724 else if ((defprinter = cupsGetDefault2(http)) != NULL)
1725 {
1726 strlcpy(name, defprinter, sizeof(name));
1727 defprinter = name;
1728 }
1729
1730 if (defprinter)
1731 {
1732 /*
1733 * Separate printer and instance name...
1734 */
1735
1736 if ((instance = strchr(name, '/')) != NULL)
1737 *instance++ = '\0';
1738
1739 /*
1740 * Lookup the printer and instance and make it the default...
1741 */
1742
1743 if ((dest = cupsGetDest(name, instance, num_dests, *dests)) != NULL)
1744 dest->is_default = 1;
1745 }
1746 else
1747 instance = NULL;
1748
1749 /*
1750 * Load the /etc/cups/lpoptions and ~/.cups/lpoptions files...
1751 */
1752
1753 snprintf(filename, sizeof(filename), "%s/lpoptions", cg->cups_serverroot);
1754 num_dests = cups_get_dests(filename, NULL, NULL, user_default != NULL,
1755 num_dests, dests);
1756
1757 if ((home = getenv("HOME")) != NULL)
1758 {
1759 snprintf(filename, sizeof(filename), "%s/.cups/lpoptions", home);
1760
1761 num_dests = cups_get_dests(filename, NULL, NULL, user_default != NULL,
1762 num_dests, dests);
1763 }
1764
1765 /*
1766 * Validate the current default destination - this prevents old
1767 * Default lines in /etc/cups/lpoptions and ~/.cups/lpoptions from
1768 * pointing to a non-existent printer or class...
1769 */
1770
1771 if (num_reals)
1772 {
1773 /*
1774 * See if we have a default printer...
1775 */
1776
1777 if ((dest = cupsGetDest(NULL, NULL, num_dests, *dests)) != NULL)
1778 {
1779 /*
1780 * Have a default; see if it is real...
1781 */
1782
1783 dest = cupsGetDest(dest->name, NULL, num_reals, reals);
1784 }
1785
1786 /*
1787 * If dest is NULL, then no default (that exists) is set, so we
1788 * need to set a default if one exists...
1789 */
1790
1791 if (dest == NULL && defprinter != NULL)
1792 {
1793 for (i = 0; i < num_dests; i ++)
1794 (*dests)[i].is_default = 0;
1795
1796 if ((dest = cupsGetDest(name, instance, num_dests, *dests)) != NULL)
1797 dest->is_default = 1;
1798 }
1799
1800 /*
1801 * Free memory...
1802 */
1803
1804 free(reals);
1805 }
1806
1807 /*
1808 * Return the number of destinations...
1809 */
1810
1811 if (num_dests > 0)
1812 _cupsSetError(IPP_OK, NULL, 0);
1813
1814 return (num_dests);
1815 }
1816
1817
1818 /*
1819 * 'cupsGetNamedDest()' - Get options for the named destination.
1820 *
1821 * This function is optimized for retrieving a single destination and should
1822 * be used instead of @link cupsGetDests@ and @link cupsGetDest@ when you either
1823 * know the name of the destination or want to print to the default destination.
1824 * If @code NULL@ is returned, the destination does not exist or there is no
1825 * default destination.
1826 *
1827 * If "http" is @code CUPS_HTTP_DEFAULT@, the connection to the default print
1828 * server will be used.
1829 *
1830 * If "name" is @code NULL@, the default printer for the current user will be
1831 * returned.
1832 *
1833 * The returned destination must be freed using @link cupsFreeDests@ with a
1834 * "num_dests" value of 1.
1835 *
1836 * @since CUPS 1.4/OS X 10.6@
1837 */
1838
1839 cups_dest_t * /* O - Destination or @code NULL@ */
1840 cupsGetNamedDest(http_t *http, /* I - Connection to server or @code CUPS_HTTP_DEFAULT@ */
1841 const char *name, /* I - Destination name or @code NULL@ for the default destination */
1842 const char *instance) /* I - Instance name or @code NULL@ */
1843 {
1844 cups_dest_t *dest; /* Destination */
1845 char filename[1024], /* Path to lpoptions */
1846 defname[256]; /* Default printer name */
1847 const char *home = getenv("HOME"); /* Home directory */
1848 int set_as_default = 0; /* Set returned destination as default */
1849 ipp_op_t op = IPP_GET_PRINTER_ATTRIBUTES;
1850 /* IPP operation to get server ops */
1851 _cups_globals_t *cg = _cupsGlobals(); /* Pointer to library globals */
1852
1853
1854 /*
1855 * If "name" is NULL, find the default destination...
1856 */
1857
1858 if (!name)
1859 {
1860 set_as_default = 1;
1861 name = _cupsUserDefault(defname, sizeof(defname));
1862
1863 if (name)
1864 {
1865 char *ptr; /* Temporary pointer... */
1866
1867 if ((ptr = strchr(defname, '/')) != NULL)
1868 {
1869 *ptr++ = '\0';
1870 instance = ptr;
1871 }
1872 else
1873 instance = NULL;
1874 }
1875 else if (home)
1876 {
1877 /*
1878 * No default in the environment, try the user's lpoptions files...
1879 */
1880
1881 snprintf(filename, sizeof(filename), "%s/.cups/lpoptions", home);
1882
1883 name = cups_get_default(filename, defname, sizeof(defname), &instance);
1884 }
1885
1886 if (!name)
1887 {
1888 /*
1889 * Still not there? Try the system lpoptions file...
1890 */
1891
1892 snprintf(filename, sizeof(filename), "%s/lpoptions",
1893 cg->cups_serverroot);
1894 name = cups_get_default(filename, defname, sizeof(defname), &instance);
1895 }
1896
1897 if (!name)
1898 {
1899 /*
1900 * No locally-set default destination, ask the server...
1901 */
1902
1903 op = CUPS_GET_DEFAULT;
1904 }
1905 }
1906
1907 /*
1908 * Get the printer's attributes...
1909 */
1910
1911 if (!_cupsGetDests(http, op, name, &dest, 0, 0))
1912 {
1913 if (op == CUPS_GET_DEFAULT || (name && !set_as_default))
1914 return (NULL);
1915
1916 /*
1917 * The default printer from environment variables or from a
1918 * configuration file does not exist. Find out the real default.
1919 */
1920
1921 if (!_cupsGetDests(http, CUPS_GET_DEFAULT, NULL, &dest, 0, 0))
1922 return (NULL);
1923 }
1924
1925 if (instance)
1926 dest->instance = _cupsStrAlloc(instance);
1927
1928 if (set_as_default)
1929 dest->is_default = 1;
1930
1931 /*
1932 * Then add local options...
1933 */
1934
1935 snprintf(filename, sizeof(filename), "%s/lpoptions", cg->cups_serverroot);
1936 cups_get_dests(filename, name, instance, 1, 1, &dest);
1937
1938 if (home)
1939 {
1940 snprintf(filename, sizeof(filename), "%s/.cups/lpoptions", home);
1941
1942 cups_get_dests(filename, name, instance, 1, 1, &dest);
1943 }
1944
1945 /*
1946 * Return the result...
1947 */
1948
1949 return (dest);
1950 }
1951
1952
1953 /*
1954 * 'cupsRemoveDest()' - Remove a destination from the destination list.
1955 *
1956 * Removing a destination/instance does not delete the class or printer
1957 * queue, merely the lpoptions for that destination/instance. Use the
1958 * @link cupsSetDests@ or @link cupsSetDests2@ functions to save the new
1959 * options for the user.
1960 *
1961 * @since CUPS 1.3/OS X 10.5@
1962 */
1963
1964 int /* O - New number of destinations */
1965 cupsRemoveDest(const char *name, /* I - Destination name */
1966 const char *instance, /* I - Instance name or @code NULL@ */
1967 int num_dests, /* I - Number of destinations */
1968 cups_dest_t **dests) /* IO - Destinations */
1969 {
1970 int i; /* Index into destinations */
1971 cups_dest_t *dest; /* Pointer to destination */
1972
1973
1974 /*
1975 * Find the destination...
1976 */
1977
1978 if ((dest = cupsGetDest(name, instance, num_dests, *dests)) == NULL)
1979 return (num_dests);
1980
1981 /*
1982 * Free memory...
1983 */
1984
1985 _cupsStrFree(dest->name);
1986 _cupsStrFree(dest->instance);
1987 cupsFreeOptions(dest->num_options, dest->options);
1988
1989 /*
1990 * Remove the destination from the array...
1991 */
1992
1993 num_dests --;
1994
1995 i = dest - *dests;
1996
1997 if (i < num_dests)
1998 memmove(dest, dest + 1, (num_dests - i) * sizeof(cups_dest_t));
1999
2000 return (num_dests);
2001 }
2002
2003
2004 /*
2005 * 'cupsSetDefaultDest()' - Set the default destination.
2006 *
2007 * @since CUPS 1.3/OS X 10.5@
2008 */
2009
2010 void
2011 cupsSetDefaultDest(
2012 const char *name, /* I - Destination name */
2013 const char *instance, /* I - Instance name or @code NULL@ */
2014 int num_dests, /* I - Number of destinations */
2015 cups_dest_t *dests) /* I - Destinations */
2016 {
2017 int i; /* Looping var */
2018 cups_dest_t *dest; /* Current destination */
2019
2020
2021 /*
2022 * Range check input...
2023 */
2024
2025 if (!name || num_dests <= 0 || !dests)
2026 return;
2027
2028 /*
2029 * Loop through the array and set the "is_default" flag for the matching
2030 * destination...
2031 */
2032
2033 for (i = num_dests, dest = dests; i > 0; i --, dest ++)
2034 dest->is_default = !_cups_strcasecmp(name, dest->name) &&
2035 ((!instance && !dest->instance) ||
2036 (instance && dest->instance &&
2037 !_cups_strcasecmp(instance, dest->instance)));
2038 }
2039
2040
2041 /*
2042 * 'cupsSetDests()' - Save the list of destinations for the default server.
2043 *
2044 * This function saves the destinations to /etc/cups/lpoptions when run
2045 * as root and ~/.cups/lpoptions when run as a normal user.
2046 */
2047
2048 void
2049 cupsSetDests(int num_dests, /* I - Number of destinations */
2050 cups_dest_t *dests) /* I - Destinations */
2051 {
2052 cupsSetDests2(CUPS_HTTP_DEFAULT, num_dests, dests);
2053 }
2054
2055
2056 /*
2057 * 'cupsSetDests2()' - Save the list of destinations for the specified server.
2058 *
2059 * This function saves the destinations to /etc/cups/lpoptions when run
2060 * as root and ~/.cups/lpoptions when run as a normal user.
2061 *
2062 * @since CUPS 1.1.21/OS X 10.4@
2063 */
2064
2065 int /* O - 0 on success, -1 on error */
2066 cupsSetDests2(http_t *http, /* I - Connection to server or @code CUPS_HTTP_DEFAULT@ */
2067 int num_dests, /* I - Number of destinations */
2068 cups_dest_t *dests) /* I - Destinations */
2069 {
2070 int i, j; /* Looping vars */
2071 int wrote; /* Wrote definition? */
2072 cups_dest_t *dest; /* Current destination */
2073 cups_option_t *option; /* Current option */
2074 _ipp_option_t *match; /* Matching attribute for option */
2075 FILE *fp; /* File pointer */
2076 #ifndef WIN32
2077 const char *home; /* HOME environment variable */
2078 #endif /* WIN32 */
2079 char filename[1024]; /* lpoptions file */
2080 int num_temps; /* Number of temporary destinations */
2081 cups_dest_t *temps = NULL, /* Temporary destinations */
2082 *temp; /* Current temporary dest */
2083 const char *val; /* Value of temporary option */
2084 _cups_globals_t *cg = _cupsGlobals(); /* Pointer to library globals */
2085
2086
2087 /*
2088 * Range check the input...
2089 */
2090
2091 if (!num_dests || !dests)
2092 return (-1);
2093
2094 /*
2095 * Get the server destinations...
2096 */
2097
2098 num_temps = _cupsGetDests(http, CUPS_GET_PRINTERS, NULL, &temps, 0, 0);
2099
2100 if (cupsLastError() >= IPP_REDIRECTION_OTHER_SITE)
2101 {
2102 cupsFreeDests(num_temps, temps);
2103 return (-1);
2104 }
2105
2106 /*
2107 * Figure out which file to write to...
2108 */
2109
2110 snprintf(filename, sizeof(filename), "%s/lpoptions", cg->cups_serverroot);
2111
2112 #ifndef WIN32
2113 if (getuid())
2114 {
2115 /*
2116 * Merge in server defaults...
2117 */
2118
2119 num_temps = cups_get_dests(filename, NULL, NULL, 0, num_temps, &temps);
2120
2121 /*
2122 * Point to user defaults...
2123 */
2124
2125 if ((home = getenv("HOME")) != NULL)
2126 {
2127 /*
2128 * Create ~/.cups subdirectory...
2129 */
2130
2131 snprintf(filename, sizeof(filename), "%s/.cups", home);
2132 if (access(filename, 0))
2133 mkdir(filename, 0700);
2134
2135 snprintf(filename, sizeof(filename), "%s/.cups/lpoptions", home);
2136 }
2137 }
2138 #endif /* !WIN32 */
2139
2140 /*
2141 * Try to open the file...
2142 */
2143
2144 if ((fp = fopen(filename, "w")) == NULL)
2145 {
2146 cupsFreeDests(num_temps, temps);
2147 return (-1);
2148 }
2149
2150 #ifndef WIN32
2151 /*
2152 * Set the permissions to 0644 when saving to the /etc/cups/lpoptions
2153 * file...
2154 */
2155
2156 if (!getuid())
2157 fchmod(fileno(fp), 0644);
2158 #endif /* !WIN32 */
2159
2160 /*
2161 * Write each printer; each line looks like:
2162 *
2163 * Dest name[/instance] options
2164 * Default name[/instance] options
2165 */
2166
2167 for (i = num_dests, dest = dests; i > 0; i --, dest ++)
2168 if (dest->instance != NULL || dest->num_options != 0 || dest->is_default)
2169 {
2170 if (dest->is_default)
2171 {
2172 fprintf(fp, "Default %s", dest->name);
2173 if (dest->instance)
2174 fprintf(fp, "/%s", dest->instance);
2175
2176 wrote = 1;
2177 }
2178 else
2179 wrote = 0;
2180
2181 if ((temp = cupsGetDest(dest->name, dest->instance, num_temps, temps)) == NULL)
2182 temp = cupsGetDest(dest->name, NULL, num_temps, temps);
2183
2184 for (j = dest->num_options, option = dest->options; j > 0; j --, option ++)
2185 {
2186 /*
2187 * See if this option is a printer attribute; if so, skip it...
2188 */
2189
2190 if ((match = _ippFindOption(option->name)) != NULL &&
2191 match->group_tag == IPP_TAG_PRINTER)
2192 continue;
2193
2194 /*
2195 * See if the server/global options match these; if so, don't
2196 * write 'em.
2197 */
2198
2199 if (temp &&
2200 (val = cupsGetOption(option->name, temp->num_options,
2201 temp->options)) != NULL &&
2202 !_cups_strcasecmp(val, option->value))
2203 continue;
2204
2205 /*
2206 * Options don't match, write to the file...
2207 */
2208
2209 if (!wrote)
2210 {
2211 fprintf(fp, "Dest %s", dest->name);
2212 if (dest->instance)
2213 fprintf(fp, "/%s", dest->instance);
2214 wrote = 1;
2215 }
2216
2217 if (option->value[0])
2218 {
2219 if (strchr(option->value, ' ') ||
2220 strchr(option->value, '\\') ||
2221 strchr(option->value, '\"') ||
2222 strchr(option->value, '\''))
2223 {
2224 /*
2225 * Quote the value...
2226 */
2227
2228 fprintf(fp, " %s=\"", option->name);
2229
2230 for (val = option->value; *val; val ++)
2231 {
2232 if (strchr("\"\'\\", *val))
2233 putc('\\', fp);
2234
2235 putc(*val, fp);
2236 }
2237
2238 putc('\"', fp);
2239 }
2240 else
2241 {
2242 /*
2243 * Store the literal value...
2244 */
2245
2246 fprintf(fp, " %s=%s", option->name, option->value);
2247 }
2248 }
2249 else
2250 fprintf(fp, " %s", option->name);
2251 }
2252
2253 if (wrote)
2254 fputs("\n", fp);
2255 }
2256
2257 /*
2258 * Free the temporary destinations and close the file...
2259 */
2260
2261 cupsFreeDests(num_temps, temps);
2262
2263 fclose(fp);
2264
2265 #ifdef __APPLE__
2266 /*
2267 * Set the default printer for this location - this allows command-line
2268 * and GUI applications to share the same default destination...
2269 */
2270
2271 if ((dest = cupsGetDest(NULL, NULL, num_dests, dests)) != NULL)
2272 {
2273 CFStringRef name = CFStringCreateWithCString(kCFAllocatorDefault,
2274 dest->name,
2275 kCFStringEncodingUTF8);
2276 /* Default printer name */
2277
2278 if (name)
2279 {
2280 _cupsAppleSetDefaultPrinter(name);
2281 CFRelease(name);
2282 }
2283 }
2284 #endif /* __APPLE__ */
2285
2286 #ifdef HAVE_NOTIFY_POST
2287 /*
2288 * Send a notification so that MacOS X applications can know about the
2289 * change, too.
2290 */
2291
2292 notify_post("com.apple.printerListChange");
2293 #endif /* HAVE_NOTIFY_POST */
2294
2295 return (0);
2296 }
2297
2298
2299 /*
2300 * '_cupsUserDefault()' - Get the user default printer from environment
2301 * variables and location information.
2302 */
2303
2304 char * /* O - Default printer or NULL */
2305 _cupsUserDefault(char *name, /* I - Name buffer */
2306 size_t namesize) /* I - Size of name buffer */
2307 {
2308 const char *env; /* LPDEST or PRINTER env variable */
2309 #ifdef __APPLE__
2310 CFStringRef locprinter; /* Last printer as this location */
2311 #endif /* __APPLE__ */
2312
2313
2314 if ((env = getenv("LPDEST")) == NULL)
2315 if ((env = getenv("PRINTER")) != NULL && !strcmp(env, "lp"))
2316 env = NULL;
2317
2318 if (env)
2319 {
2320 strlcpy(name, env, namesize);
2321 return (name);
2322 }
2323
2324 #ifdef __APPLE__
2325 /*
2326 * Use location-based defaults if "use last printer" is selected in the
2327 * system preferences...
2328 */
2329
2330 if ((locprinter = _cupsAppleCopyDefaultPrinter()) != NULL)
2331 {
2332 CFStringGetCString(locprinter, name, namesize, kCFStringEncodingUTF8);
2333 CFRelease(locprinter);
2334 }
2335 else
2336 name[0] = '\0';
2337
2338 DEBUG_printf(("1_cupsUserDefault: Returning \"%s\".", name));
2339
2340 return (*name ? name : NULL);
2341
2342 #else
2343 /*
2344 * No location-based defaults on this platform...
2345 */
2346
2347 name[0] = '\0';
2348 return (NULL);
2349 #endif /* __APPLE__ */
2350 }
2351
2352
2353 #ifdef __APPLE__
2354 /*
2355 * 'appleCopyLocations()' - Copy the location history array.
2356 */
2357
2358 static CFArrayRef /* O - Location array or NULL */
2359 appleCopyLocations(void)
2360 {
2361 CFArrayRef locations; /* Location array */
2362
2363
2364 /*
2365 * Look up the location array in the preferences...
2366 */
2367
2368 if ((locations = CFPreferencesCopyAppValue(kLastUsedPrintersKey,
2369 kCUPSPrintingPrefs)) == NULL)
2370 return (NULL);
2371
2372 if (CFGetTypeID(locations) != CFArrayGetTypeID())
2373 {
2374 CFRelease(locations);
2375 return (NULL);
2376 }
2377
2378 return (locations);
2379 }
2380
2381
2382 /*
2383 * 'appleCopyNetwork()' - Get the network ID for the current location.
2384 */
2385
2386 static CFStringRef /* O - Network ID */
2387 appleCopyNetwork(void)
2388 {
2389 SCDynamicStoreRef dynamicStore; /* System configuration data */
2390 CFStringRef key; /* Current network configuration key */
2391 CFDictionaryRef ip_dict; /* Network configuration data */
2392 CFStringRef network = NULL; /* Current network ID */
2393
2394
2395 if ((dynamicStore = SCDynamicStoreCreate(NULL, CFSTR("libcups"), NULL,
2396 NULL)) != NULL)
2397 {
2398 /*
2399 * First use the IPv6 router address, if available, since that will generally
2400 * be a globally-unique link-local address.
2401 */
2402
2403 if ((key = SCDynamicStoreKeyCreateNetworkGlobalEntity(
2404 NULL, kSCDynamicStoreDomainState, kSCEntNetIPv6)) != NULL)
2405 {
2406 if ((ip_dict = SCDynamicStoreCopyValue(dynamicStore, key)) != NULL)
2407 {
2408 if ((network = CFDictionaryGetValue(ip_dict,
2409 kSCPropNetIPv6Router)) != NULL)
2410 CFRetain(network);
2411
2412 CFRelease(ip_dict);
2413 }
2414
2415 CFRelease(key);
2416 }
2417
2418 /*
2419 * If that doesn't work, try the IPv4 router address. This isn't as unique
2420 * and will likely be a 10.x.y.z or 192.168.y.z address...
2421 */
2422
2423 if (!network)
2424 {
2425 if ((key = SCDynamicStoreKeyCreateNetworkGlobalEntity(
2426 NULL, kSCDynamicStoreDomainState, kSCEntNetIPv4)) != NULL)
2427 {
2428 if ((ip_dict = SCDynamicStoreCopyValue(dynamicStore, key)) != NULL)
2429 {
2430 if ((network = CFDictionaryGetValue(ip_dict,
2431 kSCPropNetIPv4Router)) != NULL)
2432 CFRetain(network);
2433
2434 CFRelease(ip_dict);
2435 }
2436
2437 CFRelease(key);
2438 }
2439 }
2440
2441 CFRelease(dynamicStore);
2442 }
2443
2444 return (network);
2445 }
2446
2447
2448 /*
2449 * 'appleGetPaperSize()' - Get the default paper size.
2450 */
2451
2452 char * /* O - Default paper size */
2453 appleGetPaperSize(char *name, /* I - Paper size name buffer */
2454 int namesize) /* I - Size of buffer */
2455 {
2456 CFStringRef defaultPaperID; /* Default paper ID */
2457 _pwg_media_t *pwgmedia; /* PWG media size */
2458
2459
2460 defaultPaperID = _cupsAppleCopyDefaultPaperID();
2461 if (!defaultPaperID ||
2462 CFGetTypeID(defaultPaperID) != CFStringGetTypeID() ||
2463 !CFStringGetCString(defaultPaperID, name, namesize,
2464 kCFStringEncodingUTF8))
2465 name[0] = '\0';
2466 else if ((pwgmedia = _pwgMediaForLegacy(name)) != NULL)
2467 strlcpy(name, pwgmedia->pwg, namesize);
2468
2469 if (defaultPaperID)
2470 CFRelease(defaultPaperID);
2471
2472 return (name);
2473 }
2474
2475
2476 /*
2477 * 'appleGetPrinter()' - Get a printer from the history array.
2478 */
2479
2480 static CFStringRef /* O - Printer name or NULL */
2481 appleGetPrinter(CFArrayRef locations, /* I - Location array */
2482 CFStringRef network, /* I - Network name */
2483 CFIndex *locindex) /* O - Index in array */
2484 {
2485 CFIndex i, /* Looping var */
2486 count; /* Number of locations */
2487 CFDictionaryRef location; /* Current location */
2488 CFStringRef locnetwork, /* Current network */
2489 locprinter; /* Current printer */
2490
2491
2492 for (i = 0, count = CFArrayGetCount(locations); i < count; i ++)
2493 if ((location = CFArrayGetValueAtIndex(locations, i)) != NULL &&
2494 CFGetTypeID(location) == CFDictionaryGetTypeID())
2495 {
2496 if ((locnetwork = CFDictionaryGetValue(location,
2497 kLocationNetworkKey)) != NULL &&
2498 CFGetTypeID(locnetwork) == CFStringGetTypeID() &&
2499 CFStringCompare(network, locnetwork, 0) == kCFCompareEqualTo &&
2500 (locprinter = CFDictionaryGetValue(location,
2501 kLocationPrinterIDKey)) != NULL &&
2502 CFGetTypeID(locprinter) == CFStringGetTypeID())
2503 {
2504 if (locindex)
2505 *locindex = i;
2506
2507 return (locprinter);
2508 }
2509 }
2510
2511 return (NULL);
2512 }
2513 #endif /* __APPLE__ */
2514
2515
2516 /*
2517 * 'cups_add_dest()' - Add a destination to the array.
2518 *
2519 * Unlike cupsAddDest(), this function does not check for duplicates.
2520 */
2521
2522 static cups_dest_t * /* O - New destination */
2523 cups_add_dest(const char *name, /* I - Name of destination */
2524 const char *instance, /* I - Instance or NULL */
2525 int *num_dests, /* IO - Number of destinations */
2526 cups_dest_t **dests) /* IO - Destinations */
2527 {
2528 int insert, /* Insertion point */
2529 diff; /* Result of comparison */
2530 cups_dest_t *dest; /* Destination pointer */
2531
2532
2533 /*
2534 * Add new destination...
2535 */
2536
2537 if (*num_dests == 0)
2538 dest = malloc(sizeof(cups_dest_t));
2539 else
2540 dest = realloc(*dests, sizeof(cups_dest_t) * (*num_dests + 1));
2541
2542 if (!dest)
2543 return (NULL);
2544
2545 *dests = dest;
2546
2547 /*
2548 * Find where to insert the destination...
2549 */
2550
2551 if (*num_dests == 0)
2552 insert = 0;
2553 else
2554 {
2555 insert = cups_find_dest(name, instance, *num_dests, *dests, *num_dests - 1,
2556 &diff);
2557
2558 if (diff > 0)
2559 insert ++;
2560 }
2561
2562 /*
2563 * Move the array elements as needed...
2564 */
2565
2566 if (insert < *num_dests)
2567 memmove(*dests + insert + 1, *dests + insert,
2568 (*num_dests - insert) * sizeof(cups_dest_t));
2569
2570 (*num_dests) ++;
2571
2572 /*
2573 * Initialize the destination...
2574 */
2575
2576 dest = *dests + insert;
2577 dest->name = _cupsStrAlloc(name);
2578 dest->instance = _cupsStrAlloc(instance);
2579 dest->is_default = 0;
2580 dest->num_options = 0;
2581 dest->options = (cups_option_t *)0;
2582
2583 return (dest);
2584 }
2585
2586
2587 # ifdef __BLOCKS__
2588 /*
2589 * 'cups_block_cb()' - Enumeration callback for block API.
2590 */
2591
2592 static int /* O - 1 to continue, 0 to stop */
2593 cups_block_cb(
2594 cups_dest_block_t block, /* I - Block */
2595 unsigned flags, /* I - Destination flags */
2596 cups_dest_t *dest) /* I - Destination */
2597 {
2598 return ((block)(flags, dest));
2599 }
2600 # endif /* __BLOCKS__ */
2601
2602
2603 /*
2604 * 'cups_compare_dests()' - Compare two destinations.
2605 */
2606
2607 static int /* O - Result of comparison */
2608 cups_compare_dests(cups_dest_t *a, /* I - First destination */
2609 cups_dest_t *b) /* I - Second destination */
2610 {
2611 int diff; /* Difference */
2612
2613
2614 if ((diff = _cups_strcasecmp(a->name, b->name)) != 0)
2615 return (diff);
2616 else if (a->instance && b->instance)
2617 return (_cups_strcasecmp(a->instance, b->instance));
2618 else
2619 return ((a->instance && !b->instance) - (!a->instance && b->instance));
2620 }
2621
2622
2623 #if defined(HAVE_DNSSD) || defined(HAVE_AVAHI)
2624 # ifdef HAVE_DNSSD
2625 /*
2626 * 'cups_dnssd_browse_cb()' - Browse for printers.
2627 */
2628
2629 static void
2630 cups_dnssd_browse_cb(
2631 DNSServiceRef sdRef, /* I - Service reference */
2632 DNSServiceFlags flags, /* I - Option flags */
2633 uint32_t interfaceIndex, /* I - Interface number */
2634 DNSServiceErrorType errorCode, /* I - Error, if any */
2635 const char *serviceName, /* I - Name of service/device */
2636 const char *regtype, /* I - Type of service */
2637 const char *replyDomain, /* I - Service domain */
2638 void *context) /* I - Enumeration data */
2639 {
2640 _cups_dnssd_data_t *data = (_cups_dnssd_data_t *)context;
2641 /* Enumeration data */
2642
2643
2644 DEBUG_printf(("5cups_dnssd_browse_cb(sdRef=%p, flags=%x, "
2645 "interfaceIndex=%d, errorCode=%d, serviceName=\"%s\", "
2646 "regtype=\"%s\", replyDomain=\"%s\", context=%p)",
2647 sdRef, flags, interfaceIndex, errorCode, serviceName, regtype,
2648 replyDomain, context));
2649
2650 /*
2651 * Don't do anything on error...
2652 */
2653
2654 if (errorCode != kDNSServiceErr_NoError)
2655 return;
2656
2657 /*
2658 * Get the device...
2659 */
2660
2661 cups_dnssd_get_device(data, serviceName, regtype, replyDomain);
2662 }
2663
2664
2665 # else /* HAVE_AVAHI */
2666 /*
2667 * 'cups_dnssd_browse_cb()' - Browse for printers.
2668 */
2669
2670 static void
2671 cups_dnssd_browse_cb(
2672 AvahiServiceBrowser *browser, /* I - Browser */
2673 AvahiIfIndex interface, /* I - Interface index (unused) */
2674 AvahiProtocol protocol, /* I - Network protocol (unused) */
2675 AvahiBrowserEvent event, /* I - What happened */
2676 const char *name, /* I - Service name */
2677 const char *type, /* I - Registration type */
2678 const char *domain, /* I - Domain */
2679 AvahiLookupResultFlags flags, /* I - Flags */
2680 void *context) /* I - Devices array */
2681 {
2682 AvahiClient *client = avahi_service_browser_get_client(browser);
2683 /* Client information */
2684 _cups_dnssd_data_t *data = (_cups_dnssd_data_t *)context;
2685 /* Enumeration data */
2686
2687
2688 (void)interface;
2689 (void)protocol;
2690 (void)context;
2691
2692 switch (event)
2693 {
2694 case AVAHI_BROWSER_FAILURE:
2695 DEBUG_printf(("cups_dnssd_browse_cb: %s",
2696 avahi_strerror(avahi_client_errno(client))));
2697 avahi_simple_poll_quit(data->simple_poll);
2698 break;
2699
2700 case AVAHI_BROWSER_NEW:
2701 /*
2702 * This object is new on the network.
2703 */
2704
2705 if (flags & AVAHI_LOOKUP_RESULT_LOCAL)
2706 {
2707 /*
2708 * This comes from the local machine so ignore it.
2709 */
2710
2711 DEBUG_printf(("cups_dnssd_browse_cb: Ignoring local service \"%s\".",
2712 name));
2713 }
2714 else
2715 {
2716 /*
2717 * Create a device entry for it if it doesn't yet exist.
2718 */
2719
2720 cups_dnssd_get_device(data, name, type, domain);
2721 }
2722 break;
2723
2724 case AVAHI_BROWSER_REMOVE:
2725 case AVAHI_BROWSER_ALL_FOR_NOW:
2726 case AVAHI_BROWSER_CACHE_EXHAUSTED:
2727 break;
2728 }
2729 }
2730
2731
2732 /*
2733 * 'cups_dnssd_client_cb()' - Avahi client callback function.
2734 */
2735
2736 static void
2737 cups_dnssd_client_cb(
2738 AvahiClient *client, /* I - Client information (unused) */
2739 AvahiClientState state, /* I - Current state */
2740 void *context) /* I - User data (unused) */
2741 {
2742 _cups_dnssd_data_t *data = (_cups_dnssd_data_t *)context;
2743 /* Enumeration data */
2744
2745
2746 (void)client;
2747
2748 /*
2749 * If the connection drops, quit.
2750 */
2751
2752 if (state == AVAHI_CLIENT_FAILURE)
2753 {
2754 DEBUG_puts("cups_dnssd_client_cb: Avahi connection failed.");
2755 avahi_simple_poll_quit(data->simple_poll);
2756 }
2757 }
2758 # endif /* HAVE_DNSSD */
2759
2760
2761 /*
2762 * 'cups_dnssd_compare_device()' - Compare two devices.
2763 */
2764
2765 static int /* O - Result of comparison */
2766 cups_dnssd_compare_devices(
2767 _cups_dnssd_device_t *a, /* I - First device */
2768 _cups_dnssd_device_t *b) /* I - Second device */
2769 {
2770 return (strcmp(a->dest.name, b->dest.name));
2771 }
2772
2773
2774 /*
2775 * 'cups_dnssd_free_device()' - Free the memory used by a device.
2776 */
2777
2778 static void
2779 cups_dnssd_free_device(
2780 _cups_dnssd_device_t *device, /* I - Device */
2781 _cups_dnssd_data_t *data) /* I - Enumeration data */
2782 {
2783 DEBUG_printf(("5cups_dnssd_free_device(device=%p(%s), data=%p)", device,
2784 device->dest.name, data));
2785
2786 # ifdef HAVE_DNSSD
2787 if (device->ref)
2788 DNSServiceRefDeallocate(device->ref);
2789 # else /* HAVE_AVAHI */
2790 if (device->ref)
2791 avahi_record_browser_free(device->ref);
2792 # endif /* HAVE_DNSSD */
2793
2794 _cupsStrFree(device->domain);
2795 _cupsStrFree(device->fullName);
2796 _cupsStrFree(device->regtype);
2797 _cupsStrFree(device->dest.name);
2798
2799 cupsFreeOptions(device->dest.num_options, device->dest.options);
2800
2801 free(device);
2802 }
2803
2804
2805 /*
2806 * 'cups_dnssd_get_device()' - Lookup a device and create it as needed.
2807 */
2808
2809 static _cups_dnssd_device_t * /* O - Device */
2810 cups_dnssd_get_device(
2811 _cups_dnssd_data_t *data, /* I - Enumeration data */
2812 const char *serviceName, /* I - Service name */
2813 const char *regtype, /* I - Registration type */
2814 const char *replyDomain) /* I - Domain name */
2815 {
2816 _cups_dnssd_device_t key, /* Search key */
2817 *device; /* Device */
2818 char fullName[kDNSServiceMaxDomainName];
2819 /* Full name for query */
2820
2821
2822 DEBUG_printf(("5cups_dnssd_get_device(data=%p, serviceName=\"%s\", "
2823 "regtype=\"%s\", replyDomain=\"%s\")", data, serviceName,
2824 regtype, replyDomain));
2825
2826 /*
2827 * See if this is an existing device...
2828 */
2829
2830 key.dest.name = (char *)serviceName;
2831
2832 if ((device = cupsArrayFind(data->devices, &key)) != NULL)
2833 {
2834 /*
2835 * Yes, see if we need to do anything with this...
2836 */
2837
2838 int update = 0; /* Non-zero if we need to update */
2839
2840 if (!_cups_strcasecmp(replyDomain, "local.") &&
2841 _cups_strcasecmp(device->domain, replyDomain))
2842 {
2843 /*
2844 * Update the "global" listing to use the .local domain name instead.
2845 */
2846
2847 _cupsStrFree(device->domain);
2848 device->domain = _cupsStrAlloc(replyDomain);
2849
2850 DEBUG_printf(("6cups_dnssd_get_device: Updating '%s' to use local "
2851 "domain.", device->dest.name));
2852
2853 update = 1;
2854 }
2855
2856 if (!_cups_strcasecmp(regtype, "_ipps._tcp") &&
2857 _cups_strcasecmp(device->regtype, regtype))
2858 {
2859 /*
2860 * Prefer IPPS over IPP.
2861 */
2862
2863 _cupsStrFree(device->regtype);
2864 device->regtype = _cupsStrAlloc(regtype);
2865
2866 DEBUG_printf(("6cups_dnssd_get_device: Updating '%s' to use IPPS.",
2867 device->dest.name));
2868
2869 update = 1;
2870 }
2871
2872 if (!update)
2873 {
2874 DEBUG_printf(("6cups_dnssd_get_device: No changes to '%s'.",
2875 device->dest.name));
2876 return (device);
2877 }
2878 }
2879 else
2880 {
2881 /*
2882 * No, add the device...
2883 */
2884
2885 DEBUG_printf(("6cups_dnssd_get_device: Adding '%s' for %s with domain "
2886 "'%s'.", serviceName,
2887 !strcmp(regtype, "_ipps._tcp") ? "IPPS" : "IPP",
2888 replyDomain));
2889
2890 device = calloc(sizeof(_cups_dnssd_device_t), 1);
2891 device->dest.name = _cupsStrAlloc(serviceName);
2892 device->domain = _cupsStrAlloc(replyDomain);
2893 device->regtype = _cupsStrAlloc(regtype);
2894
2895 cupsArrayAdd(data->devices, device);
2896 }
2897
2898 /*
2899 * Set the "full name" of this service, which is used for queries...
2900 */
2901
2902 # ifdef HAVE_DNSSD
2903 DNSServiceConstructFullName(fullName, device->dest.name, device->regtype,
2904 device->domain);
2905 # else /* HAVE_AVAHI */
2906 avahi_service_name_join(fullName, kDNSServiceMaxDomainName, serviceName,
2907 regtype, replyDomain);
2908 # endif /* HAVE_DNSSD */
2909
2910 _cupsStrFree(device->fullName);
2911 device->fullName = _cupsStrAlloc(fullName);
2912
2913 if (device->ref)
2914 {
2915 # ifdef HAVE_DNSSD
2916 DNSServiceRefDeallocate(device->ref);
2917 # else /* HAVE_AVAHI */
2918 avahi_record_browser_free(device->ref);
2919 # endif /* HAVE_DNSSD */
2920
2921 device->ref = 0;
2922 }
2923
2924 if (device->state == _CUPS_DNSSD_ACTIVE)
2925 {
2926 (*data->cb)(data->user_data, CUPS_DEST_FLAGS_REMOVED, &device->dest);
2927 device->state = _CUPS_DNSSD_NEW;
2928 }
2929
2930 return (device);
2931 }
2932
2933
2934 # ifdef HAVE_DNSSD
2935 /*
2936 * 'cups_dnssd_local_cb()' - Browse for local printers.
2937 */
2938
2939 static void
2940 cups_dnssd_local_cb(
2941 DNSServiceRef sdRef, /* I - Service reference */
2942 DNSServiceFlags flags, /* I - Option flags */
2943 uint32_t interfaceIndex, /* I - Interface number */
2944 DNSServiceErrorType errorCode, /* I - Error, if any */
2945 const char *serviceName, /* I - Name of service/device */
2946 const char *regtype, /* I - Type of service */
2947 const char *replyDomain, /* I - Service domain */
2948 void *context) /* I - Devices array */
2949 {
2950 _cups_dnssd_data_t *data = (_cups_dnssd_data_t *)context;
2951 /* Enumeration data */
2952 _cups_dnssd_device_t *device; /* Device */
2953
2954
2955 DEBUG_printf(("5cups_dnssd_local_cb(sdRef=%p, flags=%x, "
2956 "interfaceIndex=%d, errorCode=%d, serviceName=\"%s\", "
2957 "regtype=\"%s\", replyDomain=\"%s\", context=%p)",
2958 sdRef, flags, interfaceIndex, errorCode, serviceName,
2959 regtype, replyDomain, context));
2960
2961 /*
2962 * Only process "add" data...
2963 */
2964
2965 if (errorCode != kDNSServiceErr_NoError || !(flags & kDNSServiceFlagsAdd))
2966 return;
2967
2968 /*
2969 * Get the device...
2970 */
2971
2972 device = cups_dnssd_get_device(data, serviceName, regtype, replyDomain);
2973
2974 /*
2975 * Hide locally-registered devices...
2976 */
2977
2978 DEBUG_printf(("6cups_dnssd_local_cb: Hiding local printer '%s'.",
2979 serviceName));
2980
2981 if (device->ref)
2982 {
2983 DNSServiceRefDeallocate(device->ref);
2984 device->ref = 0;
2985 }
2986
2987 if (device->state == _CUPS_DNSSD_ACTIVE)
2988 (*data->cb)(data->user_data, CUPS_DEST_FLAGS_REMOVED, &device->dest);
2989
2990 device->state = _CUPS_DNSSD_LOCAL;
2991 }
2992 # endif /* HAVE_DNSSD */
2993
2994
2995 # ifdef HAVE_AVAHI
2996 /*
2997 * 'cups_dnssd_poll_cb()' - Wait for input on the specified file descriptors.
2998 *
2999 * Note: This function is needed because avahi_simple_poll_iterate is broken
3000 * and always uses a timeout of 0 (!) milliseconds.
3001 * (Avahi Ticket #364)
3002 */
3003
3004 static int /* O - Number of file descriptors matching */
3005 cups_dnssd_poll_cb(
3006 struct pollfd *pollfds, /* I - File descriptors */
3007 unsigned int num_pollfds, /* I - Number of file descriptors */
3008 int timeout, /* I - Timeout in milliseconds (unused) */
3009 void *context) /* I - User data (unused) */
3010 {
3011 _cups_dnssd_data_t *data = (_cups_dnssd_data_t *)context;
3012 /* Enumeration data */
3013 int val; /* Return value */
3014
3015
3016 (void)timeout;
3017
3018 val = poll(pollfds, num_pollfds, 250);
3019
3020 if (val < 0)
3021 {
3022 DEBUG_printf(("cups_dnssd_poll_cb: %s", strerror(errno)));
3023 }
3024 else if (val > 0)
3025 data->got_data = 1;
3026
3027 return (val);
3028 }
3029 # endif /* HAVE_AVAHI */
3030
3031
3032 /*
3033 * 'cups_dnssd_query_cb()' - Process query data.
3034 */
3035
3036 # ifdef HAVE_DNSSD
3037 static void
3038 cups_dnssd_query_cb(
3039 DNSServiceRef sdRef, /* I - Service reference */
3040 DNSServiceFlags flags, /* I - Data flags */
3041 uint32_t interfaceIndex, /* I - Interface */
3042 DNSServiceErrorType errorCode, /* I - Error, if any */
3043 const char *fullName, /* I - Full service name */
3044 uint16_t rrtype, /* I - Record type */
3045 uint16_t rrclass, /* I - Record class */
3046 uint16_t rdlen, /* I - Length of record data */
3047 const void *rdata, /* I - Record data */
3048 uint32_t ttl, /* I - Time-to-live */
3049 void *context) /* I - Enumeration data */
3050 {
3051 # else /* HAVE_AVAHI */
3052 static void
3053 cups_dnssd_query_cb(
3054 AvahiRecordBrowser *browser, /* I - Record browser */
3055 AvahiIfIndex interfaceIndex,
3056 /* I - Interface index (unused) */
3057 AvahiProtocol protocol, /* I - Network protocol (unused) */
3058 AvahiBrowserEvent event, /* I - What happened? */
3059 const char *fullName, /* I - Service name */
3060 uint16_t rrclass, /* I - Record class */
3061 uint16_t rrtype, /* I - Record type */
3062 const void *rdata, /* I - TXT record */
3063 size_t rdlen, /* I - Length of TXT record */
3064 AvahiLookupResultFlags flags, /* I - Flags */
3065 void *context) /* I - Enumeration data */
3066 {
3067 AvahiClient *client = avahi_record_browser_get_client(browser);
3068 /* Client information */
3069 # endif /* HAVE_DNSSD */
3070 _cups_dnssd_data_t *data = (_cups_dnssd_data_t *)context;
3071 /* Enumeration data */
3072 char name[1024], /* Service name */
3073 *ptr; /* Pointer into string */
3074 _cups_dnssd_device_t dkey, /* Search key */
3075 *device; /* Device */
3076
3077
3078 # ifdef HAVE_DNSSD
3079 DEBUG_printf(("5cups_dnssd_query_cb(sdRef=%p, flags=%x, "
3080 "interfaceIndex=%d, errorCode=%d, fullName=\"%s\", "
3081 "rrtype=%u, rrclass=%u, rdlen=%u, rdata=%p, ttl=%u, "
3082 "context=%p)", sdRef, flags, interfaceIndex, errorCode,
3083 fullName, rrtype, rrclass, rdlen, rdata, ttl, context));
3084
3085 /*
3086 * Only process "add" data...
3087 */
3088
3089 if (errorCode != kDNSServiceErr_NoError || !(flags & kDNSServiceFlagsAdd))
3090 return;
3091
3092 # else /* HAVE_AVAHI */
3093 DEBUG_printf(("5cups_dnssd_query_cb(browser=%p, interfaceIndex=%d, "
3094 "protocol=%d, event=%d, fullName=\"%s\", rrclass=%u, "
3095 "rrtype=%u, rdata=%p, rdlen=%u, flags=%x, context=%p)",
3096 browser, interfaceIndex, protocol, event, fullName, rrclass,
3097 rrtype, rdata, (unsigned)rdlen, flags, context));
3098
3099 /*
3100 * Only process "add" data...
3101 */
3102
3103 if (event != AVAHI_BROWSER_NEW)
3104 {
3105 if (event == AVAHI_BROWSER_FAILURE)
3106 DEBUG_printf(("cups_dnssd_query_cb: %s",
3107 avahi_strerror(avahi_client_errno(client))));
3108
3109 return;
3110 }
3111 # endif /* HAVE_DNSSD */
3112
3113 /*
3114 * Lookup the service in the devices array.
3115 */
3116
3117 dkey.dest.name = name;
3118
3119 cups_dnssd_unquote(name, fullName, sizeof(name));
3120
3121 if ((ptr = strstr(name, "._")) != NULL)
3122 *ptr = '\0';
3123
3124 if ((device = cupsArrayFind(data->devices, &dkey)) != NULL)
3125 {
3126 /*
3127 * Found it, pull out the make and model from the TXT record and save it...
3128 */
3129
3130 const uint8_t *txt, /* Pointer into data */
3131 *txtnext, /* Next key/value pair */
3132 *txtend; /* End of entire TXT record */
3133 uint8_t txtlen; /* Length of current key/value pair */
3134 char key[256], /* Key string */
3135 value[256], /* Value string */
3136 make_and_model[512],
3137 /* Manufacturer and model */
3138 model[256], /* Model */
3139 uriname[1024], /* Name for URI */
3140 uri[1024]; /* Printer URI */
3141 cups_ptype_t type = CUPS_PRINTER_REMOTE | CUPS_PRINTER_BW;
3142 /* Printer type */
3143 int saw_printer_type = 0;
3144 /* Did we see a printer-type key? */
3145
3146 device->state = _CUPS_DNSSD_PENDING;
3147 make_and_model[0] = '\0';
3148
3149 strcpy(model, "Unknown");
3150
3151 for (txt = rdata, txtend = txt + rdlen;
3152 txt < txtend;
3153 txt = txtnext)
3154 {
3155 /*
3156 * Read a key/value pair starting with an 8-bit length. Since the
3157 * length is 8 bits and the size of the key/value buffers is 256, we
3158 * don't need to check for overflow...
3159 */
3160
3161 txtlen = *txt++;
3162
3163 if (!txtlen || (txt + txtlen) > txtend)
3164 break;
3165
3166 txtnext = txt + txtlen;
3167
3168 for (ptr = key; txt < txtnext && *txt != '='; txt ++)
3169 *ptr++ = *txt;
3170 *ptr = '\0';
3171
3172 if (txt < txtnext && *txt == '=')
3173 {
3174 txt ++;
3175
3176 if (txt < txtnext)
3177 memcpy(value, txt, txtnext - txt);
3178 value[txtnext - txt] = '\0';
3179
3180 DEBUG_printf(("6cups_dnssd_query_cb: %s=%s", key, value));
3181 }
3182 else
3183 {
3184 DEBUG_printf(("6cups_dnssd_query_cb: '%s' with no value.", key));
3185 continue;
3186 }
3187
3188 if (!_cups_strcasecmp(key, "usb_MFG") ||
3189 !_cups_strcasecmp(key, "usb_MANU") ||
3190 !_cups_strcasecmp(key, "usb_MANUFACTURER"))
3191 strcpy(make_and_model, value);
3192 else if (!_cups_strcasecmp(key, "usb_MDL") ||
3193 !_cups_strcasecmp(key, "usb_MODEL"))
3194 strcpy(model, value);
3195 else if (!_cups_strcasecmp(key, "product") && !strstr(value, "Ghostscript"))
3196 {
3197 if (value[0] == '(')
3198 {
3199 /*
3200 * Strip parenthesis...
3201 */
3202
3203 if ((ptr = value + strlen(value) - 1) > value && *ptr == ')')
3204 *ptr = '\0';
3205
3206 strcpy(model, value + 1);
3207 }
3208 else
3209 strcpy(model, value);
3210 }
3211 else if (!_cups_strcasecmp(key, "ty"))
3212 {
3213 strcpy(model, value);
3214
3215 if ((ptr = strchr(model, ',')) != NULL)
3216 *ptr = '\0';
3217 }
3218 else if (!_cups_strcasecmp(key, "note"))
3219 device->dest.num_options = cupsAddOption("printer-location", value,
3220 device->dest.num_options,
3221 &device->dest.options);
3222 else if (!_cups_strcasecmp(key, "pdl"))
3223 {
3224 /*
3225 * Look for PDF-capable printers; only PDF-capable printers are shown.
3226 */
3227
3228 const char *start, *next; /* Pointer into value */
3229 int have_pdf = 0; /* Have PDF? */
3230
3231 for (start = value; start && *start; start = next)
3232 {
3233 if (!_cups_strncasecmp(start, "application/pdf", 15) &&
3234 (!start[15] || start[15] == ','))
3235 {
3236 have_pdf = 1;
3237 break;
3238 }
3239
3240 if ((next = strchr(start, ',')) != NULL)
3241 next ++;
3242 }
3243
3244 if (!have_pdf)
3245 device->state = _CUPS_DNSSD_INCOMPATIBLE;
3246 }
3247 else if (!_cups_strcasecmp(key, "printer-type"))
3248 {
3249 /*
3250 * Value is either NNNN or 0xXXXX
3251 */
3252
3253 saw_printer_type = 1;
3254 type = strtol(value, NULL, 0);
3255 }
3256 else if (!saw_printer_type)
3257 {
3258 if (!_cups_strcasecmp(key, "air") &&
3259 !_cups_strcasecmp(value, "t"))
3260 type |= CUPS_PRINTER_AUTHENTICATED;
3261 else if (!_cups_strcasecmp(key, "bind") &&
3262 !_cups_strcasecmp(value, "t"))
3263 type |= CUPS_PRINTER_BIND;
3264 else if (!_cups_strcasecmp(key, "collate") &&
3265 !_cups_strcasecmp(value, "t"))
3266 type |= CUPS_PRINTER_COLLATE;
3267 else if (!_cups_strcasecmp(key, "color") &&
3268 !_cups_strcasecmp(value, "t"))
3269 type |= CUPS_PRINTER_COLOR;
3270 else if (!_cups_strcasecmp(key, "copies") &&
3271 !_cups_strcasecmp(value, "t"))
3272 type |= CUPS_PRINTER_COPIES;
3273 else if (!_cups_strcasecmp(key, "duplex") &&
3274 !_cups_strcasecmp(value, "t"))
3275 type |= CUPS_PRINTER_DUPLEX;
3276 else if (!_cups_strcasecmp(key, "fax") &&
3277 !_cups_strcasecmp(value, "t"))
3278 type |= CUPS_PRINTER_MFP;
3279 else if (!_cups_strcasecmp(key, "papercustom") &&
3280 !_cups_strcasecmp(value, "t"))
3281 type |= CUPS_PRINTER_VARIABLE;
3282 else if (!_cups_strcasecmp(key, "papermax"))
3283 {
3284 if (!_cups_strcasecmp(value, "legal-a4"))
3285 type |= CUPS_PRINTER_SMALL;
3286 else if (!_cups_strcasecmp(value, "isoc-a2"))
3287 type |= CUPS_PRINTER_MEDIUM;
3288 else if (!_cups_strcasecmp(value, ">isoc-a2"))
3289 type |= CUPS_PRINTER_LARGE;
3290 }
3291 else if (!_cups_strcasecmp(key, "punch") &&
3292 !_cups_strcasecmp(value, "t"))
3293 type |= CUPS_PRINTER_PUNCH;
3294 else if (!_cups_strcasecmp(key, "scan") &&
3295 !_cups_strcasecmp(value, "t"))
3296 type |= CUPS_PRINTER_MFP;
3297 else if (!_cups_strcasecmp(key, "sort") &&
3298 !_cups_strcasecmp(value, "t"))
3299 type |= CUPS_PRINTER_SORT;
3300 else if (!_cups_strcasecmp(key, "staple") &&
3301 !_cups_strcasecmp(value, "t"))
3302 type |= CUPS_PRINTER_STAPLE;
3303 }
3304 }
3305
3306 /*
3307 * Save the printer-xxx values...
3308 */
3309
3310 device->dest.num_options = cupsAddOption("printer-info", name,
3311 device->dest.num_options,
3312 &device->dest.options);
3313
3314 if (make_and_model[0])
3315 {
3316 strlcat(make_and_model, " ", sizeof(make_and_model));
3317 strlcat(make_and_model, model, sizeof(make_and_model));
3318
3319 device->dest.num_options = cupsAddOption("printer-make-and-model",
3320 make_and_model,
3321 device->dest.num_options,
3322 &device->dest.options);
3323 }
3324 else
3325 device->dest.num_options = cupsAddOption("printer-make-and-model",
3326 model,
3327 device->dest.num_options,
3328 &device->dest.options);
3329
3330 device->type = type;
3331 snprintf(value, sizeof(value), "%u", type);
3332 device->dest.num_options = cupsAddOption("printer-type", value,
3333 device->dest.num_options,
3334 &device->dest.options);
3335
3336 /*
3337 * Save the URI...
3338 */
3339
3340 cups_dnssd_unquote(uriname, device->fullName, sizeof(uriname));
3341 httpAssembleURI(HTTP_URI_CODING_ALL, uri, sizeof(uri),
3342 !strcmp(device->regtype, "_ipps._tcp") ? "ipps" : "ipp",
3343 NULL, uriname, 0, saw_printer_type ? "/cups" : "/");
3344
3345 DEBUG_printf(("6cups_dnssd_query: printer-uri-supported=\"%s\"", uri));
3346
3347 device->dest.num_options = cupsAddOption("printer-uri-supported", uri,
3348 device->dest.num_options,
3349 &device->dest.options);
3350 }
3351 else
3352 DEBUG_printf(("6cups_dnssd_query: Ignoring TXT record for '%s'.",
3353 fullName));
3354 }
3355
3356
3357 /*
3358 * 'cups_dnssd_resolve()' - Resolve a Bonjour printer URI.
3359 */
3360
3361 static const char * /* O - Resolved URI or NULL */
3362 cups_dnssd_resolve(
3363 cups_dest_t *dest, /* I - Destination */
3364 const char *uri, /* I - Current printer URI */
3365 int msec, /* I - Time in milliseconds */
3366 int *cancel, /* I - Pointer to "cancel" variable */
3367 cups_dest_cb_t cb, /* I - Callback */
3368 void *user_data) /* I - User data for callback */
3369 {
3370 char tempuri[1024]; /* Temporary URI buffer */
3371 _cups_dnssd_resolve_t resolve; /* Resolve data */
3372
3373
3374 /*
3375 * Resolve the URI...
3376 */
3377
3378 resolve.cancel = cancel;
3379 gettimeofday(&resolve.end_time, NULL);
3380 if (msec > 0)
3381 {
3382 resolve.end_time.tv_sec += msec / 1000;
3383 resolve.end_time.tv_usec += (msec % 1000) * 1000;
3384
3385 while (resolve.end_time.tv_usec >= 1000000)
3386 {
3387 resolve.end_time.tv_sec ++;
3388 resolve.end_time.tv_usec -= 1000000;
3389 }
3390 }
3391 else
3392 resolve.end_time.tv_sec += 75;
3393
3394 if (cb)
3395 (*cb)(user_data, CUPS_DEST_FLAGS_UNCONNECTED | CUPS_DEST_FLAGS_RESOLVING,
3396 dest);
3397
3398 if ((uri = _httpResolveURI(uri, tempuri, sizeof(tempuri),
3399 _HTTP_RESOLVE_FQDN, cups_dnssd_resolve_cb,
3400 &resolve)) == NULL)
3401 {
3402 _cupsSetError(IPP_INTERNAL_ERROR, _("Unable to resolve printer URI."), 1);
3403
3404 if (cb)
3405 (*cb)(user_data, CUPS_DEST_FLAGS_UNCONNECTED | CUPS_DEST_FLAGS_ERROR,
3406 dest);
3407
3408 return (NULL);
3409 }
3410
3411 /*
3412 * Save the resolved URI...
3413 */
3414
3415 dest->num_options = cupsAddOption("printer-uri-supported", uri,
3416 dest->num_options, &dest->options);
3417
3418 return (cupsGetOption("printer-uri-supported", dest->num_options,
3419 dest->options));
3420 }
3421
3422
3423 /*
3424 * 'cups_dnssd_resolve_cb()' - See if we should continue resolving.
3425 */
3426
3427 static int /* O - 1 to continue, 0 to stop */
3428 cups_dnssd_resolve_cb(void *context) /* I - Resolve data */
3429 {
3430 _cups_dnssd_resolve_t *resolve = (_cups_dnssd_resolve_t *)context;
3431 /* Resolve data */
3432 struct timeval curtime; /* Current time */
3433
3434
3435 /*
3436 * If the cancel variable is set, return immediately.
3437 */
3438
3439 if (*resolve->cancel)
3440 return (0);
3441
3442 /*
3443 * Otherwise check the end time...
3444 */
3445
3446 gettimeofday(&curtime, NULL);
3447
3448 return (curtime.tv_sec > resolve->end_time.tv_sec ||
3449 (curtime.tv_sec == resolve->end_time.tv_sec &&
3450 curtime.tv_usec > resolve->end_time.tv_usec));
3451 }
3452
3453
3454 /*
3455 * 'cups_dnssd_unquote()' - Unquote a name string.
3456 */
3457
3458 static void
3459 cups_dnssd_unquote(char *dst, /* I - Destination buffer */
3460 const char *src, /* I - Source string */
3461 size_t dstsize) /* I - Size of destination buffer */
3462 {
3463 char *dstend = dst + dstsize - 1; /* End of destination buffer */
3464
3465
3466 while (*src && dst < dstend)
3467 {
3468 if (*src == '\\')
3469 {
3470 src ++;
3471 if (isdigit(src[0] & 255) && isdigit(src[1] & 255) &&
3472 isdigit(src[2] & 255))
3473 {
3474 *dst++ = ((((src[0] - '0') * 10) + src[1] - '0') * 10) + src[2] - '0';
3475 src += 3;
3476 }
3477 else
3478 *dst++ = *src++;
3479 }
3480 else
3481 *dst++ = *src ++;
3482 }
3483
3484 *dst = '\0';
3485 }
3486 #endif /* HAVE_DNSSD */
3487
3488
3489 /*
3490 * 'cups_find_dest()' - Find a destination using a binary search.
3491 */
3492
3493 static int /* O - Index of match */
3494 cups_find_dest(const char *name, /* I - Destination name */
3495 const char *instance, /* I - Instance or NULL */
3496 int num_dests, /* I - Number of destinations */
3497 cups_dest_t *dests, /* I - Destinations */
3498 int prev, /* I - Previous index */
3499 int *rdiff) /* O - Difference of match */
3500 {
3501 int left, /* Low mark for binary search */
3502 right, /* High mark for binary search */
3503 current, /* Current index */
3504 diff; /* Result of comparison */
3505 cups_dest_t key; /* Search key */
3506
3507
3508 key.name = (char *)name;
3509 key.instance = (char *)instance;
3510
3511 if (prev >= 0)
3512 {
3513 /*
3514 * Start search on either side of previous...
3515 */
3516
3517 if ((diff = cups_compare_dests(&key, dests + prev)) == 0 ||
3518 (diff < 0 && prev == 0) ||
3519 (diff > 0 && prev == (num_dests - 1)))
3520 {
3521 *rdiff = diff;
3522 return (prev);
3523 }
3524 else if (diff < 0)
3525 {
3526 /*
3527 * Start with previous on right side...
3528 */
3529
3530 left = 0;
3531 right = prev;
3532 }
3533 else
3534 {
3535 /*
3536 * Start wih previous on left side...
3537 */
3538
3539 left = prev;
3540 right = num_dests - 1;
3541 }
3542 }
3543 else
3544 {
3545 /*
3546 * Start search in the middle...
3547 */
3548
3549 left = 0;
3550 right = num_dests - 1;
3551 }
3552
3553 do
3554 {
3555 current = (left + right) / 2;
3556 diff = cups_compare_dests(&key, dests + current);
3557
3558 if (diff == 0)
3559 break;
3560 else if (diff < 0)
3561 right = current;
3562 else
3563 left = current;
3564 }
3565 while ((right - left) > 1);
3566
3567 if (diff != 0)
3568 {
3569 /*
3570 * Check the last 1 or 2 elements...
3571 */
3572
3573 if ((diff = cups_compare_dests(&key, dests + left)) <= 0)
3574 current = left;
3575 else
3576 {
3577 diff = cups_compare_dests(&key, dests + right);
3578 current = right;
3579 }
3580 }
3581
3582 /*
3583 * Return the closest destination and the difference...
3584 */
3585
3586 *rdiff = diff;
3587
3588 return (current);
3589 }
3590
3591
3592 /*
3593 * 'cups_get_default()' - Get the default destination from an lpoptions file.
3594 */
3595
3596 static char * /* O - Default destination or NULL */
3597 cups_get_default(const char *filename, /* I - File to read */
3598 char *namebuf, /* I - Name buffer */
3599 size_t namesize, /* I - Size of name buffer */
3600 const char **instance) /* I - Instance */
3601 {
3602 cups_file_t *fp; /* lpoptions file */
3603 char line[8192], /* Line from file */
3604 *value, /* Value for line */
3605 *nameptr; /* Pointer into name */
3606 int linenum; /* Current line */
3607
3608
3609 *namebuf = '\0';
3610
3611 if ((fp = cupsFileOpen(filename, "r")) != NULL)
3612 {
3613 linenum = 0;
3614
3615 while (cupsFileGetConf(fp, line, sizeof(line), &value, &linenum))
3616 {
3617 if (!_cups_strcasecmp(line, "default") && value)
3618 {
3619 strlcpy(namebuf, value, namesize);
3620
3621 if ((nameptr = strchr(namebuf, ' ')) != NULL)
3622 *nameptr = '\0';
3623 if ((nameptr = strchr(namebuf, '\t')) != NULL)
3624 *nameptr = '\0';
3625
3626 if ((nameptr = strchr(namebuf, '/')) != NULL)
3627 *nameptr++ = '\0';
3628
3629 *instance = nameptr;
3630 break;
3631 }
3632 }
3633
3634 cupsFileClose(fp);
3635 }
3636
3637 return (*namebuf ? namebuf : NULL);
3638 }
3639
3640
3641 /*
3642 * 'cups_get_dests()' - Get destinations from a file.
3643 */
3644
3645 static int /* O - Number of destinations */
3646 cups_get_dests(
3647 const char *filename, /* I - File to read from */
3648 const char *match_name, /* I - Destination name we want */
3649 const char *match_inst, /* I - Instance name we want */
3650 int user_default_set, /* I - User default printer set? */
3651 int num_dests, /* I - Number of destinations */
3652 cups_dest_t **dests) /* IO - Destinations */
3653 {
3654 int i; /* Looping var */
3655 cups_dest_t *dest; /* Current destination */
3656 cups_file_t *fp; /* File pointer */
3657 char line[8192], /* Line from file */
3658 *lineptr, /* Pointer into line */
3659 *name, /* Name of destination/option */
3660 *instance; /* Instance of destination */
3661 int linenum; /* Current line number */
3662
3663
3664 DEBUG_printf(("7cups_get_dests(filename=\"%s\", match_name=\"%s\", "
3665 "match_inst=\"%s\", user_default_set=%d, num_dests=%d, "
3666 "dests=%p)", filename, match_name, match_inst,
3667 user_default_set, num_dests, dests));
3668
3669 /*
3670 * Try to open the file...
3671 */
3672
3673 if ((fp = cupsFileOpen(filename, "r")) == NULL)
3674 return (num_dests);
3675
3676 /*
3677 * Read each printer; each line looks like:
3678 *
3679 * Dest name[/instance] options
3680 * Default name[/instance] options
3681 */
3682
3683 linenum = 0;
3684
3685 while (cupsFileGetConf(fp, line, sizeof(line), &lineptr, &linenum))
3686 {
3687 /*
3688 * See what type of line it is...
3689 */
3690
3691 DEBUG_printf(("9cups_get_dests: linenum=%d line=\"%s\" lineptr=\"%s\"",
3692 linenum, line, lineptr));
3693
3694 if ((_cups_strcasecmp(line, "dest") && _cups_strcasecmp(line, "default")) || !lineptr)
3695 {
3696 DEBUG_puts("9cups_get_dests: Not a dest or default line...");
3697 continue;
3698 }
3699
3700 name = lineptr;
3701
3702 /*
3703 * Search for an instance...
3704 */
3705
3706 while (!isspace(*lineptr & 255) && *lineptr && *lineptr != '/')
3707 lineptr ++;
3708
3709 if (*lineptr == '/')
3710 {
3711 /*
3712 * Found an instance...
3713 */
3714
3715 *lineptr++ = '\0';
3716 instance = lineptr;
3717
3718 /*
3719 * Search for an instance...
3720 */
3721
3722 while (!isspace(*lineptr & 255) && *lineptr)
3723 lineptr ++;
3724 }
3725 else
3726 instance = NULL;
3727
3728 if (*lineptr)
3729 *lineptr++ = '\0';
3730
3731 DEBUG_printf(("9cups_get_dests: name=\"%s\", instance=\"%s\"", name,
3732 instance));
3733
3734 /*
3735 * See if the primary instance of the destination exists; if not,
3736 * ignore this entry and move on...
3737 */
3738
3739 if (match_name)
3740 {
3741 if (_cups_strcasecmp(name, match_name) ||
3742 (!instance && match_inst) ||
3743 (instance && !match_inst) ||
3744 (instance && _cups_strcasecmp(instance, match_inst)))
3745 continue;
3746
3747 dest = *dests;
3748 }
3749 else if (cupsGetDest(name, NULL, num_dests, *dests) == NULL)
3750 {
3751 DEBUG_puts("9cups_get_dests: Not found!");
3752 continue;
3753 }
3754 else
3755 {
3756 /*
3757 * Add the destination...
3758 */
3759
3760 num_dests = cupsAddDest(name, instance, num_dests, dests);
3761
3762 if ((dest = cupsGetDest(name, instance, num_dests, *dests)) == NULL)
3763 {
3764 /*
3765 * Out of memory!
3766 */
3767
3768 DEBUG_puts("9cups_get_dests: Out of memory!");
3769 break;
3770 }
3771 }
3772
3773 /*
3774 * Add options until we hit the end of the line...
3775 */
3776
3777 dest->num_options = cupsParseOptions(lineptr, dest->num_options,
3778 &(dest->options));
3779
3780 /*
3781 * If we found what we were looking for, stop now...
3782 */
3783
3784 if (match_name)
3785 break;
3786
3787 /*
3788 * Set this as default if needed...
3789 */
3790
3791 if (!user_default_set && !_cups_strcasecmp(line, "default"))
3792 {
3793 DEBUG_puts("9cups_get_dests: Setting as default...");
3794
3795 for (i = 0; i < num_dests; i ++)
3796 (*dests)[i].is_default = 0;
3797
3798 dest->is_default = 1;
3799 }
3800 }
3801
3802 /*
3803 * Close the file and return...
3804 */
3805
3806 cupsFileClose(fp);
3807
3808 return (num_dests);
3809 }
3810
3811
3812 /*
3813 * 'cups_make_string()' - Make a comma-separated string of values from an IPP
3814 * attribute.
3815 */
3816
3817 static char * /* O - New string */
3818 cups_make_string(
3819 ipp_attribute_t *attr, /* I - Attribute to convert */
3820 char *buffer, /* I - Buffer */
3821 size_t bufsize) /* I - Size of buffer */
3822 {
3823 int i; /* Looping var */
3824 char *ptr, /* Pointer into buffer */
3825 *end, /* Pointer to end of buffer */
3826 *valptr; /* Pointer into string attribute */
3827
3828
3829 /*
3830 * Return quickly if we have a single string value...
3831 */
3832
3833 if (attr->num_values == 1 &&
3834 attr->value_tag != IPP_TAG_INTEGER &&
3835 attr->value_tag != IPP_TAG_ENUM &&
3836 attr->value_tag != IPP_TAG_BOOLEAN &&
3837 attr->value_tag != IPP_TAG_RANGE)
3838 return (attr->values[0].string.text);
3839
3840 /*
3841 * Copy the values to the string, separating with commas and escaping strings
3842 * as needed...
3843 */
3844
3845 end = buffer + bufsize - 1;
3846
3847 for (i = 0, ptr = buffer; i < attr->num_values && ptr < end; i ++)
3848 {
3849 if (i)
3850 *ptr++ = ',';
3851
3852 switch (attr->value_tag)
3853 {
3854 case IPP_TAG_INTEGER :
3855 case IPP_TAG_ENUM :
3856 snprintf(ptr, end - ptr + 1, "%d", attr->values[i].integer);
3857 break;
3858
3859 case IPP_TAG_BOOLEAN :
3860 if (attr->values[i].boolean)
3861 strlcpy(ptr, "true", end - ptr + 1);
3862 else
3863 strlcpy(ptr, "false", end - ptr + 1);
3864 break;
3865
3866 case IPP_TAG_RANGE :
3867 if (attr->values[i].range.lower == attr->values[i].range.upper)
3868 snprintf(ptr, end - ptr + 1, "%d", attr->values[i].range.lower);
3869 else
3870 snprintf(ptr, end - ptr + 1, "%d-%d", attr->values[i].range.lower,
3871 attr->values[i].range.upper);
3872 break;
3873
3874 default :
3875 for (valptr = attr->values[i].string.text;
3876 *valptr && ptr < end;)
3877 {
3878 if (strchr(" \t\n\\\'\"", *valptr))
3879 {
3880 if (ptr >= (end - 1))
3881 break;
3882
3883 *ptr++ = '\\';
3884 }
3885
3886 *ptr++ = *valptr++;
3887 }
3888
3889 *ptr = '\0';
3890 break;
3891 }
3892
3893 ptr += strlen(ptr);
3894 }
3895
3896 *ptr = '\0';
3897
3898 return (buffer);
3899 }
3900
3901
3902 /*
3903 * End of "$Id: dest.c 9568 2011-02-25 06:13:56Z mike $".
3904 */
Unnamed repository; edit this file 'description' to name the repository.