source3/rpc_server/spoolss/srv_spoolss_nt.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *  RPC Pipe client / server routines
   4  *  Copyright (C) Andrew Tridgell              1992-2000,
   5  *  Copyright (C) Luke Kenneth Casson Leighton 1996-2000,
   6  *  Copyright (C) Jean François Micouleau      1998-2000,
   7  *  Copyright (C) Jeremy Allison               2001-2002,
   8  *  Copyright (C) Gerald Carter                2000-2004,
   9  *  Copyright (C) Tim Potter                   2001-2002.
  10  *  Copyright (C) Guenther Deschner            2009-2010.
  11  *  Copyright (C) Andreas Schneider            2010.
  12  *
  13  *  This program is free software; you can redistribute it and/or modify
  14  *  it under the terms of the GNU General Public License as published by
  15  *  the Free Software Foundation; either version 3 of the License, or
  16  *  (at your option) any later version.
  17  *
  18  *  This program is distributed in the hope that it will be useful,
  19  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  *  GNU General Public License for more details.
  22  *
  23  *  You should have received a copy of the GNU General Public License
  24  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
  25  */
  26
  27 /* Since the SPOOLSS rpc routines are basically DOS 16-bit calls wrapped
  28    up, all the errors returned are DOS errors, not NT status codes. */
  29
  30 #include "includes.h"
  31 #include "ntdomain.h"
  32 #include "nt_printing.h"
  33 #include "srv_spoolss_util.h"
  34 #include "../librpc/gen_ndr/srv_spoolss.h"
  35 #include "../librpc/gen_ndr/ndr_spoolss_c.h"
  36 #include "rpc_client/init_spoolss.h"
  37 #include "rpc_client/cli_pipe.h"
  38 #include "../libcli/security/security.h"
  39 #include "librpc/gen_ndr/ndr_security.h"
  40 #include "registry.h"
  41 #include "include/printing.h"
  42 #include "secrets.h"
  43 #include "../librpc/gen_ndr/netlogon.h"
  44 #include "rpc_misc.h"
  45 #include "printing/notify.h"
  46 #include "serverid.h"
  47 #include "../libcli/registry/util_reg.h"
  48 #include "smbd/smbd.h"
  49 #include "smbd/globals.h"
  50 #include "auth.h"
  51 #include "messages.h"
  52 #include "rpc_server/spoolss/srv_spoolss_nt.h"
  53 #include "util_tdb.h"
  54 #include "libsmb/libsmb.h"
  55 #include "printing/printer_list.h"
  56 #include "../lib/tsocket/tsocket.h"
  57 #include "rpc_client/cli_winreg_spoolss.h"
  58 #include "../libcli/smb/smbXcli_base.h"
  59 #include "rpc_server/spoolss/srv_spoolss_handle.h"
  60
  61 /* macros stolen from s4 spoolss server */
  62 #define SPOOLSS_BUFFER_UNION(fn,info,level) \
  63         ((info)?ndr_size_##fn(info, level, 0):0)
  64
  65 #define SPOOLSS_BUFFER_UNION_ARRAY(mem_ctx,fn,info,level,count) \
  66         ((info)?ndr_size_##fn##_info(mem_ctx, level, count, info):0)
  67
  68 #define SPOOLSS_BUFFER_ARRAY(mem_ctx,fn,info,count) \
  69         ((info)?ndr_size_##fn##_info(mem_ctx, count, info):0)
  70
  71 #define SPOOLSS_BUFFER_OK(val_true,val_false) ((r->in.offered >= *r->out.needed)?val_true:val_false)
  72
  73 #undef DBGC_CLASS
  74 #define DBGC_CLASS DBGC_RPC_SRV
  75
  76 #ifndef MAX_OPEN_PRINTER_EXS
  77 #define MAX_OPEN_PRINTER_EXS 50
  78 #endif
  79
  80 #define GLOBAL_SPOOLSS_OS_MAJOR_DEFAULT 5
  81 #define GLOBAL_SPOOLSS_OS_MINOR_DEFAULT 2
  82 #define GLOBAL_SPOOLSS_OS_BUILD_DEFAULT 3790
  83 #define GLOBAL_SPOOLSS_ARCHITECTURE SPOOLSS_ARCHITECTURE_x64
  84
  85 static struct printer_handle *printers_list;
  86
  87 struct printer_session_counter {
  88         struct printer_session_counter *next;
  89         struct printer_session_counter *prev;
  90
  91         int snum;
  92         uint32_t counter;
  93 };
  94
  95 static struct printer_session_counter *counter_list;
  96
  97 struct notify_back_channel {
  98         struct notify_back_channel *prev, *next;
  99
 100         /* associated client */
 101         struct sockaddr_storage client_address;
 102
 103         /* print notify back-channel pipe handle*/
 104         struct rpc_pipe_client *cli_pipe;
 105         struct cli_state *cli;
 106         uint32_t active_connections;
 107 };
 108
 109 static struct notify_back_channel *back_channels;
 110
 111 /* Map generic permissions to printer object specific permissions */
 112
 113 const struct standard_mapping printer_std_mapping = {
 114         PRINTER_READ,
 115         PRINTER_WRITE,
 116         PRINTER_EXECUTE,
 117         PRINTER_ALL_ACCESS
 118 };
 119
 120 /* Map generic permissions to print server object specific permissions */
 121
 122 const struct standard_mapping printserver_std_mapping = {
 123         SERVER_READ,
 124         SERVER_WRITE,
 125         SERVER_EXECUTE,
 126         SERVER_ALL_ACCESS
 127 };
 128
 129 /* API table for Xcv Monitor functions */
 130
 131 struct xcv_api_table {
 132         const char *name;
 133         WERROR(*fn) (TALLOC_CTX *mem_ctx, struct security_token *token, DATA_BLOB *in, DATA_BLOB *out, uint32_t *needed);
 134 };
 135
 136 static void prune_printername_cache(void);
 137
 138 /********************************************************************
 139  * Canonicalize servername.
 140  ********************************************************************/
 141
 142 static const char *canon_servername(const char *servername)
 143 {
 144         const char *pservername = servername;
 145         while (*pservername == '\\') {
 146                 pservername++;
 147         }
 148         return pservername;
 149 }
 150
 151 /* translate between internal status numbers and NT status numbers */
 152 static int nt_printj_status(int v)
 153 {
 154         switch (v) {
 155         case LPQ_QUEUED:
 156                 return 0;
 157         case LPQ_PAUSED:
 158                 return JOB_STATUS_PAUSED;
 159         case LPQ_SPOOLING:
 160                 return JOB_STATUS_SPOOLING;
 161         case LPQ_PRINTING:
 162                 return JOB_STATUS_PRINTING;
 163         case LPQ_ERROR:
 164                 return JOB_STATUS_ERROR;
 165         case LPQ_DELETING:
 166                 return JOB_STATUS_DELETING;
 167         case LPQ_OFFLINE:
 168                 return JOB_STATUS_OFFLINE;
 169         case LPQ_PAPEROUT:
 170                 return JOB_STATUS_PAPEROUT;
 171         case LPQ_PRINTED:
 172                 return JOB_STATUS_PRINTED;
 173         case LPQ_DELETED:
 174                 return JOB_STATUS_DELETED;
 175         case LPQ_BLOCKED:
 176                 return JOB_STATUS_BLOCKED_DEVQ;
 177         case LPQ_USER_INTERVENTION:
 178                 return JOB_STATUS_USER_INTERVENTION;
 179         }
 180         return 0;
 181 }
 182
 183 static int nt_printq_status(int v)
 184 {
 185         switch (v) {
 186         case LPQ_PAUSED:
 187                 return PRINTER_STATUS_PAUSED;
 188         case LPQ_QUEUED:
 189         case LPQ_SPOOLING:
 190         case LPQ_PRINTING:
 191                 return 0;
 192         }
 193         return 0;
 194 }
 195
 196 /***************************************************************************
 197  Disconnect from the client
 198 ****************************************************************************/
 199
 200 static void srv_spoolss_replycloseprinter(int snum,
 201                                           struct printer_handle *prn_hnd)
 202 {
 203         WERROR result;
 204         NTSTATUS status;
 205
 206         /*
 207          * Tell the specific printing tdb we no longer want messages for this printer
 208          * by deregistering our PID.
 209          */
 210
 211         if (!print_notify_deregister_pid(snum)) {
 212                 DEBUG(0, ("Failed to register our pid for printer %s\n",
 213                           lp_const_servicename(snum)));
 214         }
 215
 216         /* weird if the test succeeds !!! */
 217         if (prn_hnd->notify.cli_chan == NULL ||
 218             prn_hnd->notify.cli_chan->cli_pipe == NULL ||
 219             prn_hnd->notify.cli_chan->cli_pipe->binding_handle == NULL ||
 220             prn_hnd->notify.cli_chan->active_connections == 0) {
 221                 DEBUG(0, ("Trying to close unexisting backchannel!\n"));
 222                 DLIST_REMOVE(back_channels, prn_hnd->notify.cli_chan);
 223                 TALLOC_FREE(prn_hnd->notify.cli_chan);
 224                 return;
 225         }
 226
 227         status = dcerpc_spoolss_ReplyClosePrinter(
 228                                         prn_hnd->notify.cli_chan->cli_pipe->binding_handle,
 229                                         talloc_tos(),
 230                                         &prn_hnd->notify.cli_hnd,
 231                                         &result);
 232         if (!NT_STATUS_IS_OK(status)) {
 233                 DEBUG(0, ("dcerpc_spoolss_ReplyClosePrinter failed [%s].\n",
 234                           nt_errstr(status)));
 235                 result = ntstatus_to_werror(status);
 236         } else if (!W_ERROR_IS_OK(result)) {
 237                 DEBUG(0, ("reply_close_printer failed [%s].\n",
 238                           win_errstr(result)));
 239         }
 240
 241         /* if it's the last connection, deconnect the IPC$ share */
 242         if (prn_hnd->notify.cli_chan->active_connections == 1) {
 243
 244                 cli_shutdown(prn_hnd->notify.cli_chan->cli);
 245                 DLIST_REMOVE(back_channels, prn_hnd->notify.cli_chan);
 246                 TALLOC_FREE(prn_hnd->notify.cli_chan);
 247
 248                 if (prn_hnd->notify.msg_ctx != NULL) {
 249                         messaging_deregister(prn_hnd->notify.msg_ctx,
 250                                              MSG_PRINTER_NOTIFY2, NULL);
 251                 }
 252         }
 253
 254         if (prn_hnd->notify.cli_chan) {
 255                 prn_hnd->notify.cli_chan->active_connections--;
 256                 prn_hnd->notify.cli_chan = NULL;
 257         }
 258 }
 259
 260 /****************************************************************************
 261  Functions to free a printer entry datastruct.
 262 ****************************************************************************/
 263
 264 static int printer_entry_destructor(struct printer_handle *Printer)
 265 {
 266         if (Printer->notify.cli_chan != NULL &&
 267             Printer->notify.cli_chan->active_connections > 0) {
 268                 int snum = -1;
 269
 270                 switch(Printer->printer_type) {
 271                 case SPLHND_SERVER:
 272                         srv_spoolss_replycloseprinter(snum, Printer);
 273                         break;
 274
 275                 case SPLHND_PRINTER:
 276                         snum = print_queue_snum(Printer->sharename);
 277                         if (snum != -1) {
 278                                 srv_spoolss_replycloseprinter(snum, Printer);
 279                         }
 280                         break;
 281                 default:
 282                         break;
 283                 }
 284         }
 285
 286         Printer->notify.flags=0;
 287         Printer->notify.options=0;
 288         Printer->notify.localmachine[0]='\0';
 289         Printer->notify.printerlocal=0;
 290         TALLOC_FREE(Printer->notify.option);
 291         TALLOC_FREE(Printer->devmode);
 292
 293         /* Remove from the internal list. */
 294         DLIST_REMOVE(printers_list, Printer);
 295         return 0;
 296 }
 297
 298 /****************************************************************************
 299   find printer index by handle
 300 ****************************************************************************/
 301
 302 static struct printer_handle *find_printer_index_by_hnd(struct pipes_struct *p,
 303                                                         struct policy_handle *hnd)
 304 {
 305         struct printer_handle *find_printer = NULL;
 306
 307         if(!find_policy_by_hnd(p,hnd,(void **)(void *)&find_printer)) {
 308                 DEBUG(2,("find_printer_index_by_hnd: Printer handle not found: "));
 309                 return NULL;
 310         }
 311
 312         return find_printer;
 313 }
 314
 315 /****************************************************************************
 316  Close printer index by handle.
 317 ****************************************************************************/
 318
 319 static bool close_printer_handle(struct pipes_struct *p, struct policy_handle *hnd)
 320 {
 321         struct printer_handle *Printer = find_printer_index_by_hnd(p, hnd);
 322
 323         if (!Printer) {
 324                 DEBUG(2,("close_printer_handle: Invalid handle (%s:%u:%u)\n",
 325                         OUR_HANDLE(hnd)));
 326                 return false;
 327         }
 328
 329         close_policy_hnd(p, hnd);
 330
 331         return true;
 332 }
 333
 334 /****************************************************************************
 335  Delete a printer given a handle.
 336 ****************************************************************************/
 337
 338 static WERROR delete_printer_hook(TALLOC_CTX *ctx, struct security_token *token,
 339                                   const char *sharename,
 340                                   struct messaging_context *msg_ctx)
 341 {
 342         char *cmd = lp_deleteprinter_command(talloc_tos());
 343         char *command = NULL;
 344         int ret;
 345         bool is_print_op = false;
 346
 347         /* can't fail if we don't try */
 348
 349         if ( !*cmd )
 350                 return WERR_OK;
 351
 352         command = talloc_asprintf(ctx,
 353                         "%s \"%s\"",
 354                         cmd, sharename);
 355         if (!command) {
 356                 return WERR_NOT_ENOUGH_MEMORY;
 357         }
 358         if ( token )
 359                 is_print_op = security_token_has_privilege(token, SEC_PRIV_PRINT_OPERATOR);
 360
 361         DEBUG(10,("Running [%s]\n", command));
 362
 363         /********** BEGIN SePrintOperatorPrivlege BLOCK **********/
 364
 365         if ( is_print_op )
 366                 become_root();
 367
 368         ret = smbrun(command, NULL, NULL);
 369         if (ret == 0) {
 370                 /* Tell everyone we updated smb.conf. */
 371                 message_send_all(msg_ctx, MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
 372         }
 373
 374         if ( is_print_op )
 375                 unbecome_root();
 376
 377         /********** END SePrintOperatorPrivlege BLOCK **********/
 378
 379         DEBUGADD(10,("returned [%d]\n", ret));
 380
 381         TALLOC_FREE(command);
 382
 383         if (ret != 0)
 384                 return WERR_INVALID_HANDLE; /* What to return here? */
 385
 386         return WERR_OK;
 387 }
 388
 389 /****************************************************************************
 390  Delete a printer given a handle.
 391 ****************************************************************************/
 392
 393 static WERROR delete_printer_handle(struct pipes_struct *p, struct policy_handle *hnd)
 394 {
 395         struct printer_handle *Printer = find_printer_index_by_hnd(p, hnd);
 396         WERROR result;
 397
 398         if (!Printer) {
 399                 DEBUG(2,("delete_printer_handle: Invalid handle (%s:%u:%u)\n",
 400                         OUR_HANDLE(hnd)));
 401                 return WERR_INVALID_HANDLE;
 402         }
 403
 404         /*
 405          * It turns out that Windows allows delete printer on a handle
 406          * opened by an admin user, then used on a pipe handle created
 407          * by an anonymous user..... but they're working on security.... riiight !
 408          * JRA.
 409          */
 410
 411         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
 412                 DEBUG(3, ("delete_printer_handle: denied by handle\n"));
 413                 return WERR_ACCESS_DENIED;
 414         }
 415
 416         /* this does not need a become root since the access check has been
 417            done on the handle already */
 418
 419         result = winreg_delete_printer_key_internal(p->mem_ctx,
 420                                            get_session_info_system(),
 421                                            p->msg_ctx,
 422                                            Printer->sharename,
 423                                            "");
 424         if (!W_ERROR_IS_OK(result)) {
 425                 DEBUG(3,("Error deleting printer %s\n", Printer->sharename));
 426                 return WERR_INVALID_HANDLE;
 427         }
 428
 429         result = delete_printer_hook(p->mem_ctx, p->session_info->security_token,
 430                                      Printer->sharename, p->msg_ctx);
 431         if (!W_ERROR_IS_OK(result)) {
 432                 return result;
 433         }
 434         prune_printername_cache();
 435         return WERR_OK;
 436 }
 437
 438 /****************************************************************************
 439  Return the snum of a printer corresponding to an handle.
 440 ****************************************************************************/
 441
 442 static bool get_printer_snum(struct pipes_struct *p, struct policy_handle *hnd,
 443                              int *number, struct share_params **params)
 444 {
 445         struct printer_handle *Printer = find_printer_index_by_hnd(p, hnd);
 446
 447         if (!Printer) {
 448                 DEBUG(2,("get_printer_snum: Invalid handle (%s:%u:%u)\n",
 449                         OUR_HANDLE(hnd)));
 450                 return false;
 451         }
 452
 453         switch (Printer->printer_type) {
 454                 case SPLHND_PRINTER:
 455                         DEBUG(4,("short name:%s\n", Printer->sharename));
 456                         *number = print_queue_snum(Printer->sharename);
 457                         return (*number != -1);
 458                 case SPLHND_SERVER:
 459                         return false;
 460                 default:
 461                         return false;
 462         }
 463 }
 464
 465 /****************************************************************************
 466  Set printer handle type.
 467  Check if it's \\server or \\server\printer
 468 ****************************************************************************/
 469
 470 static bool set_printer_hnd_printertype(struct printer_handle *Printer, const char *handlename)
 471 {
 472         DEBUG(3,("Setting printer type=%s\n", handlename));
 473
 474         /* it's a print server */
 475         if (handlename && *handlename=='\\' && *(handlename+1)=='\\' && !strchr_m(handlename+2, '\\')) {
 476                 DEBUGADD(4,("Printer is a print server\n"));
 477                 Printer->printer_type = SPLHND_SERVER;
 478         }
 479         /* it's a printer (set_printer_hnd_name() will handle port monitors */
 480         else {
 481                 DEBUGADD(4,("Printer is a printer\n"));
 482                 Printer->printer_type = SPLHND_PRINTER;
 483         }
 484
 485         return true;
 486 }
 487
 488 static void prune_printername_cache_fn(const char *key, const char *value,
 489                                        time_t timeout, void *private_data)
 490 {
 491         gencache_del(key);
 492 }
 493
 494 static void prune_printername_cache(void)
 495 {
 496         gencache_iterate(prune_printername_cache_fn, NULL, "PRINTERNAME/*");
 497 }
 498
 499 /****************************************************************************
 500  Set printer handle name..  Accept names like \\server, \\server\printer,
 501  \\server\SHARE, & "\\server\,XcvMonitor Standard TCP/IP Port"    See
 502  the MSDN docs regarding OpenPrinter() for details on the XcvData() and
 503  XcvDataPort() interface.
 504 ****************************************************************************/
 505
 506 static WERROR set_printer_hnd_name(TALLOC_CTX *mem_ctx,
 507                                    const struct auth_session_info *session_info,
 508                                    struct messaging_context *msg_ctx,
 509                                    struct printer_handle *Printer,
 510                                    const char *handlename)
 511 {
 512         int snum;
 513         int n_services=lp_numservices();
 514         char *aprinter;
 515         const char *printername;
 516         const char *servername = NULL;
 517         fstring sname;
 518         bool found = false;
 519         struct spoolss_PrinterInfo2 *info2 = NULL;
 520         WERROR result;
 521         char *p;
 522
 523         /*
 524          * Hopefully nobody names his printers like this. Maybe \ or ,
 525          * are illegal in printer names even?
 526          */
 527         const char printer_not_found[] = "Printer \\, !@#$%^&*( not found";
 528         char *cache_key;
 529         char *tmp;
 530
 531         DEBUG(4,("Setting printer name=%s (len=%lu)\n", handlename,
 532                 (unsigned long)strlen(handlename)));
 533
 534         aprinter = discard_const_p(char, handlename);
 535         if ( *handlename == '\\' ) {
 536                 servername = canon_servername(handlename);
 537                 if ( (aprinter = strchr_m( servername, '\\' )) != NULL ) {
 538                         *aprinter = '\0';
 539                         aprinter++;
 540                 }
 541                 if (!is_myname_or_ipaddr(servername)) {
 542                         return WERR_INVALID_PRINTER_NAME;
 543                 }
 544                 Printer->servername = talloc_asprintf(Printer, "\\\\%s", servername);
 545                 if (Printer->servername == NULL) {
 546                         return WERR_NOT_ENOUGH_MEMORY;
 547                 }
 548         }
 549
 550         if (Printer->printer_type == SPLHND_SERVER) {
 551                 return WERR_OK;
 552         }
 553
 554         if (Printer->printer_type != SPLHND_PRINTER) {
 555                 return WERR_INVALID_HANDLE;
 556         }
 557
 558         DEBUGADD(5, ("searching for [%s]\n", aprinter));
 559
 560         p = strchr(aprinter, ',');
 561         if (p != NULL) {
 562                 char *p2 = p;
 563                 p++;
 564                 if (*p == ' ') {
 565                         p++;
 566                 }
 567                 if (strncmp(p, "DrvConvert", strlen("DrvConvert")) == 0) {
 568                         *p2 = '\0';
 569                 } else if (strncmp(p, "LocalOnly", strlen("LocalOnly")) == 0) {
 570                         *p2 = '\0';
 571                 }
 572         }
 573
 574         if (p) {
 575                 DEBUGADD(5, ("stripped handlename: [%s]\n", aprinter));
 576         }
 577
 578         /* check for the Port Monitor Interface */
 579         if ( strequal( aprinter, SPL_XCV_MONITOR_TCPMON ) ) {
 580                 Printer->printer_type = SPLHND_PORTMON_TCP;
 581                 fstrcpy(sname, SPL_XCV_MONITOR_TCPMON);
 582                 found = true;
 583         }
 584         else if ( strequal( aprinter, SPL_XCV_MONITOR_LOCALMON ) ) {
 585                 Printer->printer_type = SPLHND_PORTMON_LOCAL;
 586                 fstrcpy(sname, SPL_XCV_MONITOR_LOCALMON);
 587                 found = true;
 588         }
 589
 590         cache_key = talloc_asprintf(talloc_tos(), "PRINTERNAME/%s", aprinter);
 591         if (cache_key == NULL) {
 592                 return WERR_NOT_ENOUGH_MEMORY;
 593         }
 594
 595         /*
 596          * With hundreds of printers, the "for" loop iterating all
 597          * shares can be quite expensive, as it is done on every
 598          * OpenPrinter. The loop maps "aprinter" to "sname", the
 599          * result of which we cache in gencache.
 600          */
 601         if (gencache_get(cache_key, talloc_tos(), &tmp, NULL)) {
 602                 found = (strcmp(tmp, printer_not_found) != 0);
 603                 if (!found) {
 604                         DEBUG(4, ("Printer %s not found\n", aprinter));
 605                         TALLOC_FREE(tmp);
 606                         return WERR_INVALID_PRINTER_NAME;
 607                 }
 608                 fstrcpy(sname, tmp);
 609                 TALLOC_FREE(tmp);
 610         }
 611
 612         /* Search all sharenames first as this is easier than pulling
 613            the printer_info_2 off of disk. Don't use find_service() since
 614            that calls out to map_username() */
 615
 616         /* do another loop to look for printernames */
 617         for (snum = 0; !found && snum < n_services; snum++) {
 618                 const char *printer = lp_const_servicename(snum);
 619
 620                 /* no point going on if this is not a printer */
 621                 if (!(lp_snum_ok(snum) && lp_printable(snum))) {
 622                         continue;
 623                 }
 624
 625                 /* ignore [printers] share */
 626                 if (strequal(printer, "printers")) {
 627                         continue;
 628                 }
 629
 630                 fstrcpy(sname, printer);
 631                 if (strequal(aprinter, printer)) {
 632                         found = true;
 633                         break;
 634                 }
 635
 636                 /* no point looking up the printer object if
 637                    we aren't allowing printername != sharename */
 638                 if (lp_force_printername(snum)) {
 639                         continue;
 640                 }
 641
 642                 result = winreg_get_printer_internal(mem_ctx,
 643                                             session_info,
 644                                             msg_ctx,
 645                                             sname,
 646                                             &info2);
 647                 if ( !W_ERROR_IS_OK(result) ) {
 648                         DEBUG(2,("set_printer_hnd_name: failed to lookup printer [%s] -- result [%s]\n",
 649                                  sname, win_errstr(result)));
 650                         continue;
 651                 }
 652
 653                 printername = strrchr(info2->printername, '\\');
 654                 if (printername == NULL) {
 655                         printername = info2->printername;
 656                 } else {
 657                         printername++;
 658                 }
 659
 660                 if (strequal(printername, aprinter)) {
 661                         found = true;
 662                         break;
 663                 }
 664
 665                 DEBUGADD(10, ("printername: %s\n", printername));
 666
 667                 TALLOC_FREE(info2);
 668         }
 669
 670         if (!found) {
 671                 gencache_set(cache_key, printer_not_found,
 672                              time(NULL) + 300);
 673                 TALLOC_FREE(cache_key);
 674                 DEBUGADD(4,("Printer not found\n"));
 675                 return WERR_INVALID_PRINTER_NAME;
 676         }
 677
 678         gencache_set(cache_key, sname, time(NULL) + 300);
 679         TALLOC_FREE(cache_key);
 680
 681         DEBUGADD(4,("set_printer_hnd_name: Printer found: %s -> %s\n", aprinter, sname));
 682
 683         strlcpy(Printer->sharename, sname, sizeof(Printer->sharename));
 684
 685         return WERR_OK;
 686 }
 687
 688 /****************************************************************************
 689  Find first available printer slot. creates a printer handle for you.
 690  ****************************************************************************/
 691
 692 static WERROR open_printer_hnd(struct pipes_struct *p,
 693                                struct policy_handle *hnd,
 694                                const char *name,
 695                                uint32_t access_granted)
 696 {
 697         struct printer_handle *new_printer;
 698         WERROR result;
 699
 700         DEBUG(10,("open_printer_hnd: name [%s]\n", name));
 701
 702         new_printer = talloc_zero(p->mem_ctx, struct printer_handle);
 703         if (new_printer == NULL) {
 704                 return WERR_NOT_ENOUGH_MEMORY;
 705         }
 706         talloc_set_destructor(new_printer, printer_entry_destructor);
 707
 708         /* This also steals the printer_handle on the policy_handle */
 709         if (!create_policy_hnd(p, hnd, new_printer)) {
 710                 TALLOC_FREE(new_printer);
 711                 return WERR_INVALID_HANDLE;
 712         }
 713
 714         /* Add to the internal list. */
 715         DLIST_ADD(printers_list, new_printer);
 716
 717         new_printer->notify.option=NULL;
 718
 719         if (!set_printer_hnd_printertype(new_printer, name)) {
 720                 close_printer_handle(p, hnd);
 721                 return WERR_INVALID_HANDLE;
 722         }
 723
 724         result = set_printer_hnd_name(p->mem_ctx,
 725                                       get_session_info_system(),
 726                                       p->msg_ctx,
 727                                       new_printer, name);
 728         if (!W_ERROR_IS_OK(result)) {
 729                 close_printer_handle(p, hnd);
 730                 return result;
 731         }
 732
 733         new_printer->access_granted = access_granted;
 734
 735         DEBUG(5, ("%d printer handles active\n",
 736                   (int)num_pipe_handles(p)));
 737
 738         return WERR_OK;
 739 }
 740
 741 /***************************************************************************
 742  check to see if the client motify handle is monitoring the notification
 743  given by (notify_type, notify_field).
 744  **************************************************************************/
 745
 746 static bool is_monitoring_event_flags(uint32_t flags, uint16_t notify_type,
 747                                       uint16_t notify_field)
 748 {
 749         return true;
 750 }
 751
 752 static bool is_monitoring_event(struct printer_handle *p, uint16_t notify_type,
 753                                 uint16_t notify_field)
 754 {
 755         struct spoolss_NotifyOption *option = p->notify.option;
 756         uint32_t i, j;
 757
 758         /*
 759          * Flags should always be zero when the change notify
 760          * is registered by the client's spooler.  A user Win32 app
 761          * might use the flags though instead of the NOTIFY_OPTION_INFO
 762          * --jerry
 763          */
 764
 765         if (!option) {
 766                 return false;
 767         }
 768
 769         if (p->notify.flags)
 770                 return is_monitoring_event_flags(
 771                         p->notify.flags, notify_type, notify_field);
 772
 773         for (i = 0; i < option->count; i++) {
 774
 775                 /* Check match for notify_type */
 776
 777                 if (option->types[i].type != notify_type)
 778                         continue;
 779
 780                 /* Check match for field */
 781
 782                 for (j = 0; j < option->types[i].count; j++) {
 783                         if (option->types[i].fields[j].field == notify_field) {
 784                                 return true;
 785                         }
 786                 }
 787         }
 788
 789         DEBUG(10, ("Open handle for \\\\%s\\%s is not monitoring 0x%02x/0x%02x\n",
 790                    p->servername, p->sharename, notify_type, notify_field));
 791
 792         return false;
 793 }
 794
 795 #define SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(_data, _integer) \
 796         _data->data.integer[0] = _integer; \
 797         _data->data.integer[1] = 0;
 798
 799
 800 #define SETUP_SPOOLSS_NOTIFY_DATA_STRING(_data, _p) \
 801         _data->data.string.string = talloc_strdup(mem_ctx, _p); \
 802         if (!_data->data.string.string) {\
 803                 _data->data.string.size = 0; \
 804         } \
 805         _data->data.string.size = strlen_m_term(_p) * 2;
 806
 807 #define SETUP_SPOOLSS_NOTIFY_DATA_DEVMODE(_data, _devmode) \
 808         _data->data.devmode.devmode = _devmode;
 809
 810 static void init_systemtime_buffer(TALLOC_CTX *mem_ctx,
 811                                    struct tm *t,
 812                                    const char **pp,
 813                                    uint32_t *plen)
 814 {
 815         struct spoolss_Time st;
 816         uint32_t len = 16;
 817         char *p;
 818
 819         if (!init_systemtime(&st, t)) {
 820                 return;
 821         }
 822
 823         p = talloc_array(mem_ctx, char, len);
 824         if (!p) {
 825                 return;
 826         }
 827
 828         /*
 829          * Systemtime must be linearized as a set of UINT16's.
 830          * Fix from Benjamin (Bj) Kuit bj@it.uts.edu.au
 831          */
 832
 833         SSVAL(p, 0, st.year);
 834         SSVAL(p, 2, st.month);
 835         SSVAL(p, 4, st.day_of_week);
 836         SSVAL(p, 6, st.day);
 837         SSVAL(p, 8, st.hour);
 838         SSVAL(p, 10, st.minute);
 839         SSVAL(p, 12, st.second);
 840         SSVAL(p, 14, st.millisecond);
 841
 842         *pp = p;
 843         *plen = len;
 844 }
 845
 846 /* Convert a notification message to a struct spoolss_Notify */
 847
 848 static void notify_one_value(struct spoolss_notify_msg *msg,
 849                              struct spoolss_Notify *data,
 850                              TALLOC_CTX *mem_ctx)
 851 {
 852         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, msg->notify.value[0]);
 853 }
 854
 855 static void notify_string(struct spoolss_notify_msg *msg,
 856                           struct spoolss_Notify *data,
 857                           TALLOC_CTX *mem_ctx)
 858 {
 859         /* The length of the message includes the trailing \0 */
 860
 861         data->data.string.size = msg->len * 2;
 862         data->data.string.string = talloc_strdup(mem_ctx, msg->notify.data);
 863         if (!data->data.string.string) {
 864                 data->data.string.size = 0;
 865                 return;
 866         }
 867 }
 868
 869 static void notify_system_time(struct spoolss_notify_msg *msg,
 870                                struct spoolss_Notify *data,
 871                                TALLOC_CTX *mem_ctx)
 872 {
 873         data->data.string.string = NULL;
 874         data->data.string.size = 0;
 875
 876         if (msg->len != sizeof(time_t)) {
 877                 DEBUG(5, ("notify_system_time: received wrong sized message (%d)\n",
 878                           msg->len));
 879                 return;
 880         }
 881
 882         init_systemtime_buffer(mem_ctx, gmtime((time_t *)msg->notify.data),
 883                                &data->data.string.string,
 884                                &data->data.string.size);
 885 }
 886
 887 struct notify2_message_table {
 888         const char *name;
 889         void (*fn)(struct spoolss_notify_msg *msg,
 890                    struct spoolss_Notify *data, TALLOC_CTX *mem_ctx);
 891 };
 892
 893 static struct notify2_message_table printer_notify_table[] = {
 894         /* 0x00 */ { "PRINTER_NOTIFY_FIELD_SERVER_NAME", notify_string },
 895         /* 0x01 */ { "PRINTER_NOTIFY_FIELD_PRINTER_NAME", notify_string },
 896         /* 0x02 */ { "PRINTER_NOTIFY_FIELD_SHARE_NAME", notify_string },
 897         /* 0x03 */ { "PRINTER_NOTIFY_FIELD_PORT_NAME", notify_string },
 898         /* 0x04 */ { "PRINTER_NOTIFY_FIELD_DRIVER_NAME", notify_string },
 899         /* 0x05 */ { "PRINTER_NOTIFY_FIELD_COMMENT", notify_string },
 900         /* 0x06 */ { "PRINTER_NOTIFY_FIELD_LOCATION", notify_string },
 901         /* 0x07 */ { "PRINTER_NOTIFY_FIELD_DEVMODE", NULL },
 902         /* 0x08 */ { "PRINTER_NOTIFY_FIELD_SEPFILE", notify_string },
 903         /* 0x09 */ { "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR", notify_string },
 904         /* 0x0a */ { "PRINTER_NOTIFY_FIELD_PARAMETERS", NULL },
 905         /* 0x0b */ { "PRINTER_NOTIFY_FIELD_DATATYPE", notify_string },
 906         /* 0x0c */ { "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NULL },
 907         /* 0x0d */ { "PRINTER_NOTIFY_FIELD_ATTRIBUTES", notify_one_value },
 908         /* 0x0e */ { "PRINTER_NOTIFY_FIELD_PRIORITY", notify_one_value },
 909         /* 0x0f */ { "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY", NULL },
 910         /* 0x10 */ { "PRINTER_NOTIFY_FIELD_START_TIME", NULL },
 911         /* 0x11 */ { "PRINTER_NOTIFY_FIELD_UNTIL_TIME", NULL },
 912         /* 0x12 */ { "PRINTER_NOTIFY_FIELD_STATUS", notify_one_value },
 913 };
 914
 915 static struct notify2_message_table job_notify_table[] = {
 916         /* 0x00 */ { "JOB_NOTIFY_FIELD_PRINTER_NAME", NULL },
 917         /* 0x01 */ { "JOB_NOTIFY_FIELD_MACHINE_NAME", NULL },
 918         /* 0x02 */ { "JOB_NOTIFY_FIELD_PORT_NAME", NULL },
 919         /* 0x03 */ { "JOB_NOTIFY_FIELD_USER_NAME", notify_string },
 920         /* 0x04 */ { "JOB_NOTIFY_FIELD_NOTIFY_NAME", NULL },
 921         /* 0x05 */ { "JOB_NOTIFY_FIELD_DATATYPE", NULL },
 922         /* 0x06 */ { "JOB_NOTIFY_FIELD_PRINT_PROCESSOR", NULL },
 923         /* 0x07 */ { "JOB_NOTIFY_FIELD_PARAMETERS", NULL },
 924         /* 0x08 */ { "JOB_NOTIFY_FIELD_DRIVER_NAME", NULL },
 925         /* 0x09 */ { "JOB_NOTIFY_FIELD_DEVMODE", NULL },
 926         /* 0x0a */ { "JOB_NOTIFY_FIELD_STATUS", notify_one_value },
 927         /* 0x0b */ { "JOB_NOTIFY_FIELD_STATUS_STRING", NULL },
 928         /* 0x0c */ { "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NULL },
 929         /* 0x0d */ { "JOB_NOTIFY_FIELD_DOCUMENT", notify_string },
 930         /* 0x0e */ { "JOB_NOTIFY_FIELD_PRIORITY", NULL },
 931         /* 0x0f */ { "JOB_NOTIFY_FIELD_POSITION", NULL },
 932         /* 0x10 */ { "JOB_NOTIFY_FIELD_SUBMITTED", notify_system_time },
 933         /* 0x11 */ { "JOB_NOTIFY_FIELD_START_TIME", NULL },
 934         /* 0x12 */ { "JOB_NOTIFY_FIELD_UNTIL_TIME", NULL },
 935         /* 0x13 */ { "JOB_NOTIFY_FIELD_TIME", NULL },
 936         /* 0x14 */ { "JOB_NOTIFY_FIELD_TOTAL_PAGES", notify_one_value },
 937         /* 0x15 */ { "JOB_NOTIFY_FIELD_PAGES_PRINTED", NULL },
 938         /* 0x16 */ { "JOB_NOTIFY_FIELD_TOTAL_BYTES", notify_one_value },
 939         /* 0x17 */ { "JOB_NOTIFY_FIELD_BYTES_PRINTED", NULL },
 940 };
 941
 942
 943 /***********************************************************************
 944  Allocate talloc context for container object
 945  **********************************************************************/
 946
 947 static void notify_msg_ctr_init( SPOOLSS_NOTIFY_MSG_CTR *ctr )
 948 {
 949         if ( !ctr )
 950                 return;
 951
 952         ctr->ctx = talloc_init("notify_msg_ctr_init %p", ctr);
 953
 954         return;
 955 }
 956
 957 /***********************************************************************
 958  release all allocated memory and zero out structure
 959  **********************************************************************/
 960
 961 static void notify_msg_ctr_destroy( SPOOLSS_NOTIFY_MSG_CTR *ctr )
 962 {
 963         if ( !ctr )
 964                 return;
 965
 966         if ( ctr->ctx )
 967                 talloc_destroy(ctr->ctx);
 968
 969         ZERO_STRUCTP(ctr);
 970
 971         return;
 972 }
 973
 974 /***********************************************************************
 975  **********************************************************************/
 976
 977 static TALLOC_CTX* notify_ctr_getctx( SPOOLSS_NOTIFY_MSG_CTR *ctr )
 978 {
 979         if ( !ctr )
 980                 return NULL;
 981
 982         return ctr->ctx;
 983 }
 984
 985 /***********************************************************************
 986  **********************************************************************/
 987
 988 static SPOOLSS_NOTIFY_MSG_GROUP* notify_ctr_getgroup( SPOOLSS_NOTIFY_MSG_CTR *ctr, uint32_t idx )
 989 {
 990         if ( !ctr || !ctr->msg_groups )
 991                 return NULL;
 992
 993         if ( idx >= ctr->num_groups )
 994                 return NULL;
 995
 996         return &ctr->msg_groups[idx];
 997
 998 }
 999
1000 /***********************************************************************
1001  How many groups of change messages do we have ?
1002  **********************************************************************/
1003
1004 static int notify_msg_ctr_numgroups( SPOOLSS_NOTIFY_MSG_CTR *ctr )
1005 {
1006         if ( !ctr )
1007                 return 0;
1008
1009         return ctr->num_groups;
1010 }
1011
1012 /***********************************************************************
1013  Add a SPOOLSS_NOTIFY_MSG_CTR to the correct group
1014  **********************************************************************/
1015
1016 static int notify_msg_ctr_addmsg( SPOOLSS_NOTIFY_MSG_CTR *ctr, SPOOLSS_NOTIFY_MSG *msg )
1017 {
1018         SPOOLSS_NOTIFY_MSG_GROUP        *groups = NULL;
1019         SPOOLSS_NOTIFY_MSG_GROUP        *msg_grp = NULL;
1020         SPOOLSS_NOTIFY_MSG              *msg_list = NULL;
1021         int                             i, new_slot;
1022
1023         if ( !ctr || !msg )
1024                 return 0;
1025
1026         /* loop over all groups looking for a matching printer name */
1027
1028         for ( i=0; i<ctr->num_groups; i++ ) {
1029                 if ( strcmp(ctr->msg_groups[i].printername, msg->printer) == 0 )
1030                         break;
1031         }
1032
1033         /* add a new group? */
1034
1035         if ( i == ctr->num_groups ) {
1036                 ctr->num_groups++;
1037
1038                 if ( !(groups = talloc_realloc( ctr->ctx, ctr->msg_groups, SPOOLSS_NOTIFY_MSG_GROUP, ctr->num_groups)) ) {
1039                         DEBUG(0,("notify_msg_ctr_addmsg: talloc_realloc() failed!\n"));
1040                         return 0;
1041                 }
1042                 ctr->msg_groups = groups;
1043
1044                 /* clear the new entry and set the printer name */
1045
1046                 ZERO_STRUCT( ctr->msg_groups[ctr->num_groups-1] );
1047                 fstrcpy( ctr->msg_groups[ctr->num_groups-1].printername, msg->printer );
1048         }
1049
1050         /* add the change messages; 'i' is the correct index now regardless */
1051
1052         msg_grp = &ctr->msg_groups[i];
1053
1054         msg_grp->num_msgs++;
1055
1056         if ( !(msg_list = talloc_realloc( ctr->ctx, msg_grp->msgs, SPOOLSS_NOTIFY_MSG, msg_grp->num_msgs )) ) {
1057                 DEBUG(0,("notify_msg_ctr_addmsg: talloc_realloc() failed for new message [%d]!\n", msg_grp->num_msgs));
1058                 return 0;
1059         }
1060         msg_grp->msgs = msg_list;
1061
1062         new_slot = msg_grp->num_msgs-1;
1063         memcpy( &msg_grp->msgs[new_slot], msg, sizeof(SPOOLSS_NOTIFY_MSG) );
1064
1065         /* need to allocate own copy of data */
1066
1067         if ( msg->len != 0 )
1068                 msg_grp->msgs[new_slot].notify.data = (char *)
1069                         talloc_memdup( ctr->ctx, msg->notify.data, msg->len );
1070
1071         return ctr->num_groups;
1072 }
1073
1074 static void construct_info_data(struct spoolss_Notify *info_data,
1075                                 enum spoolss_NotifyType type,
1076                                 uint16_t field, int id);
1077
1078 /***********************************************************************
1079  Send a change notication message on all handles which have a call
1080  back registered
1081  **********************************************************************/
1082
1083 static int build_notify2_messages(TALLOC_CTX *mem_ctx,
1084                                   struct printer_handle *prn_hnd,
1085                                   SPOOLSS_NOTIFY_MSG *messages,
1086                                   uint32_t num_msgs,
1087                                   struct spoolss_Notify **_notifies,
1088                                   int *_count)
1089 {
1090         struct spoolss_Notify *notifies;
1091         SPOOLSS_NOTIFY_MSG *msg;
1092         int count = 0;
1093         uint32_t id;
1094         int i;
1095
1096         notifies = talloc_zero_array(mem_ctx,
1097                                      struct spoolss_Notify, num_msgs);
1098         if (!notifies) {
1099                 return ENOMEM;
1100         }
1101
1102         for (i = 0; i < num_msgs; i++) {
1103
1104                 msg = &messages[i];
1105
1106                 /* Are we monitoring this event? */
1107
1108                 if (!is_monitoring_event(prn_hnd, msg->type, msg->field)) {
1109                         continue;
1110                 }
1111
1112                 DEBUG(10, ("Sending message type [0x%x] field [0x%2x] "
1113                            "for printer [%s]\n",
1114                            msg->type, msg->field, prn_hnd->sharename));
1115
1116                 /*
1117                  * if the is a printer notification handle and not a job
1118                  * notification type, then set the id to 0.
1119                  * Otherwise just use what was specified in the message.
1120                  *
1121                  * When registering change notification on a print server
1122                  * handle we always need to send back the id (snum) matching
1123                  * the printer for which the change took place.
1124                  * For change notify registered on a printer handle,
1125                  * this does not matter and the id should be 0.
1126                  *
1127                  * --jerry
1128                  */
1129
1130                 if ((msg->type == PRINTER_NOTIFY_TYPE) &&
1131                     (prn_hnd->printer_type == SPLHND_PRINTER)) {
1132                         id = 0;
1133                 } else {
1134                         id = msg->id;
1135                 }
1136
1137                 /* Convert unix jobid to smb jobid */
1138
1139                 if (msg->flags & SPOOLSS_NOTIFY_MSG_UNIX_JOBID) {
1140                         id = sysjob_to_jobid(msg->id);
1141
1142                         if (id == -1) {
1143                                 DEBUG(3, ("no such unix jobid %d\n",
1144                                           msg->id));
1145                                 continue;
1146                         }
1147                 }
1148
1149                 construct_info_data(&notifies[count],
1150                                     msg->type, msg->field, id);
1151
1152                 switch(msg->type) {
1153                 case PRINTER_NOTIFY_TYPE:
1154                         if (printer_notify_table[msg->field].fn) {
1155                                 printer_notify_table[msg->field].fn(msg,
1156                                                 &notifies[count], mem_ctx);
1157                         }
1158                         break;
1159
1160                 case JOB_NOTIFY_TYPE:
1161                         if (job_notify_table[msg->field].fn) {
1162                                 job_notify_table[msg->field].fn(msg,
1163                                                 &notifies[count], mem_ctx);
1164                         }
1165                         break;
1166
1167                 default:
1168                         DEBUG(5, ("Unknown notification type %d\n",
1169                                   msg->type));
1170                         continue;
1171                 }
1172
1173                 count++;
1174         }
1175
1176         *_notifies = notifies;
1177         *_count = count;
1178
1179         return 0;
1180 }
1181
1182 static int send_notify2_printer(TALLOC_CTX *mem_ctx,
1183                                 struct printer_handle *prn_hnd,
1184                                 SPOOLSS_NOTIFY_MSG_GROUP *msg_group)
1185 {
1186         struct spoolss_Notify *notifies;
1187         int count = 0;
1188         union spoolss_ReplyPrinterInfo info;
1189         struct spoolss_NotifyInfo info0;
1190         uint32_t reply_result;
1191         NTSTATUS status;
1192         WERROR werr;
1193         int ret;
1194
1195         /* Is there notification on this handle? */
1196         if (prn_hnd->notify.cli_chan == NULL ||
1197             prn_hnd->notify.cli_chan->cli_pipe == NULL ||
1198             prn_hnd->notify.cli_chan->cli_pipe->binding_handle == NULL ||
1199             prn_hnd->notify.cli_chan->active_connections == 0) {
1200                 return 0;
1201         }
1202
1203         DEBUG(10, ("Client connected! [\\\\%s\\%s]\n",
1204                    prn_hnd->servername, prn_hnd->sharename));
1205
1206         /* For this printer? Print servers always receive notifications. */
1207         if ((prn_hnd->printer_type == SPLHND_PRINTER)  &&
1208             (!strequal(msg_group->printername, prn_hnd->sharename))) {
1209                 return 0;
1210         }
1211
1212         DEBUG(10,("Our printer\n"));
1213
1214         /* build the array of change notifications */
1215         ret = build_notify2_messages(mem_ctx, prn_hnd,
1216                                      msg_group->msgs,
1217                                      msg_group->num_msgs,
1218                                      &notifies, &count);
1219         if (ret) {
1220                 return ret;
1221         }
1222
1223         info0.version   = 0x2;
1224         info0.flags     = count ? 0x00020000 /* ??? */ : PRINTER_NOTIFY_INFO_DISCARDED;
1225         info0.count     = count;
1226         info0.notifies  = notifies;
1227
1228         info.info0 = &info0;
1229
1230         status = dcerpc_spoolss_RouterReplyPrinterEx(
1231                                 prn_hnd->notify.cli_chan->cli_pipe->binding_handle,
1232                                 mem_ctx,
1233                                 &prn_hnd->notify.cli_hnd,
1234                                 prn_hnd->notify.change, /* color */
1235                                 prn_hnd->notify.flags,
1236                                 &reply_result,
1237                                 0, /* reply_type, must be 0 */
1238                                 info, &werr);
1239         if (!NT_STATUS_IS_OK(status)) {
1240                 DEBUG(1, ("dcerpc_spoolss_RouterReplyPrinterEx to client: %s "
1241                           "failed: %s\n",
1242                           prn_hnd->notify.cli_chan->cli_pipe->srv_name_slash,
1243                           nt_errstr(status)));
1244                 werr = ntstatus_to_werror(status);
1245         } else if (!W_ERROR_IS_OK(werr)) {
1246                 DEBUG(1, ("RouterReplyPrinterEx to client: %s "
1247                           "failed: %s\n",
1248                           prn_hnd->notify.cli_chan->cli_pipe->srv_name_slash,
1249                           win_errstr(werr)));
1250         }
1251         switch (reply_result) {
1252         case 0:
1253                 break;
1254         case PRINTER_NOTIFY_INFO_DISCARDED:
1255         case PRINTER_NOTIFY_INFO_DISCARDNOTED:
1256         case PRINTER_NOTIFY_INFO_COLOR_MISMATCH:
1257                 break;
1258         default:
1259                 break;
1260         }
1261
1262         return 0;
1263 }
1264
1265 static void send_notify2_changes( SPOOLSS_NOTIFY_MSG_CTR *ctr, uint32_t idx )
1266 {
1267         struct printer_handle    *p;
1268         TALLOC_CTX               *mem_ctx = notify_ctr_getctx( ctr );
1269         SPOOLSS_NOTIFY_MSG_GROUP *msg_group = notify_ctr_getgroup( ctr, idx );
1270         int ret;
1271
1272         if ( !msg_group ) {
1273                 DEBUG(5,("send_notify2_changes() called with no msg group!\n"));
1274                 return;
1275         }
1276
1277         if (!msg_group->msgs) {
1278                 DEBUG(5, ("send_notify2_changes() called with no messages!\n"));
1279                 return;
1280         }
1281
1282         DEBUG(8,("send_notify2_changes: Enter...[%s]\n", msg_group->printername));
1283
1284         /* loop over all printers */
1285
1286         for (p = printers_list; p; p = p->next) {
1287                 ret = send_notify2_printer(mem_ctx, p, msg_group);
1288                 if (ret) {
1289                         goto done;
1290                 }
1291         }
1292
1293 done:
1294         DEBUG(8,("send_notify2_changes: Exit...\n"));
1295         return;
1296 }
1297
1298 /***********************************************************************
1299  **********************************************************************/
1300
1301 static bool notify2_unpack_msg( SPOOLSS_NOTIFY_MSG *msg, struct timeval *tv, void *buf, size_t len )
1302 {
1303
1304         uint32_t tv_sec, tv_usec;
1305         size_t offset = 0;
1306
1307         /* Unpack message */
1308
1309         offset += tdb_unpack((uint8_t *)buf + offset, len - offset, "f",
1310                              msg->printer);
1311
1312         offset += tdb_unpack((uint8_t *)buf + offset, len - offset, "ddddddd",
1313                                 &tv_sec, &tv_usec,
1314                                 &msg->type, &msg->field, &msg->id, &msg->len, &msg->flags);
1315
1316         if (msg->len == 0)
1317                 tdb_unpack((uint8_t *)buf + offset, len - offset, "dd",
1318                            &msg->notify.value[0], &msg->notify.value[1]);
1319         else
1320                 tdb_unpack((uint8_t *)buf + offset, len - offset, "B",
1321                            &msg->len, &msg->notify.data);
1322
1323         DEBUG(3, ("notify2_unpack_msg: got NOTIFY2 message for printer %s, jobid %u type %d, field 0x%02x, flags 0x%04x\n",
1324                   msg->printer, (unsigned int)msg->id, msg->type, msg->field, msg->flags));
1325
1326         tv->tv_sec = tv_sec;
1327         tv->tv_usec = tv_usec;
1328
1329         if (msg->len == 0)
1330                 DEBUG(3, ("notify2_unpack_msg: value1 = %d, value2 = %d\n", msg->notify.value[0],
1331                           msg->notify.value[1]));
1332         else
1333                 dump_data(3, (uint8_t *)msg->notify.data, msg->len);
1334
1335         return true;
1336 }
1337
1338 /********************************************************************
1339  Receive a notify2 message list
1340  ********************************************************************/
1341
1342 static void receive_notify2_message_list(struct messaging_context *msg,
1343                                          void *private_data,
1344                                          uint32_t msg_type,
1345                                          struct server_id server_id,
1346                                          DATA_BLOB *data)
1347 {
1348         size_t                  msg_count, i;
1349         char                    *buf = (char *)data->data;
1350         char                    *msg_ptr;
1351         size_t                  msg_len;
1352         SPOOLSS_NOTIFY_MSG      notify;
1353         SPOOLSS_NOTIFY_MSG_CTR  messages;
1354         int                     num_groups;
1355
1356         if (data->length < 4) {
1357                 DEBUG(0,("receive_notify2_message_list: bad message format (len < 4)!\n"));
1358                 return;
1359         }
1360
1361         msg_count = IVAL(buf, 0);
1362         msg_ptr = buf + 4;
1363
1364         DEBUG(5, ("receive_notify2_message_list: got %lu messages in list\n", (unsigned long)msg_count));
1365
1366         if (msg_count == 0) {
1367                 DEBUG(0,("receive_notify2_message_list: bad message format (msg_count == 0) !\n"));
1368                 return;
1369         }
1370
1371         /* initialize the container */
1372
1373         ZERO_STRUCT( messages );
1374         notify_msg_ctr_init( &messages );
1375
1376         /*
1377          * build message groups for each printer identified
1378          * in a change_notify msg.  Remember that a PCN message
1379          * includes the handle returned for the srv_spoolss_replyopenprinter()
1380          * call.  Therefore messages are grouped according to printer handle.
1381          */
1382
1383         for ( i=0; i<msg_count; i++ ) {
1384                 struct timeval msg_tv;
1385
1386                 if (msg_ptr + 4 - buf > data->length) {
1387                         DEBUG(0,("receive_notify2_message_list: bad message format (len > buf_size) !\n"));
1388                         return;
1389                 }
1390
1391                 msg_len = IVAL(msg_ptr,0);
1392                 msg_ptr += 4;
1393
1394                 if (msg_ptr + msg_len - buf > data->length) {
1395                         DEBUG(0,("receive_notify2_message_list: bad message format (bad len) !\n"));
1396                         return;
1397                 }
1398
1399                 /* unpack messages */
1400
1401                 ZERO_STRUCT( notify );
1402                 notify2_unpack_msg( &notify, &msg_tv, msg_ptr, msg_len );
1403                 msg_ptr += msg_len;
1404
1405                 /* add to correct list in container */
1406
1407                 notify_msg_ctr_addmsg( &messages, &notify );
1408
1409                 /* free memory that might have been allocated by notify2_unpack_msg() */
1410
1411                 if ( notify.len != 0 )
1412                         SAFE_FREE( notify.notify.data );
1413         }
1414
1415         /* process each group of messages */
1416
1417         num_groups = notify_msg_ctr_numgroups( &messages );
1418         for ( i=0; i<num_groups; i++ )
1419                 send_notify2_changes( &messages, i );
1420
1421
1422         /* cleanup */
1423
1424         DEBUG(10,("receive_notify2_message_list: processed %u messages\n",
1425                 (uint32_t)msg_count ));
1426
1427         notify_msg_ctr_destroy( &messages );
1428
1429         return;
1430 }
1431
1432 /********************************************************************
1433  Send a message to ourself about new driver being installed
1434  so we can upgrade the information for each printer bound to this
1435  driver
1436  ********************************************************************/
1437
1438 static bool srv_spoolss_drv_upgrade_printer(const char *drivername,
1439                                             struct messaging_context *msg_ctx)
1440 {
1441         int len = strlen(drivername);
1442
1443         if (!len)
1444                 return false;
1445
1446         DEBUG(10,("srv_spoolss_drv_upgrade_printer: Sending message about driver upgrade [%s]\n",
1447                 drivername));
1448
1449         messaging_send_buf(msg_ctx, messaging_server_id(msg_ctx),
1450                            MSG_PRINTER_DRVUPGRADE,
1451                            (const uint8_t *)drivername, len+1);
1452
1453         return true;
1454 }
1455
1456 void srv_spoolss_cleanup(void)
1457 {
1458         struct printer_session_counter *session_counter;
1459
1460         for (session_counter = counter_list;
1461              session_counter != NULL;
1462              session_counter = counter_list) {
1463                 DLIST_REMOVE(counter_list, session_counter);
1464                 TALLOC_FREE(session_counter);
1465         }
1466 }
1467
1468 /**********************************************************************
1469  callback to receive a MSG_PRINTER_DRVUPGRADE message and interate
1470  over all printers, upgrading ones as necessary
1471  This is now *ONLY* called inside the background lpq updater. JRA.
1472  **********************************************************************/
1473
1474 void do_drv_upgrade_printer(struct messaging_context *msg,
1475                             void *private_data,
1476                             uint32_t msg_type,
1477                             struct server_id server_id,
1478                             DATA_BLOB *data)
1479 {
1480         TALLOC_CTX *tmp_ctx;
1481         const struct auth_session_info *session_info = get_session_info_system();
1482         struct spoolss_PrinterInfo2 *pinfo2;
1483         WERROR result;
1484         const char *drivername;
1485         int snum;
1486         int n_services = lp_numservices();
1487         struct dcerpc_binding_handle *b = NULL;
1488
1489         tmp_ctx = talloc_new(NULL);
1490         if (!tmp_ctx) return;
1491
1492         drivername = talloc_strndup(tmp_ctx, (const char *)data->data, data->length);
1493         if (!drivername) {
1494                 DEBUG(0, ("do_drv_upgrade_printer: Out of memoery ?!\n"));
1495                 goto done;
1496         }
1497
1498         DEBUG(10, ("do_drv_upgrade_printer: "
1499                    "Got message for new driver [%s]\n", drivername));
1500
1501         /* Iterate the printer list */
1502
1503         for (snum = 0; snum < n_services; snum++) {
1504                 if (!lp_snum_ok(snum) || !lp_printable(snum)) {
1505                         continue;
1506                 }
1507
1508                 /* ignore [printers] share */
1509                 if (strequal(lp_const_servicename(snum), "printers")) {
1510                         continue;
1511                 }
1512
1513                 if (b == NULL) {
1514                         result = winreg_printer_binding_handle(tmp_ctx,
1515                                                                session_info,
1516                                                                msg,
1517                                                                &b);
1518                         if (!W_ERROR_IS_OK(result)) {
1519                                 break;
1520                         }
1521                 }
1522
1523                 result = winreg_get_printer(tmp_ctx, b,
1524                                             lp_const_servicename(snum),
1525                                             &pinfo2);
1526
1527                 if (!W_ERROR_IS_OK(result)) {
1528                         continue;
1529                 }
1530
1531                 if (!pinfo2->drivername) {
1532                         continue;
1533                 }
1534
1535                 if (strcmp(drivername, pinfo2->drivername) != 0) {
1536                         continue;
1537                 }
1538
1539                 DEBUG(6,("Updating printer [%s]\n", pinfo2->printername));
1540
1541                 /* all we care about currently is the change_id */
1542                 result = winreg_printer_update_changeid(tmp_ctx, b,
1543                                                         pinfo2->printername);
1544
1545                 if (!W_ERROR_IS_OK(result)) {
1546                         DEBUG(3, ("do_drv_upgrade_printer: "
1547                                   "Failed to update changeid [%s]\n",
1548                                   win_errstr(result)));
1549                 }
1550         }
1551
1552         /* all done */
1553 done:
1554         talloc_free(tmp_ctx);
1555 }
1556
1557 /********************************************************************
1558  Update the cache for all printq's with a registered client
1559  connection
1560  ********************************************************************/
1561
1562 void update_monitored_printq_cache(struct messaging_context *msg_ctx)
1563 {
1564         struct printer_handle *printer = printers_list;
1565         int snum;
1566
1567         /* loop through all printers and update the cache where
1568            a client is connected */
1569         while (printer) {
1570                 if ((printer->printer_type == SPLHND_PRINTER) &&
1571                     ((printer->notify.cli_chan != NULL) &&
1572                      (printer->notify.cli_chan->active_connections > 0))) {
1573                         snum = print_queue_snum(printer->sharename);
1574                         print_queue_status(msg_ctx, snum, NULL, NULL);
1575                 }
1576
1577                 printer = printer->next;
1578         }
1579
1580         return;
1581 }
1582
1583 /****************************************************************
1584  _spoolss_OpenPrinter
1585 ****************************************************************/
1586
1587 WERROR _spoolss_OpenPrinter(struct pipes_struct *p,
1588                             struct spoolss_OpenPrinter *r)
1589 {
1590         struct spoolss_OpenPrinterEx e;
1591         struct spoolss_UserLevel1 level1;
1592         WERROR werr;
1593
1594         ZERO_STRUCT(level1);
1595
1596         e.in.printername        = r->in.printername;
1597         e.in.datatype           = r->in.datatype;
1598         e.in.devmode_ctr        = r->in.devmode_ctr;
1599         e.in.access_mask        = r->in.access_mask;
1600         e.in.userlevel_ctr.level                = 1;
1601         e.in.userlevel_ctr.user_info.level1     = &level1;
1602
1603         e.out.handle            = r->out.handle;
1604
1605         werr = _spoolss_OpenPrinterEx(p, &e);
1606
1607         if (W_ERROR_EQUAL(werr, WERR_INVALID_PARAMETER)) {
1608                 /* OpenPrinterEx returns this for a bad
1609                  * printer name. We must return WERR_INVALID_PRINTER_NAME
1610                  * instead.
1611                  */
1612                 werr = WERR_INVALID_PRINTER_NAME;
1613         }
1614
1615         return werr;
1616 }
1617
1618 static WERROR copy_devicemode(TALLOC_CTX *mem_ctx,
1619                               struct spoolss_DeviceMode *orig,
1620                               struct spoolss_DeviceMode **dest)
1621 {
1622         struct spoolss_DeviceMode *dm;
1623
1624         dm = talloc(mem_ctx, struct spoolss_DeviceMode);
1625         if (!dm) {
1626                 return WERR_NOT_ENOUGH_MEMORY;
1627         }
1628
1629         /* copy all values, then duplicate strings and structs */
1630         *dm = *orig;
1631
1632         dm->devicename = talloc_strdup(dm, orig->devicename);
1633         if (!dm->devicename) {
1634                 return WERR_NOT_ENOUGH_MEMORY;
1635         }
1636         dm->formname = talloc_strdup(dm, orig->formname);
1637         if (!dm->formname) {
1638                 return WERR_NOT_ENOUGH_MEMORY;
1639         }
1640         if (orig->driverextra_data.data) {
1641                 dm->driverextra_data.data =
1642                         (uint8_t *) talloc_memdup(dm, orig->driverextra_data.data,
1643                                         orig->driverextra_data.length);
1644                 if (!dm->driverextra_data.data) {
1645                         return WERR_NOT_ENOUGH_MEMORY;
1646                 }
1647         }
1648
1649         *dest = dm;
1650         return WERR_OK;
1651 }
1652
1653 /****************************************************************
1654  _spoolss_OpenPrinterEx
1655 ****************************************************************/
1656
1657 WERROR _spoolss_OpenPrinterEx(struct pipes_struct *p,
1658                               struct spoolss_OpenPrinterEx *r)
1659 {
1660         int snum;
1661         char *raddr;
1662         char *rhost;
1663         struct printer_handle *Printer=NULL;
1664         WERROR result;
1665         int rc;
1666
1667         if (!r->in.printername) {
1668                 return WERR_INVALID_PARAMETER;
1669         }
1670
1671         if (!*r->in.printername) {
1672                 return WERR_INVALID_PARAMETER;
1673         }
1674
1675         if (r->in.userlevel_ctr.level > 3) {
1676                 return WERR_INVALID_PARAMETER;
1677         }
1678         if ((r->in.userlevel_ctr.level == 1 && !r->in.userlevel_ctr.user_info.level1) ||
1679             (r->in.userlevel_ctr.level == 2 && !r->in.userlevel_ctr.user_info.level2) ||
1680             (r->in.userlevel_ctr.level == 3 && !r->in.userlevel_ctr.user_info.level3)) {
1681                 return WERR_INVALID_PARAMETER;
1682         }
1683
1684         /*
1685          * The printcap printer share inventory is updated on client
1686          * enumeration. For clients that do not perform enumeration prior to
1687          * access, such as cupssmbadd, we reinitialise the printer share
1688          * inventory on open as well.
1689          */
1690         become_root();
1691         delete_and_reload_printers(server_event_context(), p->msg_ctx);
1692         unbecome_root();
1693
1694         /* some sanity check because you can open a printer or a print server */
1695         /* aka: \\server\printer or \\server */
1696
1697         DEBUGADD(3,("checking name: %s\n", r->in.printername));
1698
1699         result = open_printer_hnd(p, r->out.handle, r->in.printername, 0);
1700         if (!W_ERROR_IS_OK(result)) {
1701                 DEBUG(3,("_spoolss_OpenPrinterEx: Cannot open a printer handle "
1702                         "for printer %s\n", r->in.printername));
1703                 ZERO_STRUCTP(r->out.handle);
1704                 return result;
1705         }
1706
1707         Printer = find_printer_index_by_hnd(p, r->out.handle);
1708         if ( !Printer ) {
1709                 DEBUG(0,("_spoolss_OpenPrinterEx: logic error.  Can't find printer "
1710                         "handle we created for printer %s\n", r->in.printername));
1711                 close_printer_handle(p, r->out.handle);
1712                 ZERO_STRUCTP(r->out.handle);
1713                 return WERR_INVALID_PARAMETER;
1714         }
1715
1716         /*
1717          * First case: the user is opening the print server:
1718          *
1719          * Disallow MS AddPrinterWizard if parameter disables it. A Win2k
1720          * client 1st tries an OpenPrinterEx with access==0, MUST be allowed.
1721          *
1722          * Then both Win2k and WinNT clients try an OpenPrinterEx with
1723          * SERVER_ALL_ACCESS, which we allow only if the user is root (uid=0)
1724          * or if the user is listed in the smb.conf printer admin parameter.
1725          *
1726          * Then they try OpenPrinterEx with SERVER_READ which we allow. This lets the
1727          * client view printer folder, but does not show the MSAPW.
1728          *
1729          * Note: this test needs code to check access rights here too. Jeremy
1730          * could you look at this?
1731          *
1732          * Second case: the user is opening a printer:
1733          * NT doesn't let us connect to a printer if the connecting user
1734          * doesn't have print permission.
1735          *
1736          * Third case: user is opening a Port Monitor
1737          * access checks same as opening a handle to the print server.
1738          */
1739
1740         switch (Printer->printer_type )
1741         {
1742         case SPLHND_SERVER:
1743         case SPLHND_PORTMON_TCP:
1744         case SPLHND_PORTMON_LOCAL:
1745                 /* Printserver handles use global struct... */
1746
1747                 snum = -1;
1748
1749                 if (r->in.access_mask & SEC_FLAG_MAXIMUM_ALLOWED) {
1750                         r->in.access_mask |= SERVER_ACCESS_ADMINISTER;
1751                         r->in.access_mask |= SERVER_ACCESS_ENUMERATE;
1752                 }
1753
1754                 /* Map standard access rights to object specific access rights */
1755
1756                 se_map_standard(&r->in.access_mask,
1757                                 &printserver_std_mapping);
1758
1759                 /* Deny any object specific bits that don't apply to print
1760                    servers (i.e printer and job specific bits) */
1761
1762                 r->in.access_mask &= SEC_MASK_SPECIFIC;
1763
1764                 if (r->in.access_mask &
1765                     ~(SERVER_ACCESS_ADMINISTER | SERVER_ACCESS_ENUMERATE)) {
1766                         DEBUG(3, ("access DENIED for non-printserver bits\n"));
1767                         close_printer_handle(p, r->out.handle);
1768                         ZERO_STRUCTP(r->out.handle);
1769                         return WERR_ACCESS_DENIED;
1770                 }
1771
1772                 /* Allow admin access */
1773
1774                 if ( r->in.access_mask & SERVER_ACCESS_ADMINISTER )
1775                 {
1776                         if (!lp_show_add_printer_wizard()) {
1777                                 close_printer_handle(p, r->out.handle);
1778                                 ZERO_STRUCTP(r->out.handle);
1779                                 return WERR_ACCESS_DENIED;
1780                         }
1781
1782                         /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
1783                            and not a printer admin, then fail */
1784
1785                         if ((p->session_info->unix_token->uid != sec_initial_uid()) &&
1786                             !security_token_has_privilege(p->session_info->security_token, SEC_PRIV_PRINT_OPERATOR) &&
1787                             !nt_token_check_sid(&global_sid_Builtin_Print_Operators,
1788                                                 p->session_info->security_token)) {
1789                                 close_printer_handle(p, r->out.handle);
1790                                 ZERO_STRUCTP(r->out.handle);
1791                                 DEBUG(3,("access DENIED as user is not root, "
1792                                         "has no printoperator privilege and is "
1793                                         "not a member of the printoperator builtin group\n"));
1794                                 return WERR_ACCESS_DENIED;
1795                         }
1796
1797                         r->in.access_mask = SERVER_ACCESS_ADMINISTER;
1798                 }
1799                 else
1800                 {
1801                         r->in.access_mask = SERVER_ACCESS_ENUMERATE;
1802                 }
1803
1804                 DEBUG(4,("Setting print server access = %s\n", (r->in.access_mask == SERVER_ACCESS_ADMINISTER)
1805                         ? "SERVER_ACCESS_ADMINISTER" : "SERVER_ACCESS_ENUMERATE" ));
1806
1807                 /* We fall through to return WERR_OK */
1808                 break;
1809
1810         case SPLHND_PRINTER:
1811                 /* NT doesn't let us connect to a printer if the connecting user
1812                    doesn't have print permission.  */
1813
1814                 if (!get_printer_snum(p, r->out.handle, &snum, NULL)) {
1815                         close_printer_handle(p, r->out.handle);
1816                         ZERO_STRUCTP(r->out.handle);
1817                         return WERR_INVALID_HANDLE;
1818                 }
1819
1820                 if (r->in.access_mask == SEC_FLAG_MAXIMUM_ALLOWED) {
1821                         r->in.access_mask = PRINTER_ACCESS_ADMINISTER;
1822                 }
1823
1824                 se_map_standard(&r->in.access_mask, &printer_std_mapping);
1825
1826                 /* map an empty access mask to the minimum access mask */
1827                 if (r->in.access_mask == 0x0)
1828                         r->in.access_mask = PRINTER_ACCESS_USE;
1829
1830                 /*
1831                  * If we are not serving the printer driver for this printer,
1832                  * map PRINTER_ACCESS_ADMINISTER to PRINTER_ACCESS_USE.  This
1833                  * will keep NT clients happy  --jerry
1834                  */
1835
1836                 if (lp_use_client_driver(snum)
1837                         && (r->in.access_mask & PRINTER_ACCESS_ADMINISTER))
1838                 {
1839                         r->in.access_mask = PRINTER_ACCESS_USE;
1840                 }
1841
1842                 /* check smb.conf parameters and the the sec_desc */
1843                 raddr = tsocket_address_inet_addr_string(p->remote_address,
1844                                                          p->mem_ctx);
1845                 if (raddr == NULL) {
1846                         return WERR_NOT_ENOUGH_MEMORY;
1847                 }
1848
1849                 rc = get_remote_hostname(p->remote_address,
1850                                          &rhost,
1851                                          p->mem_ctx);
1852                 if (rc < 0) {
1853                         return WERR_NOT_ENOUGH_MEMORY;
1854                 }
1855                 if (strequal(rhost, "UNKNOWN")) {
1856                         rhost = raddr;
1857                 }
1858
1859                 if (!allow_access(lp_hosts_deny(snum), lp_hosts_allow(snum),
1860                                   rhost, raddr)) {
1861                         DEBUG(3, ("access DENIED (hosts allow/deny) for printer open\n"));
1862                         ZERO_STRUCTP(r->out.handle);
1863                         return WERR_ACCESS_DENIED;
1864                 }
1865
1866                 if (!user_ok_token(uidtoname(p->session_info->unix_token->uid), NULL,
1867                                    p->session_info->security_token, snum) ||
1868                     !W_ERROR_IS_OK(print_access_check(p->session_info,
1869                                                       p->msg_ctx,
1870                                                       snum,
1871                                                       r->in.access_mask))) {
1872                         DEBUG(3, ("access DENIED for printer open\n"));
1873                         close_printer_handle(p, r->out.handle);
1874                         ZERO_STRUCTP(r->out.handle);
1875                         return WERR_ACCESS_DENIED;
1876                 }
1877
1878                 if ((r->in.access_mask & SEC_MASK_SPECIFIC)& ~(PRINTER_ACCESS_ADMINISTER|PRINTER_ACCESS_USE)) {
1879                         DEBUG(3, ("access DENIED for printer open - unknown bits\n"));
1880                         close_printer_handle(p, r->out.handle);
1881                         ZERO_STRUCTP(r->out.handle);
1882                         return WERR_ACCESS_DENIED;
1883                 }
1884
1885                 if (r->in.access_mask & PRINTER_ACCESS_ADMINISTER)
1886                         r->in.access_mask = PRINTER_ACCESS_ADMINISTER;
1887                 else
1888                         r->in.access_mask = PRINTER_ACCESS_USE;
1889
1890                 DEBUG(4,("Setting printer access = %s\n", (r->in.access_mask == PRINTER_ACCESS_ADMINISTER)
1891                         ? "PRINTER_ACCESS_ADMINISTER" : "PRINTER_ACCESS_USE" ));
1892
1893                 winreg_create_printer_internal(p->mem_ctx,
1894                                       get_session_info_system(),
1895                                       p->msg_ctx,
1896                                       lp_const_servicename(snum));
1897
1898                 break;
1899
1900         default:
1901                 /* sanity check to prevent programmer error */
1902                 ZERO_STRUCTP(r->out.handle);
1903                 return WERR_INVALID_HANDLE;
1904         }
1905
1906         Printer->access_granted = r->in.access_mask;
1907
1908         /*
1909          * If the client sent a devmode in the OpenPrinter() call, then
1910          * save it here in case we get a job submission on this handle
1911          */
1912
1913          if ((Printer->printer_type != SPLHND_SERVER)
1914           && (r->in.devmode_ctr.devmode != NULL)) {
1915                 copy_devicemode(NULL, r->in.devmode_ctr.devmode,
1916                                 &Printer->devmode);
1917          }
1918
1919         return WERR_OK;
1920 }
1921
1922 /****************************************************************
1923  _spoolss_ClosePrinter
1924 ****************************************************************/
1925
1926 WERROR _spoolss_ClosePrinter(struct pipes_struct *p,
1927                              struct spoolss_ClosePrinter *r)
1928 {
1929         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
1930
1931         if (Printer && Printer->document_started) {
1932                 struct spoolss_EndDocPrinter e;
1933
1934                 e.in.handle = r->in.handle;
1935
1936                 _spoolss_EndDocPrinter(p, &e);
1937         }
1938
1939         if (!close_printer_handle(p, r->in.handle))
1940                 return WERR_INVALID_HANDLE;
1941
1942         /* clear the returned printer handle.  Observed behavior
1943            from Win2k server.  Don't think this really matters.
1944            Previous code just copied the value of the closed
1945            handle.    --jerry */
1946
1947         ZERO_STRUCTP(r->out.handle);
1948
1949         return WERR_OK;
1950 }
1951
1952 /****************************************************************
1953  _spoolss_DeletePrinter
1954 ****************************************************************/
1955
1956 WERROR _spoolss_DeletePrinter(struct pipes_struct *p,
1957                               struct spoolss_DeletePrinter *r)
1958 {
1959         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
1960         WERROR result;
1961         int snum;
1962
1963         if (Printer && Printer->document_started) {
1964                 struct spoolss_EndDocPrinter e;
1965
1966                 e.in.handle = r->in.handle;
1967
1968                 _spoolss_EndDocPrinter(p, &e);
1969         }
1970
1971         if (get_printer_snum(p, r->in.handle, &snum, NULL)) {
1972                 winreg_delete_printer_key_internal(p->mem_ctx,
1973                                           get_session_info_system(),
1974                                           p->msg_ctx,
1975                                           lp_const_servicename(snum),
1976                                           "");
1977         }
1978
1979         result = delete_printer_handle(p, r->in.handle);
1980
1981         return result;
1982 }
1983
1984 /*******************************************************************
1985  * static function to lookup the version id corresponding to an
1986  * long architecture string
1987  ******************************************************************/
1988
1989 static const struct print_architecture_table_node archi_table[]= {
1990
1991         {"Windows 4.0",          SPL_ARCH_WIN40,        0 },
1992         {"Windows NT x86",       SPL_ARCH_W32X86,       2 },
1993         {"Windows NT R4000",     SPL_ARCH_W32MIPS,      2 },
1994         {"Windows NT Alpha_AXP", SPL_ARCH_W32ALPHA,     2 },
1995         {"Windows NT PowerPC",   SPL_ARCH_W32PPC,       2 },
1996         {"Windows IA64",         SPL_ARCH_IA64,         3 },
1997         {"Windows x64",          SPL_ARCH_X64,          3 },
1998         {NULL,                   "",            -1 }
1999 };
2000
2001 static const int drv_cversion[] = {SPOOLSS_DRIVER_VERSION_9X,
2002                                    SPOOLSS_DRIVER_VERSION_NT35,
2003                                    SPOOLSS_DRIVER_VERSION_NT4,
2004                                    SPOOLSS_DRIVER_VERSION_200X,
2005                                    -1};
2006
2007 static int get_version_id(const char *arch)
2008 {
2009         int i;
2010
2011         for (i=0; archi_table[i].long_archi != NULL; i++)
2012         {
2013                 if (strcmp(arch, archi_table[i].long_archi) == 0)
2014                         return (archi_table[i].version);
2015         }
2016
2017         return -1;
2018 }
2019
2020 /****************************************************************
2021  _spoolss_DeletePrinterDriver
2022 ****************************************************************/
2023
2024 WERROR _spoolss_DeletePrinterDriver(struct pipes_struct *p,
2025                                     struct spoolss_DeletePrinterDriver *r)
2026 {
2027
2028         struct spoolss_DriverInfo8 *info = NULL;
2029         int                             version;
2030         WERROR                          status;
2031         struct dcerpc_binding_handle *b;
2032         TALLOC_CTX *tmp_ctx = NULL;
2033         int i;
2034         bool found;
2035
2036         /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
2037            and not a printer admin, then fail */
2038
2039         if ((p->session_info->unix_token->uid != sec_initial_uid()) &&
2040             !security_token_has_privilege(p->session_info->security_token,
2041                                           SEC_PRIV_PRINT_OPERATOR)) {
2042                 return WERR_ACCESS_DENIED;
2043         }
2044
2045         /* check that we have a valid driver name first */
2046
2047         if ((version = get_version_id(r->in.architecture)) == -1) {
2048                 return WERR_INVALID_ENVIRONMENT;
2049         }
2050
2051         tmp_ctx = talloc_new(p->mem_ctx);
2052         if (!tmp_ctx) {
2053                 return WERR_NOT_ENOUGH_MEMORY;
2054         }
2055
2056         status = winreg_printer_binding_handle(tmp_ctx,
2057                                                get_session_info_system(),
2058                                                p->msg_ctx,
2059                                                &b);
2060         if (!W_ERROR_IS_OK(status)) {
2061                 goto done;
2062         }
2063
2064         for (found = false, i = 0; drv_cversion[i] >= 0; i++) {
2065                 status = winreg_get_driver(tmp_ctx, b,
2066                                            r->in.architecture, r->in.driver,
2067                                            drv_cversion[i], &info);
2068                 if (!W_ERROR_IS_OK(status)) {
2069                         DEBUG(5, ("skipping del of driver with version %d\n",
2070                                   drv_cversion[i]));
2071                         continue;
2072                 }
2073                 found = true;
2074
2075                 if (printer_driver_in_use(tmp_ctx, b, info)) {
2076                         status = WERR_PRINTER_DRIVER_IN_USE;
2077                         goto done;
2078                 }
2079
2080                 status = winreg_del_driver(tmp_ctx, b, info, drv_cversion[i]);
2081                 if (!W_ERROR_IS_OK(status)) {
2082                         DEBUG(0, ("failed del of driver with version %d\n",
2083                                   drv_cversion[i]));
2084                         goto done;
2085                 }
2086         }
2087         if (found == false) {
2088                 DEBUG(0, ("driver %s not found for deletion\n", r->in.driver));
2089                 status = WERR_UNKNOWN_PRINTER_DRIVER;
2090         } else {
2091                 status = WERR_OK;
2092         }
2093
2094 done:
2095         talloc_free(tmp_ctx);
2096
2097         return status;
2098 }
2099
2100 static WERROR spoolss_dpd_version(TALLOC_CTX *mem_ctx,
2101                                   struct pipes_struct *p,
2102                                   struct spoolss_DeletePrinterDriverEx *r,
2103                                   struct dcerpc_binding_handle *b,
2104                                   struct spoolss_DriverInfo8 *info)
2105 {
2106         WERROR status;
2107         bool delete_files;
2108
2109         if (printer_driver_in_use(mem_ctx, b, info)) {
2110                 status = WERR_PRINTER_DRIVER_IN_USE;
2111                 goto done;
2112         }
2113
2114         /*
2115          * we have a couple of cases to consider.
2116          * (1) Are any files in use?  If so and DPD_DELETE_ALL_FILES is set,
2117          *     then the delete should fail if **any** files overlap with
2118          *     other drivers
2119          * (2) If DPD_DELETE_UNUSED_FILES is set, then delete all
2120          *     non-overlapping files
2121          * (3) If neither DPD_DELETE_ALL_FILES nor DPD_DELETE_UNUSED_FILES
2122          *     are set, then do not delete any files
2123          * Refer to MSDN docs on DeletePrinterDriverEx() for details.
2124          */
2125
2126         delete_files = r->in.delete_flags
2127                         & (DPD_DELETE_ALL_FILES | DPD_DELETE_UNUSED_FILES);
2128
2129
2130         if (delete_files) {
2131                 bool in_use = printer_driver_files_in_use(mem_ctx, b, info);
2132                 if (in_use && (r->in.delete_flags & DPD_DELETE_ALL_FILES)) {
2133                         status = WERR_PRINTER_DRIVER_IN_USE;
2134                         goto done;
2135                 }
2136                 /*
2137                  * printer_driver_files_in_use() has trimmed overlapping files
2138                  * from info so they are not removed on DPD_DELETE_UNUSED_FILES
2139                  */
2140         }
2141
2142
2143         status = winreg_del_driver(mem_ctx, b, info, info->version);
2144         if (!W_ERROR_IS_OK(status)) {
2145                 goto done;
2146         }
2147
2148         /*
2149          * now delete any associated files if delete_files is
2150          * true. Even if this part failes, we return succes
2151          * because the driver doesn not exist any more
2152          */
2153         if (delete_files) {
2154                 delete_driver_files(p->session_info, info);
2155         }
2156
2157 done:
2158         return status;
2159 }
2160
2161 /****************************************************************
2162  _spoolss_DeletePrinterDriverEx
2163 ****************************************************************/
2164
2165 WERROR _spoolss_DeletePrinterDriverEx(struct pipes_struct *p,
2166                                       struct spoolss_DeletePrinterDriverEx *r)
2167 {
2168         struct spoolss_DriverInfo8 *info = NULL;
2169         WERROR                          status;
2170         struct dcerpc_binding_handle *b;
2171         TALLOC_CTX *tmp_ctx = NULL;
2172         int i;
2173         bool found;
2174
2175         /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
2176            and not a printer admin, then fail */
2177
2178         if ((p->session_info->unix_token->uid != sec_initial_uid()) &&
2179             !security_token_has_privilege(p->session_info->security_token,
2180                                           SEC_PRIV_PRINT_OPERATOR)) {
2181                 return WERR_ACCESS_DENIED;
2182         }
2183
2184         /* check that we have a valid driver name first */
2185         if (get_version_id(r->in.architecture) == -1) {
2186                 /* this is what NT returns */
2187                 return WERR_INVALID_ENVIRONMENT;
2188         }
2189
2190         tmp_ctx = talloc_new(p->mem_ctx);
2191         if (!tmp_ctx) {
2192                 return WERR_NOT_ENOUGH_MEMORY;
2193         }
2194
2195         status = winreg_printer_binding_handle(tmp_ctx,
2196                                                get_session_info_system(),
2197                                                p->msg_ctx,
2198                                                &b);
2199         if (!W_ERROR_IS_OK(status)) {
2200                 goto done;
2201         }
2202
2203         for (found = false, i = 0; drv_cversion[i] >= 0; i++) {
2204                 if ((r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION)
2205                  && (drv_cversion[i] != r->in.version)) {
2206                         continue;
2207                 }
2208
2209                 /* check if a driver with this version exists before delete */
2210                 status = winreg_get_driver(tmp_ctx, b,
2211                                            r->in.architecture, r->in.driver,
2212                                            drv_cversion[i], &info);
2213                 if (!W_ERROR_IS_OK(status)) {
2214                         DEBUG(5, ("skipping del of driver with version %d\n",
2215                                   drv_cversion[i]));
2216                         continue;
2217                 }
2218                 found = true;
2219
2220                 status = spoolss_dpd_version(tmp_ctx, p, r, b, info);
2221                 if (!W_ERROR_IS_OK(status)) {
2222                         DEBUG(0, ("failed to delete driver with version %d\n",
2223                                   drv_cversion[i]));
2224                         goto done;
2225                 }
2226         }
2227         if (found == false) {
2228                 DEBUG(0, ("driver %s not found for deletion\n", r->in.driver));
2229                 status = WERR_UNKNOWN_PRINTER_DRIVER;
2230         } else {
2231                 status = WERR_OK;
2232         }
2233
2234 done:
2235         talloc_free(tmp_ctx);
2236         return status;
2237 }
2238
2239
2240 /********************************************************************
2241  GetPrinterData on a printer server Handle.
2242 ********************************************************************/
2243
2244 static WERROR getprinterdata_printer_server(TALLOC_CTX *mem_ctx,
2245                                             const char *value,
2246                                             enum winreg_Type *type,
2247                                             union spoolss_PrinterData *data)
2248 {
2249         DEBUG(8,("getprinterdata_printer_server:%s\n", value));
2250
2251         if (!strcasecmp_m(value, "W3SvcInstalled")) {
2252                 *type = REG_DWORD;
2253                 SIVAL(&data->value, 0, 0x00);
2254                 return WERR_OK;
2255         }
2256
2257         if (!strcasecmp_m(value, "BeepEnabled")) {
2258                 *type = REG_DWORD;
2259                 SIVAL(&data->value, 0, 0x00);
2260                 return WERR_OK;
2261         }
2262
2263         if (!strcasecmp_m(value, "EventLog")) {
2264                 *type = REG_DWORD;
2265                 /* formally was 0x1b */
2266                 SIVAL(&data->value, 0, 0x00);
2267                 return WERR_OK;
2268         }
2269
2270         if (!strcasecmp_m(value, "NetPopup")) {
2271                 *type = REG_DWORD;
2272                 SIVAL(&data->value, 0, 0x00);
2273                 return WERR_OK;
2274         }
2275
2276         if (!strcasecmp_m(value, "MajorVersion")) {
2277                 *type = REG_DWORD;
2278
2279                 /* Windows NT 4.0 seems to not allow uploading of drivers
2280                    to a server that reports 0x3 as the MajorVersion.
2281                    need to investigate more how Win2k gets around this .
2282                    -- jerry */
2283
2284                 if (RA_WINNT == get_remote_arch()) {
2285                         SIVAL(&data->value, 0, 0x02);
2286                 } else {
2287                         SIVAL(&data->value, 0, 0x03);
2288                 }
2289
2290                 return WERR_OK;
2291         }
2292
2293         if (!strcasecmp_m(value, "MinorVersion")) {
2294                 *type = REG_DWORD;
2295                 SIVAL(&data->value, 0, 0x00);
2296                 return WERR_OK;
2297         }
2298
2299         /* REG_BINARY
2300          *  uint32_t size        = 0x114
2301          *  uint32_t major       = 5
2302          *  uint32_t minor       = [0|1]
2303          *  uint32_t build       = [2195|2600]
2304          *  extra unicode string = e.g. "Service Pack 3"
2305          */
2306         if (!strcasecmp_m(value, "OSVersion")) {
2307                 DATA_BLOB blob;
2308                 enum ndr_err_code ndr_err;
2309                 struct spoolss_OSVersion os;
2310
2311                 /*
2312                  * Set the default OSVersion to:
2313                  *
2314                  *     Windows Server 2003R2 SP2 (5.2.3790)
2315                  *
2316                  * used to be Windows 2000 (5.0.2195)
2317                  */
2318                 os.major                = lp_parm_int(GLOBAL_SECTION_SNUM,
2319                                                       "spoolss", "os_major",
2320                                                       GLOBAL_SPOOLSS_OS_MAJOR_DEFAULT);
2321                 os.minor                = lp_parm_int(GLOBAL_SECTION_SNUM,
2322                                                       "spoolss", "os_minor",
2323                                                       GLOBAL_SPOOLSS_OS_MINOR_DEFAULT);
2324                 os.build                = lp_parm_int(GLOBAL_SECTION_SNUM,
2325                                                       "spoolss", "os_build",
2326                                                       GLOBAL_SPOOLSS_OS_BUILD_DEFAULT);
2327                 os.extra_string         = "";   /* leave extra string empty */
2328
2329                 ndr_err = ndr_push_struct_blob(&blob, mem_ctx, &os,
2330                         (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion);
2331                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2332                         return WERR_GEN_FAILURE;
2333                 }
2334
2335                 if (DEBUGLEVEL >= 10) {
2336                         NDR_PRINT_DEBUG(spoolss_OSVersion, &os);
2337                 }
2338
2339                 *type = REG_BINARY;
2340                 data->binary = blob;
2341
2342                 return WERR_OK;
2343         }
2344
2345
2346         if (!strcasecmp_m(value, "DefaultSpoolDirectory")) {
2347                 *type = REG_SZ;
2348
2349                 data->string = talloc_strdup(mem_ctx, SPOOLSS_DEFAULT_SERVER_PATH);
2350                 W_ERROR_HAVE_NO_MEMORY(data->string);
2351
2352                 return WERR_OK;
2353         }
2354
2355         if (!strcasecmp_m(value, "Architecture")) {
2356                 *type = REG_SZ;
2357                 data->string = talloc_strdup(mem_ctx,
2358                         lp_parm_const_string(GLOBAL_SECTION_SNUM, "spoolss", "architecture", GLOBAL_SPOOLSS_ARCHITECTURE));
2359                 W_ERROR_HAVE_NO_MEMORY(data->string);
2360
2361                 return WERR_OK;
2362         }
2363
2364         if (!strcasecmp_m(value, "DsPresent")) {
2365                 *type = REG_DWORD;
2366
2367                 /* only show the publish check box if we are a
2368                    member of a AD domain */
2369
2370                 if (lp_security() == SEC_ADS) {
2371                         SIVAL(&data->value, 0, 0x01);
2372                 } else {
2373                         SIVAL(&data->value, 0, 0x00);
2374                 }
2375                 return WERR_OK;
2376         }
2377
2378         if (!strcasecmp_m(value, "DNSMachineName")) {
2379                 const char *hostname = get_mydnsfullname();
2380
2381                 if (!hostname) {
2382                         return WERR_FILE_NOT_FOUND;
2383                 }
2384
2385                 *type = REG_SZ;
2386                 data->string = talloc_strdup(mem_ctx, hostname);
2387                 W_ERROR_HAVE_NO_MEMORY(data->string);
2388
2389                 return WERR_OK;
2390         }
2391
2392         *type = REG_NONE;
2393
2394         return WERR_INVALID_PARAMETER;
2395 }
2396
2397 /****************************************************************
2398  _spoolss_GetPrinterData
2399 ****************************************************************/
2400
2401 WERROR _spoolss_GetPrinterData(struct pipes_struct *p,
2402                                struct spoolss_GetPrinterData *r)
2403 {
2404         struct spoolss_GetPrinterDataEx r2;
2405
2406         r2.in.handle            = r->in.handle;
2407         r2.in.key_name          = "PrinterDriverData";
2408         r2.in.value_name        = r->in.value_name;
2409         r2.in.offered           = r->in.offered;
2410         r2.out.type             = r->out.type;
2411         r2.out.data             = r->out.data;
2412         r2.out.needed           = r->out.needed;
2413
2414         return _spoolss_GetPrinterDataEx(p, &r2);
2415 }
2416
2417 /*********************************************************
2418  Connect to the client machine.
2419 **********************************************************/
2420
2421 static bool spoolss_connect_to_client(struct rpc_pipe_client **pp_pipe, struct cli_state **pp_cli,
2422                                       struct sockaddr_storage *client_ss, const char *remote_machine)
2423 {
2424         NTSTATUS ret;
2425         struct sockaddr_storage rm_addr;
2426         char addr[INET6_ADDRSTRLEN];
2427
2428         if ( is_zero_addr(client_ss) ) {
2429                 DEBUG(2,("spoolss_connect_to_client: resolving %s\n",
2430                         remote_machine));
2431                 if ( !resolve_name( remote_machine, &rm_addr, 0x20, false) ) {
2432                         DEBUG(2,("spoolss_connect_to_client: Can't resolve address for %s\n", remote_machine));
2433                         return false;
2434                 }
2435                 print_sockaddr(addr, sizeof(addr), &rm_addr);
2436         } else {
2437                 rm_addr = *client_ss;
2438                 print_sockaddr(addr, sizeof(addr), &rm_addr);
2439                 DEBUG(5,("spoolss_connect_to_client: Using address %s (no name resolution necessary)\n",
2440                         addr));
2441         }
2442
2443         if (ismyaddr((struct sockaddr *)(void *)&rm_addr)) {
2444                 DEBUG(0,("spoolss_connect_to_client: Machine %s is one of our addresses. Cannot add to ourselves.\n",
2445                         addr));
2446                 return false;
2447         }
2448
2449         /* setup the connection */
2450         ret = cli_full_connection( pp_cli, lp_netbios_name(), remote_machine,
2451                 &rm_addr, 0, "IPC$", "IPC",
2452                 "", /* username */
2453                 "", /* domain */
2454                 "", /* password */
2455                 0, lp_client_signing());
2456
2457         if ( !NT_STATUS_IS_OK( ret ) ) {
2458                 DEBUG(2,("spoolss_connect_to_client: connection to [%s] failed!\n",
2459                         remote_machine ));
2460                 return false;
2461         }
2462
2463         if ( smbXcli_conn_protocol((*pp_cli)->conn) != PROTOCOL_NT1 ) {
2464                 DEBUG(0,("spoolss_connect_to_client: machine %s didn't negotiate NT protocol.\n", remote_machine));
2465                 cli_shutdown(*pp_cli);
2466                 return false;
2467         }
2468
2469         /*
2470          * Ok - we have an anonymous connection to the IPC$ share.
2471          * Now start the NT Domain stuff :-).
2472          */
2473
2474         ret = cli_rpc_pipe_open_noauth(*pp_cli, &ndr_table_spoolss, pp_pipe);
2475         if (!NT_STATUS_IS_OK(ret)) {
2476                 DEBUG(2,("spoolss_connect_to_client: unable to open the spoolss pipe on machine %s. Error was : %s.\n",
2477                         remote_machine, nt_errstr(ret)));
2478                 cli_shutdown(*pp_cli);
2479                 return false;
2480         }
2481
2482         return true;
2483 }
2484
2485 /***************************************************************************
2486  Connect to the client.
2487 ****************************************************************************/
2488
2489 static bool srv_spoolss_replyopenprinter(int snum, const char *printer,
2490                                         uint32_t localprinter,
2491                                         enum winreg_Type type,
2492                                         struct policy_handle *handle,
2493                                         struct notify_back_channel **_chan,
2494                                         struct sockaddr_storage *client_ss,
2495                                         struct messaging_context *msg_ctx)
2496 {
2497         WERROR result;
2498         NTSTATUS status;
2499         struct notify_back_channel *chan;
2500
2501         for (chan = back_channels; chan; chan = chan->next) {
2502                 if (memcmp(&chan->client_address, client_ss,
2503                            sizeof(struct sockaddr_storage)) == 0) {
2504                         break;
2505                 }
2506         }
2507
2508         /*
2509          * If it's the first connection, contact the client
2510          * and connect to the IPC$ share anonymously
2511          */
2512         if (!chan) {
2513                 fstring unix_printer;
2514
2515                 /* the +2 is to strip the leading 2 backslashs */
2516                 fstrcpy(unix_printer, printer + 2);
2517
2518                 chan = talloc_zero(NULL, struct notify_back_channel);
2519                 if (!chan) {
2520                         return false;
2521                 }
2522                 chan->client_address = *client_ss;
2523
2524                 if (!spoolss_connect_to_client(&chan->cli_pipe, &chan->cli, client_ss, unix_printer)) {
2525                         TALLOC_FREE(chan);
2526                         return false;
2527                 }
2528
2529                 DLIST_ADD(back_channels, chan);
2530
2531                 messaging_register(msg_ctx, NULL, MSG_PRINTER_NOTIFY2,
2532                                    receive_notify2_message_list);
2533         }
2534
2535         if (chan->cli_pipe == NULL ||
2536             chan->cli_pipe->binding_handle == NULL) {
2537                 DEBUG(0, ("srv_spoolss_replyopenprinter: error - "
2538                         "NULL %s for printer %s\n",
2539                         chan->cli_pipe == NULL ?
2540                         "chan->cli_pipe" : "chan->cli_pipe->binding_handle",
2541                         printer));
2542                 return false;
2543         }
2544
2545         /*
2546          * Tell the specific printing tdb we want messages for this printer
2547          * by registering our PID.
2548          */
2549
2550         if (!print_notify_register_pid(snum)) {
2551                 DEBUG(0, ("Failed to register our pid for printer %s\n",
2552                           printer));
2553         }
2554
2555         status = dcerpc_spoolss_ReplyOpenPrinter(chan->cli_pipe->binding_handle,
2556                                                  talloc_tos(),
2557                                                  printer,
2558                                                  localprinter,
2559                                                  type,
2560                                                  0,
2561                                                  NULL,
2562                                                  handle,
2563                                                  &result);
2564         if (!NT_STATUS_IS_OK(status)) {
2565                 DEBUG(5, ("dcerpc_spoolss_ReplyOpenPrinter returned [%s]\n", nt_errstr(status)));
2566                 result = ntstatus_to_werror(status);
2567         } else if (!W_ERROR_IS_OK(result)) {
2568                 DEBUG(5, ("ReplyOpenPrinter returned [%s]\n", win_errstr(result)));
2569         }
2570
2571         chan->active_connections++;
2572         *_chan = chan;
2573
2574         return (W_ERROR_IS_OK(result));
2575 }
2576
2577 /****************************************************************
2578  ****************************************************************/
2579
2580 static struct spoolss_NotifyOption *dup_spoolss_NotifyOption(TALLOC_CTX *mem_ctx,
2581                                                              const struct spoolss_NotifyOption *r)
2582 {
2583         struct spoolss_NotifyOption *option;
2584         uint32_t i,k;
2585
2586         if (!r) {
2587                 return NULL;
2588         }
2589
2590         option = talloc_zero(mem_ctx, struct spoolss_NotifyOption);
2591         if (!option) {
2592                 return NULL;
2593         }
2594
2595         *option = *r;
2596
2597         if (!option->count) {
2598                 return option;
2599         }
2600
2601         option->types = talloc_zero_array(option,
2602                 struct spoolss_NotifyOptionType, option->count);
2603         if (!option->types) {
2604                 talloc_free(option);
2605                 return NULL;
2606         }
2607
2608         for (i=0; i < option->count; i++) {
2609                 option->types[i] = r->types[i];
2610
2611                 if (option->types[i].count) {
2612                         option->types[i].fields = talloc_zero_array(option,
2613                                 union spoolss_Field, option->types[i].count);
2614                         if (!option->types[i].fields) {
2615                                 talloc_free(option);
2616                                 return NULL;
2617                         }
2618                         for (k=0; k<option->types[i].count; k++) {
2619                                 option->types[i].fields[k] =
2620                                         r->types[i].fields[k];
2621                         }
2622                 }
2623         }
2624
2625         return option;
2626 }
2627
2628 /****************************************************************
2629  * _spoolss_RemoteFindFirstPrinterChangeNotifyEx
2630  *
2631  * before replying OK: status=0 a rpc call is made to the workstation
2632  * asking ReplyOpenPrinter
2633  *
2634  * in fact ReplyOpenPrinter is the changenotify equivalent on the spoolss pipe
2635  * called from api_spoolss_rffpcnex
2636 ****************************************************************/
2637
2638 WERROR _spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct pipes_struct *p,
2639                                                      struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
2640 {
2641         int snum = -1;
2642         struct spoolss_NotifyOption *option = r->in.notify_options;
2643         struct sockaddr_storage client_ss;
2644         ssize_t client_len;
2645
2646         /* store the notify value in the printer struct */
2647
2648         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
2649
2650         if (!Printer) {
2651                 DEBUG(2,("_spoolss_RemoteFindFirstPrinterChangeNotifyEx: "
2652                         "Invalid handle (%s:%u:%u).\n",
2653                         OUR_HANDLE(r->in.handle)));
2654                 return WERR_INVALID_HANDLE;
2655         }
2656
2657         Printer->notify.flags           = r->in.flags;
2658         Printer->notify.options         = r->in.options;
2659         Printer->notify.printerlocal    = r->in.printer_local;
2660         Printer->notify.msg_ctx         = p->msg_ctx;
2661
2662         TALLOC_FREE(Printer->notify.option);
2663         Printer->notify.option = dup_spoolss_NotifyOption(Printer, option);
2664
2665         fstrcpy(Printer->notify.localmachine, r->in.local_machine);
2666
2667         /* Connect to the client machine and send a ReplyOpenPrinter */
2668
2669         if ( Printer->printer_type == SPLHND_SERVER)
2670                 snum = -1;
2671         else if ( (Printer->printer_type == SPLHND_PRINTER) &&
2672                         !get_printer_snum(p, r->in.handle, &snum, NULL) )
2673                 return WERR_INVALID_HANDLE;
2674
2675         DEBUG(10,("_spoolss_RemoteFindFirstPrinterChangeNotifyEx: "
2676                   "remote_address is %s\n",
2677                   tsocket_address_string(p->remote_address, p->mem_ctx)));
2678
2679         if (!lp_print_notify_backchannel(snum)) {
2680                 DEBUG(10, ("_spoolss_RemoteFindFirstPrinterChangeNotifyEx: "
2681                         "backchannel disabled\n"));
2682                 return WERR_RPC_S_SERVER_UNAVAILABLE;
2683         }
2684
2685         client_len = tsocket_address_bsd_sockaddr(p->remote_address,
2686                                                   (struct sockaddr *) &client_ss,
2687                                                   sizeof(struct sockaddr_storage));
2688         if (client_len < 0) {
2689                 return WERR_NOT_ENOUGH_MEMORY;
2690         }
2691
2692         if(!srv_spoolss_replyopenprinter(snum, Printer->notify.localmachine,
2693                                         Printer->notify.printerlocal, REG_SZ,
2694                                         &Printer->notify.cli_hnd,
2695                                         &Printer->notify.cli_chan,
2696                                         &client_ss, p->msg_ctx)) {
2697                 return WERR_RPC_S_SERVER_UNAVAILABLE;
2698         }
2699
2700         return WERR_OK;
2701 }
2702
2703 /*******************************************************************
2704  * fill a notify_info_data with the servername
2705  ********************************************************************/
2706
2707 static void spoolss_notify_server_name(struct messaging_context *msg_ctx,
2708                                        int snum,
2709                                        struct spoolss_Notify *data,
2710                                        print_queue_struct *queue,
2711                                        struct spoolss_PrinterInfo2 *pinfo2,
2712                                        TALLOC_CTX *mem_ctx)
2713 {
2714         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->servername);
2715 }
2716
2717 /*******************************************************************
2718  * fill a notify_info_data with the printername (not including the servername).
2719  ********************************************************************/
2720
2721 static void spoolss_notify_printer_name(struct messaging_context *msg_ctx,
2722                                         int snum,
2723                                         struct spoolss_Notify *data,
2724                                         print_queue_struct *queue,
2725                                         struct spoolss_PrinterInfo2 *pinfo2,
2726                                         TALLOC_CTX *mem_ctx)
2727 {
2728         /* the notify name should not contain the \\server\ part */
2729         const char *p = strrchr(pinfo2->printername, '\\');
2730
2731         if (!p) {
2732                 p = pinfo2->printername;
2733         } else {
2734                 p++;
2735         }
2736
2737         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, p);
2738 }
2739
2740 /*******************************************************************
2741  * fill a notify_info_data with the servicename
2742  ********************************************************************/
2743
2744 static void spoolss_notify_share_name(struct messaging_context *msg_ctx,
2745                                       int snum,
2746                                       struct spoolss_Notify *data,
2747                                       print_queue_struct *queue,
2748                                       struct spoolss_PrinterInfo2 *pinfo2,
2749                                       TALLOC_CTX *mem_ctx)
2750 {
2751         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, lp_servicename(talloc_tos(), snum));
2752 }
2753
2754 /*******************************************************************
2755  * fill a notify_info_data with the port name
2756  ********************************************************************/
2757
2758 static void spoolss_notify_port_name(struct messaging_context *msg_ctx,
2759                                      int snum,
2760                                      struct spoolss_Notify *data,
2761                                      print_queue_struct *queue,
2762                                      struct spoolss_PrinterInfo2 *pinfo2,
2763                                      TALLOC_CTX *mem_ctx)
2764 {
2765         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->portname);
2766 }
2767
2768 /*******************************************************************
2769  * fill a notify_info_data with the printername
2770  * but it doesn't exist, have to see what to do
2771  ********************************************************************/
2772
2773 static void spoolss_notify_driver_name(struct messaging_context *msg_ctx,
2774                                        int snum,
2775                                        struct spoolss_Notify *data,
2776                                        print_queue_struct *queue,
2777                                        struct spoolss_PrinterInfo2 *pinfo2,
2778                                        TALLOC_CTX *mem_ctx)
2779 {
2780         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->drivername);
2781 }
2782
2783 /*******************************************************************
2784  * fill a notify_info_data with the comment
2785  ********************************************************************/
2786
2787 static void spoolss_notify_comment(struct messaging_context *msg_ctx,
2788                                    int snum,
2789                                    struct spoolss_Notify *data,
2790                                    print_queue_struct *queue,
2791                                    struct spoolss_PrinterInfo2 *pinfo2,
2792                                    TALLOC_CTX *mem_ctx)
2793 {
2794         const char *p;
2795
2796         if (*pinfo2->comment == '\0') {
2797                 p = lp_comment(talloc_tos(), snum);
2798         } else {
2799                 p = pinfo2->comment;
2800         }
2801
2802         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, p);
2803 }
2804
2805 /*******************************************************************
2806  * fill a notify_info_data with the comment
2807  * location = "Room 1, floor 2, building 3"
2808  ********************************************************************/
2809
2810 static void spoolss_notify_location(struct messaging_context *msg_ctx,
2811                                     int snum,
2812                                     struct spoolss_Notify *data,
2813                                     print_queue_struct *queue,
2814                                     struct spoolss_PrinterInfo2 *pinfo2,
2815                                     TALLOC_CTX *mem_ctx)
2816 {
2817         const char *loc = pinfo2->location;
2818         NTSTATUS status;
2819
2820         status = printer_list_get_printer(mem_ctx,
2821                                           pinfo2->sharename,
2822                                           NULL,
2823                                           &loc,
2824                                           NULL);
2825         if (NT_STATUS_IS_OK(status)) {
2826                 if (loc == NULL) {
2827                         loc = pinfo2->location;
2828                 }
2829         }
2830
2831         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, loc);
2832 }
2833
2834 /*******************************************************************
2835  * fill a notify_info_data with the device mode
2836  * jfm:xxxx don't to it for know but that's a real problem !!!
2837  ********************************************************************/
2838
2839 static void spoolss_notify_devmode(struct messaging_context *msg_ctx,
2840                                    int snum,
2841                                    struct spoolss_Notify *data,
2842                                    print_queue_struct *queue,
2843                                    struct spoolss_PrinterInfo2 *pinfo2,
2844                                    TALLOC_CTX *mem_ctx)
2845 {
2846         /* for a dummy implementation we have to zero the fields */
2847         SETUP_SPOOLSS_NOTIFY_DATA_DEVMODE(data, NULL);
2848 }
2849
2850 /*******************************************************************
2851  * fill a notify_info_data with the separator file name
2852  ********************************************************************/
2853
2854 static void spoolss_notify_sepfile(struct messaging_context *msg_ctx,
2855                                    int snum,
2856                                    struct spoolss_Notify *data,
2857                                    print_queue_struct *queue,
2858                                    struct spoolss_PrinterInfo2 *pinfo2,
2859                                    TALLOC_CTX *mem_ctx)
2860 {
2861         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->sepfile);
2862 }
2863
2864 /*******************************************************************
2865  * fill a notify_info_data with the print processor
2866  * jfm:xxxx return always winprint to indicate we don't do anything to it
2867  ********************************************************************/
2868
2869 static void spoolss_notify_print_processor(struct messaging_context *msg_ctx,
2870                                            int snum,
2871                                            struct spoolss_Notify *data,
2872                                            print_queue_struct *queue,
2873                                            struct spoolss_PrinterInfo2 *pinfo2,
2874                                            TALLOC_CTX *mem_ctx)
2875 {
2876         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->printprocessor);
2877 }
2878
2879 /*******************************************************************
2880  * fill a notify_info_data with the print processor options
2881  * jfm:xxxx send an empty string
2882  ********************************************************************/
2883
2884 static void spoolss_notify_parameters(struct messaging_context *msg_ctx,
2885                                       int snum,
2886                                       struct spoolss_Notify *data,
2887                                       print_queue_struct *queue,
2888                                       struct spoolss_PrinterInfo2 *pinfo2,
2889                                       TALLOC_CTX *mem_ctx)
2890 {
2891         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->parameters);
2892 }
2893
2894 /*******************************************************************
2895  * fill a notify_info_data with the data type
2896  * jfm:xxxx always send RAW as data type
2897  ********************************************************************/
2898
2899 static void spoolss_notify_datatype(struct messaging_context *msg_ctx,
2900                                     int snum,
2901                                     struct spoolss_Notify *data,
2902                                     print_queue_struct *queue,
2903                                     struct spoolss_PrinterInfo2 *pinfo2,
2904                                     TALLOC_CTX *mem_ctx)
2905 {
2906         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->datatype);
2907 }
2908
2909 /*******************************************************************
2910  * fill a notify_info_data with the security descriptor
2911  * jfm:xxxx send an null pointer to say no security desc
2912  * have to implement security before !
2913  ********************************************************************/
2914
2915 static void spoolss_notify_security_desc(struct messaging_context *msg_ctx,
2916                                          int snum,
2917                                          struct spoolss_Notify *data,
2918                                          print_queue_struct *queue,
2919                                          struct spoolss_PrinterInfo2 *pinfo2,
2920                                          TALLOC_CTX *mem_ctx)
2921 {
2922         if (pinfo2->secdesc == NULL) {
2923                 data->data.sd.sd = NULL;
2924         } else {
2925                 data->data.sd.sd = security_descriptor_copy(mem_ctx,
2926                                                             pinfo2->secdesc);
2927         }
2928         data->data.sd.sd_size = ndr_size_security_descriptor(data->data.sd.sd,
2929                                                              0);
2930 }
2931
2932 /*******************************************************************
2933  * fill a notify_info_data with the attributes
2934  * jfm:xxxx a samba printer is always shared
2935  ********************************************************************/
2936
2937 static void spoolss_notify_attributes(struct messaging_context *msg_ctx,
2938                                       int snum,
2939                                       struct spoolss_Notify *data,
2940                                       print_queue_struct *queue,
2941                                       struct spoolss_PrinterInfo2 *pinfo2,
2942                                       TALLOC_CTX *mem_ctx)
2943 {
2944         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->attributes);
2945 }
2946
2947 /*******************************************************************
2948  * fill a notify_info_data with the priority
2949  ********************************************************************/
2950
2951 static void spoolss_notify_priority(struct messaging_context *msg_ctx,
2952                                     int snum,
2953                                     struct spoolss_Notify *data,
2954                                     print_queue_struct *queue,
2955                                     struct spoolss_PrinterInfo2 *pinfo2,
2956                                     TALLOC_CTX *mem_ctx)
2957 {
2958         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->priority);
2959 }
2960
2961 /*******************************************************************
2962  * fill a notify_info_data with the default priority
2963  ********************************************************************/
2964
2965 static void spoolss_notify_default_priority(struct messaging_context *msg_ctx,
2966                                             int snum,
2967                                             struct spoolss_Notify *data,
2968                                             print_queue_struct *queue,
2969                                             struct spoolss_PrinterInfo2 *pinfo2,
2970                                             TALLOC_CTX *mem_ctx)
2971 {
2972         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->defaultpriority);
2973 }
2974
2975 /*******************************************************************
2976  * fill a notify_info_data with the start time
2977  ********************************************************************/
2978
2979 static void spoolss_notify_start_time(struct messaging_context *msg_ctx,
2980                                       int snum,
2981                                       struct spoolss_Notify *data,
2982                                       print_queue_struct *queue,
2983                                       struct spoolss_PrinterInfo2 *pinfo2,
2984                                       TALLOC_CTX *mem_ctx)
2985 {
2986         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->starttime);
2987 }
2988
2989 /*******************************************************************
2990  * fill a notify_info_data with the until time
2991  ********************************************************************/
2992
2993 static void spoolss_notify_until_time(struct messaging_context *msg_ctx,
2994                                       int snum,
2995                                       struct spoolss_Notify *data,
2996                                       print_queue_struct *queue,
2997                                       struct spoolss_PrinterInfo2 *pinfo2,
2998                                       TALLOC_CTX *mem_ctx)
2999 {
3000         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->untiltime);
3001 }
3002
3003 /*******************************************************************
3004  * fill a notify_info_data with the status
3005  ********************************************************************/
3006
3007 static void spoolss_notify_status(struct messaging_context *msg_ctx,
3008                                   int snum,
3009                                   struct spoolss_Notify *data,
3010                                   print_queue_struct *queue,
3011                                   struct spoolss_PrinterInfo2 *pinfo2,
3012                                   TALLOC_CTX *mem_ctx)
3013 {
3014         print_status_struct status;
3015
3016         print_queue_length(msg_ctx, snum, &status);
3017         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, status.status);
3018 }
3019
3020 /*******************************************************************
3021  * fill a notify_info_data with the number of jobs queued
3022  ********************************************************************/
3023
3024 static void spoolss_notify_cjobs(struct messaging_context *msg_ctx,
3025                                  int snum,
3026                                  struct spoolss_Notify *data,
3027                                  print_queue_struct *queue,
3028                                  struct spoolss_PrinterInfo2 *pinfo2,
3029                                  TALLOC_CTX *mem_ctx)
3030 {
3031         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(
3032                 data, print_queue_length(msg_ctx, snum, NULL));
3033 }
3034
3035 /*******************************************************************
3036  * fill a notify_info_data with the average ppm
3037  ********************************************************************/
3038
3039 static void spoolss_notify_average_ppm(struct messaging_context *msg_ctx,
3040                                        int snum,
3041                                        struct spoolss_Notify *data,
3042                                        print_queue_struct *queue,
3043                                        struct spoolss_PrinterInfo2 *pinfo2,
3044                                        TALLOC_CTX *mem_ctx)
3045 {
3046         /* always respond 8 pages per minutes */
3047         /* a little hard ! */
3048         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->averageppm);
3049 }
3050
3051 /*******************************************************************
3052  * fill a notify_info_data with username
3053  ********************************************************************/
3054
3055 static void spoolss_notify_username(struct messaging_context *msg_ctx,
3056                                     int snum,
3057                                     struct spoolss_Notify *data,
3058                                     print_queue_struct *queue,
3059                                     struct spoolss_PrinterInfo2 *pinfo2,
3060                                     TALLOC_CTX *mem_ctx)
3061 {
3062         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, queue->fs_user);
3063 }
3064
3065 /*******************************************************************
3066  * fill a notify_info_data with job status
3067  ********************************************************************/
3068
3069 static void spoolss_notify_job_status(struct messaging_context *msg_ctx,
3070                                       int snum,
3071                                       struct spoolss_Notify *data,
3072                                       print_queue_struct *queue,
3073                                       struct spoolss_PrinterInfo2 *pinfo2,
3074                                       TALLOC_CTX *mem_ctx)
3075 {
3076         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, nt_printj_status(queue->status));
3077 }
3078
3079 /*******************************************************************
3080  * fill a notify_info_data with job name
3081  ********************************************************************/
3082
3083 static void spoolss_notify_job_name(struct messaging_context *msg_ctx,
3084                                     int snum,
3085                                     struct spoolss_Notify *data,
3086                                     print_queue_struct *queue,
3087                                     struct spoolss_PrinterInfo2 *pinfo2,
3088                                     TALLOC_CTX *mem_ctx)
3089 {
3090         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, queue->fs_file);
3091 }
3092
3093 /*******************************************************************
3094  * fill a notify_info_data with job status
3095  ********************************************************************/
3096
3097 static void spoolss_notify_job_status_string(struct messaging_context *msg_ctx,
3098                                              int snum,
3099                                              struct spoolss_Notify *data,
3100                                              print_queue_struct *queue,
3101                                              struct spoolss_PrinterInfo2 *pinfo2,
3102                                              TALLOC_CTX *mem_ctx)
3103 {
3104         /*
3105          * Now we're returning job status codes we just return a "" here. JRA.
3106          */
3107
3108         const char *p = "";
3109
3110 #if 0 /* NO LONGER NEEDED - JRA. 02/22/2001 */
3111         p = "unknown";
3112
3113         switch (queue->status) {
3114         case LPQ_QUEUED:
3115                 p = "Queued";
3116                 break;
3117         case LPQ_PAUSED:
3118                 p = "";    /* NT provides the paused string */
3119                 break;
3120         case LPQ_SPOOLING:
3121                 p = "Spooling";
3122                 break;
3123         case LPQ_PRINTING:
3124                 p = "Printing";
3125                 break;
3126         }
3127 #endif /* NO LONGER NEEDED. */
3128
3129         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, p);
3130 }
3131
3132 /*******************************************************************
3133  * fill a notify_info_data with job time
3134  ********************************************************************/
3135
3136 static void spoolss_notify_job_time(struct messaging_context *msg_ctx,
3137                                     int snum,
3138                                     struct spoolss_Notify *data,
3139                                     print_queue_struct *queue,
3140                                     struct spoolss_PrinterInfo2 *pinfo2,
3141                                     TALLOC_CTX *mem_ctx)
3142 {
3143         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, 0);
3144 }
3145
3146 /*******************************************************************
3147  * fill a notify_info_data with job size
3148  ********************************************************************/
3149
3150 static void spoolss_notify_job_size(struct messaging_context *msg_ctx,
3151                                     int snum,
3152                                     struct spoolss_Notify *data,
3153                                     print_queue_struct *queue,
3154                                     struct spoolss_PrinterInfo2 *pinfo2,
3155                                     TALLOC_CTX *mem_ctx)
3156 {
3157         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->size);
3158 }
3159
3160 /*******************************************************************
3161  * fill a notify_info_data with page info
3162  ********************************************************************/
3163 static void spoolss_notify_total_pages(struct messaging_context *msg_ctx,
3164                                        int snum,
3165                                 struct spoolss_Notify *data,
3166                                 print_queue_struct *queue,
3167                                 struct spoolss_PrinterInfo2 *pinfo2,
3168                                 TALLOC_CTX *mem_ctx)
3169 {
3170         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->page_count);
3171 }
3172
3173 /*******************************************************************
3174  * fill a notify_info_data with pages printed info.
3175  ********************************************************************/
3176 static void spoolss_notify_pages_printed(struct messaging_context *msg_ctx,
3177                                          int snum,
3178                                 struct spoolss_Notify *data,
3179                                 print_queue_struct *queue,
3180                                 struct spoolss_PrinterInfo2 *pinfo2,
3181                                 TALLOC_CTX *mem_ctx)
3182 {
3183         /* Add code when back-end tracks this */
3184         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, 0);
3185 }
3186
3187 /*******************************************************************
3188  Fill a notify_info_data with job position.
3189  ********************************************************************/
3190
3191 static void spoolss_notify_job_position(struct messaging_context *msg_ctx,
3192                                         int snum,
3193                                         struct spoolss_Notify *data,
3194                                         print_queue_struct *queue,
3195                                         struct spoolss_PrinterInfo2 *pinfo2,
3196                                         TALLOC_CTX *mem_ctx)
3197 {
3198         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->sysjob);
3199 }
3200
3201 /*******************************************************************
3202  Fill a notify_info_data with submitted time.
3203  ********************************************************************/
3204
3205 static void spoolss_notify_submitted_time(struct messaging_context *msg_ctx,
3206                                           int snum,
3207                                           struct spoolss_Notify *data,
3208                                           print_queue_struct *queue,
3209                                           struct spoolss_PrinterInfo2 *pinfo2,
3210                                           TALLOC_CTX *mem_ctx)
3211 {
3212         data->data.string.string = NULL;
3213         data->data.string.size = 0;
3214
3215         init_systemtime_buffer(mem_ctx, gmtime(&queue->time),
3216                                &data->data.string.string,
3217                                &data->data.string.size);
3218
3219 }
3220
3221 struct s_notify_info_data_table
3222 {
3223         enum spoolss_NotifyType type;
3224         uint16_t field;
3225         const char *name;
3226         enum spoolss_NotifyTable variable_type;
3227         void (*fn) (struct messaging_context *msg_ctx,
3228                     int snum, struct spoolss_Notify *data,
3229                     print_queue_struct *queue,
3230                     struct spoolss_PrinterInfo2 *pinfo2,
3231                     TALLOC_CTX *mem_ctx);
3232 };
3233
3234 /* A table describing the various print notification constants and
3235    whether the notification data is a pointer to a variable sized
3236    buffer, a one value uint32_t or a two value uint32_t. */
3237
3238 static const struct s_notify_info_data_table notify_info_data_table[] =
3239 {
3240 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SERVER_NAME,         "PRINTER_NOTIFY_FIELD_SERVER_NAME",         NOTIFY_TABLE_STRING,   spoolss_notify_server_name },
3241 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRINTER_NAME,        "PRINTER_NOTIFY_FIELD_PRINTER_NAME",        NOTIFY_TABLE_STRING,   spoolss_notify_printer_name },
3242 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SHARE_NAME,          "PRINTER_NOTIFY_FIELD_SHARE_NAME",          NOTIFY_TABLE_STRING,   spoolss_notify_share_name },
3243 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PORT_NAME,           "PRINTER_NOTIFY_FIELD_PORT_NAME",           NOTIFY_TABLE_STRING,   spoolss_notify_port_name },
3244 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DRIVER_NAME,         "PRINTER_NOTIFY_FIELD_DRIVER_NAME",         NOTIFY_TABLE_STRING,   spoolss_notify_driver_name },
3245 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_COMMENT,             "PRINTER_NOTIFY_FIELD_COMMENT",             NOTIFY_TABLE_STRING,   spoolss_notify_comment },
3246 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_LOCATION,            "PRINTER_NOTIFY_FIELD_LOCATION",            NOTIFY_TABLE_STRING,   spoolss_notify_location },
3247 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DEVMODE,             "PRINTER_NOTIFY_FIELD_DEVMODE",             NOTIFY_TABLE_DEVMODE,  spoolss_notify_devmode },
3248 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SEPFILE,             "PRINTER_NOTIFY_FIELD_SEPFILE",             NOTIFY_TABLE_STRING,   spoolss_notify_sepfile },
3249 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR,     "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR",     NOTIFY_TABLE_STRING,   spoolss_notify_print_processor },
3250 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PARAMETERS,          "PRINTER_NOTIFY_FIELD_PARAMETERS",          NOTIFY_TABLE_STRING,   spoolss_notify_parameters },
3251 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DATATYPE,            "PRINTER_NOTIFY_FIELD_DATATYPE",            NOTIFY_TABLE_STRING,   spoolss_notify_datatype },
3252 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR, "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NOTIFY_TABLE_SECURITYDESCRIPTOR,   spoolss_notify_security_desc },
3253 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_ATTRIBUTES,          "PRINTER_NOTIFY_FIELD_ATTRIBUTES",          NOTIFY_TABLE_DWORD,    spoolss_notify_attributes },
3254 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRIORITY,            "PRINTER_NOTIFY_FIELD_PRIORITY",            NOTIFY_TABLE_DWORD,    spoolss_notify_priority },
3255 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY,    "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY",    NOTIFY_TABLE_DWORD,    spoolss_notify_default_priority },
3256 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_START_TIME,          "PRINTER_NOTIFY_FIELD_START_TIME",          NOTIFY_TABLE_DWORD,    spoolss_notify_start_time },
3257 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_UNTIL_TIME,          "PRINTER_NOTIFY_FIELD_UNTIL_TIME",          NOTIFY_TABLE_DWORD,    spoolss_notify_until_time },
3258 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_STATUS,              "PRINTER_NOTIFY_FIELD_STATUS",              NOTIFY_TABLE_DWORD,    spoolss_notify_status },
3259 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_STATUS_STRING,       "PRINTER_NOTIFY_FIELD_STATUS_STRING",       NOTIFY_TABLE_STRING,   NULL },
3260 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_CJOBS,               "PRINTER_NOTIFY_FIELD_CJOBS",               NOTIFY_TABLE_DWORD,    spoolss_notify_cjobs },
3261 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_AVERAGE_PPM,         "PRINTER_NOTIFY_FIELD_AVERAGE_PPM",         NOTIFY_TABLE_DWORD,    spoolss_notify_average_ppm },
3262 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_TOTAL_PAGES,         "PRINTER_NOTIFY_FIELD_TOTAL_PAGES",         NOTIFY_TABLE_DWORD,    NULL },
3263 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PAGES_PRINTED,       "PRINTER_NOTIFY_FIELD_PAGES_PRINTED",       NOTIFY_TABLE_DWORD,    NULL },
3264 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_TOTAL_BYTES,         "PRINTER_NOTIFY_FIELD_TOTAL_BYTES",         NOTIFY_TABLE_DWORD,    NULL },
3265 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_BYTES_PRINTED,       "PRINTER_NOTIFY_FIELD_BYTES_PRINTED",       NOTIFY_TABLE_DWORD,    NULL },
3266 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_PRINTER_NAME,            "JOB_NOTIFY_FIELD_PRINTER_NAME",            NOTIFY_TABLE_STRING,   spoolss_notify_printer_name },
3267 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_MACHINE_NAME,            "JOB_NOTIFY_FIELD_MACHINE_NAME",            NOTIFY_TABLE_STRING,   spoolss_notify_server_name },
3268 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_PORT_NAME,               "JOB_NOTIFY_FIELD_PORT_NAME",               NOTIFY_TABLE_STRING,   spoolss_notify_port_name },
3269 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_USER_NAME,               "JOB_NOTIFY_FIELD_USER_NAME",               NOTIFY_TABLE_STRING,   spoolss_notify_username },
3270 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_NOTIFY_NAME,             "JOB_NOTIFY_FIELD_NOTIFY_NAME",             NOTIFY_TABLE_STRING,   spoolss_notify_username },
3271 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_DATATYPE,                "JOB_NOTIFY_FIELD_DATATYPE",                NOTIFY_TABLE_STRING,   spoolss_notify_datatype },
3272 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_PRINT_PROCESSOR,         "JOB_NOTIFY_FIELD_PRINT_PROCESSOR",         NOTIFY_TABLE_STRING,   spoolss_notify_print_processor },
3273 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_PARAMETERS,              "JOB_NOTIFY_FIELD_PARAMETERS",              NOTIFY_TABLE_STRING,   spoolss_notify_parameters },
3274 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_DRIVER_NAME,             "JOB_NOTIFY_FIELD_DRIVER_NAME",             NOTIFY_TABLE_STRING,   spoolss_notify_driver_name },
3275 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_DEVMODE,                 "JOB_NOTIFY_FIELD_DEVMODE",                 NOTIFY_TABLE_DEVMODE,  spoolss_notify_devmode },
3276 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_STATUS,                  "JOB_NOTIFY_FIELD_STATUS",                  NOTIFY_TABLE_DWORD,    spoolss_notify_job_status },
3277 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_STATUS_STRING,           "JOB_NOTIFY_FIELD_STATUS_STRING",           NOTIFY_TABLE_STRING,   spoolss_notify_job_status_string },
3278 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR,     "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR",     NOTIFY_TABLE_SECURITYDESCRIPTOR,   NULL },
3279 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_DOCUMENT,                "JOB_NOTIFY_FIELD_DOCUMENT",                NOTIFY_TABLE_STRING,   spoolss_notify_job_name },
3280 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_PRIORITY,                "JOB_NOTIFY_FIELD_PRIORITY",                NOTIFY_TABLE_DWORD,    spoolss_notify_priority },
3281 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_POSITION,                "JOB_NOTIFY_FIELD_POSITION",                NOTIFY_TABLE_DWORD,    spoolss_notify_job_position },
3282 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_SUBMITTED,               "JOB_NOTIFY_FIELD_SUBMITTED",               NOTIFY_TABLE_TIME,     spoolss_notify_submitted_time },
3283 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_START_TIME,              "JOB_NOTIFY_FIELD_START_TIME",              NOTIFY_TABLE_DWORD,    spoolss_notify_start_time },
3284 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_UNTIL_TIME,              "JOB_NOTIFY_FIELD_UNTIL_TIME",              NOTIFY_TABLE_DWORD,    spoolss_notify_until_time },
3285 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_TIME,                    "JOB_NOTIFY_FIELD_TIME",                    NOTIFY_TABLE_DWORD,    spoolss_notify_job_time },
3286 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_TOTAL_PAGES,             "JOB_NOTIFY_FIELD_TOTAL_PAGES",             NOTIFY_TABLE_DWORD,    spoolss_notify_total_pages },
3287 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_PAGES_PRINTED,           "JOB_NOTIFY_FIELD_PAGES_PRINTED",           NOTIFY_TABLE_DWORD,    spoolss_notify_pages_printed },
3288 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_TOTAL_BYTES,             "JOB_NOTIFY_FIELD_TOTAL_BYTES",             NOTIFY_TABLE_DWORD,    spoolss_notify_job_size },
3289 };
3290
3291 /*******************************************************************
3292  Return the variable_type of info_data structure.
3293 ********************************************************************/
3294
3295 static enum spoolss_NotifyTable variable_type_of_notify_info_data(enum spoolss_NotifyType type,
3296                                                                   uint16_t field)
3297 {
3298         int i=0;
3299
3300         for (i = 0; i < ARRAY_SIZE(notify_info_data_table); i++) {
3301                 if ( (notify_info_data_table[i].type == type) &&
3302                      (notify_info_data_table[i].field == field) ) {
3303                         return notify_info_data_table[i].variable_type;
3304                 }
3305         }
3306
3307         DEBUG(5, ("invalid notify data type %d/%d\n", type, field));
3308
3309         return (enum spoolss_NotifyTable) 0;
3310 }
3311
3312 /****************************************************************************
3313 ****************************************************************************/
3314
3315 static bool search_notify(enum spoolss_NotifyType type,
3316                           uint16_t field,
3317                           int *value)
3318 {
3319         int i;
3320
3321         for (i = 0; i < ARRAY_SIZE(notify_info_data_table); i++) {
3322                 if (notify_info_data_table[i].type == type &&
3323                     notify_info_data_table[i].field == field &&
3324                     notify_info_data_table[i].fn != NULL) {
3325                         *value = i;
3326                         return true;
3327                 }
3328         }
3329
3330         return false;
3331 }
3332
3333 /****************************************************************************
3334 ****************************************************************************/
3335
3336 static void construct_info_data(struct spoolss_Notify *info_data,
3337                                 enum spoolss_NotifyType type,
3338                                 uint16_t field, int id)
3339 {
3340         info_data->type                 = type;
3341         info_data->field.field          = field;
3342         info_data->variable_type        = variable_type_of_notify_info_data(type, field);
3343         info_data->job_id               = id;
3344 }
3345
3346 /*******************************************************************
3347  *
3348  * fill a notify_info struct with info asked
3349  *
3350  ********************************************************************/
3351
3352 static bool construct_notify_printer_info(struct messaging_context *msg_ctx,
3353                                           struct printer_handle *print_hnd,
3354                                           struct spoolss_NotifyInfo *info,
3355                                           struct spoolss_PrinterInfo2 *pinfo2,
3356                                           int snum,
3357                                           const struct spoolss_NotifyOptionType *option_type,
3358                                           uint32_t id,
3359                                           TALLOC_CTX *mem_ctx)
3360 {
3361         int field_num,j;
3362         enum spoolss_NotifyType type;
3363         uint16_t field;
3364
3365         struct spoolss_Notify *current_data;
3366
3367         type = option_type->type;
3368
3369         DEBUG(4,("construct_notify_printer_info: Notify type: [%s], number of notify info: [%d] on printer: [%s]\n",
3370                 (type == PRINTER_NOTIFY_TYPE ? "PRINTER_NOTIFY_TYPE" : "JOB_NOTIFY_TYPE"),
3371                 option_type->count, lp_servicename(talloc_tos(), snum)));
3372
3373         for(field_num=0; field_num < option_type->count; field_num++) {
3374                 field = option_type->fields[field_num].field;
3375
3376                 DEBUG(4,("construct_notify_printer_info: notify [%d]: type [%x], field [%x]\n", field_num, type, field));
3377
3378                 if (!search_notify(type, field, &j) )
3379                         continue;
3380
3381                 info->notifies = talloc_realloc(info, info->notifies,
3382                                                       struct spoolss_Notify,
3383                                                       info->count + 1);
3384                 if (info->notifies == NULL) {
3385                         DEBUG(2,("construct_notify_printer_info: failed to enlarge buffer info->data!\n"));
3386                         return false;
3387                 }
3388
3389                 current_data = &info->notifies[info->count];
3390
3391                 construct_info_data(current_data, type, field, id);
3392
3393                 DEBUG(10, ("construct_notify_printer_info: "
3394                            "calling [%s]  snum=%d  printername=[%s])\n",
3395                            notify_info_data_table[j].name, snum,
3396                            pinfo2->printername));
3397
3398                 notify_info_data_table[j].fn(msg_ctx, snum, current_data,
3399                                              NULL, pinfo2, mem_ctx);
3400
3401                 info->count++;
3402         }
3403
3404         return true;
3405 }
3406
3407 /*******************************************************************
3408  *
3409  * fill a notify_info struct with info asked
3410  *
3411  ********************************************************************/
3412
3413 static bool construct_notify_jobs_info(struct messaging_context *msg_ctx,
3414                                        print_queue_struct *queue,
3415                                        struct spoolss_NotifyInfo *info,
3416                                        struct spoolss_PrinterInfo2 *pinfo2,
3417                                        int snum,
3418                                        const struct spoolss_NotifyOptionType *option_type,
3419                                        uint32_t id,
3420                                        TALLOC_CTX *mem_ctx)
3421 {
3422         int field_num,j;
3423         enum spoolss_NotifyType type;
3424         uint16_t field;
3425         struct spoolss_Notify *current_data;
3426
3427         DEBUG(4,("construct_notify_jobs_info\n"));
3428
3429         type = option_type->type;
3430
3431         DEBUGADD(4,("Notify type: [%s], number of notify info: [%d]\n",
3432                 (type == PRINTER_NOTIFY_TYPE ? "PRINTER_NOTIFY_TYPE" : "JOB_NOTIFY_TYPE"),
3433                 option_type->count));
3434
3435         for(field_num=0; field_num<option_type->count; field_num++) {
3436                 field = option_type->fields[field_num].field;
3437
3438                 if (!search_notify(type, field, &j) )
3439                         continue;
3440
3441                 info->notifies = talloc_realloc(info, info->notifies,
3442                                                       struct spoolss_Notify,
3443                                                       info->count + 1);
3444                 if (info->notifies == NULL) {
3445                         DEBUG(2,("construct_notify_jobs_info: failed to enlarg buffer info->data!\n"));
3446                         return false;
3447                 }
3448
3449                 current_data=&(info->notifies[info->count]);
3450
3451                 construct_info_data(current_data, type, field, id);
3452                 notify_info_data_table[j].fn(msg_ctx, snum, current_data,
3453                                              queue, pinfo2, mem_ctx);
3454                 info->count++;
3455         }
3456
3457         return true;
3458 }
3459
3460 /*
3461  * JFM: The enumeration is not that simple, it's even non obvious.
3462  *
3463  * let's take an example: I want to monitor the PRINTER SERVER for
3464  * the printer's name and the number of jobs currently queued.
3465  * So in the NOTIFY_OPTION, I have one NOTIFY_OPTION_TYPE structure.
3466  * Its type is PRINTER_NOTIFY_TYPE and it has 2 fields NAME and CJOBS.
3467  *
3468  * I have 3 printers on the back of my server.
3469  *
3470  * Now the response is a NOTIFY_INFO structure, with 6 NOTIFY_INFO_DATA
3471  * structures.
3472  *   Number     Data                    Id
3473  *      1       printer 1 name          1
3474  *      2       printer 1 cjob          1
3475  *      3       printer 2 name          2
3476  *      4       printer 2 cjob          2
3477  *      5       printer 3 name          3
3478  *      6       printer 3 name          3
3479  *
3480  * that's the print server case, the printer case is even worse.
3481  */
3482
3483 /*******************************************************************
3484  *
3485  * enumerate all printers on the printserver
3486  * fill a notify_info struct with info asked
3487  *
3488  ********************************************************************/
3489
3490 static WERROR printserver_notify_info(struct pipes_struct *p,
3491                                       struct policy_handle *hnd,
3492                                       struct spoolss_NotifyInfo *info,
3493                                       TALLOC_CTX *mem_ctx)
3494 {
3495         int snum;
3496         struct printer_handle *Printer = find_printer_index_by_hnd(p, hnd);
3497         int n_services=lp_numservices();
3498         int i;
3499         struct spoolss_NotifyOption *option;
3500         struct spoolss_NotifyOptionType option_type;
3501         struct spoolss_PrinterInfo2 *pinfo2 = NULL;
3502         WERROR result;
3503
3504         DEBUG(4,("printserver_notify_info\n"));
3505
3506         if (!Printer)
3507                 return WERR_INVALID_HANDLE;
3508
3509         option = Printer->notify.option;
3510
3511         info->version   = 2;
3512         info->notifies  = NULL;
3513         info->count     = 0;
3514
3515         /* a bug in xp sp2 rc2 causes it to send a fnpcn request without
3516            sending a ffpcn() request first */
3517
3518         if ( !option )
3519                 return WERR_INVALID_HANDLE;
3520
3521         for (i=0; i<option->count; i++) {
3522                 option_type = option->types[i];
3523
3524                 if (option_type.type != PRINTER_NOTIFY_TYPE)
3525                         continue;
3526
3527                 for (snum = 0; snum < n_services; snum++) {
3528                         if (!lp_browseable(snum) ||
3529                             !lp_snum_ok(snum) ||
3530                             !lp_printable(snum)) {
3531                                 continue; /* skip */
3532                         }
3533
3534                         /* Maybe we should use the SYSTEM session_info here... */
3535                         result = winreg_get_printer_internal(mem_ctx,
3536                                                     get_session_info_system(),
3537                                                     p->msg_ctx,
3538                                                     lp_servicename(talloc_tos(), snum),
3539                                                     &pinfo2);
3540                         if (!W_ERROR_IS_OK(result)) {
3541                                 DEBUG(4, ("printserver_notify_info: "
3542                                           "Failed to get printer [%s]\n",
3543                                           lp_servicename(talloc_tos(), snum)));
3544                                 continue;
3545                         }
3546
3547
3548                         construct_notify_printer_info(p->msg_ctx,
3549                                                       Printer, info,
3550                                                       pinfo2, snum,
3551                                                       &option_type, snum,
3552                                                       mem_ctx);
3553
3554                         TALLOC_FREE(pinfo2);
3555                 }
3556         }
3557
3558 #if 0
3559         /*
3560          * Debugging information, don't delete.
3561          */
3562
3563         DEBUG(1,("dumping the NOTIFY_INFO\n"));
3564         DEBUGADD(1,("info->version:[%d], info->flags:[%d], info->count:[%d]\n", info->version, info->flags, info->count));
3565         DEBUGADD(1,("num\ttype\tfield\tres\tid\tsize\tenc_type\n"));
3566
3567         for (i=0; i<info->count; i++) {
3568                 DEBUGADD(1,("[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\n",
3569                 i, info->data[i].type, info->data[i].field, info->data[i].reserved,
3570                 info->data[i].id, info->data[i].size, info->data[i].enc_type));
3571         }
3572 #endif
3573
3574         return WERR_OK;
3575 }
3576
3577 /*******************************************************************
3578  *
3579  * fill a notify_info struct with info asked
3580  *
3581  ********************************************************************/
3582
3583 static WERROR printer_notify_info(struct pipes_struct *p,
3584                                   struct policy_handle *hnd,
3585                                   struct spoolss_NotifyInfo *info,
3586                                   TALLOC_CTX *mem_ctx)
3587 {
3588         int snum;
3589         struct printer_handle *Printer = find_printer_index_by_hnd(p, hnd);
3590         int i;
3591         uint32_t id;
3592         struct spoolss_NotifyOption *option;
3593         struct spoolss_NotifyOptionType option_type;
3594         int count,j;
3595         print_queue_struct *queue=NULL;
3596         print_status_struct status;
3597         struct spoolss_PrinterInfo2 *pinfo2 = NULL;
3598         WERROR result;
3599         struct tdb_print_db *pdb;
3600
3601         DEBUG(4,("printer_notify_info\n"));
3602
3603         if (!Printer)
3604                 return WERR_INVALID_HANDLE;
3605
3606         option = Printer->notify.option;
3607         id = 0x0;
3608
3609         info->version   = 2;
3610         info->notifies  = NULL;
3611         info->count     = 0;
3612
3613         /* a bug in xp sp2 rc2 causes it to send a fnpcn request without
3614            sending a ffpcn() request first */
3615
3616         if ( !option )
3617                 return WERR_INVALID_HANDLE;
3618
3619         if (!get_printer_snum(p, hnd, &snum, NULL)) {
3620                 return WERR_INVALID_HANDLE;
3621         }
3622
3623         pdb = get_print_db_byname(Printer->sharename);
3624         if (pdb == NULL) {
3625                 return WERR_INVALID_HANDLE;
3626         }
3627
3628         /* Maybe we should use the SYSTEM session_info here... */
3629         result = winreg_get_printer_internal(mem_ctx,
3630                                     get_session_info_system(),
3631                                     p->msg_ctx,
3632                                     lp_servicename(talloc_tos(), snum), &pinfo2);
3633         if (!W_ERROR_IS_OK(result)) {
3634                 result = WERR_INVALID_HANDLE;
3635                 goto err_pdb_drop;
3636         }
3637
3638         /*
3639          * When sending a PRINTER_NOTIFY_FIELD_SERVER_NAME we should send the
3640          * correct servername.
3641          */
3642         pinfo2->servername = talloc_strdup(pinfo2, Printer->servername);
3643         if (pinfo2->servername == NULL) {
3644                 result = WERR_NOT_ENOUGH_MEMORY;
3645                 goto err_pdb_drop;
3646         }
3647
3648         for (i = 0; i < option->count; i++) {
3649                 option_type = option->types[i];
3650
3651                 switch (option_type.type) {
3652                 case PRINTER_NOTIFY_TYPE:
3653                         if (construct_notify_printer_info(p->msg_ctx,
3654                                                           Printer, info,
3655                                                           pinfo2, snum,
3656                                                           &option_type, id,
3657                                                           mem_ctx)) {
3658                                 id--;
3659                         }
3660                         break;
3661
3662                 case JOB_NOTIFY_TYPE:
3663
3664                         count = print_queue_status(p->msg_ctx, snum, &queue,
3665                                                    &status);
3666
3667                         for (j = 0; j < count; j++) {
3668                                 uint32_t jobid;
3669                                 jobid = sysjob_to_jobid_pdb(pdb,
3670                                                             queue[j].sysjob);
3671                                 if (jobid == (uint32_t)-1) {
3672                                         DEBUG(2, ("ignoring untracked job %d\n",
3673                                                   queue[j].sysjob));
3674                                         continue;
3675                                 }
3676                                 /* FIXME check return value */
3677                                 construct_notify_jobs_info(p->msg_ctx,
3678                                                            &queue[j], info,
3679                                                            pinfo2, snum,
3680                                                            &option_type,
3681                                                            jobid,
3682                                                            mem_ctx);
3683                         }
3684
3685                         SAFE_FREE(queue);
3686                         break;
3687                 }
3688         }
3689
3690         /*
3691          * Debugging information, don't delete.
3692          */
3693         /*
3694         DEBUG(1,("dumping the NOTIFY_INFO\n"));
3695         DEBUGADD(1,("info->version:[%d], info->flags:[%d], info->count:[%d]\n", info->version, info->flags, info->count));
3696         DEBUGADD(1,("num\ttype\tfield\tres\tid\tsize\tenc_type\n"));
3697
3698         for (i=0; i<info->count; i++) {
3699                 DEBUGADD(1,("[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\n",
3700                 i, info->data[i].type, info->data[i].field, info->data[i].reserved,
3701                 info->data[i].id, info->data[i].size, info->data[i].enc_type));
3702         }
3703         */
3704
3705         talloc_free(pinfo2);
3706         result = WERR_OK;
3707 err_pdb_drop:
3708         release_print_db(pdb);
3709         return result;
3710 }
3711
3712 /****************************************************************
3713  _spoolss_RouterRefreshPrinterChangeNotify
3714 ****************************************************************/
3715
3716 WERROR _spoolss_RouterRefreshPrinterChangeNotify(struct pipes_struct *p,
3717                                                  struct spoolss_RouterRefreshPrinterChangeNotify *r)
3718 {
3719         struct spoolss_NotifyInfo *info;
3720
3721         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
3722         WERROR result = WERR_INVALID_HANDLE;
3723
3724         /* we always have a spoolss_NotifyInfo struct */
3725         info = talloc_zero(p->mem_ctx, struct spoolss_NotifyInfo);
3726         if (!info) {
3727                 result = WERR_NOT_ENOUGH_MEMORY;
3728                 goto done;
3729         }
3730
3731         *r->out.info = info;
3732
3733         if (!Printer) {
3734                 DEBUG(2,("_spoolss_RouterRefreshPrinterChangeNotify: "
3735                         "Invalid handle (%s:%u:%u).\n",
3736                         OUR_HANDLE(r->in.handle)));
3737                 goto done;
3738         }
3739
3740         DEBUG(4,("Printer type %x\n",Printer->printer_type));
3741
3742         /*
3743          *      We are now using the change value, and
3744          *      I should check for PRINTER_NOTIFY_OPTIONS_REFRESH but as
3745          *      I don't have a global notification system, I'm sending back all the
3746          *      information even when _NOTHING_ has changed.
3747          */
3748
3749         /* We need to keep track of the change value to send back in
3750            RRPCN replies otherwise our updates are ignored. */
3751
3752         Printer->notify.fnpcn = true;
3753
3754         if (Printer->notify.cli_chan != NULL &&
3755             Printer->notify.cli_chan->active_connections > 0) {
3756                 DEBUG(10,("_spoolss_RouterRefreshPrinterChangeNotify: "
3757                         "Saving change value in request [%x]\n",
3758                         r->in.change_low));
3759                 Printer->notify.change = r->in.change_low;
3760         }
3761
3762         /* just ignore the spoolss_NotifyOption */
3763
3764         switch (Printer->printer_type) {
3765                 case SPLHND_SERVER:
3766                         result = printserver_notify_info(p, r->in.handle,
3767                                                          info, p->mem_ctx);
3768                         break;
3769
3770                 case SPLHND_PRINTER:
3771                         result = printer_notify_info(p, r->in.handle,
3772                                                      info, p->mem_ctx);
3773                         break;
3774         }
3775
3776         Printer->notify.fnpcn = false;
3777
3778 done:
3779         return result;
3780 }
3781
3782 /********************************************************************
3783  ********************************************************************/
3784
3785 static WERROR create_printername(TALLOC_CTX *mem_ctx,
3786                                  const char *servername,
3787                                  const char *printername,
3788                                  const char **printername_p)
3789 {
3790         /* FIXME: add lp_force_printername() */
3791
3792         if (servername == NULL) {
3793                 *printername_p = talloc_strdup(mem_ctx, printername);
3794                 W_ERROR_HAVE_NO_MEMORY(*printername_p);
3795                 return WERR_OK;
3796         }
3797
3798         if (servername[0] == '\\' && servername[1] == '\\') {
3799                 servername += 2;
3800         }
3801
3802         *printername_p = talloc_asprintf(mem_ctx, "\\\\%s\\%s", servername, printername);
3803         W_ERROR_HAVE_NO_MEMORY(*printername_p);
3804
3805         return WERR_OK;
3806 }
3807
3808 /********************************************************************
3809  ********************************************************************/
3810
3811 static void compose_devicemode_devicename(struct spoolss_DeviceMode *dm,
3812                                           const char *printername)
3813 {
3814         if (dm == NULL) {
3815                 return;
3816         }
3817
3818         dm->devicename = talloc_strndup(dm, printername,
3819                                         MIN(strlen(printername), 31));
3820 }
3821
3822 /********************************************************************
3823  * construct_printer_info_0
3824  * fill a printer_info_0 struct
3825  ********************************************************************/
3826
3827 static WERROR construct_printer_info0(TALLOC_CTX *mem_ctx,
3828                                       const struct auth_session_info *session_info,
3829                                       struct messaging_context *msg_ctx,
3830                                       struct spoolss_PrinterInfo2 *info2,
3831                                       const char *servername,
3832                                       struct spoolss_PrinterInfo0 *r,
3833                                       int snum)
3834 {
3835         int count;
3836         struct printer_session_counter *session_counter;
3837         struct timeval setuptime;
3838         print_status_struct status;
3839         WERROR result;
3840         int os_major, os_minor, os_build;
3841         const char *architecture;
3842         uint32_t processor_architecture, processor_type;
3843
3844         result = create_printername(mem_ctx, servername, info2->printername, &r->printername);
3845         if (!W_ERROR_IS_OK(result)) {
3846                 return result;
3847         }
3848
3849         if (servername) {
3850                 r->servername = talloc_strdup(mem_ctx, servername);
3851                 W_ERROR_HAVE_NO_MEMORY(r->servername);
3852         } else {
3853                 r->servername = NULL;
3854         }
3855
3856         count = print_queue_length(msg_ctx, snum, &status);
3857
3858         /* check if we already have a counter for this printer */
3859         for (session_counter = counter_list; session_counter; session_counter = session_counter->next) {
3860                 if (session_counter->snum == snum)
3861                         break;
3862         }
3863
3864         /* it's the first time, add it to the list */
3865         if (session_counter == NULL) {
3866                 session_counter = talloc_zero(counter_list, struct printer_session_counter);
3867                 W_ERROR_HAVE_NO_MEMORY(session_counter);
3868                 session_counter->snum           = snum;
3869                 session_counter->counter        = 0;
3870                 DLIST_ADD(counter_list, session_counter);
3871         }
3872
3873         /* increment it */
3874         session_counter->counter++;
3875
3876         r->cjobs                        = count;
3877         r->total_jobs                   = 0;
3878         r->total_bytes                  = 0;
3879
3880         get_startup_time(&setuptime);
3881         init_systemtime(&r->time, gmtime(&setuptime.tv_sec));
3882
3883         /* JFM:
3884          * the global_counter should be stored in a TDB as it's common to all the clients
3885          * and should be zeroed on samba startup
3886          */
3887         r->global_counter               = session_counter->counter;
3888         r->total_pages                  = 0;
3889
3890         /* in 2.2 we reported ourselves as 0x0004 and 0x0565 */
3891         os_major = lp_parm_int(GLOBAL_SECTION_SNUM,
3892                                "spoolss", "os_major",
3893                                GLOBAL_SPOOLSS_OS_MAJOR_DEFAULT);
3894         os_minor = lp_parm_int(GLOBAL_SECTION_SNUM,
3895                                "spoolss", "os_minor",
3896                                GLOBAL_SPOOLSS_OS_MINOR_DEFAULT);
3897         os_build = lp_parm_int(GLOBAL_SECTION_SNUM,
3898                                "spoolss", "os_build",
3899                                GLOBAL_SPOOLSS_OS_BUILD_DEFAULT);
3900
3901         SCVAL(&r->version, 0, os_major);
3902         SCVAL(&r->version, 1, os_minor);
3903         SSVAL(&r->version, 2, os_build);
3904
3905         architecture = lp_parm_const_string(GLOBAL_SECTION_SNUM,
3906                                             "spoolss",
3907                                             "architecture",
3908                                             GLOBAL_SPOOLSS_ARCHITECTURE);
3909
3910         if (strequal(architecture, SPOOLSS_ARCHITECTURE_x64)) {
3911                 processor_architecture  = PROCESSOR_ARCHITECTURE_AMD64;
3912                 processor_type          = PROCESSOR_AMD_X8664;
3913         } else {
3914                 processor_architecture  = PROCESSOR_ARCHITECTURE_INTEL;
3915                 processor_type          = PROCESSOR_INTEL_PENTIUM;
3916         }
3917
3918         r->free_build                   = SPOOLSS_RELEASE_BUILD;
3919         r->spooling                     = 0;
3920         r->max_spooling                 = 0;
3921         r->session_counter              = session_counter->counter;
3922         r->num_error_out_of_paper       = 0x0;
3923         r->num_error_not_ready          = 0x0;          /* number of print failure */
3924         r->job_error                    = 0x0;
3925         r->number_of_processors         = 0x1;
3926         r->processor_type               = processor_type;
3927         r->high_part_total_bytes        = 0x0;
3928
3929         /* ChangeID in milliseconds*/
3930         winreg_printer_get_changeid_internal(mem_ctx, session_info, msg_ctx,
3931                                     info2->sharename, &r->change_id);
3932
3933         r->last_error                   = WERR_OK;
3934         r->status                       = nt_printq_status(status.status);
3935         r->enumerate_network_printers   = 0x0;
3936         r->c_setprinter                 = 0x0;
3937         r->processor_architecture       = processor_architecture;
3938         r->processor_level              = 0x6;          /* 6  ???*/
3939         r->ref_ic                       = 0;
3940         r->reserved2                    = 0;
3941         r->reserved3                    = 0;
3942
3943         return WERR_OK;
3944 }
3945
3946
3947 /********************************************************************
3948  * construct_printer_info1
3949  * fill a spoolss_PrinterInfo1 struct
3950 ********************************************************************/
3951
3952 static WERROR construct_printer_info1(TALLOC_CTX *mem_ctx,
3953                                       const struct spoolss_PrinterInfo2 *info2,
3954                                       uint32_t flags,
3955                                       const char *servername,
3956                                       struct spoolss_PrinterInfo1 *r,
3957                                       int snum)
3958 {
3959         WERROR result;
3960
3961         r->flags                = flags;
3962
3963         if (info2->comment == NULL || info2->comment[0] == '\0') {
3964                 r->comment      = lp_comment(mem_ctx, snum);
3965         } else {
3966                 r->comment      = talloc_strdup(mem_ctx, info2->comment); /* saved comment */
3967         }
3968         W_ERROR_HAVE_NO_MEMORY(r->comment);
3969
3970         result = create_printername(mem_ctx, servername, info2->printername, &r->name);
3971         if (!W_ERROR_IS_OK(result)) {
3972                 return result;
3973         }
3974
3975         r->description          = talloc_asprintf(mem_ctx, "%s,%s,%s",
3976                                                   r->name,
3977                                                   info2->drivername,
3978                                                   r->comment);
3979         W_ERROR_HAVE_NO_MEMORY(r->description);
3980
3981         return WERR_OK;
3982 }
3983
3984 /********************************************************************
3985  * construct_printer_info2
3986  * fill a spoolss_PrinterInfo2 struct
3987 ********************************************************************/
3988
3989 static WERROR construct_printer_info2(TALLOC_CTX *mem_ctx,
3990                                       struct messaging_context *msg_ctx,
3991                                       const struct spoolss_PrinterInfo2 *info2,
3992                                       const char *servername,
3993                                       struct spoolss_PrinterInfo2 *r,
3994                                       int snum)
3995 {
3996         int count;
3997         print_status_struct status;
3998         WERROR result;
3999
4000         count = print_queue_length(msg_ctx, snum, &status);
4001
4002         if (servername) {
4003                 r->servername           = talloc_strdup(mem_ctx, servername);
4004                 W_ERROR_HAVE_NO_MEMORY(r->servername);
4005         } else {
4006                 r->servername           = NULL;
4007         }
4008
4009         result = create_printername(mem_ctx, servername, info2->printername, &r->printername);
4010         if (!W_ERROR_IS_OK(result)) {
4011                 return result;
4012         }
4013
4014         r->sharename            = lp_servicename(mem_ctx, snum);
4015         W_ERROR_HAVE_NO_MEMORY(r->sharename);
4016         r->portname             = talloc_strdup(mem_ctx, info2->portname);
4017         W_ERROR_HAVE_NO_MEMORY(r->portname);
4018         r->drivername           = talloc_strdup(mem_ctx, info2->drivername);
4019         W_ERROR_HAVE_NO_MEMORY(r->drivername);
4020
4021         if (info2->comment[0] == '\0') {
4022                 r->comment      = lp_comment(mem_ctx, snum);
4023         } else {
4024                 r->comment      = talloc_strdup(mem_ctx, info2->comment);
4025         }
4026         W_ERROR_HAVE_NO_MEMORY(r->comment);
4027
4028         r->location     = talloc_strdup(mem_ctx, info2->location);
4029         if (info2->location[0] == '\0') {
4030                 const char *loc = NULL;
4031                 NTSTATUS nt_status;
4032
4033                 nt_status = printer_list_get_printer(mem_ctx,
4034                                                      info2->sharename,
4035                                                      NULL,
4036                                                      &loc,
4037                                                      NULL);
4038                 if (NT_STATUS_IS_OK(nt_status)) {
4039                         if (loc != NULL) {
4040                                 r->location = talloc_strdup(mem_ctx, loc);
4041                         }
4042                 }
4043         }
4044         W_ERROR_HAVE_NO_MEMORY(r->location);
4045
4046         r->sepfile              = talloc_strdup(mem_ctx, info2->sepfile);
4047         W_ERROR_HAVE_NO_MEMORY(r->sepfile);
4048         r->printprocessor       = talloc_strdup(mem_ctx, info2->printprocessor);
4049         W_ERROR_HAVE_NO_MEMORY(r->printprocessor);
4050         r->datatype             = talloc_strdup(mem_ctx, info2->datatype);
4051         W_ERROR_HAVE_NO_MEMORY(r->datatype);
4052         r->parameters           = talloc_strdup(mem_ctx, info2->parameters);
4053         W_ERROR_HAVE_NO_MEMORY(r->parameters);
4054
4055         r->attributes           = info2->attributes;
4056
4057         r->priority             = info2->priority;
4058         r->defaultpriority      = info2->defaultpriority;
4059         r->starttime            = info2->starttime;
4060         r->untiltime            = info2->untiltime;
4061         r->status               = nt_printq_status(status.status);
4062         r->cjobs                = count;
4063         r->averageppm           = info2->averageppm;
4064
4065         if (info2->devmode != NULL) {
4066                 result = copy_devicemode(mem_ctx,
4067                                          info2->devmode,
4068                                          &r->devmode);
4069                 if (!W_ERROR_IS_OK(result)) {
4070                         return result;
4071                 }
4072         } else if (lp_default_devmode(snum)) {
4073                 result = spoolss_create_default_devmode(mem_ctx,
4074                                                         info2->printername,
4075                                                         &r->devmode);
4076                 if (!W_ERROR_IS_OK(result)) {
4077                         return result;
4078                 }
4079         } else {
4080                 r->devmode = NULL;
4081                 DEBUG(8,("Returning NULL Devicemode!\n"));
4082         }
4083
4084         compose_devicemode_devicename(r->devmode, r->printername);
4085
4086         r->secdesc = NULL;
4087
4088         if (info2->secdesc != NULL) {
4089                 /* don't use talloc_steal() here unless you do a deep steal of all
4090                    the SEC_DESC members */
4091
4092                 r->secdesc = security_descriptor_copy(mem_ctx, info2->secdesc);
4093                 if (r->secdesc == NULL) {
4094                         return WERR_NOT_ENOUGH_MEMORY;
4095                 }
4096         }
4097
4098         return WERR_OK;
4099 }
4100
4101 /********************************************************************
4102  * construct_printer_info3
4103  * fill a spoolss_PrinterInfo3 struct
4104  ********************************************************************/
4105
4106 static WERROR construct_printer_info3(TALLOC_CTX *mem_ctx,
4107                                       const struct spoolss_PrinterInfo2 *info2,
4108                                       const char *servername,
4109                                       struct spoolss_PrinterInfo3 *r,
4110                                       int snum)
4111 {
4112         /* These are the components of the SD we are returning. */
4113
4114         if (info2->secdesc != NULL) {
4115                 /* don't use talloc_steal() here unless you do a deep steal of all
4116                    the SEC_DESC members */
4117
4118                 r->secdesc = security_descriptor_copy(mem_ctx, info2->secdesc);
4119                 if (r->secdesc == NULL) {
4120                         return WERR_NOT_ENOUGH_MEMORY;
4121                 }
4122         }
4123
4124         return WERR_OK;
4125 }
4126
4127 /********************************************************************
4128  * construct_printer_info4
4129  * fill a spoolss_PrinterInfo4 struct
4130  ********************************************************************/
4131
4132 static WERROR construct_printer_info4(TALLOC_CTX *mem_ctx,
4133                                       const struct spoolss_PrinterInfo2 *info2,
4134                                       const char *servername,
4135                                       struct spoolss_PrinterInfo4 *r,
4136                                       int snum)
4137 {
4138         WERROR result;
4139
4140         result = create_printername(mem_ctx, servername, info2->printername, &r->printername);
4141         if (!W_ERROR_IS_OK(result)) {
4142                 return result;
4143         }
4144
4145         if (servername) {
4146                 r->servername   = talloc_strdup(mem_ctx, servername);
4147                 W_ERROR_HAVE_NO_MEMORY(r->servername);
4148         } else {
4149                 r->servername = NULL;
4150         }
4151
4152         r->attributes   = info2->attributes;
4153
4154         return WERR_OK;
4155 }
4156
4157 /********************************************************************
4158  * construct_printer_info5
4159  * fill a spoolss_PrinterInfo5 struct
4160  ********************************************************************/
4161
4162 static WERROR construct_printer_info5(TALLOC_CTX *mem_ctx,
4163                                       const struct spoolss_PrinterInfo2 *info2,
4164                                       const char *servername,
4165                                       struct spoolss_PrinterInfo5 *r,
4166                                       int snum)
4167 {
4168         WERROR result;
4169
4170         result = create_printername(mem_ctx, servername, info2->printername, &r->printername);
4171         if (!W_ERROR_IS_OK(result)) {
4172                 return result;
4173         }
4174
4175         r->portname     = talloc_strdup(mem_ctx, info2->portname);
4176         W_ERROR_HAVE_NO_MEMORY(r->portname);
4177
4178         r->attributes   = info2->attributes;
4179
4180         /* these two are not used by NT+ according to MSDN */
4181         r->device_not_selected_timeout          = 0x0;  /* have seen 0x3a98 */
4182         r->transmission_retry_timeout           = 0x0;  /* have seen 0xafc8 */
4183
4184         return WERR_OK;
4185 }
4186
4187 /********************************************************************
4188  * construct_printer_info_6
4189  * fill a spoolss_PrinterInfo6 struct
4190  ********************************************************************/
4191
4192 static WERROR construct_printer_info6(TALLOC_CTX *mem_ctx,
4193                                       struct messaging_context *msg_ctx,
4194                                       const struct spoolss_PrinterInfo2 *info2,
4195                                       const char *servername,
4196                                       struct spoolss_PrinterInfo6 *r,
4197                                       int snum)
4198 {
4199         print_status_struct status;
4200
4201         print_queue_length(msg_ctx, snum, &status);
4202
4203         r->status = nt_printq_status(status.status);
4204
4205         return WERR_OK;
4206 }
4207
4208 /********************************************************************
4209  * construct_printer_info7
4210  * fill a spoolss_PrinterInfo7 struct
4211  ********************************************************************/
4212
4213 static WERROR construct_printer_info7(TALLOC_CTX *mem_ctx,
4214                                       struct messaging_context *msg_ctx,
4215                                       const char *servername,
4216                                       struct spoolss_PrinterInfo7 *r,
4217                                       int snum)
4218 {
4219         const struct auth_session_info *session_info;
4220         struct spoolss_PrinterInfo2 *pinfo2 = NULL;
4221         char *printer;
4222         WERROR werr;
4223         TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
4224         if (tmp_ctx == NULL) {
4225                 return WERR_NOT_ENOUGH_MEMORY;
4226         }
4227
4228         session_info = get_session_info_system();
4229         SMB_ASSERT(session_info != NULL);
4230
4231         printer = lp_servicename(tmp_ctx, snum);
4232         if (printer == NULL) {
4233                 DEBUG(0, ("invalid printer snum %d\n", snum));
4234                 werr = WERR_INVALID_PARAMETER;
4235                 goto out_tmp_free;
4236         }
4237
4238         if (is_printer_published(tmp_ctx, session_info, msg_ctx,
4239                                  servername, printer, &pinfo2)) {
4240                 struct GUID guid;
4241                 struct GUID_txt_buf guid_txt;
4242                 werr = nt_printer_guid_get(tmp_ctx, session_info, msg_ctx,
4243                                            printer, &guid);
4244                 if (!W_ERROR_IS_OK(werr)) {
4245                         /*
4246                          * If we do not have a GUID entry in the registry, then
4247                          * try to retrieve it from AD and store it now.
4248                          */
4249                         werr = nt_printer_guid_retrieve(tmp_ctx, printer,
4250                                                         &guid);
4251                         if (!W_ERROR_IS_OK(werr)) {
4252                                 DBG_NOTICE("Failed to retrieve GUID for "
4253                                            "printer [%s] from AD - %s\n",
4254                                            printer,
4255                                            win_errstr(werr));
4256                                 if (W_ERROR_EQUAL(werr, WERR_FILE_NOT_FOUND)) {
4257                                         /*
4258                                          * If we did not find it in AD, then it
4259                                          * is unpublished and we should reflect
4260                                          * this in the registry and return
4261                                          * success.
4262                                          */
4263                                         DBG_WARNING("Unpublish printer [%s]\n",
4264                                                     pinfo2->sharename);
4265                                         nt_printer_publish(tmp_ctx,
4266                                                            session_info,
4267                                                            msg_ctx,
4268                                                            pinfo2,
4269                                                            DSPRINT_UNPUBLISH);
4270                                         r->guid = talloc_strdup(mem_ctx, "");
4271                                         r->action = DSPRINT_UNPUBLISH;
4272
4273                                         if (r->guid == NULL) {
4274                                                 werr = WERR_NOT_ENOUGH_MEMORY;
4275                                         } else {
4276                                                 werr = WERR_OK;
4277                                         }
4278                                 }
4279                                 goto out_tmp_free;
4280                         }
4281
4282                         werr = nt_printer_guid_store(msg_ctx, printer, guid);
4283                         if (!W_ERROR_IS_OK(werr)) {
4284                                 DEBUG(3, ("failed to store printer %s guid\n",
4285                                           printer));
4286                         }
4287                 }
4288                 r->guid = talloc_strdup_upper(mem_ctx,
4289                                              GUID_buf_string(&guid, &guid_txt));
4290                 r->action = DSPRINT_PUBLISH;
4291         } else {
4292                 r->guid = talloc_strdup(mem_ctx, "");
4293                 r->action = DSPRINT_UNPUBLISH;
4294         }
4295         if (r->guid == NULL) {
4296                 werr = WERR_NOT_ENOUGH_MEMORY;
4297                 goto out_tmp_free;
4298         }
4299
4300         werr = WERR_OK;
4301 out_tmp_free:
4302         talloc_free(tmp_ctx);
4303         return werr;
4304 }
4305
4306 /********************************************************************
4307  * construct_printer_info8
4308  * fill a spoolss_PrinterInfo8 struct
4309  ********************************************************************/
4310
4311 static WERROR construct_printer_info8(TALLOC_CTX *mem_ctx,
4312                                       const struct spoolss_PrinterInfo2 *info2,
4313                                       const char *servername,
4314                                       struct spoolss_DeviceModeInfo *r,
4315                                       int snum)
4316 {
4317         WERROR result;
4318         const char *printername;
4319
4320         result = create_printername(mem_ctx, servername, info2->printername, &printername);
4321         if (!W_ERROR_IS_OK(result)) {
4322                 return result;
4323         }
4324
4325         if (info2->devmode != NULL) {
4326                 result = copy_devicemode(mem_ctx,
4327                                          info2->devmode,
4328                                          &r->devmode);
4329                 if (!W_ERROR_IS_OK(result)) {
4330                         return result;
4331                 }
4332         } else if (lp_default_devmode(snum)) {
4333                 result = spoolss_create_default_devmode(mem_ctx,
4334                                                         info2->printername,
4335                                                         &r->devmode);
4336                 if (!W_ERROR_IS_OK(result)) {
4337                         return result;
4338                 }
4339         } else {
4340                 r->devmode = NULL;
4341                 DEBUG(8,("Returning NULL Devicemode!\n"));
4342         }
4343
4344         compose_devicemode_devicename(r->devmode, printername);
4345
4346         return WERR_OK;
4347 }
4348
4349 /********************************************************************
4350  Spoolss_enumprinters.
4351 ********************************************************************/
4352
4353 static WERROR enum_all_printers_info_level(TALLOC_CTX *mem_ctx,
4354                                            const struct auth_session_info *session_info,
4355                                            struct messaging_context *msg_ctx,
4356                                            const char *servername,
4357                                            uint32_t level,
4358                                            uint32_t flags,
4359                                            union spoolss_PrinterInfo **info_p,
4360                                            uint32_t *count_p)
4361 {
4362         int snum;
4363         int n_services;
4364         union spoolss_PrinterInfo *info = NULL;
4365         uint32_t count = 0;
4366         WERROR result = WERR_OK;
4367         struct dcerpc_binding_handle *b = NULL;
4368         TALLOC_CTX *tmp_ctx = NULL;
4369
4370         tmp_ctx = talloc_new(mem_ctx);
4371         if (!tmp_ctx) {
4372                 return WERR_NOT_ENOUGH_MEMORY;
4373         }
4374
4375         /*
4376          * printer shares are updated on client enumeration. The background
4377          * printer process updates printer_list.tdb at regular intervals.
4378          */
4379         become_root();
4380         delete_and_reload_printers(server_event_context(), msg_ctx);
4381         unbecome_root();
4382
4383         n_services = lp_numservices();
4384         *count_p = 0;
4385         *info_p = NULL;
4386
4387         for (snum = 0; snum < n_services; snum++) {
4388
4389                 const char *printer;
4390                 struct spoolss_PrinterInfo2 *info2;
4391
4392                 if (!snum_is_shared_printer(snum)) {
4393                         continue;
4394                 }
4395
4396                 printer = lp_const_servicename(snum);
4397
4398                 DEBUG(4,("Found a printer in smb.conf: %s[%x]\n",
4399                         printer, snum));
4400
4401                 if (b == NULL) {
4402                         result = winreg_printer_binding_handle(tmp_ctx,
4403                                                                session_info,
4404                                                                msg_ctx,
4405                                                                &b);
4406                         if (!W_ERROR_IS_OK(result)) {
4407                                 goto out;
4408                         }
4409                 }
4410
4411                 result = winreg_create_printer(tmp_ctx, b,
4412                                                printer);
4413                 if (!W_ERROR_IS_OK(result)) {
4414                         goto out;
4415                 }
4416
4417                 info = talloc_realloc(tmp_ctx, info,
4418                                             union spoolss_PrinterInfo,
4419                                             count + 1);
4420                 if (!info) {
4421                         result = WERR_NOT_ENOUGH_MEMORY;
4422                         goto out;
4423                 }
4424
4425                 result = winreg_get_printer(tmp_ctx, b,
4426                                             printer, &info2);
4427                 if (!W_ERROR_IS_OK(result)) {
4428                         goto out;
4429                 }
4430
4431                 switch (level) {
4432                 case 0:
4433                         result = construct_printer_info0(info, session_info,
4434                                                          msg_ctx, info2,
4435                                                          servername,
4436                                                          &info[count].info0, snum);
4437                         break;
4438                 case 1:
4439                         result = construct_printer_info1(info, info2, flags,
4440                                                          servername,
4441                                                          &info[count].info1, snum);
4442                         break;
4443                 case 2:
4444                         result = construct_printer_info2(info, msg_ctx, info2,
4445                                                          servername,
4446                                                          &info[count].info2, snum);
4447                         break;
4448                 case 4:
4449                         result = construct_printer_info4(info, info2,
4450                                                          servername,
4451                                                          &info[count].info4, snum);
4452                         break;
4453                 case 5:
4454                         result = construct_printer_info5(info, info2,
4455                                                          servername,
4456                                                          &info[count].info5, snum);
4457                         break;
4458
4459                 default:
4460                         result = WERR_INVALID_LEVEL;
4461                         goto out;
4462                 }
4463
4464                 if (!W_ERROR_IS_OK(result)) {
4465                         goto out;
4466                 }
4467
4468                 count++;
4469         }
4470
4471 out:
4472         if (W_ERROR_IS_OK(result)) {
4473                 *info_p = talloc_move(mem_ctx, &info);
4474                 *count_p = count;
4475         }
4476
4477         talloc_free(tmp_ctx);
4478
4479         return result;
4480 }
4481
4482 /********************************************************************
4483  * handle enumeration of printers at level 0
4484  ********************************************************************/
4485
4486 static WERROR enumprinters_level0(TALLOC_CTX *mem_ctx,
4487                                   const struct auth_session_info *session_info,
4488                                   struct messaging_context *msg_ctx,
4489                                   uint32_t flags,
4490                                   const char *servername,
4491                                   union spoolss_PrinterInfo **info,
4492                                   uint32_t *count)
4493 {
4494         DEBUG(4,("enum_all_printers_info_0\n"));
4495
4496         return enum_all_printers_info_level(mem_ctx, session_info, msg_ctx,
4497                                             servername, 0, flags, info, count);
4498 }
4499
4500
4501 /********************************************************************
4502 ********************************************************************/
4503
4504 static WERROR enum_all_printers_info_1(TALLOC_CTX *mem_ctx,
4505                                        const struct auth_session_info *session_info,
4506                                        struct messaging_context *msg_ctx,
4507                                        const char *servername,
4508                                        uint32_t flags,
4509                                        union spoolss_PrinterInfo **info,
4510                                        uint32_t *count)
4511 {
4512         DEBUG(4,("enum_all_printers_info_1\n"));
4513
4514         return enum_all_printers_info_level(mem_ctx, session_info, msg_ctx,
4515                                             servername, 1, flags, info, count);
4516 }
4517
4518 /********************************************************************
4519  enum_all_printers_info_1_local.
4520 *********************************************************************/
4521
4522 static WERROR enum_all_printers_info_1_local(TALLOC_CTX *mem_ctx,
4523                                              const struct auth_session_info *session_info,
4524                                              struct messaging_context *msg_ctx,
4525                                              const char *servername,
4526                                              union spoolss_PrinterInfo **info,
4527                                              uint32_t *count)
4528 {
4529         DEBUG(4,("enum_all_printers_info_1_local\n"));
4530
4531         return enum_all_printers_info_1(mem_ctx, session_info, msg_ctx,
4532                                         servername, PRINTER_ENUM_ICON8, info, count);
4533 }
4534
4535 /********************************************************************
4536  enum_all_printers_info_1_name.
4537 *********************************************************************/
4538
4539 static WERROR enum_all_printers_info_1_name(TALLOC_CTX *mem_ctx,
4540                                             const struct auth_session_info *session_info,
4541                                             struct messaging_context *msg_ctx,
4542                                             const char *servername,
4543                                             union spoolss_PrinterInfo **info,
4544                                             uint32_t *count)
4545 {
4546         const char *s = servername;
4547
4548         DEBUG(4,("enum_all_printers_info_1_name\n"));
4549
4550         if (servername != NULL &&
4551             (servername[0] == '\\') && (servername[1] == '\\')) {
4552                 s = servername + 2;
4553         }
4554
4555         if (!is_myname_or_ipaddr(s)) {
4556                 return WERR_INVALID_NAME;
4557         }
4558
4559         return enum_all_printers_info_1(mem_ctx, session_info, msg_ctx,
4560                                         servername, PRINTER_ENUM_ICON8, info, count);
4561 }
4562
4563 /********************************************************************
4564  enum_all_printers_info_1_network.
4565 *********************************************************************/
4566
4567 static WERROR enum_all_printers_info_1_network(TALLOC_CTX *mem_ctx,
4568                                                const struct auth_session_info *session_info,
4569                                                struct messaging_context *msg_ctx,
4570                                                const char *servername,
4571                                                union spoolss_PrinterInfo **info,
4572                                                uint32_t *count)
4573 {
4574         const char *s = servername;
4575
4576         DEBUG(4,("enum_all_printers_info_1_network\n"));
4577
4578         /* If we respond to a enum_printers level 1 on our name with flags
4579            set to PRINTER_ENUM_REMOTE with a list of printers then these
4580            printers incorrectly appear in the APW browse list.
4581            Specifically the printers for the server appear at the workgroup
4582            level where all the other servers in the domain are
4583            listed. Windows responds to this call with a
4584            WERR_CAN_NOT_COMPLETE so we should do the same. */
4585
4586         if (servername != NULL &&
4587             (servername[0] == '\\') && (servername[1] == '\\')) {
4588                  s = servername + 2;
4589         }
4590
4591         if (is_myname_or_ipaddr(s)) {
4592                  return WERR_CAN_NOT_COMPLETE;
4593         }
4594
4595         return enum_all_printers_info_1(mem_ctx, session_info, msg_ctx,
4596                                         servername, PRINTER_ENUM_NAME, info, count);
4597 }
4598
4599 /********************************************************************
4600  * api_spoolss_enumprinters
4601  *
4602  * called from api_spoolss_enumprinters (see this to understand)
4603  ********************************************************************/
4604
4605 static WERROR enum_all_printers_info_2(TALLOC_CTX *mem_ctx,
4606                                        const struct auth_session_info *session_info,
4607                                        struct messaging_context *msg_ctx,
4608                                        const char *servername,
4609                                        union spoolss_PrinterInfo **info,
4610                                        uint32_t *count)
4611 {
4612         DEBUG(4,("enum_all_printers_info_2\n"));
4613
4614         return enum_all_printers_info_level(mem_ctx, session_info, msg_ctx,
4615                                             servername, 2, 0, info, count);
4616 }
4617
4618 /********************************************************************
4619  * handle enumeration of printers at level 1
4620  ********************************************************************/
4621
4622 static WERROR enumprinters_level1(TALLOC_CTX *mem_ctx,
4623                                   const struct auth_session_info *session_info,
4624                                   struct messaging_context *msg_ctx,
4625                                   uint32_t flags,
4626                                   const char *servername,
4627                                   union spoolss_PrinterInfo **info,
4628                                   uint32_t *count)
4629 {
4630         /* Not all the flags are equals */
4631
4632         if (flags & PRINTER_ENUM_LOCAL) {
4633                 return enum_all_printers_info_1_local(mem_ctx, session_info,
4634                                                       msg_ctx, servername, info, count);
4635         }
4636
4637         if (flags & PRINTER_ENUM_NAME) {
4638                 return enum_all_printers_info_1_name(mem_ctx, session_info,
4639                                                      msg_ctx, servername, info,
4640                                                      count);
4641         }
4642
4643         if (flags & PRINTER_ENUM_NETWORK) {
4644                 return enum_all_printers_info_1_network(mem_ctx, session_info,
4645                                                         msg_ctx, servername, info,
4646                                                         count);
4647         }
4648
4649         return WERR_OK; /* NT4sp5 does that */
4650 }
4651
4652 /********************************************************************
4653  * handle enumeration of printers at level 2
4654  ********************************************************************/
4655
4656 static WERROR enumprinters_level2(TALLOC_CTX *mem_ctx,
4657                                   const struct auth_session_info *session_info,
4658                                   struct messaging_context *msg_ctx,
4659                                   uint32_t flags,
4660                                   const char *servername,
4661                                   union spoolss_PrinterInfo **info,
4662                                   uint32_t *count)
4663 {
4664         if (flags & PRINTER_ENUM_LOCAL) {
4665
4666                 return enum_all_printers_info_2(mem_ctx, session_info, msg_ctx,
4667                                                 servername,
4668                                                 info, count);
4669         }
4670
4671         if (flags & PRINTER_ENUM_NAME) {
4672                 if (servername && !is_myname_or_ipaddr(canon_servername(servername))) {
4673                         return WERR_INVALID_NAME;
4674                 }
4675
4676                 return enum_all_printers_info_2(mem_ctx, session_info, msg_ctx,
4677                                                 servername,
4678                                                 info, count);
4679         }
4680
4681         if (flags & PRINTER_ENUM_REMOTE) {
4682                 return WERR_INVALID_LEVEL;
4683         }
4684
4685         return WERR_OK;
4686 }
4687
4688 /********************************************************************
4689  * handle enumeration of printers at level 4
4690  ********************************************************************/
4691
4692 static WERROR enumprinters_level4(TALLOC_CTX *mem_ctx,
4693                                   const struct auth_session_info *session_info,
4694                                   struct messaging_context *msg_ctx,
4695                                   uint32_t flags,
4696                                   const char *servername,
4697                                   union spoolss_PrinterInfo **info,
4698                                   uint32_t *count)
4699 {
4700         DEBUG(4,("enum_all_printers_info_4\n"));
4701
4702         return enum_all_printers_info_level(mem_ctx, session_info, msg_ctx,
4703                                             servername, 4, flags, info, count);
4704 }
4705
4706
4707 /********************************************************************
4708  * handle enumeration of printers at level 5
4709  ********************************************************************/
4710
4711 static WERROR enumprinters_level5(TALLOC_CTX *mem_ctx,
4712                                   const struct auth_session_info *session_info,
4713                                   struct messaging_context *msg_ctx,
4714                                   uint32_t flags,
4715                                   const char *servername,
4716                                   union spoolss_PrinterInfo **info,
4717                                   uint32_t *count)
4718 {
4719         DEBUG(4,("enum_all_printers_info_5\n"));
4720
4721         return enum_all_printers_info_level(mem_ctx, session_info, msg_ctx,
4722                                             servername, 5, flags, info, count);
4723 }
4724
4725 /****************************************************************
4726  _spoolss_EnumPrinters
4727 ****************************************************************/
4728
4729 WERROR _spoolss_EnumPrinters(struct pipes_struct *p,
4730                              struct spoolss_EnumPrinters *r)
4731 {
4732         const struct auth_session_info *session_info = get_session_info_system();
4733         WERROR result;
4734
4735         /* that's an [in out] buffer */
4736
4737         if (!r->in.buffer && (r->in.offered != 0)) {
4738                 return WERR_INVALID_PARAMETER;
4739         }
4740
4741         DEBUG(4,("_spoolss_EnumPrinters\n"));
4742
4743         *r->out.needed = 0;
4744         *r->out.count = 0;
4745         *r->out.info = NULL;
4746
4747         /*
4748          * Level 1:
4749          *          flags==PRINTER_ENUM_NAME
4750          *           if name=="" then enumerates all printers
4751          *           if name!="" then enumerate the printer
4752          *          flags==PRINTER_ENUM_REMOTE
4753          *          name is NULL, enumerate printers
4754          * Level 2: name!="" enumerates printers, name can't be NULL
4755          * Level 3: doesn't exist
4756          * Level 4: does a local registry lookup
4757          * Level 5: same as Level 2
4758          */
4759
4760         if (r->in.server && r->in.server[0] == '\0') {
4761                 r->in.server = NULL;
4762         }
4763
4764         switch (r->in.level) {
4765         case 0:
4766                 result = enumprinters_level0(p->mem_ctx, session_info,
4767                                              p->msg_ctx, r->in.flags,
4768                                              r->in.server,
4769                                              r->out.info, r->out.count);
4770                 break;
4771         case 1:
4772                 result = enumprinters_level1(p->mem_ctx, session_info,
4773                                              p->msg_ctx, r->in.flags,
4774                                              r->in.server,
4775                                              r->out.info, r->out.count);
4776                 break;
4777         case 2:
4778                 result = enumprinters_level2(p->mem_ctx, session_info,
4779                                              p->msg_ctx, r->in.flags,
4780                                              r->in.server,
4781                                              r->out.info, r->out.count);
4782                 break;
4783         case 4:
4784                 result = enumprinters_level4(p->mem_ctx, session_info,
4785                                              p->msg_ctx, r->in.flags,
4786                                              r->in.server,
4787                                              r->out.info, r->out.count);
4788                 break;
4789         case 5:
4790                 result = enumprinters_level5(p->mem_ctx, session_info,
4791                                              p->msg_ctx, r->in.flags,
4792                                              r->in.server,
4793                                              r->out.info, r->out.count);
4794                 break;
4795         default:
4796                 return WERR_INVALID_LEVEL;
4797         }
4798
4799         if (!W_ERROR_IS_OK(result)) {
4800                 return result;
4801         }
4802
4803         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
4804                                                      spoolss_EnumPrinters,
4805                                                      *r->out.info, r->in.level,
4806                                                      *r->out.count);
4807         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
4808         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
4809
4810         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
4811 }
4812
4813 /****************************************************************
4814  _spoolss_GetPrinter
4815 ****************************************************************/
4816
4817 WERROR _spoolss_GetPrinter(struct pipes_struct *p,
4818                            struct spoolss_GetPrinter *r)
4819 {
4820         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
4821         struct spoolss_PrinterInfo2 *info2 = NULL;
4822         WERROR result = WERR_OK;
4823         int snum;
4824
4825         /* that's an [in out] buffer */
4826
4827         if (!r->in.buffer && (r->in.offered != 0)) {
4828                 result = WERR_INVALID_PARAMETER;
4829                 goto err_info_free;
4830         }
4831
4832         *r->out.needed = 0;
4833
4834         if (Printer == NULL) {
4835                 result = WERR_INVALID_HANDLE;
4836                 goto err_info_free;
4837         }
4838
4839         if (Printer->printer_type == SPLHND_SERVER) {
4840
4841                 struct dcerpc_binding_handle *b;
4842
4843                 if (r->in.level != 3) {
4844                         result = WERR_INVALID_LEVEL;
4845                         goto err_info_free;
4846                 }
4847
4848                 result = winreg_printer_binding_handle(p->mem_ctx,
4849                                                        get_session_info_system(),
4850                                                        p->msg_ctx,
4851                                                        &b);
4852                 if (!W_ERROR_IS_OK(result)) {
4853                         goto err_info_free;
4854                 }
4855
4856                 result = winreg_get_printserver_secdesc(p->mem_ctx,
4857                                                         b,
4858                                                         &r->out.info->info3.secdesc);
4859                 if (!W_ERROR_IS_OK(result)) {
4860                         goto err_info_free;
4861                 }
4862
4863                 goto done;
4864         }
4865
4866         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
4867                 result = WERR_INVALID_HANDLE;
4868                 goto err_info_free;
4869         }
4870
4871         result = winreg_get_printer_internal(p->mem_ctx,
4872                                     get_session_info_system(),
4873                                     p->msg_ctx,
4874                                     lp_const_servicename(snum),
4875                                     &info2);
4876         if (!W_ERROR_IS_OK(result)) {
4877                 goto err_info_free;
4878         }
4879
4880         switch (r->in.level) {
4881         case 0:
4882                 result = construct_printer_info0(p->mem_ctx,
4883                                                  get_session_info_system(),
4884                                                  p->msg_ctx,
4885                                                  info2,
4886                                                  Printer->servername,
4887                                                  &r->out.info->info0,
4888                                                  snum);
4889                 break;
4890         case 1:
4891                 result = construct_printer_info1(p->mem_ctx, info2,
4892                                                  PRINTER_ENUM_ICON8,
4893                                                  Printer->servername,
4894                                                  &r->out.info->info1, snum);
4895                 break;
4896         case 2:
4897                 result = construct_printer_info2(p->mem_ctx, p->msg_ctx, info2,
4898                                                  Printer->servername,
4899                                                  &r->out.info->info2, snum);
4900                 break;
4901         case 3:
4902                 result = construct_printer_info3(p->mem_ctx, info2,
4903                                                  Printer->servername,
4904                                                  &r->out.info->info3, snum);
4905                 break;
4906         case 4:
4907                 result = construct_printer_info4(p->mem_ctx, info2,
4908                                                  Printer->servername,
4909                                                  &r->out.info->info4, snum);
4910                 break;
4911         case 5:
4912                 result = construct_printer_info5(p->mem_ctx, info2,
4913                                                  Printer->servername,
4914                                                  &r->out.info->info5, snum);
4915                 break;
4916         case 6:
4917                 result = construct_printer_info6(p->mem_ctx, p->msg_ctx, info2,
4918                                                  Printer->servername,
4919                                                  &r->out.info->info6, snum);
4920                 break;
4921         case 7:
4922                 result = construct_printer_info7(p->mem_ctx, p->msg_ctx,
4923                                                  Printer->servername,
4924                                                  &r->out.info->info7, snum);
4925                 break;
4926         case 8:
4927                 result = construct_printer_info8(p->mem_ctx, info2,
4928                                                  Printer->servername,
4929                                                  &r->out.info->info8, snum);
4930                 break;
4931         default:
4932                 result = WERR_INVALID_LEVEL;
4933                 break;
4934         }
4935         TALLOC_FREE(info2);
4936
4937         if (!W_ERROR_IS_OK(result)) {
4938                 DEBUG(0, ("_spoolss_GetPrinter: failed to construct printer info level %d - %s\n",
4939                           r->in.level, win_errstr(result)));
4940                 goto err_info_free;
4941         }
4942  done:
4943         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_PrinterInfo,
4944                                                r->out.info, r->in.level);
4945         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
4946
4947         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
4948
4949 err_info_free:
4950         TALLOC_FREE(r->out.info);
4951         return result;
4952 }
4953
4954 /********************************************************************
4955  ********************************************************************/
4956
4957 #define FILL_DRIVER_STRING(mem_ctx, in, out) \
4958         do { \
4959                 if (in && strlen(in)) { \
4960                         out = talloc_strdup(mem_ctx, in); \
4961                 } else { \
4962                         out = talloc_strdup(mem_ctx, ""); \
4963                 } \
4964                 W_ERROR_HAVE_NO_MEMORY(out); \
4965         } while (0);
4966
4967 #define FILL_DRIVER_UNC_STRING(mem_ctx, server, arch, ver, in, out) \
4968         do { \
4969                 if (in && strlen(in)) { \
4970                         out = talloc_asprintf(mem_ctx, "\\\\%s\\print$\\%s\\%d\\%s", server, get_short_archi(arch), ver, in); \
4971                 } else { \
4972                         out = talloc_strdup(mem_ctx, ""); \
4973                 } \
4974                 W_ERROR_HAVE_NO_MEMORY(out); \
4975         } while (0);
4976
4977 static WERROR string_array_from_driver_info(TALLOC_CTX *mem_ctx,
4978                                                   const char **string_array,
4979                                                   const char ***presult,
4980                                                   const char *cservername,
4981                                                   const char *arch,
4982                                                   int version)
4983 {
4984         int i;
4985         size_t num_strings = 0;
4986         const char **array = NULL;
4987
4988         if (string_array == NULL) {
4989                 return WERR_INVALID_PARAMETER;
4990         }
4991
4992         for (i=0; string_array[i] && string_array[i][0] != '\0'; i++) {
4993                 const char *str = NULL;
4994
4995                 if (cservername == NULL || arch == NULL) {
4996                         FILL_DRIVER_STRING(mem_ctx, string_array[i], str);
4997                 } else {
4998                         FILL_DRIVER_UNC_STRING(mem_ctx, cservername, arch, version, string_array[i], str);
4999                 }
5000
5001                 if (!add_string_to_array(mem_ctx, str, &array, &num_strings)) {
5002                         TALLOC_FREE(array);
5003                         return WERR_NOT_ENOUGH_MEMORY;
5004                 }
5005         }
5006
5007         if (i > 0) {
5008                 ADD_TO_ARRAY(mem_ctx, const char *, NULL,
5009                              &array, &num_strings);
5010         }
5011
5012         if (presult != NULL) {
5013                 *presult = array;
5014         } else {
5015                 talloc_free(array);
5016         }
5017
5018         return WERR_OK;
5019 }
5020
5021 /********************************************************************
5022  * fill a spoolss_DriverInfo1 struct
5023  ********************************************************************/
5024
5025 static WERROR fill_printer_driver_info1(TALLOC_CTX *mem_ctx,
5026                                         struct spoolss_DriverInfo1 *r,
5027                                         const struct spoolss_DriverInfo8 *driver,
5028                                         const char *servername)
5029 {
5030         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
5031         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
5032
5033         return WERR_OK;
5034 }
5035
5036 /********************************************************************
5037  * fill a spoolss_DriverInfo2 struct
5038  ********************************************************************/
5039
5040 static WERROR fill_printer_driver_info2(TALLOC_CTX *mem_ctx,
5041                                         struct spoolss_DriverInfo2 *r,
5042                                         const struct spoolss_DriverInfo8 *driver,
5043                                         const char *servername)
5044
5045 {
5046         const char *cservername = canon_servername(servername);
5047
5048         r->version              = driver->version;
5049
5050         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
5051         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
5052         r->architecture         = talloc_strdup(mem_ctx, driver->architecture);
5053         W_ERROR_HAVE_NO_MEMORY(r->architecture);
5054
5055         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5056                                driver->architecture,
5057                                driver->version,
5058                                driver->driver_path,
5059                                r->driver_path);
5060
5061         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5062                                driver->architecture,
5063                                driver->version,
5064                                driver->data_file,
5065                                r->data_file);
5066
5067         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5068                                driver->architecture,
5069                                driver->version,
5070                                driver->config_file,
5071                                r->config_file);
5072
5073         return WERR_OK;
5074 }
5075
5076 /********************************************************************
5077  * fill a spoolss_DriverInfo3 struct
5078  ********************************************************************/
5079
5080 static WERROR fill_printer_driver_info3(TALLOC_CTX *mem_ctx,
5081                                         struct spoolss_DriverInfo3 *r,
5082                                         const struct spoolss_DriverInfo8 *driver,
5083                                         const char *servername)
5084 {
5085         const char *cservername = canon_servername(servername);
5086
5087         r->version              = driver->version;
5088
5089         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
5090         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
5091         r->architecture         = talloc_strdup(mem_ctx, driver->architecture);
5092         W_ERROR_HAVE_NO_MEMORY(r->architecture);
5093
5094         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5095                                driver->architecture,
5096                                driver->version,
5097                                driver->driver_path,
5098                                r->driver_path);
5099
5100         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5101                                driver->architecture,
5102                                driver->version,
5103                                driver->data_file,
5104                                r->data_file);
5105
5106         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5107                                driver->architecture,
5108                                driver->version,
5109                                driver->config_file,
5110                                r->config_file);
5111
5112         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5113                                driver->architecture,
5114                                driver->version,
5115                                driver->help_file,
5116                                r->help_file);
5117
5118         FILL_DRIVER_STRING(mem_ctx,
5119                            driver->monitor_name,
5120                            r->monitor_name);
5121
5122         FILL_DRIVER_STRING(mem_ctx,
5123                            driver->default_datatype,
5124                            r->default_datatype);
5125
5126         return string_array_from_driver_info(mem_ctx,
5127                                              driver->dependent_files,
5128                                              &r->dependent_files,
5129                                              cservername,
5130                                              driver->architecture,
5131                                              driver->version);
5132 }
5133
5134 /********************************************************************
5135  * fill a spoolss_DriverInfo4 struct
5136  ********************************************************************/
5137
5138 static WERROR fill_printer_driver_info4(TALLOC_CTX *mem_ctx,
5139                                         struct spoolss_DriverInfo4 *r,
5140                                         const struct spoolss_DriverInfo8 *driver,
5141                                         const char *servername)
5142 {
5143         const char *cservername = canon_servername(servername);
5144         WERROR result;
5145
5146         r->version              = driver->version;
5147
5148         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
5149         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
5150         r->architecture         = talloc_strdup(mem_ctx, driver->architecture);
5151         W_ERROR_HAVE_NO_MEMORY(r->architecture);
5152
5153         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5154                                driver->architecture,
5155                                driver->version,
5156                                driver->driver_path,
5157                                r->driver_path);
5158
5159         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5160                                driver->architecture,
5161                                driver->version,
5162                                driver->data_file,
5163                                r->data_file);
5164
5165         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5166                                driver->architecture,
5167                                driver->version,
5168                                driver->config_file,
5169                                r->config_file);
5170
5171         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5172                                driver->architecture,
5173                                driver->version,
5174                                driver->help_file,
5175                                r->help_file);
5176
5177         result = string_array_from_driver_info(mem_ctx,
5178                                                driver->dependent_files,
5179                                                &r->dependent_files,
5180                                                cservername,
5181                                                driver->architecture,
5182                                                driver->version);
5183         if (!W_ERROR_IS_OK(result)) {
5184                 return result;
5185         }
5186
5187         FILL_DRIVER_STRING(mem_ctx,
5188                            driver->monitor_name,
5189                            r->monitor_name);
5190
5191         FILL_DRIVER_STRING(mem_ctx,
5192                            driver->default_datatype,
5193                            r->default_datatype);
5194
5195
5196         result = string_array_from_driver_info(mem_ctx,
5197                                                driver->previous_names,
5198                                                &r->previous_names,
5199                                                NULL, NULL, 0);
5200
5201         return result;
5202 }
5203
5204 /********************************************************************
5205  * fill a spoolss_DriverInfo5 struct
5206  ********************************************************************/
5207
5208 static WERROR fill_printer_driver_info5(TALLOC_CTX *mem_ctx,
5209                                         struct spoolss_DriverInfo5 *r,
5210                                         const struct spoolss_DriverInfo8 *driver,
5211                                         const char *servername)
5212 {
5213         const char *cservername = canon_servername(servername);
5214
5215         r->version              = driver->version;
5216
5217         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
5218         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
5219         r->architecture         = talloc_strdup(mem_ctx, driver->architecture);
5220         W_ERROR_HAVE_NO_MEMORY(r->architecture);
5221
5222         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5223                                driver->architecture,
5224                                driver->version,
5225                                driver->driver_path,
5226                                r->driver_path);
5227
5228         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5229                                driver->architecture,
5230                                driver->version,
5231                                driver->data_file,
5232                                r->data_file);
5233
5234         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5235                                driver->architecture,
5236                                driver->version,
5237                                driver->config_file,
5238                                r->config_file);
5239
5240         r->driver_attributes    = 0;
5241         r->config_version       = 0;
5242         r->driver_version       = 0;
5243
5244         return WERR_OK;
5245 }
5246 /********************************************************************
5247  * fill a spoolss_DriverInfo6 struct
5248  ********************************************************************/
5249
5250 static WERROR fill_printer_driver_info6(TALLOC_CTX *mem_ctx,
5251                                         struct spoolss_DriverInfo6 *r,
5252                                         const struct spoolss_DriverInfo8 *driver,
5253                                         const char *servername)
5254 {
5255         const char *cservername = canon_servername(servername);
5256         WERROR result;
5257
5258         r->version              = driver->version;
5259
5260         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
5261         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
5262         r->architecture         = talloc_strdup(mem_ctx, driver->architecture);
5263         W_ERROR_HAVE_NO_MEMORY(r->architecture);
5264
5265         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5266                                driver->architecture,
5267                                driver->version,
5268                                driver->driver_path,
5269                                r->driver_path);
5270
5271         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5272                                driver->architecture,
5273                                driver->version,
5274                                driver->data_file,
5275                                r->data_file);
5276
5277         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5278                                driver->architecture,
5279                                driver->version,
5280                                driver->config_file,
5281                                r->config_file);
5282
5283         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5284                                driver->architecture,
5285                                driver->version,
5286                                driver->help_file,
5287                                r->help_file);
5288
5289         FILL_DRIVER_STRING(mem_ctx,
5290                            driver->monitor_name,
5291                            r->monitor_name);
5292
5293         FILL_DRIVER_STRING(mem_ctx,
5294                            driver->default_datatype,
5295                            r->default_datatype);
5296
5297         result = string_array_from_driver_info(mem_ctx,
5298                                                driver->dependent_files,
5299                                                &r->dependent_files,
5300                                                cservername,
5301                                                driver->architecture,
5302                                                driver->version);
5303         if (!W_ERROR_IS_OK(result)) {
5304                 return result;
5305         }
5306
5307         result = string_array_from_driver_info(mem_ctx,
5308                                                driver->previous_names,
5309                                                &r->previous_names,
5310                                                NULL, NULL, 0);
5311         if (!W_ERROR_IS_OK(result)) {
5312                 return result;
5313         }
5314
5315         r->driver_date          = driver->driver_date;
5316         r->driver_version       = driver->driver_version;
5317
5318         FILL_DRIVER_STRING(mem_ctx,
5319                            driver->manufacturer_name,
5320                            r->manufacturer_name);
5321         FILL_DRIVER_STRING(mem_ctx,
5322                            driver->manufacturer_url,
5323                            r->manufacturer_url);
5324         FILL_DRIVER_STRING(mem_ctx,
5325                            driver->hardware_id,
5326                            r->hardware_id);
5327         FILL_DRIVER_STRING(mem_ctx,
5328                            driver->provider,
5329                            r->provider);
5330
5331         return WERR_OK;
5332 }
5333
5334 /********************************************************************
5335  * fill a spoolss_DriverInfo8 struct
5336  ********************************************************************/
5337
5338 static WERROR fill_printer_driver_info8(TALLOC_CTX *mem_ctx,
5339                                         struct spoolss_DriverInfo8 *r,
5340                                         const struct spoolss_DriverInfo8 *driver,
5341                                         const char *servername)
5342 {
5343         const char *cservername = canon_servername(servername);
5344         WERROR result;
5345
5346         r->version              = driver->version;
5347
5348         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
5349         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
5350         r->architecture         = talloc_strdup(mem_ctx, driver->architecture);
5351         W_ERROR_HAVE_NO_MEMORY(r->architecture);
5352
5353         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5354                                driver->architecture,
5355                                driver->version,
5356                                driver->driver_path,
5357                                r->driver_path);
5358
5359         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5360                                driver->architecture,
5361                                driver->version,
5362                                driver->data_file,
5363                                r->data_file);
5364
5365         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5366                                driver->architecture,
5367                                driver->version,
5368                                driver->config_file,
5369                                r->config_file);
5370
5371         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5372                                driver->architecture,
5373                                driver->version,
5374                                driver->help_file,
5375                                r->help_file);
5376
5377         FILL_DRIVER_STRING(mem_ctx,
5378                            driver->monitor_name,
5379                            r->monitor_name);
5380
5381         FILL_DRIVER_STRING(mem_ctx,
5382                            driver->default_datatype,
5383                            r->default_datatype);
5384
5385         result = string_array_from_driver_info(mem_ctx,
5386                                                driver->dependent_files,
5387                                                &r->dependent_files,
5388                                                cservername,
5389                                                driver->architecture,
5390                                                driver->version);
5391         if (!W_ERROR_IS_OK(result)) {
5392                 return result;
5393         }
5394
5395         result = string_array_from_driver_info(mem_ctx,
5396                                                driver->previous_names,
5397                                                &r->previous_names,
5398                                                NULL, NULL, 0);
5399         if (!W_ERROR_IS_OK(result)) {
5400                 return result;
5401         }
5402
5403         r->driver_date          = driver->driver_date;
5404         r->driver_version       = driver->driver_version;
5405
5406         FILL_DRIVER_STRING(mem_ctx,
5407                            driver->manufacturer_name,
5408                            r->manufacturer_name);
5409         FILL_DRIVER_STRING(mem_ctx,
5410                            driver->manufacturer_url,
5411                            r->manufacturer_url);
5412         FILL_DRIVER_STRING(mem_ctx,
5413                            driver->hardware_id,
5414                            r->hardware_id);
5415         FILL_DRIVER_STRING(mem_ctx,
5416                            driver->provider,
5417                            r->provider);
5418
5419         FILL_DRIVER_STRING(mem_ctx,
5420                            driver->print_processor,
5421                            r->print_processor);
5422         FILL_DRIVER_STRING(mem_ctx,
5423                            driver->vendor_setup,
5424                            r->vendor_setup);
5425
5426         result = string_array_from_driver_info(mem_ctx,
5427                                                driver->color_profiles,
5428                                                &r->color_profiles,
5429                                                NULL, NULL, 0);
5430         if (!W_ERROR_IS_OK(result)) {
5431                 return result;
5432         }
5433
5434         FILL_DRIVER_STRING(mem_ctx,
5435                            driver->inf_path,
5436                            r->inf_path);
5437
5438         r->printer_driver_attributes    = driver->printer_driver_attributes;
5439
5440         result = string_array_from_driver_info(mem_ctx,
5441                                                driver->core_driver_dependencies,
5442                                                &r->core_driver_dependencies,
5443                                                NULL, NULL, 0);
5444         if (!W_ERROR_IS_OK(result)) {
5445                 return result;
5446         }
5447
5448         r->min_inbox_driver_ver_date    = driver->min_inbox_driver_ver_date;
5449         r->min_inbox_driver_ver_version = driver->min_inbox_driver_ver_version;
5450
5451         return WERR_OK;
5452 }
5453
5454 #if 0 /* disabled until marshalling issues are resolved - gd */
5455 /********************************************************************
5456  ********************************************************************/
5457
5458 static WERROR fill_spoolss_DriverFileInfo(TALLOC_CTX *mem_ctx,
5459                                           struct spoolss_DriverFileInfo *r,
5460                                           const char *cservername,
5461                                           const char *file_name,
5462                                           enum spoolss_DriverFileType file_type,
5463                                           uint32_t file_version)
5464 {
5465         r->file_name    = talloc_asprintf(mem_ctx, "\\\\%s%s",
5466                                           cservername, file_name);
5467         W_ERROR_HAVE_NO_MEMORY(r->file_name);
5468         r->file_type    = file_type;
5469         r->file_version = file_version;
5470
5471         return WERR_OK;
5472 }
5473
5474 /********************************************************************
5475  ********************************************************************/
5476
5477 static WERROR spoolss_DriverFileInfo_from_driver(TALLOC_CTX *mem_ctx,
5478                                                  const struct spoolss_DriverInfo8 *driver,
5479                                                  const char *cservername,
5480                                                  struct spoolss_DriverFileInfo **info_p,
5481                                                  uint32_t *count_p)
5482 {
5483         struct spoolss_DriverFileInfo *info = NULL;
5484         uint32_t count = 0;
5485         WERROR result;
5486         uint32_t i;
5487
5488         *info_p = NULL;
5489         *count_p = 0;
5490
5491         if (strlen(driver->driver_path)) {
5492                 info = talloc_realloc(mem_ctx, info,
5493                                             struct spoolss_DriverFileInfo,
5494                                             count + 1);
5495                 W_ERROR_HAVE_NO_MEMORY(info);
5496                 result = fill_spoolss_DriverFileInfo(info,
5497                                                      &info[count],
5498                                                      cservername,
5499                                                      driver->driver_path,
5500                                                      SPOOLSS_DRIVER_FILE_TYPE_RENDERING,
5501                                                      0);
5502                 W_ERROR_NOT_OK_RETURN(result);
5503                 count++;
5504         }
5505
5506         if (strlen(driver->config_file)) {
5507                 info = talloc_realloc(mem_ctx, info,
5508                                             struct spoolss_DriverFileInfo,
5509                                             count + 1);
5510                 W_ERROR_HAVE_NO_MEMORY(info);
5511                 result = fill_spoolss_DriverFileInfo(info,
5512                                                      &info[count],
5513                                                      cservername,
5514                                                      driver->config_file,
5515                                                      SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION,
5516                                                      0);
5517                 W_ERROR_NOT_OK_RETURN(result);
5518                 count++;
5519         }
5520
5521         if (strlen(driver->data_file)) {
5522                 info = talloc_realloc(mem_ctx, info,
5523                                             struct spoolss_DriverFileInfo,
5524                                             count + 1);
5525                 W_ERROR_HAVE_NO_MEMORY(info);
5526                 result = fill_spoolss_DriverFileInfo(info,
5527                                                      &info[count],
5528                                                      cservername,
5529                                                      driver->data_file,
5530                                                      SPOOLSS_DRIVER_FILE_TYPE_DATA,
5531                                                      0);
5532                 W_ERROR_NOT_OK_RETURN(result);
5533                 count++;
5534         }
5535
5536         if (strlen(driver->help_file)) {
5537                 info = talloc_realloc(mem_ctx, info,
5538                                             struct spoolss_DriverFileInfo,
5539                                             count + 1);
5540                 W_ERROR_HAVE_NO_MEMORY(info);
5541                 result = fill_spoolss_DriverFileInfo(info,
5542                                                      &info[count],
5543                                                      cservername,
5544                                                      driver->help_file,
5545                                                      SPOOLSS_DRIVER_FILE_TYPE_HELP,
5546                                                      0);
5547                 W_ERROR_NOT_OK_RETURN(result);
5548                 count++;
5549         }
5550
5551         for (i=0; driver->dependent_files[i] && driver->dependent_files[i][0] != '\0'; i++) {
5552                 info = talloc_realloc(mem_ctx, info,
5553                                             struct spoolss_DriverFileInfo,
5554                                             count + 1);
5555                 W_ERROR_HAVE_NO_MEMORY(info);
5556                 result = fill_spoolss_DriverFileInfo(info,
5557                                                      &info[count],
5558                                                      cservername,
5559                                                      driver->dependent_files[i],
5560                                                      SPOOLSS_DRIVER_FILE_TYPE_OTHER,
5561                                                      0);
5562                 W_ERROR_NOT_OK_RETURN(result);
5563                 count++;
5564         }
5565
5566         *info_p = info;
5567         *count_p = count;
5568
5569         return WERR_OK;
5570 }
5571
5572 /********************************************************************
5573  * fill a spoolss_DriverInfo101 struct
5574  ********************************************************************/
5575
5576 static WERROR fill_printer_driver_info101(TALLOC_CTX *mem_ctx,
5577                                           struct spoolss_DriverInfo101 *r,
5578                                           const struct spoolss_DriverInfo8 *driver,
5579                                           const char *servername)
5580 {
5581         const char *cservername = canon_servername(servername);
5582         WERROR result;
5583
5584         r->version              = driver->version;
5585
5586         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
5587         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
5588         r->architecture         = talloc_strdup(mem_ctx, driver->architecture);
5589         W_ERROR_HAVE_NO_MEMORY(r->architecture);
5590
5591         result = spoolss_DriverFileInfo_from_driver(mem_ctx, driver,
5592                                                     cservername,
5593                                                     &r->file_info,
5594                                                     &r->file_count);
5595         if (!W_ERROR_IS_OK(result)) {
5596                 return result;
5597         }
5598
5599         FILL_DRIVER_STRING(mem_ctx,
5600                            driver->monitor_name,
5601                            r->monitor_name);
5602
5603         FILL_DRIVER_STRING(mem_ctx,
5604                            driver->default_datatype,
5605                            r->default_datatype);
5606
5607         result = string_array_from_driver_info(mem_ctx,
5608                                                driver->previous_names,
5609                                                &r->previous_names,
5610                                                NULL, NULL, 0);
5611         if (!W_ERROR_IS_OK(result)) {
5612                 return result;
5613         }
5614
5615         r->driver_date          = driver->driver_date;
5616         r->driver_version       = driver->driver_version;
5617
5618         FILL_DRIVER_STRING(mem_ctx,
5619                            driver->manufacturer_name,
5620                            r->manufacturer_name);
5621         FILL_DRIVER_STRING(mem_ctx,
5622                            driver->manufacturer_url,
5623                            r->manufacturer_url);
5624         FILL_DRIVER_STRING(mem_ctx,
5625                            driver->hardware_id,
5626                            r->hardware_id);
5627         FILL_DRIVER_STRING(mem_ctx,
5628                            driver->provider,
5629                            r->provider);
5630
5631         return WERR_OK;
5632 }
5633 #endif
5634 /********************************************************************
5635  ********************************************************************/
5636
5637 static WERROR construct_printer_driver_info_level(TALLOC_CTX *mem_ctx,
5638                                                   const struct auth_session_info *session_info,
5639                                                   struct messaging_context *msg_ctx,
5640                                                   uint32_t level,
5641                                                   union spoolss_DriverInfo *r,
5642                                                   int snum,
5643                                                   const char *servername,
5644                                                   const char *architecture,
5645                                                   uint32_t version)
5646 {
5647         struct spoolss_PrinterInfo2 *pinfo2 = NULL;
5648         struct spoolss_DriverInfo8 *driver;
5649         WERROR result;
5650         struct dcerpc_binding_handle *b;
5651         TALLOC_CTX *tmp_ctx = NULL;
5652
5653         if (level == 101) {
5654                 return WERR_INVALID_LEVEL;
5655         }
5656
5657         tmp_ctx = talloc_new(mem_ctx);
5658         if (!tmp_ctx) {
5659                 return WERR_NOT_ENOUGH_MEMORY;
5660         }
5661
5662         result = winreg_printer_binding_handle(tmp_ctx,
5663                                                session_info,
5664                                                msg_ctx,
5665                                                &b);
5666         if (!W_ERROR_IS_OK(result)) {
5667                 goto done;
5668         }
5669
5670         result = winreg_get_printer(tmp_ctx, b,
5671                                     lp_const_servicename(snum),
5672                                     &pinfo2);
5673         if (!W_ERROR_IS_OK(result)) {
5674                 DBG_ERR("Failed to get printer info2 for [%s]: %s\n",
5675                         lp_const_servicename(snum), win_errstr(result));
5676                 result = WERR_INVALID_PRINTER_NAME;
5677                 goto done;
5678         }
5679
5680         if (pinfo2->drivername == NULL || pinfo2->drivername[0] == '\0') {
5681                 return WERR_UNKNOWN_PRINTER_DRIVER;
5682         }
5683
5684         DBG_INFO("Construct printer driver [%s] for [%s]\n",
5685                  pinfo2->drivername,
5686                  pinfo2->sharename);
5687
5688         result = winreg_get_driver(tmp_ctx, b,
5689                                    architecture,
5690                                    pinfo2->drivername, version, &driver);
5691
5692         DBG_INFO("winreg_get_driver() status: %s\n",
5693                  win_errstr(result));
5694
5695         if (!W_ERROR_IS_OK(result)) {
5696                 /*
5697                  * Is this a W2k client ?
5698                  */
5699
5700                 if (version < 3) {
5701                         result = WERR_UNKNOWN_PRINTER_DRIVER;
5702                         goto done;
5703                 }
5704
5705                 /* Yes - try again with a WinNT driver. */
5706                 version = 2;
5707                 result = winreg_get_driver(tmp_ctx, b,
5708                                            architecture,
5709                                            pinfo2->drivername,
5710                                            version, &driver);
5711                 DEBUG(8,("construct_printer_driver_level: status: %s\n",
5712                         win_errstr(result)));
5713                 if (!W_ERROR_IS_OK(result)) {
5714                         result = WERR_UNKNOWN_PRINTER_DRIVER;
5715                         goto done;
5716                 }
5717         }
5718
5719         /* these are allocated on mem_ctx and not tmp_ctx because they are
5720          * the 'return value' and need to utlive this call */
5721         switch (level) {
5722         case 1:
5723                 result = fill_printer_driver_info1(mem_ctx, &r->info1, driver, servername);
5724                 break;
5725         case 2:
5726                 result = fill_printer_driver_info2(mem_ctx, &r->info2, driver, servername);
5727                 break;
5728         case 3:
5729                 result = fill_printer_driver_info3(mem_ctx, &r->info3, driver, servername);
5730                 break;
5731         case 4:
5732                 result = fill_printer_driver_info4(mem_ctx, &r->info4, driver, servername);
5733                 break;
5734         case 5:
5735                 result = fill_printer_driver_info5(mem_ctx, &r->info5, driver, servername);
5736                 break;
5737         case 6:
5738                 result = fill_printer_driver_info6(mem_ctx, &r->info6, driver, servername);
5739                 break;
5740         case 8:
5741                 result = fill_printer_driver_info8(mem_ctx, &r->info8, driver, servername);
5742                 break;
5743 #if 0 /* disabled until marshalling issues are resolved - gd */
5744         case 101:
5745                 result = fill_printer_driver_info101(mem_ctx, &r->info101, driver, servername);
5746                 break;
5747 #endif
5748         default:
5749                 result = WERR_INVALID_LEVEL;
5750                 break;
5751         }
5752
5753 done:
5754         talloc_free(tmp_ctx);
5755         return result;
5756 }
5757
5758 /****************************************************************
5759  _spoolss_GetPrinterDriver2
5760 ****************************************************************/
5761
5762 WERROR _spoolss_GetPrinterDriver2(struct pipes_struct *p,
5763                                   struct spoolss_GetPrinterDriver2 *r)
5764 {
5765         struct printer_handle *printer;
5766         WERROR result;
5767         uint32_t version = r->in.client_major_version;
5768
5769         int snum;
5770
5771         /* that's an [in out] buffer */
5772
5773         if (!r->in.buffer && (r->in.offered != 0)) {
5774                 result = WERR_INVALID_PARAMETER;
5775                 goto err_info_free;
5776         }
5777
5778         DEBUG(4,("_spoolss_GetPrinterDriver2\n"));
5779
5780         if (!(printer = find_printer_index_by_hnd(p, r->in.handle))) {
5781                 DEBUG(0,("_spoolss_GetPrinterDriver2: invalid printer handle!\n"));
5782                 result = WERR_INVALID_PRINTER_NAME;
5783                 goto err_info_free;
5784         }
5785
5786         *r->out.needed = 0;
5787         *r->out.server_major_version = 0;
5788         *r->out.server_minor_version = 0;
5789
5790         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5791                 result = WERR_INVALID_HANDLE;
5792                 goto err_info_free;
5793         }
5794
5795         if (r->in.client_major_version == SPOOLSS_DRIVER_VERSION_2012) {
5796                 DEBUG(3,("_spoolss_GetPrinterDriver2: v4 driver requested, "
5797                         "downgrading to v3\n"));
5798                 version = SPOOLSS_DRIVER_VERSION_200X;
5799         }
5800
5801         result = construct_printer_driver_info_level(p->mem_ctx,
5802                                                      get_session_info_system(),
5803                                                      p->msg_ctx,
5804                                                      r->in.level, r->out.info,
5805                                                      snum, printer->servername,
5806                                                      r->in.architecture,
5807                                                      version);
5808         if (!W_ERROR_IS_OK(result)) {
5809                 goto err_info_free;
5810         }
5811
5812         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_DriverInfo,
5813                                                r->out.info, r->in.level);
5814         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
5815
5816         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
5817
5818 err_info_free:
5819         TALLOC_FREE(r->out.info);
5820         return result;
5821 }
5822
5823
5824 /****************************************************************
5825  _spoolss_StartPagePrinter
5826 ****************************************************************/
5827
5828 WERROR _spoolss_StartPagePrinter(struct pipes_struct *p,
5829                                  struct spoolss_StartPagePrinter *r)
5830 {
5831         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
5832
5833         if (!Printer) {
5834                 DEBUG(3,("_spoolss_StartPagePrinter: "
5835                         "Error in startpageprinter printer handle\n"));
5836                 return WERR_INVALID_HANDLE;
5837         }
5838
5839         Printer->page_started = true;
5840         return WERR_OK;
5841 }
5842
5843 /****************************************************************
5844  _spoolss_EndPagePrinter
5845 ****************************************************************/
5846
5847 WERROR _spoolss_EndPagePrinter(struct pipes_struct *p,
5848                                struct spoolss_EndPagePrinter *r)
5849 {
5850         int snum;
5851
5852         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
5853
5854         if (!Printer) {
5855                 DEBUG(2,("_spoolss_EndPagePrinter: Invalid handle (%s:%u:%u).\n",
5856                         OUR_HANDLE(r->in.handle)));
5857                 return WERR_INVALID_HANDLE;
5858         }
5859
5860         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5861                 return WERR_INVALID_HANDLE;
5862
5863         Printer->page_started = false;
5864         print_job_endpage(p->msg_ctx, snum, Printer->jobid);
5865
5866         return WERR_OK;
5867 }
5868
5869 /****************************************************************
5870  _spoolss_StartDocPrinter
5871 ****************************************************************/
5872
5873 WERROR _spoolss_StartDocPrinter(struct pipes_struct *p,
5874                                 struct spoolss_StartDocPrinter *r)
5875 {
5876         struct spoolss_DocumentInfo1 *info_1;
5877         int snum;
5878         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
5879         WERROR werr;
5880         char *rhost;
5881         int rc;
5882
5883         if (!Printer) {
5884                 DEBUG(2,("_spoolss_StartDocPrinter: "
5885                         "Invalid handle (%s:%u:%u)\n",
5886                         OUR_HANDLE(r->in.handle)));
5887                 return WERR_INVALID_HANDLE;
5888         }
5889
5890         if (Printer->jobid) {
5891                 DEBUG(2, ("_spoolss_StartDocPrinter: "
5892                           "StartDocPrinter called twice! "
5893                           "(existing jobid = %d)\n", Printer->jobid));
5894                 return WERR_INVALID_HANDLE;
5895         }
5896
5897         if (r->in.info_ctr->level != 1) {
5898                 return WERR_INVALID_LEVEL;
5899         }
5900
5901         info_1 = r->in.info_ctr->info.info1;
5902
5903         /*
5904          * a nice thing with NT is it doesn't listen to what you tell it.
5905          * when asked to send _only_ RAW datas, it tries to send datas
5906          * in EMF format.
5907          *
5908          * So I add checks like in NT Server ...
5909          */
5910
5911         if (info_1->datatype) {
5912                 /*
5913                  * The v4 driver model used in Windows 8 declares print jobs
5914                  * intended to bypass the XPS processing layer by setting
5915                  * datatype to "XPS_PASS" instead of "RAW".
5916                  */
5917                 if ((strcmp(info_1->datatype, "RAW") != 0)
5918                  && (strcmp(info_1->datatype, "XPS_PASS") != 0)) {
5919                         *r->out.job_id = 0;
5920                         return WERR_INVALID_DATATYPE;
5921                 }
5922         }
5923
5924         /* get the share number of the printer */
5925         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5926                 return WERR_INVALID_HANDLE;
5927         }
5928
5929         rc = get_remote_hostname(p->remote_address,
5930                                  &rhost,
5931                                  p->mem_ctx);
5932         if (rc < 0) {
5933                 return WERR_NOT_ENOUGH_MEMORY;
5934         }
5935         if (strequal(rhost,"UNKNOWN")) {
5936                 rhost = tsocket_address_inet_addr_string(p->remote_address,
5937                                                          p->mem_ctx);
5938                 if (rhost == NULL) {
5939                         return WERR_NOT_ENOUGH_MEMORY;
5940                 }
5941         }
5942
5943         werr = print_job_start(p->session_info,
5944                                p->msg_ctx,
5945                                rhost,
5946                                snum,
5947                                info_1->document_name,
5948                                info_1->output_file,
5949                                Printer->devmode,
5950                                &Printer->jobid);
5951
5952         /* An error occured in print_job_start() so return an appropriate
5953            NT error code. */
5954
5955         if (!W_ERROR_IS_OK(werr)) {
5956                 return werr;
5957         }
5958
5959         Printer->document_started = true;
5960         *r->out.job_id = Printer->jobid;
5961
5962         return WERR_OK;
5963 }
5964
5965 /****************************************************************
5966  _spoolss_EndDocPrinter
5967 ****************************************************************/
5968
5969 WERROR _spoolss_EndDocPrinter(struct pipes_struct *p,
5970                               struct spoolss_EndDocPrinter *r)
5971 {
5972         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
5973         NTSTATUS status;
5974         int snum;
5975
5976         if (!Printer) {
5977                 DEBUG(2,("_spoolss_EndDocPrinter: Invalid handle (%s:%u:%u)\n",
5978                         OUR_HANDLE(r->in.handle)));
5979                 return WERR_INVALID_HANDLE;
5980         }
5981
5982         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5983                 return WERR_INVALID_HANDLE;
5984         }
5985
5986         Printer->document_started = false;
5987         status = print_job_end(p->msg_ctx, snum, Printer->jobid, NORMAL_CLOSE);
5988         if (!NT_STATUS_IS_OK(status)) {
5989                 DEBUG(2, ("_spoolss_EndDocPrinter: "
5990                           "print_job_end failed [%s]\n",
5991                           nt_errstr(status)));
5992         }
5993
5994         Printer->jobid = 0;
5995         return ntstatus_to_werror(status);
5996 }
5997
5998 /****************************************************************
5999  _spoolss_WritePrinter
6000 ****************************************************************/
6001
6002 WERROR _spoolss_WritePrinter(struct pipes_struct *p,
6003                              struct spoolss_WritePrinter *r)
6004 {
6005         ssize_t buffer_written;
6006         int snum;
6007         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
6008
6009         if (!Printer) {
6010                 DEBUG(2,("_spoolss_WritePrinter: Invalid handle (%s:%u:%u)\n",
6011                         OUR_HANDLE(r->in.handle)));
6012                 *r->out.num_written = r->in._data_size;
6013                 return WERR_INVALID_HANDLE;
6014         }
6015
6016         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
6017                 return WERR_INVALID_HANDLE;
6018
6019         /* print_job_write takes care of checking for PJOB_SMBD_SPOOLING */
6020         buffer_written = print_job_write(server_event_context(),p->msg_ctx,
6021                                                    snum, Printer->jobid,
6022                                                    (const char *)r->in.data.data,
6023                                                    (size_t)r->in._data_size);
6024         if (buffer_written == (ssize_t)-1) {
6025                 *r->out.num_written = 0;
6026                 if (errno == ENOSPC)
6027                         return WERR_NO_SPOOL_SPACE;
6028                 else
6029                         return WERR_ACCESS_DENIED;
6030         }
6031
6032         *r->out.num_written = r->in._data_size;
6033
6034         return WERR_OK;
6035 }
6036
6037 /********************************************************************
6038  * api_spoolss_getprinter
6039  * called from the spoolss dispatcher
6040  *
6041  ********************************************************************/
6042
6043 static WERROR control_printer(struct policy_handle *handle, uint32_t command,
6044                               struct pipes_struct *p)
6045 {
6046         const struct auth_session_info *session_info = p->session_info;
6047         int snum;
6048         WERROR errcode = WERR_INVALID_FUNCTION;
6049         struct printer_handle *Printer = find_printer_index_by_hnd(p, handle);
6050
6051         if (!Printer) {
6052                 DEBUG(2,("control_printer: Invalid handle (%s:%u:%u)\n",
6053                         OUR_HANDLE(handle)));
6054                 return WERR_INVALID_HANDLE;
6055         }
6056
6057         if (!get_printer_snum(p, handle, &snum, NULL))
6058                 return WERR_INVALID_HANDLE;
6059
6060         switch (command) {
6061         case SPOOLSS_PRINTER_CONTROL_PAUSE:
6062                 errcode = print_queue_pause(session_info, p->msg_ctx, snum);
6063                 break;
6064         case SPOOLSS_PRINTER_CONTROL_RESUME:
6065         case SPOOLSS_PRINTER_CONTROL_UNPAUSE:
6066                 errcode = print_queue_resume(session_info, p->msg_ctx, snum);
6067                 break;
6068         case SPOOLSS_PRINTER_CONTROL_PURGE:
6069                 errcode = print_queue_purge(session_info, p->msg_ctx, snum);
6070                 break;
6071         default:
6072                 return WERR_INVALID_LEVEL;
6073         }
6074
6075         return errcode;
6076 }
6077
6078
6079 /****************************************************************
6080  _spoolss_AbortPrinter
6081  * From MSDN: "Deletes printer's spool file if printer is configured
6082  * for spooling"
6083 ****************************************************************/
6084
6085 WERROR _spoolss_AbortPrinter(struct pipes_struct *p,
6086                              struct spoolss_AbortPrinter *r)
6087 {
6088         struct printer_handle   *Printer = find_printer_index_by_hnd(p, r->in.handle);
6089         int             snum;
6090         WERROR          errcode = WERR_OK;
6091
6092         if (!Printer) {
6093                 DEBUG(2,("_spoolss_AbortPrinter: Invalid handle (%s:%u:%u)\n",
6094                         OUR_HANDLE(r->in.handle)));
6095                 return WERR_INVALID_HANDLE;
6096         }
6097
6098         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
6099                 return WERR_INVALID_HANDLE;
6100
6101         if (!Printer->document_started) {
6102                 return WERR_SPL_NO_STARTDOC;
6103         }
6104
6105         errcode = print_job_delete(p->session_info,
6106                                    p->msg_ctx,
6107                                    snum,
6108                                    Printer->jobid);
6109
6110         return errcode;
6111 }
6112
6113 /********************************************************************
6114  * called by spoolss_api_setprinter
6115  * when updating a printer description
6116  ********************************************************************/
6117
6118 static WERROR update_printer_sec(struct policy_handle *handle,
6119                                  struct pipes_struct *p,
6120                                  struct sec_desc_buf *secdesc_ctr)
6121 {
6122         struct spoolss_security_descriptor *new_secdesc = NULL;
6123         struct spoolss_security_descriptor *old_secdesc = NULL;
6124         const char *printer = NULL;
6125         WERROR result;
6126         int snum = -1;
6127         struct printer_handle *Printer = find_printer_index_by_hnd(p, handle);
6128         struct dcerpc_binding_handle *b;
6129         TALLOC_CTX *tmp_ctx = NULL;
6130         bool ok = false;
6131
6132         if (!Printer) {
6133                 DEBUG(2,("update_printer_sec: Invalid handle (%s:%u:%u)\n",
6134                          OUR_HANDLE(handle)));
6135
6136                 result = WERR_INVALID_HANDLE;
6137                 goto done;
6138         }
6139
6140         if (secdesc_ctr == NULL) {
6141                 DEBUG(10,("update_printer_sec: secdesc_ctr is NULL !\n"));
6142                 result = WERR_INVALID_PARAMETER;
6143                 goto done;
6144         }
6145
6146         switch (Printer->printer_type) {
6147         case SPLHND_SERVER:
6148                 break;
6149         case SPLHND_PRINTER:
6150                 if (!get_printer_snum(p, handle, &snum, NULL)) {
6151                         DEBUG(2,("update_printer_sec: Invalid handle (%s:%u:%u)\n",
6152                                  OUR_HANDLE(handle)));
6153                         result = WERR_INVALID_HANDLE;
6154                         goto done;
6155                 }
6156                 printer = lp_const_servicename(snum);
6157                 break;
6158         default:
6159                 break;
6160         }
6161
6162         /* Check the user has permissions to change the security
6163            descriptor.  By experimentation with two NT machines, the user
6164            requires Full Access to the printer to change security
6165            information. */
6166
6167         switch (Printer->printer_type) {
6168         case SPLHND_SERVER:
6169                 ok = Printer->access_granted == SERVER_ACCESS_ADMINISTER;
6170                 break;
6171         case SPLHND_PRINTER:
6172                 ok = Printer->access_granted == PRINTER_ACCESS_ADMINISTER;
6173                 break;
6174         default:
6175                 break;
6176         }
6177
6178         if (!ok) {
6179                 DEBUG(4,("update_printer_sec: updated denied by printer permissions "
6180                         "(access_granted: 0x%08x)\n", Printer->access_granted));
6181                 result = WERR_ACCESS_DENIED;
6182                 goto done;
6183         }
6184
6185         tmp_ctx = talloc_new(p->mem_ctx);
6186         if (!tmp_ctx) {
6187                 return WERR_NOT_ENOUGH_MEMORY;
6188         }
6189
6190         result = winreg_printer_binding_handle(tmp_ctx,
6191                                                get_session_info_system(),
6192                                                p->msg_ctx,
6193                                                &b);
6194         if (!W_ERROR_IS_OK(result)) {
6195                 goto done;
6196         }
6197
6198         /* NT seems to like setting the security descriptor even though
6199            nothing may have actually changed. */
6200
6201         if (printer != NULL) {
6202                 result = winreg_get_printer_secdesc(tmp_ctx, b,
6203                                                     printer,
6204                                                     &old_secdesc);
6205         } else {
6206                 result = winreg_get_printserver_secdesc(tmp_ctx, b,
6207                                                         &old_secdesc);
6208         }
6209         if (!W_ERROR_IS_OK(result)) {
6210                 DEBUG(2,("update_printer_sec: winreg_get_printer_secdesc_internal() failed\n"));
6211                 result = WERR_INVALID_HANDLE;
6212                 goto done;
6213         }
6214
6215         if (DEBUGLEVEL >= 10) {
6216                 struct security_acl *the_acl;
6217                 int i;
6218
6219                 the_acl = old_secdesc->dacl;
6220                 DEBUG(10, ("old_secdesc_ctr for %s has %d aces:\n",
6221                            printer, the_acl->num_aces));
6222
6223                 for (i = 0; i < the_acl->num_aces; i++) {
6224                         DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
6225                                            &the_acl->aces[i].trustee),
6226                                   the_acl->aces[i].access_mask));
6227                 }
6228
6229                 the_acl = secdesc_ctr->sd->dacl;
6230
6231                 if (the_acl) {
6232                         DEBUG(10, ("secdesc_ctr for %s has %d aces:\n",
6233                                    printer, the_acl->num_aces));
6234
6235                         for (i = 0; i < the_acl->num_aces; i++) {
6236                                 DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
6237                                                    &the_acl->aces[i].trustee),
6238                                            the_acl->aces[i].access_mask));
6239                         }
6240                 } else {
6241                         DEBUG(10, ("dacl for secdesc_ctr is NULL\n"));
6242                 }
6243         }
6244
6245         new_secdesc = sec_desc_merge(tmp_ctx, secdesc_ctr->sd, old_secdesc);
6246         if (new_secdesc == NULL) {
6247                 result = WERR_NOT_ENOUGH_MEMORY;
6248                 goto done;
6249         }
6250
6251         if (security_descriptor_equal(new_secdesc, old_secdesc)) {
6252                 result = WERR_OK;
6253                 goto done;
6254         }
6255
6256         if (printer != NULL) {
6257                 result = winreg_set_printer_secdesc(tmp_ctx, b,
6258                                                     printer,
6259                                                     new_secdesc);
6260         } else {
6261                 result = winreg_set_printserver_secdesc(tmp_ctx, b,
6262                                                         new_secdesc);
6263         }
6264
6265 done:
6266         talloc_free(tmp_ctx);
6267         return result;
6268 }
6269
6270 /********************************************************************
6271  Canonicalize printer info from a client
6272  ********************************************************************/
6273
6274 static bool check_printer_ok(TALLOC_CTX *mem_ctx,
6275                              struct spoolss_SetPrinterInfo2 *info2,
6276                              int snum)
6277 {
6278         fstring printername;
6279         const char *p;
6280
6281         DEBUG(5,("check_printer_ok: servername=%s printername=%s sharename=%s "
6282                 "portname=%s drivername=%s comment=%s location=%s\n",
6283                 info2->servername, info2->printername, info2->sharename,
6284                 info2->portname, info2->drivername, info2->comment,
6285                 info2->location));
6286
6287         /* we force some elements to "correct" values */
6288         info2->servername = talloc_asprintf(mem_ctx, "\\\\%s", lp_netbios_name());
6289         if (info2->servername == NULL) {
6290                 return false;
6291         }
6292         info2->sharename = talloc_strdup(mem_ctx, lp_const_servicename(snum));
6293         if (info2->sharename == NULL) {
6294                 return false;
6295         }
6296
6297         /* check to see if we allow printername != sharename */
6298         if (lp_force_printername(snum)) {
6299                 info2->printername = talloc_asprintf(mem_ctx, "\\\\%s\\%s",
6300                                         lp_netbios_name(), info2->sharename);
6301         } else {
6302                 /* make sure printername is in \\server\printername format */
6303                 fstrcpy(printername, info2->printername);
6304                 p = printername;
6305                 if ( printername[0] == '\\' && printername[1] == '\\' ) {
6306                         if ( (p = strchr_m( &printername[2], '\\' )) != NULL )
6307                                 p++;
6308                 }
6309
6310                 info2->printername = talloc_asprintf(mem_ctx, "\\\\%s\\%s",
6311                                         lp_netbios_name(), p);
6312         }
6313         if (info2->printername == NULL) {
6314                 return false;
6315         }
6316
6317         info2->attributes |= PRINTER_ATTRIBUTE_SAMBA;
6318         info2->attributes &= ~PRINTER_ATTRIBUTE_NOT_SAMBA;
6319
6320         return true;
6321 }
6322
6323 /****************************************************************************
6324 ****************************************************************************/
6325
6326 static WERROR add_port_hook(TALLOC_CTX *ctx, struct security_token *token, const char *portname, const char *uri)
6327 {
6328         char *cmd = lp_addport_command(talloc_tos());
6329         char *command = NULL;
6330         int ret;
6331         bool is_print_op = false;
6332
6333         if ( !*cmd ) {
6334                 return WERR_ACCESS_DENIED;
6335         }
6336
6337         command = talloc_asprintf(ctx,
6338                         "%s \"%s\" \"%s\"", cmd, portname, uri );
6339         if (!command) {
6340                 return WERR_NOT_ENOUGH_MEMORY;
6341         }
6342
6343         if ( token )
6344                 is_print_op = security_token_has_privilege(token, SEC_PRIV_PRINT_OPERATOR);
6345
6346         DEBUG(10,("Running [%s]\n", command));
6347
6348         /********* BEGIN SePrintOperatorPrivilege **********/
6349
6350         if ( is_print_op )
6351                 become_root();
6352
6353         ret = smbrun(command, NULL, NULL);
6354
6355         if ( is_print_op )
6356                 unbecome_root();
6357
6358         /********* END SePrintOperatorPrivilege **********/
6359
6360         DEBUGADD(10,("returned [%d]\n", ret));
6361
6362         TALLOC_FREE(command);
6363
6364         if ( ret != 0 ) {
6365                 return WERR_ACCESS_DENIED;
6366         }
6367
6368         return WERR_OK;
6369 }
6370
6371 /****************************************************************************
6372 ****************************************************************************/
6373
6374 static bool spoolss_conn_snum_used(struct smbd_server_connection *sconn,
6375                                    int snum)
6376 {
6377         /*
6378          * As we do not know if we are embedded in the file server process
6379          * or not, we have to pretend that all shares are in use.
6380          */
6381         return true;
6382 }
6383
6384 static bool add_printer_hook(TALLOC_CTX *ctx, struct security_token *token,
6385                              struct spoolss_SetPrinterInfo2 *info2,
6386                              const char *remote_machine,
6387                              struct messaging_context *msg_ctx)
6388 {
6389         char *cmd = lp_addprinter_command(talloc_tos());
6390         char **qlines;
6391         char *command = NULL;
6392         int numlines;
6393         int ret;
6394         int fd;
6395         bool is_print_op = false;
6396
6397         if (!remote_machine) {
6398                 return false;
6399         }
6400
6401         command = talloc_asprintf(ctx,
6402                         "%s \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"",
6403                         cmd, info2->printername, info2->sharename,
6404                         info2->portname, info2->drivername,
6405                         info2->location, info2->comment, remote_machine);
6406         if (!command) {
6407                 return false;
6408         }
6409
6410         if ( token )
6411                 is_print_op = security_token_has_privilege(token, SEC_PRIV_PRINT_OPERATOR);
6412
6413         DEBUG(10,("Running [%s]\n", command));
6414
6415         /********* BEGIN SePrintOperatorPrivilege **********/
6416
6417         if ( is_print_op )
6418                 become_root();
6419
6420         ret = smbrun(command, &fd, NULL);
6421         if (ret == 0) {
6422                 /* Tell everyone we updated smb.conf. */
6423                 message_send_all(msg_ctx, MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
6424         }
6425
6426         if ( is_print_op )
6427                 unbecome_root();
6428
6429         /********* END SePrintOperatorPrivilege **********/
6430
6431         DEBUGADD(10,("returned [%d]\n", ret));
6432
6433         TALLOC_FREE(command);
6434
6435         if ( ret != 0 ) {
6436                 if (fd != -1)
6437                         close(fd);
6438                 return false;
6439         }
6440
6441         /* reload our services immediately */
6442         become_root();
6443         reload_services(NULL, spoolss_conn_snum_used, false);
6444         unbecome_root();
6445
6446         numlines = 0;
6447         /* Get lines and convert them back to dos-codepage */
6448         qlines = fd_lines_load(fd, &numlines, 0, NULL);
6449         DEBUGADD(10,("Lines returned = [%d]\n", numlines));
6450         close(fd);
6451
6452         /* Set the portname to what the script says the portname should be. */
6453         /* but don't require anything to be return from the script exit a good error code */
6454
6455         if (numlines) {
6456                 /* Set the portname to what the script says the portname should be. */
6457                 info2->portname = talloc_strdup(ctx, qlines[0]);
6458                 DEBUGADD(6,("Line[0] = [%s]\n", qlines[0]));
6459         }
6460
6461         TALLOC_FREE(qlines);
6462         return true;
6463 }
6464
6465 static WERROR update_dsspooler(TALLOC_CTX *mem_ctx,
6466                                const struct auth_session_info *session_info,
6467                                struct messaging_context *msg_ctx,
6468                                int snum,
6469                                struct spoolss_SetPrinterInfo2 *printer,
6470                                struct spoolss_PrinterInfo2 *old_printer)
6471 {
6472         bool force_update = (old_printer == NULL);
6473         const char *dnsdomname;
6474         const char *longname;
6475         const char *uncname;
6476         const char *spooling;
6477         DATA_BLOB buffer;
6478         WERROR result = WERR_OK;
6479         struct dcerpc_binding_handle *b;
6480         TALLOC_CTX *tmp_ctx;
6481         bool ok;
6482
6483         tmp_ctx = talloc_new(mem_ctx);
6484         if (!tmp_ctx) {
6485                 return WERR_NOT_ENOUGH_MEMORY;
6486         }
6487
6488         result = winreg_printer_binding_handle(tmp_ctx,
6489                                                session_info,
6490                                                msg_ctx,
6491                                                &b);
6492         if (!W_ERROR_IS_OK(result)) {
6493                 goto done;
6494         }
6495
6496         if (printer->drivername != NULL &&
6497             (force_update ||
6498              !strequal(printer->drivername, old_printer->drivername))) {
6499                 ok = push_reg_sz(tmp_ctx, &buffer, printer->drivername);
6500                 if (!ok) {
6501                         DEBUG(0, ("%s data corrupted\n", SPOOL_REG_DRIVERNAME));
6502                         result = WERR_INVALID_DATA;
6503                         goto done;
6504                 }
6505                 result = winreg_set_printer_dataex(tmp_ctx, b,
6506                                           printer->sharename,
6507                                           SPOOL_DSSPOOLER_KEY,
6508                                           SPOOL_REG_DRIVERNAME,
6509                                           REG_SZ,
6510                                           buffer.data,
6511                                           buffer.length);
6512                 if (!W_ERROR_IS_OK(result)) {
6513                         DEBUG(0, ("Failed to set %s\n", SPOOL_REG_DRIVERNAME));
6514                         goto done;
6515                 }
6516
6517                 if (!force_update) {
6518                         DEBUG(10,("update_printer: changing driver [%s]!  Sending event!\n",
6519                                 printer->drivername));
6520
6521                         notify_printer_driver(server_event_context(), msg_ctx,
6522                                               snum, printer->drivername ?
6523                                               printer->drivername : "");
6524                 }
6525         }
6526
6527         if (printer->comment != NULL &&
6528             (force_update ||
6529              !strequal(printer->comment, old_printer->comment))) {
6530                 ok = push_reg_sz(tmp_ctx, &buffer, printer->comment);
6531                 if (!ok) {
6532                         DEBUG(0, ("comment data corrupted\n"));
6533                         result = WERR_INVALID_DATA;
6534                         goto done;
6535                 }
6536                 result = winreg_set_printer_dataex(tmp_ctx, b,
6537                                           printer->sharename,
6538                                           SPOOL_DSSPOOLER_KEY,
6539                                           SPOOL_REG_DESCRIPTION,
6540                                           REG_SZ,
6541                                           buffer.data,
6542                                           buffer.length);
6543                 if (!W_ERROR_IS_OK(result)) {
6544                         DEBUG(0, ("Failed to set %s\n", SPOOL_REG_DESCRIPTION));
6545                         goto done;
6546                 }
6547
6548                 if (!force_update) {
6549                         notify_printer_comment(server_event_context(), msg_ctx,
6550                                                snum, printer->comment ?
6551                                                printer->comment : "");
6552                 }
6553         }
6554
6555         if (printer->sharename != NULL &&
6556             (force_update ||
6557              !strequal(printer->sharename, old_printer->sharename))) {
6558                 ok = push_reg_sz(tmp_ctx, &buffer, printer->sharename);
6559                 if (!ok) {
6560                         DEBUG(0, ("sharename data corrupted\n"));
6561                         result = WERR_INVALID_DATA;
6562                         goto done;
6563                 }
6564                 result = winreg_set_printer_dataex(tmp_ctx, b,
6565                                           printer->sharename,
6566                                           SPOOL_DSSPOOLER_KEY,
6567                                           SPOOL_REG_PRINTSHARENAME,
6568                                           REG_SZ,
6569                                           buffer.data,
6570                                           buffer.length);
6571                 if (!W_ERROR_IS_OK(result)) {
6572                         DEBUG(0, ("Failed to set %s\n", SPOOL_REG_PRINTSHARENAME));
6573                         goto done;
6574                 }
6575
6576                 if (!force_update) {
6577                         notify_printer_sharename(server_event_context(),
6578                                                  msg_ctx,
6579                                                  snum, printer->sharename ?
6580                                                  printer->sharename : "");
6581                 }
6582
6583                 /* name change, purge any cache entries for the old */
6584                 prune_printername_cache();
6585         }
6586
6587         if (printer->printername != NULL &&
6588             (force_update ||
6589              !strequal(printer->printername, old_printer->printername))) {
6590                 const char *p;
6591
6592                 p = strrchr(printer->printername, '\\' );
6593                 if (p != NULL) {
6594                         p++;
6595                 } else {
6596                         p = printer->printername;
6597                 }
6598
6599                 ok = push_reg_sz(tmp_ctx, &buffer, p);
6600                 if (!ok) {
6601                         DEBUG(0, ("printername data corrupted\n"));
6602                         result = WERR_INVALID_DATA;
6603                         goto done;
6604                 }
6605                 result = winreg_set_printer_dataex(tmp_ctx, b,
6606                                           printer->sharename,
6607                                           SPOOL_DSSPOOLER_KEY,
6608                                           SPOOL_REG_PRINTERNAME,
6609                                           REG_SZ,
6610                                           buffer.data,
6611                                           buffer.length);
6612                 if (!W_ERROR_IS_OK(result)) {
6613                         DEBUG(0, ("Failed to set %s\n", SPOOL_REG_PRINTSHARENAME));
6614                         goto done;
6615                 }
6616
6617                 if (!force_update) {
6618                         notify_printer_printername(server_event_context(),
6619                                                    msg_ctx, snum, p ? p : "");
6620                 }
6621
6622                 /* name change, purge any cache entries for the old */
6623                 prune_printername_cache();
6624         }
6625
6626         if (printer->portname != NULL &&
6627             (force_update ||
6628              !strequal(printer->portname, old_printer->portname))) {
6629                 ok = push_reg_sz(tmp_ctx, &buffer, printer->portname);
6630                 if (!ok) {
6631                         DEBUG(0, ("portname data corrupted\n"));
6632                         result = WERR_INVALID_DATA;
6633                         goto done;
6634                 }
6635                 result = winreg_set_printer_dataex(tmp_ctx, b,
6636                                           printer->sharename,
6637                                           SPOOL_DSSPOOLER_KEY,
6638                                           SPOOL_REG_PORTNAME,
6639                                           REG_SZ,
6640                                           buffer.data,
6641                                           buffer.length);
6642                 if (!W_ERROR_IS_OK(result)) {
6643                         DEBUG(0, ("Failed to set %s\n", SPOOL_REG_PORTNAME));
6644                         goto done;
6645                 }
6646
6647                 if (!force_update) {
6648                         notify_printer_port(server_event_context(),
6649                                             msg_ctx, snum, printer->portname ?
6650                                             printer->portname : "");
6651                 }
6652         }
6653
6654         if (printer->location != NULL &&
6655             (force_update ||
6656              !strequal(printer->location, old_printer->location))) {
6657                 ok = push_reg_sz(tmp_ctx, &buffer, printer->location);
6658                 if (!ok) {
6659                         DEBUG(0, ("location data corrupted\n"));
6660                         result = WERR_INVALID_DATA;
6661                         goto done;
6662                 }
6663                 result = winreg_set_printer_dataex(tmp_ctx, b,
6664                                           printer->sharename,
6665                                           SPOOL_DSSPOOLER_KEY,
6666                                           SPOOL_REG_LOCATION,
6667                                           REG_SZ,
6668                                           buffer.data,
6669                                           buffer.length);
6670                 if (!W_ERROR_IS_OK(result)) {
6671                         DEBUG(0, ("Failed to set %s\n", SPOOL_REG_LOCATION));
6672                         goto done;
6673                 }
6674
6675                 if (!force_update) {
6676                         notify_printer_location(server_event_context(),
6677                                                 msg_ctx, snum,
6678                                                 printer->location ?
6679                                                 printer->location : "");
6680                 }
6681         }
6682
6683         if (printer->sepfile != NULL &&
6684             (force_update ||
6685              !strequal(printer->sepfile, old_printer->sepfile))) {
6686                 ok = push_reg_sz(tmp_ctx, &buffer, printer->sepfile);
6687                 if (!ok) {
6688                         DEBUG(0, ("sepfile data corrupted\n"));
6689                         result = WERR_INVALID_DATA;
6690                         goto done;
6691                 }
6692                 result = winreg_set_printer_dataex(tmp_ctx, b,
6693                                           printer->sharename,
6694                                           SPOOL_DSSPOOLER_KEY,
6695                                           SPOOL_REG_PRINTSEPARATORFILE,
6696                                           REG_SZ,
6697                                           buffer.data,
6698                                           buffer.length);
6699                 if (!W_ERROR_IS_OK(result)) {
6700                         DEBUG(0, ("Failed to set %s\n", SPOOL_REG_PRINTSEPARATORFILE));
6701                         goto done;
6702                 }
6703
6704                 if (!force_update) {
6705                         notify_printer_sepfile(server_event_context(),
6706                                                msg_ctx, snum,
6707                                                printer->sepfile ?
6708                                                printer->sepfile : "");
6709                 }
6710         }
6711
6712         if (printer->starttime != 0 &&
6713             (force_update ||
6714              printer->starttime != old_printer->starttime)) {
6715                 buffer = data_blob_talloc(tmp_ctx, NULL, 4);
6716                 SIVAL(buffer.data, 0, printer->starttime);
6717                 result = winreg_set_printer_dataex(tmp_ctx, b,
6718                                           printer->sharename,
6719                                           SPOOL_DSSPOOLER_KEY,
6720                                           SPOOL_REG_PRINTSTARTTIME,
6721                                           REG_DWORD,
6722                                           buffer.data,
6723                                           buffer.length);
6724                 if (!W_ERROR_IS_OK(result)) {
6725                         DEBUG(0, ("Failed to set %s\n", SPOOL_REG_PRINTSTARTTIME));
6726                         goto done;
6727                 }
6728         }
6729
6730         if (printer->untiltime != 0 &&
6731             (force_update ||
6732              printer->untiltime != old_printer->untiltime)) {
6733                 buffer = data_blob_talloc(tmp_ctx, NULL, 4);
6734                 SIVAL(buffer.data, 0, printer->untiltime);
6735                 result = winreg_set_printer_dataex(tmp_ctx, b,
6736                                           printer->sharename,
6737                                           SPOOL_DSSPOOLER_KEY,
6738                                           SPOOL_REG_PRINTENDTIME,
6739                                           REG_DWORD,
6740                                           buffer.data,
6741                                           buffer.length);
6742                 if (!W_ERROR_IS_OK(result)) {
6743                         DEBUG(0, ("Failed to set %s\n", SPOOL_REG_PRINTENDTIME));
6744                         goto done;
6745                 }
6746         }
6747
6748         if (force_update || printer->priority != old_printer->priority) {
6749                 buffer = data_blob_talloc(tmp_ctx, NULL, 4);
6750                 SIVAL(buffer.data, 0, printer->priority);
6751                 result = winreg_set_printer_dataex(tmp_ctx, b,
6752                                           printer->sharename,
6753                                           SPOOL_DSSPOOLER_KEY,
6754                                           SPOOL_REG_PRIORITY,
6755                                           REG_DWORD,
6756                                           buffer.data,
6757                                           buffer.length);
6758                 if (!W_ERROR_IS_OK(result)) {
6759                         DEBUG(0, ("Failed to set %s\n", SPOOL_REG_PRINTENDTIME));
6760                         goto done;
6761                 }
6762         }
6763
6764         if (force_update || printer->attributes != old_printer->attributes) {
6765                 buffer = data_blob_talloc(tmp_ctx, NULL, 4);
6766                 SIVAL(buffer.data, 0, (printer->attributes &
6767                                        PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS));
6768                 result = winreg_set_printer_dataex(tmp_ctx, b,
6769                                           printer->sharename,
6770                                           SPOOL_DSSPOOLER_KEY,
6771                                           SPOOL_REG_PRINTKEEPPRINTEDJOBS,
6772                                           REG_DWORD,
6773                                           buffer.data,
6774                                           buffer.length);
6775                 if (!W_ERROR_IS_OK(result)) {
6776                         DEBUG(0, ("Failed to set %s\n", SPOOL_REG_PRINTENDTIME));
6777                         goto done;
6778                 }
6779
6780                 switch (printer->attributes & 0x3) {
6781                         case 0:
6782                                 spooling = SPOOL_REGVAL_PRINTWHILESPOOLING;
6783                                 break;
6784                         case 1:
6785                                 spooling = SPOOL_REGVAL_PRINTAFTERSPOOLED;
6786                                 break;
6787                         case 2:
6788                                 spooling = SPOOL_REGVAL_PRINTDIRECT;
6789                                 break;
6790                         default:
6791                                 spooling = "unknown";
6792                 }
6793                 ok = push_reg_sz(tmp_ctx, &buffer, spooling);
6794                 if (!ok) {
6795                         DEBUG(0, ("printSpooling data corrupted\n"));
6796                         result = WERR_INVALID_DATA;
6797                         goto done;
6798                 }
6799                 winreg_set_printer_dataex(tmp_ctx, b,
6800                                           printer->sharename,
6801                                           SPOOL_DSSPOOLER_KEY,
6802                                           SPOOL_REG_PRINTSPOOLING,
6803                                           REG_SZ,
6804                                           buffer.data,
6805                                           buffer.length);
6806         }
6807
6808         ok = push_reg_sz(tmp_ctx, &buffer, lp_netbios_name());
6809         if (!ok) {
6810                 DEBUG(0, ("shortServerName data corrupted\n"));
6811                 result = WERR_INVALID_DATA;
6812                 goto done;
6813         }
6814         result = winreg_set_printer_dataex(tmp_ctx, b,
6815                                   printer->sharename,
6816                                   SPOOL_DSSPOOLER_KEY,
6817                                   SPOOL_REG_SHORTSERVERNAME,
6818                                   REG_SZ,
6819                                   buffer.data,
6820                                   buffer.length);
6821         if (!W_ERROR_IS_OK(result)) {
6822                 DEBUG(0, ("Failed to set %s\n", SPOOL_REG_SHORTSERVERNAME));
6823                 goto done;
6824         }
6825
6826         dnsdomname = get_mydnsfullname();
6827         if (dnsdomname != NULL && dnsdomname[0] != '\0') {
6828                 longname = talloc_strdup(tmp_ctx, dnsdomname);
6829         } else {
6830                 longname = talloc_strdup(tmp_ctx, lp_netbios_name());
6831         }
6832         if (longname == NULL) {
6833                 result = WERR_NOT_ENOUGH_MEMORY;
6834                 goto done;
6835         }
6836
6837         ok = push_reg_sz(tmp_ctx, &buffer, longname);
6838         if (!ok) {
6839                 DEBUG(0, ("longname data corrupted\n"));
6840                 result = WERR_INVALID_DATA;
6841                 goto done;
6842         }
6843         result = winreg_set_printer_dataex(tmp_ctx, b,
6844                                            printer->sharename,
6845                                            SPOOL_DSSPOOLER_KEY,
6846                                            SPOOL_REG_SERVERNAME,
6847                                            REG_SZ,
6848                                            buffer.data,
6849                                            buffer.length);
6850         if (!W_ERROR_IS_OK(result)) {
6851                 DEBUG(0, ("Failed to set %s\n", SPOOL_REG_SERVERNAME));
6852                 goto done;
6853         }
6854
6855         uncname = talloc_asprintf(tmp_ctx, "\\\\%s\\%s",
6856                                   lp_netbios_name(), printer->sharename);
6857         ok = push_reg_sz(tmp_ctx, &buffer, uncname);
6858         if (!ok) {
6859                 DEBUG(0, ("uncName data corrupted\n"));
6860                 result = WERR_INVALID_DATA;
6861                 goto done;
6862         }
6863         result = winreg_set_printer_dataex(tmp_ctx, b,
6864                                   printer->sharename,
6865                                   SPOOL_DSSPOOLER_KEY,
6866                                   SPOOL_REG_UNCNAME,
6867                                   REG_SZ,
6868                                   buffer.data,
6869                                   buffer.length);
6870         if (!W_ERROR_IS_OK(result)) {
6871                 DEBUG(0, ("Failed to set %s\n", SPOOL_REG_UNCNAME));
6872                 goto done;
6873         }
6874
6875 done:
6876         talloc_free(tmp_ctx);
6877         return result;
6878 }
6879
6880 /********************************************************************
6881  * Called by spoolss_api_setprinter
6882  * when updating a printer description.
6883  ********************************************************************/
6884
6885 static WERROR update_printer(struct pipes_struct *p,
6886                              struct policy_handle *handle,
6887                              struct spoolss_SetPrinterInfoCtr *info_ctr,
6888                              struct spoolss_DeviceMode *devmode)
6889 {
6890         uint32_t printer_mask = SPOOLSS_PRINTER_INFO_ALL;
6891         struct spoolss_SetPrinterInfo2 *printer = info_ctr->info.info2;
6892         struct spoolss_PrinterInfo2 *old_printer;
6893         struct printer_handle *Printer = find_printer_index_by_hnd(p, handle);
6894         int snum;
6895         WERROR result = WERR_OK;
6896         TALLOC_CTX *tmp_ctx;
6897         struct dcerpc_binding_handle *b;
6898
6899         DEBUG(8,("update_printer\n"));
6900
6901         tmp_ctx = talloc_new(p->mem_ctx);
6902         if (tmp_ctx == NULL) {
6903                 return WERR_NOT_ENOUGH_MEMORY;
6904         }
6905
6906         if (!Printer) {
6907                 result = WERR_INVALID_HANDLE;
6908                 goto done;
6909         }
6910
6911         if (!get_printer_snum(p, handle, &snum, NULL)) {
6912                 result = WERR_INVALID_HANDLE;
6913                 goto done;
6914         }
6915
6916         result = winreg_printer_binding_handle(tmp_ctx,
6917                                                get_session_info_system(),
6918                                                p->msg_ctx,
6919                                                &b);
6920         if (!W_ERROR_IS_OK(result)) {
6921                 goto done;
6922         }
6923
6924         result = winreg_get_printer(tmp_ctx, b,
6925                                     lp_const_servicename(snum),
6926                                     &old_printer);
6927         if (!W_ERROR_IS_OK(result)) {
6928                 result = WERR_INVALID_HANDLE;
6929                 goto done;
6930         }
6931
6932         /* Do sanity check on the requested changes for Samba */
6933         if (!check_printer_ok(tmp_ctx, printer, snum)) {
6934                 result = WERR_INVALID_PARAMETER;
6935                 goto done;
6936         }
6937
6938         /* FIXME!!! If the driver has changed we really should verify that
6939            it is installed before doing much else   --jerry */
6940
6941         /* Check calling user has permission to update printer description */
6942         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
6943                 DEBUG(3, ("update_printer: printer property change denied by handle\n"));
6944                 result = WERR_ACCESS_DENIED;
6945                 goto done;
6946         }
6947
6948         /* Call addprinter hook */
6949         /* Check changes to see if this is really needed */
6950
6951         if (*lp_addprinter_command(talloc_tos()) &&
6952                         (!strequal(printer->drivername, old_printer->drivername) ||
6953                          !strequal(printer->comment, old_printer->comment) ||
6954                          !strequal(printer->portname, old_printer->portname) ||
6955                          !strequal(printer->location, old_printer->location)) )
6956         {
6957                 char *raddr;
6958
6959                 raddr = tsocket_address_inet_addr_string(p->remote_address,
6960                                                          p->mem_ctx);
6961                 if (raddr == NULL) {
6962                         return WERR_NOT_ENOUGH_MEMORY;
6963                 }
6964
6965                 /* add_printer_hook() will call reload_services() */
6966                 if (!add_printer_hook(tmp_ctx, p->session_info->security_token,
6967                                       printer, raddr,
6968                                       p->msg_ctx)) {
6969                         result = WERR_ACCESS_DENIED;
6970                         goto done;
6971                 }
6972         }
6973
6974         result = update_dsspooler(tmp_ctx,
6975                                   get_session_info_system(),
6976                                   p->msg_ctx,
6977                                   snum,
6978                                   printer,
6979                                   old_printer);
6980         if (!W_ERROR_IS_OK(result)) {
6981                 goto done;
6982         }
6983
6984         printer_mask &= ~SPOOLSS_PRINTER_INFO_SECDESC;
6985
6986         if (devmode == NULL) {
6987                 printer_mask &= ~SPOOLSS_PRINTER_INFO_DEVMODE;
6988         }
6989         result = winreg_update_printer(tmp_ctx, b,
6990                                        printer->sharename,
6991                                        printer_mask,
6992                                        printer,
6993                                        devmode,
6994                                        NULL);
6995
6996 done:
6997         talloc_free(tmp_ctx);
6998
6999         return result;
7000 }
7001
7002 /****************************************************************************
7003 ****************************************************************************/
7004 static WERROR publish_or_unpublish_printer(struct pipes_struct *p,
7005                                            struct policy_handle *handle,
7006                                            struct spoolss_SetPrinterInfo7 *info7)
7007 {
7008 #ifdef HAVE_ADS
7009         struct spoolss_PrinterInfo2 *pinfo2 = NULL;
7010         WERROR result;
7011         int snum;
7012         struct printer_handle *Printer;
7013
7014         if ( lp_security() != SEC_ADS ) {
7015                 return WERR_INVALID_LEVEL;
7016         }
7017
7018         Printer = find_printer_index_by_hnd(p, handle);
7019
7020         DEBUG(5,("publish_or_unpublish_printer, action = %d\n",info7->action));
7021
7022         if (!Printer)
7023                 return WERR_INVALID_HANDLE;
7024
7025         if (!get_printer_snum(p, handle, &snum, NULL))
7026                 return WERR_INVALID_HANDLE;
7027
7028         result = winreg_get_printer_internal(p->mem_ctx,
7029                                     get_session_info_system(),
7030                                     p->msg_ctx,
7031                                     lp_servicename(talloc_tos(), snum),
7032                                     &pinfo2);
7033         if (!W_ERROR_IS_OK(result)) {
7034                 return WERR_INVALID_HANDLE;
7035         }
7036
7037         nt_printer_publish(pinfo2,
7038                            get_session_info_system(),
7039                            p->msg_ctx,
7040                            pinfo2,
7041                            info7->action);
7042
7043         TALLOC_FREE(pinfo2);
7044         return WERR_OK;
7045 #else
7046         return WERR_INVALID_LEVEL;
7047 #endif
7048 }
7049
7050 /********************************************************************
7051  ********************************************************************/
7052
7053 static WERROR update_printer_devmode(struct pipes_struct *p,
7054                                      struct policy_handle *handle,
7055                                      struct spoolss_DeviceMode *devmode)
7056 {
7057         int snum;
7058         struct printer_handle *Printer = find_printer_index_by_hnd(p, handle);
7059         uint32_t info2_mask = SPOOLSS_PRINTER_INFO_DEVMODE;
7060
7061         DEBUG(8,("update_printer_devmode\n"));
7062
7063         if (!Printer) {
7064                 return WERR_INVALID_HANDLE;
7065         }
7066
7067         if (!get_printer_snum(p, handle, &snum, NULL)) {
7068                 return WERR_INVALID_HANDLE;
7069         }
7070
7071         /* Check calling user has permission to update printer description */
7072         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
7073                 DEBUG(3, ("update_printer: printer property change denied by handle\n"));
7074                 return WERR_ACCESS_DENIED;
7075         }
7076
7077         return winreg_update_printer_internal(p->mem_ctx,
7078                                      get_session_info_system(),
7079                                      p->msg_ctx,
7080                                      lp_const_servicename(snum),
7081                                      info2_mask,
7082                                      NULL,
7083                                      devmode,
7084                                      NULL);
7085 }
7086
7087
7088 /****************************************************************
7089  _spoolss_SetPrinter
7090 ****************************************************************/
7091
7092 WERROR _spoolss_SetPrinter(struct pipes_struct *p,
7093                            struct spoolss_SetPrinter *r)
7094 {
7095         WERROR result;
7096
7097         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
7098
7099         if (!Printer) {
7100                 DEBUG(2,("_spoolss_SetPrinter: Invalid handle (%s:%u:%u)\n",
7101                         OUR_HANDLE(r->in.handle)));
7102                 return WERR_INVALID_HANDLE;
7103         }
7104
7105         /* check the level */
7106         switch (r->in.info_ctr->level) {
7107                 case 0:
7108                         return control_printer(r->in.handle, r->in.command, p);
7109                 case 2:
7110                         result = update_printer(p, r->in.handle,
7111                                                 r->in.info_ctr,
7112                                                 r->in.devmode_ctr->devmode);
7113                         if (!W_ERROR_IS_OK(result))
7114                                 return result;
7115                         if (r->in.secdesc_ctr->sd)
7116                                 result = update_printer_sec(r->in.handle, p,
7117                                                             r->in.secdesc_ctr);
7118                         return result;
7119                 case 3:
7120                         return update_printer_sec(r->in.handle, p,
7121                                                   r->in.secdesc_ctr);
7122                 case 4: {
7123                         struct spoolss_PrinterInfo2 *old_printer;
7124                         struct spoolss_SetPrinterInfo2 *set_old_printer;
7125                         struct spoolss_SetPrinterInfoCtr *info_ctr;
7126                         struct dcerpc_binding_handle *b;
7127                         int snum;
7128                         TALLOC_CTX *tmp_ctx;
7129
7130                         tmp_ctx = talloc_new(p->mem_ctx);
7131                         if (tmp_ctx == NULL) {
7132                                 return WERR_NOT_ENOUGH_MEMORY;
7133                         }
7134
7135                         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
7136                                 TALLOC_FREE(tmp_ctx);
7137                                 return WERR_INVALID_HANDLE;
7138                         }
7139
7140                         result = winreg_printer_binding_handle(tmp_ctx,
7141                                                                get_session_info_system(),
7142                                                                p->msg_ctx,
7143                                                                &b);
7144                         if (!W_ERROR_IS_OK(result)) {
7145                                 TALLOC_FREE(tmp_ctx);
7146                                 return result;
7147                         }
7148
7149                         result = winreg_get_printer(tmp_ctx, b,
7150                                                     lp_const_servicename(snum),
7151                                                     &old_printer);
7152                         if (!W_ERROR_IS_OK(result)) {
7153                                 TALLOC_FREE(tmp_ctx);
7154                                 return WERR_INVALID_HANDLE;
7155                         }
7156
7157                         old_printer->servername = talloc_strdup(tmp_ctx, r->in.info_ctr->info.info4->servername);
7158                         if (old_printer->servername == NULL) {
7159                                 TALLOC_FREE(tmp_ctx);
7160                                 return WERR_NOT_ENOUGH_MEMORY;
7161                         }
7162
7163                         old_printer->printername = talloc_strdup(tmp_ctx, r->in.info_ctr->info.info4->printername);
7164                         if (old_printer->printername == NULL) {
7165                                 TALLOC_FREE(tmp_ctx);
7166                                 return WERR_NOT_ENOUGH_MEMORY;
7167                         }
7168
7169                         old_printer->attributes = r->in.info_ctr->info.info4->attributes;
7170
7171                         set_old_printer = talloc_zero(tmp_ctx, struct spoolss_SetPrinterInfo2);
7172                         if (set_old_printer == NULL) {
7173                                 TALLOC_FREE(tmp_ctx);
7174                                 return WERR_NOT_ENOUGH_MEMORY;
7175                         }
7176
7177                         spoolss_printerinfo2_to_setprinterinfo2(old_printer, set_old_printer);
7178
7179                         info_ctr = talloc_zero(tmp_ctx, struct spoolss_SetPrinterInfoCtr);
7180                         if (info_ctr == NULL) {
7181                                 TALLOC_FREE(tmp_ctx);
7182                                 return WERR_NOT_ENOUGH_MEMORY;
7183                         }
7184
7185                         info_ctr->level = 2;
7186                         info_ctr->info.info2 = set_old_printer;
7187
7188                         result = update_printer(p, r->in.handle,
7189                                                 info_ctr,
7190                                                 r->in.devmode_ctr->devmode);
7191
7192                         if (!W_ERROR_IS_OK(result)) {
7193                                 TALLOC_FREE(tmp_ctx);
7194                                 return result;
7195                         }
7196
7197                         if (r->in.secdesc_ctr->sd) {
7198                                 result = update_printer_sec(r->in.handle, p,
7199                                                             r->in.secdesc_ctr);
7200                         }
7201
7202                         TALLOC_FREE(tmp_ctx);
7203                         return result;
7204                 }
7205                 case 7:
7206                         return publish_or_unpublish_printer(p, r->in.handle,
7207                                                             r->in.info_ctr->info.info7);
7208                 case 8:
7209                         return update_printer_devmode(p, r->in.handle,
7210                                                       r->in.devmode_ctr->devmode);
7211                 default:
7212                         return WERR_INVALID_LEVEL;
7213         }
7214 }
7215
7216 /****************************************************************
7217  _spoolss_FindClosePrinterNotify
7218 ****************************************************************/
7219
7220 WERROR _spoolss_FindClosePrinterNotify(struct pipes_struct *p,
7221                                        struct spoolss_FindClosePrinterNotify *r)
7222 {
7223         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
7224
7225         if (!Printer) {
7226                 DEBUG(2,("_spoolss_FindClosePrinterNotify: "
7227                         "Invalid handle (%s:%u:%u)\n", OUR_HANDLE(r->in.handle)));
7228                 return WERR_INVALID_HANDLE;
7229         }
7230
7231         if (Printer->notify.cli_chan != NULL &&
7232             Printer->notify.cli_chan->active_connections > 0) {
7233                 int snum = -1;
7234
7235                 if (Printer->printer_type == SPLHND_PRINTER) {
7236                         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
7237                                 return WERR_INVALID_HANDLE;
7238                         }
7239                 }
7240
7241                 srv_spoolss_replycloseprinter(snum, Printer);
7242         }
7243
7244         Printer->notify.flags=0;
7245         Printer->notify.options=0;
7246         Printer->notify.localmachine[0]='\0';
7247         Printer->notify.printerlocal=0;
7248         TALLOC_FREE(Printer->notify.option);
7249
7250         return WERR_OK;
7251 }
7252
7253 /****************************************************************
7254  _spoolss_AddJob
7255 ****************************************************************/
7256
7257 WERROR _spoolss_AddJob(struct pipes_struct *p,
7258                        struct spoolss_AddJob *r)
7259 {
7260         if (!r->in.buffer && (r->in.offered != 0)) {
7261                 return WERR_INVALID_PARAMETER;
7262         }
7263
7264         /* this is what a NT server returns for AddJob. AddJob must fail on
7265          * non-local printers */
7266
7267         if (r->in.level != 1) {
7268                 return WERR_INVALID_LEVEL;
7269         }
7270
7271         return WERR_INVALID_PARAMETER;
7272 }
7273
7274 /****************************************************************************
7275 fill_job_info1
7276 ****************************************************************************/
7277
7278 static WERROR fill_job_info1(TALLOC_CTX *mem_ctx,
7279                              struct spoolss_JobInfo1 *r,
7280                              const print_queue_struct *queue,
7281                              uint32_t jobid,
7282                              int position, int snum,
7283                              struct spoolss_PrinterInfo2 *pinfo2)
7284 {
7285         struct tm *t;
7286
7287         t = gmtime(&queue->time);
7288
7289         r->job_id               = jobid;
7290
7291         r->printer_name         = lp_servicename(mem_ctx, snum);
7292         W_ERROR_HAVE_NO_MEMORY(r->printer_name);
7293         r->server_name          = talloc_strdup(mem_ctx, pinfo2->servername);
7294         W_ERROR_HAVE_NO_MEMORY(r->server_name);
7295         r->user_name            = talloc_strdup(mem_ctx, queue->fs_user);
7296         W_ERROR_HAVE_NO_MEMORY(r->user_name);
7297         r->document_name        = talloc_strdup(mem_ctx, queue->fs_file);
7298         W_ERROR_HAVE_NO_MEMORY(r->document_name);
7299         r->data_type            = talloc_strdup(mem_ctx, "RAW");
7300         W_ERROR_HAVE_NO_MEMORY(r->data_type);
7301         r->text_status          = talloc_strdup(mem_ctx, "");
7302         W_ERROR_HAVE_NO_MEMORY(r->text_status);
7303
7304         r->status               = nt_printj_status(queue->status);
7305         r->priority             = queue->priority;
7306         r->position             = position;
7307         r->total_pages          = queue->page_count;
7308         r->pages_printed        = 0; /* ??? */
7309
7310         init_systemtime(&r->submitted, t);
7311
7312         return WERR_OK;
7313 }
7314
7315 /****************************************************************************
7316 fill_job_info2
7317 ****************************************************************************/
7318
7319 static WERROR fill_job_info2(TALLOC_CTX *mem_ctx,
7320                              struct spoolss_JobInfo2 *r,
7321                              const print_queue_struct *queue,
7322                              uint32_t jobid,
7323                              int position, int snum,
7324                              struct spoolss_PrinterInfo2 *pinfo2,
7325                              struct spoolss_DeviceMode *devmode)
7326 {
7327         struct tm *t;
7328
7329         t = gmtime(&queue->time);
7330
7331         r->job_id               = jobid;
7332
7333         r->printer_name         = lp_servicename(mem_ctx, snum);
7334         W_ERROR_HAVE_NO_MEMORY(r->printer_name);
7335         r->server_name          = talloc_strdup(mem_ctx, pinfo2->servername);
7336         W_ERROR_HAVE_NO_MEMORY(r->server_name);
7337         r->user_name            = talloc_strdup(mem_ctx, queue->fs_user);
7338         W_ERROR_HAVE_NO_MEMORY(r->user_name);
7339         r->document_name        = talloc_strdup(mem_ctx, queue->fs_file);
7340         W_ERROR_HAVE_NO_MEMORY(r->document_name);
7341         r->notify_name          = talloc_strdup(mem_ctx, queue->fs_user);
7342         W_ERROR_HAVE_NO_MEMORY(r->notify_name);
7343         r->data_type            = talloc_strdup(mem_ctx, "RAW");
7344         W_ERROR_HAVE_NO_MEMORY(r->data_type);
7345         r->print_processor      = talloc_strdup(mem_ctx, "winprint");
7346         W_ERROR_HAVE_NO_MEMORY(r->print_processor);
7347         r->parameters           = talloc_strdup(mem_ctx, "");
7348         W_ERROR_HAVE_NO_MEMORY(r->parameters);
7349         r->driver_name          = talloc_strdup(mem_ctx, pinfo2->drivername);
7350         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
7351
7352         r->devmode              = devmode;
7353
7354         r->text_status          = talloc_strdup(mem_ctx, "");
7355         W_ERROR_HAVE_NO_MEMORY(r->text_status);
7356
7357         r->secdesc              = NULL;
7358
7359         r->status               = nt_printj_status(queue->status);
7360         r->priority             = queue->priority;
7361         r->position             = position;
7362         r->start_time           = 0;
7363         r->until_time           = 0;
7364         r->total_pages          = queue->page_count;
7365         r->size                 = queue->size;
7366         init_systemtime(&r->submitted, t);
7367         r->time                 = 0;
7368         r->pages_printed        = 0; /* ??? */
7369
7370         return WERR_OK;
7371 }
7372
7373 /****************************************************************************
7374  Enumjobs at level 1.
7375 ****************************************************************************/
7376
7377 static WERROR enumjobs_level1(TALLOC_CTX *mem_ctx,
7378                               const print_queue_struct *queue,
7379                               uint32_t num_queues, int snum,
7380                               struct spoolss_PrinterInfo2 *pinfo2,
7381                               union spoolss_JobInfo **info_p,
7382                               uint32_t *count)
7383 {
7384         union spoolss_JobInfo *info;
7385         int i;
7386         WERROR result = WERR_OK;
7387         uint32_t num_filled;
7388         struct tdb_print_db *pdb;
7389
7390         info = talloc_array(mem_ctx, union spoolss_JobInfo, num_queues);
7391         if (info == NULL) {
7392                 result = WERR_NOT_ENOUGH_MEMORY;
7393                 goto err_out;
7394         }
7395
7396         pdb = get_print_db_byname(pinfo2->sharename);
7397         if (pdb == NULL) {
7398                 result = WERR_INVALID_PARAMETER;
7399                 goto err_info_free;
7400         }
7401
7402         num_filled = 0;
7403         for (i = 0; i < num_queues; i++) {
7404                 uint32_t jobid = sysjob_to_jobid_pdb(pdb, queue[i].sysjob);
7405                 if (jobid == (uint32_t)-1) {
7406                         DEBUG(4, ("skipping sysjob %d\n", queue[i].sysjob));
7407                         continue;
7408                 }
7409
7410                 result = fill_job_info1(info,
7411                                         &info[num_filled].info1,
7412                                         &queue[i],
7413                                         jobid,
7414                                         i,
7415                                         snum,
7416                                         pinfo2);
7417                 if (!W_ERROR_IS_OK(result)) {
7418                         goto err_pdb_drop;
7419                 }
7420
7421                 num_filled++;
7422         }
7423
7424         release_print_db(pdb);
7425         *info_p = info;
7426         *count = num_filled;
7427
7428         return WERR_OK;
7429
7430 err_pdb_drop:
7431         release_print_db(pdb);
7432 err_info_free:
7433         TALLOC_FREE(info);
7434 err_out:
7435         *count = 0;
7436         return result;
7437 }
7438
7439 /****************************************************************************
7440  Enumjobs at level 2.
7441 ****************************************************************************/
7442
7443 static WERROR enumjobs_level2(TALLOC_CTX *mem_ctx,
7444                               const print_queue_struct *queue,
7445                               uint32_t num_queues, int snum,
7446                               struct spoolss_PrinterInfo2 *pinfo2,
7447                               union spoolss_JobInfo **info_p,
7448                               uint32_t *count)
7449 {
7450         union spoolss_JobInfo *info;
7451         int i;
7452         WERROR result = WERR_OK;
7453         uint32_t num_filled;
7454         struct tdb_print_db *pdb;
7455
7456         info = talloc_array(mem_ctx, union spoolss_JobInfo, num_queues);
7457         if (info == NULL) {
7458                 result = WERR_NOT_ENOUGH_MEMORY;
7459                 goto err_out;
7460         }
7461
7462         pdb = get_print_db_byname(pinfo2->sharename);
7463         if (pdb == NULL) {
7464                 result = WERR_INVALID_PARAMETER;
7465                 goto err_info_free;
7466         }
7467
7468         num_filled = 0;
7469         for (i = 0; i< num_queues; i++) {
7470                 struct spoolss_DeviceMode *devmode;
7471                 uint32_t jobid = sysjob_to_jobid_pdb(pdb, queue[i].sysjob);
7472                 if (jobid == (uint32_t)-1) {
7473                         DEBUG(4, ("skipping sysjob %d\n", queue[i].sysjob));
7474                         continue;
7475                 }
7476
7477                 result = spoolss_create_default_devmode(info,
7478                                                         pinfo2->printername,
7479                                                         &devmode);
7480                 if (!W_ERROR_IS_OK(result)) {
7481                         DEBUG(3, ("Can't proceed w/o a devmode!"));
7482                         goto err_pdb_drop;
7483                 }
7484
7485                 result = fill_job_info2(info,
7486                                         &info[num_filled].info2,
7487                                         &queue[i],
7488                                         jobid,
7489                                         i,
7490                                         snum,
7491                                         pinfo2,
7492                                         devmode);
7493                 if (!W_ERROR_IS_OK(result)) {
7494                         goto err_pdb_drop;
7495                 }
7496                 num_filled++;
7497         }
7498
7499         release_print_db(pdb);
7500         *info_p = info;
7501         *count = num_filled;
7502
7503         return WERR_OK;
7504
7505 err_pdb_drop:
7506         release_print_db(pdb);
7507 err_info_free:
7508         TALLOC_FREE(info);
7509 err_out:
7510         *count = 0;
7511         return result;
7512 }
7513
7514 /****************************************************************************
7515  Enumjobs at level 3.
7516 ****************************************************************************/
7517
7518 static WERROR enumjobs_level3(TALLOC_CTX *mem_ctx,
7519                               const print_queue_struct *queue,
7520                               uint32_t num_queues, int snum,
7521                               struct spoolss_PrinterInfo2 *pinfo2,
7522                               union spoolss_JobInfo **info_p,
7523                               uint32_t *count)
7524 {
7525         union spoolss_JobInfo *info;
7526         int i;
7527         WERROR result = WERR_OK;
7528         uint32_t num_filled;
7529         struct tdb_print_db *pdb;
7530
7531         info = talloc_array(mem_ctx, union spoolss_JobInfo, num_queues);
7532         if (info == NULL) {
7533                 result = WERR_NOT_ENOUGH_MEMORY;
7534                 goto err_out;
7535         }
7536
7537         pdb = get_print_db_byname(pinfo2->sharename);
7538         if (pdb == NULL) {
7539                 result = WERR_INVALID_PARAMETER;
7540                 goto err_info_free;
7541         }
7542
7543         num_filled = 0;
7544         for (i = 0; i < num_queues; i++) {
7545                 uint32_t jobid = sysjob_to_jobid_pdb(pdb, queue[i].sysjob);
7546                 if (jobid == (uint32_t)-1) {
7547                         DEBUG(4, ("skipping sysjob %d\n", queue[i].sysjob));
7548                         continue;
7549                 }
7550
7551                 info[num_filled].info3.job_id = jobid;
7552                 /* next_job_id is overwritten on next iteration */
7553                 info[num_filled].info3.next_job_id = 0;
7554                 info[num_filled].info3.reserved = 0;
7555
7556                 if (num_filled > 0) {
7557                         info[num_filled - 1].info3.next_job_id = jobid;
7558                 }
7559                 num_filled++;
7560         }
7561
7562         release_print_db(pdb);
7563         *info_p = info;
7564         *count = num_filled;
7565
7566         return WERR_OK;
7567
7568 err_info_free:
7569         TALLOC_FREE(info);
7570 err_out:
7571         *count = 0;
7572         return result;
7573 }
7574
7575 /****************************************************************
7576  _spoolss_EnumJobs
7577 ****************************************************************/
7578
7579 WERROR _spoolss_EnumJobs(struct pipes_struct *p,
7580                          struct spoolss_EnumJobs *r)
7581 {
7582         WERROR result;
7583         struct spoolss_PrinterInfo2 *pinfo2 = NULL;
7584         int snum;
7585         print_status_struct prt_status;
7586         print_queue_struct *queue = NULL;
7587         uint32_t count;
7588
7589         /* that's an [in out] buffer */
7590
7591         if (!r->in.buffer && (r->in.offered != 0)) {
7592                 return WERR_INVALID_PARAMETER;
7593         }
7594
7595         if ((r->in.level != 1) && (r->in.level != 2) && (r->in.level != 3)) {
7596                 DEBUG(4, ("EnumJobs level %d not supported\n", r->in.level));
7597                 return WERR_INVALID_LEVEL;
7598         }
7599
7600         DEBUG(4,("_spoolss_EnumJobs\n"));
7601
7602         *r->out.needed = 0;
7603         *r->out.count = 0;
7604         *r->out.info = NULL;
7605
7606         /* lookup the printer snum and tdb entry */
7607
7608         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
7609                 return WERR_INVALID_HANDLE;
7610         }
7611
7612         result = winreg_get_printer_internal(p->mem_ctx,
7613                                     get_session_info_system(),
7614                                     p->msg_ctx,
7615                                     lp_const_servicename(snum),
7616                                     &pinfo2);
7617         if (!W_ERROR_IS_OK(result)) {
7618                 return result;
7619         }
7620
7621         count = print_queue_status(p->msg_ctx, snum, &queue, &prt_status);
7622         DEBUGADD(4,("count:[%d], status:[%d], [%s]\n",
7623                 count, prt_status.status, prt_status.message));
7624
7625         if (count == 0) {
7626                 SAFE_FREE(queue);
7627                 TALLOC_FREE(pinfo2);
7628                 return WERR_OK;
7629         }
7630
7631         switch (r->in.level) {
7632         case 1:
7633                 result = enumjobs_level1(p->mem_ctx, queue, count, snum,
7634                                          pinfo2, r->out.info, r->out.count);
7635                 break;
7636         case 2:
7637                 result = enumjobs_level2(p->mem_ctx, queue, count, snum,
7638                                          pinfo2, r->out.info, r->out.count);
7639                 break;
7640         case 3:
7641                 result = enumjobs_level3(p->mem_ctx, queue, count, snum,
7642                                          pinfo2, r->out.info, r->out.count);
7643                 break;
7644         default:
7645                 SMB_ASSERT(false);      /* level checked on entry */
7646                 break;
7647         }
7648
7649         SAFE_FREE(queue);
7650         TALLOC_FREE(pinfo2);
7651
7652         if (!W_ERROR_IS_OK(result)) {
7653                 return result;
7654         }
7655
7656         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
7657                                                      spoolss_EnumJobs,
7658                                                      *r->out.info, r->in.level,
7659                                                      *r->out.count);
7660         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
7661         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
7662
7663         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7664 }
7665
7666 /****************************************************************
7667  _spoolss_ScheduleJob
7668 ****************************************************************/
7669
7670 WERROR _spoolss_ScheduleJob(struct pipes_struct *p,
7671                             struct spoolss_ScheduleJob *r)
7672 {
7673         return WERR_OK;
7674 }
7675
7676 /****************************************************************
7677 ****************************************************************/
7678
7679 static WERROR spoolss_setjob_1(TALLOC_CTX *mem_ctx,
7680                                struct messaging_context *msg_ctx,
7681                                const char *printer_name,
7682                                uint32_t job_id,
7683                                struct spoolss_SetJobInfo1 *r)
7684 {
7685         char *old_doc_name;
7686
7687         if (!print_job_get_name(mem_ctx, printer_name, job_id, &old_doc_name)) {
7688                 return WERR_INVALID_HANDLE;
7689         }
7690
7691         if (strequal(old_doc_name, r->document_name)) {
7692                 return WERR_OK;
7693         }
7694
7695         if (!print_job_set_name(server_event_context(), msg_ctx,
7696                                 printer_name, job_id, r->document_name)) {
7697                 return WERR_INVALID_HANDLE;
7698         }
7699
7700         return WERR_OK;
7701 }
7702
7703 /****************************************************************
7704  _spoolss_SetJob
7705 ****************************************************************/
7706
7707 WERROR _spoolss_SetJob(struct pipes_struct *p,
7708                        struct spoolss_SetJob *r)
7709 {
7710         const struct auth_session_info *session_info = p->session_info;
7711         int snum;
7712         WERROR errcode = WERR_INVALID_FUNCTION;
7713
7714         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
7715                 return WERR_INVALID_HANDLE;
7716         }
7717
7718         if (!print_job_exists(lp_const_servicename(snum), r->in.job_id)) {
7719                 return WERR_INVALID_PRINTER_NAME;
7720         }
7721
7722         switch (r->in.command) {
7723         case SPOOLSS_JOB_CONTROL_CANCEL:
7724         case SPOOLSS_JOB_CONTROL_DELETE:
7725                 errcode = print_job_delete(session_info, p->msg_ctx,
7726                                            snum, r->in.job_id);
7727                 if (W_ERROR_EQUAL(errcode, WERR_PRINTER_HAS_JOBS_QUEUED)) {
7728                         errcode = WERR_OK;
7729                 }
7730                 break;
7731         case SPOOLSS_JOB_CONTROL_PAUSE:
7732                 errcode = print_job_pause(session_info, p->msg_ctx,
7733                                           snum, r->in.job_id);
7734                 break;
7735         case SPOOLSS_JOB_CONTROL_RESTART:
7736         case SPOOLSS_JOB_CONTROL_RESUME:
7737                 errcode = print_job_resume(session_info, p->msg_ctx,
7738                                            snum, r->in.job_id);
7739                 break;
7740         case SPOOLSS_JOB_CONTROL_NOOP:
7741                 errcode = WERR_OK;
7742                 break;
7743         default:
7744                 return WERR_INVALID_LEVEL;
7745         }
7746
7747         if (!W_ERROR_IS_OK(errcode)) {
7748                 return errcode;
7749         }
7750
7751         if (r->in.ctr == NULL) {
7752                 return errcode;
7753         }
7754
7755         switch (r->in.ctr->level) {
7756         case 1:
7757                 errcode = spoolss_setjob_1(p->mem_ctx, p->msg_ctx,
7758                                            lp_const_servicename(snum),
7759                                            r->in.job_id,
7760                                            r->in.ctr->info.info1);
7761                 break;
7762         case 2:
7763         case 3:
7764         case 4:
7765         default:
7766                 return WERR_INVALID_LEVEL;
7767         }
7768
7769         return errcode;
7770 }
7771
7772 /****************************************************************************
7773  Enumerates all printer drivers by level and architecture.
7774 ****************************************************************************/
7775
7776 static WERROR enumprinterdrivers_level_by_architecture(TALLOC_CTX *mem_ctx,
7777                                                        const struct auth_session_info *session_info,
7778                                                        struct messaging_context *msg_ctx,
7779                                                        const char *servername,
7780                                                        const char *architecture,
7781                                                        uint32_t level,
7782                                                        union spoolss_DriverInfo **info_p,
7783                                                        uint32_t *count_p)
7784 {
7785         int i;
7786         uint32_t version;
7787         struct spoolss_DriverInfo8 *driver;
7788         union spoolss_DriverInfo *info = NULL;
7789         uint32_t count = 0;
7790         WERROR result = WERR_OK;
7791         uint32_t num_drivers;
7792         const char **drivers;
7793         struct dcerpc_binding_handle *b;
7794         TALLOC_CTX *tmp_ctx = NULL;
7795
7796         *count_p = 0;
7797         *info_p = NULL;
7798
7799         tmp_ctx = talloc_new(mem_ctx);
7800         if (!tmp_ctx) {
7801                 return WERR_NOT_ENOUGH_MEMORY;
7802         }
7803
7804         result = winreg_printer_binding_handle(tmp_ctx,
7805                                                session_info,
7806                                                msg_ctx,
7807                                                &b);
7808         if (!W_ERROR_IS_OK(result)) {
7809                 goto out;
7810         }
7811
7812         for (version=0; version<DRIVER_MAX_VERSION; version++) {
7813                 result = winreg_get_driver_list(tmp_ctx, b,
7814                                                 architecture, version,
7815                                                 &num_drivers, &drivers);
7816                 if (!W_ERROR_IS_OK(result)) {
7817                         goto out;
7818                 }
7819                 DEBUG(4, ("we have:[%d] drivers in environment"
7820                           " [%s] and version [%d]\n",
7821                           num_drivers, architecture, version));
7822
7823                 if (num_drivers != 0) {
7824                         info = talloc_realloc(tmp_ctx, info,
7825                                                     union spoolss_DriverInfo,
7826                                                     count + num_drivers);
7827                         if (!info) {
7828                                 DEBUG(0,("enumprinterdrivers_level_by_architecture: "
7829                                         "failed to enlarge driver info buffer!\n"));
7830                                 result = WERR_NOT_ENOUGH_MEMORY;
7831                                 goto out;
7832                         }
7833                 }
7834
7835                 for (i = 0; i < num_drivers; i++) {
7836                         DEBUG(5, ("\tdriver: [%s]\n", drivers[i]));
7837
7838                         result = winreg_get_driver(tmp_ctx, b,
7839                                                    architecture, drivers[i],
7840                                                    version, &driver);
7841                         if (!W_ERROR_IS_OK(result)) {
7842                                 goto out;
7843                         }
7844
7845                         switch (level) {
7846                         case 1:
7847                                 result = fill_printer_driver_info1(info, &info[count+i].info1,
7848                                                                    driver, servername);
7849                                 break;
7850                         case 2:
7851                                 result = fill_printer_driver_info2(info, &info[count+i].info2,
7852                                                                    driver, servername);
7853                                 break;
7854                         case 3:
7855                                 result = fill_printer_driver_info3(info, &info[count+i].info3,
7856                                                                    driver, servername);
7857                                 break;
7858                         case 4:
7859                                 result = fill_printer_driver_info4(info, &info[count+i].info4,
7860                                                                    driver, servername);
7861                                 break;
7862                         case 5:
7863                                 result = fill_printer_driver_info5(info, &info[count+i].info5,
7864                                                                    driver, servername);
7865                                 break;
7866                         case 6:
7867                                 result = fill_printer_driver_info6(info, &info[count+i].info6,
7868                                                                    driver, servername);
7869                                 break;
7870                         case 8:
7871                                 result = fill_printer_driver_info8(info, &info[count+i].info8,
7872                                                                    driver, servername);
7873                                 break;
7874                         default:
7875                                 result = WERR_INVALID_LEVEL;
7876                                 break;
7877                         }
7878
7879                         TALLOC_FREE(driver);
7880
7881                         if (!W_ERROR_IS_OK(result)) {
7882                                 goto out;
7883                         }
7884                 }
7885
7886                 count += num_drivers;
7887                 TALLOC_FREE(drivers);
7888         }
7889
7890 out:
7891         if (W_ERROR_IS_OK(result)) {
7892                 *info_p = talloc_move(mem_ctx, &info);
7893                 *count_p = count;
7894         }
7895
7896         talloc_free(tmp_ctx);
7897         return result;
7898 }
7899
7900 /****************************************************************************
7901  Enumerates all printer drivers by level.
7902 ****************************************************************************/
7903
7904 static WERROR enumprinterdrivers_level(TALLOC_CTX *mem_ctx,
7905                                        const struct auth_session_info *session_info,
7906                                        struct messaging_context *msg_ctx,
7907                                        const char *servername,
7908                                        const char *architecture,
7909                                        uint32_t level,
7910                                        union spoolss_DriverInfo **info_p,
7911                                        uint32_t *count_p)
7912 {
7913         uint32_t a,i;
7914         WERROR result = WERR_OK;
7915
7916         if (strequal(architecture, SPOOLSS_ARCHITECTURE_ALL)) {
7917
7918                 for (a=0; archi_table[a].long_archi != NULL; a++) {
7919
7920                         union spoolss_DriverInfo *info = NULL;
7921                         uint32_t count = 0;
7922
7923                         result = enumprinterdrivers_level_by_architecture(mem_ctx,
7924                                                                           session_info,
7925                                                                           msg_ctx,
7926                                                                           servername,
7927                                                                           archi_table[a].long_archi,
7928                                                                           level,
7929                                                                           &info,
7930                                                                           &count);
7931                         if (!W_ERROR_IS_OK(result)) {
7932                                 continue;
7933                         }
7934
7935                         for (i=0; i < count; i++) {
7936                                 ADD_TO_ARRAY(mem_ctx, union spoolss_DriverInfo,
7937                                              info[i], info_p, count_p);
7938                         }
7939                 }
7940
7941                 return result;
7942         }
7943
7944         return enumprinterdrivers_level_by_architecture(mem_ctx,
7945                                                         session_info,
7946                                                         msg_ctx,
7947                                                         servername,
7948                                                         architecture,
7949                                                         level,
7950                                                         info_p,
7951                                                         count_p);
7952 }
7953
7954 /****************************************************************
7955  _spoolss_EnumPrinterDrivers
7956 ****************************************************************/
7957
7958 WERROR _spoolss_EnumPrinterDrivers(struct pipes_struct *p,
7959                                    struct spoolss_EnumPrinterDrivers *r)
7960 {
7961         const char *cservername;
7962         WERROR result;
7963
7964         /* that's an [in out] buffer */
7965
7966         if (!r->in.buffer && (r->in.offered != 0)) {
7967                 return WERR_INVALID_PARAMETER;
7968         }
7969
7970         DEBUG(4,("_spoolss_EnumPrinterDrivers\n"));
7971
7972         *r->out.needed = 0;
7973         *r->out.count = 0;
7974         *r->out.info = NULL;
7975
7976         cservername = canon_servername(r->in.server);
7977
7978         if (!is_myname_or_ipaddr(cservername)) {
7979                 return WERR_UNKNOWN_PRINTER_DRIVER;
7980         }
7981
7982         result = enumprinterdrivers_level(p->mem_ctx,
7983                                           get_session_info_system(),
7984                                           p->msg_ctx,
7985                                           cservername,
7986                                           r->in.environment,
7987                                           r->in.level,
7988                                           r->out.info,
7989                                           r->out.count);
7990         if (!W_ERROR_IS_OK(result)) {
7991                 return result;
7992         }
7993
7994         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
7995                                                      spoolss_EnumPrinterDrivers,
7996                                                      *r->out.info, r->in.level,
7997                                                      *r->out.count);
7998         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
7999         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8000
8001         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8002 }
8003
8004 /****************************************************************
8005  _spoolss_EnumForms
8006 ****************************************************************/
8007
8008 WERROR _spoolss_EnumForms(struct pipes_struct *p,
8009                           struct spoolss_EnumForms *r)
8010 {
8011         WERROR result;
8012
8013         *r->out.count = 0;
8014         *r->out.needed = 0;
8015         *r->out.info = NULL;
8016
8017         /* that's an [in out] buffer */
8018
8019         if (!r->in.buffer && (r->in.offered != 0) ) {
8020                 return WERR_INVALID_PARAMETER;
8021         }
8022
8023         DEBUG(4,("_spoolss_EnumForms\n"));
8024         DEBUGADD(5,("Offered buffer size [%d]\n", r->in.offered));
8025         DEBUGADD(5,("Info level [%d]\n",          r->in.level));
8026
8027         switch (r->in.level) {
8028         case 1:
8029                 result = winreg_printer_enumforms1_internal(p->mem_ctx,
8030                                                    get_session_info_system(),
8031                                                    p->msg_ctx,
8032                                                    r->out.count,
8033                                                    r->out.info);
8034                 break;
8035         default:
8036                 result = WERR_INVALID_LEVEL;
8037                 break;
8038         }
8039
8040         if (!W_ERROR_IS_OK(result)) {
8041                 return result;
8042         }
8043
8044         if (*r->out.count == 0) {
8045                 return WERR_NO_MORE_ITEMS;
8046         }
8047
8048         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8049                                                      spoolss_EnumForms,
8050                                                      *r->out.info, r->in.level,
8051                                                      *r->out.count);
8052         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8053         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8054
8055         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8056 }
8057
8058 /****************************************************************
8059  _spoolss_GetForm
8060 ****************************************************************/
8061
8062 WERROR _spoolss_GetForm(struct pipes_struct *p,
8063                         struct spoolss_GetForm *r)
8064 {
8065         WERROR result;
8066
8067         /* that's an [in out] buffer */
8068
8069         if (!r->in.buffer && (r->in.offered != 0)) {
8070                 TALLOC_FREE(r->out.info);
8071                 return WERR_INVALID_PARAMETER;
8072         }
8073
8074         DEBUG(4,("_spoolss_GetForm\n"));
8075         DEBUGADD(5,("Offered buffer size [%d]\n", r->in.offered));
8076         DEBUGADD(5,("Info level [%d]\n",          r->in.level));
8077
8078         switch (r->in.level) {
8079         case 1:
8080                 result = winreg_printer_getform1_internal(p->mem_ctx,
8081                                                  get_session_info_system(),
8082                                                  p->msg_ctx,
8083                                                  r->in.form_name,
8084                                                  &r->out.info->info1);
8085                 break;
8086         default:
8087                 result = WERR_INVALID_LEVEL;
8088                 break;
8089         }
8090
8091         if (!W_ERROR_IS_OK(result)) {
8092                 TALLOC_FREE(r->out.info);
8093                 return result;
8094         }
8095
8096         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_FormInfo,
8097                                                r->out.info, r->in.level);
8098         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
8099
8100         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8101 }
8102
8103 /****************************************************************************
8104 ****************************************************************************/
8105
8106 static WERROR fill_port_1(TALLOC_CTX *mem_ctx,
8107                           struct spoolss_PortInfo1 *r,
8108                           const char *name)
8109 {
8110         r->port_name = talloc_strdup(mem_ctx, name);
8111         W_ERROR_HAVE_NO_MEMORY(r->port_name);
8112
8113         return WERR_OK;
8114 }
8115
8116 /****************************************************************************
8117  TODO: This probably needs distinguish between TCP/IP and Local ports
8118  somehow.
8119 ****************************************************************************/
8120
8121 static WERROR fill_port_2(TALLOC_CTX *mem_ctx,
8122                           struct spoolss_PortInfo2 *r,
8123                           const char *name)
8124 {
8125         r->port_name = talloc_strdup(mem_ctx, name);
8126         W_ERROR_HAVE_NO_MEMORY(r->port_name);
8127
8128         r->monitor_name = talloc_strdup(mem_ctx, "Local Monitor");
8129         W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
8130
8131         r->description = talloc_strdup(mem_ctx, SPL_LOCAL_PORT);
8132         W_ERROR_HAVE_NO_MEMORY(r->description);
8133
8134         r->port_type = SPOOLSS_PORT_TYPE_WRITE;
8135         r->reserved = 0;
8136
8137         return WERR_OK;
8138 }
8139
8140
8141 /****************************************************************************
8142  wrapper around the enumer ports command
8143 ****************************************************************************/
8144
8145 static WERROR enumports_hook(TALLOC_CTX *ctx, int *count, char ***lines)
8146 {
8147         char *cmd = lp_enumports_command(talloc_tos());
8148         char **qlines = NULL;
8149         char *command = NULL;
8150         int numlines;
8151         int ret;
8152         int fd;
8153
8154         *count = 0;
8155         *lines = NULL;
8156
8157         /* if no hook then just fill in the default port */
8158
8159         if ( !*cmd ) {
8160                 if (!(qlines = talloc_array( NULL, char*, 2 ))) {
8161                         return WERR_NOT_ENOUGH_MEMORY;
8162                 }
8163                 if (!(qlines[0] = talloc_strdup(qlines, SAMBA_PRINTER_PORT_NAME ))) {
8164                         TALLOC_FREE(qlines);
8165                         return WERR_NOT_ENOUGH_MEMORY;
8166                 }
8167                 qlines[1] = NULL;
8168                 numlines = 1;
8169         }
8170         else {
8171                 /* we have a valid enumport command */
8172
8173                 command = talloc_asprintf(ctx, "%s \"%d\"", cmd, 1);
8174                 if (!command) {
8175                         return WERR_NOT_ENOUGH_MEMORY;
8176                 }
8177
8178                 DEBUG(10,("Running [%s]\n", command));
8179                 ret = smbrun(command, &fd, NULL);
8180                 DEBUG(10,("Returned [%d]\n", ret));
8181                 TALLOC_FREE(command);
8182                 if (ret != 0) {
8183                         if (fd != -1) {
8184                                 close(fd);
8185                         }
8186                         return WERR_ACCESS_DENIED;
8187                 }
8188
8189                 numlines = 0;
8190                 qlines = fd_lines_load(fd, &numlines, 0, NULL);
8191                 DEBUGADD(10,("Lines returned = [%d]\n", numlines));
8192                 close(fd);
8193         }
8194
8195         *count = numlines;
8196         *lines = qlines;
8197
8198         return WERR_OK;
8199 }
8200
8201 /****************************************************************************
8202  enumports level 1.
8203 ****************************************************************************/
8204
8205 static WERROR enumports_level_1(TALLOC_CTX *mem_ctx,
8206                                 union spoolss_PortInfo **info_p,
8207                                 uint32_t *count)
8208 {
8209         union spoolss_PortInfo *info = NULL;
8210         int i=0;
8211         WERROR result = WERR_OK;
8212         char **qlines = NULL;
8213         int numlines = 0;
8214
8215         result = enumports_hook(talloc_tos(), &numlines, &qlines );
8216         if (!W_ERROR_IS_OK(result)) {
8217                 goto out;
8218         }
8219
8220         if (numlines) {
8221                 info = talloc_array(mem_ctx, union spoolss_PortInfo, numlines);
8222                 if (!info) {
8223                         DEBUG(10,("Returning WERR_NOT_ENOUGH_MEMORY\n"));
8224                         result = WERR_NOT_ENOUGH_MEMORY;
8225                         goto out;
8226                 }
8227
8228                 for (i=0; i<numlines; i++) {
8229                         DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
8230                         result = fill_port_1(info, &info[i].info1, qlines[i]);
8231                         if (!W_ERROR_IS_OK(result)) {
8232                                 goto out;
8233                         }
8234                 }
8235         }
8236         TALLOC_FREE(qlines);
8237
8238 out:
8239         if (!W_ERROR_IS_OK(result)) {
8240                 TALLOC_FREE(info);
8241                 TALLOC_FREE(qlines);
8242                 *count = 0;
8243                 *info_p = NULL;
8244                 return result;
8245         }
8246
8247         *info_p = info;
8248         *count = numlines;
8249
8250         return WERR_OK;
8251 }
8252
8253 /****************************************************************************
8254  enumports level 2.
8255 ****************************************************************************/
8256
8257 static WERROR enumports_level_2(TALLOC_CTX *mem_ctx,
8258                                 union spoolss_PortInfo **info_p,
8259                                 uint32_t *count)
8260 {
8261         union spoolss_PortInfo *info = NULL;
8262         int i=0;
8263         WERROR result = WERR_OK;
8264         char **qlines = NULL;
8265         int numlines = 0;
8266
8267         result = enumports_hook(talloc_tos(), &numlines, &qlines );
8268         if (!W_ERROR_IS_OK(result)) {
8269                 goto out;
8270         }
8271
8272         if (numlines) {
8273                 info = talloc_array(mem_ctx, union spoolss_PortInfo, numlines);
8274                 if (!info) {
8275                         DEBUG(10,("Returning WERR_NOT_ENOUGH_MEMORY\n"));
8276                         result = WERR_NOT_ENOUGH_MEMORY;
8277                         goto out;
8278                 }
8279
8280                 for (i=0; i<numlines; i++) {
8281                         DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
8282                         result = fill_port_2(info, &info[i].info2, qlines[i]);
8283                         if (!W_ERROR_IS_OK(result)) {
8284                                 goto out;
8285                         }
8286                 }
8287         }
8288         TALLOC_FREE(qlines);
8289
8290 out:
8291         if (!W_ERROR_IS_OK(result)) {
8292                 TALLOC_FREE(info);
8293                 TALLOC_FREE(qlines);
8294                 *count = 0;
8295                 *info_p = NULL;
8296                 return result;
8297         }
8298
8299         *info_p = info;
8300         *count = numlines;
8301
8302         return WERR_OK;
8303 }
8304
8305 /****************************************************************
8306  _spoolss_EnumPorts
8307 ****************************************************************/
8308
8309 WERROR _spoolss_EnumPorts(struct pipes_struct *p,
8310                           struct spoolss_EnumPorts *r)
8311 {
8312         WERROR result;
8313
8314         /* that's an [in out] buffer */
8315
8316         if (!r->in.buffer && (r->in.offered != 0)) {
8317                 return WERR_INVALID_PARAMETER;
8318         }
8319
8320         DEBUG(4,("_spoolss_EnumPorts\n"));
8321
8322         *r->out.count = 0;
8323         *r->out.needed = 0;
8324         *r->out.info = NULL;
8325
8326         switch (r->in.level) {
8327         case 1:
8328                 result = enumports_level_1(p->mem_ctx, r->out.info,
8329                                            r->out.count);
8330                 break;
8331         case 2:
8332                 result = enumports_level_2(p->mem_ctx, r->out.info,
8333                                            r->out.count);
8334                 break;
8335         default:
8336                 return WERR_INVALID_LEVEL;
8337         }
8338
8339         if (!W_ERROR_IS_OK(result)) {
8340                 return result;
8341         }
8342
8343         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8344                                                      spoolss_EnumPorts,
8345                                                      *r->out.info, r->in.level,
8346                                                      *r->out.count);
8347         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8348         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8349
8350         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8351 }
8352
8353 /****************************************************************************
8354 ****************************************************************************/
8355
8356 static WERROR spoolss_addprinterex_level_2(struct pipes_struct *p,
8357                                            const char *server,
8358                                            struct spoolss_SetPrinterInfoCtr *info_ctr,
8359                                            struct spoolss_DeviceMode *devmode,
8360                                            struct security_descriptor *secdesc,
8361                                            struct spoolss_UserLevelCtr *user_ctr,
8362                                            struct policy_handle *handle)
8363 {
8364         struct spoolss_SetPrinterInfo2 *info2 = info_ctr->info.info2;
8365         uint32_t info2_mask = SPOOLSS_PRINTER_INFO_ALL;
8366         int     snum;
8367         WERROR err = WERR_OK;
8368
8369         /* samba does not have a concept of local, non-shared printers yet, so
8370          * make sure we always setup sharename - gd */
8371         if ((info2->sharename == NULL || info2->sharename[0] == '\0') &&
8372             (info2->printername != NULL && info2->printername[0] != '\0')) {
8373                 DEBUG(5, ("spoolss_addprinterex_level_2: "
8374                         "no sharename has been set, setting printername %s as sharename\n",
8375                         info2->printername));
8376                 info2->sharename = info2->printername;
8377         }
8378
8379         /* check to see if the printer already exists */
8380         if ((snum = print_queue_snum(info2->sharename)) != -1) {
8381                 DEBUG(5, ("spoolss_addprinterex_level_2: Attempted to add a printer named [%s] when one already existed!\n",
8382                         info2->sharename));
8383                 return WERR_PRINTER_ALREADY_EXISTS;
8384         }
8385
8386         if (!lp_force_printername(GLOBAL_SECTION_SNUM)) {
8387                 if ((snum = print_queue_snum(info2->printername)) != -1) {
8388                         DEBUG(5, ("spoolss_addprinterex_level_2: Attempted to add a printer named [%s] when one already existed!\n",
8389                                 info2->printername));
8390                         return WERR_PRINTER_ALREADY_EXISTS;
8391                 }
8392         }
8393
8394         /* validate printer info struct */
8395         if (!info2->printername || strlen(info2->printername) == 0) {
8396                 return WERR_INVALID_PRINTER_NAME;
8397         }
8398         if (!info2->portname || strlen(info2->portname) == 0) {
8399                 return WERR_UNKNOWN_PORT;
8400         }
8401         if (!info2->drivername || strlen(info2->drivername) == 0) {
8402                 return WERR_UNKNOWN_PRINTER_DRIVER;
8403         }
8404         if (!info2->printprocessor || strlen(info2->printprocessor) == 0) {
8405                 return WERR_UNKNOWN_PRINTPROCESSOR;
8406         }
8407
8408         /* FIXME!!!  smbd should check to see if the driver is installed before
8409            trying to add a printer like this  --jerry */
8410
8411         if (*lp_addprinter_command(talloc_tos()) ) {
8412                 char *raddr;
8413
8414                 raddr = tsocket_address_inet_addr_string(p->remote_address,
8415                                                          p->mem_ctx);
8416                 if (raddr == NULL) {
8417                         return WERR_NOT_ENOUGH_MEMORY;
8418                 }
8419
8420                 if ( !add_printer_hook(p->mem_ctx, p->session_info->security_token,
8421                                        info2, raddr,
8422                                        p->msg_ctx) ) {
8423                         return WERR_ACCESS_DENIED;
8424                 }
8425         } else {
8426                 DEBUG(0,("spoolss_addprinterex_level_2: add printer for printer %s called and no "
8427                         "smb.conf parameter \"addprinter command\" is defined. This "
8428                         "parameter must exist for this call to succeed\n",
8429                         info2->sharename ));
8430         }
8431
8432         if ((snum = print_queue_snum(info2->sharename)) == -1) {
8433                 return WERR_ACCESS_DENIED;
8434         }
8435
8436         /* you must be a printer admin to add a new printer */
8437         if (!W_ERROR_IS_OK(print_access_check(p->session_info,
8438                                               p->msg_ctx,
8439                                               snum,
8440                                               PRINTER_ACCESS_ADMINISTER))) {
8441                 return WERR_ACCESS_DENIED;
8442         }
8443
8444         /*
8445          * Do sanity check on the requested changes for Samba.
8446          */
8447
8448         if (!check_printer_ok(p->mem_ctx, info2, snum)) {
8449                 return WERR_INVALID_PARAMETER;
8450         }
8451
8452         if (devmode == NULL) {
8453                 info2_mask = ~SPOOLSS_PRINTER_INFO_DEVMODE;
8454         }
8455
8456         err = update_dsspooler(p->mem_ctx,
8457                                get_session_info_system(),
8458                                p->msg_ctx,
8459                                0,
8460                                info2,
8461                                NULL);
8462         if (!W_ERROR_IS_OK(err)) {
8463                 return err;
8464         }
8465
8466         err = winreg_update_printer_internal(p->mem_ctx,
8467                                     get_session_info_system(),
8468                                     p->msg_ctx,
8469                                     info2->sharename,
8470                                     info2_mask,
8471                                     info2,
8472                                     devmode,
8473                                     secdesc);
8474         if (!W_ERROR_IS_OK(err)) {
8475                 return err;
8476         }
8477
8478         err = open_printer_hnd(p, handle, info2->printername, PRINTER_ACCESS_ADMINISTER);
8479         if (!W_ERROR_IS_OK(err)) {
8480                 /* Handle open failed - remove addition. */
8481                 ZERO_STRUCTP(handle);
8482                 return err;
8483         }
8484
8485         return WERR_OK;
8486 }
8487
8488 /****************************************************************
8489  _spoolss_AddPrinterEx
8490 ****************************************************************/
8491
8492 WERROR _spoolss_AddPrinterEx(struct pipes_struct *p,
8493                              struct spoolss_AddPrinterEx *r)
8494 {
8495         switch (r->in.info_ctr->level) {
8496         case 1:
8497                 /* we don't handle yet */
8498                 /* but I know what to do ... */
8499                 return WERR_INVALID_LEVEL;
8500         case 2:
8501                 return spoolss_addprinterex_level_2(p, r->in.server,
8502                                                     r->in.info_ctr,
8503                                                     r->in.devmode_ctr->devmode,
8504                                                     r->in.secdesc_ctr->sd,
8505                                                     r->in.userlevel_ctr,
8506                                                     r->out.handle);
8507         default:
8508                 return WERR_INVALID_LEVEL;
8509         }
8510 }
8511
8512 /****************************************************************
8513  _spoolss_AddPrinter
8514 ****************************************************************/
8515
8516 WERROR _spoolss_AddPrinter(struct pipes_struct *p,
8517                            struct spoolss_AddPrinter *r)
8518 {
8519         struct spoolss_AddPrinterEx a;
8520         struct spoolss_UserLevelCtr userlevel_ctr;
8521
8522         ZERO_STRUCT(userlevel_ctr);
8523
8524         userlevel_ctr.level = 1;
8525
8526         a.in.server             = r->in.server;
8527         a.in.info_ctr           = r->in.info_ctr;
8528         a.in.devmode_ctr        = r->in.devmode_ctr;
8529         a.in.secdesc_ctr        = r->in.secdesc_ctr;
8530         a.in.userlevel_ctr      = &userlevel_ctr;
8531         a.out.handle            = r->out.handle;
8532
8533         return _spoolss_AddPrinterEx(p, &a);
8534 }
8535
8536 /****************************************************************
8537  _spoolss_AddPrinterDriverEx
8538 ****************************************************************/
8539
8540 WERROR _spoolss_AddPrinterDriverEx(struct pipes_struct *p,
8541                                    struct spoolss_AddPrinterDriverEx *r)
8542 {
8543         WERROR err = WERR_OK;
8544         const char *driver_name = NULL;
8545         const char *driver_directory = NULL;
8546         uint32_t version;
8547
8548         /*
8549          * we only support the semantics of AddPrinterDriver()
8550          * i.e. only copy files that are newer than existing ones
8551          */
8552
8553         if (r->in.flags == 0) {
8554                 return WERR_INVALID_PARAMETER;
8555         }
8556
8557         if (!(r->in.flags & APD_COPY_ALL_FILES) &&
8558             !(r->in.flags & APD_COPY_NEW_FILES)) {
8559                 return WERR_ACCESS_DENIED;
8560         }
8561
8562         /* FIXME */
8563         if (r->in.info_ctr->level != 3 &&
8564             r->in.info_ctr->level != 6 &&
8565             r->in.info_ctr->level != 8) {
8566                 DEBUG(0,("%s: level %d not yet implemented\n", __func__,
8567                         r->in.info_ctr->level));
8568                 return WERR_INVALID_LEVEL;
8569         }
8570
8571         DEBUG(5,("Cleaning driver's information\n"));
8572         err = clean_up_driver_struct(p->mem_ctx,
8573                                      p->session_info,
8574                                      r->in.info_ctr,
8575                                      r->in.flags,
8576                                      &driver_directory);
8577         if (!W_ERROR_IS_OK(err)) {
8578                 DBG_ERR("clean_up_driver_struct failed - %s\n",
8579                         win_errstr(err));
8580                 goto done;
8581         }
8582
8583         DEBUG(5,("Moving driver to final destination\n"));
8584         err = move_driver_to_download_area(p->session_info,
8585                                            r->in.info_ctr,
8586                                            driver_directory);
8587         if (!W_ERROR_IS_OK(err)) {
8588                 DBG_ERR("move_driver_to_download_area failed - %s\n",
8589                         win_errstr(err));
8590                 goto done;
8591         }
8592
8593         err = winreg_add_driver_internal(p->mem_ctx,
8594                                 get_session_info_system(),
8595                                 p->msg_ctx,
8596                                 r->in.info_ctr,
8597                                 &driver_name,
8598                                 &version);
8599         if (!W_ERROR_IS_OK(err)) {
8600                 DBG_ERR("winreg_add_driver_internal failed - %s\n",
8601                         win_errstr(err));
8602                 goto done;
8603         }
8604
8605         /*
8606          * I think this is where he DrvUpgradePrinter() hook would be
8607          * be called in a driver's interface DLL on a Windows NT 4.0/2k
8608          * server.  Right now, we just need to send ourselves a message
8609          * to update each printer bound to this driver.   --jerry
8610          */
8611
8612         if (!srv_spoolss_drv_upgrade_printer(driver_name, p->msg_ctx)) {
8613                 DEBUG(0,("%s: Failed to send message about upgrading driver [%s]!\n",
8614                         __func__, driver_name));
8615         }
8616
8617 done:
8618         return err;
8619 }
8620
8621 /****************************************************************
8622  _spoolss_AddPrinterDriver
8623 ****************************************************************/
8624
8625 WERROR _spoolss_AddPrinterDriver(struct pipes_struct *p,
8626                                  struct spoolss_AddPrinterDriver *r)
8627 {
8628         struct spoolss_AddPrinterDriverEx a;
8629
8630         switch (r->in.info_ctr->level) {
8631         case 2:
8632         case 3:
8633         case 4:
8634         case 5:
8635                 break;
8636         default:
8637                 return WERR_INVALID_LEVEL;
8638         }
8639
8640         a.in.servername         = r->in.servername;
8641         a.in.info_ctr           = r->in.info_ctr;
8642         a.in.flags              = APD_COPY_NEW_FILES;
8643
8644         return _spoolss_AddPrinterDriverEx(p, &a);
8645 }
8646
8647 /****************************************************************************
8648 ****************************************************************************/
8649
8650 struct _spoolss_paths {
8651         int type;
8652         const char *share;
8653         const char *dir;
8654 };
8655
8656 enum { SPOOLSS_DRIVER_PATH, SPOOLSS_PRTPROCS_PATH };
8657
8658 static const struct _spoolss_paths spoolss_paths[]= {
8659         { SPOOLSS_DRIVER_PATH,          "print$",       "DRIVERS" },
8660         { SPOOLSS_PRTPROCS_PATH,        "prnproc$",     "PRTPROCS" }
8661 };
8662
8663 static WERROR compose_spoolss_server_path(TALLOC_CTX *mem_ctx,
8664                                           const char *servername,
8665                                           const char *environment,
8666                                           int component,
8667                                           char **path)
8668 {
8669         const char *pservername = NULL;
8670         const char *long_archi;
8671         const char *short_archi;
8672
8673         *path = NULL;
8674
8675         /* environment may be empty */
8676         if (environment && strlen(environment)) {
8677                 long_archi = environment;
8678         } else {
8679                 long_archi = lp_parm_const_string(GLOBAL_SECTION_SNUM,
8680                                                   "spoolss", "architecture",
8681                                                   GLOBAL_SPOOLSS_ARCHITECTURE);
8682         }
8683
8684         /* servername may be empty */
8685         if (servername && strlen(servername)) {
8686                 pservername = canon_servername(servername);
8687
8688                 if (!is_myname_or_ipaddr(pservername)) {
8689                         return WERR_INVALID_PARAMETER;
8690                 }
8691         }
8692
8693         if (!(short_archi = get_short_archi(long_archi))) {
8694                 return WERR_INVALID_ENVIRONMENT;
8695         }
8696
8697         switch (component) {
8698         case SPOOLSS_PRTPROCS_PATH:
8699         case SPOOLSS_DRIVER_PATH:
8700                 if (pservername) {
8701                         *path = talloc_asprintf(mem_ctx,
8702                                         "\\\\%s\\%s\\%s",
8703                                         pservername,
8704                                         spoolss_paths[component].share,
8705                                         short_archi);
8706                 } else {
8707                         *path = talloc_asprintf(mem_ctx, "%s\\%s\\%s",
8708                                         SPOOLSS_DEFAULT_SERVER_PATH,
8709                                         spoolss_paths[component].dir,
8710                                         short_archi);
8711                 }
8712                 break;
8713         default:
8714                 return WERR_INVALID_PARAMETER;
8715         }
8716
8717         if (!*path) {
8718                 return WERR_NOT_ENOUGH_MEMORY;
8719         }
8720
8721         return WERR_OK;
8722 }
8723
8724 /****************************************************************************
8725 ****************************************************************************/
8726
8727 static WERROR getprinterdriverdir_level_1(TALLOC_CTX *mem_ctx,
8728                                           const char *servername,
8729                                           const char *environment,
8730                                           struct spoolss_DriverDirectoryInfo1 *r)
8731 {
8732         WERROR werr;
8733         char *path = NULL;
8734
8735         werr = compose_spoolss_server_path(mem_ctx,
8736                                            servername,
8737                                            environment,
8738                                            SPOOLSS_DRIVER_PATH,
8739                                            &path);
8740         if (!W_ERROR_IS_OK(werr)) {
8741                 return werr;
8742         }
8743
8744         DEBUG(4,("printer driver directory: [%s]\n", path));
8745
8746         r->directory_name = path;
8747
8748         return WERR_OK;
8749 }
8750
8751 /****************************************************************
8752  _spoolss_GetPrinterDriverDirectory
8753 ****************************************************************/
8754
8755 WERROR _spoolss_GetPrinterDriverDirectory(struct pipes_struct *p,
8756                                           struct spoolss_GetPrinterDriverDirectory *r)
8757 {
8758         WERROR werror;
8759
8760         /* that's an [in out] buffer */
8761
8762         if (!r->in.buffer && (r->in.offered != 0)) {
8763                 TALLOC_FREE(r->out.info);
8764                 return WERR_INVALID_PARAMETER;
8765         }
8766
8767         DEBUG(5,("_spoolss_GetPrinterDriverDirectory: level %d\n",
8768                 r->in.level));
8769
8770         *r->out.needed = 0;
8771
8772         /* r->in.level is ignored */
8773
8774         werror = getprinterdriverdir_level_1(p->mem_ctx,
8775                                              r->in.server,
8776                                              r->in.environment,
8777                                              &r->out.info->info1);
8778         if (!W_ERROR_IS_OK(werror)) {
8779                 TALLOC_FREE(r->out.info);
8780                 return werror;
8781         }
8782
8783         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_DriverDirectoryInfo,
8784                                                r->out.info, r->in.level);
8785         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
8786
8787         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8788 }
8789
8790 /****************************************************************
8791  _spoolss_EnumPrinterData
8792 ****************************************************************/
8793
8794 WERROR _spoolss_EnumPrinterData(struct pipes_struct *p,
8795                                 struct spoolss_EnumPrinterData *r)
8796 {
8797         WERROR result;
8798         struct spoolss_EnumPrinterDataEx r2;
8799         uint32_t count;
8800         struct spoolss_PrinterEnumValues *info, *val = NULL;
8801         uint32_t needed;
8802
8803         r2.in.handle    = r->in.handle;
8804         r2.in.key_name  = "PrinterDriverData";
8805         r2.in.offered   = 0;
8806         r2.out.count    = &count;
8807         r2.out.info     = &info;
8808         r2.out.needed   = &needed;
8809
8810         result = _spoolss_EnumPrinterDataEx(p, &r2);
8811         if (W_ERROR_EQUAL(result, WERR_MORE_DATA)) {
8812                 r2.in.offered = needed;
8813                 result = _spoolss_EnumPrinterDataEx(p, &r2);
8814         }
8815         if (!W_ERROR_IS_OK(result)) {
8816                 return result;
8817         }
8818
8819         /*
8820          * The NT machine wants to know the biggest size of value and data
8821          *
8822          * cf: MSDN EnumPrinterData remark section
8823          */
8824
8825         if (!r->in.value_offered && !r->in.data_offered) {
8826                 uint32_t biggest_valuesize = 0;
8827                 uint32_t biggest_datasize = 0;
8828                 int i, name_length;
8829
8830                 DEBUGADD(6,("Activating NT mega-hack to find sizes\n"));
8831
8832                 for (i=0; i<count; i++) {
8833
8834                         name_length = strlen(info[i].value_name);
8835                         if (strlen(info[i].value_name) > biggest_valuesize) {
8836                                 biggest_valuesize = name_length;
8837                         }
8838
8839                         if (info[i].data_length > biggest_datasize) {
8840                                 biggest_datasize = info[i].data_length;
8841                         }
8842
8843                         DEBUG(6,("current values: [%d], [%d]\n", biggest_valuesize,
8844                                 biggest_datasize));
8845                 }
8846
8847                 /* the value is an UNICODE string but real_value_size is the length
8848                    in bytes including the trailing 0 */
8849
8850                 *r->out.value_needed = 2 * (1 + biggest_valuesize);
8851                 *r->out.data_needed  = biggest_datasize;
8852
8853                 DEBUG(6,("final values: [%d], [%d]\n",
8854                         *r->out.value_needed, *r->out.data_needed));
8855
8856                 return WERR_OK;
8857         }
8858
8859         if (r->in.enum_index < count) {
8860                 val = &info[r->in.enum_index];
8861         }
8862
8863         if (val == NULL) {
8864                 /* out_value should default to "" or else NT4 has
8865                    problems unmarshalling the response */
8866
8867                 if (r->in.value_offered) {
8868                         *r->out.value_needed = 1;
8869                         r->out.value_name = talloc_strdup(r, "");
8870                         if (!r->out.value_name) {
8871                                 return WERR_NOT_ENOUGH_MEMORY;
8872                         }
8873                 } else {
8874                         r->out.value_name = NULL;
8875                         *r->out.value_needed = 0;
8876                 }
8877
8878                 /* the data is counted in bytes */
8879
8880                 *r->out.data_needed = r->in.data_offered;
8881
8882                 result = WERR_NO_MORE_ITEMS;
8883         } else {
8884                 /*
8885                  * the value is:
8886                  * - counted in bytes in the request
8887                  * - counted in UNICODE chars in the max reply
8888                  * - counted in bytes in the real size
8889                  *
8890                  * take a pause *before* coding not *during* coding
8891                  */
8892
8893                 /* name */
8894                 if (r->in.value_offered) {
8895                         r->out.value_name = talloc_strdup(r, val->value_name);
8896                         if (!r->out.value_name) {
8897                                 return WERR_NOT_ENOUGH_MEMORY;
8898                         }
8899                         *r->out.value_needed = val->value_name_len;
8900                 } else {
8901                         r->out.value_name = NULL;
8902                         *r->out.value_needed = 0;
8903                 }
8904
8905                 /* type */
8906
8907                 *r->out.type = val->type;
8908
8909                 /* data - counted in bytes */
8910
8911                 /*
8912                  * See the section "Dynamically Typed Query Parameters"
8913                  * in MS-RPRN.
8914                  */
8915
8916                 if (r->out.data && val->data && val->data->data &&
8917                                 val->data_length && r->in.data_offered) {
8918                         memcpy(r->out.data, val->data->data,
8919                                 MIN(val->data_length,r->in.data_offered));
8920                 }
8921
8922                 *r->out.data_needed = val->data_length;
8923
8924                 result = WERR_OK;
8925         }
8926
8927         return result;
8928 }
8929
8930 /****************************************************************
8931  _spoolss_SetPrinterData
8932 ****************************************************************/
8933
8934 WERROR _spoolss_SetPrinterData(struct pipes_struct *p,
8935                                struct spoolss_SetPrinterData *r)
8936 {
8937         struct spoolss_SetPrinterDataEx r2;
8938
8939         r2.in.handle            = r->in.handle;
8940         r2.in.key_name          = "PrinterDriverData";
8941         r2.in.value_name        = r->in.value_name;
8942         r2.in.type              = r->in.type;
8943         r2.in.data              = r->in.data;
8944         r2.in.offered           = r->in.offered;
8945
8946         return _spoolss_SetPrinterDataEx(p, &r2);
8947 }
8948
8949 /****************************************************************
8950  _spoolss_ResetPrinter
8951 ****************************************************************/
8952
8953 WERROR _spoolss_ResetPrinter(struct pipes_struct *p,
8954                              struct spoolss_ResetPrinter *r)
8955 {
8956         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
8957         int             snum;
8958
8959         DEBUG(5,("_spoolss_ResetPrinter\n"));
8960
8961         /*
8962          * All we do is to check to see if the handle and queue is valid.
8963          * This call really doesn't mean anything to us because we only
8964          * support RAW printing.   --jerry
8965          */
8966
8967         if (!Printer) {
8968                 DEBUG(2,("_spoolss_ResetPrinter: Invalid handle (%s:%u:%u).\n",
8969                         OUR_HANDLE(r->in.handle)));
8970                 return WERR_INVALID_HANDLE;
8971         }
8972
8973         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8974                 return WERR_INVALID_HANDLE;
8975
8976
8977         /* blindly return success */
8978         return WERR_OK;
8979 }
8980
8981 /****************************************************************
8982  _spoolss_DeletePrinterData
8983 ****************************************************************/
8984
8985 WERROR _spoolss_DeletePrinterData(struct pipes_struct *p,
8986                                   struct spoolss_DeletePrinterData *r)
8987 {
8988         struct spoolss_DeletePrinterDataEx r2;
8989
8990         r2.in.handle            = r->in.handle;
8991         r2.in.key_name          = "PrinterDriverData";
8992         r2.in.value_name        = r->in.value_name;
8993
8994         return _spoolss_DeletePrinterDataEx(p, &r2);
8995 }
8996
8997 /****************************************************************
8998  _spoolss_AddForm
8999 ****************************************************************/
9000
9001 WERROR _spoolss_AddForm(struct pipes_struct *p,
9002                         struct spoolss_AddForm *r)
9003 {
9004         struct spoolss_AddFormInfo1 *form;
9005         int snum = -1;
9006         WERROR status = WERR_OK;
9007         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
9008         struct dcerpc_binding_handle *b;
9009         TALLOC_CTX *tmp_ctx = NULL;
9010
9011         DEBUG(5,("_spoolss_AddForm\n"));
9012
9013         if (!Printer) {
9014                 DEBUG(2,("_spoolss_AddForm: Invalid handle (%s:%u:%u).\n",
9015                         OUR_HANDLE(r->in.handle)));
9016                 return WERR_INVALID_HANDLE;
9017         }
9018
9019         /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
9020            and not a printer admin, then fail */
9021
9022         if ((p->session_info->unix_token->uid != sec_initial_uid()) &&
9023             !security_token_has_privilege(p->session_info->security_token,
9024                                           SEC_PRIV_PRINT_OPERATOR)) {
9025                 DEBUG(2,("_spoolss_Addform: denied by insufficient permissions.\n"));
9026                 return WERR_ACCESS_DENIED;
9027         }
9028
9029         if (r->in.info_ctr->level != 1) {
9030                 return WERR_INVALID_LEVEL;
9031         }
9032
9033         form = r->in.info_ctr->info.info1;
9034         if (!form) {
9035                 return WERR_INVALID_PARAMETER;
9036         }
9037
9038         switch (form->flags) {
9039         case SPOOLSS_FORM_USER:
9040         case SPOOLSS_FORM_BUILTIN:
9041         case SPOOLSS_FORM_PRINTER:
9042                 break;
9043         default:
9044                 return WERR_INVALID_PARAMETER;
9045         }
9046
9047         tmp_ctx = talloc_new(p->mem_ctx);
9048         if (!tmp_ctx) {
9049                 return WERR_NOT_ENOUGH_MEMORY;
9050         }
9051
9052         status = winreg_printer_binding_handle(tmp_ctx,
9053                                                get_session_info_system(),
9054                                                p->msg_ctx,
9055                                                &b);
9056         if (!W_ERROR_IS_OK(status)) {
9057                 goto done;
9058         }
9059
9060         status = winreg_printer_addform1(tmp_ctx, b, form);
9061         if (!W_ERROR_IS_OK(status)) {
9062                 goto done;
9063         }
9064
9065         /*
9066          * ChangeID must always be set if this is a printer
9067          */
9068         if (Printer->printer_type == SPLHND_PRINTER) {
9069                 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9070                         status = WERR_INVALID_HANDLE;
9071                         goto done;
9072                 }
9073
9074                 status = winreg_printer_update_changeid(tmp_ctx, b,
9075                                                         lp_const_servicename(snum));
9076         }
9077
9078 done:
9079         talloc_free(tmp_ctx);
9080         return status;
9081 }
9082
9083 /****************************************************************
9084  _spoolss_DeleteForm
9085 ****************************************************************/
9086
9087 WERROR _spoolss_DeleteForm(struct pipes_struct *p,
9088                            struct spoolss_DeleteForm *r)
9089 {
9090         const char *form_name = r->in.form_name;
9091         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
9092         int snum = -1;
9093         WERROR status = WERR_OK;
9094         struct dcerpc_binding_handle *b;
9095         TALLOC_CTX *tmp_ctx = NULL;
9096
9097         DEBUG(5,("_spoolss_DeleteForm\n"));
9098
9099         if (!Printer) {
9100                 DEBUG(2,("_spoolss_DeleteForm: Invalid handle (%s:%u:%u).\n",
9101                         OUR_HANDLE(r->in.handle)));
9102                 return WERR_INVALID_HANDLE;
9103         }
9104
9105         if ((p->session_info->unix_token->uid != sec_initial_uid()) &&
9106             !security_token_has_privilege(p->session_info->security_token,
9107                                           SEC_PRIV_PRINT_OPERATOR)) {
9108                 DEBUG(2,("_spoolss_DeleteForm: denied by insufficient permissions.\n"));
9109                 return WERR_ACCESS_DENIED;
9110         }
9111
9112         tmp_ctx = talloc_new(p->mem_ctx);
9113         if (!tmp_ctx) {
9114                 return WERR_NOT_ENOUGH_MEMORY;
9115         }
9116
9117         status = winreg_printer_binding_handle(tmp_ctx,
9118                                                get_session_info_system(),
9119                                                p->msg_ctx,
9120                                                &b);
9121         if (!W_ERROR_IS_OK(status)) {
9122                 goto done;
9123         }
9124
9125         status = winreg_printer_deleteform1(tmp_ctx, b, form_name);
9126         if (!W_ERROR_IS_OK(status)) {
9127                 goto done;
9128         }
9129
9130         /*
9131          * ChangeID must always be set if this is a printer
9132          */
9133         if (Printer->printer_type == SPLHND_PRINTER) {
9134                 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9135                         status = WERR_INVALID_HANDLE;
9136                         goto done;
9137                 }
9138
9139                 status = winreg_printer_update_changeid(tmp_ctx, b,
9140                                                         lp_const_servicename(snum));
9141         }
9142
9143 done:
9144         talloc_free(tmp_ctx);
9145         return status;
9146 }
9147
9148 /****************************************************************
9149  _spoolss_SetForm
9150 ****************************************************************/
9151
9152 WERROR _spoolss_SetForm(struct pipes_struct *p,
9153                         struct spoolss_SetForm *r)
9154 {
9155         struct spoolss_AddFormInfo1 *form;
9156         const char *form_name = r->in.form_name;
9157         int snum = -1;
9158         WERROR status = WERR_OK;
9159         struct dcerpc_binding_handle *b;
9160         TALLOC_CTX *tmp_ctx = NULL;
9161
9162         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
9163
9164         DEBUG(5,("_spoolss_SetForm\n"));
9165
9166         if (!Printer) {
9167                 DEBUG(2,("_spoolss_SetForm: Invalid handle (%s:%u:%u).\n",
9168                         OUR_HANDLE(r->in.handle)));
9169                 return WERR_INVALID_HANDLE;
9170         }
9171
9172         /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
9173            and not a printer admin, then fail */
9174
9175         if ((p->session_info->unix_token->uid != sec_initial_uid()) &&
9176              !security_token_has_privilege(p->session_info->security_token,
9177                                            SEC_PRIV_PRINT_OPERATOR)) {
9178                 DEBUG(2,("_spoolss_Setform: denied by insufficient permissions.\n"));
9179                 return WERR_ACCESS_DENIED;
9180         }
9181
9182         if (r->in.info_ctr->level != 1) {
9183                 return WERR_INVALID_LEVEL;
9184         }
9185
9186         form = r->in.info_ctr->info.info1;
9187         if (!form) {
9188                 return WERR_INVALID_PARAMETER;
9189         }
9190
9191         tmp_ctx = talloc_new(p->mem_ctx);
9192         if (!tmp_ctx) {
9193                 return WERR_NOT_ENOUGH_MEMORY;
9194         }
9195
9196         status = winreg_printer_binding_handle(tmp_ctx,
9197                                                get_session_info_system(),
9198                                                p->msg_ctx,
9199                                                &b);
9200         if (!W_ERROR_IS_OK(status)) {
9201                 goto done;
9202         }
9203
9204         status = winreg_printer_setform1(tmp_ctx, b,
9205                                          form_name,
9206                                          form);
9207         if (!W_ERROR_IS_OK(status)) {
9208                 goto done;
9209         }
9210
9211         /*
9212          * ChangeID must always be set if this is a printer
9213          */
9214         if (Printer->printer_type == SPLHND_PRINTER) {
9215                 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9216                         status = WERR_INVALID_HANDLE;
9217                         goto done;
9218                 }
9219
9220                 status = winreg_printer_update_changeid(tmp_ctx, b,
9221                                                         lp_const_servicename(snum));
9222         }
9223
9224 done:
9225         talloc_free(tmp_ctx);
9226         return status;
9227 }
9228
9229 /****************************************************************************
9230  fill_print_processor1
9231 ****************************************************************************/
9232
9233 static WERROR fill_print_processor1(TALLOC_CTX *mem_ctx,
9234                                     struct spoolss_PrintProcessorInfo1 *r,
9235                                     const char *print_processor_name)
9236 {
9237         r->print_processor_name = talloc_strdup(mem_ctx, print_processor_name);
9238         W_ERROR_HAVE_NO_MEMORY(r->print_processor_name);
9239
9240         return WERR_OK;
9241 }
9242
9243 /****************************************************************************
9244  enumprintprocessors level 1.
9245 ****************************************************************************/
9246
9247 static WERROR enumprintprocessors_level_1(TALLOC_CTX *mem_ctx,
9248                                           union spoolss_PrintProcessorInfo **info_p,
9249                                           uint32_t *count)
9250 {
9251         union spoolss_PrintProcessorInfo *info;
9252         WERROR result;
9253
9254         info = talloc_array(mem_ctx, union spoolss_PrintProcessorInfo, 1);
9255         W_ERROR_HAVE_NO_MEMORY(info);
9256
9257         *count = 1;
9258
9259         result = fill_print_processor1(info, &info[0].info1, "winprint");
9260         if (!W_ERROR_IS_OK(result)) {
9261                 goto out;
9262         }
9263
9264  out:
9265         if (!W_ERROR_IS_OK(result)) {
9266                 TALLOC_FREE(info);
9267                 *count = 0;
9268                 return result;
9269         }
9270
9271         *info_p = info;
9272
9273         return WERR_OK;
9274 }
9275
9276 /****************************************************************
9277  _spoolss_EnumPrintProcessors
9278 ****************************************************************/
9279
9280 WERROR _spoolss_EnumPrintProcessors(struct pipes_struct *p,
9281                                     struct spoolss_EnumPrintProcessors *r)
9282 {
9283         WERROR result;
9284
9285         /* that's an [in out] buffer */
9286
9287         if (!r->in.buffer && (r->in.offered != 0)) {
9288                 return WERR_INVALID_PARAMETER;
9289         }
9290
9291         DEBUG(5,("_spoolss_EnumPrintProcessors\n"));
9292
9293         /*
9294          * Enumerate the print processors ...
9295          *
9296          * Just reply with "winprint", to keep NT happy
9297          * and I can use my nice printer checker.
9298          */
9299
9300         *r->out.count = 0;
9301         *r->out.needed = 0;
9302         *r->out.info = NULL;
9303
9304         if (!get_short_archi(r->in.environment)) {
9305                 return WERR_INVALID_ENVIRONMENT;
9306         }
9307
9308         switch (r->in.level) {
9309         case 1:
9310                 result = enumprintprocessors_level_1(p->mem_ctx, r->out.info,
9311                                                      r->out.count);
9312                 break;
9313         default:
9314                 return WERR_INVALID_LEVEL;
9315         }
9316
9317         if (!W_ERROR_IS_OK(result)) {
9318                 return result;
9319         }
9320
9321         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
9322                                                      spoolss_EnumPrintProcessors,
9323                                                      *r->out.info, r->in.level,
9324                                                      *r->out.count);
9325         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
9326         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
9327
9328         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
9329 }
9330
9331 /****************************************************************************
9332  fill_printprocdatatype1
9333 ****************************************************************************/
9334
9335 static WERROR fill_printprocdatatype1(TALLOC_CTX *mem_ctx,
9336                                       struct spoolss_PrintProcDataTypesInfo1 *r,
9337                                       const char *name_array)
9338 {
9339         r->name_array = talloc_strdup(mem_ctx, name_array);
9340         W_ERROR_HAVE_NO_MEMORY(r->name_array);
9341
9342         return WERR_OK;
9343 }
9344
9345 /****************************************************************************
9346  enumprintprocdatatypes level 1.
9347 ****************************************************************************/
9348
9349 static WERROR enumprintprocdatatypes_level_1(TALLOC_CTX *mem_ctx,
9350                                              union spoolss_PrintProcDataTypesInfo **info_p,
9351                                              uint32_t *count)
9352 {
9353         WERROR result;
9354         union spoolss_PrintProcDataTypesInfo *info;
9355
9356         info = talloc_array(mem_ctx, union spoolss_PrintProcDataTypesInfo, 1);
9357         W_ERROR_HAVE_NO_MEMORY(info);
9358
9359         *count = 1;
9360
9361         result = fill_printprocdatatype1(info, &info[0].info1, "RAW");
9362         if (!W_ERROR_IS_OK(result)) {
9363                 goto out;
9364         }
9365
9366  out:
9367         if (!W_ERROR_IS_OK(result)) {
9368                 TALLOC_FREE(info);
9369                 *count = 0;
9370                 return result;
9371         }
9372
9373         *info_p = info;
9374
9375         return WERR_OK;
9376 }
9377
9378 /****************************************************************
9379  _spoolss_EnumPrintProcessorDataTypes
9380 ****************************************************************/
9381
9382 WERROR _spoolss_EnumPrintProcessorDataTypes(struct pipes_struct *p,
9383                                             struct spoolss_EnumPrintProcessorDataTypes *r)
9384 {
9385         WERROR result;
9386
9387         /* that's an [in out] buffer */
9388
9389         if (!r->in.buffer && (r->in.offered != 0)) {
9390                 return WERR_INVALID_PARAMETER;
9391         }
9392
9393         DEBUG(5,("_spoolss_EnumPrintProcessorDataTypes\n"));
9394
9395         *r->out.count = 0;
9396         *r->out.needed = 0;
9397         *r->out.info = NULL;
9398
9399         if (r->in.print_processor_name == NULL ||
9400             !strequal(r->in.print_processor_name, "winprint")) {
9401                 return WERR_UNKNOWN_PRINTPROCESSOR;
9402         }
9403
9404         switch (r->in.level) {
9405         case 1:
9406                 result = enumprintprocdatatypes_level_1(p->mem_ctx, r->out.info,
9407                                                         r->out.count);
9408                 break;
9409         default:
9410                 return WERR_INVALID_LEVEL;
9411         }
9412
9413         if (!W_ERROR_IS_OK(result)) {
9414                 return result;
9415         }
9416
9417         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
9418                                                      spoolss_EnumPrintProcessorDataTypes,
9419                                                      *r->out.info, r->in.level,
9420                                                      *r->out.count);
9421         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
9422         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
9423
9424         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
9425 }
9426
9427 /****************************************************************************
9428  fill_monitor_1
9429 ****************************************************************************/
9430
9431 static WERROR fill_monitor_1(TALLOC_CTX *mem_ctx,
9432                              struct spoolss_MonitorInfo1 *r,
9433                              const char *monitor_name)
9434 {
9435         r->monitor_name                 = talloc_strdup(mem_ctx, monitor_name);
9436         W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
9437
9438         return WERR_OK;
9439 }
9440
9441 /****************************************************************************
9442  fill_monitor_2
9443 ****************************************************************************/
9444
9445 static WERROR fill_monitor_2(TALLOC_CTX *mem_ctx,
9446                              struct spoolss_MonitorInfo2 *r,
9447                              const char *monitor_name,
9448                              const char *environment,
9449                              const char *dll_name)
9450 {
9451         r->monitor_name                 = talloc_strdup(mem_ctx, monitor_name);
9452         W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
9453         r->environment                  = talloc_strdup(mem_ctx, environment);
9454         W_ERROR_HAVE_NO_MEMORY(r->environment);
9455         r->dll_name                     = talloc_strdup(mem_ctx, dll_name);
9456         W_ERROR_HAVE_NO_MEMORY(r->dll_name);
9457
9458         return WERR_OK;
9459 }
9460
9461 /****************************************************************************
9462  enumprintmonitors level 1.
9463 ****************************************************************************/
9464
9465 static WERROR enumprintmonitors_level_1(TALLOC_CTX *mem_ctx,
9466                                         union spoolss_MonitorInfo **info_p,
9467                                         uint32_t *count)
9468 {
9469         union spoolss_MonitorInfo *info;
9470         WERROR result = WERR_OK;
9471
9472         info = talloc_array(mem_ctx, union spoolss_MonitorInfo, 2);
9473         W_ERROR_HAVE_NO_MEMORY(info);
9474
9475         *count = 2;
9476
9477         result = fill_monitor_1(info, &info[0].info1,
9478                                 SPL_LOCAL_PORT);
9479         if (!W_ERROR_IS_OK(result)) {
9480                 goto out;
9481         }
9482
9483         result = fill_monitor_1(info, &info[1].info1,
9484                                 SPL_TCPIP_PORT);
9485         if (!W_ERROR_IS_OK(result)) {
9486                 goto out;
9487         }
9488
9489 out:
9490         if (!W_ERROR_IS_OK(result)) {
9491                 TALLOC_FREE(info);
9492                 *count = 0;
9493                 return result;
9494         }
9495
9496         *info_p = info;
9497
9498         return WERR_OK;
9499 }
9500
9501 /****************************************************************************
9502  enumprintmonitors level 2.
9503 ****************************************************************************/
9504
9505 static WERROR enumprintmonitors_level_2(TALLOC_CTX *mem_ctx,
9506                                         union spoolss_MonitorInfo **info_p,
9507                                         uint32_t *count)
9508 {
9509         union spoolss_MonitorInfo *info;
9510         WERROR result = WERR_OK;
9511         const char *architecture;
9512
9513         info = talloc_array(mem_ctx, union spoolss_MonitorInfo, 2);
9514         W_ERROR_HAVE_NO_MEMORY(info);
9515
9516         *count = 2;
9517
9518         architecture = lp_parm_const_string(GLOBAL_SECTION_SNUM,
9519                                             "spoolss",
9520                                             "architecture",
9521                                             GLOBAL_SPOOLSS_ARCHITECTURE);
9522
9523         result = fill_monitor_2(info, &info[0].info2,
9524                                 SPL_LOCAL_PORT,
9525                                 architecture,
9526                                 "localmon.dll");
9527         if (!W_ERROR_IS_OK(result)) {
9528                 goto out;
9529         }
9530
9531         result = fill_monitor_2(info, &info[1].info2,
9532                                 SPL_TCPIP_PORT,
9533                                 architecture,
9534                                 "tcpmon.dll");
9535         if (!W_ERROR_IS_OK(result)) {
9536                 goto out;
9537         }
9538
9539 out:
9540         if (!W_ERROR_IS_OK(result)) {
9541                 TALLOC_FREE(info);
9542                 *count = 0;
9543                 return result;
9544         }
9545
9546         *info_p = info;
9547
9548         return WERR_OK;
9549 }
9550
9551 /****************************************************************
9552  _spoolss_EnumMonitors
9553 ****************************************************************/
9554
9555 WERROR _spoolss_EnumMonitors(struct pipes_struct *p,
9556                              struct spoolss_EnumMonitors *r)
9557 {
9558         WERROR result;
9559
9560         /* that's an [in out] buffer */
9561
9562         if (!r->in.buffer && (r->in.offered != 0)) {
9563                 return WERR_INVALID_PARAMETER;
9564         }
9565
9566         DEBUG(5,("_spoolss_EnumMonitors\n"));
9567
9568         /*
9569          * Enumerate the print monitors ...
9570          *
9571          * Just reply with "Local Port", to keep NT happy
9572          * and I can use my nice printer checker.
9573          */
9574
9575         *r->out.count = 0;
9576         *r->out.needed = 0;
9577         *r->out.info = NULL;
9578
9579         switch (r->in.level) {
9580         case 1:
9581                 result = enumprintmonitors_level_1(p->mem_ctx, r->out.info,
9582                                                    r->out.count);
9583                 break;
9584         case 2:
9585                 result = enumprintmonitors_level_2(p->mem_ctx, r->out.info,
9586                                                    r->out.count);
9587                 break;
9588         default:
9589                 return WERR_INVALID_LEVEL;
9590         }
9591
9592         if (!W_ERROR_IS_OK(result)) {
9593                 return result;
9594         }
9595
9596         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
9597                                                      spoolss_EnumMonitors,
9598                                                      *r->out.info, r->in.level,
9599                                                      *r->out.count);
9600         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
9601         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
9602
9603         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
9604 }
9605
9606 /****************************************************************************
9607 ****************************************************************************/
9608
9609 static WERROR getjob_level_1(TALLOC_CTX *mem_ctx,
9610                              const print_queue_struct *queue,
9611                              int count, int snum,
9612                              struct spoolss_PrinterInfo2 *pinfo2,
9613                              uint32_t jobid,
9614                              int sysjob,
9615                              struct spoolss_JobInfo1 *r)
9616 {
9617         int i = 0;
9618         bool found = false;
9619
9620         for (i=0; i<count; i++) {
9621                 if (queue[i].sysjob == sysjob) {
9622                         found = true;
9623                         break;
9624                 }
9625         }
9626
9627         if (found == false) {
9628                 /* NT treats not found as bad param... yet another bad choice */
9629                 return WERR_INVALID_PARAMETER;
9630         }
9631
9632         return fill_job_info1(mem_ctx,
9633                               r,
9634                               &queue[i],
9635                               jobid,
9636                               i,
9637                               snum,
9638                               pinfo2);
9639 }
9640
9641 /****************************************************************************
9642 ****************************************************************************/
9643
9644 static WERROR getjob_level_2(TALLOC_CTX *mem_ctx,
9645                              const print_queue_struct *queue,
9646                              int count, int snum,
9647                              struct spoolss_PrinterInfo2 *pinfo2,
9648                              uint32_t jobid,
9649                              int sysjob,
9650                              struct spoolss_JobInfo2 *r)
9651 {
9652         int i = 0;
9653         bool found = false;
9654         struct spoolss_DeviceMode *devmode;
9655         WERROR result;
9656
9657         for (i=0; i<count; i++) {
9658                 if (queue[i].sysjob == sysjob) {
9659                         found = true;
9660                         break;
9661                 }
9662         }
9663
9664         if (found == false) {
9665                 /* NT treats not found as bad param... yet another bad
9666                    choice */
9667                 return WERR_INVALID_PARAMETER;
9668         }
9669
9670         /*
9671          * if the print job does not have a DEVMODE associated with it,
9672          * just use the one for the printer. A NULL devicemode is not
9673          *  a failure condition
9674          */
9675
9676         devmode = print_job_devmode(mem_ctx, lp_const_servicename(snum), jobid);
9677         if (!devmode) {
9678                 result = spoolss_create_default_devmode(mem_ctx,
9679                                                 pinfo2->printername,
9680                                                 &devmode);
9681                 if (!W_ERROR_IS_OK(result)) {
9682                         DEBUG(3, ("Can't proceed w/o a devmode!"));
9683                         return result;
9684                 }
9685         }
9686
9687         return fill_job_info2(mem_ctx,
9688                               r,
9689                               &queue[i],
9690                               jobid,
9691                               i,
9692                               snum,
9693                               pinfo2,
9694                               devmode);
9695 }
9696
9697 /****************************************************************
9698  _spoolss_GetJob
9699 ****************************************************************/
9700
9701 WERROR _spoolss_GetJob(struct pipes_struct *p,
9702                        struct spoolss_GetJob *r)
9703 {
9704         WERROR result = WERR_OK;
9705         struct spoolss_PrinterInfo2 *pinfo2 = NULL;
9706         const char *svc_name;
9707         int sysjob;
9708         int snum;
9709         int count;
9710         struct tdb_print_db *pdb;
9711         print_queue_struct      *queue = NULL;
9712         print_status_struct prt_status;
9713
9714         /* that's an [in out] buffer */
9715
9716         if (!r->in.buffer && (r->in.offered != 0)) {
9717                 result = WERR_INVALID_PARAMETER;
9718                 goto err_jinfo_free;
9719         }
9720
9721         DEBUG(5,("_spoolss_GetJob\n"));
9722
9723         *r->out.needed = 0;
9724
9725         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9726                 result = WERR_INVALID_HANDLE;
9727                 goto err_jinfo_free;
9728         }
9729
9730         svc_name = lp_const_servicename(snum);
9731         if (svc_name == NULL) {
9732                 result = WERR_INVALID_PARAMETER;
9733                 goto err_jinfo_free;
9734         }
9735
9736         result = winreg_get_printer_internal(p->mem_ctx,
9737                                     get_session_info_system(),
9738                                     p->msg_ctx,
9739                                     svc_name,
9740                                     &pinfo2);
9741         if (!W_ERROR_IS_OK(result)) {
9742                 goto err_jinfo_free;
9743         }
9744
9745         pdb = get_print_db_byname(svc_name);
9746         if (pdb == NULL) {
9747                 DEBUG(3, ("failed to get print db for svc %s\n", svc_name));
9748                 result = WERR_INVALID_PARAMETER;
9749                 goto err_pinfo_free;
9750         }
9751
9752         sysjob = jobid_to_sysjob_pdb(pdb, r->in.job_id);
9753         release_print_db(pdb);
9754         if (sysjob == -1) {
9755                 DEBUG(3, ("no sysjob for spoolss jobid %u\n", r->in.job_id));
9756                 result = WERR_INVALID_PARAMETER;
9757                 goto err_pinfo_free;
9758         }
9759
9760         count = print_queue_status(p->msg_ctx, snum, &queue, &prt_status);
9761
9762         DEBUGADD(4,("count:[%d], prt_status:[%d], [%s]\n",
9763                      count, prt_status.status, prt_status.message));
9764
9765         switch (r->in.level) {
9766         case 1:
9767                 result = getjob_level_1(p->mem_ctx,
9768                                         queue, count, snum, pinfo2,
9769                                         r->in.job_id, sysjob,
9770                                         &r->out.info->info1);
9771                 break;
9772         case 2:
9773                 result = getjob_level_2(p->mem_ctx,
9774                                         queue, count, snum, pinfo2,
9775                                         r->in.job_id, sysjob,
9776                                         &r->out.info->info2);
9777                 break;
9778         default:
9779                 result = WERR_INVALID_LEVEL;
9780                 break;
9781         }
9782
9783         SAFE_FREE(queue);
9784         TALLOC_FREE(pinfo2);
9785
9786         if (!W_ERROR_IS_OK(result)) {
9787                 goto err_jinfo_free;
9788         }
9789
9790         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_JobInfo, r->out.info,
9791                                                                                    r->in.level);
9792         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
9793
9794         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
9795
9796 err_pinfo_free:
9797         TALLOC_FREE(pinfo2);
9798 err_jinfo_free:
9799         TALLOC_FREE(r->out.info);
9800         return result;
9801 }
9802
9803 /****************************************************************
9804  _spoolss_GetPrinterDataEx
9805 ****************************************************************/
9806
9807 WERROR _spoolss_GetPrinterDataEx(struct pipes_struct *p,
9808                                  struct spoolss_GetPrinterDataEx *r)
9809 {
9810
9811         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
9812         const char *printer;
9813         int                     snum = 0;
9814         WERROR result = WERR_OK;
9815         DATA_BLOB blob;
9816         enum winreg_Type val_type = REG_NONE;
9817         uint8_t *val_data = NULL;
9818         uint32_t val_size = 0;
9819         struct dcerpc_binding_handle *b;
9820         TALLOC_CTX *tmp_ctx;
9821
9822         DEBUG(4,("_spoolss_GetPrinterDataEx\n"));
9823
9824         DEBUG(10, ("_spoolss_GetPrinterDataEx: key => [%s], value => [%s]\n",
9825                 r->in.key_name, r->in.value_name));
9826
9827         /* in case of problem, return some default values */
9828
9829         *r->out.needed  = 0;
9830         *r->out.type    = REG_NONE;
9831
9832         tmp_ctx = talloc_new(p->mem_ctx);
9833         if (!tmp_ctx) {
9834                 return WERR_NOT_ENOUGH_MEMORY;
9835         }
9836
9837         if (!Printer) {
9838                 DEBUG(2,("_spoolss_GetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
9839                         OUR_HANDLE(r->in.handle)));
9840                 result = WERR_INVALID_HANDLE;
9841                 goto done;
9842         }
9843
9844         /* Is the handle to a printer or to the server? */
9845
9846         if (Printer->printer_type == SPLHND_SERVER) {
9847
9848                 union spoolss_PrinterData data;
9849
9850                 result = getprinterdata_printer_server(tmp_ctx,
9851                                                        r->in.value_name,
9852                                                        r->out.type,
9853                                                        &data);
9854                 if (!W_ERROR_IS_OK(result)) {
9855                         goto done;
9856                 }
9857
9858                 result = push_spoolss_PrinterData(tmp_ctx, &blob,
9859                                                   *r->out.type, &data);
9860                 if (!W_ERROR_IS_OK(result)) {
9861                         goto done;
9862                 }
9863
9864                 *r->out.needed = blob.length;
9865
9866                 if (r->in.offered >= *r->out.needed) {
9867                         memcpy(r->out.data, blob.data, blob.length);
9868                 }
9869
9870                 result = WERR_OK;
9871                 goto done;
9872         }
9873
9874         /* check to see if the keyname is valid */
9875         if (!strlen(r->in.key_name)) {
9876                 result = WERR_INVALID_PARAMETER;
9877                 goto done;
9878         }
9879
9880         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9881                 result = WERR_INVALID_HANDLE;
9882                 goto done;
9883         }
9884         printer = lp_const_servicename(snum);
9885
9886         result = winreg_printer_binding_handle(tmp_ctx,
9887                                                get_session_info_system(),
9888                                                p->msg_ctx,
9889                                                &b);
9890         if (!W_ERROR_IS_OK(result)) {
9891                 goto done;
9892         }
9893
9894         /* XP sends this and wants the ChangeID value from PRINTER_INFO_0 */
9895         if (strequal(r->in.key_name, SPOOL_PRINTERDATA_KEY) &&
9896             strequal(r->in.value_name, "ChangeId")) {
9897                 *r->out.type = REG_DWORD;
9898                 *r->out.needed = 4;
9899                 if (r->in.offered >= *r->out.needed) {
9900                         uint32_t changeid = 0;
9901
9902                         result = winreg_printer_get_changeid(tmp_ctx, b,
9903                                                              printer,
9904                                                              &changeid);
9905                         if (!W_ERROR_IS_OK(result)) {
9906                                 goto done;
9907                         }
9908
9909                         SIVAL(r->out.data, 0, changeid);
9910                         result = WERR_OK;
9911                 }
9912                 goto done;
9913         }
9914
9915         result = winreg_get_printer_dataex(tmp_ctx, b,
9916                                            printer,
9917                                            r->in.key_name,
9918                                            r->in.value_name,
9919                                            &val_type,
9920                                            &val_data,
9921                                            &val_size);
9922         if (!W_ERROR_IS_OK(result)) {
9923                 goto done;
9924         }
9925
9926         *r->out.needed = val_size;
9927         *r->out.type = val_type;
9928
9929         if (r->in.offered >= *r->out.needed) {
9930                 memcpy(r->out.data, val_data, val_size);
9931         }
9932
9933 done:
9934         /* NOTE: do not replace type when returning WERR_MORE_DATA */
9935
9936         if (W_ERROR_IS_OK(result)) {
9937                 result = SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
9938         }
9939
9940         talloc_free(tmp_ctx);
9941         return result;
9942 }
9943
9944 /****************************************************************
9945  _spoolss_SetPrinterDataEx
9946 ****************************************************************/
9947
9948 WERROR _spoolss_SetPrinterDataEx(struct pipes_struct *p,
9949                                  struct spoolss_SetPrinterDataEx *r)
9950 {
9951         struct spoolss_PrinterInfo2 *pinfo2 = NULL;
9952         int                     snum = 0;
9953         WERROR                  result = WERR_OK;
9954         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
9955         char                    *oid_string;
9956         struct dcerpc_binding_handle *b;
9957         TALLOC_CTX *tmp_ctx;
9958
9959         DEBUG(4,("_spoolss_SetPrinterDataEx\n"));
9960
9961         /* From MSDN documentation of SetPrinterDataEx: pass request to
9962            SetPrinterData if key is "PrinterDriverData" */
9963
9964         if (!Printer) {
9965                 DEBUG(2,("_spoolss_SetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
9966                         OUR_HANDLE(r->in.handle)));
9967                 return WERR_INVALID_HANDLE;
9968         }
9969
9970         if (Printer->printer_type == SPLHND_SERVER) {
9971                 DEBUG(10,("_spoolss_SetPrinterDataEx: "
9972                         "Not implemented for server handles yet\n"));
9973                 return WERR_INVALID_PARAMETER;
9974         }
9975
9976         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9977                 return WERR_INVALID_HANDLE;
9978         }
9979
9980         /*
9981          * Access check : NT returns "access denied" if you make a
9982          * SetPrinterData call without the necessary privildge.
9983          * we were originally returning OK if nothing changed
9984          * which made Win2k issue **a lot** of SetPrinterData
9985          * when connecting to a printer  --jerry
9986          */
9987
9988         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9989                 DEBUG(3, ("_spoolss_SetPrinterDataEx: "
9990                         "change denied by handle access permissions\n"));
9991                 return WERR_ACCESS_DENIED;
9992         }
9993
9994         tmp_ctx = talloc_new(p->mem_ctx);
9995         if (!tmp_ctx) {
9996                 return WERR_NOT_ENOUGH_MEMORY;
9997         }
9998
9999         result = winreg_printer_binding_handle(tmp_ctx,
10000                                                get_session_info_system(),
10001                                                p->msg_ctx,
10002                                                &b);
10003         if (!W_ERROR_IS_OK(result)) {
10004                 goto done;
10005         }
10006
10007         result = winreg_get_printer(tmp_ctx, b,
10008                                     lp_servicename(talloc_tos(), snum),
10009                                     &pinfo2);
10010         if (!W_ERROR_IS_OK(result)) {
10011                 goto done;
10012         }
10013
10014         /* check for OID in valuename */
10015
10016         oid_string = strchr(r->in.value_name, ',');
10017         if (oid_string) {
10018                 *oid_string = '\0';
10019                 oid_string++;
10020         }
10021
10022         /* save the registry data */
10023
10024         result = winreg_set_printer_dataex(tmp_ctx, b,
10025                                            pinfo2->sharename,
10026                                            r->in.key_name,
10027                                            r->in.value_name,
10028                                            r->in.type,
10029                                            r->in.data,
10030                                            r->in.offered);
10031
10032         if (W_ERROR_IS_OK(result)) {
10033                 /* save the OID if one was specified */
10034                 if (oid_string) {
10035                         char *str = talloc_asprintf(tmp_ctx, "%s\\%s",
10036                                 r->in.key_name, SPOOL_OID_KEY);
10037                         if (!str) {
10038                                 result = WERR_NOT_ENOUGH_MEMORY;
10039                                 goto done;
10040                         }
10041
10042                         /*
10043                          * I'm not checking the status here on purpose.  Don't know
10044                          * if this is right, but I'm returning the status from the
10045                          * previous set_printer_dataex() call.  I have no idea if
10046                          * this is right.    --jerry
10047                          */
10048                         winreg_set_printer_dataex(tmp_ctx, b,
10049                                                   pinfo2->sharename,
10050                                                   str,
10051                                                   r->in.value_name,
10052                                                   REG_SZ,
10053                                                   (uint8_t *) oid_string,
10054                                                   strlen(oid_string) + 1);
10055                 }
10056
10057                 result = winreg_printer_update_changeid(tmp_ctx, b,
10058                                                         lp_const_servicename(snum));
10059
10060         }
10061
10062 done:
10063         talloc_free(tmp_ctx);
10064         return result;
10065 }
10066
10067 /****************************************************************
10068  _spoolss_DeletePrinterDataEx
10069 ****************************************************************/
10070
10071 WERROR _spoolss_DeletePrinterDataEx(struct pipes_struct *p,
10072                                     struct spoolss_DeletePrinterDataEx *r)
10073 {
10074         const char *printer;
10075         int             snum=0;
10076         WERROR          status = WERR_OK;
10077         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
10078
10079         DEBUG(5,("_spoolss_DeletePrinterDataEx\n"));
10080
10081         if (!Printer) {
10082                 DEBUG(2,("_spoolss_DeletePrinterDataEx: "
10083                         "Invalid handle (%s:%u:%u).\n",
10084                         OUR_HANDLE(r->in.handle)));
10085                 return WERR_INVALID_HANDLE;
10086         }
10087
10088         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
10089                 DEBUG(3, ("_spoolss_DeletePrinterDataEx: "
10090                         "printer properties change denied by handle\n"));
10091                 return WERR_ACCESS_DENIED;
10092         }
10093
10094         if (!r->in.value_name || !r->in.key_name) {
10095                 return WERR_NOT_ENOUGH_MEMORY;
10096         }
10097
10098         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
10099                 return WERR_INVALID_HANDLE;
10100         }
10101         printer = lp_const_servicename(snum);
10102
10103         status = winreg_delete_printer_dataex_internal(p->mem_ctx,
10104                                               get_session_info_system(),
10105                                               p->msg_ctx,
10106                                               printer,
10107                                               r->in.key_name,
10108                                               r->in.value_name);
10109         if (W_ERROR_IS_OK(status)) {
10110                 status = winreg_printer_update_changeid_internal(p->mem_ctx,
10111                                                         get_session_info_system(),
10112                                                         p->msg_ctx,
10113                                                         printer);
10114         }
10115
10116         return status;
10117 }
10118
10119 /****************************************************************
10120  _spoolss_EnumPrinterKey
10121 ****************************************************************/
10122
10123 WERROR _spoolss_EnumPrinterKey(struct pipes_struct *p,
10124                                struct spoolss_EnumPrinterKey *r)
10125 {
10126         uint32_t        num_keys;
10127         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
10128         int             snum = 0;
10129         WERROR          result = WERR_FILE_NOT_FOUND;
10130         const char **array = NULL;
10131         DATA_BLOB blob;
10132
10133         DEBUG(4,("_spoolss_EnumPrinterKey\n"));
10134
10135         if (!Printer) {
10136                 DEBUG(2,("_spoolss_EnumPrinterKey: Invalid handle (%s:%u:%u).\n",
10137                         OUR_HANDLE(r->in.handle)));
10138                 return WERR_INVALID_HANDLE;
10139         }
10140
10141         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
10142                 return WERR_INVALID_HANDLE;
10143         }
10144
10145         result = winreg_enum_printer_key_internal(p->mem_ctx,
10146                                          get_session_info_system(),
10147                                          p->msg_ctx,
10148                                          lp_const_servicename(snum),
10149                                          r->in.key_name,
10150                                          &num_keys,
10151                                          &array);
10152         if (!W_ERROR_IS_OK(result)) {
10153                 goto done;
10154         }
10155
10156         if (!push_reg_multi_sz(p->mem_ctx, &blob, array)) {
10157                 result = WERR_NOT_ENOUGH_MEMORY;
10158                 goto done;
10159         }
10160
10161         *r->out._ndr_size = r->in.offered / 2;
10162         *r->out.needed = blob.length;
10163
10164         if (r->in.offered < *r->out.needed) {
10165                 result = WERR_MORE_DATA;
10166         } else {
10167                 result = WERR_OK;
10168                 r->out.key_buffer->string_array = array;
10169         }
10170
10171  done:
10172         if (!W_ERROR_IS_OK(result)) {
10173                 TALLOC_FREE(array);
10174                 if (!W_ERROR_EQUAL(result, WERR_MORE_DATA)) {
10175                         *r->out.needed = 0;
10176                 }
10177         }
10178
10179         return result;
10180 }
10181
10182 /****************************************************************
10183  _spoolss_DeletePrinterKey
10184 ****************************************************************/
10185
10186 WERROR _spoolss_DeletePrinterKey(struct pipes_struct *p,
10187                                  struct spoolss_DeletePrinterKey *r)
10188 {
10189         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
10190         int                     snum=0;
10191         WERROR                  status;
10192         const char *printer;
10193         struct dcerpc_binding_handle *b;
10194         TALLOC_CTX *tmp_ctx;
10195
10196         DEBUG(5,("_spoolss_DeletePrinterKey\n"));
10197
10198         if (!Printer) {
10199                 DEBUG(2,("_spoolss_DeletePrinterKey: Invalid handle (%s:%u:%u).\n",
10200                         OUR_HANDLE(r->in.handle)));
10201                 return WERR_INVALID_HANDLE;
10202         }
10203
10204         /* if keyname == NULL, return error */
10205         if ( !r->in.key_name )
10206                 return WERR_INVALID_PARAMETER;
10207
10208         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
10209                 return WERR_INVALID_HANDLE;
10210         }
10211
10212         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
10213                 DEBUG(3, ("_spoolss_DeletePrinterKey: "
10214                         "printer properties change denied by handle\n"));
10215                 return WERR_ACCESS_DENIED;
10216         }
10217
10218         printer = lp_const_servicename(snum);
10219
10220         tmp_ctx = talloc_new(p->mem_ctx);
10221         if (!tmp_ctx) {
10222                 return WERR_NOT_ENOUGH_MEMORY;
10223         }
10224
10225         status = winreg_printer_binding_handle(tmp_ctx,
10226                                                get_session_info_system(),
10227                                                p->msg_ctx,
10228                                                &b);
10229         if (!W_ERROR_IS_OK(status)) {
10230                 goto done;
10231         }
10232
10233         /* delete the key and all subkeys */
10234         status = winreg_delete_printer_key(tmp_ctx, b,
10235                                            printer,
10236                                            r->in.key_name);
10237         if (W_ERROR_IS_OK(status)) {
10238                 status = winreg_printer_update_changeid(tmp_ctx, b,
10239                                                         printer);
10240         }
10241
10242 done:
10243         talloc_free(tmp_ctx);
10244         return status;
10245 }
10246
10247 /****************************************************************
10248  _spoolss_EnumPrinterDataEx
10249 ****************************************************************/
10250
10251 WERROR _spoolss_EnumPrinterDataEx(struct pipes_struct *p,
10252                                   struct spoolss_EnumPrinterDataEx *r)
10253 {
10254         uint32_t        count = 0;
10255         struct spoolss_PrinterEnumValues *info = NULL;
10256         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
10257         int             snum;
10258         WERROR          result;
10259
10260         DEBUG(4,("_spoolss_EnumPrinterDataEx\n"));
10261
10262         *r->out.count = 0;
10263         *r->out.needed = 0;
10264         *r->out.info = NULL;
10265
10266         if (!Printer) {
10267                 DEBUG(2,("_spoolss_EnumPrinterDataEx: Invalid handle (%s:%u:%u1<).\n",
10268                         OUR_HANDLE(r->in.handle)));
10269                 return WERR_INVALID_HANDLE;
10270         }
10271
10272         /*
10273          * first check for a keyname of NULL or "".  Win2k seems to send
10274          * this a lot and we should send back WERR_INVALID_PARAMETER
10275          * no need to spend time looking up the printer in this case.
10276          * --jerry
10277          */
10278
10279         if (!strlen(r->in.key_name)) {
10280                 result = WERR_INVALID_PARAMETER;
10281                 goto done;
10282         }
10283
10284         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
10285                 return WERR_INVALID_HANDLE;
10286         }
10287
10288         /* now look for a match on the key name */
10289         result = winreg_enum_printer_dataex_internal(p->mem_ctx,
10290                                             get_session_info_system(),
10291                                             p->msg_ctx,
10292                                             lp_const_servicename(snum),
10293                                             r->in.key_name,
10294                                             &count,
10295                                             &info);
10296         if (!W_ERROR_IS_OK(result)) {
10297                 goto done;
10298         }
10299
10300 #if 0 /* FIXME - gd */
10301         /* housekeeping information in the reply */
10302
10303         /* Fix from Martin Zielinski <mz@seh.de> - ensure
10304          * the hand marshalled container size is a multiple
10305          * of 4 bytes for RPC alignment.
10306          */
10307
10308         if (needed % 4) {
10309                 needed += 4-(needed % 4);
10310         }
10311 #endif
10312         *r->out.count   = count;
10313         *r->out.info    = info;
10314
10315  done:
10316         if (!W_ERROR_IS_OK(result)) {
10317                 return result;
10318         }
10319
10320         *r->out.needed  = SPOOLSS_BUFFER_ARRAY(p->mem_ctx,
10321                                                spoolss_EnumPrinterDataEx,
10322                                                *r->out.info,
10323                                                *r->out.count);
10324         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
10325         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, *r->out.count);
10326
10327         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
10328 }
10329
10330 /****************************************************************************
10331 ****************************************************************************/
10332
10333 static WERROR getprintprocessordirectory_level_1(TALLOC_CTX *mem_ctx,
10334                                                  const char *servername,
10335                                                  const char *environment,
10336                                                  struct spoolss_PrintProcessorDirectoryInfo1 *r)
10337 {
10338         WERROR werr;
10339         char *path = NULL;
10340
10341         werr = compose_spoolss_server_path(mem_ctx,
10342                                            servername,
10343                                            environment,
10344                                            SPOOLSS_PRTPROCS_PATH,
10345                                            &path);
10346         if (!W_ERROR_IS_OK(werr)) {
10347                 return werr;
10348         }
10349
10350         DEBUG(4,("print processor directory: [%s]\n", path));
10351
10352         r->directory_name = path;
10353
10354         return WERR_OK;
10355 }
10356
10357 /****************************************************************
10358  _spoolss_GetPrintProcessorDirectory
10359 ****************************************************************/
10360
10361 WERROR _spoolss_GetPrintProcessorDirectory(struct pipes_struct *p,
10362                                            struct spoolss_GetPrintProcessorDirectory *r)
10363 {
10364         WERROR result;
10365         char *prnproc_share = NULL;
10366         bool prnproc_share_exists = false;
10367         int snum;
10368
10369         /* that's an [in out] buffer */
10370
10371         if (!r->in.buffer && (r->in.offered != 0)) {
10372                 result = WERR_INVALID_PARAMETER;
10373                 goto err_info_free;
10374         }
10375
10376         DEBUG(5,("_spoolss_GetPrintProcessorDirectory: level %d\n",
10377                 r->in.level));
10378
10379         *r->out.needed = 0;
10380
10381         /* r->in.level is ignored */
10382
10383         /* We always should reply with a local print processor directory so that
10384          * users are not forced to have a [prnproc$] share on the Samba spoolss
10385          * server, if users decide to do so, lets announce it though - Guenther */
10386
10387         snum = find_service(talloc_tos(), "prnproc$", &prnproc_share);
10388         if (!prnproc_share) {
10389                 result = WERR_NOT_ENOUGH_MEMORY;
10390                 goto err_info_free;
10391         }
10392         if (snum != -1) {
10393                 prnproc_share_exists = true;
10394         }
10395
10396         result = getprintprocessordirectory_level_1(p->mem_ctx,
10397                                                     prnproc_share_exists ? r->in.server : NULL,
10398                                                     r->in.environment,
10399                                                     &r->out.info->info1);
10400         if (!W_ERROR_IS_OK(result)) {
10401                 goto err_info_free;
10402         }
10403
10404         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_PrintProcessorDirectoryInfo,
10405                                                                                    r->out.info, r->in.level);
10406         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
10407
10408         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
10409
10410 err_info_free:
10411         TALLOC_FREE(r->out.info);
10412         return result;
10413 }
10414
10415 /*******************************************************************
10416  ********************************************************************/
10417
10418 static bool push_monitorui_buf(TALLOC_CTX *mem_ctx, DATA_BLOB *buf,
10419                                const char *dllname)
10420 {
10421         enum ndr_err_code ndr_err;
10422         struct spoolss_MonitorUi ui;
10423
10424         ui.dll_name = dllname;
10425
10426         ndr_err = ndr_push_struct_blob(buf, mem_ctx, &ui,
10427                        (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorUi);
10428         if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
10429                 NDR_PRINT_DEBUG(spoolss_MonitorUi, &ui);
10430         }
10431         return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
10432 }
10433
10434 /*******************************************************************
10435  Streams the monitor UI DLL name in UNICODE
10436 *******************************************************************/
10437
10438 static WERROR xcvtcp_monitorui(TALLOC_CTX *mem_ctx,
10439                                struct security_token *token, DATA_BLOB *in,
10440                                DATA_BLOB *out, uint32_t *needed)
10441 {
10442         const char *dllname = "tcpmonui.dll";
10443
10444         *needed = (strlen(dllname)+1) * 2;
10445
10446         if (out->length < *needed) {
10447                 return WERR_INSUFFICIENT_BUFFER;
10448         }
10449
10450         if (!push_monitorui_buf(mem_ctx, out, dllname)) {
10451                 return WERR_NOT_ENOUGH_MEMORY;
10452         }
10453
10454         return WERR_OK;
10455 }
10456
10457 /*******************************************************************
10458  ********************************************************************/
10459
10460 static bool pull_port_data_1(TALLOC_CTX *mem_ctx,
10461                              struct spoolss_PortData1 *port1,
10462                              const DATA_BLOB *buf)
10463 {
10464         enum ndr_err_code ndr_err;
10465         ndr_err = ndr_pull_struct_blob(buf, mem_ctx, port1,
10466                        (ndr_pull_flags_fn_t)ndr_pull_spoolss_PortData1);
10467         if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
10468                 NDR_PRINT_DEBUG(spoolss_PortData1, port1);
10469         }
10470         return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
10471 }
10472
10473 /*******************************************************************
10474  ********************************************************************/
10475
10476 static bool pull_port_data_2(TALLOC_CTX *mem_ctx,
10477                              struct spoolss_PortData2 *port2,
10478                              const DATA_BLOB *buf)
10479 {
10480         enum ndr_err_code ndr_err;
10481         ndr_err = ndr_pull_struct_blob(buf, mem_ctx, port2,
10482                        (ndr_pull_flags_fn_t)ndr_pull_spoolss_PortData2);
10483         if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
10484                 NDR_PRINT_DEBUG(spoolss_PortData2, port2);
10485         }
10486         return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
10487 }
10488
10489 /*******************************************************************
10490  Create a new TCP/IP port
10491 *******************************************************************/
10492
10493 static WERROR xcvtcp_addport(TALLOC_CTX *mem_ctx,
10494                              struct security_token *token, DATA_BLOB *in,
10495                              DATA_BLOB *out, uint32_t *needed)
10496 {
10497         struct spoolss_PortData1 port1;
10498         struct spoolss_PortData2 port2;
10499         char *device_uri = NULL;
10500         uint32_t version;
10501
10502         const char *portname;
10503         const char *hostaddress;
10504         const char *queue;
10505         uint32_t port_number;
10506         uint32_t protocol;
10507
10508         /* peek for spoolss_PortData version */
10509
10510         if (!in || (in->length < (128 + 4))) {
10511                 return WERR_GEN_FAILURE;
10512         }
10513
10514         version = IVAL(in->data, 128);
10515
10516         switch (version) {
10517                 case 1:
10518                         ZERO_STRUCT(port1);
10519
10520                         if (!pull_port_data_1(mem_ctx, &port1, in)) {
10521                                 return WERR_NOT_ENOUGH_MEMORY;
10522                         }
10523
10524                         portname        = port1.portname;
10525                         hostaddress     = port1.hostaddress;
10526                         queue           = port1.queue;
10527                         protocol        = port1.protocol;
10528                         port_number     = port1.port_number;
10529
10530                         break;
10531                 case 2:
10532                         ZERO_STRUCT(port2);
10533
10534                         if (!pull_port_data_2(mem_ctx, &port2, in)) {
10535                                 return WERR_NOT_ENOUGH_MEMORY;
10536                         }
10537
10538                         portname        = port2.portname;
10539                         hostaddress     = port2.hostaddress;
10540                         queue           = port2.queue;
10541                         protocol        = port2.protocol;
10542                         port_number     = port2.port_number;
10543
10544                         break;
10545                 default:
10546                         DEBUG(1,("xcvtcp_addport: "
10547                                 "unknown version of port_data: %d\n", version));
10548                         return WERR_UNKNOWN_PORT;
10549         }
10550
10551         /* create the device URI and call the add_port_hook() */
10552
10553         switch (protocol) {
10554         case PROTOCOL_RAWTCP_TYPE:
10555                 device_uri = talloc_asprintf(mem_ctx,
10556                                 "socket://%s:%d/", hostaddress,
10557                                 port_number);
10558                 break;
10559
10560         case PROTOCOL_LPR_TYPE:
10561                 device_uri = talloc_asprintf(mem_ctx,
10562                         "lpr://%s/%s", hostaddress, queue );
10563                 break;
10564
10565         default:
10566                 return WERR_UNKNOWN_PORT;
10567         }
10568
10569         if (!device_uri) {
10570                 return WERR_NOT_ENOUGH_MEMORY;
10571         }
10572
10573         return add_port_hook(mem_ctx, token, portname, device_uri);
10574 }
10575
10576 /*******************************************************************
10577 *******************************************************************/
10578
10579 struct xcv_api_table xcvtcp_cmds[] = {
10580         { "MonitorUI",  xcvtcp_monitorui },
10581         { "AddPort",    xcvtcp_addport},
10582         { NULL,         NULL }
10583 };
10584
10585 static WERROR process_xcvtcp_command(TALLOC_CTX *mem_ctx,
10586                                      struct security_token *token, const char *command,
10587                                      DATA_BLOB *inbuf,
10588                                      DATA_BLOB *outbuf,
10589                                      uint32_t *needed )
10590 {
10591         int i;
10592
10593         DEBUG(10,("process_xcvtcp_command: Received command \"%s\"\n", command));
10594
10595         for ( i=0; xcvtcp_cmds[i].name; i++ ) {
10596                 if ( strcmp( command, xcvtcp_cmds[i].name ) == 0 )
10597                         return xcvtcp_cmds[i].fn(mem_ctx, token, inbuf, outbuf, needed);
10598         }
10599
10600         return WERR_INVALID_FUNCTION;
10601 }
10602
10603 /*******************************************************************
10604 *******************************************************************/
10605 #if 0   /* don't support management using the "Local Port" monitor */
10606
10607 static WERROR xcvlocal_monitorui(TALLOC_CTX *mem_ctx,
10608                                  struct security_token *token, DATA_BLOB *in,
10609                                  DATA_BLOB *out, uint32_t *needed)
10610 {
10611         const char *dllname = "localui.dll";
10612
10613         *needed = (strlen(dllname)+1) * 2;
10614
10615         if (out->length < *needed) {
10616                 return WERR_INSUFFICIENT_BUFFER;
10617         }
10618
10619         if (!push_monitorui_buf(mem_ctx, out, dllname)) {
10620                 return WERR_NOT_ENOUGH_MEMORY;
10621         }
10622
10623         return WERR_OK;
10624 }
10625
10626 /*******************************************************************
10627 *******************************************************************/
10628
10629 struct xcv_api_table xcvlocal_cmds[] = {
10630         { "MonitorUI",  xcvlocal_monitorui },
10631         { NULL,         NULL }
10632 };
10633 #else
10634 struct xcv_api_table xcvlocal_cmds[] = {
10635         { NULL,         NULL }
10636 };
10637 #endif
10638
10639
10640
10641 /*******************************************************************
10642 *******************************************************************/
10643
10644 static WERROR process_xcvlocal_command(TALLOC_CTX *mem_ctx,
10645                                        struct security_token *token, const char *command,
10646                                        DATA_BLOB *inbuf, DATA_BLOB *outbuf,
10647                                        uint32_t *needed)
10648 {
10649         int i;
10650
10651         DEBUG(10,("process_xcvlocal_command: Received command \"%s\"\n", command));
10652
10653         for ( i=0; xcvlocal_cmds[i].name; i++ ) {
10654                 if ( strcmp( command, xcvlocal_cmds[i].name ) == 0 )
10655                         return xcvlocal_cmds[i].fn(mem_ctx, token, inbuf, outbuf, needed);
10656         }
10657         return WERR_INVALID_FUNCTION;
10658 }
10659
10660 /****************************************************************
10661  _spoolss_XcvData
10662 ****************************************************************/
10663
10664 WERROR _spoolss_XcvData(struct pipes_struct *p,
10665                         struct spoolss_XcvData *r)
10666 {
10667         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
10668         DATA_BLOB out_data = data_blob_null;
10669         WERROR werror;
10670
10671         if (!Printer) {
10672                 DEBUG(2,("_spoolss_XcvData: Invalid handle (%s:%u:%u).\n",
10673                         OUR_HANDLE(r->in.handle)));
10674                 return WERR_INVALID_HANDLE;
10675         }
10676
10677         /* Has to be a handle to the TCP/IP port monitor */
10678
10679         if ( !(Printer->printer_type & (SPLHND_PORTMON_LOCAL|SPLHND_PORTMON_TCP)) ) {
10680                 DEBUG(2,("_spoolss_XcvData: Call only valid for Port Monitors\n"));
10681                 return WERR_INVALID_HANDLE;
10682         }
10683
10684         /* requires administrative access to the server */
10685
10686         if ( !(Printer->access_granted & SERVER_ACCESS_ADMINISTER) ) {
10687                 DEBUG(2,("_spoolss_XcvData: denied by handle permissions.\n"));
10688                 return WERR_ACCESS_DENIED;
10689         }
10690
10691         /* Allocate the outgoing buffer */
10692
10693         if (r->in.out_data_size) {
10694                 out_data = data_blob_talloc_zero(p->mem_ctx, r->in.out_data_size);
10695                 if (out_data.data == NULL) {
10696                         return WERR_NOT_ENOUGH_MEMORY;
10697                 }
10698         }
10699
10700         switch ( Printer->printer_type ) {
10701         case SPLHND_PORTMON_TCP:
10702                 werror = process_xcvtcp_command(p->mem_ctx,
10703                                                 p->session_info->security_token,
10704                                                 r->in.function_name,
10705                                                 &r->in.in_data, &out_data,
10706                                                 r->out.needed);
10707                 break;
10708         case SPLHND_PORTMON_LOCAL:
10709                 werror = process_xcvlocal_command(p->mem_ctx,
10710                                                   p->session_info->security_token,
10711                                                   r->in.function_name,
10712                                                   &r->in.in_data, &out_data,
10713                                                   r->out.needed);
10714                 break;
10715         default:
10716                 werror = WERR_INVALID_PRINT_MONITOR;
10717         }
10718
10719         if (!W_ERROR_IS_OK(werror)) {
10720                 return werror;
10721         }
10722
10723         *r->out.status_code = 0;
10724
10725         if (r->out.out_data && out_data.data && r->in.out_data_size && out_data.length) {
10726                 memcpy(r->out.out_data, out_data.data,
10727                         MIN(r->in.out_data_size, out_data.length));
10728         }
10729
10730         return WERR_OK;
10731 }
10732
10733 /****************************************************************
10734  _spoolss_AddPrintProcessor
10735 ****************************************************************/
10736
10737 WERROR _spoolss_AddPrintProcessor(struct pipes_struct *p,
10738                                   struct spoolss_AddPrintProcessor *r)
10739 {
10740         /* for now, just indicate success and ignore the add.  We'll
10741            automatically set the winprint processor for printer
10742            entries later.  Used to debug the LexMark Optra S 1855 PCL
10743            driver --jerry */
10744
10745         return WERR_OK;
10746 }
10747
10748 /****************************************************************
10749  _spoolss_AddPort
10750 ****************************************************************/
10751
10752 WERROR _spoolss_AddPort(struct pipes_struct *p,
10753                         struct spoolss_AddPort *r)
10754 {
10755         /* do what w2k3 does */
10756
10757         return WERR_NOT_SUPPORTED;
10758 }
10759
10760 /****************************************************************
10761  _spoolss_GetPrinterDriver
10762 ****************************************************************/
10763
10764 WERROR _spoolss_GetPrinterDriver(struct pipes_struct *p,
10765                                  struct spoolss_GetPrinterDriver *r)
10766 {
10767         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10768         return WERR_NOT_SUPPORTED;
10769 }
10770
10771 /****************************************************************
10772  _spoolss_ReadPrinter
10773 ****************************************************************/
10774
10775 WERROR _spoolss_ReadPrinter(struct pipes_struct *p,
10776                             struct spoolss_ReadPrinter *r)
10777 {
10778         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10779         return WERR_NOT_SUPPORTED;
10780 }
10781
10782 /****************************************************************
10783  _spoolss_WaitForPrinterChange
10784 ****************************************************************/
10785
10786 WERROR _spoolss_WaitForPrinterChange(struct pipes_struct *p,
10787                                      struct spoolss_WaitForPrinterChange *r)
10788 {
10789         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10790         return WERR_NOT_SUPPORTED;
10791 }
10792
10793 /****************************************************************
10794  _spoolss_ConfigurePort
10795 ****************************************************************/
10796
10797 WERROR _spoolss_ConfigurePort(struct pipes_struct *p,
10798                               struct spoolss_ConfigurePort *r)
10799 {
10800         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10801         return WERR_NOT_SUPPORTED;
10802 }
10803
10804 /****************************************************************
10805  _spoolss_DeletePort
10806 ****************************************************************/
10807
10808 WERROR _spoolss_DeletePort(struct pipes_struct *p,
10809                            struct spoolss_DeletePort *r)
10810 {
10811         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10812         return WERR_NOT_SUPPORTED;
10813 }
10814
10815 /****************************************************************
10816  _spoolss_CreatePrinterIC
10817 ****************************************************************/
10818
10819 WERROR _spoolss_CreatePrinterIC(struct pipes_struct *p,
10820                                 struct spoolss_CreatePrinterIC *r)
10821 {
10822         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10823         return WERR_NOT_SUPPORTED;
10824 }
10825
10826 /****************************************************************
10827  _spoolss_PlayGDIScriptOnPrinterIC
10828 ****************************************************************/
10829
10830 WERROR _spoolss_PlayGDIScriptOnPrinterIC(struct pipes_struct *p,
10831                                          struct spoolss_PlayGDIScriptOnPrinterIC *r)
10832 {
10833         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10834         return WERR_NOT_SUPPORTED;
10835 }
10836
10837 /****************************************************************
10838  _spoolss_DeletePrinterIC
10839 ****************************************************************/
10840
10841 WERROR _spoolss_DeletePrinterIC(struct pipes_struct *p,
10842                                 struct spoolss_DeletePrinterIC *r)
10843 {
10844         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10845         return WERR_NOT_SUPPORTED;
10846 }
10847
10848 /****************************************************************
10849  _spoolss_AddPrinterConnection
10850 ****************************************************************/
10851
10852 WERROR _spoolss_AddPrinterConnection(struct pipes_struct *p,
10853                                      struct spoolss_AddPrinterConnection *r)
10854 {
10855         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10856         return WERR_NOT_SUPPORTED;
10857 }
10858
10859 /****************************************************************
10860  _spoolss_DeletePrinterConnection
10861 ****************************************************************/
10862
10863 WERROR _spoolss_DeletePrinterConnection(struct pipes_struct *p,
10864                                         struct spoolss_DeletePrinterConnection *r)
10865 {
10866         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10867         return WERR_NOT_SUPPORTED;
10868 }
10869
10870 /****************************************************************
10871  _spoolss_PrinterMessageBox
10872 ****************************************************************/
10873
10874 WERROR _spoolss_PrinterMessageBox(struct pipes_struct *p,
10875                                   struct spoolss_PrinterMessageBox *r)
10876 {
10877         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10878         return WERR_NOT_SUPPORTED;
10879 }
10880
10881 /****************************************************************
10882  _spoolss_AddMonitor
10883 ****************************************************************/
10884
10885 WERROR _spoolss_AddMonitor(struct pipes_struct *p,
10886                            struct spoolss_AddMonitor *r)
10887 {
10888         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10889         return WERR_NOT_SUPPORTED;
10890 }
10891
10892 /****************************************************************
10893  _spoolss_DeleteMonitor
10894 ****************************************************************/
10895
10896 WERROR _spoolss_DeleteMonitor(struct pipes_struct *p,
10897                               struct spoolss_DeleteMonitor *r)
10898 {
10899         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10900         return WERR_NOT_SUPPORTED;
10901 }
10902
10903 /****************************************************************
10904  _spoolss_DeletePrintProcessor
10905 ****************************************************************/
10906
10907 WERROR _spoolss_DeletePrintProcessor(struct pipes_struct *p,
10908                                      struct spoolss_DeletePrintProcessor *r)
10909 {
10910         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10911         return WERR_NOT_SUPPORTED;
10912 }
10913
10914 /****************************************************************
10915  _spoolss_AddPrintProvidor
10916 ****************************************************************/
10917
10918 WERROR _spoolss_AddPrintProvidor(struct pipes_struct *p,
10919                                  struct spoolss_AddPrintProvidor *r)
10920 {
10921         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10922         return WERR_NOT_SUPPORTED;
10923 }
10924
10925 /****************************************************************
10926  _spoolss_DeletePrintProvidor
10927 ****************************************************************/
10928
10929 WERROR _spoolss_DeletePrintProvidor(struct pipes_struct *p,
10930                                     struct spoolss_DeletePrintProvidor *r)
10931 {
10932         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10933         return WERR_NOT_SUPPORTED;
10934 }
10935
10936 /****************************************************************
10937  _spoolss_FindFirstPrinterChangeNotification
10938 ****************************************************************/
10939
10940 WERROR _spoolss_FindFirstPrinterChangeNotification(struct pipes_struct *p,
10941                                                    struct spoolss_FindFirstPrinterChangeNotification *r)
10942 {
10943         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10944         return WERR_NOT_SUPPORTED;
10945 }
10946
10947 /****************************************************************
10948  _spoolss_FindNextPrinterChangeNotification
10949 ****************************************************************/
10950
10951 WERROR _spoolss_FindNextPrinterChangeNotification(struct pipes_struct *p,
10952                                                   struct spoolss_FindNextPrinterChangeNotification *r)
10953 {
10954         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10955         return WERR_NOT_SUPPORTED;
10956 }
10957
10958 /****************************************************************
10959  _spoolss_RouterFindFirstPrinterChangeNotificationOld
10960 ****************************************************************/
10961
10962 WERROR _spoolss_RouterFindFirstPrinterChangeNotificationOld(struct pipes_struct *p,
10963                                                             struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
10964 {
10965         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10966         return WERR_NOT_SUPPORTED;
10967 }
10968
10969 /****************************************************************
10970  _spoolss_ReplyOpenPrinter
10971 ****************************************************************/
10972
10973 WERROR _spoolss_ReplyOpenPrinter(struct pipes_struct *p,
10974                                  struct spoolss_ReplyOpenPrinter *r)
10975 {
10976         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10977         return WERR_NOT_SUPPORTED;
10978 }
10979
10980 /****************************************************************
10981  _spoolss_RouterReplyPrinter
10982 ****************************************************************/
10983
10984 WERROR _spoolss_RouterReplyPrinter(struct pipes_struct *p,
10985                                    struct spoolss_RouterReplyPrinter *r)
10986 {
10987         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10988         return WERR_NOT_SUPPORTED;
10989 }
10990
10991 /****************************************************************
10992  _spoolss_ReplyClosePrinter
10993 ****************************************************************/
10994
10995 WERROR _spoolss_ReplyClosePrinter(struct pipes_struct *p,
10996                                   struct spoolss_ReplyClosePrinter *r)
10997 {
10998         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10999         return WERR_NOT_SUPPORTED;
11000 }
11001
11002 /****************************************************************
11003  _spoolss_AddPortEx
11004 ****************************************************************/
11005
11006 WERROR _spoolss_AddPortEx(struct pipes_struct *p,
11007                           struct spoolss_AddPortEx *r)
11008 {
11009         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11010         return WERR_NOT_SUPPORTED;
11011 }
11012
11013 /****************************************************************
11014  _spoolss_RouterFindFirstPrinterChangeNotification
11015 ****************************************************************/
11016
11017 WERROR _spoolss_RouterFindFirstPrinterChangeNotification(struct pipes_struct *p,
11018                                                          struct spoolss_RouterFindFirstPrinterChangeNotification *r)
11019 {
11020         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11021         return WERR_NOT_SUPPORTED;
11022 }
11023
11024 /****************************************************************
11025  _spoolss_SpoolerInit
11026 ****************************************************************/
11027
11028 WERROR _spoolss_SpoolerInit(struct pipes_struct *p,
11029                             struct spoolss_SpoolerInit *r)
11030 {
11031         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11032         return WERR_NOT_SUPPORTED;
11033 }
11034
11035 /****************************************************************
11036  _spoolss_ResetPrinterEx
11037 ****************************************************************/
11038
11039 WERROR _spoolss_ResetPrinterEx(struct pipes_struct *p,
11040                                struct spoolss_ResetPrinterEx *r)
11041 {
11042         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11043         return WERR_NOT_SUPPORTED;
11044 }
11045
11046 /****************************************************************
11047  _spoolss_RouterReplyPrinterEx
11048 ****************************************************************/
11049
11050 WERROR _spoolss_RouterReplyPrinterEx(struct pipes_struct *p,
11051                                      struct spoolss_RouterReplyPrinterEx *r)
11052 {
11053         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11054         return WERR_NOT_SUPPORTED;
11055 }
11056
11057 /****************************************************************
11058  _spoolss_44
11059 ****************************************************************/
11060
11061 WERROR _spoolss_44(struct pipes_struct *p,
11062                    struct spoolss_44 *r)
11063 {
11064         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11065         return WERR_NOT_SUPPORTED;
11066 }
11067
11068 /****************************************************************
11069  _spoolss_SetPort
11070 ****************************************************************/
11071
11072 WERROR _spoolss_SetPort(struct pipes_struct *p,
11073                         struct spoolss_SetPort *r)
11074 {
11075         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11076         return WERR_NOT_SUPPORTED;
11077 }
11078
11079 /****************************************************************
11080  _spoolss_4a
11081 ****************************************************************/
11082
11083 WERROR _spoolss_4a(struct pipes_struct *p,
11084                    struct spoolss_4a *r)
11085 {
11086         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11087         return WERR_NOT_SUPPORTED;
11088 }
11089
11090 /****************************************************************
11091  _spoolss_4b
11092 ****************************************************************/
11093
11094 WERROR _spoolss_4b(struct pipes_struct *p,
11095                    struct spoolss_4b *r)
11096 {
11097         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11098         return WERR_NOT_SUPPORTED;
11099 }
11100
11101 /****************************************************************
11102  _spoolss_4c
11103 ****************************************************************/
11104
11105 WERROR _spoolss_4c(struct pipes_struct *p,
11106                    struct spoolss_4c *r)
11107 {
11108         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11109         return WERR_NOT_SUPPORTED;
11110 }
11111
11112 /****************************************************************
11113  _spoolss_53
11114 ****************************************************************/
11115
11116 WERROR _spoolss_53(struct pipes_struct *p,
11117                    struct spoolss_53 *r)
11118 {
11119         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11120         return WERR_NOT_SUPPORTED;
11121 }
11122
11123 /****************************************************************
11124  _spoolss_AddPerMachineConnection
11125 ****************************************************************/
11126
11127 WERROR _spoolss_AddPerMachineConnection(struct pipes_struct *p,
11128                                         struct spoolss_AddPerMachineConnection *r)
11129 {
11130         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11131         return WERR_NOT_SUPPORTED;
11132 }
11133
11134 /****************************************************************
11135  _spoolss_DeletePerMachineConnection
11136 ****************************************************************/
11137
11138 WERROR _spoolss_DeletePerMachineConnection(struct pipes_struct *p,
11139                                            struct spoolss_DeletePerMachineConnection *r)
11140 {
11141         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11142         return WERR_NOT_SUPPORTED;
11143 }
11144
11145 /****************************************************************
11146  _spoolss_EnumPerMachineConnections
11147 ****************************************************************/
11148
11149 WERROR _spoolss_EnumPerMachineConnections(struct pipes_struct *p,
11150                                           struct spoolss_EnumPerMachineConnections *r)
11151 {
11152         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11153         return WERR_NOT_SUPPORTED;
11154 }
11155
11156 /****************************************************************
11157  _spoolss_5a
11158 ****************************************************************/
11159
11160 WERROR _spoolss_5a(struct pipes_struct *p,
11161                    struct spoolss_5a *r)
11162 {
11163         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11164         return WERR_NOT_SUPPORTED;
11165 }
11166
11167 /****************************************************************
11168  _spoolss_5b
11169 ****************************************************************/
11170
11171 WERROR _spoolss_5b(struct pipes_struct *p,
11172                    struct spoolss_5b *r)
11173 {
11174         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11175         return WERR_NOT_SUPPORTED;
11176 }
11177
11178 /****************************************************************
11179  _spoolss_5c
11180 ****************************************************************/
11181
11182 WERROR _spoolss_5c(struct pipes_struct *p,
11183                    struct spoolss_5c *r)
11184 {
11185         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11186         return WERR_NOT_SUPPORTED;
11187 }
11188
11189 /****************************************************************
11190  _spoolss_5d
11191 ****************************************************************/
11192
11193 WERROR _spoolss_5d(struct pipes_struct *p,
11194                    struct spoolss_5d *r)
11195 {
11196         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11197         return WERR_NOT_SUPPORTED;
11198 }
11199
11200 /****************************************************************
11201  _spoolss_5e
11202 ****************************************************************/
11203
11204 WERROR _spoolss_5e(struct pipes_struct *p,
11205                    struct spoolss_5e *r)
11206 {
11207         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11208         return WERR_NOT_SUPPORTED;
11209 }
11210
11211 /****************************************************************
11212  _spoolss_5f
11213 ****************************************************************/
11214
11215 WERROR _spoolss_5f(struct pipes_struct *p,
11216                    struct spoolss_5f *r)
11217 {
11218         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11219         return WERR_NOT_SUPPORTED;
11220 }
11221
11222 /****************************************************************
11223  _spoolss_60
11224 ****************************************************************/
11225
11226 WERROR _spoolss_60(struct pipes_struct *p,
11227                    struct spoolss_60 *r)
11228 {
11229         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11230         return WERR_NOT_SUPPORTED;
11231 }
11232
11233 /****************************************************************
11234  _spoolss_SendRecvBidiData
11235 ****************************************************************/
11236
11237 WERROR _spoolss_SendRecvBidiData(struct pipes_struct *p,
11238                                  struct spoolss_SendRecvBidiData *r)
11239 {
11240         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11241         return WERR_NOT_SUPPORTED;
11242 }
11243
11244 /****************************************************************
11245  _spoolss_62
11246 ****************************************************************/
11247
11248 WERROR _spoolss_62(struct pipes_struct *p,
11249                    struct spoolss_62 *r)
11250 {
11251         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11252         return WERR_NOT_SUPPORTED;
11253 }
11254
11255 /****************************************************************
11256  _spoolss_63
11257 ****************************************************************/
11258
11259 WERROR _spoolss_63(struct pipes_struct *p,
11260                    struct spoolss_63 *r)
11261 {
11262         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11263         return WERR_NOT_SUPPORTED;
11264 }
11265
11266 /****************************************************************
11267  _spoolss_64
11268 ****************************************************************/
11269
11270 WERROR _spoolss_64(struct pipes_struct *p,
11271                    struct spoolss_64 *r)
11272 {
11273         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11274         return WERR_NOT_SUPPORTED;
11275 }
11276
11277 /****************************************************************
11278  _spoolss_65
11279 ****************************************************************/
11280
11281 WERROR _spoolss_65(struct pipes_struct *p,
11282                    struct spoolss_65 *r)
11283 {
11284         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11285         return WERR_NOT_SUPPORTED;
11286 }
11287
11288 /****************************************************************
11289  _spoolss_GetCorePrinterDrivers
11290 ****************************************************************/
11291
11292 HRESULT _spoolss_GetCorePrinterDrivers(struct pipes_struct *p,
11293                                        struct spoolss_GetCorePrinterDrivers *r)
11294 {
11295         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11296         return HRES_ERROR_NOT_SUPPORTED;
11297 }
11298
11299 /****************************************************************
11300  _spoolss_67
11301 ****************************************************************/
11302
11303 WERROR _spoolss_67(struct pipes_struct *p,
11304                    struct spoolss_67 *r)
11305 {
11306         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11307         return WERR_NOT_SUPPORTED;
11308 }
11309
11310 /****************************************************************
11311  _spoolss_GetPrinterDriverPackagePath
11312 ****************************************************************/
11313
11314 HRESULT _spoolss_GetPrinterDriverPackagePath(struct pipes_struct *p,
11315                                              struct spoolss_GetPrinterDriverPackagePath *r)
11316 {
11317         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11318         return HRES_ERROR_NOT_SUPPORTED;
11319 }
11320
11321 /****************************************************************
11322  _spoolss_69
11323 ****************************************************************/
11324
11325 WERROR _spoolss_69(struct pipes_struct *p,
11326                    struct spoolss_69 *r)
11327 {
11328         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11329         return WERR_NOT_SUPPORTED;
11330 }
11331
11332 /****************************************************************
11333  _spoolss_6a
11334 ****************************************************************/
11335
11336 WERROR _spoolss_6a(struct pipes_struct *p,
11337                    struct spoolss_6a *r)
11338 {
11339         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11340         return WERR_NOT_SUPPORTED;
11341 }
11342
11343 /****************************************************************
11344  _spoolss_6b
11345 ****************************************************************/
11346
11347 WERROR _spoolss_6b(struct pipes_struct *p,
11348                    struct spoolss_6b *r)
11349 {
11350         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11351         return WERR_NOT_SUPPORTED;
11352 }
11353
11354 /****************************************************************
11355  _spoolss_6c
11356 ****************************************************************/
11357
11358 WERROR _spoolss_6c(struct pipes_struct *p,
11359                    struct spoolss_6c *r)
11360 {
11361         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11362         return WERR_NOT_SUPPORTED;
11363 }
11364
11365 /****************************************************************
11366  _spoolss_6d
11367 ****************************************************************/
11368
11369 WERROR _spoolss_6d(struct pipes_struct *p,
11370                    struct spoolss_6d *r)
11371 {
11372         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11373         return WERR_NOT_SUPPORTED;
11374 }
11375
11376 /****************************************************************
11377  _spoolss_GetJobNamedPropertyValue
11378 ****************************************************************/
11379
11380 WERROR _spoolss_GetJobNamedPropertyValue(struct pipes_struct *p,
11381                                          struct spoolss_GetJobNamedPropertyValue *r)
11382 {
11383         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11384         return WERR_NOT_SUPPORTED;
11385 }
11386
11387 /****************************************************************
11388  _spoolss_SetJobNamedProperty
11389 ****************************************************************/
11390
11391 WERROR _spoolss_SetJobNamedProperty(struct pipes_struct *p,
11392                                     struct spoolss_SetJobNamedProperty *r)
11393 {
11394         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11395         return WERR_NOT_SUPPORTED;
11396 }
11397
11398 /****************************************************************
11399  _spoolss_DeleteJobNamedProperty
11400 ****************************************************************/
11401
11402 WERROR _spoolss_DeleteJobNamedProperty(struct pipes_struct *p,
11403                                        struct spoolss_DeleteJobNamedProperty *r)
11404 {
11405         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11406         return WERR_NOT_SUPPORTED;
11407 }
11408
11409 /****************************************************************
11410  _spoolss_EnumJobNamedProperties
11411 ****************************************************************/
11412
11413 WERROR _spoolss_EnumJobNamedProperties(struct pipes_struct *p,
11414                                        struct spoolss_EnumJobNamedProperties *r)
11415 {
11416         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11417         return WERR_NOT_SUPPORTED;
11418 }
11419
11420 /****************************************************************
11421  _spoolss_72
11422 ****************************************************************/
11423
11424 WERROR _spoolss_72(struct pipes_struct *p,
11425                    struct spoolss_72 *r)
11426 {
11427         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11428         return WERR_NOT_SUPPORTED;
11429 }
11430
11431 /****************************************************************
11432  _spoolss_73
11433 ****************************************************************/
11434
11435 WERROR _spoolss_73(struct pipes_struct *p,
11436                    struct spoolss_73 *r)
11437 {
11438         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11439         return WERR_NOT_SUPPORTED;
11440 }
11441
11442 /****************************************************************
11443  _spoolss_RpcLogJobInfoForBranchOffice
11444 ****************************************************************/
11445
11446 WERROR _spoolss_LogJobInfoForBranchOffice(struct pipes_struct *p,
11447                                           struct spoolss_LogJobInfoForBranchOffice *r)
11448 {
11449         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11450         return WERR_NOT_SUPPORTED;
11451 }