]> git.ipfire.org Git - thirdparty/cups.git/blob - scheduler/dirsvc.c
projects / thirdparty / cups.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Update svn:keyword properties.
[thirdparty/cups.git] / scheduler / dirsvc.c
1 /*
2 * "$Id$"
3 *
4 * Directory services routines for the CUPS scheduler.
5 *
6 * Copyright 2007-2012 by Apple Inc.
7 * Copyright 1997-2007 by Easy Software Products, all rights reserved.
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 * Contents:
16 *
17 * cupsdDeregisterPrinter() - Stop sending broadcast information for a local
18 * printer and remove any pending references to
19 * remote printers.
20 * cupsdRegisterPrinter() - Start sending broadcast information for a
21 * printer or update the broadcast contents.
22 * cupsdStartBrowsing() - Start sending and receiving broadcast
23 * information.
24 * cupsdStopBrowsing() - Stop sending and receiving broadcast
25 * information.
26 * cupsdUpdateDNSSDName() - Update the computer name we use for
27 * browsing...
28 * dnssdAddAlias() - Add a DNS-SD alias name.
29 * dnssdBuildTxtRecord() - Build a TXT record from printer info.
30 * dnssdDeregisterInstance() - Deregister a DNS-SD service instance.
31 * dnssdDeregisterPrinter() - Deregister all services for a printer.
32 * dnssdErrorString() - Return an error string for an error code.
33 * dnssdRegisterCallback() - Free a TXT record.
34 * dnssdRegisterCallback() - DNSServiceRegister callback.
35 * dnssdRegisterInstance() - Register an instance of a printer service.
36 * dnssdRegisterPrinter() - Start sending broadcast information for a
37 * printer or update the broadcast contents.
38 * dnssdStop() - Stop all DNS-SD registrations.
39 * dnssdUpdate() - Handle DNS-SD queries.
40 * get_auth_info_required() - Get the auth-info-required value to advertise.
41 * get_hostconfig() - Get an /etc/hostconfig service setting.
42 * update_lpd() - Update the LPD configuration as needed.
43 * update_smb() - Update the SMB configuration as needed.
44 */
45
46 /*
47 * Include necessary headers...
48 */
49
50 #include "cupsd.h"
51 #include <grp.h>
52
53 #if defined(HAVE_DNSSD) && defined(__APPLE__)
54 # include <nameser.h>
55 # include <CoreFoundation/CoreFoundation.h>
56 # include <SystemConfiguration/SystemConfiguration.h>
57 #endif /* HAVE_DNSSD && __APPLE__ */
58
59
60 /*
61 * Local functions...
62 */
63
64 #if defined(HAVE_DNSSD) || defined(HAVE_AVAHI)
65 static char *get_auth_info_required(cupsd_printer_t *p,
66 char *buffer, size_t bufsize);
67 #endif /* HAVE_DNSSD || HAVE_AVAHI */
68 #ifdef __APPLE__
69 static int get_hostconfig(const char *name);
70 #endif /* __APPLE__ */
71 static void update_lpd(int onoff);
72 static void update_smb(int onoff);
73
74
75 #if defined(HAVE_DNSSD) || defined(HAVE_AVAHI)
76 # ifdef __APPLE__
77 static void dnssdAddAlias(const void *key, const void *value,
78 void *context);
79 # endif /* __APPLE__ */
80 static cupsd_txt_t dnssdBuildTxtRecord(cupsd_printer_t *p, int for_lpd);
81 static void dnssdDeregisterInstance(cupsd_srv_t *srv);
82 static void dnssdDeregisterPrinter(cupsd_printer_t *p,
83 int clear_name);
84 static const char *dnssdErrorString(int error);
85 static void dnssdFreeTxtRecord(cupsd_txt_t *txt);
86 # ifdef HAVE_DNSSD
87 static void dnssdRegisterCallback(DNSServiceRef sdRef,
88 DNSServiceFlags flags,
89 DNSServiceErrorType errorCode,
90 const char *name,
91 const char *regtype,
92 const char *domain,
93 void *context);
94 # else
95 static void dnssdRegisterCallback(AvahiEntryGroup *p,
96 AvahiEntryGroupState state,
97 void *context);
98 # endif /* HAVE_DNSSD */
99 static int dnssdRegisterInstance(cupsd_srv_t *srv,
100 cupsd_printer_t *p,
101 char *name, const char *type,
102 const char *subtypes, int port,
103 cupsd_txt_t *txt, int commit);
104 static void dnssdRegisterPrinter(cupsd_printer_t *p);
105 static void dnssdStop(void);
106 # ifdef HAVE_DNSSD
107 static void dnssdUpdate(void);
108 # endif /* HAVE_DNSSD */
109 #endif /* HAVE_DNSSD || HAVE_AVAHI */
110
111
112 /*
113 * 'cupsdDeregisterPrinter()' - Stop sending broadcast information for a
114 * local printer and remove any pending
115 * references to remote printers.
116 */
117
118 void
119 cupsdDeregisterPrinter(
120 cupsd_printer_t *p, /* I - Printer to register */
121 int removeit) /* I - Printer being permanently removed */
122 {
123 /*
124 * Only deregister if browsing is enabled and it's a local printer...
125 */
126
127 cupsdLogMessage(CUPSD_LOG_DEBUG,
128 "cupsdDeregisterPrinter(p=%p(%s), removeit=%d)", p, p->name,
129 removeit);
130
131 if (!Browsing || !p->shared ||
132 (p->type & (CUPS_PRINTER_REMOTE | CUPS_PRINTER_SCANNER)))
133 return;
134
135 /*
136 * Announce the deletion...
137 */
138
139 #if defined(HAVE_DNSSD) || defined(HAVE_AVAHI)
140 if (removeit && (BrowseLocalProtocols & BROWSE_DNSSD) && DNSSDMaster)
141 dnssdDeregisterPrinter(p, 1);
142 #endif /* HAVE_DNSSD || HAVE_AVAHI */
143 }
144
145
146 /*
147 * 'cupsdRegisterPrinter()' - Start sending broadcast information for a
148 * printer or update the broadcast contents.
149 */
150
151 void
152 cupsdRegisterPrinter(cupsd_printer_t *p)/* I - Printer */
153 {
154 cupsdLogMessage(CUPSD_LOG_DEBUG, "cupsdRegisterPrinter(p=%p(%s))", p,
155 p->name);
156
157 if (!Browsing || !BrowseLocalProtocols ||
158 (p->type & (CUPS_PRINTER_REMOTE | CUPS_PRINTER_SCANNER)))
159 return;
160
161 #if defined(HAVE_DNSSD) || defined(HAVE_AVAHI)
162 if ((BrowseLocalProtocols & BROWSE_DNSSD) && DNSSDMaster)
163 dnssdRegisterPrinter(p);
164 #endif /* HAVE_DNSSD || HAVE_AVAHI */
165 }
166
167
168 /*
169 * 'cupsdStartBrowsing()' - Start sending and receiving broadcast information.
170 */
171
172 void
173 cupsdStartBrowsing(void)
174 {
175 cupsd_printer_t *p; /* Current printer */
176
177
178 if (!Browsing || !BrowseLocalProtocols)
179 return;
180
181 #if defined(HAVE_DNSSD) || defined(HAVE_AVAHI)
182 if (BrowseLocalProtocols & BROWSE_DNSSD)
183 {
184 cupsd_listener_t *lis; /* Current listening socket */
185 # ifdef HAVE_DNSSD
186 DNSServiceErrorType error; /* Error from service creation */
187
188 /*
189 * First create a "master" connection for all registrations...
190 */
191
192 if ((error = DNSServiceCreateConnection(&DNSSDMaster))
193 != kDNSServiceErr_NoError)
194 {
195 cupsdLogMessage(CUPSD_LOG_ERROR,
196 "Unable to create master DNS-SD reference: %d", error);
197
198 if (FatalErrors & CUPSD_FATAL_BROWSE)
199 cupsdEndProcess(getpid(), 0);
200 }
201 else
202 {
203 /*
204 * Add the master connection to the select list...
205 */
206
207 int fd = DNSServiceRefSockFD(DNSSDMaster);
208
209 fcntl(fd, F_SETFD, fcntl(fd, F_GETFD) | FD_CLOEXEC);
210
211 cupsdAddSelect(fd, (cupsd_selfunc_t)dnssdUpdate, NULL, NULL);
212 }
213
214 # else /* HAVE_AVAHI */
215 if ((DNSSDMaster = avahi_threaded_poll_new()) == NULL)
216 {
217 cupsdLogMessage(CUPSD_LOG_ERROR, "Unable to create DNS-SD thread.");
218
219 if (FatalErrors & CUPSD_FATAL_BROWSE)
220 cupsdEndProcess(getpid(), 0);
221 }
222 else
223 {
224 int error; /* Error code, if any */
225
226 DNSSDClient = avahi_client_new(avahi_threaded_poll_get(DNSSDMaster), 0,
227 NULL, NULL, &error);
228
229 if (DNSSDClient == NULL)
230 {
231 cupsdLogMessage(CUPSD_LOG_ERROR,
232 "Unable to communicate with avahi-daemon: %s",
233 dnssdErrorString(error));
234
235 if (FatalErrors & CUPSD_FATAL_BROWSE)
236 cupsdEndProcess(getpid(), 0);
237
238 avahi_threaded_poll_free(DNSSDMaster);
239 DNSSDMaster = NULL;
240 }
241 else
242 avahi_threaded_poll_start(DNSSDMaster);
243 }
244 # endif /* HAVE_DNSSD */
245
246 /*
247 * Then get the port we use for registrations. If we are not listening
248 * on any non-local ports, there is no sense sharing local printers via
249 * Bonjour...
250 */
251
252 DNSSDPort = 0;
253
254 for (lis = (cupsd_listener_t *)cupsArrayFirst(Listeners);
255 lis;
256 lis = (cupsd_listener_t *)cupsArrayNext(Listeners))
257 {
258 if (httpAddrLocalhost(&(lis->address)))
259 continue;
260
261 DNSSDPort = httpAddrPort(&(lis->address));
262 break;
263 }
264
265 /*
266 * Set the computer name and register the web interface...
267 */
268
269 cupsdUpdateDNSSDName();
270 }
271 #endif /* HAVE_DNSSD || HAVE_AVAHI */
272
273 /*
274 * Enable LPD and SMB printer sharing as needed through external programs...
275 */
276
277 if (BrowseLocalProtocols & BROWSE_LPD)
278 update_lpd(1);
279
280 if (BrowseLocalProtocols & BROWSE_SMB)
281 update_smb(1);
282
283 /*
284 * Register the individual printers
285 */
286
287 for (p = (cupsd_printer_t *)cupsArrayFirst(Printers);
288 p;
289 p = (cupsd_printer_t *)cupsArrayNext(Printers))
290 if (!(p->type & (CUPS_PRINTER_REMOTE | CUPS_PRINTER_SCANNER)))
291 cupsdRegisterPrinter(p);
292 }
293
294
295 /*
296 * 'cupsdStopBrowsing()' - Stop sending and receiving broadcast information.
297 */
298
299 void
300 cupsdStopBrowsing(void)
301 {
302 cupsd_printer_t *p; /* Current printer */
303
304
305 if (!Browsing || !BrowseLocalProtocols)
306 return;
307
308 /*
309 * De-register the individual printers
310 */
311
312 for (p = (cupsd_printer_t *)cupsArrayFirst(Printers);
313 p;
314 p = (cupsd_printer_t *)cupsArrayNext(Printers))
315 if (!(p->type & (CUPS_PRINTER_REMOTE | CUPS_PRINTER_SCANNER)))
316 cupsdDeregisterPrinter(p, 1);
317
318 /*
319 * Shut down browsing sockets...
320 */
321
322 #if defined(HAVE_DNSSD) || defined(HAVE_AVAHI)
323 if ((BrowseLocalProtocols & BROWSE_DNSSD) && DNSSDMaster)
324 dnssdStop();
325 #endif /* HAVE_DNSSD || HAVE_AVAHI */
326
327 /*
328 * Disable LPD and SMB printer sharing as needed through external programs...
329 */
330
331 if (BrowseLocalProtocols & BROWSE_LPD)
332 update_lpd(0);
333
334 if (BrowseLocalProtocols & BROWSE_SMB)
335 update_smb(0);
336 }
337
338
339 #if defined(HAVE_DNSSD) || defined(HAVE_AVAHI)
340 /*
341 * 'cupsdUpdateDNSSDName()' - Update the computer name we use for browsing...
342 */
343
344 void
345 cupsdUpdateDNSSDName(void)
346 {
347 char webif[1024]; /* Web interface share name */
348 # ifdef __APPLE__
349 SCDynamicStoreRef sc; /* Context for dynamic store */
350 CFDictionaryRef btmm; /* Back-to-My-Mac domains */
351 CFStringEncoding nameEncoding; /* Encoding of computer name */
352 CFStringRef nameRef; /* Host name CFString */
353 char nameBuffer[1024]; /* C-string buffer */
354 # endif /* __APPLE__ */
355
356
357 /*
358 * Only share the web interface and printers when non-local listening is
359 * enabled...
360 */
361
362 if (!DNSSDPort)
363 return;
364
365 /*
366 * Get the computer name as a c-string...
367 */
368
369 # ifdef __APPLE__
370 sc = SCDynamicStoreCreate(kCFAllocatorDefault, CFSTR("cupsd"), NULL, NULL);
371
372 if (sc)
373 {
374 /*
375 * Get the computer name from the dynamic store...
376 */
377
378 cupsdClearString(&DNSSDComputerName);
379
380 if ((nameRef = SCDynamicStoreCopyComputerName(sc, &nameEncoding)) != NULL)
381 {
382 if (CFStringGetCString(nameRef, nameBuffer, sizeof(nameBuffer),
383 kCFStringEncodingUTF8))
384 {
385 cupsdLogMessage(CUPSD_LOG_DEBUG,
386 "Dynamic store computer name is \"%s\".", nameBuffer);
387 cupsdSetString(&DNSSDComputerName, nameBuffer);
388 }
389
390 CFRelease(nameRef);
391 }
392
393 if (!DNSSDComputerName)
394 {
395 /*
396 * Use the ServerName instead...
397 */
398
399 cupsdLogMessage(CUPSD_LOG_DEBUG,
400 "Using ServerName \"%s\" as computer name.", ServerName);
401 cupsdSetString(&DNSSDComputerName, ServerName);
402 }
403
404 /*
405 * Get the local hostname from the dynamic store...
406 */
407
408 cupsdClearString(&DNSSDHostName);
409
410 if ((nameRef = SCDynamicStoreCopyLocalHostName(sc)) != NULL)
411 {
412 if (CFStringGetCString(nameRef, nameBuffer, sizeof(nameBuffer),
413 kCFStringEncodingUTF8))
414 {
415 cupsdLogMessage(CUPSD_LOG_DEBUG,
416 "Dynamic store host name is \"%s\".", nameBuffer);
417 cupsdSetString(&DNSSDHostName, nameBuffer);
418 }
419
420 CFRelease(nameRef);
421 }
422
423 if (!DNSSDHostName)
424 {
425 /*
426 * Use the ServerName instead...
427 */
428
429 cupsdLogMessage(CUPSD_LOG_DEBUG,
430 "Using ServerName \"%s\" as host name.", ServerName);
431 cupsdSetString(&DNSSDHostName, ServerName);
432 }
433
434 /*
435 * Get any Back-to-My-Mac domains and add them as aliases...
436 */
437
438 cupsdFreeAliases(DNSSDAlias);
439 DNSSDAlias = NULL;
440
441 btmm = SCDynamicStoreCopyValue(sc, CFSTR("Setup:/Network/BackToMyMac"));
442 if (btmm && CFGetTypeID(btmm) == CFDictionaryGetTypeID())
443 {
444 cupsdLogMessage(CUPSD_LOG_DEBUG, "%d Back to My Mac aliases to add.",
445 (int)CFDictionaryGetCount(btmm));
446 CFDictionaryApplyFunction(btmm, dnssdAddAlias, NULL);
447 }
448 else if (btmm)
449 cupsdLogMessage(CUPSD_LOG_ERROR,
450 "Bad Back to My Mac data in dynamic store!");
451 else
452 cupsdLogMessage(CUPSD_LOG_DEBUG, "No Back to My Mac aliases to add.");
453
454 if (btmm)
455 CFRelease(btmm);
456
457 CFRelease(sc);
458 }
459 else
460 # endif /* __APPLE__ */
461 # ifdef HAVE_AVAHI
462 if (DNSSDClient)
463 {
464 const char *host_name = avahi_client_get_host_name(DNSSDClient);
465 const char *host_fqdn = avahi_client_get_host_name_fqdn(DNSSDClient);
466
467 cupsdSetString(&DNSSDComputerName, host_name ? host_name : ServerName);
468
469 if (host_fqdn)
470 cupsdSetString(&DNSSDHostName, host_fqdn);
471 else if (strchr(ServerName, '.'))
472 cupsdSetString(&DNSSDHostName, ServerName);
473 else
474 cupsdSetStringf(&DNSSDHostName, "%s.local", ServerName);
475 }
476 else
477 # endif /* HAVE_AVAHI */
478 {
479 cupsdSetString(&DNSSDComputerName, ServerName);
480
481 if (strchr(ServerName, '.'))
482 cupsdSetString(&DNSSDHostName, ServerName);
483 else
484 cupsdSetStringf(&DNSSDHostName, "%s.local", ServerName);
485 }
486
487 /*
488 * Then (re)register the web interface if enabled...
489 */
490
491 if (BrowseWebIF)
492 {
493 if (DNSSDComputerName)
494 snprintf(webif, sizeof(webif), "CUPS @ %s", DNSSDComputerName);
495 else
496 strlcpy(webif, "CUPS", sizeof(webif));
497
498 dnssdDeregisterInstance(&WebIFSrv);
499 dnssdRegisterInstance(&WebIFSrv, NULL, webif, "_http._tcp", "_printer",
500 DNSSDPort, NULL, 1);
501 }
502 }
503
504
505 # ifdef __APPLE__
506 /*
507 * 'dnssdAddAlias()' - Add a DNS-SD alias name.
508 */
509
510 static void
511 dnssdAddAlias(const void *key, /* I - Key */
512 const void *value, /* I - Value (domain) */
513 void *context) /* I - Unused */
514 {
515 char valueStr[1024], /* Domain string */
516 hostname[1024], /* Complete hostname */
517 *hostptr; /* Pointer into hostname */
518
519
520 (void)key;
521 (void)context;
522
523 if (CFGetTypeID((CFStringRef)value) == CFStringGetTypeID() &&
524 CFStringGetCString((CFStringRef)value, valueStr, sizeof(valueStr),
525 kCFStringEncodingUTF8))
526 {
527 snprintf(hostname, sizeof(hostname), "%s.%s", DNSSDHostName, valueStr);
528 hostptr = hostname + strlen(hostname) - 1;
529 if (*hostptr == '.')
530 *hostptr = '\0'; /* Strip trailing dot */
531
532 if (!DNSSDAlias)
533 DNSSDAlias = cupsArrayNew(NULL, NULL);
534
535 cupsdAddAlias(DNSSDAlias, hostname);
536 cupsdLogMessage(CUPSD_LOG_DEBUG, "Added Back to My Mac ServerAlias %s",
537 hostname);
538 }
539 else
540 cupsdLogMessage(CUPSD_LOG_ERROR,
541 "Bad Back to My Mac domain in dynamic store!");
542 }
543 # endif /* __APPLE__ */
544
545
546 /*
547 * 'dnssdBuildTxtRecord()' - Build a TXT record from printer info.
548 */
549
550 static cupsd_txt_t /* O - TXT record */
551 dnssdBuildTxtRecord(
552 cupsd_printer_t *p, /* I - Printer information */
553 int for_lpd) /* I - 1 = LPD, 0 = IPP */
554 {
555 int i, /* Looping var */
556 count; /* Count of key/value pairs */
557 char admin_hostname[256], /* .local hostname for admin page */
558 adminurl_str[256], /* URL for the admin page */
559 type_str[32], /* Type to string buffer */
560 state_str[32], /* State to string buffer */
561 rp_str[1024], /* Queue name string buffer */
562 air_str[1024], /* auth-info-required string buffer */
563 *keyvalue[32][2]; /* Table of key/value pairs */
564 cupsd_txt_t txt; /* TXT record */
565
566
567 /*
568 * Load up the key value pairs...
569 */
570
571 count = 0;
572
573 if (!for_lpd || (BrowseLocalProtocols & BROWSE_LPD))
574 {
575 keyvalue[count ][0] = "txtvers";
576 keyvalue[count++][1] = "1";
577
578 keyvalue[count ][0] = "qtotal";
579 keyvalue[count++][1] = "1";
580
581 keyvalue[count ][0] = "rp";
582 keyvalue[count++][1] = rp_str;
583 if (for_lpd)
584 strlcpy(rp_str, p->name, sizeof(rp_str));
585 else
586 snprintf(rp_str, sizeof(rp_str), "%s/%s",
587 (p->type & CUPS_PRINTER_CLASS) ? "classes" : "printers",
588 p->name);
589
590 keyvalue[count ][0] = "ty";
591 keyvalue[count++][1] = p->make_model ? p->make_model : "Unknown";
592
593 if (strstr(DNSSDHostName, ".local"))
594 strlcpy(admin_hostname, DNSSDHostName, sizeof(admin_hostname));
595 else
596 snprintf(admin_hostname, sizeof(admin_hostname), "%s.local.",
597 DNSSDHostName);
598 httpAssembleURIf(HTTP_URI_CODING_ALL, adminurl_str, sizeof(adminurl_str),
599 # ifdef HAVE_SSL
600 "https",
601 # else
602 "http",
603 # endif /* HAVE_SSL */
604 NULL, admin_hostname, DNSSDPort, "/%s/%s",
605 (p->type & CUPS_PRINTER_CLASS) ? "classes" : "printers",
606 p->name);
607 keyvalue[count ][0] = "adminurl";
608 keyvalue[count++][1] = adminurl_str;
609
610 if (p->location)
611 {
612 keyvalue[count ][0] = "note";
613 keyvalue[count++][1] = p->location;
614 }
615
616 keyvalue[count ][0] = "priority";
617 keyvalue[count++][1] = for_lpd ? "100" : "0";
618
619 keyvalue[count ][0] = "product";
620 keyvalue[count++][1] = p->pc && p->pc->product ? p->pc->product : "Unknown";
621
622 keyvalue[count ][0] = "pdl";
623 keyvalue[count++][1] = p->pdl ? p->pdl : "application/postscript";
624
625 if (get_auth_info_required(p, air_str, sizeof(air_str)))
626 {
627 keyvalue[count ][0] = "air";
628 keyvalue[count++][1] = air_str;
629 }
630
631 keyvalue[count ][0] = "UUID";
632 keyvalue[count++][1] = p->uuid + 9;
633
634 #ifdef HAVE_SSL
635 keyvalue[count ][0] = "TLS";
636 keyvalue[count++][1] = "1.2";
637 #endif /* HAVE_SSL */
638
639 if (p->type & CUPS_PRINTER_FAX)
640 {
641 keyvalue[count ][0] = "Fax";
642 keyvalue[count++][1] = (p->type & CUPS_PRINTER_FAX) ? "T" : "F";
643 }
644
645 if (p->type & CUPS_PRINTER_COLOR)
646 {
647 keyvalue[count ][0] = "Color";
648 keyvalue[count++][1] = (p->type & CUPS_PRINTER_COLOR) ? "T" : "F";
649 }
650
651 if (p->type & CUPS_PRINTER_DUPLEX)
652 {
653 keyvalue[count ][0] = "Duplex";
654 keyvalue[count++][1] = (p->type & CUPS_PRINTER_DUPLEX) ? "T" : "F";
655 }
656
657 if (p->type & CUPS_PRINTER_STAPLE)
658 {
659 keyvalue[count ][0] = "Staple";
660 keyvalue[count++][1] = (p->type & CUPS_PRINTER_STAPLE) ? "T" : "F";
661 }
662
663 if (p->type & CUPS_PRINTER_COPIES)
664 {
665 keyvalue[count ][0] = "Copies";
666 keyvalue[count++][1] = (p->type & CUPS_PRINTER_COPIES) ? "T" : "F";
667 }
668
669 if (p->type & CUPS_PRINTER_COLLATE)
670 {
671 keyvalue[count ][0] = "Collate";
672 keyvalue[count++][1] = (p->type & CUPS_PRINTER_COLLATE) ? "T" : "F";
673 }
674
675 if (p->type & CUPS_PRINTER_PUNCH)
676 {
677 keyvalue[count ][0] = "Punch";
678 keyvalue[count++][1] = (p->type & CUPS_PRINTER_PUNCH) ? "T" : "F";
679 }
680
681 if (p->type & CUPS_PRINTER_BIND)
682 {
683 keyvalue[count ][0] = "Bind";
684 keyvalue[count++][1] = (p->type & CUPS_PRINTER_BIND) ? "T" : "F";
685 }
686
687 if (p->type & CUPS_PRINTER_SORT)
688 {
689 keyvalue[count ][0] = "Sort";
690 keyvalue[count++][1] = (p->type & CUPS_PRINTER_SORT) ? "T" : "F";
691 }
692
693 if (p->type & CUPS_PRINTER_MFP)
694 {
695 keyvalue[count ][0] = "Scan";
696 keyvalue[count++][1] = (p->type & CUPS_PRINTER_MFP) ? "T" : "F";
697 }
698
699 snprintf(type_str, sizeof(type_str), "0x%X", p->type | CUPS_PRINTER_REMOTE);
700 snprintf(state_str, sizeof(state_str), "%d", p->state);
701
702 keyvalue[count ][0] = "printer-state";
703 keyvalue[count++][1] = state_str;
704
705 keyvalue[count ][0] = "printer-type";
706 keyvalue[count++][1] = type_str;
707 }
708
709 /*
710 * Then pack them into a proper txt record...
711 */
712
713 # ifdef HAVE_DNSSD
714 TXTRecordCreate(&txt, 0, NULL);
715
716 for (i = 0; i < count; i ++)
717 {
718 size_t len = strlen(keyvalue[i][1]);
719
720 if (len < 256)
721 TXTRecordSetValue(&txt, keyvalue[i][0], (uint8_t)len, keyvalue[i][1]);
722 }
723
724 # else
725 for (i = 0, txt = NULL; i < count; i ++)
726 txt = avahi_string_list_add_printf(txt, "%s=%s", keyvalue[i][0],
727 keyvalue[i][1]);
728 # endif /* HAVE_DNSSD */
729
730 return (txt);
731 }
732
733
734 /*
735 * 'dnssdDeregisterInstance()' - Deregister a DNS-SD service instance.
736 */
737
738 static void
739 dnssdDeregisterInstance(
740 cupsd_srv_t *srv) /* I - Service */
741 {
742 if (!srv || !*srv)
743 return;
744
745 # ifdef HAVE_DNSSD
746 DNSServiceRefDeallocate(*srv);
747
748 # else /* HAVE_AVAHI */
749 avahi_threaded_poll_lock(DNSSDMaster);
750 avahi_entry_group_free(*srv);
751 avahi_threaded_poll_unlock(DNSSDMaster);
752 # endif /* HAVE_DNSSD */
753
754 *srv = NULL;
755 }
756
757
758 /*
759 * 'dnssdDeregisterPrinter()' - Deregister all services for a printer.
760 */
761
762 static void
763 dnssdDeregisterPrinter(
764 cupsd_printer_t *p, /* I - Printer */
765 int clear_name) /* I - Clear the name? */
766
767 {
768 cupsdLogMessage(CUPSD_LOG_DEBUG2,
769 "dnssdDeregisterPrinter(p=%p(%s), clear_name=%d)", p, p->name,
770 clear_name);
771
772 if (p->ipp_srv)
773 {
774 dnssdDeregisterInstance(&p->ipp_srv);
775
776 # ifdef HAVE_DNSSD
777 # ifdef HAVE_SSL
778 dnssdDeregisterInstance(&p->ipps_srv);
779 # endif /* HAVE_SSL */
780 dnssdDeregisterInstance(&p->printer_srv);
781 # endif /* HAVE_DNSSD */
782 }
783
784 /*
785 * Remove the printer from the array of DNS-SD printers but keep the
786 * registered name...
787 */
788
789 cupsArrayRemove(DNSSDPrinters, p);
790
791 /*
792 * Optionally clear the service name...
793 */
794
795 if (clear_name)
796 cupsdClearString(&p->reg_name);
797 }
798
799
800 /*
801 * 'dnssdErrorString()' - Return an error string for an error code.
802 */
803
804 static const char * /* O - Error message */
805 dnssdErrorString(int error) /* I - Error number */
806 {
807 # ifdef HAVE_DNSSD
808 switch (error)
809 {
810 case kDNSServiceErr_NoError :
811 return ("OK.");
812
813 default :
814 case kDNSServiceErr_Unknown :
815 return ("Unknown error.");
816
817 case kDNSServiceErr_NoSuchName :
818 return ("Service not found.");
819
820 case kDNSServiceErr_NoMemory :
821 return ("Out of memory.");
822
823 case kDNSServiceErr_BadParam :
824 return ("Bad parameter.");
825
826 case kDNSServiceErr_BadReference :
827 return ("Bad service reference.");
828
829 case kDNSServiceErr_BadState :
830 return ("Bad state.");
831
832 case kDNSServiceErr_BadFlags :
833 return ("Bad flags.");
834
835 case kDNSServiceErr_Unsupported :
836 return ("Unsupported.");
837
838 case kDNSServiceErr_NotInitialized :
839 return ("Not initialized.");
840
841 case kDNSServiceErr_AlreadyRegistered :
842 return ("Already registered.");
843
844 case kDNSServiceErr_NameConflict :
845 return ("Name conflict.");
846
847 case kDNSServiceErr_Invalid :
848 return ("Invalid name.");
849
850 case kDNSServiceErr_Firewall :
851 return ("Firewall prevents registration.");
852
853 case kDNSServiceErr_Incompatible :
854 return ("Client library incompatible.");
855
856 case kDNSServiceErr_BadInterfaceIndex :
857 return ("Bad interface index.");
858
859 case kDNSServiceErr_Refused :
860 return ("Server prevents registration.");
861
862 case kDNSServiceErr_NoSuchRecord :
863 return ("Record not found.");
864
865 case kDNSServiceErr_NoAuth :
866 return ("Authentication required.");
867
868 case kDNSServiceErr_NoSuchKey :
869 return ("Encryption key not found.");
870
871 case kDNSServiceErr_NATTraversal :
872 return ("Unable to traverse NAT boundary.");
873
874 case kDNSServiceErr_DoubleNAT :
875 return ("Unable to traverse double-NAT boundary.");
876
877 case kDNSServiceErr_BadTime :
878 return ("Bad system time.");
879
880 case kDNSServiceErr_BadSig :
881 return ("Bad signature.");
882
883 case kDNSServiceErr_BadKey :
884 return ("Bad encryption key.");
885
886 case kDNSServiceErr_Transient :
887 return ("Transient error occurred - please try again.");
888
889 case kDNSServiceErr_ServiceNotRunning :
890 return ("Server not running.");
891
892 case kDNSServiceErr_NATPortMappingUnsupported :
893 return ("NAT doesn't support NAT-PMP or UPnP.");
894
895 case kDNSServiceErr_NATPortMappingDisabled :
896 return ("NAT supports NAT-PNP or UPnP but it is disabled.");
897
898 case kDNSServiceErr_NoRouter :
899 return ("No Internet/default router configured.");
900
901 case kDNSServiceErr_PollingMode :
902 return ("Service polling mode error.");
903
904 case kDNSServiceErr_Timeout :
905 return ("Service timeout.");
906 }
907
908 # else /* HAVE_AVAHI */
909 return (avahi_strerror(error));
910 # endif /* HAVE_DNSSD */
911 }
912
913
914 /*
915 * 'dnssdRegisterCallback()' - Free a TXT record.
916 */
917
918 static void
919 dnssdFreeTxtRecord(cupsd_txt_t *txt) /* I - TXT record */
920 {
921 # ifdef HAVE_DNSSD
922 TXTRecordDeallocate(txt);
923
924 # else /* HAVE_AVAHI */
925 avahi_string_list_free(*txt);
926 *txt = NULL;
927 # endif /* HAVE_DNSSD */
928 }
929
930
931 /*
932 * 'dnssdRegisterCallback()' - DNSServiceRegister callback.
933 */
934
935 # ifdef HAVE_DNSSD
936 static void
937 dnssdRegisterCallback(
938 DNSServiceRef sdRef, /* I - DNS Service reference */
939 DNSServiceFlags flags, /* I - Reserved for future use */
940 DNSServiceErrorType errorCode, /* I - Error code */
941 const char *name, /* I - Service name */
942 const char *regtype, /* I - Service type */
943 const char *domain, /* I - Domain. ".local" for now */
944 void *context) /* I - Printer */
945 {
946 cupsd_printer_t *p = (cupsd_printer_t *)context;
947 /* Current printer */
948
949
950 (void)sdRef;
951 (void)flags;
952 (void)domain;
953
954 cupsdLogMessage(CUPSD_LOG_DEBUG2, "dnssdRegisterCallback(%s, %s) for %s (%s)",
955 name, regtype, p ? p->name : "Web Interface",
956 p ? (p->reg_name ? p->reg_name : "(null)") : "NA");
957
958 if (errorCode)
959 {
960 cupsdLogMessage(CUPSD_LOG_ERROR,
961 "DNSServiceRegister failed with error %d", (int)errorCode);
962 return;
963 }
964 else if (p && (!p->reg_name || _cups_strcasecmp(name, p->reg_name)))
965 {
966 cupsdLogMessage(CUPSD_LOG_INFO, "Using service name \"%s\" for \"%s\"",
967 name, p->name);
968
969 cupsArrayRemove(DNSSDPrinters, p);
970 cupsdSetString(&p->reg_name, name);
971 cupsArrayAdd(DNSSDPrinters, p);
972
973 LastEvent |= CUPSD_EVENT_PRINTER_MODIFIED;
974 }
975 }
976
977 # else /* HAVE_AVAHI */
978 static void
979 dnssdRegisterCallback(
980 AvahiEntryGroup *srv, /* I - Service */
981 AvahiEntryGroupState state, /* I - Registration state */
982 void *context) /* I - Printer */
983 {
984 cupsd_printer_t *p = (cupsd_printer_t *)context;
985 /* Current printer */
986
987 cupsdLogMessage(CUPSD_LOG_DEBUG2,
988 "dnssdRegisterCallback(srv=%p, state=%d, context=%p) "
989 "for %s (%s)", srv, state, context,
990 p ? p->name : "Web Interface",
991 p ? (p->reg_name ? p->reg_name : "(null)") : "NA");
992
993 /* TODO: Handle collisions with avahi_alternate_service_name(p->reg_name)? */
994 }
995 # endif /* HAVE_DNSSD */
996
997
998 /*
999 * 'dnssdRegisterInstance()' - Register an instance of a printer service.
1000 */
1001
1002 static int /* O - 1 on success, 0 on failure */
1003 dnssdRegisterInstance(
1004 cupsd_srv_t *srv, /* O - Service */
1005 cupsd_printer_t *p, /* I - Printer */
1006 char *name, /* I - DNS-SD service name */
1007 const char *type, /* I - DNS-SD service type */
1008 const char *subtypes, /* I - Subtypes to register or NULL */
1009 int port, /* I - Port number or 0 */
1010 cupsd_txt_t *txt, /* I - TXT record */
1011 int commit) /* I - Commit registration? */
1012 {
1013 char temp[256], /* Temporary string */
1014 *ptr; /* Pointer into string */
1015 int error; /* Any error */
1016
1017
1018 cupsdLogMessage(CUPSD_LOG_DEBUG,
1019 "Registering \"%s\" with DNS-SD type \"%s\".", name, type);
1020
1021 if (p && !srv)
1022 {
1023 /*
1024 * Assign the correct pointer for "srv"...
1025 */
1026
1027 # ifdef HAVE_DNSSD
1028 if (!strcmp(type, "_printer._tcp"))
1029 srv = &p->printer_srv; /* Target LPD service */
1030 # ifdef HAVE_SSL
1031 else if (!strcmp(type, "_ipps._tcp"))
1032 srv = &p->ipps_srv; /* Target IPPS service */
1033 # endif /* HAVE_SSL */
1034 else
1035 srv = &p->ipp_srv; /* Target IPP service */
1036
1037 # else /* HAVE_AVAHI */
1038 srv = &p->ipp_srv; /* Target service group */
1039 # endif /* HAVE_DNSSD */
1040 }
1041
1042 # ifdef HAVE_DNSSD
1043 (void)commit;
1044
1045 # else /* HAVE_AVAHI */
1046 avahi_threaded_poll_lock(DNSSDMaster);
1047
1048 if (!*srv)
1049 *srv = avahi_entry_group_new(DNSSDClient, dnssdRegisterCallback, NULL);
1050 if (!*srv)
1051 {
1052 avahi_threaded_poll_unlock(DNSSDMaster);
1053
1054 cupsdLogMessage(CUPSD_LOG_WARN, "DNS-SD registration of \"%s\" failed: %s",
1055 name, dnssdErrorString(avahi_client_errno(DNSSDClient)));
1056 return (0);
1057 }
1058 # endif /* HAVE_DNSSD */
1059
1060 /*
1061 * Make sure the name is <= 63 octets, and when we truncate be sure to
1062 * properly truncate any UTF-8 characters...
1063 */
1064
1065 ptr = name + strlen(name);
1066 while ((ptr - name) > 63)
1067 {
1068 do
1069 {
1070 ptr --;
1071 }
1072 while (ptr > name && (*ptr & 0xc0) == 0x80);
1073
1074 if (ptr > name)
1075 *ptr = '\0';
1076 }
1077
1078 /*
1079 * Register the service...
1080 */
1081
1082 # ifdef HAVE_DNSSD
1083 if (subtypes)
1084 snprintf(temp, sizeof(temp), "%s,%s", type, subtypes);
1085 else
1086 strlcpy(temp, type, sizeof(temp));
1087
1088 *srv = DNSSDMaster;
1089 error = DNSServiceRegister(srv, kDNSServiceFlagsShareConnection,
1090 0, name, temp, NULL, NULL, htons(port),
1091 txt ? TXTRecordGetLength(txt) : 0,
1092 txt ? TXTRecordGetBytesPtr(txt) : NULL,
1093 dnssdRegisterCallback, p);
1094
1095 # else /* HAVE_AVAHI */
1096 if (txt)
1097 {
1098 AvahiStringList *temptxt;
1099 for (temptxt = *txt; temptxt; temptxt = temptxt->next)
1100 cupsdLogMessage(CUPSD_LOG_DEBUG, "DNS_SD \"%s\" %s", name, temptxt->text);
1101 }
1102
1103 error = avahi_entry_group_add_service_strlst(*srv, AVAHI_IF_UNSPEC,
1104 AVAHI_PROTO_UNSPEC, 0, name,
1105 type, NULL, NULL, port,
1106 txt ? *txt : NULL);
1107 if (error)
1108 cupsdLogMessage(CUPSD_LOG_DEBUG, "DNS-SD service add for \"%s\" failed.",
1109 name);
1110
1111 if (!error && subtypes)
1112 {
1113 /*
1114 * Register all of the subtypes...
1115 */
1116
1117 char *start, /* Start of subtype */
1118 subtype[256]; /* Subtype string */
1119
1120 strlcpy(temp, subtypes, sizeof(temp));
1121
1122 for (start = temp; *start; start = ptr)
1123 {
1124 /*
1125 * Skip leading whitespace...
1126 */
1127
1128 while (*start && isspace(*start & 255))
1129 start ++;
1130
1131 /*
1132 * Grab everything up to the next comma or the end of the string...
1133 */
1134
1135 for (ptr = start; *ptr && *ptr != ','; ptr ++);
1136
1137 if (*ptr)
1138 *ptr++ = '\0';
1139
1140 if (!*start)
1141 break;
1142
1143 /*
1144 * Register the subtype...
1145 */
1146
1147 snprintf(subtype, sizeof(subtype), "%s._sub.%s", start, type);
1148
1149 error = avahi_entry_group_add_service_subtype(*srv, AVAHI_IF_UNSPEC,
1150 AVAHI_PROTO_UNSPEC, 0,
1151 name, type, NULL, subtype);
1152 if (error)
1153 {
1154 cupsdLogMessage(CUPSD_LOG_DEBUG,
1155 "DNS-SD subtype %s registration for \"%s\" failed." ,
1156 subtype, name);
1157 break;
1158 }
1159 }
1160 }
1161
1162 if (!error && commit)
1163 {
1164 if ((error = avahi_entry_group_commit(*srv)) != 0)
1165 cupsdLogMessage(CUPSD_LOG_DEBUG, "DNS-SD commit of \"%s\" failed.",
1166 name);
1167 }
1168
1169 avahi_threaded_poll_unlock(DNSSDMaster);
1170 # endif /* HAVE_DNSSD */
1171
1172 if (error)
1173 {
1174 cupsdLogMessage(CUPSD_LOG_WARN, "DNS-SD registration of \"%s\" failed: %s",
1175 name, dnssdErrorString(error));
1176 cupsdLogMessage(CUPSD_LOG_DEBUG, "DNS-SD type: %s", type);
1177 if (subtypes)
1178 cupsdLogMessage(CUPSD_LOG_DEBUG, "DNS-SD sub-types: %s", subtypes);
1179 }
1180
1181 return (!error);
1182 }
1183
1184
1185 /*
1186 * 'dnssdRegisterPrinter()' - Start sending broadcast information for a printer
1187 * or update the broadcast contents.
1188 */
1189
1190 static void
1191 dnssdRegisterPrinter(cupsd_printer_t *p)/* I - Printer */
1192 {
1193 char name[256]; /* Service name */
1194 int printer_port; /* LPD port number */
1195 int status; /* Registration status */
1196 cupsd_txt_t ipp_txt, /* IPP(S) TXT record */
1197 printer_txt; /* LPD TXT record */
1198
1199 cupsdLogMessage(CUPSD_LOG_DEBUG2, "dnssdRegisterPrinter(%s) %s", p->name,
1200 !p->ipp_srv ? "new" : "update");
1201
1202 /*
1203 * Remove the current registrations if we have them and then return if
1204 * per-printer sharing was just disabled...
1205 */
1206
1207 dnssdDeregisterPrinter(p, 0);
1208
1209 if (!p->shared)
1210 return;
1211
1212 /*
1213 * Set the registered name as needed; the registered name takes the form of
1214 * "<printer-info> @ <computer name>"...
1215 */
1216
1217 if (!p->reg_name)
1218 {
1219 if (p->info && strlen(p->info) > 0)
1220 {
1221 if (DNSSDComputerName)
1222 snprintf(name, sizeof(name), "%s @ %s", p->info, DNSSDComputerName);
1223 else
1224 strlcpy(name, p->info, sizeof(name));
1225 }
1226 else if (DNSSDComputerName)
1227 snprintf(name, sizeof(name), "%s @ %s", p->name, DNSSDComputerName);
1228 else
1229 strlcpy(name, p->name, sizeof(name));
1230 }
1231 else
1232 strlcpy(name, p->reg_name, sizeof(name));
1233
1234 /*
1235 * Register IPP and LPD...
1236 *
1237 * We always must register the "_printer" service type in order to reserve
1238 * our name, but use port number 0 if we haven't actually configured cups-lpd
1239 * to share via LPD...
1240 */
1241
1242 ipp_txt = dnssdBuildTxtRecord(p, 0);
1243 printer_txt = dnssdBuildTxtRecord(p, 1);
1244
1245 if (BrowseLocalProtocols & BROWSE_LPD)
1246 printer_port = 515;
1247 else
1248 printer_port = 0;
1249
1250 status = dnssdRegisterInstance(NULL, p, name, "_printer._tcp", NULL,
1251 printer_port, &printer_txt, 0);
1252
1253 # ifdef HAVE_SSL
1254 if (status)
1255 dnssdRegisterInstance(NULL, p, name, "_ipps._tcp", DNSSDSubTypes,
1256 DNSSDPort, &ipp_txt, 0);
1257 # endif /* HAVE_SSL */
1258
1259 if (status)
1260 {
1261 /*
1262 * Use the "_fax-ipp" service type for fax queues, otherwise use "_ipp"...
1263 */
1264
1265 if (p->type & CUPS_PRINTER_FAX)
1266 status = dnssdRegisterInstance(NULL, p, name, "_fax-ipp._tcp",
1267 DNSSDSubTypes, DNSSDPort, &ipp_txt, 1);
1268 else
1269 status = dnssdRegisterInstance(NULL, p, name, "_ipp._tcp", DNSSDSubTypes,
1270 DNSSDPort, &ipp_txt, 1);
1271 }
1272
1273 dnssdFreeTxtRecord(&ipp_txt);
1274 dnssdFreeTxtRecord(&printer_txt);
1275
1276 if (status)
1277 {
1278 /*
1279 * Save the registered name and add the printer to the array of DNS-SD
1280 * printers...
1281 */
1282
1283 cupsdSetString(&p->reg_name, name);
1284 cupsArrayAdd(DNSSDPrinters, p);
1285 }
1286 else
1287 {
1288 /*
1289 * Registration failed for this printer...
1290 */
1291
1292 dnssdDeregisterInstance(&p->ipp_srv);
1293
1294 # ifdef HAVE_DNSSD
1295 # ifdef HAVE_SSL
1296 dnssdDeregisterInstance(&p->ipps_srv);
1297 # endif /* HAVE_SSL */
1298 dnssdDeregisterInstance(&p->printer_srv);
1299 # endif /* HAVE_DNSSD */
1300 }
1301 }
1302
1303
1304 /*
1305 * 'dnssdStop()' - Stop all DNS-SD registrations.
1306 */
1307
1308 static void
1309 dnssdStop(void)
1310 {
1311 cupsd_printer_t *p; /* Current printer */
1312
1313
1314 /*
1315 * De-register the individual printers
1316 */
1317
1318 for (p = (cupsd_printer_t *)cupsArrayFirst(Printers);
1319 p;
1320 p = (cupsd_printer_t *)cupsArrayNext(Printers))
1321 dnssdDeregisterPrinter(p, 1);
1322
1323 /*
1324 * Shutdown the rest of the service refs...
1325 */
1326
1327 dnssdDeregisterInstance(&WebIFSrv);
1328
1329 # ifdef HAVE_DNSSD
1330 cupsdRemoveSelect(DNSServiceRefSockFD(DNSSDMaster));
1331
1332 DNSServiceRefDeallocate(DNSSDMaster);
1333 DNSSDMaster = NULL;
1334
1335 # else /* HAVE_AVAHI */
1336 avahi_threaded_poll_stop(DNSSDMaster);
1337
1338 avahi_client_free(DNSSDClient);
1339 DNSSDClient = NULL;
1340
1341 avahi_threaded_poll_free(DNSSDMaster);
1342 DNSSDMaster = NULL;
1343 # endif /* HAVE_DNSSD */
1344
1345 cupsArrayDelete(DNSSDPrinters);
1346 DNSSDPrinters = NULL;
1347
1348 DNSSDPort = 0;
1349 }
1350
1351
1352 # ifdef HAVE_DNSSD
1353 /*
1354 * 'dnssdUpdate()' - Handle DNS-SD queries.
1355 */
1356
1357 static void
1358 dnssdUpdate(void)
1359 {
1360 DNSServiceErrorType sdErr; /* Service discovery error */
1361
1362
1363 if ((sdErr = DNSServiceProcessResult(DNSSDMaster)) != kDNSServiceErr_NoError)
1364 {
1365 cupsdLogMessage(CUPSD_LOG_ERROR,
1366 "DNS Service Discovery registration error %d!",
1367 sdErr);
1368 dnssdStop();
1369 }
1370 }
1371 # endif /* HAVE_DNSSD */
1372
1373
1374 /*
1375 * 'get_auth_info_required()' - Get the auth-info-required value to advertise.
1376 */
1377
1378 static char * /* O - String or NULL if none */
1379 get_auth_info_required(
1380 cupsd_printer_t *p, /* I - Printer */
1381 char *buffer, /* I - Value buffer */
1382 size_t bufsize) /* I - Size of value buffer */
1383 {
1384 cupsd_location_t *auth; /* Pointer to authentication element */
1385 char resource[1024]; /* Printer/class resource path */
1386
1387
1388 /*
1389 * If auth-info-required is set for this printer, return that...
1390 */
1391
1392 if (p->num_auth_info_required > 0 && strcmp(p->auth_info_required[0], "none"))
1393 {
1394 int i; /* Looping var */
1395 char *bufptr; /* Pointer into buffer */
1396
1397 for (i = 0, bufptr = buffer; i < p->num_auth_info_required; i ++)
1398 {
1399 if (bufptr >= (buffer + bufsize - 2))
1400 break;
1401
1402 if (i)
1403 *bufptr++ = ',';
1404
1405 strlcpy(bufptr, p->auth_info_required[i], bufsize - (bufptr - buffer));
1406 bufptr += strlen(bufptr);
1407 }
1408
1409 return (buffer);
1410 }
1411
1412 /*
1413 * Figure out the authentication data requirements to advertise...
1414 */
1415
1416 if (p->type & CUPS_PRINTER_CLASS)
1417 snprintf(resource, sizeof(resource), "/classes/%s", p->name);
1418 else
1419 snprintf(resource, sizeof(resource), "/printers/%s", p->name);
1420
1421 if ((auth = cupsdFindBest(resource, HTTP_POST)) == NULL ||
1422 auth->type == CUPSD_AUTH_NONE)
1423 auth = cupsdFindPolicyOp(p->op_policy_ptr, IPP_PRINT_JOB);
1424
1425 if (auth)
1426 {
1427 int auth_type; /* Authentication type */
1428
1429 if ((auth_type = auth->type) == CUPSD_AUTH_DEFAULT)
1430 auth_type = cupsdDefaultAuthType();
1431
1432 switch (auth_type)
1433 {
1434 case CUPSD_AUTH_NONE :
1435 return (NULL);
1436
1437 case CUPSD_AUTH_NEGOTIATE :
1438 strlcpy(buffer, "negotiate", bufsize);
1439 break;
1440
1441 default :
1442 strlcpy(buffer, "username,password", bufsize);
1443 break;
1444 }
1445
1446 return (buffer);
1447 }
1448
1449 return ("none");
1450 }
1451 #endif /* HAVE_DNSSD || HAVE_AVAHI */
1452
1453
1454 #ifdef __APPLE__
1455 /*
1456 * 'get_hostconfig()' - Get an /etc/hostconfig service setting.
1457 */
1458
1459 static int /* O - 1 for YES or AUTOMATIC, 0 for NO */
1460 get_hostconfig(const char *name) /* I - Name of service */
1461 {
1462 cups_file_t *fp; /* Hostconfig file */
1463 char line[1024], /* Line from file */
1464 *ptr; /* Pointer to value */
1465 int state = 1; /* State of service */
1466
1467
1468 /*
1469 * Try opening the /etc/hostconfig file; if we can't open it, assume that
1470 * the service is enabled/auto.
1471 */
1472
1473 if ((fp = cupsFileOpen("/etc/hostconfig", "r")) != NULL)
1474 {
1475 /*
1476 * Read lines from the file until we find the service...
1477 */
1478
1479 while (cupsFileGets(fp, line, sizeof(line)))
1480 {
1481 if (line[0] == '#' || (ptr = strchr(line, '=')) == NULL)
1482 continue;
1483
1484 *ptr++ = '\0';
1485
1486 if (!_cups_strcasecmp(line, name))
1487 {
1488 /*
1489 * Found the service, see if it is set to "-NO-"...
1490 */
1491
1492 if (!_cups_strncasecmp(ptr, "-NO-", 4))
1493 state = 0;
1494 break;
1495 }
1496 }
1497
1498 cupsFileClose(fp);
1499 }
1500
1501 return (state);
1502 }
1503 #endif /* __APPLE__ */
1504
1505
1506 /*
1507 * 'update_lpd()' - Update the LPD configuration as needed.
1508 */
1509
1510 static void
1511 update_lpd(int onoff) /* - 1 = turn on, 0 = turn off */
1512 {
1513 if (!LPDConfigFile)
1514 return;
1515
1516 #ifdef __APPLE__
1517 /*
1518 * Allow /etc/hostconfig CUPS_LPD service setting to override cupsd.conf
1519 * setting for backwards-compatibility.
1520 */
1521
1522 if (onoff && !get_hostconfig("CUPS_LPD"))
1523 onoff = 0;
1524 #endif /* __APPLE__ */
1525
1526 if (!strncmp(LPDConfigFile, "xinetd:///", 10))
1527 {
1528 /*
1529 * Enable/disable LPD via the xinetd.d config file for cups-lpd...
1530 */
1531
1532 char newfile[1024]; /* New cups-lpd.N file */
1533 cups_file_t *ofp, /* Original file pointer */
1534 *nfp; /* New file pointer */
1535 char line[1024]; /* Line from file */
1536
1537
1538 snprintf(newfile, sizeof(newfile), "%s.N", LPDConfigFile + 9);
1539
1540 if ((ofp = cupsFileOpen(LPDConfigFile + 9, "r")) == NULL)
1541 {
1542 cupsdLogMessage(CUPSD_LOG_ERROR, "Unable to open \"%s\" - %s",
1543 LPDConfigFile + 9, strerror(errno));
1544 return;
1545 }
1546
1547 if ((nfp = cupsFileOpen(newfile, "w")) == NULL)
1548 {
1549 cupsdLogMessage(CUPSD_LOG_ERROR, "Unable to create \"%s\" - %s",
1550 newfile, strerror(errno));
1551 cupsFileClose(ofp);
1552 return;
1553 }
1554
1555 /*
1556 * Copy all of the lines from the cups-lpd file...
1557 */
1558
1559 while (cupsFileGets(ofp, line, sizeof(line)))
1560 {
1561 if (line[0] == '{')
1562 {
1563 cupsFilePrintf(nfp, "%s\n", line);
1564 snprintf(line, sizeof(line), "\tdisable = %s",
1565 onoff ? "no" : "yes");
1566 }
1567 else if (!strstr(line, "disable ="))
1568 cupsFilePrintf(nfp, "%s\n", line);
1569 }
1570
1571 cupsFileClose(nfp);
1572 cupsFileClose(ofp);
1573 rename(newfile, LPDConfigFile + 9);
1574 }
1575 #ifdef __APPLE__
1576 else if (!strncmp(LPDConfigFile, "launchd:///", 11))
1577 {
1578 /*
1579 * Enable/disable LPD via the launchctl command...
1580 */
1581
1582 char *argv[5], /* Arguments for command */
1583 *envp[MAX_ENV]; /* Environment for command */
1584 int pid; /* Process ID */
1585
1586
1587 cupsdLoadEnv(envp, (int)(sizeof(envp) / sizeof(envp[0])));
1588 argv[0] = (char *)"launchctl";
1589 argv[1] = (char *)(onoff ? "load" : "unload");
1590 argv[2] = (char *)"-w";
1591 argv[3] = LPDConfigFile + 10;
1592 argv[4] = NULL;
1593
1594 cupsdStartProcess("/bin/launchctl", argv, envp, -1, -1, -1, -1, -1, 1,
1595 NULL, NULL, &pid);
1596 }
1597 #endif /* __APPLE__ */
1598 else
1599 cupsdLogMessage(CUPSD_LOG_INFO, "Unknown LPDConfigFile scheme!");
1600 }
1601
1602
1603 /*
1604 * 'update_smb()' - Update the SMB configuration as needed.
1605 */
1606
1607 static void
1608 update_smb(int onoff) /* I - 1 = turn on, 0 = turn off */
1609 {
1610 if (!SMBConfigFile)
1611 return;
1612
1613 if (!strncmp(SMBConfigFile, "samba:///", 9))
1614 {
1615 /*
1616 * Enable/disable SMB via the specified smb.conf config file...
1617 */
1618
1619 char newfile[1024]; /* New smb.conf.N file */
1620 cups_file_t *ofp, /* Original file pointer */
1621 *nfp; /* New file pointer */
1622 char line[1024]; /* Line from file */
1623 int in_printers; /* In [printers] section? */
1624
1625
1626 snprintf(newfile, sizeof(newfile), "%s.N", SMBConfigFile + 8);
1627
1628 if ((ofp = cupsFileOpen(SMBConfigFile + 8, "r")) == NULL)
1629 {
1630 cupsdLogMessage(CUPSD_LOG_ERROR, "Unable to open \"%s\" - %s",
1631 SMBConfigFile + 8, strerror(errno));
1632 return;
1633 }
1634
1635 if ((nfp = cupsFileOpen(newfile, "w")) == NULL)
1636 {
1637 cupsdLogMessage(CUPSD_LOG_ERROR, "Unable to create \"%s\" - %s",
1638 newfile, strerror(errno));
1639 cupsFileClose(ofp);
1640 return;
1641 }
1642
1643 /*
1644 * Copy all of the lines from the smb.conf file...
1645 */
1646
1647 in_printers = 0;
1648
1649 while (cupsFileGets(ofp, line, sizeof(line)))
1650 {
1651 if (in_printers && strstr(line, "printable ="))
1652 snprintf(line, sizeof(line), " printable = %s",
1653 onoff ? "yes" : "no");
1654
1655 cupsFilePrintf(nfp, "%s\n", line);
1656
1657 if (line[0] == '[')
1658 in_printers = !strcmp(line, "[printers]");
1659 }
1660
1661 cupsFileClose(nfp);
1662 cupsFileClose(ofp);
1663 rename(newfile, SMBConfigFile + 8);
1664 }
1665 else
1666 cupsdLogMessage(CUPSD_LOG_INFO, "Unknown SMBConfigFile scheme!");
1667 }
1668
1669
1670 /*
1671 * End of "$Id$".
1672 */
Unnamed repository; edit this file 'description' to name the repository.