scheduler/dirsvc.c

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