source3/printing/nt_printing_ads.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *  RPC Pipe client / server routines
   4  *  Copyright (C) Andrew Tridgell              1992-2000,
   5  *  Copyright (C) Jean François Micouleau      1998-2000.
   6  *  Copyright (C) Gerald Carter                2002-2005.
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 3 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22 #include "includes.h"
  23 #include "../librpc/gen_ndr/spoolss.h"
  24 #include "rpc_server/spoolss/srv_spoolss_util.h"
  25 #include "nt_printing.h"
  26 #include "ads.h"
  27 #include "secrets.h"
  28 #include "krb5_env.h"
  29 #include "../libcli/registry/util_reg.h"
  30 #include "auth.h"
  31 #include "../librpc/ndr/libndr.h"
  32 #include "rpc_client/cli_winreg_spoolss.h"
  33
  34 #ifdef HAVE_ADS
  35 /*****************************************************************
  36  ****************************************************************/
  37
  38 WERROR nt_printer_guid_store(struct messaging_context *msg_ctx,
  39                              const char *printer, struct GUID guid)
  40 {
  41         TALLOC_CTX *tmp_ctx;
  42         const struct auth_session_info *session_info;
  43         const char *guid_str;
  44         DATA_BLOB blob;
  45         WERROR result;
  46
  47         tmp_ctx = talloc_new(NULL);
  48         if (!tmp_ctx) {
  49                 DEBUG(0, ("Out of memory?!\n"));
  50                 return WERR_NOMEM;
  51         }
  52
  53         session_info = get_session_info_system();
  54         if (session_info == NULL) {
  55                 DEBUG(0, ("Could not get system session_info\n"));
  56                 result = WERR_NOMEM;
  57                 goto done;
  58         }
  59
  60         guid_str = GUID_string(tmp_ctx, &guid);
  61         if (!guid_str) {
  62                 DEBUG(0, ("Out of memory?!\n"));
  63                 result = WERR_NOMEM;
  64                 goto done;
  65         }
  66
  67         /* We used to store this as a REG_BINARY but that causes
  68            Vista to whine */
  69
  70         if (!push_reg_sz(tmp_ctx, &blob, guid_str)) {
  71                 DEBUG(0, ("Could not marshall string %s for objectGUID\n",
  72                           guid_str));
  73                 result = WERR_NOMEM;
  74                 goto done;
  75         }
  76
  77         result = winreg_set_printer_dataex_internal(tmp_ctx, session_info, msg_ctx,
  78                                            printer,
  79                                            SPOOL_DSSPOOLER_KEY, "objectGUID",
  80                                            REG_SZ, blob.data, blob.length);
  81         if (!W_ERROR_IS_OK(result)) {
  82                 DEBUG(0, ("Failed to store GUID for printer %s\n", printer));
  83                 goto done;
  84         }
  85
  86         result = WERR_OK;
  87 done:
  88         talloc_free(tmp_ctx);
  89
  90         return result;
  91 }
  92
  93 static WERROR nt_printer_dn_lookup(TALLOC_CTX *mem_ctx,
  94                                    ADS_STRUCT *ads,
  95                                    const char *printer,
  96                                    char **pprinter_dn)
  97 {
  98         char *printer_dn = NULL;
  99         char *srv_dn = NULL;
 100         char *srv_cn_0 = NULL;
 101         char *srv_cn_escaped = NULL;
 102         char *sharename_escaped = NULL;
 103         char *srv_dn_utf8 = NULL;
 104         char **srv_cn_utf8 = NULL;
 105         size_t converted_size;
 106         ADS_STATUS ads_status;
 107         LDAPMessage *res;
 108         WERROR result;
 109         bool ok;
 110
 111         ads_status = ads_find_machine_acct(ads, &res, lp_netbios_name());
 112         if (!ADS_ERR_OK(ads_status)) {
 113                 DEBUG(2, ("Failed to find machine account for %s\n",
 114                           lp_netbios_name()));
 115                 result = WERR_NOT_FOUND;
 116                 goto err_out;
 117         }
 118
 119         /*
 120          * We use ldap_get_dn here as we need the answer in utf8 to call
 121          * ldap_explode_dn(). JRA.
 122          */
 123         srv_dn_utf8 = ldap_get_dn((LDAP *)ads->ldap.ld, (LDAPMessage *)res);
 124         ads_msgfree(ads, res);
 125         if (srv_dn_utf8 == NULL) {
 126                 result = WERR_SERVER_UNAVAILABLE;
 127                 goto err_out;
 128         }
 129
 130         srv_cn_utf8 = ldap_explode_dn(srv_dn_utf8, 1);
 131         if (srv_cn_utf8 == NULL) {
 132                 ldap_memfree(srv_dn_utf8);
 133                 result = WERR_SERVER_UNAVAILABLE;
 134                 goto err_out;
 135         }
 136
 137         /* Now convert to CH_UNIX. */
 138         ok = pull_utf8_talloc(mem_ctx, &srv_dn, srv_dn_utf8, &converted_size);
 139         ldap_memfree(srv_dn_utf8);
 140         if (!ok) {
 141                 ldap_memfree(srv_cn_utf8);
 142                 result = WERR_SERVER_UNAVAILABLE;
 143                 goto err_out;
 144         }
 145
 146         ok = pull_utf8_talloc(mem_ctx, &srv_cn_0, srv_cn_utf8[0], &converted_size);
 147         ldap_memfree(srv_cn_utf8);
 148         if (!ok) {
 149                 result = WERR_SERVER_UNAVAILABLE;
 150                 goto err_out;
 151         }
 152
 153         srv_cn_escaped = escape_rdn_val_string_alloc(srv_cn_0);
 154         if (srv_cn_escaped == NULL) {
 155                 result = WERR_SERVER_UNAVAILABLE;
 156                 goto err_out;
 157         }
 158
 159         sharename_escaped = escape_rdn_val_string_alloc(printer);
 160         if (sharename_escaped == NULL) {
 161                 result = WERR_SERVER_UNAVAILABLE;
 162                 goto err_out;
 163         }
 164
 165         printer_dn = talloc_asprintf(mem_ctx,
 166                                      "cn=%s-%s,%s",
 167                                      srv_cn_escaped,
 168                                      sharename_escaped,
 169                                      srv_dn);
 170         if (printer_dn == NULL) {
 171                 result = WERR_NOMEM;
 172                 goto err_out;
 173         }
 174
 175         *pprinter_dn = printer_dn;
 176
 177         result = WERR_OK;
 178 err_out:
 179         SAFE_FREE(sharename_escaped);
 180         SAFE_FREE(srv_cn_escaped);
 181         TALLOC_FREE(srv_cn_0);
 182         TALLOC_FREE(srv_dn);
 183         return result;
 184 }
 185
 186 static WERROR nt_printer_guid_retrieve_internal(ADS_STRUCT *ads,
 187                                                 const char *printer_dn,
 188                                                 struct GUID *pguid)
 189 {
 190         ADS_STATUS ads_status;
 191         LDAPMessage *res;
 192         const char *attrs[] = {"objectGUID", NULL};
 193         struct GUID guid;
 194         bool ok;
 195
 196         ads_status = ads_search_dn(ads, &res, printer_dn, attrs);
 197         if (!ADS_ERR_OK(ads_status)) {
 198                 DEBUG(2, ("Failed to retrieve GUID from DC - %s\n",
 199                           ads_errstr(ads_status)));
 200                 return WERR_BADFILE;
 201         }
 202
 203         ZERO_STRUCT(guid);
 204         ok = ads_pull_guid(ads, res, &guid);
 205         ads_msgfree(ads, res);
 206         if (!ok) {
 207                 return WERR_NOMEM;
 208         }
 209
 210         *pguid = guid;
 211
 212         return WERR_OK;
 213 }
 214
 215 WERROR nt_printer_guid_retrieve(TALLOC_CTX *mem_ctx, const char *printer,
 216                                 struct GUID *pguid)
 217 {
 218         ADS_STRUCT *ads = NULL;
 219         char *old_krb5ccname = NULL;
 220         char *printer_dn;
 221         WERROR result;
 222         ADS_STATUS ads_status;
 223         TALLOC_CTX *tmp_ctx;
 224
 225         tmp_ctx = talloc_new(mem_ctx);
 226         if (tmp_ctx == NULL) {
 227                 return WERR_NOMEM;
 228         }
 229
 230         ads = ads_init(lp_realm(), lp_workgroup(), NULL);
 231         if (ads == NULL) {
 232                 result = WERR_SERVER_UNAVAILABLE;
 233                 goto out;
 234         }
 235
 236         old_krb5ccname = getenv(KRB5_ENV_CCNAME);
 237         setenv(KRB5_ENV_CCNAME, "MEMORY:prtpub_cache", 1);
 238         SAFE_FREE(ads->auth.password);
 239         ads->auth.password = secrets_fetch_machine_password(lp_workgroup(),
 240                                                             NULL, NULL);
 241
 242         ads_status = ads_connect(ads);
 243         if (!ADS_ERR_OK(ads_status)) {
 244                 DEBUG(3, ("ads_connect failed: %s\n", ads_errstr(ads_status)));
 245                 result = WERR_ACCESS_DENIED;
 246                 goto out;
 247         }
 248
 249         result = nt_printer_dn_lookup(tmp_ctx, ads, printer, &printer_dn);
 250         if (!W_ERROR_IS_OK(result)) {
 251                 goto out;
 252         }
 253
 254         result = nt_printer_guid_retrieve_internal(ads, printer_dn, pguid);
 255 out:
 256         TALLOC_FREE(tmp_ctx);
 257         ads_destroy(&ads);
 258         ads_kdestroy("MEMORY:prtpub_cache");
 259         unsetenv(KRB5_ENV_CCNAME);
 260         if (old_krb5ccname != NULL) {
 261                 setenv(KRB5_ENV_CCNAME, old_krb5ccname, 0);
 262         }
 263
 264         return result;
 265 }
 266
 267 WERROR nt_printer_guid_get(TALLOC_CTX *mem_ctx,
 268                            const struct auth_session_info *session_info,
 269                            struct messaging_context *msg_ctx,
 270                            const char *printer, struct GUID *guid)
 271 {
 272         TALLOC_CTX *tmp_ctx;
 273         enum winreg_Type type;
 274         DATA_BLOB blob;
 275         uint32_t len;
 276         NTSTATUS status;
 277         WERROR result;
 278
 279         tmp_ctx = talloc_new(mem_ctx);
 280         if (tmp_ctx == NULL) {
 281                 DEBUG(0, ("out of memory?!\n"));
 282                 return WERR_NOMEM;
 283         }
 284
 285         result = winreg_get_printer_dataex_internal(tmp_ctx, session_info,
 286                                                     msg_ctx, printer,
 287                                                     SPOOL_DSSPOOLER_KEY,
 288                                                     "objectGUID",
 289                                                     &type,
 290                                                     &blob.data,
 291                                                     &len);
 292         if (!W_ERROR_IS_OK(result)) {
 293                 DEBUG(0, ("Failed to get GUID for printer %s\n", printer));
 294                 goto out_ctx_free;
 295         }
 296         blob.length = (size_t)len;
 297
 298         /* We used to store the guid as REG_BINARY, then swapped
 299            to REG_SZ for Vista compatibility so check for both */
 300
 301         switch (type) {
 302         case REG_SZ: {
 303                 bool ok;
 304                 const char *guid_str;
 305                 ok = pull_reg_sz(tmp_ctx, &blob, &guid_str);
 306                 if (!ok) {
 307                         DEBUG(0, ("Failed to unmarshall GUID for printer %s\n",
 308                                   printer));
 309                         result = WERR_REG_CORRUPT;
 310                         goto out_ctx_free;
 311                 }
 312                 status = GUID_from_string(guid_str, guid);
 313                 if (!NT_STATUS_IS_OK(status)) {
 314                         DEBUG(0, ("bad GUID for printer %s\n", printer));
 315                         result = ntstatus_to_werror(status);
 316                         goto out_ctx_free;
 317                 }
 318                 break;
 319         }
 320         case REG_BINARY:
 321                 if (blob.length != sizeof(struct GUID)) {
 322                         DEBUG(0, ("bad GUID for printer %s\n", printer));
 323                         result = WERR_REG_CORRUPT;
 324                         goto out_ctx_free;
 325                 }
 326                 memcpy(guid, blob.data, sizeof(struct GUID));
 327                 break;
 328         default:
 329                 DEBUG(0,("GUID value stored as invalid type (%d)\n", type));
 330                 result = WERR_REG_CORRUPT;
 331                 goto out_ctx_free;
 332                 break;
 333         }
 334         result = WERR_OK;
 335
 336 out_ctx_free:
 337         talloc_free(tmp_ctx);
 338         return result;
 339 }
 340
 341 static WERROR nt_printer_info_to_mods(TALLOC_CTX *ctx,
 342                                       struct spoolss_PrinterInfo2 *info2,
 343                                       ADS_MODLIST *mods)
 344 {
 345         char *info_str;
 346
 347         ads_mod_str(ctx, mods, SPOOL_REG_PRINTERNAME, info2->sharename);
 348         ads_mod_str(ctx, mods, SPOOL_REG_SHORTSERVERNAME, lp_netbios_name());
 349         ads_mod_str(ctx, mods, SPOOL_REG_SERVERNAME, get_mydnsfullname());
 350
 351         info_str = talloc_asprintf(ctx, "\\\\%s\\%s",
 352                                    get_mydnsfullname(), info2->sharename);
 353         if (info_str == NULL) {
 354                 return WERR_NOMEM;
 355         }
 356         ads_mod_str(ctx, mods, SPOOL_REG_UNCNAME, info_str);
 357
 358         info_str = talloc_asprintf(ctx, "%d", 4);
 359         if (info_str == NULL) {
 360                 return WERR_NOMEM;
 361         }
 362         ads_mod_str(ctx, mods, SPOOL_REG_VERSIONNUMBER, info_str);
 363
 364         /* empty strings in the mods list result in an attrubute error */
 365         if (strlen(info2->drivername) != 0)
 366                 ads_mod_str(ctx, mods, SPOOL_REG_DRIVERNAME, info2->drivername);
 367         if (strlen(info2->location) != 0)
 368                 ads_mod_str(ctx, mods, SPOOL_REG_LOCATION, info2->location);
 369         if (strlen(info2->comment) != 0)
 370                 ads_mod_str(ctx, mods, SPOOL_REG_DESCRIPTION, info2->comment);
 371         if (strlen(info2->portname) != 0)
 372                 ads_mod_str(ctx, mods, SPOOL_REG_PORTNAME, info2->portname);
 373         if (strlen(info2->sepfile) != 0)
 374                 ads_mod_str(ctx, mods, SPOOL_REG_PRINTSEPARATORFILE, info2->sepfile);
 375
 376         info_str = talloc_asprintf(ctx, "%u", info2->starttime);
 377         if (info_str == NULL) {
 378                 return WERR_NOMEM;
 379         }
 380         ads_mod_str(ctx, mods, SPOOL_REG_PRINTSTARTTIME, info_str);
 381
 382         info_str = talloc_asprintf(ctx, "%u", info2->untiltime);
 383         if (info_str == NULL) {
 384                 return WERR_NOMEM;
 385         }
 386         ads_mod_str(ctx, mods, SPOOL_REG_PRINTENDTIME, info_str);
 387
 388         info_str = talloc_asprintf(ctx, "%u", info2->priority);
 389         if (info_str == NULL) {
 390                 return WERR_NOMEM;
 391         }
 392         ads_mod_str(ctx, mods, SPOOL_REG_PRIORITY, info_str);
 393
 394         if (info2->attributes & PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS) {
 395                 ads_mod_str(ctx, mods, SPOOL_REG_PRINTKEEPPRINTEDJOBS, "TRUE");
 396         } else {
 397                 ads_mod_str(ctx, mods, SPOOL_REG_PRINTKEEPPRINTEDJOBS, "FALSE");
 398         }
 399
 400         switch (info2->attributes & 0x3) {
 401         case 0:
 402                 ads_mod_str(ctx, mods, SPOOL_REG_PRINTSPOOLING,
 403                             SPOOL_REGVAL_PRINTWHILESPOOLING);
 404                 break;
 405         case 1:
 406                 ads_mod_str(ctx, mods, SPOOL_REG_PRINTSPOOLING,
 407                             SPOOL_REGVAL_PRINTAFTERSPOOLED);
 408                 break;
 409         case 2:
 410                 ads_mod_str(ctx, mods, SPOOL_REG_PRINTSPOOLING,
 411                             SPOOL_REGVAL_PRINTDIRECT);
 412                 break;
 413         default:
 414                 DEBUG(3, ("unsupported printer attributes %x\n",
 415                           info2->attributes));
 416         }
 417
 418         return WERR_OK;
 419 }
 420
 421 static WERROR nt_printer_publish_ads(struct messaging_context *msg_ctx,
 422                                      ADS_STRUCT *ads,
 423                                      struct spoolss_PrinterInfo2 *pinfo2)
 424 {
 425         ADS_STATUS ads_rc;
 426         TALLOC_CTX *ctx;
 427         ADS_MODLIST mods;
 428         struct GUID guid;
 429         WERROR win_rc = WERR_OK;
 430         const char *printer = pinfo2->sharename;
 431         char *printer_dn = NULL;
 432
 433         /* build the ads mods */
 434         ctx = talloc_init("nt_printer_publish_ads");
 435         if (ctx == NULL) {
 436                 return WERR_NOMEM;
 437         }
 438
 439         DEBUG(5, ("publishing printer %s\n", printer));
 440
 441         win_rc = nt_printer_dn_lookup(ctx, ads, printer, &printer_dn);
 442         if (!W_ERROR_IS_OK(win_rc)) {
 443                 DEBUG(2, ("Failed to create printer dn\n"));
 444                 TALLOC_FREE(ctx);
 445                 return win_rc;
 446         }
 447
 448         mods = ads_init_mods(ctx);
 449
 450         if (mods == NULL) {
 451                 TALLOC_FREE(ctx);
 452                 return WERR_NOMEM;
 453         }
 454
 455         win_rc = nt_printer_info_to_mods(ctx, pinfo2, &mods);
 456         if (!W_ERROR_IS_OK(win_rc)) {
 457                 TALLOC_FREE(ctx);
 458                 return win_rc;
 459         }
 460
 461         /* publish it */
 462         ads_rc = ads_mod_printer_entry(ads, printer_dn, ctx, &mods);
 463         if (ads_rc.err.rc == LDAP_NO_SUCH_OBJECT) {
 464                 int i;
 465                 for (i=0; mods[i] != 0; i++)
 466                         ;
 467                 mods[i] = (LDAPMod *)-1;
 468                 ads_rc = ads_add_printer_entry(ads, printer_dn, ctx, &mods);
 469         }
 470
 471         if (!ADS_ERR_OK(ads_rc)) {
 472                 DEBUG(3, ("error publishing %s: %s\n",
 473                           printer, ads_errstr(ads_rc)));
 474                 /* XXX failed to publish, so no guid to retrieve */
 475         }
 476
 477         win_rc = nt_printer_guid_retrieve_internal(ads, printer_dn, &guid);
 478         if (!W_ERROR_IS_OK(win_rc)) {
 479                 TALLOC_FREE(ctx);
 480                 return win_rc;
 481         }
 482
 483         win_rc = nt_printer_guid_store(msg_ctx, printer, guid);
 484         if (!W_ERROR_IS_OK(win_rc)) {
 485                 DEBUG(3, ("failed to store printer %s guid\n",
 486                           printer));
 487                 /* not catastrophic, retrieve on next use */
 488                 win_rc = WERR_OK;
 489         }
 490
 491         TALLOC_FREE(ctx);
 492
 493         return win_rc;
 494 }
 495
 496 static WERROR nt_printer_unpublish_ads(ADS_STRUCT *ads,
 497                                        const char *printer)
 498 {
 499         ADS_STATUS ads_rc;
 500         LDAPMessage *res = NULL;
 501         char *prt_dn = NULL;
 502
 503         DEBUG(5, ("unpublishing printer %s\n", printer));
 504
 505         /* remove the printer from the directory */
 506         ads_rc = ads_find_printer_on_server(ads, &res,
 507                                             printer, lp_netbios_name());
 508
 509         if (ADS_ERR_OK(ads_rc) && res && ads_count_replies(ads, res)) {
 510                 prt_dn = ads_get_dn(ads, talloc_tos(), res);
 511                 if (!prt_dn) {
 512                         ads_msgfree(ads, res);
 513                         return WERR_NOMEM;
 514                 }
 515                 ads_rc = ads_del_dn(ads, prt_dn);
 516                 TALLOC_FREE(prt_dn);
 517         }
 518
 519         if (res) {
 520                 ads_msgfree(ads, res);
 521         }
 522         return WERR_OK;
 523 }
 524
 525 /****************************************************************************
 526  * Publish a printer in the directory
 527  *
 528  * @param mem_ctx      memory context
 529  * @param session_info  session_info to access winreg pipe
 530  * @param pinfo2       printer information
 531  * @param action       publish/unpublish action
 532  * @return WERROR indicating status of publishing
 533  ***************************************************************************/
 534
 535 WERROR nt_printer_publish(TALLOC_CTX *mem_ctx,
 536                           const struct auth_session_info *session_info,
 537                           struct messaging_context *msg_ctx,
 538                           struct spoolss_PrinterInfo2 *pinfo2,
 539                           int action)
 540 {
 541         uint32_t info2_mask = SPOOLSS_PRINTER_INFO_ATTRIBUTES;
 542         struct spoolss_SetPrinterInfo2 *sinfo2;
 543         ADS_STATUS ads_rc;
 544         ADS_STRUCT *ads = NULL;
 545         WERROR win_rc;
 546
 547         sinfo2 = talloc_zero(mem_ctx, struct spoolss_SetPrinterInfo2);
 548         if (!sinfo2) {
 549                 return WERR_NOMEM;
 550         }
 551
 552         switch (action) {
 553         case DSPRINT_PUBLISH:
 554         case DSPRINT_UPDATE:
 555                 pinfo2->attributes |= PRINTER_ATTRIBUTE_PUBLISHED;
 556                 break;
 557         case DSPRINT_UNPUBLISH:
 558                 pinfo2->attributes &= (~PRINTER_ATTRIBUTE_PUBLISHED);
 559                 break;
 560         default:
 561                 win_rc = WERR_NOT_SUPPORTED;
 562                 goto done;
 563         }
 564
 565         sinfo2->attributes = pinfo2->attributes;
 566
 567         win_rc = winreg_update_printer_internal(mem_ctx, session_info, msg_ctx,
 568                                         pinfo2->sharename, info2_mask,
 569                                         sinfo2, NULL, NULL);
 570         if (!W_ERROR_IS_OK(win_rc)) {
 571                 DEBUG(3, ("err %d saving data\n", W_ERROR_V(win_rc)));
 572                 goto done;
 573         }
 574
 575         TALLOC_FREE(sinfo2);
 576
 577         ads = ads_init(lp_realm(), lp_workgroup(), NULL);
 578         if (!ads) {
 579                 DEBUG(3, ("ads_init() failed\n"));
 580                 win_rc = WERR_SERVER_UNAVAILABLE;
 581                 goto done;
 582         }
 583         setenv(KRB5_ENV_CCNAME, "MEMORY:prtpub_cache", 1);
 584         SAFE_FREE(ads->auth.password);
 585         ads->auth.password = secrets_fetch_machine_password(lp_workgroup(),
 586                 NULL, NULL);
 587
 588         /* ads_connect() will find the DC for us */
 589         ads_rc = ads_connect(ads);
 590         if (!ADS_ERR_OK(ads_rc)) {
 591                 DEBUG(3, ("ads_connect failed: %s\n", ads_errstr(ads_rc)));
 592                 win_rc = WERR_ACCESS_DENIED;
 593                 goto done;
 594         }
 595
 596         switch (action) {
 597         case DSPRINT_PUBLISH:
 598         case DSPRINT_UPDATE:
 599                 win_rc = nt_printer_publish_ads(msg_ctx, ads, pinfo2);
 600                 break;
 601         case DSPRINT_UNPUBLISH:
 602                 win_rc = nt_printer_unpublish_ads(ads, pinfo2->sharename);
 603                 break;
 604         }
 605
 606 done:
 607         ads_destroy(&ads);
 608         return win_rc;
 609 }
 610
 611 WERROR check_published_printers(struct messaging_context *msg_ctx)
 612 {
 613         ADS_STATUS ads_rc;
 614         ADS_STRUCT *ads = NULL;
 615         int snum;
 616         int n_services = lp_numservices();
 617         TALLOC_CTX *tmp_ctx = NULL;
 618         struct auth_session_info *session_info = NULL;
 619         struct spoolss_PrinterInfo2 *pinfo2;
 620         NTSTATUS status;
 621         WERROR result;
 622
 623         tmp_ctx = talloc_new(NULL);
 624         if (!tmp_ctx) return WERR_NOMEM;
 625
 626         ads = ads_init(lp_realm(), lp_workgroup(), NULL);
 627         if (!ads) {
 628                 DEBUG(3, ("ads_init() failed\n"));
 629                 return WERR_SERVER_UNAVAILABLE;
 630         }
 631         setenv(KRB5_ENV_CCNAME, "MEMORY:prtpub_cache", 1);
 632         SAFE_FREE(ads->auth.password);
 633         ads->auth.password = secrets_fetch_machine_password(lp_workgroup(),
 634                 NULL, NULL);
 635
 636         /* ads_connect() will find the DC for us */
 637         ads_rc = ads_connect(ads);
 638         if (!ADS_ERR_OK(ads_rc)) {
 639                 DEBUG(3, ("ads_connect failed: %s\n", ads_errstr(ads_rc)));
 640                 result = WERR_ACCESS_DENIED;
 641                 goto done;
 642         }
 643
 644         status = make_session_info_system(tmp_ctx, &session_info);
 645         if (!NT_STATUS_IS_OK(status)) {
 646                 DEBUG(0, ("check_published_printers: "
 647                           "Could not create system session_info\n"));
 648                 result = WERR_ACCESS_DENIED;
 649                 goto done;
 650         }
 651
 652         for (snum = 0; snum < n_services; snum++) {
 653                 if (!lp_snum_ok(snum) || !lp_print_ok(snum)) {
 654                         continue;
 655                 }
 656
 657                 result = winreg_get_printer_internal(tmp_ctx, session_info, msg_ctx,
 658                                             lp_servicename(talloc_tos(), snum),
 659                                             &pinfo2);
 660                 if (!W_ERROR_IS_OK(result)) {
 661                         continue;
 662                 }
 663
 664                 if (pinfo2->attributes & PRINTER_ATTRIBUTE_PUBLISHED) {
 665                         nt_printer_publish_ads(msg_ctx, ads, pinfo2);
 666                 }
 667
 668                 TALLOC_FREE(pinfo2);
 669         }
 670
 671         result = WERR_OK;
 672 done:
 673         ads_destroy(&ads);
 674         ads_kdestroy("MEMORY:prtpub_cache");
 675         talloc_free(tmp_ctx);
 676         return result;
 677 }
 678
 679 bool is_printer_published(TALLOC_CTX *mem_ctx,
 680                           const struct auth_session_info *session_info,
 681                           struct messaging_context *msg_ctx,
 682                           const char *servername,
 683                           const char *printer,
 684                           struct spoolss_PrinterInfo2 **info2)
 685 {
 686         struct spoolss_PrinterInfo2 *pinfo2 = NULL;
 687         WERROR result;
 688         struct dcerpc_binding_handle *b;
 689
 690         result = winreg_printer_binding_handle(mem_ctx,
 691                                                session_info,
 692                                                msg_ctx,
 693                                                &b);
 694         if (!W_ERROR_IS_OK(result)) {
 695                 return false;
 696         }
 697
 698         result = winreg_get_printer(mem_ctx, b,
 699                                     printer, &pinfo2);
 700         if (!W_ERROR_IS_OK(result)) {
 701                 return false;
 702         }
 703
 704         if (!(pinfo2->attributes & PRINTER_ATTRIBUTE_PUBLISHED)) {
 705                 TALLOC_FREE(pinfo2);
 706                 return false;
 707         }
 708
 709         if (info2) {
 710                 *info2 = talloc_move(mem_ctx, &pinfo2);
 711         }
 712         talloc_free(pinfo2);
 713         return true;
 714 }
 715 #else
 716 WERROR nt_printer_guid_store(struct messaging_context *msg_ctx,
 717                            const char *printer, struct GUID guid)
 718 {
 719         return WERR_NOT_SUPPORTED;
 720 }
 721
 722 WERROR nt_printer_guid_retrieve(TALLOC_CTX *mem_ctx, const char *printer,
 723                                 struct GUID *pguid)
 724 {
 725         return WERR_NOT_SUPPORTED;
 726 }
 727
 728 WERROR nt_printer_guid_get(TALLOC_CTX *mem_ctx,
 729                            const struct auth_session_info *session_info,
 730                            struct messaging_context *msg_ctx,
 731                            const char *printer, struct GUID *guid)
 732 {
 733         return WERR_NOT_SUPPORTED;
 734 }
 735
 736 WERROR nt_printer_publish(TALLOC_CTX *mem_ctx,
 737                           const struct auth_session_info *session_info,
 738                           struct messaging_context *msg_ctx,
 739                           struct spoolss_PrinterInfo2 *pinfo2,
 740                           int action)
 741 {
 742         return WERR_OK;
 743 }
 744
 745 WERROR check_published_printers(struct messaging_context *msg_ctx)
 746 {
 747         return WERR_OK;
 748 }
 749
 750 bool is_printer_published(TALLOC_CTX *mem_ctx,
 751                           const struct auth_session_info *session_info,
 752                           struct messaging_context *msg_ctx,
 753                           const char *servername,
 754                           const char *printer,
 755                           struct spoolss_PrinterInfo2 **info2)
 756 {
 757         return False;
 758 }
 759 #endif /* HAVE_ADS */