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
  60 /* macros stolen from s4 spoolss server */
  61 #define SPOOLSS_BUFFER_UNION(fn,info,level) \
  62         ((info)?ndr_size_##fn(info, level, 0):0)
  63
  64 #define SPOOLSS_BUFFER_UNION_ARRAY(mem_ctx,fn,info,level,count) \
  65         ((info)?ndr_size_##fn##_info(mem_ctx, level, count, info):0)
  66
  67 #define SPOOLSS_BUFFER_ARRAY(mem_ctx,fn,info,count) \
  68         ((info)?ndr_size_##fn##_info(mem_ctx, count, info):0)
  69
  70 #define SPOOLSS_BUFFER_OK(val_true,val_false) ((r->in.offered >= *r->out.needed)?val_true:val_false)
  71
  72 #undef DBGC_CLASS
  73 #define DBGC_CLASS DBGC_RPC_SRV
  74
  75 #ifndef MAX_OPEN_PRINTER_EXS
  76 #define MAX_OPEN_PRINTER_EXS 50
  77 #endif
  78
  79 struct notify_back_channel;
  80
  81 /* structure to store the printer handles */
  82 /* and a reference to what it's pointing to */
  83 /* and the notify info asked about */
  84 /* that's the central struct */
  85 struct printer_handle {
  86         struct printer_handle *prev, *next;
  87         bool document_started;
  88         bool page_started;
  89         uint32 jobid; /* jobid in printing backend */
  90         int printer_type;
  91         const char *servername;
  92         fstring sharename;
  93         uint32 type;
  94         uint32 access_granted;
  95         struct {
  96                 uint32 flags;
  97                 uint32 options;
  98                 fstring localmachine;
  99                 uint32 printerlocal;
 100                 struct spoolss_NotifyOption *option;
 101                 struct policy_handle cli_hnd;
 102                 struct notify_back_channel *cli_chan;
 103                 uint32 change;
 104                 /* are we in a FindNextPrinterChangeNotify() call? */
 105                 bool fnpcn;
 106                 struct messaging_context *msg_ctx;
 107         } notify;
 108         struct {
 109                 fstring machine;
 110                 fstring user;
 111         } client;
 112
 113         /* devmode sent in the OpenPrinter() call */
 114         struct spoolss_DeviceMode *devmode;
 115
 116         /* TODO cache the printer info2 structure */
 117         struct spoolss_PrinterInfo2 *info2;
 118
 119 };
 120
 121 static struct printer_handle *printers_list;
 122
 123 struct printer_session_counter {
 124         struct printer_session_counter *next;
 125         struct printer_session_counter *prev;
 126
 127         int snum;
 128         uint32_t counter;
 129 };
 130
 131 static struct printer_session_counter *counter_list;
 132
 133 struct notify_back_channel {
 134         struct notify_back_channel *prev, *next;
 135
 136         /* associated client */
 137         struct sockaddr_storage client_address;
 138
 139         /* print notify back-channel pipe handle*/
 140         struct rpc_pipe_client *cli_pipe;
 141         uint32_t active_connections;
 142 };
 143
 144 static struct notify_back_channel *back_channels;
 145
 146 /* Map generic permissions to printer object specific permissions */
 147
 148 const struct standard_mapping printer_std_mapping = {
 149         PRINTER_READ,
 150         PRINTER_WRITE,
 151         PRINTER_EXECUTE,
 152         PRINTER_ALL_ACCESS
 153 };
 154
 155 /* Map generic permissions to print server object specific permissions */
 156
 157 const struct standard_mapping printserver_std_mapping = {
 158         SERVER_READ,
 159         SERVER_WRITE,
 160         SERVER_EXECUTE,
 161         SERVER_ALL_ACCESS
 162 };
 163
 164 /* API table for Xcv Monitor functions */
 165
 166 struct xcv_api_table {
 167         const char *name;
 168         WERROR(*fn) (TALLOC_CTX *mem_ctx, struct security_token *token, DATA_BLOB *in, DATA_BLOB *out, uint32_t *needed);
 169 };
 170
 171 static void prune_printername_cache(void);
 172
 173 /********************************************************************
 174  * Canonicalize servername.
 175  ********************************************************************/
 176
 177 static const char *canon_servername(const char *servername)
 178 {
 179         const char *pservername = servername;
 180         while (*pservername == '\\') {
 181                 pservername++;
 182         }
 183         return pservername;
 184 }
 185
 186 /* translate between internal status numbers and NT status numbers */
 187 static int nt_printj_status(int v)
 188 {
 189         switch (v) {
 190         case LPQ_QUEUED:
 191                 return 0;
 192         case LPQ_PAUSED:
 193                 return JOB_STATUS_PAUSED;
 194         case LPQ_SPOOLING:
 195                 return JOB_STATUS_SPOOLING;
 196         case LPQ_PRINTING:
 197                 return JOB_STATUS_PRINTING;
 198         case LPQ_ERROR:
 199                 return JOB_STATUS_ERROR;
 200         case LPQ_DELETING:
 201                 return JOB_STATUS_DELETING;
 202         case LPQ_OFFLINE:
 203                 return JOB_STATUS_OFFLINE;
 204         case LPQ_PAPEROUT:
 205                 return JOB_STATUS_PAPEROUT;
 206         case LPQ_PRINTED:
 207                 return JOB_STATUS_PRINTED;
 208         case LPQ_DELETED:
 209                 return JOB_STATUS_DELETED;
 210         case LPQ_BLOCKED:
 211                 return JOB_STATUS_BLOCKED_DEVQ;
 212         case LPQ_USER_INTERVENTION:
 213                 return JOB_STATUS_USER_INTERVENTION;
 214         }
 215         return 0;
 216 }
 217
 218 static int nt_printq_status(int v)
 219 {
 220         switch (v) {
 221         case LPQ_PAUSED:
 222                 return PRINTER_STATUS_PAUSED;
 223         case LPQ_QUEUED:
 224         case LPQ_SPOOLING:
 225         case LPQ_PRINTING:
 226                 return 0;
 227         }
 228         return 0;
 229 }
 230
 231 /***************************************************************************
 232  Disconnect from the client
 233 ****************************************************************************/
 234
 235 static void srv_spoolss_replycloseprinter(int snum,
 236                                           struct printer_handle *prn_hnd)
 237 {
 238         WERROR result;
 239         NTSTATUS status;
 240
 241         /*
 242          * Tell the specific printing tdb we no longer want messages for this printer
 243          * by deregistering our PID.
 244          */
 245
 246         if (!print_notify_deregister_pid(snum)) {
 247                 DEBUG(0, ("Failed to register our pid for printer %s\n",
 248                           lp_const_servicename(snum)));
 249         }
 250
 251         /* weird if the test succeeds !!! */
 252         if (prn_hnd->notify.cli_chan == NULL ||
 253             prn_hnd->notify.cli_chan->cli_pipe == NULL ||
 254             prn_hnd->notify.cli_chan->cli_pipe->binding_handle == NULL ||
 255             prn_hnd->notify.cli_chan->active_connections == 0) {
 256                 DEBUG(0, ("Trying to close unexisting backchannel!\n"));
 257                 DLIST_REMOVE(back_channels, prn_hnd->notify.cli_chan);
 258                 TALLOC_FREE(prn_hnd->notify.cli_chan);
 259                 return;
 260         }
 261
 262         status = dcerpc_spoolss_ReplyClosePrinter(
 263                                         prn_hnd->notify.cli_chan->cli_pipe->binding_handle,
 264                                         talloc_tos(),
 265                                         &prn_hnd->notify.cli_hnd,
 266                                         &result);
 267         if (!NT_STATUS_IS_OK(status)) {
 268                 DEBUG(0, ("dcerpc_spoolss_ReplyClosePrinter failed [%s].\n",
 269                           nt_errstr(status)));
 270                 result = ntstatus_to_werror(status);
 271         } else if (!W_ERROR_IS_OK(result)) {
 272                 DEBUG(0, ("reply_close_printer failed [%s].\n",
 273                           win_errstr(result)));
 274         }
 275
 276         /* if it's the last connection, deconnect the IPC$ share */
 277         if (prn_hnd->notify.cli_chan->active_connections == 1) {
 278
 279                 cli_shutdown(rpc_pipe_np_smb_conn(prn_hnd->notify.cli_chan->cli_pipe));
 280                 DLIST_REMOVE(back_channels, prn_hnd->notify.cli_chan);
 281                 TALLOC_FREE(prn_hnd->notify.cli_chan);
 282
 283                 if (prn_hnd->notify.msg_ctx != NULL) {
 284                         messaging_deregister(prn_hnd->notify.msg_ctx,
 285                                              MSG_PRINTER_NOTIFY2, NULL);
 286                 }
 287         }
 288
 289         if (prn_hnd->notify.cli_chan) {
 290                 prn_hnd->notify.cli_chan->active_connections--;
 291                 prn_hnd->notify.cli_chan = NULL;
 292         }
 293 }
 294
 295 /****************************************************************************
 296  Functions to free a printer entry datastruct.
 297 ****************************************************************************/
 298
 299 static int printer_entry_destructor(struct printer_handle *Printer)
 300 {
 301         if (Printer->notify.cli_chan != NULL &&
 302             Printer->notify.cli_chan->active_connections > 0) {
 303                 int snum = -1;
 304
 305                 switch(Printer->printer_type) {
 306                 case SPLHND_SERVER:
 307                         srv_spoolss_replycloseprinter(snum, Printer);
 308                         break;
 309
 310                 case SPLHND_PRINTER:
 311                         snum = print_queue_snum(Printer->sharename);
 312                         if (snum != -1) {
 313                                 srv_spoolss_replycloseprinter(snum, Printer);
 314                         }
 315                         break;
 316                 default:
 317                         break;
 318                 }
 319         }
 320
 321         Printer->notify.flags=0;
 322         Printer->notify.options=0;
 323         Printer->notify.localmachine[0]='\0';
 324         Printer->notify.printerlocal=0;
 325         TALLOC_FREE(Printer->notify.option);
 326         TALLOC_FREE(Printer->devmode);
 327
 328         /* Remove from the internal list. */
 329         DLIST_REMOVE(printers_list, Printer);
 330         return 0;
 331 }
 332
 333 /****************************************************************************
 334   find printer index by handle
 335 ****************************************************************************/
 336
 337 static struct printer_handle *find_printer_index_by_hnd(struct pipes_struct *p,
 338                                                         struct policy_handle *hnd)
 339 {
 340         struct printer_handle *find_printer = NULL;
 341
 342         if(!find_policy_by_hnd(p,hnd,(void **)(void *)&find_printer)) {
 343                 DEBUG(2,("find_printer_index_by_hnd: Printer handle not found: "));
 344                 return NULL;
 345         }
 346
 347         return find_printer;
 348 }
 349
 350 /****************************************************************************
 351  Close printer index by handle.
 352 ****************************************************************************/
 353
 354 static bool close_printer_handle(struct pipes_struct *p, struct policy_handle *hnd)
 355 {
 356         struct printer_handle *Printer = find_printer_index_by_hnd(p, hnd);
 357
 358         if (!Printer) {
 359                 DEBUG(2,("close_printer_handle: Invalid handle (%s:%u:%u)\n",
 360                         OUR_HANDLE(hnd)));
 361                 return false;
 362         }
 363
 364         close_policy_hnd(p, hnd);
 365
 366         return true;
 367 }
 368
 369 /****************************************************************************
 370  Delete a printer given a handle.
 371 ****************************************************************************/
 372
 373 static WERROR delete_printer_hook(TALLOC_CTX *ctx, struct security_token *token,
 374                                   const char *sharename,
 375                                   struct messaging_context *msg_ctx)
 376 {
 377         char *cmd = lp_deleteprinter_cmd(talloc_tos());
 378         char *command = NULL;
 379         int ret;
 380         bool is_print_op = false;
 381
 382         /* can't fail if we don't try */
 383
 384         if ( !*cmd )
 385                 return WERR_OK;
 386
 387         command = talloc_asprintf(ctx,
 388                         "%s \"%s\"",
 389                         cmd, sharename);
 390         if (!command) {
 391                 return WERR_NOMEM;
 392         }
 393         if ( token )
 394                 is_print_op = security_token_has_privilege(token, SEC_PRIV_PRINT_OPERATOR);
 395
 396         DEBUG(10,("Running [%s]\n", command));
 397
 398         /********** BEGIN SePrintOperatorPrivlege BLOCK **********/
 399
 400         if ( is_print_op )
 401                 become_root();
 402
 403         if ( (ret = smbrun(command, NULL)) == 0 ) {
 404                 /* Tell everyone we updated smb.conf. */
 405                 message_send_all(msg_ctx, MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
 406         }
 407
 408         if ( is_print_op )
 409                 unbecome_root();
 410
 411         /********** END SePrintOperatorPrivlege BLOCK **********/
 412
 413         DEBUGADD(10,("returned [%d]\n", ret));
 414
 415         TALLOC_FREE(command);
 416
 417         if (ret != 0)
 418                 return WERR_BADFID; /* What to return here? */
 419
 420         return WERR_OK;
 421 }
 422
 423 /****************************************************************************
 424  Delete a printer given a handle.
 425 ****************************************************************************/
 426
 427 static WERROR delete_printer_handle(struct pipes_struct *p, struct policy_handle *hnd)
 428 {
 429         struct printer_handle *Printer = find_printer_index_by_hnd(p, hnd);
 430         WERROR result;
 431
 432         if (!Printer) {
 433                 DEBUG(2,("delete_printer_handle: Invalid handle (%s:%u:%u)\n",
 434                         OUR_HANDLE(hnd)));
 435                 return WERR_BADFID;
 436         }
 437
 438         /*
 439          * It turns out that Windows allows delete printer on a handle
 440          * opened by an admin user, then used on a pipe handle created
 441          * by an anonymous user..... but they're working on security.... riiight !
 442          * JRA.
 443          */
 444
 445         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
 446                 DEBUG(3, ("delete_printer_handle: denied by handle\n"));
 447                 return WERR_ACCESS_DENIED;
 448         }
 449
 450         /* this does not need a become root since the access check has been
 451            done on the handle already */
 452
 453         result = winreg_delete_printer_key_internal(p->mem_ctx,
 454                                            get_session_info_system(),
 455                                            p->msg_ctx,
 456                                            Printer->sharename,
 457                                            "");
 458         if (!W_ERROR_IS_OK(result)) {
 459                 DEBUG(3,("Error deleting printer %s\n", Printer->sharename));
 460                 return WERR_BADFID;
 461         }
 462
 463         result = delete_printer_hook(p->mem_ctx, p->session_info->security_token,
 464                                      Printer->sharename, p->msg_ctx);
 465         if (!W_ERROR_IS_OK(result)) {
 466                 return result;
 467         }
 468         prune_printername_cache();
 469         return WERR_OK;
 470 }
 471
 472 /****************************************************************************
 473  Return the snum of a printer corresponding to an handle.
 474 ****************************************************************************/
 475
 476 static bool get_printer_snum(struct pipes_struct *p, struct policy_handle *hnd,
 477                              int *number, struct share_params **params)
 478 {
 479         struct printer_handle *Printer = find_printer_index_by_hnd(p, hnd);
 480
 481         if (!Printer) {
 482                 DEBUG(2,("get_printer_snum: Invalid handle (%s:%u:%u)\n",
 483                         OUR_HANDLE(hnd)));
 484                 return false;
 485         }
 486
 487         switch (Printer->printer_type) {
 488                 case SPLHND_PRINTER:
 489                         DEBUG(4,("short name:%s\n", Printer->sharename));
 490                         *number = print_queue_snum(Printer->sharename);
 491                         return (*number != -1);
 492                 case SPLHND_SERVER:
 493                         return false;
 494                 default:
 495                         return false;
 496         }
 497 }
 498
 499 /****************************************************************************
 500  Set printer handle type.
 501  Check if it's \\server or \\server\printer
 502 ****************************************************************************/
 503
 504 static bool set_printer_hnd_printertype(struct printer_handle *Printer, const char *handlename)
 505 {
 506         DEBUG(3,("Setting printer type=%s\n", handlename));
 507
 508         /* it's a print server */
 509         if (handlename && *handlename=='\\' && *(handlename+1)=='\\' && !strchr_m(handlename+2, '\\')) {
 510                 DEBUGADD(4,("Printer is a print server\n"));
 511                 Printer->printer_type = SPLHND_SERVER;
 512         }
 513         /* it's a printer (set_printer_hnd_name() will handle port monitors */
 514         else {
 515                 DEBUGADD(4,("Printer is a printer\n"));
 516                 Printer->printer_type = SPLHND_PRINTER;
 517         }
 518
 519         return true;
 520 }
 521
 522 static void prune_printername_cache_fn(const char *key, const char *value,
 523                                        time_t timeout, void *private_data)
 524 {
 525         gencache_del(key);
 526 }
 527
 528 static void prune_printername_cache(void)
 529 {
 530         gencache_iterate(prune_printername_cache_fn, NULL, "PRINTERNAME/*");
 531 }
 532
 533 /****************************************************************************
 534  Set printer handle name..  Accept names like \\server, \\server\printer,
 535  \\server\SHARE, & "\\server\,XcvMonitor Standard TCP/IP Port"    See
 536  the MSDN docs regarding OpenPrinter() for details on the XcvData() and
 537  XcvDataPort() interface.
 538 ****************************************************************************/
 539
 540 static WERROR set_printer_hnd_name(TALLOC_CTX *mem_ctx,
 541                                    const struct auth_session_info *session_info,
 542                                    struct messaging_context *msg_ctx,
 543                                    struct printer_handle *Printer,
 544                                    const char *handlename)
 545 {
 546         int snum;
 547         int n_services=lp_numservices();
 548         char *aprinter;
 549         const char *printername;
 550         const char *servername = NULL;
 551         fstring sname;
 552         bool found = false;
 553         struct spoolss_PrinterInfo2 *info2 = NULL;
 554         WERROR result;
 555         char *p;
 556
 557         /*
 558          * Hopefully nobody names his printers like this. Maybe \ or ,
 559          * are illegal in printer names even?
 560          */
 561         const char printer_not_found[] = "Printer \\, !@#$%^&*( not found";
 562         char *cache_key;
 563         char *tmp;
 564
 565         DEBUG(4,("Setting printer name=%s (len=%lu)\n", handlename,
 566                 (unsigned long)strlen(handlename)));
 567
 568         aprinter = discard_const_p(char, handlename);
 569         if ( *handlename == '\\' ) {
 570                 servername = canon_servername(handlename);
 571                 if ( (aprinter = strchr_m( servername, '\\' )) != NULL ) {
 572                         *aprinter = '\0';
 573                         aprinter++;
 574                 }
 575                 if (!is_myname_or_ipaddr(servername)) {
 576                         return WERR_INVALID_PRINTER_NAME;
 577                 }
 578                 Printer->servername = talloc_asprintf(Printer, "\\\\%s", servername);
 579                 if (Printer->servername == NULL) {
 580                         return WERR_NOMEM;
 581                 }
 582         }
 583
 584         if (Printer->printer_type == SPLHND_SERVER) {
 585                 return WERR_OK;
 586         }
 587
 588         if (Printer->printer_type != SPLHND_PRINTER) {
 589                 return WERR_INVALID_HANDLE;
 590         }
 591
 592         DEBUGADD(5, ("searching for [%s]\n", aprinter));
 593
 594         p = strchr(aprinter, ',');
 595         if (p != NULL) {
 596                 char *p2 = p;
 597                 p++;
 598                 if (*p == ' ') {
 599                         p++;
 600                 }
 601                 if (strncmp(p, "DrvConvert", strlen("DrvConvert")) == 0) {
 602                         *p2 = '\0';
 603                 } else if (strncmp(p, "LocalOnly", strlen("LocalOnly")) == 0) {
 604                         *p2 = '\0';
 605                 }
 606         }
 607
 608         if (p) {
 609                 DEBUGADD(5, ("stripped handlename: [%s]\n", aprinter));
 610         }
 611
 612         /* check for the Port Monitor Interface */
 613         if ( strequal( aprinter, SPL_XCV_MONITOR_TCPMON ) ) {
 614                 Printer->printer_type = SPLHND_PORTMON_TCP;
 615                 fstrcpy(sname, SPL_XCV_MONITOR_TCPMON);
 616                 found = true;
 617         }
 618         else if ( strequal( aprinter, SPL_XCV_MONITOR_LOCALMON ) ) {
 619                 Printer->printer_type = SPLHND_PORTMON_LOCAL;
 620                 fstrcpy(sname, SPL_XCV_MONITOR_LOCALMON);
 621                 found = true;
 622         }
 623
 624         /*
 625          * With hundreds of printers, the "for" loop iterating all
 626          * shares can be quite expensive, as it is done on every
 627          * OpenPrinter. The loop maps "aprinter" to "sname", the
 628          * result of which we cache in gencache.
 629          */
 630
 631         cache_key = talloc_asprintf(talloc_tos(), "PRINTERNAME/%s",
 632                                     aprinter);
 633         if ((cache_key != NULL) && gencache_get(cache_key, &tmp, NULL)) {
 634
 635                 found = (strcmp(tmp, printer_not_found) != 0);
 636                 if (!found) {
 637                         DEBUG(4, ("Printer %s not found\n", aprinter));
 638                         SAFE_FREE(tmp);
 639                         return WERR_INVALID_PRINTER_NAME;
 640                 }
 641                 fstrcpy(sname, tmp);
 642                 SAFE_FREE(tmp);
 643         }
 644
 645         /* Search all sharenames first as this is easier than pulling
 646            the printer_info_2 off of disk. Don't use find_service() since
 647            that calls out to map_username() */
 648
 649         /* do another loop to look for printernames */
 650         for (snum = 0; !found && snum < n_services; snum++) {
 651                 const char *printer = lp_const_servicename(snum);
 652
 653                 /* no point going on if this is not a printer */
 654                 if (!(lp_snum_ok(snum) && lp_print_ok(snum))) {
 655                         continue;
 656                 }
 657
 658                 /* ignore [printers] share */
 659                 if (strequal(printer, "printers")) {
 660                         continue;
 661                 }
 662
 663                 fstrcpy(sname, printer);
 664                 if (strequal(aprinter, printer)) {
 665                         found = true;
 666                         break;
 667                 }
 668
 669                 /* no point looking up the printer object if
 670                    we aren't allowing printername != sharename */
 671                 if (lp_force_printername(snum)) {
 672                         continue;
 673                 }
 674
 675                 result = winreg_get_printer_internal(mem_ctx,
 676                                             session_info,
 677                                             msg_ctx,
 678                                             sname,
 679                                             &info2);
 680                 if ( !W_ERROR_IS_OK(result) ) {
 681                         DEBUG(2,("set_printer_hnd_name: failed to lookup printer [%s] -- result [%s]\n",
 682                                  sname, win_errstr(result)));
 683                         continue;
 684                 }
 685
 686                 printername = strrchr(info2->printername, '\\');
 687                 if (printername == NULL) {
 688                         printername = info2->printername;
 689                 } else {
 690                         printername++;
 691                 }
 692
 693                 if (strequal(printername, aprinter)) {
 694                         found = true;
 695                         break;
 696                 }
 697
 698                 DEBUGADD(10, ("printername: %s\n", printername));
 699
 700                 TALLOC_FREE(info2);
 701         }
 702
 703         if ( !found ) {
 704                 if (cache_key != NULL) {
 705                         gencache_set(cache_key, printer_not_found,
 706                                      time(NULL)+300);
 707                         TALLOC_FREE(cache_key);
 708                 }
 709                 DEBUGADD(4,("Printer not found\n"));
 710                 return WERR_INVALID_PRINTER_NAME;
 711         }
 712
 713         if (cache_key != NULL) {
 714                 gencache_set(cache_key, sname, time(NULL)+300);
 715                 TALLOC_FREE(cache_key);
 716         }
 717
 718         DEBUGADD(4,("set_printer_hnd_name: Printer found: %s -> %s\n", aprinter, sname));
 719
 720         strlcpy(Printer->sharename, sname, sizeof(Printer->sharename));
 721
 722         return WERR_OK;
 723 }
 724
 725 /****************************************************************************
 726  Find first available printer slot. creates a printer handle for you.
 727  ****************************************************************************/
 728
 729 static WERROR open_printer_hnd(struct pipes_struct *p,
 730                                struct policy_handle *hnd,
 731                                const char *name,
 732                                uint32_t access_granted)
 733 {
 734         struct printer_handle *new_printer;
 735         WERROR result;
 736
 737         DEBUG(10,("open_printer_hnd: name [%s]\n", name));
 738
 739         new_printer = talloc_zero(p->mem_ctx, struct printer_handle);
 740         if (new_printer == NULL) {
 741                 return WERR_NOMEM;
 742         }
 743         talloc_set_destructor(new_printer, printer_entry_destructor);
 744
 745         /* This also steals the printer_handle on the policy_handle */
 746         if (!create_policy_hnd(p, hnd, new_printer)) {
 747                 TALLOC_FREE(new_printer);
 748                 return WERR_INVALID_HANDLE;
 749         }
 750
 751         /* Add to the internal list. */
 752         DLIST_ADD(printers_list, new_printer);
 753
 754         new_printer->notify.option=NULL;
 755
 756         if (!set_printer_hnd_printertype(new_printer, name)) {
 757                 close_printer_handle(p, hnd);
 758                 return WERR_INVALID_HANDLE;
 759         }
 760
 761         result = set_printer_hnd_name(p->mem_ctx,
 762                                       get_session_info_system(),
 763                                       p->msg_ctx,
 764                                       new_printer, name);
 765         if (!W_ERROR_IS_OK(result)) {
 766                 close_printer_handle(p, hnd);
 767                 return result;
 768         }
 769
 770         new_printer->access_granted = access_granted;
 771
 772         DEBUG(5, ("%d printer handles active\n",
 773                   (int)num_pipe_handles(p)));
 774
 775         return WERR_OK;
 776 }
 777
 778 /***************************************************************************
 779  check to see if the client motify handle is monitoring the notification
 780  given by (notify_type, notify_field).
 781  **************************************************************************/
 782
 783 static bool is_monitoring_event_flags(uint32_t flags, uint16_t notify_type,
 784                                       uint16_t notify_field)
 785 {
 786         return true;
 787 }
 788
 789 static bool is_monitoring_event(struct printer_handle *p, uint16_t notify_type,
 790                                 uint16_t notify_field)
 791 {
 792         struct spoolss_NotifyOption *option = p->notify.option;
 793         uint32_t i, j;
 794
 795         /*
 796          * Flags should always be zero when the change notify
 797          * is registered by the client's spooler.  A user Win32 app
 798          * might use the flags though instead of the NOTIFY_OPTION_INFO
 799          * --jerry
 800          */
 801
 802         if (!option) {
 803                 return false;
 804         }
 805
 806         if (p->notify.flags)
 807                 return is_monitoring_event_flags(
 808                         p->notify.flags, notify_type, notify_field);
 809
 810         for (i = 0; i < option->count; i++) {
 811
 812                 /* Check match for notify_type */
 813
 814                 if (option->types[i].type != notify_type)
 815                         continue;
 816
 817                 /* Check match for field */
 818
 819                 for (j = 0; j < option->types[i].count; j++) {
 820                         if (option->types[i].fields[j].field == notify_field) {
 821                                 return true;
 822                         }
 823                 }
 824         }
 825
 826         DEBUG(10, ("Open handle for \\\\%s\\%s is not monitoring 0x%02x/0x%02x\n",
 827                    p->servername, p->sharename, notify_type, notify_field));
 828
 829         return false;
 830 }
 831
 832 #define SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(_data, _integer) \
 833         _data->data.integer[0] = _integer; \
 834         _data->data.integer[1] = 0;
 835
 836
 837 #define SETUP_SPOOLSS_NOTIFY_DATA_STRING(_data, _p) \
 838         _data->data.string.string = talloc_strdup(mem_ctx, _p); \
 839         if (!_data->data.string.string) {\
 840                 _data->data.string.size = 0; \
 841         } \
 842         _data->data.string.size = strlen_m_term(_p) * 2;
 843
 844 #define SETUP_SPOOLSS_NOTIFY_DATA_DEVMODE(_data, _devmode) \
 845         _data->data.devmode.devmode = _devmode;
 846
 847 #define SETUP_SPOOLSS_NOTIFY_DATA_SECDESC(_data, _sd) \
 848         _data->data.sd.sd = dup_sec_desc(mem_ctx, _sd); \
 849         if (!_data->data.sd.sd) { \
 850                 _data->data.sd.sd_size = 0; \
 851         } \
 852         _data->data.sd.sd_size = \
 853                 ndr_size_security_descriptor(_data->data.sd.sd, 0);
 854
 855 static void init_systemtime_buffer(TALLOC_CTX *mem_ctx,
 856                                    struct tm *t,
 857                                    const char **pp,
 858                                    uint32_t *plen)
 859 {
 860         struct spoolss_Time st;
 861         uint32_t len = 16;
 862         char *p;
 863
 864         if (!init_systemtime(&st, t)) {
 865                 return;
 866         }
 867
 868         p = talloc_array(mem_ctx, char, len);
 869         if (!p) {
 870                 return;
 871         }
 872
 873         /*
 874          * Systemtime must be linearized as a set of UINT16's.
 875          * Fix from Benjamin (Bj) Kuit bj@it.uts.edu.au
 876          */
 877
 878         SSVAL(p, 0, st.year);
 879         SSVAL(p, 2, st.month);
 880         SSVAL(p, 4, st.day_of_week);
 881         SSVAL(p, 6, st.day);
 882         SSVAL(p, 8, st.hour);
 883         SSVAL(p, 10, st.minute);
 884         SSVAL(p, 12, st.second);
 885         SSVAL(p, 14, st.millisecond);
 886
 887         *pp = p;
 888         *plen = len;
 889 }
 890
 891 /* Convert a notification message to a struct spoolss_Notify */
 892
 893 static void notify_one_value(struct spoolss_notify_msg *msg,
 894                              struct spoolss_Notify *data,
 895                              TALLOC_CTX *mem_ctx)
 896 {
 897         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, msg->notify.value[0]);
 898 }
 899
 900 static void notify_string(struct spoolss_notify_msg *msg,
 901                           struct spoolss_Notify *data,
 902                           TALLOC_CTX *mem_ctx)
 903 {
 904         /* The length of the message includes the trailing \0 */
 905
 906         data->data.string.size = msg->len * 2;
 907         data->data.string.string = talloc_strdup(mem_ctx, msg->notify.data);
 908         if (!data->data.string.string) {
 909                 data->data.string.size = 0;
 910                 return;
 911         }
 912 }
 913
 914 static void notify_system_time(struct spoolss_notify_msg *msg,
 915                                struct spoolss_Notify *data,
 916                                TALLOC_CTX *mem_ctx)
 917 {
 918         data->data.string.string = NULL;
 919         data->data.string.size = 0;
 920
 921         if (msg->len != sizeof(time_t)) {
 922                 DEBUG(5, ("notify_system_time: received wrong sized message (%d)\n",
 923                           msg->len));
 924                 return;
 925         }
 926
 927         init_systemtime_buffer(mem_ctx, gmtime((time_t *)msg->notify.data),
 928                                &data->data.string.string,
 929                                &data->data.string.size);
 930 }
 931
 932 struct notify2_message_table {
 933         const char *name;
 934         void (*fn)(struct spoolss_notify_msg *msg,
 935                    struct spoolss_Notify *data, TALLOC_CTX *mem_ctx);
 936 };
 937
 938 static struct notify2_message_table printer_notify_table[] = {
 939         /* 0x00 */ { "PRINTER_NOTIFY_FIELD_SERVER_NAME", notify_string },
 940         /* 0x01 */ { "PRINTER_NOTIFY_FIELD_PRINTER_NAME", notify_string },
 941         /* 0x02 */ { "PRINTER_NOTIFY_FIELD_SHARE_NAME", notify_string },
 942         /* 0x03 */ { "PRINTER_NOTIFY_FIELD_PORT_NAME", notify_string },
 943         /* 0x04 */ { "PRINTER_NOTIFY_FIELD_DRIVER_NAME", notify_string },
 944         /* 0x05 */ { "PRINTER_NOTIFY_FIELD_COMMENT", notify_string },
 945         /* 0x06 */ { "PRINTER_NOTIFY_FIELD_LOCATION", notify_string },
 946         /* 0x07 */ { "PRINTER_NOTIFY_FIELD_DEVMODE", NULL },
 947         /* 0x08 */ { "PRINTER_NOTIFY_FIELD_SEPFILE", notify_string },
 948         /* 0x09 */ { "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR", notify_string },
 949         /* 0x0a */ { "PRINTER_NOTIFY_FIELD_PARAMETERS", NULL },
 950         /* 0x0b */ { "PRINTER_NOTIFY_FIELD_DATATYPE", notify_string },
 951         /* 0x0c */ { "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NULL },
 952         /* 0x0d */ { "PRINTER_NOTIFY_FIELD_ATTRIBUTES", notify_one_value },
 953         /* 0x0e */ { "PRINTER_NOTIFY_FIELD_PRIORITY", notify_one_value },
 954         /* 0x0f */ { "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY", NULL },
 955         /* 0x10 */ { "PRINTER_NOTIFY_FIELD_START_TIME", NULL },
 956         /* 0x11 */ { "PRINTER_NOTIFY_FIELD_UNTIL_TIME", NULL },
 957         /* 0x12 */ { "PRINTER_NOTIFY_FIELD_STATUS", notify_one_value },
 958 };
 959
 960 static struct notify2_message_table job_notify_table[] = {
 961         /* 0x00 */ { "JOB_NOTIFY_FIELD_PRINTER_NAME", NULL },
 962         /* 0x01 */ { "JOB_NOTIFY_FIELD_MACHINE_NAME", NULL },
 963         /* 0x02 */ { "JOB_NOTIFY_FIELD_PORT_NAME", NULL },
 964         /* 0x03 */ { "JOB_NOTIFY_FIELD_USER_NAME", notify_string },
 965         /* 0x04 */ { "JOB_NOTIFY_FIELD_NOTIFY_NAME", NULL },
 966         /* 0x05 */ { "JOB_NOTIFY_FIELD_DATATYPE", NULL },
 967         /* 0x06 */ { "JOB_NOTIFY_FIELD_PRINT_PROCESSOR", NULL },
 968         /* 0x07 */ { "JOB_NOTIFY_FIELD_PARAMETERS", NULL },
 969         /* 0x08 */ { "JOB_NOTIFY_FIELD_DRIVER_NAME", NULL },
 970         /* 0x09 */ { "JOB_NOTIFY_FIELD_DEVMODE", NULL },
 971         /* 0x0a */ { "JOB_NOTIFY_FIELD_STATUS", notify_one_value },
 972         /* 0x0b */ { "JOB_NOTIFY_FIELD_STATUS_STRING", NULL },
 973         /* 0x0c */ { "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NULL },
 974         /* 0x0d */ { "JOB_NOTIFY_FIELD_DOCUMENT", notify_string },
 975         /* 0x0e */ { "JOB_NOTIFY_FIELD_PRIORITY", NULL },
 976         /* 0x0f */ { "JOB_NOTIFY_FIELD_POSITION", NULL },
 977         /* 0x10 */ { "JOB_NOTIFY_FIELD_SUBMITTED", notify_system_time },
 978         /* 0x11 */ { "JOB_NOTIFY_FIELD_START_TIME", NULL },
 979         /* 0x12 */ { "JOB_NOTIFY_FIELD_UNTIL_TIME", NULL },
 980         /* 0x13 */ { "JOB_NOTIFY_FIELD_TIME", NULL },
 981         /* 0x14 */ { "JOB_NOTIFY_FIELD_TOTAL_PAGES", notify_one_value },
 982         /* 0x15 */ { "JOB_NOTIFY_FIELD_PAGES_PRINTED", NULL },
 983         /* 0x16 */ { "JOB_NOTIFY_FIELD_TOTAL_BYTES", notify_one_value },
 984         /* 0x17 */ { "JOB_NOTIFY_FIELD_BYTES_PRINTED", NULL },
 985 };
 986
 987
 988 /***********************************************************************
 989  Allocate talloc context for container object
 990  **********************************************************************/
 991
 992 static void notify_msg_ctr_init( SPOOLSS_NOTIFY_MSG_CTR *ctr )
 993 {
 994         if ( !ctr )
 995                 return;
 996
 997         ctr->ctx = talloc_init("notify_msg_ctr_init %p", ctr);
 998
 999         return;
1000 }
1001
1002 /***********************************************************************
1003  release all allocated memory and zero out structure
1004  **********************************************************************/
1005
1006 static void notify_msg_ctr_destroy( SPOOLSS_NOTIFY_MSG_CTR *ctr )
1007 {
1008         if ( !ctr )
1009                 return;
1010
1011         if ( ctr->ctx )
1012                 talloc_destroy(ctr->ctx);
1013
1014         ZERO_STRUCTP(ctr);
1015
1016         return;
1017 }
1018
1019 /***********************************************************************
1020  **********************************************************************/
1021
1022 static TALLOC_CTX* notify_ctr_getctx( SPOOLSS_NOTIFY_MSG_CTR *ctr )
1023 {
1024         if ( !ctr )
1025                 return NULL;
1026
1027         return ctr->ctx;
1028 }
1029
1030 /***********************************************************************
1031  **********************************************************************/
1032
1033 static SPOOLSS_NOTIFY_MSG_GROUP* notify_ctr_getgroup( SPOOLSS_NOTIFY_MSG_CTR *ctr, uint32_t idx )
1034 {
1035         if ( !ctr || !ctr->msg_groups )
1036                 return NULL;
1037
1038         if ( idx >= ctr->num_groups )
1039                 return NULL;
1040
1041         return &ctr->msg_groups[idx];
1042
1043 }
1044
1045 /***********************************************************************
1046  How many groups of change messages do we have ?
1047  **********************************************************************/
1048
1049 static int notify_msg_ctr_numgroups( SPOOLSS_NOTIFY_MSG_CTR *ctr )
1050 {
1051         if ( !ctr )
1052                 return 0;
1053
1054         return ctr->num_groups;
1055 }
1056
1057 /***********************************************************************
1058  Add a SPOOLSS_NOTIFY_MSG_CTR to the correct group
1059  **********************************************************************/
1060
1061 static int notify_msg_ctr_addmsg( SPOOLSS_NOTIFY_MSG_CTR *ctr, SPOOLSS_NOTIFY_MSG *msg )
1062 {
1063         SPOOLSS_NOTIFY_MSG_GROUP        *groups = NULL;
1064         SPOOLSS_NOTIFY_MSG_GROUP        *msg_grp = NULL;
1065         SPOOLSS_NOTIFY_MSG              *msg_list = NULL;
1066         int                             i, new_slot;
1067
1068         if ( !ctr || !msg )
1069                 return 0;
1070
1071         /* loop over all groups looking for a matching printer name */
1072
1073         for ( i=0; i<ctr->num_groups; i++ ) {
1074                 if ( strcmp(ctr->msg_groups[i].printername, msg->printer) == 0 )
1075                         break;
1076         }
1077
1078         /* add a new group? */
1079
1080         if ( i == ctr->num_groups ) {
1081                 ctr->num_groups++;
1082
1083                 if ( !(groups = talloc_realloc( ctr->ctx, ctr->msg_groups, SPOOLSS_NOTIFY_MSG_GROUP, ctr->num_groups)) ) {
1084                         DEBUG(0,("notify_msg_ctr_addmsg: talloc_realloc() failed!\n"));
1085                         return 0;
1086                 }
1087                 ctr->msg_groups = groups;
1088
1089                 /* clear the new entry and set the printer name */
1090
1091                 ZERO_STRUCT( ctr->msg_groups[ctr->num_groups-1] );
1092                 fstrcpy( ctr->msg_groups[ctr->num_groups-1].printername, msg->printer );
1093         }
1094
1095         /* add the change messages; 'i' is the correct index now regardless */
1096
1097         msg_grp = &ctr->msg_groups[i];
1098
1099         msg_grp->num_msgs++;
1100
1101         if ( !(msg_list = talloc_realloc( ctr->ctx, msg_grp->msgs, SPOOLSS_NOTIFY_MSG, msg_grp->num_msgs )) ) {
1102                 DEBUG(0,("notify_msg_ctr_addmsg: talloc_realloc() failed for new message [%d]!\n", msg_grp->num_msgs));
1103                 return 0;
1104         }
1105         msg_grp->msgs = msg_list;
1106
1107         new_slot = msg_grp->num_msgs-1;
1108         memcpy( &msg_grp->msgs[new_slot], msg, sizeof(SPOOLSS_NOTIFY_MSG) );
1109
1110         /* need to allocate own copy of data */
1111
1112         if ( msg->len != 0 )
1113                 msg_grp->msgs[new_slot].notify.data = (char *)
1114                         talloc_memdup( ctr->ctx, msg->notify.data, msg->len );
1115
1116         return ctr->num_groups;
1117 }
1118
1119 static void construct_info_data(struct spoolss_Notify *info_data,
1120                                 enum spoolss_NotifyType type,
1121                                 uint16_t field, int id);
1122
1123 /***********************************************************************
1124  Send a change notication message on all handles which have a call
1125  back registered
1126  **********************************************************************/
1127
1128 static int build_notify2_messages(TALLOC_CTX *mem_ctx,
1129                                   struct printer_handle *prn_hnd,
1130                                   SPOOLSS_NOTIFY_MSG *messages,
1131                                   uint32_t num_msgs,
1132                                   struct spoolss_Notify **_notifies,
1133                                   int *_count)
1134 {
1135         struct spoolss_Notify *notifies;
1136         SPOOLSS_NOTIFY_MSG *msg;
1137         int count = 0;
1138         uint32_t id;
1139         int i;
1140
1141         notifies = talloc_zero_array(mem_ctx,
1142                                      struct spoolss_Notify, num_msgs);
1143         if (!notifies) {
1144                 return ENOMEM;
1145         }
1146
1147         for (i = 0; i < num_msgs; i++) {
1148
1149                 msg = &messages[i];
1150
1151                 /* Are we monitoring this event? */
1152
1153                 if (!is_monitoring_event(prn_hnd, msg->type, msg->field)) {
1154                         continue;
1155                 }
1156
1157                 DEBUG(10, ("Sending message type [0x%x] field [0x%2x] "
1158                            "for printer [%s]\n",
1159                            msg->type, msg->field, prn_hnd->sharename));
1160
1161                 /*
1162                  * if the is a printer notification handle and not a job
1163                  * notification type, then set the id to 0.
1164                  * Otherwise just use what was specified in the message.
1165                  *
1166                  * When registering change notification on a print server
1167                  * handle we always need to send back the id (snum) matching
1168                  * the printer for which the change took place.
1169                  * For change notify registered on a printer handle,
1170                  * this does not matter and the id should be 0.
1171                  *
1172                  * --jerry
1173                  */
1174
1175                 if ((msg->type == PRINTER_NOTIFY_TYPE) &&
1176                     (prn_hnd->printer_type == SPLHND_PRINTER)) {
1177                         id = 0;
1178                 } else {
1179                         id = msg->id;
1180                 }
1181
1182                 /* Convert unix jobid to smb jobid */
1183
1184                 if (msg->flags & SPOOLSS_NOTIFY_MSG_UNIX_JOBID) {
1185                         id = sysjob_to_jobid(msg->id);
1186
1187                         if (id == -1) {
1188                                 DEBUG(3, ("no such unix jobid %d\n",
1189                                           msg->id));
1190                                 continue;
1191                         }
1192                 }
1193
1194                 construct_info_data(&notifies[count],
1195                                     msg->type, msg->field, id);
1196
1197                 switch(msg->type) {
1198                 case PRINTER_NOTIFY_TYPE:
1199                         if (printer_notify_table[msg->field].fn) {
1200                                 printer_notify_table[msg->field].fn(msg,
1201                                                 &notifies[count], mem_ctx);
1202                         }
1203                         break;
1204
1205                 case JOB_NOTIFY_TYPE:
1206                         if (job_notify_table[msg->field].fn) {
1207                                 job_notify_table[msg->field].fn(msg,
1208                                                 &notifies[count], mem_ctx);
1209                         }
1210                         break;
1211
1212                 default:
1213                         DEBUG(5, ("Unknown notification type %d\n",
1214                                   msg->type));
1215                         continue;
1216                 }
1217
1218                 count++;
1219         }
1220
1221         *_notifies = notifies;
1222         *_count = count;
1223
1224         return 0;
1225 }
1226
1227 static int send_notify2_printer(TALLOC_CTX *mem_ctx,
1228                                 struct printer_handle *prn_hnd,
1229                                 SPOOLSS_NOTIFY_MSG_GROUP *msg_group)
1230 {
1231         struct spoolss_Notify *notifies;
1232         int count = 0;
1233         union spoolss_ReplyPrinterInfo info;
1234         struct spoolss_NotifyInfo info0;
1235         uint32_t reply_result;
1236         NTSTATUS status;
1237         WERROR werr;
1238         int ret;
1239
1240         /* Is there notification on this handle? */
1241         if (prn_hnd->notify.cli_chan == NULL ||
1242             prn_hnd->notify.cli_chan->cli_pipe == NULL ||
1243             prn_hnd->notify.cli_chan->cli_pipe->binding_handle == NULL ||
1244             prn_hnd->notify.cli_chan->active_connections == 0) {
1245                 return 0;
1246         }
1247
1248         DEBUG(10, ("Client connected! [\\\\%s\\%s]\n",
1249                    prn_hnd->servername, prn_hnd->sharename));
1250
1251         /* For this printer? Print servers always receive notifications. */
1252         if ((prn_hnd->printer_type == SPLHND_PRINTER)  &&
1253             (!strequal(msg_group->printername, prn_hnd->sharename))) {
1254                 return 0;
1255         }
1256
1257         DEBUG(10,("Our printer\n"));
1258
1259         /* build the array of change notifications */
1260         ret = build_notify2_messages(mem_ctx, prn_hnd,
1261                                      msg_group->msgs,
1262                                      msg_group->num_msgs,
1263                                      &notifies, &count);
1264         if (ret) {
1265                 return ret;
1266         }
1267
1268         info0.version   = 0x2;
1269         info0.flags     = count ? 0x00020000 /* ??? */ : PRINTER_NOTIFY_INFO_DISCARDED;
1270         info0.count     = count;
1271         info0.notifies  = notifies;
1272
1273         info.info0 = &info0;
1274
1275         status = dcerpc_spoolss_RouterReplyPrinterEx(
1276                                 prn_hnd->notify.cli_chan->cli_pipe->binding_handle,
1277                                 mem_ctx,
1278                                 &prn_hnd->notify.cli_hnd,
1279                                 prn_hnd->notify.change, /* color */
1280                                 prn_hnd->notify.flags,
1281                                 &reply_result,
1282                                 0, /* reply_type, must be 0 */
1283                                 info, &werr);
1284         if (!NT_STATUS_IS_OK(status)) {
1285                 DEBUG(1, ("dcerpc_spoolss_RouterReplyPrinterEx to client: %s "
1286                           "failed: %s\n",
1287                           prn_hnd->notify.cli_chan->cli_pipe->srv_name_slash,
1288                           nt_errstr(status)));
1289                 werr = ntstatus_to_werror(status);
1290         } else if (!W_ERROR_IS_OK(werr)) {
1291                 DEBUG(1, ("RouterReplyPrinterEx to client: %s "
1292                           "failed: %s\n",
1293                           prn_hnd->notify.cli_chan->cli_pipe->srv_name_slash,
1294                           win_errstr(werr)));
1295         }
1296         switch (reply_result) {
1297         case 0:
1298                 break;
1299         case PRINTER_NOTIFY_INFO_DISCARDED:
1300         case PRINTER_NOTIFY_INFO_DISCARDNOTED:
1301         case PRINTER_NOTIFY_INFO_COLOR_MISMATCH:
1302                 break;
1303         default:
1304                 break;
1305         }
1306
1307         return 0;
1308 }
1309
1310 static void send_notify2_changes( SPOOLSS_NOTIFY_MSG_CTR *ctr, uint32_t idx )
1311 {
1312         struct printer_handle    *p;
1313         TALLOC_CTX               *mem_ctx = notify_ctr_getctx( ctr );
1314         SPOOLSS_NOTIFY_MSG_GROUP *msg_group = notify_ctr_getgroup( ctr, idx );
1315         int ret;
1316
1317         if ( !msg_group ) {
1318                 DEBUG(5,("send_notify2_changes() called with no msg group!\n"));
1319                 return;
1320         }
1321
1322         if (!msg_group->msgs) {
1323                 DEBUG(5, ("send_notify2_changes() called with no messages!\n"));
1324                 return;
1325         }
1326
1327         DEBUG(8,("send_notify2_changes: Enter...[%s]\n", msg_group->printername));
1328
1329         /* loop over all printers */
1330
1331         for (p = printers_list; p; p = p->next) {
1332                 ret = send_notify2_printer(mem_ctx, p, msg_group);
1333                 if (ret) {
1334                         goto done;
1335                 }
1336         }
1337
1338 done:
1339         DEBUG(8,("send_notify2_changes: Exit...\n"));
1340         return;
1341 }
1342
1343 /***********************************************************************
1344  **********************************************************************/
1345
1346 static bool notify2_unpack_msg( SPOOLSS_NOTIFY_MSG *msg, struct timeval *tv, void *buf, size_t len )
1347 {
1348
1349         uint32_t tv_sec, tv_usec;
1350         size_t offset = 0;
1351
1352         /* Unpack message */
1353
1354         offset += tdb_unpack((uint8_t *)buf + offset, len - offset, "f",
1355                              msg->printer);
1356
1357         offset += tdb_unpack((uint8_t *)buf + offset, len - offset, "ddddddd",
1358                                 &tv_sec, &tv_usec,
1359                                 &msg->type, &msg->field, &msg->id, &msg->len, &msg->flags);
1360
1361         if (msg->len == 0)
1362                 tdb_unpack((uint8_t *)buf + offset, len - offset, "dd",
1363                            &msg->notify.value[0], &msg->notify.value[1]);
1364         else
1365                 tdb_unpack((uint8_t *)buf + offset, len - offset, "B",
1366                            &msg->len, &msg->notify.data);
1367
1368         DEBUG(3, ("notify2_unpack_msg: got NOTIFY2 message for printer %s, jobid %u type %d, field 0x%02x, flags 0x%04x\n",
1369                   msg->printer, (unsigned int)msg->id, msg->type, msg->field, msg->flags));
1370
1371         tv->tv_sec = tv_sec;
1372         tv->tv_usec = tv_usec;
1373
1374         if (msg->len == 0)
1375                 DEBUG(3, ("notify2_unpack_msg: value1 = %d, value2 = %d\n", msg->notify.value[0],
1376                           msg->notify.value[1]));
1377         else
1378                 dump_data(3, (uint8_t *)msg->notify.data, msg->len);
1379
1380         return true;
1381 }
1382
1383 /********************************************************************
1384  Receive a notify2 message list
1385  ********************************************************************/
1386
1387 static void receive_notify2_message_list(struct messaging_context *msg,
1388                                          void *private_data,
1389                                          uint32_t msg_type,
1390                                          struct server_id server_id,
1391                                          DATA_BLOB *data)
1392 {
1393         size_t                  msg_count, i;
1394         char                    *buf = (char *)data->data;
1395         char                    *msg_ptr;
1396         size_t                  msg_len;
1397         SPOOLSS_NOTIFY_MSG      notify;
1398         SPOOLSS_NOTIFY_MSG_CTR  messages;
1399         int                     num_groups;
1400
1401         if (data->length < 4) {
1402                 DEBUG(0,("receive_notify2_message_list: bad message format (len < 4)!\n"));
1403                 return;
1404         }
1405
1406         msg_count = IVAL(buf, 0);
1407         msg_ptr = buf + 4;
1408
1409         DEBUG(5, ("receive_notify2_message_list: got %lu messages in list\n", (unsigned long)msg_count));
1410
1411         if (msg_count == 0) {
1412                 DEBUG(0,("receive_notify2_message_list: bad message format (msg_count == 0) !\n"));
1413                 return;
1414         }
1415
1416         /* initialize the container */
1417
1418         ZERO_STRUCT( messages );
1419         notify_msg_ctr_init( &messages );
1420
1421         /*
1422          * build message groups for each printer identified
1423          * in a change_notify msg.  Remember that a PCN message
1424          * includes the handle returned for the srv_spoolss_replyopenprinter()
1425          * call.  Therefore messages are grouped according to printer handle.
1426          */
1427
1428         for ( i=0; i<msg_count; i++ ) {
1429                 struct timeval msg_tv;
1430
1431                 if (msg_ptr + 4 - buf > data->length) {
1432                         DEBUG(0,("receive_notify2_message_list: bad message format (len > buf_size) !\n"));
1433                         return;
1434                 }
1435
1436                 msg_len = IVAL(msg_ptr,0);
1437                 msg_ptr += 4;
1438
1439                 if (msg_ptr + msg_len - buf > data->length) {
1440                         DEBUG(0,("receive_notify2_message_list: bad message format (bad len) !\n"));
1441                         return;
1442                 }
1443
1444                 /* unpack messages */
1445
1446                 ZERO_STRUCT( notify );
1447                 notify2_unpack_msg( &notify, &msg_tv, msg_ptr, msg_len );
1448                 msg_ptr += msg_len;
1449
1450                 /* add to correct list in container */
1451
1452                 notify_msg_ctr_addmsg( &messages, &notify );
1453
1454                 /* free memory that might have been allocated by notify2_unpack_msg() */
1455
1456                 if ( notify.len != 0 )
1457                         SAFE_FREE( notify.notify.data );
1458         }
1459
1460         /* process each group of messages */
1461
1462         num_groups = notify_msg_ctr_numgroups( &messages );
1463         for ( i=0; i<num_groups; i++ )
1464                 send_notify2_changes( &messages, i );
1465
1466
1467         /* cleanup */
1468
1469         DEBUG(10,("receive_notify2_message_list: processed %u messages\n",
1470                 (uint32_t)msg_count ));
1471
1472         notify_msg_ctr_destroy( &messages );
1473
1474         return;
1475 }
1476
1477 /********************************************************************
1478  Send a message to ourself about new driver being installed
1479  so we can upgrade the information for each printer bound to this
1480  driver
1481  ********************************************************************/
1482
1483 static bool srv_spoolss_drv_upgrade_printer(const char *drivername,
1484                                             struct messaging_context *msg_ctx)
1485 {
1486         int len = strlen(drivername);
1487
1488         if (!len)
1489                 return false;
1490
1491         DEBUG(10,("srv_spoolss_drv_upgrade_printer: Sending message about driver upgrade [%s]\n",
1492                 drivername));
1493
1494         messaging_send_buf(msg_ctx, messaging_server_id(msg_ctx),
1495                            MSG_PRINTER_DRVUPGRADE,
1496                            (const uint8_t *)drivername, len+1);
1497
1498         return true;
1499 }
1500
1501 void srv_spoolss_cleanup(void)
1502 {
1503         struct printer_session_counter *session_counter;
1504
1505         for (session_counter = counter_list;
1506              session_counter != NULL;
1507              session_counter = counter_list) {
1508                 DLIST_REMOVE(counter_list, session_counter);
1509                 TALLOC_FREE(session_counter);
1510         }
1511 }
1512
1513 /**********************************************************************
1514  callback to receive a MSG_PRINTER_DRVUPGRADE message and interate
1515  over all printers, upgrading ones as necessary
1516  **********************************************************************/
1517
1518 void do_drv_upgrade_printer(struct messaging_context *msg,
1519                             void *private_data,
1520                             uint32_t msg_type,
1521                             struct server_id server_id,
1522                             DATA_BLOB *data)
1523 {
1524         TALLOC_CTX *tmp_ctx;
1525         const struct auth_session_info *session_info = get_session_info_system();
1526         struct spoolss_PrinterInfo2 *pinfo2;
1527         WERROR result;
1528         const char *drivername;
1529         int snum;
1530         int n_services = lp_numservices();
1531         struct dcerpc_binding_handle *b = NULL;
1532
1533         tmp_ctx = talloc_new(NULL);
1534         if (!tmp_ctx) return;
1535
1536         drivername = talloc_strndup(tmp_ctx, (const char *)data->data, data->length);
1537         if (!drivername) {
1538                 DEBUG(0, ("do_drv_upgrade_printer: Out of memoery ?!\n"));
1539                 goto done;
1540         }
1541
1542         DEBUG(10, ("do_drv_upgrade_printer: "
1543                    "Got message for new driver [%s]\n", drivername));
1544
1545         /* Iterate the printer list */
1546
1547         for (snum = 0; snum < n_services; snum++) {
1548                 if (!lp_snum_ok(snum) || !lp_print_ok(snum)) {
1549                         continue;
1550                 }
1551
1552                 /* ignore [printers] share */
1553                 if (strequal(lp_const_servicename(snum), "printers")) {
1554                         continue;
1555                 }
1556
1557                 if (b == NULL) {
1558                         result = winreg_printer_binding_handle(tmp_ctx,
1559                                                                session_info,
1560                                                                msg,
1561                                                                &b);
1562                         if (!W_ERROR_IS_OK(result)) {
1563                                 break;
1564                         }
1565                 }
1566
1567                 result = winreg_get_printer(tmp_ctx, b,
1568                                             lp_const_servicename(snum),
1569                                             &pinfo2);
1570
1571                 if (!W_ERROR_IS_OK(result)) {
1572                         continue;
1573                 }
1574
1575                 if (!pinfo2->drivername) {
1576                         continue;
1577                 }
1578
1579                 if (strcmp(drivername, pinfo2->drivername) != 0) {
1580                         continue;
1581                 }
1582
1583                 DEBUG(6,("Updating printer [%s]\n", pinfo2->printername));
1584
1585                 /* all we care about currently is the change_id */
1586                 result = winreg_printer_update_changeid(tmp_ctx, b,
1587                                                         pinfo2->printername);
1588
1589                 if (!W_ERROR_IS_OK(result)) {
1590                         DEBUG(3, ("do_drv_upgrade_printer: "
1591                                   "Failed to update changeid [%s]\n",
1592                                   win_errstr(result)));
1593                 }
1594         }
1595
1596         /* all done */
1597 done:
1598         talloc_free(tmp_ctx);
1599 }
1600
1601 /********************************************************************
1602  Update the cache for all printq's with a registered client
1603  connection
1604  ********************************************************************/
1605
1606 void update_monitored_printq_cache(struct messaging_context *msg_ctx)
1607 {
1608         struct printer_handle *printer = printers_list;
1609         int snum;
1610
1611         /* loop through all printers and update the cache where
1612            a client is connected */
1613         while (printer) {
1614                 if ((printer->printer_type == SPLHND_PRINTER) &&
1615                     ((printer->notify.cli_chan != NULL) &&
1616                      (printer->notify.cli_chan->active_connections > 0))) {
1617                         snum = print_queue_snum(printer->sharename);
1618                         print_queue_status(msg_ctx, snum, NULL, NULL);
1619                 }
1620
1621                 printer = printer->next;
1622         }
1623
1624         return;
1625 }
1626
1627 /****************************************************************
1628  _spoolss_OpenPrinter
1629 ****************************************************************/
1630
1631 WERROR _spoolss_OpenPrinter(struct pipes_struct *p,
1632                             struct spoolss_OpenPrinter *r)
1633 {
1634         struct spoolss_OpenPrinterEx e;
1635         WERROR werr;
1636
1637         ZERO_STRUCT(e.in.userlevel);
1638
1639         e.in.printername        = r->in.printername;
1640         e.in.datatype           = r->in.datatype;
1641         e.in.devmode_ctr        = r->in.devmode_ctr;
1642         e.in.access_mask        = r->in.access_mask;
1643         e.in.level              = 0;
1644
1645         e.out.handle            = r->out.handle;
1646
1647         werr = _spoolss_OpenPrinterEx(p, &e);
1648
1649         if (W_ERROR_EQUAL(werr, WERR_INVALID_PARAM)) {
1650                 /* OpenPrinterEx returns this for a bad
1651                  * printer name. We must return WERR_INVALID_PRINTER_NAME
1652                  * instead.
1653                  */
1654                 werr = WERR_INVALID_PRINTER_NAME;
1655         }
1656
1657         return werr;
1658 }
1659
1660 static WERROR copy_devicemode(TALLOC_CTX *mem_ctx,
1661                               struct spoolss_DeviceMode *orig,
1662                               struct spoolss_DeviceMode **dest)
1663 {
1664         struct spoolss_DeviceMode *dm;
1665
1666         dm = talloc(mem_ctx, struct spoolss_DeviceMode);
1667         if (!dm) {
1668                 return WERR_NOMEM;
1669         }
1670
1671         /* copy all values, then duplicate strings and structs */
1672         *dm = *orig;
1673
1674         dm->devicename = talloc_strdup(dm, orig->devicename);
1675         if (!dm->devicename) {
1676                 return WERR_NOMEM;
1677         }
1678         dm->formname = talloc_strdup(dm, orig->formname);
1679         if (!dm->formname) {
1680                 return WERR_NOMEM;
1681         }
1682         if (orig->driverextra_data.data) {
1683                 dm->driverextra_data.data =
1684                         (uint8_t *) talloc_memdup(dm, orig->driverextra_data.data,
1685                                         orig->driverextra_data.length);
1686                 if (!dm->driverextra_data.data) {
1687                         return WERR_NOMEM;
1688                 }
1689         }
1690
1691         *dest = dm;
1692         return WERR_OK;
1693 }
1694
1695 /****************************************************************
1696  _spoolss_OpenPrinterEx
1697 ****************************************************************/
1698
1699 WERROR _spoolss_OpenPrinterEx(struct pipes_struct *p,
1700                               struct spoolss_OpenPrinterEx *r)
1701 {
1702         int snum;
1703         char *raddr;
1704         char *rhost;
1705         struct printer_handle *Printer=NULL;
1706         WERROR result;
1707         int rc;
1708
1709         if (!r->in.printername) {
1710                 return WERR_INVALID_PARAM;
1711         }
1712
1713         if (!*r->in.printername) {
1714                 return WERR_INVALID_PARAM;
1715         }
1716
1717         if (r->in.level > 3) {
1718                 return WERR_INVALID_PARAM;
1719         }
1720         if ((r->in.level == 1 && !r->in.userlevel.level1) ||
1721             (r->in.level == 2 && !r->in.userlevel.level2) ||
1722             (r->in.level == 3 && !r->in.userlevel.level3)) {
1723                 return WERR_INVALID_PARAM;
1724         }
1725
1726         /* some sanity check because you can open a printer or a print server */
1727         /* aka: \\server\printer or \\server */
1728
1729         DEBUGADD(3,("checking name: %s\n", r->in.printername));
1730
1731         result = open_printer_hnd(p, r->out.handle, r->in.printername, 0);
1732         if (!W_ERROR_IS_OK(result)) {
1733                 DEBUG(0,("_spoolss_OpenPrinterEx: Cannot open a printer handle "
1734                         "for printer %s\n", r->in.printername));
1735                 ZERO_STRUCTP(r->out.handle);
1736                 return result;
1737         }
1738
1739         Printer = find_printer_index_by_hnd(p, r->out.handle);
1740         if ( !Printer ) {
1741                 DEBUG(0,("_spoolss_OpenPrinterEx: logic error.  Can't find printer "
1742                         "handle we created for printer %s\n", r->in.printername));
1743                 close_printer_handle(p, r->out.handle);
1744                 ZERO_STRUCTP(r->out.handle);
1745                 return WERR_INVALID_PARAM;
1746         }
1747
1748         /*
1749          * First case: the user is opening the print server:
1750          *
1751          * Disallow MS AddPrinterWizard if parameter disables it. A Win2k
1752          * client 1st tries an OpenPrinterEx with access==0, MUST be allowed.
1753          *
1754          * Then both Win2k and WinNT clients try an OpenPrinterEx with
1755          * SERVER_ALL_ACCESS, which we allow only if the user is root (uid=0)
1756          * or if the user is listed in the smb.conf printer admin parameter.
1757          *
1758          * Then they try OpenPrinterEx with SERVER_READ which we allow. This lets the
1759          * client view printer folder, but does not show the MSAPW.
1760          *
1761          * Note: this test needs code to check access rights here too. Jeremy
1762          * could you look at this?
1763          *
1764          * Second case: the user is opening a printer:
1765          * NT doesn't let us connect to a printer if the connecting user
1766          * doesn't have print permission.
1767          *
1768          * Third case: user is opening a Port Monitor
1769          * access checks same as opening a handle to the print server.
1770          */
1771
1772         switch (Printer->printer_type )
1773         {
1774         case SPLHND_SERVER:
1775         case SPLHND_PORTMON_TCP:
1776         case SPLHND_PORTMON_LOCAL:
1777                 /* Printserver handles use global struct... */
1778
1779                 snum = -1;
1780
1781                 /* Map standard access rights to object specific access rights */
1782
1783                 se_map_standard(&r->in.access_mask,
1784                                 &printserver_std_mapping);
1785
1786                 /* Deny any object specific bits that don't apply to print
1787                    servers (i.e printer and job specific bits) */
1788
1789                 r->in.access_mask &= SEC_MASK_SPECIFIC;
1790
1791                 if (r->in.access_mask &
1792                     ~(SERVER_ACCESS_ADMINISTER | SERVER_ACCESS_ENUMERATE)) {
1793                         DEBUG(3, ("access DENIED for non-printserver bits\n"));
1794                         close_printer_handle(p, r->out.handle);
1795                         ZERO_STRUCTP(r->out.handle);
1796                         return WERR_ACCESS_DENIED;
1797                 }
1798
1799                 /* Allow admin access */
1800
1801                 if ( r->in.access_mask & SERVER_ACCESS_ADMINISTER )
1802                 {
1803                         if (!lp_ms_add_printer_wizard()) {
1804                                 close_printer_handle(p, r->out.handle);
1805                                 ZERO_STRUCTP(r->out.handle);
1806                                 return WERR_ACCESS_DENIED;
1807                         }
1808
1809                         /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
1810                            and not a printer admin, then fail */
1811
1812                         if ((p->session_info->unix_token->uid != sec_initial_uid()) &&
1813                             !security_token_has_privilege(p->session_info->security_token, SEC_PRIV_PRINT_OPERATOR) &&
1814                             !nt_token_check_sid(&global_sid_Builtin_Print_Operators,
1815                                                 p->session_info->security_token)) {
1816                                 close_printer_handle(p, r->out.handle);
1817                                 ZERO_STRUCTP(r->out.handle);
1818                                 DEBUG(3,("access DENIED as user is not root, "
1819                                         "has no printoperator privilege, "
1820                                         "not a member of the printoperator builtin group and "
1821                                         "is not in printer admin list"));
1822                                 return WERR_ACCESS_DENIED;
1823                         }
1824
1825                         r->in.access_mask = SERVER_ACCESS_ADMINISTER;
1826                 }
1827                 else
1828                 {
1829                         r->in.access_mask = SERVER_ACCESS_ENUMERATE;
1830                 }
1831
1832                 DEBUG(4,("Setting print server access = %s\n", (r->in.access_mask == SERVER_ACCESS_ADMINISTER)
1833                         ? "SERVER_ACCESS_ADMINISTER" : "SERVER_ACCESS_ENUMERATE" ));
1834
1835                 /* We fall through to return WERR_OK */
1836                 break;
1837
1838         case SPLHND_PRINTER:
1839                 /* NT doesn't let us connect to a printer if the connecting user
1840                    doesn't have print permission.  */
1841
1842                 if (!get_printer_snum(p, r->out.handle, &snum, NULL)) {
1843                         close_printer_handle(p, r->out.handle);
1844                         ZERO_STRUCTP(r->out.handle);
1845                         return WERR_BADFID;
1846                 }
1847
1848                 if (r->in.access_mask == SEC_FLAG_MAXIMUM_ALLOWED) {
1849                         r->in.access_mask = PRINTER_ACCESS_ADMINISTER;
1850                 }
1851
1852                 se_map_standard(&r->in.access_mask, &printer_std_mapping);
1853
1854                 /* map an empty access mask to the minimum access mask */
1855                 if (r->in.access_mask == 0x0)
1856                         r->in.access_mask = PRINTER_ACCESS_USE;
1857
1858                 /*
1859                  * If we are not serving the printer driver for this printer,
1860                  * map PRINTER_ACCESS_ADMINISTER to PRINTER_ACCESS_USE.  This
1861                  * will keep NT clients happy  --jerry
1862                  */
1863
1864                 if (lp_use_client_driver(snum)
1865                         && (r->in.access_mask & PRINTER_ACCESS_ADMINISTER))
1866                 {
1867                         r->in.access_mask = PRINTER_ACCESS_USE;
1868                 }
1869
1870                 /* check smb.conf parameters and the the sec_desc */
1871                 raddr = tsocket_address_inet_addr_string(p->remote_address,
1872                                                          p->mem_ctx);
1873                 if (raddr == NULL) {
1874                         return WERR_NOMEM;
1875                 }
1876
1877                 rc = get_remote_hostname(p->remote_address,
1878                                          &rhost,
1879                                          p->mem_ctx);
1880                 if (rc < 0) {
1881                         return WERR_NOMEM;
1882                 }
1883                 if (strequal(rhost, "UNKNOWN")) {
1884                         rhost = raddr;
1885                 }
1886
1887                 if (!allow_access(lp_hostsdeny(snum), lp_hostsallow(snum),
1888                                   rhost, raddr)) {
1889                         DEBUG(3, ("access DENIED (hosts allow/deny) for printer open\n"));
1890                         ZERO_STRUCTP(r->out.handle);
1891                         return WERR_ACCESS_DENIED;
1892                 }
1893
1894                 if (!user_ok_token(uidtoname(p->session_info->unix_token->uid), NULL,
1895                                    p->session_info->security_token, snum) ||
1896                     !print_access_check(p->session_info,
1897                                         p->msg_ctx,
1898                                         snum,
1899                                         r->in.access_mask)) {
1900                         DEBUG(3, ("access DENIED for printer open\n"));
1901                         close_printer_handle(p, r->out.handle);
1902                         ZERO_STRUCTP(r->out.handle);
1903                         return WERR_ACCESS_DENIED;
1904                 }
1905
1906                 if ((r->in.access_mask & SEC_MASK_SPECIFIC)& ~(PRINTER_ACCESS_ADMINISTER|PRINTER_ACCESS_USE)) {
1907                         DEBUG(3, ("access DENIED for printer open - unknown bits\n"));
1908                         close_printer_handle(p, r->out.handle);
1909                         ZERO_STRUCTP(r->out.handle);
1910                         return WERR_ACCESS_DENIED;
1911                 }
1912
1913                 if (r->in.access_mask & PRINTER_ACCESS_ADMINISTER)
1914                         r->in.access_mask = PRINTER_ACCESS_ADMINISTER;
1915                 else
1916                         r->in.access_mask = PRINTER_ACCESS_USE;
1917
1918                 DEBUG(4,("Setting printer access = %s\n", (r->in.access_mask == PRINTER_ACCESS_ADMINISTER)
1919                         ? "PRINTER_ACCESS_ADMINISTER" : "PRINTER_ACCESS_USE" ));
1920
1921                 winreg_create_printer_internal(p->mem_ctx,
1922                                       get_session_info_system(),
1923                                       p->msg_ctx,
1924                                       lp_const_servicename(snum));
1925
1926                 break;
1927
1928         default:
1929                 /* sanity check to prevent programmer error */
1930                 ZERO_STRUCTP(r->out.handle);
1931                 return WERR_BADFID;
1932         }
1933
1934         Printer->access_granted = r->in.access_mask;
1935
1936         /*
1937          * If the client sent a devmode in the OpenPrinter() call, then
1938          * save it here in case we get a job submission on this handle
1939          */
1940
1941          if ((Printer->printer_type != SPLHND_SERVER)
1942           && (r->in.devmode_ctr.devmode != NULL)) {
1943                 copy_devicemode(NULL, r->in.devmode_ctr.devmode,
1944                                 &Printer->devmode);
1945          }
1946
1947         return WERR_OK;
1948 }
1949
1950 /****************************************************************
1951  _spoolss_ClosePrinter
1952 ****************************************************************/
1953
1954 WERROR _spoolss_ClosePrinter(struct pipes_struct *p,
1955                              struct spoolss_ClosePrinter *r)
1956 {
1957         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
1958
1959         if (Printer && Printer->document_started) {
1960                 struct spoolss_EndDocPrinter e;
1961
1962                 e.in.handle = r->in.handle;
1963
1964                 _spoolss_EndDocPrinter(p, &e);
1965         }
1966
1967         if (!close_printer_handle(p, r->in.handle))
1968                 return WERR_BADFID;
1969
1970         /* clear the returned printer handle.  Observed behavior
1971            from Win2k server.  Don't think this really matters.
1972            Previous code just copied the value of the closed
1973            handle.    --jerry */
1974
1975         ZERO_STRUCTP(r->out.handle);
1976
1977         return WERR_OK;
1978 }
1979
1980 /****************************************************************
1981  _spoolss_DeletePrinter
1982 ****************************************************************/
1983
1984 WERROR _spoolss_DeletePrinter(struct pipes_struct *p,
1985                               struct spoolss_DeletePrinter *r)
1986 {
1987         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
1988         WERROR result;
1989         int snum;
1990
1991         if (Printer && Printer->document_started) {
1992                 struct spoolss_EndDocPrinter e;
1993
1994                 e.in.handle = r->in.handle;
1995
1996                 _spoolss_EndDocPrinter(p, &e);
1997         }
1998
1999         if (get_printer_snum(p, r->in.handle, &snum, NULL)) {
2000                 winreg_delete_printer_key_internal(p->mem_ctx,
2001                                           get_session_info_system(),
2002                                           p->msg_ctx,
2003                                           lp_const_servicename(snum),
2004                                           "");
2005         }
2006
2007         result = delete_printer_handle(p, r->in.handle);
2008
2009         return result;
2010 }
2011
2012 /*******************************************************************
2013  * static function to lookup the version id corresponding to an
2014  * long architecture string
2015  ******************************************************************/
2016
2017 static const struct print_architecture_table_node archi_table[]= {
2018
2019         {"Windows 4.0",          SPL_ARCH_WIN40,        0 },
2020         {"Windows NT x86",       SPL_ARCH_W32X86,       2 },
2021         {"Windows NT R4000",     SPL_ARCH_W32MIPS,      2 },
2022         {"Windows NT Alpha_AXP", SPL_ARCH_W32ALPHA,     2 },
2023         {"Windows NT PowerPC",   SPL_ARCH_W32PPC,       2 },
2024         {"Windows IA64",         SPL_ARCH_IA64,         3 },
2025         {"Windows x64",          SPL_ARCH_X64,          3 },
2026         {NULL,                   "",            -1 }
2027 };
2028
2029 static const int drv_cversion[] = {SPOOLSS_DRIVER_VERSION_9X,
2030                                    SPOOLSS_DRIVER_VERSION_NT35,
2031                                    SPOOLSS_DRIVER_VERSION_NT4,
2032                                    SPOOLSS_DRIVER_VERSION_200X,
2033                                    -1};
2034
2035 static int get_version_id(const char *arch)
2036 {
2037         int i;
2038
2039         for (i=0; archi_table[i].long_archi != NULL; i++)
2040         {
2041                 if (strcmp(arch, archi_table[i].long_archi) == 0)
2042                         return (archi_table[i].version);
2043         }
2044
2045         return -1;
2046 }
2047
2048 /****************************************************************
2049  _spoolss_DeletePrinterDriver
2050 ****************************************************************/
2051
2052 WERROR _spoolss_DeletePrinterDriver(struct pipes_struct *p,
2053                                     struct spoolss_DeletePrinterDriver *r)
2054 {
2055
2056         struct spoolss_DriverInfo8 *info = NULL;
2057         int                             version;
2058         WERROR                          status;
2059         struct dcerpc_binding_handle *b;
2060         TALLOC_CTX *tmp_ctx = NULL;
2061         int i;
2062         bool found;
2063
2064         /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
2065            and not a printer admin, then fail */
2066
2067         if ((p->session_info->unix_token->uid != sec_initial_uid()) &&
2068             !security_token_has_privilege(p->session_info->security_token,
2069                                           SEC_PRIV_PRINT_OPERATOR)) {
2070                 return WERR_ACCESS_DENIED;
2071         }
2072
2073         /* check that we have a valid driver name first */
2074
2075         if ((version = get_version_id(r->in.architecture)) == -1) {
2076                 return WERR_INVALID_ENVIRONMENT;
2077         }
2078
2079         tmp_ctx = talloc_new(p->mem_ctx);
2080         if (!tmp_ctx) {
2081                 return WERR_NOMEM;
2082         }
2083
2084         status = winreg_printer_binding_handle(tmp_ctx,
2085                                                get_session_info_system(),
2086                                                p->msg_ctx,
2087                                                &b);
2088         if (!W_ERROR_IS_OK(status)) {
2089                 goto done;
2090         }
2091
2092         for (found = false, i = 0; drv_cversion[i] >= 0; i++) {
2093                 status = winreg_get_driver(tmp_ctx, b,
2094                                            r->in.architecture, r->in.driver,
2095                                            drv_cversion[i], &info);
2096                 if (!W_ERROR_IS_OK(status)) {
2097                         DEBUG(5, ("skipping del of driver with version %d\n",
2098                                   drv_cversion[i]));
2099                         continue;
2100                 }
2101                 found = true;
2102
2103                 if (printer_driver_in_use(tmp_ctx, b, info)) {
2104                         status = WERR_PRINTER_DRIVER_IN_USE;
2105                         goto done;
2106                 }
2107
2108                 status = winreg_del_driver(tmp_ctx, b, info, drv_cversion[i]);
2109                 if (!W_ERROR_IS_OK(status)) {
2110                         DEBUG(0, ("failed del of driver with version %d\n",
2111                                   drv_cversion[i]));
2112                         goto done;
2113                 }
2114         }
2115         if (found == false) {
2116                 DEBUG(0, ("driver %s not found for deletion\n", r->in.driver));
2117                 status = WERR_UNKNOWN_PRINTER_DRIVER;
2118         } else {
2119                 status = WERR_OK;
2120         }
2121
2122 done:
2123         talloc_free(tmp_ctx);
2124
2125         return status;
2126 }
2127
2128 static WERROR spoolss_dpd_version(TALLOC_CTX *mem_ctx,
2129                                   struct pipes_struct *p,
2130                                   struct spoolss_DeletePrinterDriverEx *r,
2131                                   struct dcerpc_binding_handle *b,
2132                                   struct spoolss_DriverInfo8 *info)
2133 {
2134         WERROR status;
2135         bool delete_files;
2136
2137         if (printer_driver_in_use(mem_ctx, b, info)) {
2138                 status = WERR_PRINTER_DRIVER_IN_USE;
2139                 goto done;
2140         }
2141
2142         /*
2143          * we have a couple of cases to consider.
2144          * (1) Are any files in use?  If so and DPD_DELETE_ALL_FILES is set,
2145          *     then the delete should fail if **any** files overlap with
2146          *     other drivers
2147          * (2) If DPD_DELETE_UNUSED_FILES is set, then delete all
2148          *     non-overlapping files
2149          * (3) If neither DPD_DELETE_ALL_FILES nor DPD_DELETE_UNUSED_FILES
2150          *     are set, then do not delete any files
2151          * Refer to MSDN docs on DeletePrinterDriverEx() for details.
2152          */
2153
2154         delete_files = r->in.delete_flags
2155                         & (DPD_DELETE_ALL_FILES | DPD_DELETE_UNUSED_FILES);
2156
2157
2158         if (delete_files) {
2159                 bool in_use = printer_driver_files_in_use(mem_ctx, b, info);
2160                 if (in_use && (r->in.delete_flags & DPD_DELETE_ALL_FILES)) {
2161                         status = WERR_PRINTER_DRIVER_IN_USE;
2162                         goto done;
2163                 }
2164                 /*
2165                  * printer_driver_files_in_use() has trimmed overlapping files
2166                  * from info so they are not removed on DPD_DELETE_UNUSED_FILES
2167                  */
2168         }
2169
2170
2171         status = winreg_del_driver(mem_ctx, b, info, info->version);
2172         if (!W_ERROR_IS_OK(status)) {
2173                 goto done;
2174         }
2175
2176         /*
2177          * now delete any associated files if delete_files is
2178          * true. Even if this part failes, we return succes
2179          * because the driver doesn not exist any more
2180          */
2181         if (delete_files) {
2182                 delete_driver_files(p->session_info, info);
2183         }
2184
2185 done:
2186         return status;
2187 }
2188
2189 /****************************************************************
2190  _spoolss_DeletePrinterDriverEx
2191 ****************************************************************/
2192
2193 WERROR _spoolss_DeletePrinterDriverEx(struct pipes_struct *p,
2194                                       struct spoolss_DeletePrinterDriverEx *r)
2195 {
2196         struct spoolss_DriverInfo8 *info = NULL;
2197         WERROR                          status;
2198         struct dcerpc_binding_handle *b;
2199         TALLOC_CTX *tmp_ctx = NULL;
2200         int i;
2201         bool found;
2202
2203         /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
2204            and not a printer admin, then fail */
2205
2206         if ((p->session_info->unix_token->uid != sec_initial_uid()) &&
2207             !security_token_has_privilege(p->session_info->security_token,
2208                                           SEC_PRIV_PRINT_OPERATOR)) {
2209                 return WERR_ACCESS_DENIED;
2210         }
2211
2212         /* check that we have a valid driver name first */
2213         if (get_version_id(r->in.architecture) == -1) {
2214                 /* this is what NT returns */
2215                 return WERR_INVALID_ENVIRONMENT;
2216         }
2217
2218         tmp_ctx = talloc_new(p->mem_ctx);
2219         if (!tmp_ctx) {
2220                 return WERR_NOMEM;
2221         }
2222
2223         status = winreg_printer_binding_handle(tmp_ctx,
2224                                                get_session_info_system(),
2225                                                p->msg_ctx,
2226                                                &b);
2227         if (!W_ERROR_IS_OK(status)) {
2228                 goto done;
2229         }
2230
2231         for (found = false, i = 0; drv_cversion[i] >= 0; i++) {
2232                 if ((r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION)
2233                  && (drv_cversion[i] != r->in.version)) {
2234                         continue;
2235                 }
2236
2237                 /* check if a driver with this version exists before delete */
2238                 status = winreg_get_driver(tmp_ctx, b,
2239                                            r->in.architecture, r->in.driver,
2240                                            drv_cversion[i], &info);
2241                 if (!W_ERROR_IS_OK(status)) {
2242                         DEBUG(5, ("skipping del of driver with version %d\n",
2243                                   drv_cversion[i]));
2244                         continue;
2245                 }
2246                 found = true;
2247
2248                 status = spoolss_dpd_version(tmp_ctx, p, r, b, info);
2249                 if (!W_ERROR_IS_OK(status)) {
2250                         DEBUG(0, ("failed to delete driver with version %d\n",
2251                                   drv_cversion[i]));
2252                         goto done;
2253                 }
2254         }
2255         if (found == false) {
2256                 DEBUG(0, ("driver %s not found for deletion\n", r->in.driver));
2257                 status = WERR_UNKNOWN_PRINTER_DRIVER;
2258         } else {
2259                 status = WERR_OK;
2260         }
2261
2262 done:
2263         talloc_free(tmp_ctx);
2264         return status;
2265 }
2266
2267
2268 /********************************************************************
2269  GetPrinterData on a printer server Handle.
2270 ********************************************************************/
2271
2272 static WERROR getprinterdata_printer_server(TALLOC_CTX *mem_ctx,
2273                                             const char *value,
2274                                             enum winreg_Type *type,
2275                                             union spoolss_PrinterData *data)
2276 {
2277         DEBUG(8,("getprinterdata_printer_server:%s\n", value));
2278
2279         if (!strcasecmp_m(value, "W3SvcInstalled")) {
2280                 *type = REG_DWORD;
2281                 SIVAL(&data->value, 0, 0x00);
2282                 return WERR_OK;
2283         }
2284
2285         if (!strcasecmp_m(value, "BeepEnabled")) {
2286                 *type = REG_DWORD;
2287                 SIVAL(&data->value, 0, 0x00);
2288                 return WERR_OK;
2289         }
2290
2291         if (!strcasecmp_m(value, "EventLog")) {
2292                 *type = REG_DWORD;
2293                 /* formally was 0x1b */
2294                 SIVAL(&data->value, 0, 0x00);
2295                 return WERR_OK;
2296         }
2297
2298         if (!strcasecmp_m(value, "NetPopup")) {
2299                 *type = REG_DWORD;
2300                 SIVAL(&data->value, 0, 0x00);
2301                 return WERR_OK;
2302         }
2303
2304         if (!strcasecmp_m(value, "MajorVersion")) {
2305                 *type = REG_DWORD;
2306
2307                 /* Windows NT 4.0 seems to not allow uploading of drivers
2308                    to a server that reports 0x3 as the MajorVersion.
2309                    need to investigate more how Win2k gets around this .
2310                    -- jerry */
2311
2312                 if (RA_WINNT == get_remote_arch()) {
2313                         SIVAL(&data->value, 0, 0x02);
2314                 } else {
2315                         SIVAL(&data->value, 0, 0x03);
2316                 }
2317
2318                 return WERR_OK;
2319         }
2320
2321         if (!strcasecmp_m(value, "MinorVersion")) {
2322                 *type = REG_DWORD;
2323                 SIVAL(&data->value, 0, 0x00);
2324                 return WERR_OK;
2325         }
2326
2327         /* REG_BINARY
2328          *  uint32_t size        = 0x114
2329          *  uint32_t major       = 5
2330          *  uint32_t minor       = [0|1]
2331          *  uint32_t build       = [2195|2600]
2332          *  extra unicode string = e.g. "Service Pack 3"
2333          */
2334         if (!strcasecmp_m(value, "OSVersion")) {
2335                 DATA_BLOB blob;
2336                 enum ndr_err_code ndr_err;
2337                 struct spoolss_OSVersion os;
2338
2339                 os.major                = 5;    /* Windows 2000 == 5.0 */
2340                 os.minor                = 0;
2341                 os.build                = 2195; /* build */
2342                 os.extra_string         = "";   /* leave extra string empty */
2343
2344                 ndr_err = ndr_push_struct_blob(&blob, mem_ctx, &os,
2345                         (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion);
2346                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2347                         return WERR_GENERAL_FAILURE;
2348                 }
2349
2350                 *type = REG_BINARY;
2351                 data->binary = blob;
2352
2353                 return WERR_OK;
2354         }
2355
2356
2357         if (!strcasecmp_m(value, "DefaultSpoolDirectory")) {
2358                 *type = REG_SZ;
2359
2360                 data->string = talloc_strdup(mem_ctx, "C:\\PRINTERS");
2361                 W_ERROR_HAVE_NO_MEMORY(data->string);
2362
2363                 return WERR_OK;
2364         }
2365
2366         if (!strcasecmp_m(value, "Architecture")) {
2367                 *type = REG_SZ;
2368                 data->string = talloc_strdup(mem_ctx,
2369                         lp_parm_const_string(GLOBAL_SECTION_SNUM, "spoolss", "architecture", SPOOLSS_ARCHITECTURE_NT_X86));
2370                 W_ERROR_HAVE_NO_MEMORY(data->string);
2371
2372                 return WERR_OK;
2373         }
2374
2375         if (!strcasecmp_m(value, "DsPresent")) {
2376                 *type = REG_DWORD;
2377
2378                 /* only show the publish check box if we are a
2379                    member of a AD domain */
2380
2381                 if (lp_security() == SEC_ADS) {
2382                         SIVAL(&data->value, 0, 0x01);
2383                 } else {
2384                         SIVAL(&data->value, 0, 0x00);
2385                 }
2386                 return WERR_OK;
2387         }
2388
2389         if (!strcasecmp_m(value, "DNSMachineName")) {
2390                 const char *hostname = get_mydnsfullname();
2391
2392                 if (!hostname) {
2393                         return WERR_BADFILE;
2394                 }
2395
2396                 *type = REG_SZ;
2397                 data->string = talloc_strdup(mem_ctx, hostname);
2398                 W_ERROR_HAVE_NO_MEMORY(data->string);
2399
2400                 return WERR_OK;
2401         }
2402
2403         *type = REG_NONE;
2404
2405         return WERR_INVALID_PARAM;
2406 }
2407
2408 /****************************************************************
2409  _spoolss_GetPrinterData
2410 ****************************************************************/
2411
2412 WERROR _spoolss_GetPrinterData(struct pipes_struct *p,
2413                                struct spoolss_GetPrinterData *r)
2414 {
2415         struct spoolss_GetPrinterDataEx r2;
2416
2417         r2.in.handle            = r->in.handle;
2418         r2.in.key_name          = "PrinterDriverData";
2419         r2.in.value_name        = r->in.value_name;
2420         r2.in.offered           = r->in.offered;
2421         r2.out.type             = r->out.type;
2422         r2.out.data             = r->out.data;
2423         r2.out.needed           = r->out.needed;
2424
2425         return _spoolss_GetPrinterDataEx(p, &r2);
2426 }
2427
2428 /*********************************************************
2429  Connect to the client machine.
2430 **********************************************************/
2431
2432 static bool spoolss_connect_to_client(struct rpc_pipe_client **pp_pipe,
2433                         struct sockaddr_storage *client_ss, const char *remote_machine)
2434 {
2435         NTSTATUS ret;
2436         struct cli_state *the_cli;
2437         struct sockaddr_storage rm_addr;
2438         char addr[INET6_ADDRSTRLEN];
2439
2440         if ( is_zero_addr(client_ss) ) {
2441                 DEBUG(2,("spoolss_connect_to_client: resolving %s\n",
2442                         remote_machine));
2443                 if ( !resolve_name( remote_machine, &rm_addr, 0x20, false) ) {
2444                         DEBUG(2,("spoolss_connect_to_client: Can't resolve address for %s\n", remote_machine));
2445                         return false;
2446                 }
2447                 print_sockaddr(addr, sizeof(addr), &rm_addr);
2448         } else {
2449                 rm_addr = *client_ss;
2450                 print_sockaddr(addr, sizeof(addr), &rm_addr);
2451                 DEBUG(5,("spoolss_connect_to_client: Using address %s (no name resolution necessary)\n",
2452                         addr));
2453         }
2454
2455         if (ismyaddr((struct sockaddr *)(void *)&rm_addr)) {
2456                 DEBUG(0,("spoolss_connect_to_client: Machine %s is one of our addresses. Cannot add to ourselves.\n",
2457                         addr));
2458                 return false;
2459         }
2460
2461         /* setup the connection */
2462         ret = cli_full_connection( &the_cli, lp_netbios_name(), remote_machine,
2463                 &rm_addr, 0, "IPC$", "IPC",
2464                 "", /* username */
2465                 "", /* domain */
2466                 "", /* password */
2467                 0, lp_client_signing());
2468
2469         if ( !NT_STATUS_IS_OK( ret ) ) {
2470                 DEBUG(2,("spoolss_connect_to_client: connection to [%s] failed!\n",
2471                         remote_machine ));
2472                 return false;
2473         }
2474
2475         if ( smbXcli_conn_protocol(the_cli->conn) != PROTOCOL_NT1 ) {
2476                 DEBUG(0,("spoolss_connect_to_client: machine %s didn't negotiate NT protocol.\n", remote_machine));
2477                 cli_shutdown(the_cli);
2478                 return false;
2479         }
2480
2481         /*
2482          * Ok - we have an anonymous connection to the IPC$ share.
2483          * Now start the NT Domain stuff :-).
2484          */
2485
2486         ret = cli_rpc_pipe_open_noauth(the_cli, &ndr_table_spoolss.syntax_id, pp_pipe);
2487         if (!NT_STATUS_IS_OK(ret)) {
2488                 DEBUG(2,("spoolss_connect_to_client: unable to open the spoolss pipe on machine %s. Error was : %s.\n",
2489                         remote_machine, nt_errstr(ret)));
2490                 cli_shutdown(the_cli);
2491                 return false;
2492         }
2493
2494         return true;
2495 }
2496
2497 /***************************************************************************
2498  Connect to the client.
2499 ****************************************************************************/
2500
2501 static bool srv_spoolss_replyopenprinter(int snum, const char *printer,
2502                                         uint32_t localprinter,
2503                                         enum winreg_Type type,
2504                                         struct policy_handle *handle,
2505                                         struct notify_back_channel **_chan,
2506                                         struct sockaddr_storage *client_ss,
2507                                         struct messaging_context *msg_ctx)
2508 {
2509         WERROR result;
2510         NTSTATUS status;
2511         struct notify_back_channel *chan;
2512
2513         for (chan = back_channels; chan; chan = chan->next) {
2514                 if (memcmp(&chan->client_address, client_ss,
2515                            sizeof(struct sockaddr_storage)) == 0) {
2516                         break;
2517                 }
2518         }
2519
2520         /*
2521          * If it's the first connection, contact the client
2522          * and connect to the IPC$ share anonymously
2523          */
2524         if (!chan) {
2525                 fstring unix_printer;
2526
2527                 /* the +2 is to strip the leading 2 backslashs */
2528                 fstrcpy(unix_printer, printer + 2);
2529
2530                 chan = talloc_zero(NULL, struct notify_back_channel);
2531                 if (!chan) {
2532                         return false;
2533                 }
2534                 chan->client_address = *client_ss;
2535
2536                 if (!spoolss_connect_to_client(&chan->cli_pipe, client_ss, unix_printer)) {
2537                         TALLOC_FREE(chan);
2538                         return false;
2539                 }
2540
2541                 DLIST_ADD(back_channels, chan);
2542
2543                 messaging_register(msg_ctx, NULL, MSG_PRINTER_NOTIFY2,
2544                                    receive_notify2_message_list);
2545         }
2546
2547         if (chan->cli_pipe == NULL ||
2548             chan->cli_pipe->binding_handle == NULL) {
2549                 DEBUG(0, ("srv_spoolss_replyopenprinter: error - "
2550                         "NULL %s for printer %s\n",
2551                         chan->cli_pipe == NULL ?
2552                         "chan->cli_pipe" : "chan->cli_pipe->binding_handle",
2553                         printer));
2554                 return false;
2555         }
2556
2557         /*
2558          * Tell the specific printing tdb we want messages for this printer
2559          * by registering our PID.
2560          */
2561
2562         if (!print_notify_register_pid(snum)) {
2563                 DEBUG(0, ("Failed to register our pid for printer %s\n",
2564                           printer));
2565         }
2566
2567         status = dcerpc_spoolss_ReplyOpenPrinter(chan->cli_pipe->binding_handle,
2568                                                  talloc_tos(),
2569                                                  printer,
2570                                                  localprinter,
2571                                                  type,
2572                                                  0,
2573                                                  NULL,
2574                                                  handle,
2575                                                  &result);
2576         if (!NT_STATUS_IS_OK(status)) {
2577                 DEBUG(5, ("dcerpc_spoolss_ReplyOpenPrinter returned [%s]\n", nt_errstr(status)));
2578                 result = ntstatus_to_werror(status);
2579         } else if (!W_ERROR_IS_OK(result)) {
2580                 DEBUG(5, ("ReplyOpenPrinter returned [%s]\n", win_errstr(result)));
2581         }
2582
2583         chan->active_connections++;
2584         *_chan = chan;
2585
2586         return (W_ERROR_IS_OK(result));
2587 }
2588
2589 /****************************************************************
2590  ****************************************************************/
2591
2592 static struct spoolss_NotifyOption *dup_spoolss_NotifyOption(TALLOC_CTX *mem_ctx,
2593                                                              const struct spoolss_NotifyOption *r)
2594 {
2595         struct spoolss_NotifyOption *option;
2596         uint32_t i,k;
2597
2598         if (!r) {
2599                 return NULL;
2600         }
2601
2602         option = talloc_zero(mem_ctx, struct spoolss_NotifyOption);
2603         if (!option) {
2604                 return NULL;
2605         }
2606
2607         *option = *r;
2608
2609         if (!option->count) {
2610                 return option;
2611         }
2612
2613         option->types = talloc_zero_array(option,
2614                 struct spoolss_NotifyOptionType, option->count);
2615         if (!option->types) {
2616                 talloc_free(option);
2617                 return NULL;
2618         }
2619
2620         for (i=0; i < option->count; i++) {
2621                 option->types[i] = r->types[i];
2622
2623                 if (option->types[i].count) {
2624                         option->types[i].fields = talloc_zero_array(option,
2625                                 union spoolss_Field, option->types[i].count);
2626                         if (!option->types[i].fields) {
2627                                 talloc_free(option);
2628                                 return NULL;
2629                         }
2630                         for (k=0; k<option->types[i].count; k++) {
2631                                 option->types[i].fields[k] =
2632                                         r->types[i].fields[k];
2633                         }
2634                 }
2635         }
2636
2637         return option;
2638 }
2639
2640 /****************************************************************
2641  * _spoolss_RemoteFindFirstPrinterChangeNotifyEx
2642  *
2643  * before replying OK: status=0 a rpc call is made to the workstation
2644  * asking ReplyOpenPrinter
2645  *
2646  * in fact ReplyOpenPrinter is the changenotify equivalent on the spoolss pipe
2647  * called from api_spoolss_rffpcnex
2648 ****************************************************************/
2649
2650 WERROR _spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct pipes_struct *p,
2651                                                      struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
2652 {
2653         int snum = -1;
2654         struct spoolss_NotifyOption *option = r->in.notify_options;
2655         struct sockaddr_storage client_ss;
2656         ssize_t client_len;
2657
2658         /* store the notify value in the printer struct */
2659
2660         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
2661
2662         if (!Printer) {
2663                 DEBUG(2,("_spoolss_RemoteFindFirstPrinterChangeNotifyEx: "
2664                         "Invalid handle (%s:%u:%u).\n",
2665                         OUR_HANDLE(r->in.handle)));
2666                 return WERR_BADFID;
2667         }
2668
2669         Printer->notify.flags           = r->in.flags;
2670         Printer->notify.options         = r->in.options;
2671         Printer->notify.printerlocal    = r->in.printer_local;
2672         Printer->notify.msg_ctx         = p->msg_ctx;
2673
2674         TALLOC_FREE(Printer->notify.option);
2675         Printer->notify.option = dup_spoolss_NotifyOption(Printer, option);
2676
2677         fstrcpy(Printer->notify.localmachine, r->in.local_machine);
2678
2679         /* Connect to the client machine and send a ReplyOpenPrinter */
2680
2681         if ( Printer->printer_type == SPLHND_SERVER)
2682                 snum = -1;
2683         else if ( (Printer->printer_type == SPLHND_PRINTER) &&
2684                         !get_printer_snum(p, r->in.handle, &snum, NULL) )
2685                 return WERR_BADFID;
2686
2687         DEBUG(10,("_spoolss_RemoteFindFirstPrinterChangeNotifyEx: "
2688                   "remote_address is %s\n",
2689                   tsocket_address_string(p->remote_address, p->mem_ctx)));
2690
2691         if (!lp_print_notify_backchannel(snum)) {
2692                 DEBUG(10, ("_spoolss_RemoteFindFirstPrinterChangeNotifyEx: "
2693                         "backchannel disabled\n"));
2694                 return WERR_SERVER_UNAVAILABLE;
2695         }
2696
2697         client_len = tsocket_address_bsd_sockaddr(p->remote_address,
2698                                                   (struct sockaddr *) &client_ss,
2699                                                   sizeof(struct sockaddr_storage));
2700         if (client_len < 0) {
2701                 return WERR_NOMEM;
2702         }
2703
2704         if(!srv_spoolss_replyopenprinter(snum, Printer->notify.localmachine,
2705                                         Printer->notify.printerlocal, REG_SZ,
2706                                         &Printer->notify.cli_hnd,
2707                                         &Printer->notify.cli_chan,
2708                                         &client_ss, p->msg_ctx)) {
2709                 return WERR_SERVER_UNAVAILABLE;
2710         }
2711
2712         return WERR_OK;
2713 }
2714
2715 /*******************************************************************
2716  * fill a notify_info_data with the servername
2717  ********************************************************************/
2718
2719 static void spoolss_notify_server_name(struct messaging_context *msg_ctx,
2720                                        int snum,
2721                                        struct spoolss_Notify *data,
2722                                        print_queue_struct *queue,
2723                                        struct spoolss_PrinterInfo2 *pinfo2,
2724                                        TALLOC_CTX *mem_ctx)
2725 {
2726         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->servername);
2727 }
2728
2729 /*******************************************************************
2730  * fill a notify_info_data with the printername (not including the servername).
2731  ********************************************************************/
2732
2733 static void spoolss_notify_printer_name(struct messaging_context *msg_ctx,
2734                                         int snum,
2735                                         struct spoolss_Notify *data,
2736                                         print_queue_struct *queue,
2737                                         struct spoolss_PrinterInfo2 *pinfo2,
2738                                         TALLOC_CTX *mem_ctx)
2739 {
2740         /* the notify name should not contain the \\server\ part */
2741         const char *p = strrchr(pinfo2->printername, '\\');
2742
2743         if (!p) {
2744                 p = pinfo2->printername;
2745         } else {
2746                 p++;
2747         }
2748
2749         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, p);
2750 }
2751
2752 /*******************************************************************
2753  * fill a notify_info_data with the servicename
2754  ********************************************************************/
2755
2756 static void spoolss_notify_share_name(struct messaging_context *msg_ctx,
2757                                       int snum,
2758                                       struct spoolss_Notify *data,
2759                                       print_queue_struct *queue,
2760                                       struct spoolss_PrinterInfo2 *pinfo2,
2761                                       TALLOC_CTX *mem_ctx)
2762 {
2763         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, lp_servicename(talloc_tos(), snum));
2764 }
2765
2766 /*******************************************************************
2767  * fill a notify_info_data with the port name
2768  ********************************************************************/
2769
2770 static void spoolss_notify_port_name(struct messaging_context *msg_ctx,
2771                                      int snum,
2772                                      struct spoolss_Notify *data,
2773                                      print_queue_struct *queue,
2774                                      struct spoolss_PrinterInfo2 *pinfo2,
2775                                      TALLOC_CTX *mem_ctx)
2776 {
2777         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->portname);
2778 }
2779
2780 /*******************************************************************
2781  * fill a notify_info_data with the printername
2782  * but it doesn't exist, have to see what to do
2783  ********************************************************************/
2784
2785 static void spoolss_notify_driver_name(struct messaging_context *msg_ctx,
2786                                        int snum,
2787                                        struct spoolss_Notify *data,
2788                                        print_queue_struct *queue,
2789                                        struct spoolss_PrinterInfo2 *pinfo2,
2790                                        TALLOC_CTX *mem_ctx)
2791 {
2792         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->drivername);
2793 }
2794
2795 /*******************************************************************
2796  * fill a notify_info_data with the comment
2797  ********************************************************************/
2798
2799 static void spoolss_notify_comment(struct messaging_context *msg_ctx,
2800                                    int snum,
2801                                    struct spoolss_Notify *data,
2802                                    print_queue_struct *queue,
2803                                    struct spoolss_PrinterInfo2 *pinfo2,
2804                                    TALLOC_CTX *mem_ctx)
2805 {
2806         const char *p;
2807
2808         if (*pinfo2->comment == '\0') {
2809                 p = lp_comment(talloc_tos(), snum);
2810         } else {
2811                 p = pinfo2->comment;
2812         }
2813
2814         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, p);
2815 }
2816
2817 /*******************************************************************
2818  * fill a notify_info_data with the comment
2819  * location = "Room 1, floor 2, building 3"
2820  ********************************************************************/
2821
2822 static void spoolss_notify_location(struct messaging_context *msg_ctx,
2823                                     int snum,
2824                                     struct spoolss_Notify *data,
2825                                     print_queue_struct *queue,
2826                                     struct spoolss_PrinterInfo2 *pinfo2,
2827                                     TALLOC_CTX *mem_ctx)
2828 {
2829         const char *loc = pinfo2->location;
2830         NTSTATUS status;
2831
2832         status = printer_list_get_printer(mem_ctx,
2833                                           pinfo2->sharename,
2834                                           NULL,
2835                                           &loc,
2836                                           NULL);
2837         if (NT_STATUS_IS_OK(status)) {
2838                 if (loc == NULL) {
2839                         loc = pinfo2->location;
2840                 }
2841         }
2842
2843         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, loc);
2844 }
2845
2846 /*******************************************************************
2847  * fill a notify_info_data with the device mode
2848  * jfm:xxxx don't to it for know but that's a real problem !!!
2849  ********************************************************************/
2850
2851 static void spoolss_notify_devmode(struct messaging_context *msg_ctx,
2852                                    int snum,
2853                                    struct spoolss_Notify *data,
2854                                    print_queue_struct *queue,
2855                                    struct spoolss_PrinterInfo2 *pinfo2,
2856                                    TALLOC_CTX *mem_ctx)
2857 {
2858         /* for a dummy implementation we have to zero the fields */
2859         SETUP_SPOOLSS_NOTIFY_DATA_DEVMODE(data, NULL);
2860 }
2861
2862 /*******************************************************************
2863  * fill a notify_info_data with the separator file name
2864  ********************************************************************/
2865
2866 static void spoolss_notify_sepfile(struct messaging_context *msg_ctx,
2867                                    int snum,
2868                                    struct spoolss_Notify *data,
2869                                    print_queue_struct *queue,
2870                                    struct spoolss_PrinterInfo2 *pinfo2,
2871                                    TALLOC_CTX *mem_ctx)
2872 {
2873         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->sepfile);
2874 }
2875
2876 /*******************************************************************
2877  * fill a notify_info_data with the print processor
2878  * jfm:xxxx return always winprint to indicate we don't do anything to it
2879  ********************************************************************/
2880
2881 static void spoolss_notify_print_processor(struct messaging_context *msg_ctx,
2882                                            int snum,
2883                                            struct spoolss_Notify *data,
2884                                            print_queue_struct *queue,
2885                                            struct spoolss_PrinterInfo2 *pinfo2,
2886                                            TALLOC_CTX *mem_ctx)
2887 {
2888         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->printprocessor);
2889 }
2890
2891 /*******************************************************************
2892  * fill a notify_info_data with the print processor options
2893  * jfm:xxxx send an empty string
2894  ********************************************************************/
2895
2896 static void spoolss_notify_parameters(struct messaging_context *msg_ctx,
2897                                       int snum,
2898                                       struct spoolss_Notify *data,
2899                                       print_queue_struct *queue,
2900                                       struct spoolss_PrinterInfo2 *pinfo2,
2901                                       TALLOC_CTX *mem_ctx)
2902 {
2903         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->parameters);
2904 }
2905
2906 /*******************************************************************
2907  * fill a notify_info_data with the data type
2908  * jfm:xxxx always send RAW as data type
2909  ********************************************************************/
2910
2911 static void spoolss_notify_datatype(struct messaging_context *msg_ctx,
2912                                     int snum,
2913                                     struct spoolss_Notify *data,
2914                                     print_queue_struct *queue,
2915                                     struct spoolss_PrinterInfo2 *pinfo2,
2916                                     TALLOC_CTX *mem_ctx)
2917 {
2918         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->datatype);
2919 }
2920
2921 /*******************************************************************
2922  * fill a notify_info_data with the security descriptor
2923  * jfm:xxxx send an null pointer to say no security desc
2924  * have to implement security before !
2925  ********************************************************************/
2926
2927 static void spoolss_notify_security_desc(struct messaging_context *msg_ctx,
2928                                          int snum,
2929                                          struct spoolss_Notify *data,
2930                                          print_queue_struct *queue,
2931                                          struct spoolss_PrinterInfo2 *pinfo2,
2932                                          TALLOC_CTX *mem_ctx)
2933 {
2934         SETUP_SPOOLSS_NOTIFY_DATA_SECDESC(data, pinfo2->secdesc);
2935 }
2936
2937 /*******************************************************************
2938  * fill a notify_info_data with the attributes
2939  * jfm:xxxx a samba printer is always shared
2940  ********************************************************************/
2941
2942 static void spoolss_notify_attributes(struct messaging_context *msg_ctx,
2943                                       int snum,
2944                                       struct spoolss_Notify *data,
2945                                       print_queue_struct *queue,
2946                                       struct spoolss_PrinterInfo2 *pinfo2,
2947                                       TALLOC_CTX *mem_ctx)
2948 {
2949         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->attributes);
2950 }
2951
2952 /*******************************************************************
2953  * fill a notify_info_data with the priority
2954  ********************************************************************/
2955
2956 static void spoolss_notify_priority(struct messaging_context *msg_ctx,
2957                                     int snum,
2958                                     struct spoolss_Notify *data,
2959                                     print_queue_struct *queue,
2960                                     struct spoolss_PrinterInfo2 *pinfo2,
2961                                     TALLOC_CTX *mem_ctx)
2962 {
2963         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->priority);
2964 }
2965
2966 /*******************************************************************
2967  * fill a notify_info_data with the default priority
2968  ********************************************************************/
2969
2970 static void spoolss_notify_default_priority(struct messaging_context *msg_ctx,
2971                                             int snum,
2972                                             struct spoolss_Notify *data,
2973                                             print_queue_struct *queue,
2974                                             struct spoolss_PrinterInfo2 *pinfo2,
2975                                             TALLOC_CTX *mem_ctx)
2976 {
2977         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->defaultpriority);
2978 }
2979
2980 /*******************************************************************
2981  * fill a notify_info_data with the start time
2982  ********************************************************************/
2983
2984 static void spoolss_notify_start_time(struct messaging_context *msg_ctx,
2985                                       int snum,
2986                                       struct spoolss_Notify *data,
2987                                       print_queue_struct *queue,
2988                                       struct spoolss_PrinterInfo2 *pinfo2,
2989                                       TALLOC_CTX *mem_ctx)
2990 {
2991         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->starttime);
2992 }
2993
2994 /*******************************************************************
2995  * fill a notify_info_data with the until time
2996  ********************************************************************/
2997
2998 static void spoolss_notify_until_time(struct messaging_context *msg_ctx,
2999                                       int snum,
3000                                       struct spoolss_Notify *data,
3001                                       print_queue_struct *queue,
3002                                       struct spoolss_PrinterInfo2 *pinfo2,
3003                                       TALLOC_CTX *mem_ctx)
3004 {
3005         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->untiltime);
3006 }
3007
3008 /*******************************************************************
3009  * fill a notify_info_data with the status
3010  ********************************************************************/
3011
3012 static void spoolss_notify_status(struct messaging_context *msg_ctx,
3013                                   int snum,
3014                                   struct spoolss_Notify *data,
3015                                   print_queue_struct *queue,
3016                                   struct spoolss_PrinterInfo2 *pinfo2,
3017                                   TALLOC_CTX *mem_ctx)
3018 {
3019         print_status_struct status;
3020
3021         print_queue_length(msg_ctx, snum, &status);
3022         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, status.status);
3023 }
3024
3025 /*******************************************************************
3026  * fill a notify_info_data with the number of jobs queued
3027  ********************************************************************/
3028
3029 static void spoolss_notify_cjobs(struct messaging_context *msg_ctx,
3030                                  int snum,
3031                                  struct spoolss_Notify *data,
3032                                  print_queue_struct *queue,
3033                                  struct spoolss_PrinterInfo2 *pinfo2,
3034                                  TALLOC_CTX *mem_ctx)
3035 {
3036         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(
3037                 data, print_queue_length(msg_ctx, snum, NULL));
3038 }
3039
3040 /*******************************************************************
3041  * fill a notify_info_data with the average ppm
3042  ********************************************************************/
3043
3044 static void spoolss_notify_average_ppm(struct messaging_context *msg_ctx,
3045                                        int snum,
3046                                        struct spoolss_Notify *data,
3047                                        print_queue_struct *queue,
3048                                        struct spoolss_PrinterInfo2 *pinfo2,
3049                                        TALLOC_CTX *mem_ctx)
3050 {
3051         /* always respond 8 pages per minutes */
3052         /* a little hard ! */
3053         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->averageppm);
3054 }
3055
3056 /*******************************************************************
3057  * fill a notify_info_data with username
3058  ********************************************************************/
3059
3060 static void spoolss_notify_username(struct messaging_context *msg_ctx,
3061                                     int snum,
3062                                     struct spoolss_Notify *data,
3063                                     print_queue_struct *queue,
3064                                     struct spoolss_PrinterInfo2 *pinfo2,
3065                                     TALLOC_CTX *mem_ctx)
3066 {
3067         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, queue->fs_user);
3068 }
3069
3070 /*******************************************************************
3071  * fill a notify_info_data with job status
3072  ********************************************************************/
3073
3074 static void spoolss_notify_job_status(struct messaging_context *msg_ctx,
3075                                       int snum,
3076                                       struct spoolss_Notify *data,
3077                                       print_queue_struct *queue,
3078                                       struct spoolss_PrinterInfo2 *pinfo2,
3079                                       TALLOC_CTX *mem_ctx)
3080 {
3081         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, nt_printj_status(queue->status));
3082 }
3083
3084 /*******************************************************************
3085  * fill a notify_info_data with job name
3086  ********************************************************************/
3087
3088 static void spoolss_notify_job_name(struct messaging_context *msg_ctx,
3089                                     int snum,
3090                                     struct spoolss_Notify *data,
3091                                     print_queue_struct *queue,
3092                                     struct spoolss_PrinterInfo2 *pinfo2,
3093                                     TALLOC_CTX *mem_ctx)
3094 {
3095         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, queue->fs_file);
3096 }
3097
3098 /*******************************************************************
3099  * fill a notify_info_data with job status
3100  ********************************************************************/
3101
3102 static void spoolss_notify_job_status_string(struct messaging_context *msg_ctx,
3103                                              int snum,
3104                                              struct spoolss_Notify *data,
3105                                              print_queue_struct *queue,
3106                                              struct spoolss_PrinterInfo2 *pinfo2,
3107                                              TALLOC_CTX *mem_ctx)
3108 {
3109         /*
3110          * Now we're returning job status codes we just return a "" here. JRA.
3111          */
3112
3113         const char *p = "";
3114
3115 #if 0 /* NO LONGER NEEDED - JRA. 02/22/2001 */
3116         p = "unknown";
3117
3118         switch (queue->status) {
3119         case LPQ_QUEUED:
3120                 p = "Queued";
3121                 break;
3122         case LPQ_PAUSED:
3123                 p = "";    /* NT provides the paused string */
3124                 break;
3125         case LPQ_SPOOLING:
3126                 p = "Spooling";
3127                 break;
3128         case LPQ_PRINTING:
3129                 p = "Printing";
3130                 break;
3131         }
3132 #endif /* NO LONGER NEEDED. */
3133
3134         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, p);
3135 }
3136
3137 /*******************************************************************
3138  * fill a notify_info_data with job time
3139  ********************************************************************/
3140
3141 static void spoolss_notify_job_time(struct messaging_context *msg_ctx,
3142                                     int snum,
3143                                     struct spoolss_Notify *data,
3144                                     print_queue_struct *queue,
3145                                     struct spoolss_PrinterInfo2 *pinfo2,
3146                                     TALLOC_CTX *mem_ctx)
3147 {
3148         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, 0);
3149 }
3150
3151 /*******************************************************************
3152  * fill a notify_info_data with job size
3153  ********************************************************************/
3154
3155 static void spoolss_notify_job_size(struct messaging_context *msg_ctx,
3156                                     int snum,
3157                                     struct spoolss_Notify *data,
3158                                     print_queue_struct *queue,
3159                                     struct spoolss_PrinterInfo2 *pinfo2,
3160                                     TALLOC_CTX *mem_ctx)
3161 {
3162         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->size);
3163 }
3164
3165 /*******************************************************************
3166  * fill a notify_info_data with page info
3167  ********************************************************************/
3168 static void spoolss_notify_total_pages(struct messaging_context *msg_ctx,
3169                                        int snum,
3170                                 struct spoolss_Notify *data,
3171                                 print_queue_struct *queue,
3172                                 struct spoolss_PrinterInfo2 *pinfo2,
3173                                 TALLOC_CTX *mem_ctx)
3174 {
3175         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->page_count);
3176 }
3177
3178 /*******************************************************************
3179  * fill a notify_info_data with pages printed info.
3180  ********************************************************************/
3181 static void spoolss_notify_pages_printed(struct messaging_context *msg_ctx,
3182                                          int snum,
3183                                 struct spoolss_Notify *data,
3184                                 print_queue_struct *queue,
3185                                 struct spoolss_PrinterInfo2 *pinfo2,
3186                                 TALLOC_CTX *mem_ctx)
3187 {
3188         /* Add code when back-end tracks this */
3189         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, 0);
3190 }
3191
3192 /*******************************************************************
3193  Fill a notify_info_data with job position.
3194  ********************************************************************/
3195
3196 static void spoolss_notify_job_position(struct messaging_context *msg_ctx,
3197                                         int snum,
3198                                         struct spoolss_Notify *data,
3199                                         print_queue_struct *queue,
3200                                         struct spoolss_PrinterInfo2 *pinfo2,
3201                                         TALLOC_CTX *mem_ctx)
3202 {
3203         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->sysjob);
3204 }
3205
3206 /*******************************************************************
3207  Fill a notify_info_data with submitted time.
3208  ********************************************************************/
3209
3210 static void spoolss_notify_submitted_time(struct messaging_context *msg_ctx,
3211                                           int snum,
3212                                           struct spoolss_Notify *data,
3213                                           print_queue_struct *queue,
3214                                           struct spoolss_PrinterInfo2 *pinfo2,
3215                                           TALLOC_CTX *mem_ctx)
3216 {
3217         data->data.string.string = NULL;
3218         data->data.string.size = 0;
3219
3220         init_systemtime_buffer(mem_ctx, gmtime(&queue->time),
3221                                &data->data.string.string,
3222                                &data->data.string.size);
3223
3224 }
3225
3226 struct s_notify_info_data_table
3227 {
3228         enum spoolss_NotifyType type;
3229         uint16_t field;
3230         const char *name;
3231         enum spoolss_NotifyTable variable_type;
3232         void (*fn) (struct messaging_context *msg_ctx,
3233                     int snum, struct spoolss_Notify *data,
3234                     print_queue_struct *queue,
3235                     struct spoolss_PrinterInfo2 *pinfo2,
3236                     TALLOC_CTX *mem_ctx);
3237 };
3238
3239 /* A table describing the various print notification constants and
3240    whether the notification data is a pointer to a variable sized
3241    buffer, a one value uint32_t or a two value uint32_t. */
3242
3243 static const struct s_notify_info_data_table notify_info_data_table[] =
3244 {
3245 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SERVER_NAME,         "PRINTER_NOTIFY_FIELD_SERVER_NAME",         NOTIFY_TABLE_STRING,   spoolss_notify_server_name },
3246 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRINTER_NAME,        "PRINTER_NOTIFY_FIELD_PRINTER_NAME",        NOTIFY_TABLE_STRING,   spoolss_notify_printer_name },
3247 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SHARE_NAME,          "PRINTER_NOTIFY_FIELD_SHARE_NAME",          NOTIFY_TABLE_STRING,   spoolss_notify_share_name },
3248 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PORT_NAME,           "PRINTER_NOTIFY_FIELD_PORT_NAME",           NOTIFY_TABLE_STRING,   spoolss_notify_port_name },
3249 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DRIVER_NAME,         "PRINTER_NOTIFY_FIELD_DRIVER_NAME",         NOTIFY_TABLE_STRING,   spoolss_notify_driver_name },
3250 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_COMMENT,             "PRINTER_NOTIFY_FIELD_COMMENT",             NOTIFY_TABLE_STRING,   spoolss_notify_comment },
3251 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_LOCATION,            "PRINTER_NOTIFY_FIELD_LOCATION",            NOTIFY_TABLE_STRING,   spoolss_notify_location },
3252 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DEVMODE,             "PRINTER_NOTIFY_FIELD_DEVMODE",             NOTIFY_TABLE_DEVMODE,  spoolss_notify_devmode },
3253 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SEPFILE,             "PRINTER_NOTIFY_FIELD_SEPFILE",             NOTIFY_TABLE_STRING,   spoolss_notify_sepfile },
3254 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR,     "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR",     NOTIFY_TABLE_STRING,   spoolss_notify_print_processor },
3255 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PARAMETERS,          "PRINTER_NOTIFY_FIELD_PARAMETERS",          NOTIFY_TABLE_STRING,   spoolss_notify_parameters },
3256 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DATATYPE,            "PRINTER_NOTIFY_FIELD_DATATYPE",            NOTIFY_TABLE_STRING,   spoolss_notify_datatype },
3257 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR, "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NOTIFY_TABLE_SECURITYDESCRIPTOR,   spoolss_notify_security_desc },
3258 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_ATTRIBUTES,          "PRINTER_NOTIFY_FIELD_ATTRIBUTES",          NOTIFY_TABLE_DWORD,    spoolss_notify_attributes },
3259 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRIORITY,            "PRINTER_NOTIFY_FIELD_PRIORITY",            NOTIFY_TABLE_DWORD,    spoolss_notify_priority },
3260 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY,    "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY",    NOTIFY_TABLE_DWORD,    spoolss_notify_default_priority },
3261 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_START_TIME,          "PRINTER_NOTIFY_FIELD_START_TIME",          NOTIFY_TABLE_DWORD,    spoolss_notify_start_time },
3262 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_UNTIL_TIME,          "PRINTER_NOTIFY_FIELD_UNTIL_TIME",          NOTIFY_TABLE_DWORD,    spoolss_notify_until_time },
3263 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_STATUS,              "PRINTER_NOTIFY_FIELD_STATUS",              NOTIFY_TABLE_DWORD,    spoolss_notify_status },
3264 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_STATUS_STRING,       "PRINTER_NOTIFY_FIELD_STATUS_STRING",       NOTIFY_TABLE_STRING,   NULL },
3265 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_CJOBS,               "PRINTER_NOTIFY_FIELD_CJOBS",               NOTIFY_TABLE_DWORD,    spoolss_notify_cjobs },
3266 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_AVERAGE_PPM,         "PRINTER_NOTIFY_FIELD_AVERAGE_PPM",         NOTIFY_TABLE_DWORD,    spoolss_notify_average_ppm },
3267 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_TOTAL_PAGES,         "PRINTER_NOTIFY_FIELD_TOTAL_PAGES",         NOTIFY_TABLE_DWORD,    NULL },
3268 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PAGES_PRINTED,       "PRINTER_NOTIFY_FIELD_PAGES_PRINTED",       NOTIFY_TABLE_DWORD,    NULL },
3269 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_TOTAL_BYTES,         "PRINTER_NOTIFY_FIELD_TOTAL_BYTES",         NOTIFY_TABLE_DWORD,    NULL },
3270 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_BYTES_PRINTED,       "PRINTER_NOTIFY_FIELD_BYTES_PRINTED",       NOTIFY_TABLE_DWORD,    NULL },
3271 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_PRINTER_NAME,            "JOB_NOTIFY_FIELD_PRINTER_NAME",            NOTIFY_TABLE_STRING,   spoolss_notify_printer_name },
3272 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_MACHINE_NAME,            "JOB_NOTIFY_FIELD_MACHINE_NAME",            NOTIFY_TABLE_STRING,   spoolss_notify_server_name },
3273 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_PORT_NAME,               "JOB_NOTIFY_FIELD_PORT_NAME",               NOTIFY_TABLE_STRING,   spoolss_notify_port_name },
3274 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_USER_NAME,               "JOB_NOTIFY_FIELD_USER_NAME",               NOTIFY_TABLE_STRING,   spoolss_notify_username },
3275 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_NOTIFY_NAME,             "JOB_NOTIFY_FIELD_NOTIFY_NAME",             NOTIFY_TABLE_STRING,   spoolss_notify_username },
3276 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_DATATYPE,                "JOB_NOTIFY_FIELD_DATATYPE",                NOTIFY_TABLE_STRING,   spoolss_notify_datatype },
3277 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_PRINT_PROCESSOR,         "JOB_NOTIFY_FIELD_PRINT_PROCESSOR",         NOTIFY_TABLE_STRING,   spoolss_notify_print_processor },
3278 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_PARAMETERS,              "JOB_NOTIFY_FIELD_PARAMETERS",              NOTIFY_TABLE_STRING,   spoolss_notify_parameters },
3279 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_DRIVER_NAME,             "JOB_NOTIFY_FIELD_DRIVER_NAME",             NOTIFY_TABLE_STRING,   spoolss_notify_driver_name },
3280 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_DEVMODE,                 "JOB_NOTIFY_FIELD_DEVMODE",                 NOTIFY_TABLE_DEVMODE,  spoolss_notify_devmode },
3281 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_STATUS,                  "JOB_NOTIFY_FIELD_STATUS",                  NOTIFY_TABLE_DWORD,    spoolss_notify_job_status },
3282 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_STATUS_STRING,           "JOB_NOTIFY_FIELD_STATUS_STRING",           NOTIFY_TABLE_STRING,   spoolss_notify_job_status_string },
3283 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR,     "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR",     NOTIFY_TABLE_SECURITYDESCRIPTOR,   NULL },
3284 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_DOCUMENT,                "JOB_NOTIFY_FIELD_DOCUMENT",                NOTIFY_TABLE_STRING,   spoolss_notify_job_name },
3285 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_PRIORITY,                "JOB_NOTIFY_FIELD_PRIORITY",                NOTIFY_TABLE_DWORD,    spoolss_notify_priority },
3286 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_POSITION,                "JOB_NOTIFY_FIELD_POSITION",                NOTIFY_TABLE_DWORD,    spoolss_notify_job_position },
3287 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_SUBMITTED,               "JOB_NOTIFY_FIELD_SUBMITTED",               NOTIFY_TABLE_TIME,     spoolss_notify_submitted_time },
3288 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_START_TIME,              "JOB_NOTIFY_FIELD_START_TIME",              NOTIFY_TABLE_DWORD,    spoolss_notify_start_time },
3289 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_UNTIL_TIME,              "JOB_NOTIFY_FIELD_UNTIL_TIME",              NOTIFY_TABLE_DWORD,    spoolss_notify_until_time },
3290 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_TIME,                    "JOB_NOTIFY_FIELD_TIME",                    NOTIFY_TABLE_DWORD,    spoolss_notify_job_time },
3291 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_TOTAL_PAGES,             "JOB_NOTIFY_FIELD_TOTAL_PAGES",             NOTIFY_TABLE_DWORD,    spoolss_notify_total_pages },
3292 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_PAGES_PRINTED,           "JOB_NOTIFY_FIELD_PAGES_PRINTED",           NOTIFY_TABLE_DWORD,    spoolss_notify_pages_printed },
3293 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_TOTAL_BYTES,             "JOB_NOTIFY_FIELD_TOTAL_BYTES",             NOTIFY_TABLE_DWORD,    spoolss_notify_job_size },
3294 };
3295
3296 /*******************************************************************
3297  Return the variable_type of info_data structure.
3298 ********************************************************************/
3299
3300 static enum spoolss_NotifyTable variable_type_of_notify_info_data(enum spoolss_NotifyType type,
3301                                                                   uint16_t field)
3302 {
3303         int i=0;
3304
3305         for (i = 0; i < ARRAY_SIZE(notify_info_data_table); i++) {
3306                 if ( (notify_info_data_table[i].type == type) &&
3307                      (notify_info_data_table[i].field == field) ) {
3308                         return notify_info_data_table[i].variable_type;
3309                 }
3310         }
3311
3312         DEBUG(5, ("invalid notify data type %d/%d\n", type, field));
3313
3314         return (enum spoolss_NotifyTable) 0;
3315 }
3316
3317 /****************************************************************************
3318 ****************************************************************************/
3319
3320 static bool search_notify(enum spoolss_NotifyType type,
3321                           uint16_t field,
3322                           int *value)
3323 {
3324         int i;
3325
3326         for (i = 0; i < ARRAY_SIZE(notify_info_data_table); i++) {
3327                 if (notify_info_data_table[i].type == type &&
3328                     notify_info_data_table[i].field == field &&
3329                     notify_info_data_table[i].fn != NULL) {
3330                         *value = i;
3331                         return true;
3332                 }
3333         }
3334
3335         return false;
3336 }
3337
3338 /****************************************************************************
3339 ****************************************************************************/
3340
3341 static void construct_info_data(struct spoolss_Notify *info_data,
3342                                 enum spoolss_NotifyType type,
3343                                 uint16_t field, int id)
3344 {
3345         info_data->type                 = type;
3346         info_data->field.field          = field;
3347         info_data->variable_type        = variable_type_of_notify_info_data(type, field);
3348         info_data->job_id               = id;
3349 }
3350
3351 /*******************************************************************
3352  *
3353  * fill a notify_info struct with info asked
3354  *
3355  ********************************************************************/
3356
3357 static bool construct_notify_printer_info(struct messaging_context *msg_ctx,
3358                                           struct printer_handle *print_hnd,
3359                                           struct spoolss_NotifyInfo *info,
3360                                           struct spoolss_PrinterInfo2 *pinfo2,
3361                                           int snum,
3362                                           const struct spoolss_NotifyOptionType *option_type,
3363                                           uint32_t id,
3364                                           TALLOC_CTX *mem_ctx)
3365 {
3366         int field_num,j;
3367         enum spoolss_NotifyType type;
3368         uint16_t field;
3369
3370         struct spoolss_Notify *current_data;
3371
3372         type = option_type->type;
3373
3374         DEBUG(4,("construct_notify_printer_info: Notify type: [%s], number of notify info: [%d] on printer: [%s]\n",
3375                 (type == PRINTER_NOTIFY_TYPE ? "PRINTER_NOTIFY_TYPE" : "JOB_NOTIFY_TYPE"),
3376                 option_type->count, lp_servicename(talloc_tos(), snum)));
3377
3378         for(field_num=0; field_num < option_type->count; field_num++) {
3379                 field = option_type->fields[field_num].field;
3380
3381                 DEBUG(4,("construct_notify_printer_info: notify [%d]: type [%x], field [%x]\n", field_num, type, field));
3382
3383                 if (!search_notify(type, field, &j) )
3384                         continue;
3385
3386                 info->notifies = talloc_realloc(info, info->notifies,
3387                                                       struct spoolss_Notify,
3388                                                       info->count + 1);
3389                 if (info->notifies == NULL) {
3390                         DEBUG(2,("construct_notify_printer_info: failed to enlarge buffer info->data!\n"));
3391                         return false;
3392                 }
3393
3394                 current_data = &info->notifies[info->count];
3395
3396                 construct_info_data(current_data, type, field, id);
3397
3398                 DEBUG(10, ("construct_notify_printer_info: "
3399                            "calling [%s]  snum=%d  printername=[%s])\n",
3400                            notify_info_data_table[j].name, snum,
3401                            pinfo2->printername));
3402
3403                 notify_info_data_table[j].fn(msg_ctx, snum, current_data,
3404                                              NULL, pinfo2, mem_ctx);
3405
3406                 info->count++;
3407         }
3408
3409         return true;
3410 }
3411
3412 /*******************************************************************
3413  *
3414  * fill a notify_info struct with info asked
3415  *
3416  ********************************************************************/
3417
3418 static bool construct_notify_jobs_info(struct messaging_context *msg_ctx,
3419                                        print_queue_struct *queue,
3420                                        struct spoolss_NotifyInfo *info,
3421                                        struct spoolss_PrinterInfo2 *pinfo2,
3422                                        int snum,
3423                                        const struct spoolss_NotifyOptionType *option_type,
3424                                        uint32_t id,
3425                                        TALLOC_CTX *mem_ctx)
3426 {
3427         int field_num,j;
3428         enum spoolss_NotifyType type;
3429         uint16_t field;
3430         struct spoolss_Notify *current_data;
3431
3432         DEBUG(4,("construct_notify_jobs_info\n"));
3433
3434         type = option_type->type;
3435
3436         DEBUGADD(4,("Notify type: [%s], number of notify info: [%d]\n",
3437                 (type == PRINTER_NOTIFY_TYPE ? "PRINTER_NOTIFY_TYPE" : "JOB_NOTIFY_TYPE"),
3438                 option_type->count));
3439
3440         for(field_num=0; field_num<option_type->count; field_num++) {
3441                 field = option_type->fields[field_num].field;
3442
3443                 if (!search_notify(type, field, &j) )
3444                         continue;
3445
3446                 info->notifies = talloc_realloc(info, info->notifies,
3447                                                       struct spoolss_Notify,
3448                                                       info->count + 1);
3449                 if (info->notifies == NULL) {
3450                         DEBUG(2,("construct_notify_jobs_info: failed to enlarg buffer info->data!\n"));
3451                         return false;
3452                 }
3453
3454                 current_data=&(info->notifies[info->count]);
3455
3456                 construct_info_data(current_data, type, field, id);
3457                 notify_info_data_table[j].fn(msg_ctx, snum, current_data,
3458                                              queue, pinfo2, mem_ctx);
3459                 info->count++;
3460         }
3461
3462         return true;
3463 }
3464
3465 /*
3466  * JFM: The enumeration is not that simple, it's even non obvious.
3467  *
3468  * let's take an example: I want to monitor the PRINTER SERVER for
3469  * the printer's name and the number of jobs currently queued.
3470  * So in the NOTIFY_OPTION, I have one NOTIFY_OPTION_TYPE structure.
3471  * Its type is PRINTER_NOTIFY_TYPE and it has 2 fields NAME and CJOBS.
3472  *
3473  * I have 3 printers on the back of my server.
3474  *
3475  * Now the response is a NOTIFY_INFO structure, with 6 NOTIFY_INFO_DATA
3476  * structures.
3477  *   Number     Data                    Id
3478  *      1       printer 1 name          1
3479  *      2       printer 1 cjob          1
3480  *      3       printer 2 name          2
3481  *      4       printer 2 cjob          2
3482  *      5       printer 3 name          3
3483  *      6       printer 3 name          3
3484  *
3485  * that's the print server case, the printer case is even worse.
3486  */
3487
3488 /*******************************************************************
3489  *
3490  * enumerate all printers on the printserver
3491  * fill a notify_info struct with info asked
3492  *
3493  ********************************************************************/
3494
3495 static WERROR printserver_notify_info(struct pipes_struct *p,
3496                                       struct policy_handle *hnd,
3497                                       struct spoolss_NotifyInfo *info,
3498                                       TALLOC_CTX *mem_ctx)
3499 {
3500         int snum;
3501         struct printer_handle *Printer = find_printer_index_by_hnd(p, hnd);
3502         int n_services=lp_numservices();
3503         int i;
3504         struct spoolss_NotifyOption *option;
3505         struct spoolss_NotifyOptionType option_type;
3506         struct spoolss_PrinterInfo2 *pinfo2 = NULL;
3507         WERROR result;
3508
3509         DEBUG(4,("printserver_notify_info\n"));
3510
3511         if (!Printer)
3512                 return WERR_BADFID;
3513
3514         option = Printer->notify.option;
3515
3516         info->version   = 2;
3517         info->notifies  = NULL;
3518         info->count     = 0;
3519
3520         /* a bug in xp sp2 rc2 causes it to send a fnpcn request without
3521            sending a ffpcn() request first */
3522
3523         if ( !option )
3524                 return WERR_BADFID;
3525
3526         for (i=0; i<option->count; i++) {
3527                 option_type = option->types[i];
3528
3529                 if (option_type.type != PRINTER_NOTIFY_TYPE)
3530                         continue;
3531
3532                 for (snum = 0; snum < n_services; snum++) {
3533                         if (!lp_browseable(snum) ||
3534                             !lp_snum_ok(snum) ||
3535                             !lp_print_ok(snum)) {
3536                                 continue; /* skip */
3537                         }
3538
3539                         /* Maybe we should use the SYSTEM session_info here... */
3540                         result = winreg_get_printer_internal(mem_ctx,
3541                                                     get_session_info_system(),
3542                                                     p->msg_ctx,
3543                                                     lp_servicename(talloc_tos(), snum),
3544                                                     &pinfo2);
3545                         if (!W_ERROR_IS_OK(result)) {
3546                                 DEBUG(4, ("printserver_notify_info: "
3547                                           "Failed to get printer [%s]\n",
3548                                           lp_servicename(talloc_tos(), snum)));
3549                                 continue;
3550                         }
3551
3552
3553                         construct_notify_printer_info(p->msg_ctx,
3554                                                       Printer, info,
3555                                                       pinfo2, snum,
3556                                                       &option_type, snum,
3557                                                       mem_ctx);
3558
3559                         TALLOC_FREE(pinfo2);
3560                 }
3561         }
3562
3563 #if 0
3564         /*
3565          * Debugging information, don't delete.
3566          */
3567
3568         DEBUG(1,("dumping the NOTIFY_INFO\n"));
3569         DEBUGADD(1,("info->version:[%d], info->flags:[%d], info->count:[%d]\n", info->version, info->flags, info->count));
3570         DEBUGADD(1,("num\ttype\tfield\tres\tid\tsize\tenc_type\n"));
3571
3572         for (i=0; i<info->count; i++) {
3573                 DEBUGADD(1,("[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\n",
3574                 i, info->data[i].type, info->data[i].field, info->data[i].reserved,
3575                 info->data[i].id, info->data[i].size, info->data[i].enc_type));
3576         }
3577 #endif
3578
3579         return WERR_OK;
3580 }
3581
3582 /*******************************************************************
3583  *
3584  * fill a notify_info struct with info asked
3585  *
3586  ********************************************************************/
3587
3588 static WERROR printer_notify_info(struct pipes_struct *p,
3589                                   struct policy_handle *hnd,
3590                                   struct spoolss_NotifyInfo *info,
3591                                   TALLOC_CTX *mem_ctx)
3592 {
3593         int snum;
3594         struct printer_handle *Printer = find_printer_index_by_hnd(p, hnd);
3595         int i;
3596         uint32_t id;
3597         struct spoolss_NotifyOption *option;
3598         struct spoolss_NotifyOptionType option_type;
3599         int count,j;
3600         print_queue_struct *queue=NULL;
3601         print_status_struct status;
3602         struct spoolss_PrinterInfo2 *pinfo2 = NULL;
3603         WERROR result;
3604
3605         DEBUG(4,("printer_notify_info\n"));
3606
3607         if (!Printer)
3608                 return WERR_BADFID;
3609
3610         option = Printer->notify.option;
3611         id = 0x0;
3612
3613         info->version   = 2;
3614         info->notifies  = NULL;
3615         info->count     = 0;
3616
3617         /* a bug in xp sp2 rc2 causes it to send a fnpcn request without
3618            sending a ffpcn() request first */
3619
3620         if ( !option )
3621                 return WERR_BADFID;
3622
3623         if (!get_printer_snum(p, hnd, &snum, NULL)) {
3624                 return WERR_BADFID;
3625         }
3626
3627         /* Maybe we should use the SYSTEM session_info here... */
3628         result = winreg_get_printer_internal(mem_ctx,
3629                                     get_session_info_system(),
3630                                     p->msg_ctx,
3631                                     lp_servicename(talloc_tos(), snum), &pinfo2);
3632         if (!W_ERROR_IS_OK(result)) {
3633                 return WERR_BADFID;
3634         }
3635
3636         /*
3637          * When sending a PRINTER_NOTIFY_FIELD_SERVER_NAME we should send the
3638          * correct servername.
3639          */
3640         pinfo2->servername = talloc_strdup(pinfo2, Printer->servername);
3641         if (pinfo2->servername == NULL) {
3642                 return WERR_NOMEM;
3643         }
3644
3645         for (i=0; i<option->count; i++) {
3646                 option_type = option->types[i];
3647
3648                 switch (option_type.type) {
3649                 case PRINTER_NOTIFY_TYPE:
3650                         if (construct_notify_printer_info(p->msg_ctx,
3651                                                           Printer, info,
3652                                                           pinfo2, snum,
3653                                                           &option_type, id,
3654                                                           mem_ctx)) {
3655                                 id--;
3656                         }
3657                         break;
3658
3659                 case JOB_NOTIFY_TYPE:
3660
3661                         count = print_queue_status(p->msg_ctx, snum, &queue,
3662                                                    &status);
3663
3664                         for (j=0; j<count; j++) {
3665                                 construct_notify_jobs_info(p->msg_ctx,
3666                                                            &queue[j], info,
3667                                                            pinfo2, snum,
3668                                                            &option_type,
3669                                                            queue[j].sysjob,
3670                                                            mem_ctx);
3671                         }
3672
3673                         SAFE_FREE(queue);
3674                         break;
3675                 }
3676         }
3677
3678         /*
3679          * Debugging information, don't delete.
3680          */
3681         /*
3682         DEBUG(1,("dumping the NOTIFY_INFO\n"));
3683         DEBUGADD(1,("info->version:[%d], info->flags:[%d], info->count:[%d]\n", info->version, info->flags, info->count));
3684         DEBUGADD(1,("num\ttype\tfield\tres\tid\tsize\tenc_type\n"));
3685
3686         for (i=0; i<info->count; i++) {
3687                 DEBUGADD(1,("[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\n",
3688                 i, info->data[i].type, info->data[i].field, info->data[i].reserved,
3689                 info->data[i].id, info->data[i].size, info->data[i].enc_type));
3690         }
3691         */
3692
3693         talloc_free(pinfo2);
3694         return WERR_OK;
3695 }
3696
3697 /****************************************************************
3698  _spoolss_RouterRefreshPrinterChangeNotify
3699 ****************************************************************/
3700
3701 WERROR _spoolss_RouterRefreshPrinterChangeNotify(struct pipes_struct *p,
3702                                                  struct spoolss_RouterRefreshPrinterChangeNotify *r)
3703 {
3704         struct spoolss_NotifyInfo *info;
3705
3706         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
3707         WERROR result = WERR_BADFID;
3708
3709         /* we always have a spoolss_NotifyInfo struct */
3710         info = talloc_zero(p->mem_ctx, struct spoolss_NotifyInfo);
3711         if (!info) {
3712                 result = WERR_NOMEM;
3713                 goto done;
3714         }
3715
3716         *r->out.info = info;
3717
3718         if (!Printer) {
3719                 DEBUG(2,("_spoolss_RouterRefreshPrinterChangeNotify: "
3720                         "Invalid handle (%s:%u:%u).\n",
3721                         OUR_HANDLE(r->in.handle)));
3722                 goto done;
3723         }
3724
3725         DEBUG(4,("Printer type %x\n",Printer->printer_type));
3726
3727         /*
3728          *      We are now using the change value, and
3729          *      I should check for PRINTER_NOTIFY_OPTIONS_REFRESH but as
3730          *      I don't have a global notification system, I'm sending back all the
3731          *      information even when _NOTHING_ has changed.
3732          */
3733
3734         /* We need to keep track of the change value to send back in
3735            RRPCN replies otherwise our updates are ignored. */
3736
3737         Printer->notify.fnpcn = true;
3738
3739         if (Printer->notify.cli_chan != NULL &&
3740             Printer->notify.cli_chan->active_connections > 0) {
3741                 DEBUG(10,("_spoolss_RouterRefreshPrinterChangeNotify: "
3742                         "Saving change value in request [%x]\n",
3743                         r->in.change_low));
3744                 Printer->notify.change = r->in.change_low;
3745         }
3746
3747         /* just ignore the spoolss_NotifyOption */
3748
3749         switch (Printer->printer_type) {
3750                 case SPLHND_SERVER:
3751                         result = printserver_notify_info(p, r->in.handle,
3752                                                          info, p->mem_ctx);
3753                         break;
3754
3755                 case SPLHND_PRINTER:
3756                         result = printer_notify_info(p, r->in.handle,
3757                                                      info, p->mem_ctx);
3758                         break;
3759         }
3760
3761         Printer->notify.fnpcn = false;
3762
3763 done:
3764         return result;
3765 }
3766
3767 /********************************************************************
3768  ********************************************************************/
3769
3770 static WERROR create_printername(TALLOC_CTX *mem_ctx,
3771                                  const char *servername,
3772                                  const char *printername,
3773                                  const char **printername_p)
3774 {
3775         /* FIXME: add lp_force_printername() */
3776
3777         if (servername == NULL) {
3778                 *printername_p = talloc_strdup(mem_ctx, printername);
3779                 W_ERROR_HAVE_NO_MEMORY(*printername_p);
3780                 return WERR_OK;
3781         }
3782
3783         if (servername[0] == '\\' && servername[1] == '\\') {
3784                 servername += 2;
3785         }
3786
3787         *printername_p = talloc_asprintf(mem_ctx, "\\\\%s\\%s", servername, printername);
3788         W_ERROR_HAVE_NO_MEMORY(*printername_p);
3789
3790         return WERR_OK;
3791 }
3792
3793 /********************************************************************
3794  ********************************************************************/
3795
3796 static void compose_devicemode_devicename(struct spoolss_DeviceMode *dm,
3797                                           const char *printername)
3798 {
3799         if (dm == NULL) {
3800                 return;
3801         }
3802
3803         dm->devicename = talloc_strndup(dm, printername,
3804                                         MIN(strlen(printername), 31));
3805 }
3806
3807 /********************************************************************
3808  * construct_printer_info_0
3809  * fill a printer_info_0 struct
3810  ********************************************************************/
3811
3812 static WERROR construct_printer_info0(TALLOC_CTX *mem_ctx,
3813                                       const struct auth_session_info *session_info,
3814                                       struct messaging_context *msg_ctx,
3815                                       struct spoolss_PrinterInfo2 *info2,
3816                                       const char *servername,
3817                                       struct spoolss_PrinterInfo0 *r,
3818                                       int snum)
3819 {
3820         int count;
3821         struct printer_session_counter *session_counter;
3822         struct timeval setuptime;
3823         print_status_struct status;
3824         WERROR result;
3825
3826         result = create_printername(mem_ctx, servername, info2->printername, &r->printername);
3827         if (!W_ERROR_IS_OK(result)) {
3828                 return result;
3829         }
3830
3831         if (servername) {
3832                 r->servername = talloc_strdup(mem_ctx, servername);
3833                 W_ERROR_HAVE_NO_MEMORY(r->servername);
3834         } else {
3835                 r->servername = NULL;
3836         }
3837
3838         count = print_queue_length(msg_ctx, snum, &status);
3839
3840         /* check if we already have a counter for this printer */
3841         for (session_counter = counter_list; session_counter; session_counter = session_counter->next) {
3842                 if (session_counter->snum == snum)
3843                         break;
3844         }
3845
3846         /* it's the first time, add it to the list */
3847         if (session_counter == NULL) {
3848                 session_counter = talloc_zero(counter_list, struct printer_session_counter);
3849                 W_ERROR_HAVE_NO_MEMORY(session_counter);
3850                 session_counter->snum           = snum;
3851                 session_counter->counter        = 0;
3852                 DLIST_ADD(counter_list, session_counter);
3853         }
3854
3855         /* increment it */
3856         session_counter->counter++;
3857
3858         r->cjobs                        = count;
3859         r->total_jobs                   = 0;
3860         r->total_bytes                  = 0;
3861
3862         get_startup_time(&setuptime);
3863         init_systemtime(&r->time, gmtime(&setuptime.tv_sec));
3864
3865         /* JFM:
3866          * the global_counter should be stored in a TDB as it's common to all the clients
3867          * and should be zeroed on samba startup
3868          */
3869         r->global_counter               = session_counter->counter;
3870         r->total_pages                  = 0;
3871         /* in 2.2 we reported ourselves as 0x0004 and 0x0565 */
3872         SSVAL(&r->version, 0, 0x0005); /* NT 5 */
3873         SSVAL(&r->version, 2, 0x0893); /* build 2195 */
3874         r->free_build                   = SPOOLSS_RELEASE_BUILD;
3875         r->spooling                     = 0;
3876         r->max_spooling                 = 0;
3877         r->session_counter              = session_counter->counter;
3878         r->num_error_out_of_paper       = 0x0;
3879         r->num_error_not_ready          = 0x0;          /* number of print failure */
3880         r->job_error                    = 0x0;
3881         r->number_of_processors         = 0x1;
3882         r->processor_type               = PROCESSOR_INTEL_PENTIUM; /* 586 Pentium ? */
3883         r->high_part_total_bytes        = 0x0;
3884
3885         /* ChangeID in milliseconds*/
3886         winreg_printer_get_changeid_internal(mem_ctx, session_info, msg_ctx,
3887                                     info2->sharename, &r->change_id);
3888
3889         r->last_error                   = WERR_OK;
3890         r->status                       = nt_printq_status(status.status);
3891         r->enumerate_network_printers   = 0x0;
3892         r->c_setprinter                 = 0x0;
3893         r->processor_architecture       = PROCESSOR_ARCHITECTURE_INTEL;
3894         r->processor_level              = 0x6;          /* 6  ???*/
3895         r->ref_ic                       = 0;
3896         r->reserved2                    = 0;
3897         r->reserved3                    = 0;
3898
3899         return WERR_OK;
3900 }
3901
3902
3903 /********************************************************************
3904  * construct_printer_info1
3905  * fill a spoolss_PrinterInfo1 struct
3906 ********************************************************************/
3907
3908 static WERROR construct_printer_info1(TALLOC_CTX *mem_ctx,
3909                                       const struct spoolss_PrinterInfo2 *info2,
3910                                       uint32_t flags,
3911                                       const char *servername,
3912                                       struct spoolss_PrinterInfo1 *r,
3913                                       int snum)
3914 {
3915         WERROR result;
3916
3917         r->flags                = flags;
3918
3919         if (info2->comment == NULL || info2->comment[0] == '\0') {
3920                 r->comment      = lp_comment(mem_ctx, snum);
3921         } else {
3922                 r->comment      = talloc_strdup(mem_ctx, info2->comment); /* saved comment */
3923         }
3924         W_ERROR_HAVE_NO_MEMORY(r->comment);
3925
3926         result = create_printername(mem_ctx, servername, info2->printername, &r->name);
3927         if (!W_ERROR_IS_OK(result)) {
3928                 return result;
3929         }
3930
3931         r->description          = talloc_asprintf(mem_ctx, "%s,%s,%s",
3932                                                   r->name,
3933                                                   info2->drivername,
3934                                                   r->comment);
3935         W_ERROR_HAVE_NO_MEMORY(r->description);
3936
3937         return WERR_OK;
3938 }
3939
3940 /********************************************************************
3941  * construct_printer_info2
3942  * fill a spoolss_PrinterInfo2 struct
3943 ********************************************************************/
3944
3945 static WERROR construct_printer_info2(TALLOC_CTX *mem_ctx,
3946                                       struct messaging_context *msg_ctx,
3947                                       const struct spoolss_PrinterInfo2 *info2,
3948                                       const char *servername,
3949                                       struct spoolss_PrinterInfo2 *r,
3950                                       int snum)
3951 {
3952         int count;
3953         print_status_struct status;
3954         WERROR result;
3955
3956         count = print_queue_length(msg_ctx, snum, &status);
3957
3958         if (servername) {
3959                 r->servername           = talloc_strdup(mem_ctx, servername);
3960                 W_ERROR_HAVE_NO_MEMORY(r->servername);
3961         } else {
3962                 r->servername           = NULL;
3963         }
3964
3965         result = create_printername(mem_ctx, servername, info2->printername, &r->printername);
3966         if (!W_ERROR_IS_OK(result)) {
3967                 return result;
3968         }
3969
3970         r->sharename            = lp_servicename(mem_ctx, snum);
3971         W_ERROR_HAVE_NO_MEMORY(r->sharename);
3972         r->portname             = talloc_strdup(mem_ctx, info2->portname);
3973         W_ERROR_HAVE_NO_MEMORY(r->portname);
3974         r->drivername           = talloc_strdup(mem_ctx, info2->drivername);
3975         W_ERROR_HAVE_NO_MEMORY(r->drivername);
3976
3977         if (info2->comment[0] == '\0') {
3978                 r->comment      = lp_comment(mem_ctx, snum);
3979         } else {
3980                 r->comment      = talloc_strdup(mem_ctx, info2->comment);
3981         }
3982         W_ERROR_HAVE_NO_MEMORY(r->comment);
3983
3984         r->location     = talloc_strdup(mem_ctx, info2->location);
3985         if (info2->location[0] == '\0') {
3986                 const char *loc = NULL;
3987                 NTSTATUS nt_status;
3988
3989                 nt_status = printer_list_get_printer(mem_ctx,
3990                                                      info2->sharename,
3991                                                      NULL,
3992                                                      &loc,
3993                                                      NULL);
3994                 if (NT_STATUS_IS_OK(nt_status)) {
3995                         if (loc != NULL) {
3996                                 r->location = talloc_strdup(mem_ctx, loc);
3997                         }
3998                 }
3999         }
4000         W_ERROR_HAVE_NO_MEMORY(r->location);
4001
4002         r->sepfile              = talloc_strdup(mem_ctx, info2->sepfile);
4003         W_ERROR_HAVE_NO_MEMORY(r->sepfile);
4004         r->printprocessor       = talloc_strdup(mem_ctx, info2->printprocessor);
4005         W_ERROR_HAVE_NO_MEMORY(r->printprocessor);
4006         r->datatype             = talloc_strdup(mem_ctx, info2->datatype);
4007         W_ERROR_HAVE_NO_MEMORY(r->datatype);
4008         r->parameters           = talloc_strdup(mem_ctx, info2->parameters);
4009         W_ERROR_HAVE_NO_MEMORY(r->parameters);
4010
4011         r->attributes           = info2->attributes;
4012
4013         r->priority             = info2->priority;
4014         r->defaultpriority      = info2->defaultpriority;
4015         r->starttime            = info2->starttime;
4016         r->untiltime            = info2->untiltime;
4017         r->status               = nt_printq_status(status.status);
4018         r->cjobs                = count;
4019         r->averageppm           = info2->averageppm;
4020
4021         if (info2->devmode != NULL) {
4022                 result = copy_devicemode(mem_ctx,
4023                                          info2->devmode,
4024                                          &r->devmode);
4025                 if (!W_ERROR_IS_OK(result)) {
4026                         return result;
4027                 }
4028         } else if (lp_default_devmode(snum)) {
4029                 result = spoolss_create_default_devmode(mem_ctx,
4030                                                         info2->printername,
4031                                                         &r->devmode);
4032                 if (!W_ERROR_IS_OK(result)) {
4033                         return result;
4034                 }
4035         } else {
4036                 r->devmode = NULL;
4037                 DEBUG(8,("Returning NULL Devicemode!\n"));
4038         }
4039
4040         compose_devicemode_devicename(r->devmode, r->printername);
4041
4042         r->secdesc = NULL;
4043
4044         if (info2->secdesc != NULL) {
4045                 /* don't use talloc_steal() here unless you do a deep steal of all
4046                    the SEC_DESC members */
4047
4048                 r->secdesc      = dup_sec_desc(mem_ctx, info2->secdesc);
4049         }
4050
4051         return WERR_OK;
4052 }
4053
4054 /********************************************************************
4055  * construct_printer_info3
4056  * fill a spoolss_PrinterInfo3 struct
4057  ********************************************************************/
4058
4059 static WERROR construct_printer_info3(TALLOC_CTX *mem_ctx,
4060                                       const struct spoolss_PrinterInfo2 *info2,
4061                                       const char *servername,
4062                                       struct spoolss_PrinterInfo3 *r,
4063                                       int snum)
4064 {
4065         /* These are the components of the SD we are returning. */
4066
4067         if (info2->secdesc != NULL) {
4068                 /* don't use talloc_steal() here unless you do a deep steal of all
4069                    the SEC_DESC members */
4070
4071                 r->secdesc = dup_sec_desc(mem_ctx, info2->secdesc);
4072                 W_ERROR_HAVE_NO_MEMORY(r->secdesc);
4073         }
4074
4075         return WERR_OK;
4076 }
4077
4078 /********************************************************************
4079  * construct_printer_info4
4080  * fill a spoolss_PrinterInfo4 struct
4081  ********************************************************************/
4082
4083 static WERROR construct_printer_info4(TALLOC_CTX *mem_ctx,
4084                                       const struct spoolss_PrinterInfo2 *info2,
4085                                       const char *servername,
4086                                       struct spoolss_PrinterInfo4 *r,
4087                                       int snum)
4088 {
4089         WERROR result;
4090
4091         result = create_printername(mem_ctx, servername, info2->printername, &r->printername);
4092         if (!W_ERROR_IS_OK(result)) {
4093                 return result;
4094         }
4095
4096         if (servername) {
4097                 r->servername   = talloc_strdup(mem_ctx, servername);
4098                 W_ERROR_HAVE_NO_MEMORY(r->servername);
4099         } else {
4100                 r->servername = NULL;
4101         }
4102
4103         r->attributes   = info2->attributes;
4104
4105         return WERR_OK;
4106 }
4107
4108 /********************************************************************
4109  * construct_printer_info5
4110  * fill a spoolss_PrinterInfo5 struct
4111  ********************************************************************/
4112
4113 static WERROR construct_printer_info5(TALLOC_CTX *mem_ctx,
4114                                       const struct spoolss_PrinterInfo2 *info2,
4115                                       const char *servername,
4116                                       struct spoolss_PrinterInfo5 *r,
4117                                       int snum)
4118 {
4119         WERROR result;
4120
4121         result = create_printername(mem_ctx, servername, info2->printername, &r->printername);
4122         if (!W_ERROR_IS_OK(result)) {
4123                 return result;
4124         }
4125
4126         r->portname     = talloc_strdup(mem_ctx, info2->portname);
4127         W_ERROR_HAVE_NO_MEMORY(r->portname);
4128
4129         r->attributes   = info2->attributes;
4130
4131         /* these two are not used by NT+ according to MSDN */
4132         r->device_not_selected_timeout          = 0x0;  /* have seen 0x3a98 */
4133         r->transmission_retry_timeout           = 0x0;  /* have seen 0xafc8 */
4134
4135         return WERR_OK;
4136 }
4137
4138 /********************************************************************
4139  * construct_printer_info_6
4140  * fill a spoolss_PrinterInfo6 struct
4141  ********************************************************************/
4142
4143 static WERROR construct_printer_info6(TALLOC_CTX *mem_ctx,
4144                                       struct messaging_context *msg_ctx,
4145                                       const struct spoolss_PrinterInfo2 *info2,
4146                                       const char *servername,
4147                                       struct spoolss_PrinterInfo6 *r,
4148                                       int snum)
4149 {
4150         print_status_struct status;
4151
4152         print_queue_length(msg_ctx, snum, &status);
4153
4154         r->status = nt_printq_status(status.status);
4155
4156         return WERR_OK;
4157 }
4158
4159 /********************************************************************
4160  * construct_printer_info7
4161  * fill a spoolss_PrinterInfo7 struct
4162  ********************************************************************/
4163
4164 static WERROR construct_printer_info7(TALLOC_CTX *mem_ctx,
4165                                       struct messaging_context *msg_ctx,
4166                                       const char *servername,
4167                                       struct spoolss_PrinterInfo7 *r,
4168                                       int snum)
4169 {
4170         const struct auth_session_info *session_info = get_session_info_system();
4171         struct GUID guid;
4172
4173         if (is_printer_published(mem_ctx, session_info, msg_ctx,
4174                                  servername,
4175                                  lp_servicename(talloc_tos(), snum), &guid, NULL)) {
4176                 r->guid = talloc_strdup_upper(mem_ctx, GUID_string2(mem_ctx, &guid));
4177                 r->action = DSPRINT_PUBLISH;
4178         } else {
4179                 r->guid = talloc_strdup(mem_ctx, "");
4180                 r->action = DSPRINT_UNPUBLISH;
4181         }
4182         W_ERROR_HAVE_NO_MEMORY(r->guid);
4183
4184         return WERR_OK;
4185 }
4186
4187 /********************************************************************
4188  * construct_printer_info8
4189  * fill a spoolss_PrinterInfo8 struct
4190  ********************************************************************/
4191
4192 static WERROR construct_printer_info8(TALLOC_CTX *mem_ctx,
4193                                       const struct spoolss_PrinterInfo2 *info2,
4194                                       const char *servername,
4195                                       struct spoolss_DeviceModeInfo *r,
4196                                       int snum)
4197 {
4198         WERROR result;
4199         const char *printername;
4200
4201         result = create_printername(mem_ctx, servername, info2->printername, &printername);
4202         if (!W_ERROR_IS_OK(result)) {
4203                 return result;
4204         }
4205
4206         if (info2->devmode != NULL) {
4207                 result = copy_devicemode(mem_ctx,
4208                                          info2->devmode,
4209                                          &r->devmode);
4210                 if (!W_ERROR_IS_OK(result)) {
4211                         return result;
4212                 }
4213         } else if (lp_default_devmode(snum)) {
4214                 result = spoolss_create_default_devmode(mem_ctx,
4215                                                         info2->printername,
4216                                                         &r->devmode);
4217                 if (!W_ERROR_IS_OK(result)) {
4218                         return result;
4219                 }
4220         } else {
4221                 r->devmode = NULL;
4222                 DEBUG(8,("Returning NULL Devicemode!\n"));
4223         }
4224
4225         compose_devicemode_devicename(r->devmode, printername);
4226
4227         return WERR_OK;
4228 }
4229
4230
4231 /********************************************************************
4232 ********************************************************************/
4233
4234 static bool snum_is_shared_printer(int snum)
4235 {
4236         return (lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum));
4237 }
4238
4239 /********************************************************************
4240  Spoolss_enumprinters.
4241 ********************************************************************/
4242
4243 static WERROR enum_all_printers_info_level(TALLOC_CTX *mem_ctx,
4244                                            const struct auth_session_info *session_info,
4245                                            struct messaging_context *msg_ctx,
4246                                            const char *servername,
4247                                            uint32_t level,
4248                                            uint32_t flags,
4249                                            union spoolss_PrinterInfo **info_p,
4250                                            uint32_t *count_p)
4251 {
4252         int snum;
4253         int n_services = lp_numservices();
4254         union spoolss_PrinterInfo *info = NULL;
4255         uint32_t count = 0;
4256         WERROR result = WERR_OK;
4257         struct dcerpc_binding_handle *b = NULL;
4258         TALLOC_CTX *tmp_ctx = NULL;
4259
4260         tmp_ctx = talloc_new(mem_ctx);
4261         if (!tmp_ctx) {
4262                 return WERR_NOMEM;
4263         }
4264
4265         *count_p = 0;
4266         *info_p = NULL;
4267
4268         for (snum = 0; snum < n_services; snum++) {
4269
4270                 const char *printer;
4271                 struct spoolss_PrinterInfo2 *info2;
4272
4273                 if (!snum_is_shared_printer(snum)) {
4274                         continue;
4275                 }
4276
4277                 printer = lp_const_servicename(snum);
4278
4279                 DEBUG(4,("Found a printer in smb.conf: %s[%x]\n",
4280                         printer, snum));
4281
4282                 if (b == NULL) {
4283                         result = winreg_printer_binding_handle(tmp_ctx,
4284                                                                session_info,
4285                                                                msg_ctx,
4286                                                                &b);
4287                         if (!W_ERROR_IS_OK(result)) {
4288                                 goto out;
4289                         }
4290                 }
4291
4292                 result = winreg_create_printer(tmp_ctx, b,
4293                                                printer);
4294                 if (!W_ERROR_IS_OK(result)) {
4295                         goto out;
4296                 }
4297
4298                 info = talloc_realloc(tmp_ctx, info,
4299                                             union spoolss_PrinterInfo,
4300                                             count + 1);
4301                 if (!info) {
4302                         result = WERR_NOMEM;
4303                         goto out;
4304                 }
4305
4306                 result = winreg_get_printer(tmp_ctx, b,
4307                                             printer, &info2);
4308                 if (!W_ERROR_IS_OK(result)) {
4309                         goto out;
4310                 }
4311
4312                 switch (level) {
4313                 case 0:
4314                         result = construct_printer_info0(info, session_info,
4315                                                          msg_ctx, info2,
4316                                                          servername,
4317                                                          &info[count].info0, snum);
4318                         break;
4319                 case 1:
4320                         result = construct_printer_info1(info, info2, flags,
4321                                                          servername,
4322                                                          &info[count].info1, snum);
4323                         break;
4324                 case 2:
4325                         result = construct_printer_info2(info, msg_ctx, info2,
4326                                                          servername,
4327                                                          &info[count].info2, snum);
4328                         break;
4329                 case 4:
4330                         result = construct_printer_info4(info, info2,
4331                                                          servername,
4332                                                          &info[count].info4, snum);
4333                         break;
4334                 case 5:
4335                         result = construct_printer_info5(info, info2,
4336                                                          servername,
4337                                                          &info[count].info5, snum);
4338                         break;
4339
4340                 default:
4341                         result = WERR_UNKNOWN_LEVEL;
4342                         goto out;
4343                 }
4344
4345                 if (!W_ERROR_IS_OK(result)) {
4346                         goto out;
4347                 }
4348
4349                 count++;
4350         }
4351
4352 out:
4353         if (W_ERROR_IS_OK(result)) {
4354                 *info_p = talloc_move(mem_ctx, &info);
4355                 *count_p = count;
4356         }
4357
4358         talloc_free(tmp_ctx);
4359
4360         return result;
4361 }
4362
4363 /********************************************************************
4364  * handle enumeration of printers at level 0
4365  ********************************************************************/
4366
4367 static WERROR enumprinters_level0(TALLOC_CTX *mem_ctx,
4368                                   const struct auth_session_info *session_info,
4369                                   struct messaging_context *msg_ctx,
4370                                   uint32_t flags,
4371                                   const char *servername,
4372                                   union spoolss_PrinterInfo **info,
4373                                   uint32_t *count)
4374 {
4375         DEBUG(4,("enum_all_printers_info_0\n"));
4376
4377         return enum_all_printers_info_level(mem_ctx, session_info, msg_ctx,
4378                                             servername, 0, flags, info, count);
4379 }
4380
4381
4382 /********************************************************************
4383 ********************************************************************/
4384
4385 static WERROR enum_all_printers_info_1(TALLOC_CTX *mem_ctx,
4386                                        const struct auth_session_info *session_info,
4387                                        struct messaging_context *msg_ctx,
4388                                        const char *servername,
4389                                        uint32_t flags,
4390                                        union spoolss_PrinterInfo **info,
4391                                        uint32_t *count)
4392 {
4393         DEBUG(4,("enum_all_printers_info_1\n"));
4394
4395         return enum_all_printers_info_level(mem_ctx, session_info, msg_ctx,
4396                                             servername, 1, flags, info, count);
4397 }
4398
4399 /********************************************************************
4400  enum_all_printers_info_1_local.
4401 *********************************************************************/
4402
4403 static WERROR enum_all_printers_info_1_local(TALLOC_CTX *mem_ctx,
4404                                              const struct auth_session_info *session_info,
4405                                              struct messaging_context *msg_ctx,
4406                                              const char *servername,
4407                                              union spoolss_PrinterInfo **info,
4408                                              uint32_t *count)
4409 {
4410         DEBUG(4,("enum_all_printers_info_1_local\n"));
4411
4412         return enum_all_printers_info_1(mem_ctx, session_info, msg_ctx,
4413                                         servername, PRINTER_ENUM_ICON8, info, count);
4414 }
4415
4416 /********************************************************************
4417  enum_all_printers_info_1_name.
4418 *********************************************************************/
4419
4420 static WERROR enum_all_printers_info_1_name(TALLOC_CTX *mem_ctx,
4421                                             const struct auth_session_info *session_info,
4422                                             struct messaging_context *msg_ctx,
4423                                             const char *servername,
4424                                             union spoolss_PrinterInfo **info,
4425                                             uint32_t *count)
4426 {
4427         const char *s = servername;
4428
4429         DEBUG(4,("enum_all_printers_info_1_name\n"));
4430
4431         if (servername != NULL &&
4432             (servername[0] == '\\') && (servername[1] == '\\')) {
4433                 s = servername + 2;
4434         }
4435
4436         if (!is_myname_or_ipaddr(s)) {
4437                 return WERR_INVALID_NAME;
4438         }
4439
4440         return enum_all_printers_info_1(mem_ctx, session_info, msg_ctx,
4441                                         servername, PRINTER_ENUM_ICON8, info, count);
4442 }
4443
4444 /********************************************************************
4445  enum_all_printers_info_1_network.
4446 *********************************************************************/
4447
4448 static WERROR enum_all_printers_info_1_network(TALLOC_CTX *mem_ctx,
4449                                                const struct auth_session_info *session_info,
4450                                                struct messaging_context *msg_ctx,
4451                                                const char *servername,
4452                                                union spoolss_PrinterInfo **info,
4453                                                uint32_t *count)
4454 {
4455         const char *s = servername;
4456
4457         DEBUG(4,("enum_all_printers_info_1_network\n"));
4458
4459         /* If we respond to a enum_printers level 1 on our name with flags
4460            set to PRINTER_ENUM_REMOTE with a list of printers then these
4461            printers incorrectly appear in the APW browse list.
4462            Specifically the printers for the server appear at the workgroup
4463            level where all the other servers in the domain are
4464            listed. Windows responds to this call with a
4465            WERR_CAN_NOT_COMPLETE so we should do the same. */
4466
4467         if (servername[0] == '\\' && servername[1] == '\\') {
4468                  s = servername + 2;
4469         }
4470
4471         if (is_myname_or_ipaddr(s)) {
4472                  return WERR_CAN_NOT_COMPLETE;
4473         }
4474
4475         return enum_all_printers_info_1(mem_ctx, session_info, msg_ctx,
4476                                         servername, PRINTER_ENUM_NAME, info, count);
4477 }
4478
4479 /********************************************************************
4480  * api_spoolss_enumprinters
4481  *
4482  * called from api_spoolss_enumprinters (see this to understand)
4483  ********************************************************************/
4484
4485 static WERROR enum_all_printers_info_2(TALLOC_CTX *mem_ctx,
4486                                        const struct auth_session_info *session_info,
4487                                        struct messaging_context *msg_ctx,
4488                                        const char *servername,
4489                                        union spoolss_PrinterInfo **info,
4490                                        uint32_t *count)
4491 {
4492         DEBUG(4,("enum_all_printers_info_2\n"));
4493
4494         return enum_all_printers_info_level(mem_ctx, session_info, msg_ctx,
4495                                             servername, 2, 0, info, count);
4496 }
4497
4498 /********************************************************************
4499  * handle enumeration of printers at level 1
4500  ********************************************************************/
4501
4502 static WERROR enumprinters_level1(TALLOC_CTX *mem_ctx,
4503                                   const struct auth_session_info *session_info,
4504                                   struct messaging_context *msg_ctx,
4505                                   uint32_t flags,
4506                                   const char *servername,
4507                                   union spoolss_PrinterInfo **info,
4508                                   uint32_t *count)
4509 {
4510         /* Not all the flags are equals */
4511
4512         if (flags & PRINTER_ENUM_LOCAL) {
4513                 return enum_all_printers_info_1_local(mem_ctx, session_info,
4514                                                       msg_ctx, servername, info, count);
4515         }
4516
4517         if (flags & PRINTER_ENUM_NAME) {
4518                 return enum_all_printers_info_1_name(mem_ctx, session_info,
4519                                                      msg_ctx, servername, info,
4520                                                      count);
4521         }
4522
4523         if (flags & PRINTER_ENUM_NETWORK) {
4524                 return enum_all_printers_info_1_network(mem_ctx, session_info,
4525                                                         msg_ctx, servername, info,
4526                                                         count);
4527         }
4528
4529         return WERR_OK; /* NT4sp5 does that */
4530 }
4531
4532 /********************************************************************
4533  * handle enumeration of printers at level 2
4534  ********************************************************************/
4535
4536 static WERROR enumprinters_level2(TALLOC_CTX *mem_ctx,
4537                                   const struct auth_session_info *session_info,
4538                                   struct messaging_context *msg_ctx,
4539                                   uint32_t flags,
4540                                   const char *servername,
4541                                   union spoolss_PrinterInfo **info,
4542                                   uint32_t *count)
4543 {
4544         if (flags & PRINTER_ENUM_LOCAL) {
4545
4546                 return enum_all_printers_info_2(mem_ctx, session_info, msg_ctx,
4547                                                 servername,
4548                                                 info, count);
4549         }
4550
4551         if (flags & PRINTER_ENUM_NAME) {
4552                 if (servername && !is_myname_or_ipaddr(canon_servername(servername))) {
4553                         return WERR_INVALID_NAME;
4554                 }
4555
4556                 return enum_all_printers_info_2(mem_ctx, session_info, msg_ctx,
4557                                                 servername,
4558                                                 info, count);
4559         }
4560
4561         if (flags & PRINTER_ENUM_REMOTE) {
4562                 return WERR_UNKNOWN_LEVEL;
4563         }
4564
4565         return WERR_OK;
4566 }
4567
4568 /********************************************************************
4569  * handle enumeration of printers at level 4
4570  ********************************************************************/
4571
4572 static WERROR enumprinters_level4(TALLOC_CTX *mem_ctx,
4573                                   const struct auth_session_info *session_info,
4574                                   struct messaging_context *msg_ctx,
4575                                   uint32_t flags,
4576                                   const char *servername,
4577                                   union spoolss_PrinterInfo **info,
4578                                   uint32_t *count)
4579 {
4580         DEBUG(4,("enum_all_printers_info_4\n"));
4581
4582         return enum_all_printers_info_level(mem_ctx, session_info, msg_ctx,
4583                                             servername, 4, flags, info, count);
4584 }
4585
4586
4587 /********************************************************************
4588  * handle enumeration of printers at level 5
4589  ********************************************************************/
4590
4591 static WERROR enumprinters_level5(TALLOC_CTX *mem_ctx,
4592                                   const struct auth_session_info *session_info,
4593                                   struct messaging_context *msg_ctx,
4594                                   uint32_t flags,
4595                                   const char *servername,
4596                                   union spoolss_PrinterInfo **info,
4597                                   uint32_t *count)
4598 {
4599         DEBUG(4,("enum_all_printers_info_5\n"));
4600
4601         return enum_all_printers_info_level(mem_ctx, session_info, msg_ctx,
4602                                             servername, 5, flags, info, count);
4603 }
4604
4605 /****************************************************************
4606  _spoolss_EnumPrinters
4607 ****************************************************************/
4608
4609 WERROR _spoolss_EnumPrinters(struct pipes_struct *p,
4610                              struct spoolss_EnumPrinters *r)
4611 {
4612         const struct auth_session_info *session_info = get_session_info_system();
4613         WERROR result;
4614
4615         /* that's an [in out] buffer */
4616
4617         if (!r->in.buffer && (r->in.offered != 0)) {
4618                 return WERR_INVALID_PARAM;
4619         }
4620
4621         DEBUG(4,("_spoolss_EnumPrinters\n"));
4622
4623         *r->out.needed = 0;
4624         *r->out.count = 0;
4625         *r->out.info = NULL;
4626
4627         /*
4628          * Level 1:
4629          *          flags==PRINTER_ENUM_NAME
4630          *           if name=="" then enumerates all printers
4631          *           if name!="" then enumerate the printer
4632          *          flags==PRINTER_ENUM_REMOTE
4633          *          name is NULL, enumerate printers
4634          * Level 2: name!="" enumerates printers, name can't be NULL
4635          * Level 3: doesn't exist
4636          * Level 4: does a local registry lookup
4637          * Level 5: same as Level 2
4638          */
4639
4640         if (r->in.server && r->in.server[0] == '\0') {
4641                 r->in.server = NULL;
4642         }
4643
4644         switch (r->in.level) {
4645         case 0:
4646                 result = enumprinters_level0(p->mem_ctx, session_info,
4647                                              p->msg_ctx, r->in.flags,
4648                                              r->in.server,
4649                                              r->out.info, r->out.count);
4650                 break;
4651         case 1:
4652                 result = enumprinters_level1(p->mem_ctx, session_info,
4653                                              p->msg_ctx, r->in.flags,
4654                                              r->in.server,
4655                                              r->out.info, r->out.count);
4656                 break;
4657         case 2:
4658                 result = enumprinters_level2(p->mem_ctx, session_info,
4659                                              p->msg_ctx, r->in.flags,
4660                                              r->in.server,
4661                                              r->out.info, r->out.count);
4662                 break;
4663         case 4:
4664                 result = enumprinters_level4(p->mem_ctx, session_info,
4665                                              p->msg_ctx, r->in.flags,
4666                                              r->in.server,
4667                                              r->out.info, r->out.count);
4668                 break;
4669         case 5:
4670                 result = enumprinters_level5(p->mem_ctx, session_info,
4671                                              p->msg_ctx, r->in.flags,
4672                                              r->in.server,
4673                                              r->out.info, r->out.count);
4674                 break;
4675         default:
4676                 return WERR_UNKNOWN_LEVEL;
4677         }
4678
4679         if (!W_ERROR_IS_OK(result)) {
4680                 return result;
4681         }
4682
4683         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
4684                                                      spoolss_EnumPrinters,
4685                                                      *r->out.info, r->in.level,
4686                                                      *r->out.count);
4687         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
4688         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
4689
4690         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
4691 }
4692
4693 /****************************************************************
4694  _spoolss_GetPrinter
4695 ****************************************************************/
4696
4697 WERROR _spoolss_GetPrinter(struct pipes_struct *p,
4698                            struct spoolss_GetPrinter *r)
4699 {
4700         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
4701         struct spoolss_PrinterInfo2 *info2 = NULL;
4702         WERROR result = WERR_OK;
4703         int snum;
4704
4705         /* that's an [in out] buffer */
4706
4707         if (!r->in.buffer && (r->in.offered != 0)) {
4708                 return WERR_INVALID_PARAM;
4709         }
4710
4711         *r->out.needed = 0;
4712
4713         if (Printer == NULL) {
4714                 return WERR_BADFID;
4715         }
4716
4717         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
4718                 return WERR_BADFID;
4719         }
4720
4721         result = winreg_get_printer_internal(p->mem_ctx,
4722                                     get_session_info_system(),
4723                                     p->msg_ctx,
4724                                     lp_const_servicename(snum),
4725                                     &info2);
4726         if (!W_ERROR_IS_OK(result)) {
4727                 goto out;
4728         }
4729
4730         switch (r->in.level) {
4731         case 0:
4732                 result = construct_printer_info0(p->mem_ctx,
4733                                                  get_session_info_system(),
4734                                                  p->msg_ctx,
4735                                                  info2,
4736                                                  Printer->servername,
4737                                                  &r->out.info->info0,
4738                                                  snum);
4739                 break;
4740         case 1:
4741                 result = construct_printer_info1(p->mem_ctx, info2,
4742                                                  PRINTER_ENUM_ICON8,
4743                                                  Printer->servername,
4744                                                  &r->out.info->info1, snum);
4745                 break;
4746         case 2:
4747                 result = construct_printer_info2(p->mem_ctx, p->msg_ctx, info2,
4748                                                  Printer->servername,
4749                                                  &r->out.info->info2, snum);
4750                 break;
4751         case 3:
4752                 result = construct_printer_info3(p->mem_ctx, info2,
4753                                                  Printer->servername,
4754                                                  &r->out.info->info3, snum);
4755                 break;
4756         case 4:
4757                 result = construct_printer_info4(p->mem_ctx, info2,
4758                                                  Printer->servername,
4759                                                  &r->out.info->info4, snum);
4760                 break;
4761         case 5:
4762                 result = construct_printer_info5(p->mem_ctx, info2,
4763                                                  Printer->servername,
4764                                                  &r->out.info->info5, snum);
4765                 break;
4766         case 6:
4767                 result = construct_printer_info6(p->mem_ctx, p->msg_ctx, info2,
4768                                                  Printer->servername,
4769                                                  &r->out.info->info6, snum);
4770                 break;
4771         case 7:
4772                 result = construct_printer_info7(p->mem_ctx, p->msg_ctx,
4773                                                  Printer->servername,
4774                                                  &r->out.info->info7, snum);
4775                 break;
4776         case 8:
4777                 result = construct_printer_info8(p->mem_ctx, info2,
4778                                                  Printer->servername,
4779                                                  &r->out.info->info8, snum);
4780                 break;
4781         default:
4782                 result = WERR_UNKNOWN_LEVEL;
4783                 break;
4784         }
4785         TALLOC_FREE(info2);
4786
4787  out:
4788         if (!W_ERROR_IS_OK(result)) {
4789                 DEBUG(0, ("_spoolss_GetPrinter: failed to construct printer info level %d - %s\n",
4790                           r->in.level, win_errstr(result)));
4791                 TALLOC_FREE(r->out.info);
4792                 return result;
4793         }
4794
4795         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_PrinterInfo,
4796                                                r->out.info, r->in.level);
4797         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
4798
4799         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
4800 }
4801
4802 /********************************************************************
4803  ********************************************************************/
4804
4805 #define FILL_DRIVER_STRING(mem_ctx, in, out) \
4806         do { \
4807                 if (in && strlen(in)) { \
4808                         out = talloc_strdup(mem_ctx, in); \
4809                 } else { \
4810                         out = talloc_strdup(mem_ctx, ""); \
4811                 } \
4812                 W_ERROR_HAVE_NO_MEMORY(out); \
4813         } while (0);
4814
4815 #define FILL_DRIVER_UNC_STRING(mem_ctx, server, arch, ver, in, out) \
4816         do { \
4817                 if (in && strlen(in)) { \
4818                         out = talloc_asprintf(mem_ctx, "\\\\%s\\print$\\%s\\%d\\%s", server, get_short_archi(arch), ver, in); \
4819                 } else { \
4820                         out = talloc_strdup(mem_ctx, ""); \
4821                 } \
4822                 W_ERROR_HAVE_NO_MEMORY(out); \
4823         } while (0);
4824
4825 static WERROR string_array_from_driver_info(TALLOC_CTX *mem_ctx,
4826                                                   const char **string_array,
4827                                                   const char ***presult,
4828                                                   const char *cservername,
4829                                                   const char *arch,
4830                                                   int version)
4831 {
4832         int i, num_strings = 0;
4833         const char **array = NULL;
4834
4835         if (string_array == NULL) {
4836                 return WERR_INVALID_PARAMETER;
4837         }
4838
4839         for (i=0; string_array[i] && string_array[i][0] != '\0'; i++) {
4840                 const char *str = NULL;
4841
4842                 if (cservername == NULL || arch == NULL) {
4843                         FILL_DRIVER_STRING(mem_ctx, string_array[i], str);
4844                 } else {
4845                         FILL_DRIVER_UNC_STRING(mem_ctx, cservername, arch, version, string_array[i], str);
4846                 }
4847
4848                 if (!add_string_to_array(mem_ctx, str, &array, &num_strings)) {
4849                         TALLOC_FREE(array);
4850                         return WERR_NOMEM;
4851                 }
4852         }
4853
4854         if (i > 0) {
4855                 ADD_TO_ARRAY(mem_ctx, const char *, NULL,
4856                              &array, &num_strings);
4857         }
4858
4859         if (presult) {
4860                 *presult = array;
4861         }
4862
4863         return WERR_OK;
4864 }
4865
4866 /********************************************************************
4867  * fill a spoolss_DriverInfo1 struct
4868  ********************************************************************/
4869
4870 static WERROR fill_printer_driver_info1(TALLOC_CTX *mem_ctx,
4871                                         struct spoolss_DriverInfo1 *r,
4872                                         const struct spoolss_DriverInfo8 *driver,
4873                                         const char *servername)
4874 {
4875         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
4876         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4877
4878         return WERR_OK;
4879 }
4880
4881 /********************************************************************
4882  * fill a spoolss_DriverInfo2 struct
4883  ********************************************************************/
4884
4885 static WERROR fill_printer_driver_info2(TALLOC_CTX *mem_ctx,
4886                                         struct spoolss_DriverInfo2 *r,
4887                                         const struct spoolss_DriverInfo8 *driver,
4888                                         const char *servername)
4889
4890 {
4891         const char *cservername = canon_servername(servername);
4892
4893         r->version              = driver->version;
4894
4895         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
4896         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4897         r->architecture         = talloc_strdup(mem_ctx, driver->architecture);
4898         W_ERROR_HAVE_NO_MEMORY(r->architecture);
4899
4900         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4901                                driver->architecture,
4902                                driver->version,
4903                                driver->driver_path,
4904                                r->driver_path);
4905
4906         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4907                                driver->architecture,
4908                                driver->version,
4909                                driver->data_file,
4910                                r->data_file);
4911
4912         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4913                                driver->architecture,
4914                                driver->version,
4915                                driver->config_file,
4916                                r->config_file);
4917
4918         return WERR_OK;
4919 }
4920
4921 /********************************************************************
4922  * fill a spoolss_DriverInfo3 struct
4923  ********************************************************************/
4924
4925 static WERROR fill_printer_driver_info3(TALLOC_CTX *mem_ctx,
4926                                         struct spoolss_DriverInfo3 *r,
4927                                         const struct spoolss_DriverInfo8 *driver,
4928                                         const char *servername)
4929 {
4930         const char *cservername = canon_servername(servername);
4931
4932         r->version              = driver->version;
4933
4934         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
4935         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4936         r->architecture         = talloc_strdup(mem_ctx, driver->architecture);
4937         W_ERROR_HAVE_NO_MEMORY(r->architecture);
4938
4939         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4940                                driver->architecture,
4941                                driver->version,
4942                                driver->driver_path,
4943                                r->driver_path);
4944
4945         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4946                                driver->architecture,
4947                                driver->version,
4948                                driver->data_file,
4949                                r->data_file);
4950
4951         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4952                                driver->architecture,
4953                                driver->version,
4954                                driver->config_file,
4955                                r->config_file);
4956
4957         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4958                                driver->architecture,
4959                                driver->version,
4960                                driver->help_file,
4961                                r->help_file);
4962
4963         FILL_DRIVER_STRING(mem_ctx,
4964                            driver->monitor_name,
4965                            r->monitor_name);
4966
4967         FILL_DRIVER_STRING(mem_ctx,
4968                            driver->default_datatype,
4969                            r->default_datatype);
4970
4971         return string_array_from_driver_info(mem_ctx,
4972                                              driver->dependent_files,
4973                                              &r->dependent_files,
4974                                              cservername,
4975                                              driver->architecture,
4976                                              driver->version);
4977 }
4978
4979 /********************************************************************
4980  * fill a spoolss_DriverInfo4 struct
4981  ********************************************************************/
4982
4983 static WERROR fill_printer_driver_info4(TALLOC_CTX *mem_ctx,
4984                                         struct spoolss_DriverInfo4 *r,
4985                                         const struct spoolss_DriverInfo8 *driver,
4986                                         const char *servername)
4987 {
4988         const char *cservername = canon_servername(servername);
4989         WERROR result;
4990
4991         r->version              = driver->version;
4992
4993         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
4994         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4995         r->architecture         = talloc_strdup(mem_ctx, driver->architecture);
4996         W_ERROR_HAVE_NO_MEMORY(r->architecture);
4997
4998         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4999                                driver->architecture,
5000                                driver->version,
5001                                driver->driver_path,
5002                                r->driver_path);
5003
5004         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5005                                driver->architecture,
5006                                driver->version,
5007                                driver->data_file,
5008                                r->data_file);
5009
5010         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5011                                driver->architecture,
5012                                driver->version,
5013                                driver->config_file,
5014                                r->config_file);
5015
5016         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5017                                driver->architecture,
5018                                driver->version,
5019                                driver->help_file,
5020                                r->help_file);
5021
5022         result = string_array_from_driver_info(mem_ctx,
5023                                                driver->dependent_files,
5024                                                &r->dependent_files,
5025                                                cservername,
5026                                                driver->architecture,
5027                                                driver->version);
5028         if (!W_ERROR_IS_OK(result)) {
5029                 return result;
5030         }
5031
5032         FILL_DRIVER_STRING(mem_ctx,
5033                            driver->monitor_name,
5034                            r->monitor_name);
5035
5036         FILL_DRIVER_STRING(mem_ctx,
5037                            driver->default_datatype,
5038                            r->default_datatype);
5039
5040
5041         result = string_array_from_driver_info(mem_ctx,
5042                                                driver->previous_names,
5043                                                &r->previous_names,
5044                                                NULL, NULL, 0);
5045
5046         return result;
5047 }
5048
5049 /********************************************************************
5050  * fill a spoolss_DriverInfo5 struct
5051  ********************************************************************/
5052
5053 static WERROR fill_printer_driver_info5(TALLOC_CTX *mem_ctx,
5054                                         struct spoolss_DriverInfo5 *r,
5055                                         const struct spoolss_DriverInfo8 *driver,
5056                                         const char *servername)
5057 {
5058         const char *cservername = canon_servername(servername);
5059
5060         r->version              = driver->version;
5061
5062         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
5063         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
5064         r->architecture         = talloc_strdup(mem_ctx, driver->architecture);
5065         W_ERROR_HAVE_NO_MEMORY(r->architecture);
5066
5067         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5068                                driver->architecture,
5069                                driver->version,
5070                                driver->driver_path,
5071                                r->driver_path);
5072
5073         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5074                                driver->architecture,
5075                                driver->version,
5076                                driver->data_file,
5077                                r->data_file);
5078
5079         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5080                                driver->architecture,
5081                                driver->version,
5082                                driver->config_file,
5083                                r->config_file);
5084
5085         r->driver_attributes    = 0;
5086         r->config_version       = 0;
5087         r->driver_version       = 0;
5088
5089         return WERR_OK;
5090 }
5091 /********************************************************************
5092  * fill a spoolss_DriverInfo6 struct
5093  ********************************************************************/
5094
5095 static WERROR fill_printer_driver_info6(TALLOC_CTX *mem_ctx,
5096                                         struct spoolss_DriverInfo6 *r,
5097                                         const struct spoolss_DriverInfo8 *driver,
5098                                         const char *servername)
5099 {
5100         const char *cservername = canon_servername(servername);
5101         WERROR result;
5102
5103         r->version              = driver->version;
5104
5105         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
5106         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
5107         r->architecture         = talloc_strdup(mem_ctx, driver->architecture);
5108         W_ERROR_HAVE_NO_MEMORY(r->architecture);
5109
5110         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5111                                driver->architecture,
5112                                driver->version,
5113                                driver->driver_path,
5114                                r->driver_path);
5115
5116         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5117                                driver->architecture,
5118                                driver->version,
5119                                driver->data_file,
5120                                r->data_file);
5121
5122         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5123                                driver->architecture,
5124                                driver->version,
5125                                driver->config_file,
5126                                r->config_file);
5127
5128         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5129                                driver->architecture,
5130                                driver->version,
5131                                driver->help_file,
5132                                r->help_file);
5133
5134         FILL_DRIVER_STRING(mem_ctx,
5135                            driver->monitor_name,
5136                            r->monitor_name);
5137
5138         FILL_DRIVER_STRING(mem_ctx,
5139                            driver->default_datatype,
5140                            r->default_datatype);
5141
5142         result = string_array_from_driver_info(mem_ctx,
5143                                                driver->dependent_files,
5144                                                &r->dependent_files,
5145                                                cservername,
5146                                                driver->architecture,
5147                                                driver->version);
5148         if (!W_ERROR_IS_OK(result)) {
5149                 return result;
5150         }
5151
5152         result = string_array_from_driver_info(mem_ctx,
5153                                                driver->previous_names,
5154                                                &r->previous_names,
5155                                                NULL, NULL, 0);
5156         if (!W_ERROR_IS_OK(result)) {
5157                 return result;
5158         }
5159
5160         r->driver_date          = driver->driver_date;
5161         r->driver_version       = driver->driver_version;
5162
5163         FILL_DRIVER_STRING(mem_ctx,
5164                            driver->manufacturer_name,
5165                            r->manufacturer_name);
5166         FILL_DRIVER_STRING(mem_ctx,
5167                            driver->manufacturer_url,
5168                            r->manufacturer_url);
5169         FILL_DRIVER_STRING(mem_ctx,
5170                            driver->hardware_id,
5171                            r->hardware_id);
5172         FILL_DRIVER_STRING(mem_ctx,
5173                            driver->provider,
5174                            r->provider);
5175
5176         return WERR_OK;
5177 }
5178
5179 /********************************************************************
5180  * fill a spoolss_DriverInfo8 struct
5181  ********************************************************************/
5182
5183 static WERROR fill_printer_driver_info8(TALLOC_CTX *mem_ctx,
5184                                         struct spoolss_DriverInfo8 *r,
5185                                         const struct spoolss_DriverInfo8 *driver,
5186                                         const char *servername)
5187 {
5188         const char *cservername = canon_servername(servername);
5189         WERROR result;
5190
5191         r->version              = driver->version;
5192
5193         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
5194         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
5195         r->architecture         = talloc_strdup(mem_ctx, driver->architecture);
5196         W_ERROR_HAVE_NO_MEMORY(r->architecture);
5197
5198         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5199                                driver->architecture,
5200                                driver->version,
5201                                driver->driver_path,
5202                                r->driver_path);
5203
5204         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5205                                driver->architecture,
5206                                driver->version,
5207                                driver->data_file,
5208                                r->data_file);
5209
5210         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5211                                driver->architecture,
5212                                driver->version,
5213                                driver->config_file,
5214                                r->config_file);
5215
5216         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5217                                driver->architecture,
5218                                driver->version,
5219                                driver->help_file,
5220                                r->help_file);
5221
5222         FILL_DRIVER_STRING(mem_ctx,
5223                            driver->monitor_name,
5224                            r->monitor_name);
5225
5226         FILL_DRIVER_STRING(mem_ctx,
5227                            driver->default_datatype,
5228                            r->default_datatype);
5229
5230         result = string_array_from_driver_info(mem_ctx,
5231                                                driver->dependent_files,
5232                                                &r->dependent_files,
5233                                                cservername,
5234                                                driver->architecture,
5235                                                driver->version);
5236         if (!W_ERROR_IS_OK(result)) {
5237                 return result;
5238         }
5239
5240         result = string_array_from_driver_info(mem_ctx,
5241                                                driver->previous_names,
5242                                                &r->previous_names,
5243                                                NULL, NULL, 0);
5244         if (!W_ERROR_IS_OK(result)) {
5245                 return result;
5246         }
5247
5248         r->driver_date          = driver->driver_date;
5249         r->driver_version       = driver->driver_version;
5250
5251         FILL_DRIVER_STRING(mem_ctx,
5252                            driver->manufacturer_name,
5253                            r->manufacturer_name);
5254         FILL_DRIVER_STRING(mem_ctx,
5255                            driver->manufacturer_url,
5256                            r->manufacturer_url);
5257         FILL_DRIVER_STRING(mem_ctx,
5258                            driver->hardware_id,
5259                            r->hardware_id);
5260         FILL_DRIVER_STRING(mem_ctx,
5261                            driver->provider,
5262                            r->provider);
5263
5264         FILL_DRIVER_STRING(mem_ctx,
5265                            driver->print_processor,
5266                            r->print_processor);
5267         FILL_DRIVER_STRING(mem_ctx,
5268                            driver->vendor_setup,
5269                            r->vendor_setup);
5270
5271         result = string_array_from_driver_info(mem_ctx,
5272                                                driver->color_profiles,
5273                                                &r->color_profiles,
5274                                                NULL, NULL, 0);
5275         if (!W_ERROR_IS_OK(result)) {
5276                 return result;
5277         }
5278
5279         FILL_DRIVER_STRING(mem_ctx,
5280                            driver->inf_path,
5281                            r->inf_path);
5282
5283         r->printer_driver_attributes    = driver->printer_driver_attributes;
5284
5285         result = string_array_from_driver_info(mem_ctx,
5286                                                driver->core_driver_dependencies,
5287                                                &r->core_driver_dependencies,
5288                                                NULL, NULL, 0);
5289         if (!W_ERROR_IS_OK(result)) {
5290                 return result;
5291         }
5292
5293         r->min_inbox_driver_ver_date    = driver->min_inbox_driver_ver_date;
5294         r->min_inbox_driver_ver_version = driver->min_inbox_driver_ver_version;
5295
5296         return WERR_OK;
5297 }
5298
5299 #if 0 /* disabled until marshalling issues are resolved - gd */
5300 /********************************************************************
5301  ********************************************************************/
5302
5303 static WERROR fill_spoolss_DriverFileInfo(TALLOC_CTX *mem_ctx,
5304                                           struct spoolss_DriverFileInfo *r,
5305                                           const char *cservername,
5306                                           const char *file_name,
5307                                           enum spoolss_DriverFileType file_type,
5308                                           uint32_t file_version)
5309 {
5310         r->file_name    = talloc_asprintf(mem_ctx, "\\\\%s%s",
5311                                           cservername, file_name);
5312         W_ERROR_HAVE_NO_MEMORY(r->file_name);
5313         r->file_type    = file_type;
5314         r->file_version = file_version;
5315
5316         return WERR_OK;
5317 }
5318
5319 /********************************************************************
5320  ********************************************************************/
5321
5322 static WERROR spoolss_DriverFileInfo_from_driver(TALLOC_CTX *mem_ctx,
5323                                                  const struct spoolss_DriverInfo8 *driver,
5324                                                  const char *cservername,
5325                                                  struct spoolss_DriverFileInfo **info_p,
5326                                                  uint32_t *count_p)
5327 {
5328         struct spoolss_DriverFileInfo *info = NULL;
5329         uint32_t count = 0;
5330         WERROR result;
5331         uint32_t i;
5332
5333         *info_p = NULL;
5334         *count_p = 0;
5335
5336         if (strlen(driver->driver_path)) {
5337                 info = talloc_realloc(mem_ctx, info,
5338                                             struct spoolss_DriverFileInfo,
5339                                             count + 1);
5340                 W_ERROR_HAVE_NO_MEMORY(info);
5341                 result = fill_spoolss_DriverFileInfo(info,
5342                                                      &info[count],
5343                                                      cservername,
5344                                                      driver->driver_path,
5345                                                      SPOOLSS_DRIVER_FILE_TYPE_RENDERING,
5346                                                      0);
5347                 W_ERROR_NOT_OK_RETURN(result);
5348                 count++;
5349         }
5350
5351         if (strlen(driver->config_file)) {
5352                 info = talloc_realloc(mem_ctx, info,
5353                                             struct spoolss_DriverFileInfo,
5354                                             count + 1);
5355                 W_ERROR_HAVE_NO_MEMORY(info);
5356                 result = fill_spoolss_DriverFileInfo(info,
5357                                                      &info[count],
5358                                                      cservername,
5359                                                      driver->config_file,
5360                                                      SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION,
5361                                                      0);
5362                 W_ERROR_NOT_OK_RETURN(result);
5363                 count++;
5364         }
5365
5366         if (strlen(driver->data_file)) {
5367                 info = talloc_realloc(mem_ctx, info,
5368                                             struct spoolss_DriverFileInfo,
5369                                             count + 1);
5370                 W_ERROR_HAVE_NO_MEMORY(info);
5371                 result = fill_spoolss_DriverFileInfo(info,
5372                                                      &info[count],
5373                                                      cservername,
5374                                                      driver->data_file,
5375                                                      SPOOLSS_DRIVER_FILE_TYPE_DATA,
5376                                                      0);
5377                 W_ERROR_NOT_OK_RETURN(result);
5378                 count++;
5379         }
5380
5381         if (strlen(driver->help_file)) {
5382                 info = talloc_realloc(mem_ctx, info,
5383                                             struct spoolss_DriverFileInfo,
5384                                             count + 1);
5385                 W_ERROR_HAVE_NO_MEMORY(info);
5386                 result = fill_spoolss_DriverFileInfo(info,
5387                                                      &info[count],
5388                                                      cservername,
5389                                                      driver->help_file,
5390                                                      SPOOLSS_DRIVER_FILE_TYPE_HELP,
5391                                                      0);
5392                 W_ERROR_NOT_OK_RETURN(result);
5393                 count++;
5394         }
5395
5396         for (i=0; driver->dependent_files[i] && driver->dependent_files[i][0] != '\0'; i++) {
5397                 info = talloc_realloc(mem_ctx, info,
5398                                             struct spoolss_DriverFileInfo,
5399                                             count + 1);
5400                 W_ERROR_HAVE_NO_MEMORY(info);
5401                 result = fill_spoolss_DriverFileInfo(info,
5402                                                      &info[count],
5403                                                      cservername,
5404                                                      driver->dependent_files[i],
5405                                                      SPOOLSS_DRIVER_FILE_TYPE_OTHER,
5406                                                      0);
5407                 W_ERROR_NOT_OK_RETURN(result);
5408                 count++;
5409         }
5410
5411         *info_p = info;
5412         *count_p = count;
5413
5414         return WERR_OK;
5415 }
5416
5417 /********************************************************************
5418  * fill a spoolss_DriverInfo101 struct
5419  ********************************************************************/
5420
5421 static WERROR fill_printer_driver_info101(TALLOC_CTX *mem_ctx,
5422                                           struct spoolss_DriverInfo101 *r,
5423                                           const struct spoolss_DriverInfo8 *driver,
5424                                           const char *servername)
5425 {
5426         const char *cservername = canon_servername(servername);
5427         WERROR result;
5428
5429         r->version              = driver->version;
5430
5431         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
5432         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
5433         r->architecture         = talloc_strdup(mem_ctx, driver->architecture);
5434         W_ERROR_HAVE_NO_MEMORY(r->architecture);
5435
5436         result = spoolss_DriverFileInfo_from_driver(mem_ctx, driver,
5437                                                     cservername,
5438                                                     &r->file_info,
5439                                                     &r->file_count);
5440         if (!W_ERROR_IS_OK(result)) {
5441                 return result;
5442         }
5443
5444         FILL_DRIVER_STRING(mem_ctx,
5445                            driver->monitor_name,
5446                            r->monitor_name);
5447
5448         FILL_DRIVER_STRING(mem_ctx,
5449                            driver->default_datatype,
5450                            r->default_datatype);
5451
5452         result = string_array_from_driver_info(mem_ctx,
5453                                                driver->previous_names,
5454                                                &r->previous_names,
5455                                                NULL, NULL, 0);
5456         if (!W_ERROR_IS_OK(result)) {
5457                 return result;
5458         }
5459
5460         r->driver_date          = driver->driver_date;
5461         r->driver_version       = driver->driver_version;
5462
5463         FILL_DRIVER_STRING(mem_ctx,
5464                            driver->manufacturer_name,
5465                            r->manufacturer_name);
5466         FILL_DRIVER_STRING(mem_ctx,
5467                            driver->manufacturer_url,
5468                            r->manufacturer_url);
5469         FILL_DRIVER_STRING(mem_ctx,
5470                            driver->hardware_id,
5471                            r->hardware_id);
5472         FILL_DRIVER_STRING(mem_ctx,
5473                            driver->provider,
5474                            r->provider);
5475
5476         return WERR_OK;
5477 }
5478 #endif
5479 /********************************************************************
5480  ********************************************************************/
5481
5482 static WERROR construct_printer_driver_info_level(TALLOC_CTX *mem_ctx,
5483                                                   const struct auth_session_info *session_info,
5484                                                   struct messaging_context *msg_ctx,
5485                                                   uint32_t level,
5486                                                   union spoolss_DriverInfo *r,
5487                                                   int snum,
5488                                                   const char *servername,
5489                                                   const char *architecture,
5490                                                   uint32_t version)
5491 {
5492         struct spoolss_PrinterInfo2 *pinfo2 = NULL;
5493         struct spoolss_DriverInfo8 *driver;
5494         WERROR result;
5495         struct dcerpc_binding_handle *b;
5496         TALLOC_CTX *tmp_ctx = NULL;
5497
5498         if (level == 101) {
5499                 return WERR_UNKNOWN_LEVEL;
5500         }
5501
5502         tmp_ctx = talloc_new(mem_ctx);
5503         if (!tmp_ctx) {
5504                 return WERR_NOMEM;
5505         }
5506
5507         result = winreg_printer_binding_handle(tmp_ctx,
5508                                                session_info,
5509                                                msg_ctx,
5510                                                &b);
5511         if (!W_ERROR_IS_OK(result)) {
5512                 goto done;
5513         }
5514
5515         result = winreg_get_printer(tmp_ctx, b,
5516                                     lp_const_servicename(snum),
5517                                     &pinfo2);
5518
5519         DEBUG(8,("construct_printer_driver_info_level: status: %s\n",
5520                 win_errstr(result)));
5521
5522         if (!W_ERROR_IS_OK(result)) {
5523                 result = WERR_INVALID_PRINTER_NAME;
5524                 goto done;
5525         }
5526
5527         result = winreg_get_driver(tmp_ctx, b,
5528                                    architecture,
5529                                    pinfo2->drivername, version, &driver);
5530
5531         DEBUG(8,("construct_printer_driver_info_level: status: %s\n",
5532                 win_errstr(result)));
5533
5534         if (!W_ERROR_IS_OK(result)) {
5535                 /*
5536                  * Is this a W2k client ?
5537                  */
5538
5539                 if (version < 3) {
5540                         result = WERR_UNKNOWN_PRINTER_DRIVER;
5541                         goto done;
5542                 }
5543
5544                 /* Yes - try again with a WinNT driver. */
5545                 version = 2;
5546                 result = winreg_get_driver(tmp_ctx, b,
5547                                            architecture,
5548                                            pinfo2->drivername,
5549                                            version, &driver);
5550                 DEBUG(8,("construct_printer_driver_level: status: %s\n",
5551                         win_errstr(result)));
5552                 if (!W_ERROR_IS_OK(result)) {
5553                         result = WERR_UNKNOWN_PRINTER_DRIVER;
5554                         goto done;
5555                 }
5556         }
5557
5558         /* these are allocated on mem_ctx and not tmp_ctx because they are
5559          * the 'return value' and need to utlive this call */
5560         switch (level) {
5561         case 1:
5562                 result = fill_printer_driver_info1(mem_ctx, &r->info1, driver, servername);
5563                 break;
5564         case 2:
5565                 result = fill_printer_driver_info2(mem_ctx, &r->info2, driver, servername);
5566                 break;
5567         case 3:
5568                 result = fill_printer_driver_info3(mem_ctx, &r->info3, driver, servername);
5569                 break;
5570         case 4:
5571                 result = fill_printer_driver_info4(mem_ctx, &r->info4, driver, servername);
5572                 break;
5573         case 5:
5574                 result = fill_printer_driver_info5(mem_ctx, &r->info5, driver, servername);
5575                 break;
5576         case 6:
5577                 result = fill_printer_driver_info6(mem_ctx, &r->info6, driver, servername);
5578                 break;
5579         case 8:
5580                 result = fill_printer_driver_info8(mem_ctx, &r->info8, driver, servername);
5581                 break;
5582 #if 0 /* disabled until marshalling issues are resolved - gd */
5583         case 101:
5584                 result = fill_printer_driver_info101(mem_ctx, &r->info101, driver, servername);
5585                 break;
5586 #endif
5587         default:
5588                 result = WERR_UNKNOWN_LEVEL;
5589                 break;
5590         }
5591
5592 done:
5593         talloc_free(tmp_ctx);
5594         return result;
5595 }
5596
5597 /****************************************************************
5598  _spoolss_GetPrinterDriver2
5599 ****************************************************************/
5600
5601 WERROR _spoolss_GetPrinterDriver2(struct pipes_struct *p,
5602                                   struct spoolss_GetPrinterDriver2 *r)
5603 {
5604         struct printer_handle *printer;
5605         WERROR result;
5606
5607         int snum;
5608
5609         /* that's an [in out] buffer */
5610
5611         if (!r->in.buffer && (r->in.offered != 0)) {
5612                 return WERR_INVALID_PARAM;
5613         }
5614
5615         DEBUG(4,("_spoolss_GetPrinterDriver2\n"));
5616
5617         if (!(printer = find_printer_index_by_hnd(p, r->in.handle))) {
5618                 DEBUG(0,("_spoolss_GetPrinterDriver2: invalid printer handle!\n"));
5619                 return WERR_INVALID_PRINTER_NAME;
5620         }
5621
5622         *r->out.needed = 0;
5623         *r->out.server_major_version = 0;
5624         *r->out.server_minor_version = 0;
5625
5626         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5627                 return WERR_BADFID;
5628         }
5629
5630         result = construct_printer_driver_info_level(p->mem_ctx,
5631                                                      get_session_info_system(),
5632                                                      p->msg_ctx,
5633                                                      r->in.level, r->out.info,
5634                                                      snum, printer->servername,
5635                                                      r->in.architecture,
5636                                                      r->in.client_major_version);
5637         if (!W_ERROR_IS_OK(result)) {
5638                 TALLOC_FREE(r->out.info);
5639                 return result;
5640         }
5641
5642         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_DriverInfo,
5643                                                r->out.info, r->in.level);
5644         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
5645
5646         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
5647 }
5648
5649
5650 /****************************************************************
5651  _spoolss_StartPagePrinter
5652 ****************************************************************/
5653
5654 WERROR _spoolss_StartPagePrinter(struct pipes_struct *p,
5655                                  struct spoolss_StartPagePrinter *r)
5656 {
5657         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
5658
5659         if (!Printer) {
5660                 DEBUG(3,("_spoolss_StartPagePrinter: "
5661                         "Error in startpageprinter printer handle\n"));
5662                 return WERR_BADFID;
5663         }
5664
5665         Printer->page_started = true;
5666         return WERR_OK;
5667 }
5668
5669 /****************************************************************
5670  _spoolss_EndPagePrinter
5671 ****************************************************************/
5672
5673 WERROR _spoolss_EndPagePrinter(struct pipes_struct *p,
5674                                struct spoolss_EndPagePrinter *r)
5675 {
5676         int snum;
5677
5678         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
5679
5680         if (!Printer) {
5681                 DEBUG(2,("_spoolss_EndPagePrinter: Invalid handle (%s:%u:%u).\n",
5682                         OUR_HANDLE(r->in.handle)));
5683                 return WERR_BADFID;
5684         }
5685
5686         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5687                 return WERR_BADFID;
5688
5689         Printer->page_started = false;
5690         print_job_endpage(p->msg_ctx, snum, Printer->jobid);
5691
5692         return WERR_OK;
5693 }
5694
5695 /****************************************************************
5696  _spoolss_StartDocPrinter
5697 ****************************************************************/
5698
5699 WERROR _spoolss_StartDocPrinter(struct pipes_struct *p,
5700                                 struct spoolss_StartDocPrinter *r)
5701 {
5702         struct spoolss_DocumentInfo1 *info_1;
5703         int snum;
5704         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
5705         WERROR werr;
5706         char *rhost;
5707         int rc;
5708
5709         if (!Printer) {
5710                 DEBUG(2,("_spoolss_StartDocPrinter: "
5711                         "Invalid handle (%s:%u:%u)\n",
5712                         OUR_HANDLE(r->in.handle)));
5713                 return WERR_BADFID;
5714         }
5715
5716         if (Printer->jobid) {
5717                 DEBUG(2, ("_spoolss_StartDocPrinter: "
5718                           "StartDocPrinter called twice! "
5719                           "(existing jobid = %d)\n", Printer->jobid));
5720                 return WERR_INVALID_HANDLE;
5721         }
5722
5723         if (r->in.level != 1) {
5724                 return WERR_UNKNOWN_LEVEL;
5725         }
5726
5727         info_1 = r->in.info.info1;
5728
5729         /*
5730          * a nice thing with NT is it doesn't listen to what you tell it.
5731          * when asked to send _only_ RAW datas, it tries to send datas
5732          * in EMF format.
5733          *
5734          * So I add checks like in NT Server ...
5735          */
5736
5737         if (info_1->datatype) {
5738                 if (strcmp(info_1->datatype, "RAW") != 0) {
5739                         *r->out.job_id = 0;
5740                         return WERR_INVALID_DATATYPE;
5741                 }
5742         }
5743
5744         /* get the share number of the printer */
5745         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5746                 return WERR_BADFID;
5747         }
5748
5749         rc = get_remote_hostname(p->remote_address,
5750                                  &rhost,
5751                                  p->mem_ctx);
5752         if (rc < 0) {
5753                 return WERR_NOMEM;
5754         }
5755         if (strequal(rhost,"UNKNOWN")) {
5756                 rhost = tsocket_address_inet_addr_string(p->remote_address,
5757                                                          p->mem_ctx);
5758                 if (rhost == NULL) {
5759                         return WERR_NOMEM;
5760                 }
5761         }
5762
5763         werr = print_job_start(p->session_info,
5764                                p->msg_ctx,
5765                                rhost,
5766                                snum,
5767                                info_1->document_name,
5768                                info_1->output_file,
5769                                Printer->devmode,
5770                                &Printer->jobid);
5771
5772         /* An error occured in print_job_start() so return an appropriate
5773            NT error code. */
5774
5775         if (!W_ERROR_IS_OK(werr)) {
5776                 return werr;
5777         }
5778
5779         Printer->document_started = true;
5780         *r->out.job_id = Printer->jobid;
5781
5782         return WERR_OK;
5783 }
5784
5785 /****************************************************************
5786  _spoolss_EndDocPrinter
5787 ****************************************************************/
5788
5789 WERROR _spoolss_EndDocPrinter(struct pipes_struct *p,
5790                               struct spoolss_EndDocPrinter *r)
5791 {
5792         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
5793         NTSTATUS status;
5794         int snum;
5795
5796         if (!Printer) {
5797                 DEBUG(2,("_spoolss_EndDocPrinter: Invalid handle (%s:%u:%u)\n",
5798                         OUR_HANDLE(r->in.handle)));
5799                 return WERR_BADFID;
5800         }
5801
5802         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5803                 return WERR_BADFID;
5804         }
5805
5806         Printer->document_started = false;
5807         status = print_job_end(p->msg_ctx, snum, Printer->jobid, NORMAL_CLOSE);
5808         if (!NT_STATUS_IS_OK(status)) {
5809                 DEBUG(2, ("_spoolss_EndDocPrinter: "
5810                           "print_job_end failed [%s]\n",
5811                           nt_errstr(status)));
5812         }
5813
5814         Printer->jobid = 0;
5815         return ntstatus_to_werror(status);
5816 }
5817
5818 /****************************************************************
5819  _spoolss_WritePrinter
5820 ****************************************************************/
5821
5822 WERROR _spoolss_WritePrinter(struct pipes_struct *p,
5823                              struct spoolss_WritePrinter *r)
5824 {
5825         ssize_t buffer_written;
5826         int snum;
5827         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
5828
5829         if (!Printer) {
5830                 DEBUG(2,("_spoolss_WritePrinter: Invalid handle (%s:%u:%u)\n",
5831                         OUR_HANDLE(r->in.handle)));
5832                 *r->out.num_written = r->in._data_size;
5833                 return WERR_BADFID;
5834         }
5835
5836         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5837                 return WERR_BADFID;
5838
5839         /* print_job_write takes care of checking for PJOB_SMBD_SPOOLING */
5840         buffer_written = print_job_write(server_event_context(),p->msg_ctx,
5841                                                    snum, Printer->jobid,
5842                                                    (const char *)r->in.data.data,
5843                                                    (size_t)r->in._data_size);
5844         if (buffer_written == (ssize_t)-1) {
5845                 *r->out.num_written = 0;
5846                 if (errno == ENOSPC)
5847                         return WERR_NO_SPOOL_SPACE;
5848                 else
5849                         return WERR_ACCESS_DENIED;
5850         }
5851
5852         *r->out.num_written = r->in._data_size;
5853
5854         return WERR_OK;
5855 }
5856
5857 /********************************************************************
5858  * api_spoolss_getprinter
5859  * called from the spoolss dispatcher
5860  *
5861  ********************************************************************/
5862
5863 static WERROR control_printer(struct policy_handle *handle, uint32_t command,
5864                               struct pipes_struct *p)
5865 {
5866         const struct auth_session_info *session_info = p->session_info;
5867         int snum;
5868         WERROR errcode = WERR_BADFUNC;
5869         struct printer_handle *Printer = find_printer_index_by_hnd(p, handle);
5870
5871         if (!Printer) {
5872                 DEBUG(2,("control_printer: Invalid handle (%s:%u:%u)\n",
5873                         OUR_HANDLE(handle)));
5874                 return WERR_BADFID;
5875         }
5876
5877         if (!get_printer_snum(p, handle, &snum, NULL))
5878                 return WERR_BADFID;
5879
5880         switch (command) {
5881         case SPOOLSS_PRINTER_CONTROL_PAUSE:
5882                 errcode = print_queue_pause(session_info, p->msg_ctx, snum);
5883                 break;
5884         case SPOOLSS_PRINTER_CONTROL_RESUME:
5885         case SPOOLSS_PRINTER_CONTROL_UNPAUSE:
5886                 errcode = print_queue_resume(session_info, p->msg_ctx, snum);
5887                 break;
5888         case SPOOLSS_PRINTER_CONTROL_PURGE:
5889                 errcode = print_queue_purge(session_info, p->msg_ctx, snum);
5890                 break;
5891         default:
5892                 return WERR_UNKNOWN_LEVEL;
5893         }
5894
5895         return errcode;
5896 }
5897
5898
5899 /****************************************************************
5900  _spoolss_AbortPrinter
5901  * From MSDN: "Deletes printer's spool file if printer is configured
5902  * for spooling"
5903 ****************************************************************/
5904
5905 WERROR _spoolss_AbortPrinter(struct pipes_struct *p,
5906                              struct spoolss_AbortPrinter *r)
5907 {
5908         struct printer_handle   *Printer = find_printer_index_by_hnd(p, r->in.handle);
5909         int             snum;
5910         WERROR          errcode = WERR_OK;
5911
5912         if (!Printer) {
5913                 DEBUG(2,("_spoolss_AbortPrinter: Invalid handle (%s:%u:%u)\n",
5914                         OUR_HANDLE(r->in.handle)));
5915                 return WERR_BADFID;
5916         }
5917
5918         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5919                 return WERR_BADFID;
5920
5921         if (!Printer->document_started) {
5922                 return WERR_SPL_NO_STARTDOC;
5923         }
5924
5925         errcode = print_job_delete(p->session_info,
5926                                    p->msg_ctx,
5927                                    snum,
5928                                    Printer->jobid);
5929
5930         return errcode;
5931 }
5932
5933 /********************************************************************
5934  * called by spoolss_api_setprinter
5935  * when updating a printer description
5936  ********************************************************************/
5937
5938 static WERROR update_printer_sec(struct policy_handle *handle,
5939                                  struct pipes_struct *p,
5940                                  struct sec_desc_buf *secdesc_ctr)
5941 {
5942         struct spoolss_security_descriptor *new_secdesc = NULL;
5943         struct spoolss_security_descriptor *old_secdesc = NULL;
5944         const char *printer;
5945         WERROR result;
5946         int snum;
5947         struct printer_handle *Printer = find_printer_index_by_hnd(p, handle);
5948         struct dcerpc_binding_handle *b;
5949         TALLOC_CTX *tmp_ctx = NULL;
5950
5951         if (!Printer || !get_printer_snum(p, handle, &snum, NULL)) {
5952                 DEBUG(2,("update_printer_sec: Invalid handle (%s:%u:%u)\n",
5953                          OUR_HANDLE(handle)));
5954
5955                 result = WERR_BADFID;
5956                 goto done;
5957         }
5958
5959         if (secdesc_ctr == NULL) {
5960                 DEBUG(10,("update_printer_sec: secdesc_ctr is NULL !\n"));
5961                 result = WERR_INVALID_PARAM;
5962                 goto done;
5963         }
5964         printer = lp_const_servicename(snum);
5965
5966         /* Check the user has permissions to change the security
5967            descriptor.  By experimentation with two NT machines, the user
5968            requires Full Access to the printer to change security
5969            information. */
5970
5971         if ( Printer->access_granted != PRINTER_ACCESS_ADMINISTER ) {
5972                 DEBUG(4,("update_printer_sec: updated denied by printer permissions\n"));
5973                 result = WERR_ACCESS_DENIED;
5974                 goto done;
5975         }
5976
5977         tmp_ctx = talloc_new(p->mem_ctx);
5978         if (!tmp_ctx) {
5979                 return WERR_NOMEM;
5980         }
5981
5982         result = winreg_printer_binding_handle(tmp_ctx,
5983                                                get_session_info_system(),
5984                                                p->msg_ctx,
5985                                                &b);
5986         if (!W_ERROR_IS_OK(result)) {
5987                 goto done;
5988         }
5989
5990         /* NT seems to like setting the security descriptor even though
5991            nothing may have actually changed. */
5992         result = winreg_get_printer_secdesc(tmp_ctx, b,
5993                                             printer,
5994                                             &old_secdesc);
5995         if (!W_ERROR_IS_OK(result)) {
5996                 DEBUG(2,("update_printer_sec: winreg_get_printer_secdesc_internal() failed\n"));
5997                 result = WERR_BADFID;
5998                 goto done;
5999         }
6000
6001         if (DEBUGLEVEL >= 10) {
6002                 struct security_acl *the_acl;
6003                 int i;
6004
6005                 the_acl = old_secdesc->dacl;
6006                 DEBUG(10, ("old_secdesc_ctr for %s has %d aces:\n",
6007                            printer, the_acl->num_aces));
6008
6009                 for (i = 0; i < the_acl->num_aces; i++) {
6010                         DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
6011                                            &the_acl->aces[i].trustee),
6012                                   the_acl->aces[i].access_mask));
6013                 }
6014
6015                 the_acl = secdesc_ctr->sd->dacl;
6016
6017                 if (the_acl) {
6018                         DEBUG(10, ("secdesc_ctr for %s has %d aces:\n",
6019                                    printer, the_acl->num_aces));
6020
6021                         for (i = 0; i < the_acl->num_aces; i++) {
6022                                 DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
6023                                                    &the_acl->aces[i].trustee),
6024                                            the_acl->aces[i].access_mask));
6025                         }
6026                 } else {
6027                         DEBUG(10, ("dacl for secdesc_ctr is NULL\n"));
6028                 }
6029         }
6030
6031         new_secdesc = sec_desc_merge(tmp_ctx, secdesc_ctr->sd, old_secdesc);
6032         if (new_secdesc == NULL) {
6033                 result = WERR_NOMEM;
6034                 goto done;
6035         }
6036
6037         if (security_descriptor_equal(new_secdesc, old_secdesc)) {
6038                 result = WERR_OK;
6039                 goto done;
6040         }
6041
6042         result = winreg_set_printer_secdesc(tmp_ctx, b,
6043                                             printer,
6044                                             new_secdesc);
6045
6046 done:
6047         talloc_free(tmp_ctx);
6048         return result;
6049 }
6050
6051 /********************************************************************
6052  Canonicalize printer info from a client
6053  ********************************************************************/
6054
6055 static bool check_printer_ok(TALLOC_CTX *mem_ctx,
6056                              struct spoolss_SetPrinterInfo2 *info2,
6057                              int snum)
6058 {
6059         fstring printername;
6060         const char *p;
6061
6062         DEBUG(5,("check_printer_ok: servername=%s printername=%s sharename=%s "
6063                 "portname=%s drivername=%s comment=%s location=%s\n",
6064                 info2->servername, info2->printername, info2->sharename,
6065                 info2->portname, info2->drivername, info2->comment,
6066                 info2->location));
6067
6068         /* we force some elements to "correct" values */
6069         info2->servername = talloc_asprintf(mem_ctx, "\\\\%s", lp_netbios_name());
6070         if (info2->servername == NULL) {
6071                 return false;
6072         }
6073         info2->sharename = talloc_strdup(mem_ctx, lp_const_servicename(snum));
6074         if (info2->sharename == NULL) {
6075                 return false;
6076         }
6077
6078         /* check to see if we allow printername != sharename */
6079         if (lp_force_printername(snum)) {
6080                 info2->printername = talloc_asprintf(mem_ctx, "\\\\%s\\%s",
6081                                         lp_netbios_name(), info2->sharename);
6082         } else {
6083                 /* make sure printername is in \\server\printername format */
6084                 fstrcpy(printername, info2->printername);
6085                 p = printername;
6086                 if ( printername[0] == '\\' && printername[1] == '\\' ) {
6087                         if ( (p = strchr_m( &printername[2], '\\' )) != NULL )
6088                                 p++;
6089                 }
6090
6091                 info2->printername = talloc_asprintf(mem_ctx, "\\\\%s\\%s",
6092                                         lp_netbios_name(), p);
6093         }
6094         if (info2->printername == NULL) {
6095                 return false;
6096         }
6097
6098         info2->attributes |= PRINTER_ATTRIBUTE_SAMBA;
6099         info2->attributes &= ~PRINTER_ATTRIBUTE_NOT_SAMBA;
6100
6101         return true;
6102 }
6103
6104 /****************************************************************************
6105 ****************************************************************************/
6106
6107 static WERROR add_port_hook(TALLOC_CTX *ctx, struct security_token *token, const char *portname, const char *uri)
6108 {
6109         char *cmd = lp_addport_cmd(talloc_tos());
6110         char *command = NULL;
6111         int ret;
6112         bool is_print_op = false;
6113
6114         if ( !*cmd ) {
6115                 return WERR_ACCESS_DENIED;
6116         }
6117
6118         command = talloc_asprintf(ctx,
6119                         "%s \"%s\" \"%s\"", cmd, portname, uri );
6120         if (!command) {
6121                 return WERR_NOMEM;
6122         }
6123
6124         if ( token )
6125                 is_print_op = security_token_has_privilege(token, SEC_PRIV_PRINT_OPERATOR);
6126
6127         DEBUG(10,("Running [%s]\n", command));
6128
6129         /********* BEGIN SePrintOperatorPrivilege **********/
6130
6131         if ( is_print_op )
6132                 become_root();
6133
6134         ret = smbrun(command, NULL);
6135
6136         if ( is_print_op )
6137                 unbecome_root();
6138
6139         /********* END SePrintOperatorPrivilege **********/
6140
6141         DEBUGADD(10,("returned [%d]\n", ret));
6142
6143         TALLOC_FREE(command);
6144
6145         if ( ret != 0 ) {
6146                 return WERR_ACCESS_DENIED;
6147         }
6148
6149         return WERR_OK;
6150 }
6151
6152 /****************************************************************************
6153 ****************************************************************************/
6154
6155 static bool spoolss_conn_snum_used(struct smbd_server_connection *sconn,
6156                                    int snum)
6157 {
6158         /*
6159          * As we do not know if we are embedded in the file server process
6160          * or not, we have to pretend that all shares are in use.
6161          */
6162         return true;
6163 }
6164
6165 static bool add_printer_hook(TALLOC_CTX *ctx, struct security_token *token,
6166                              struct spoolss_SetPrinterInfo2 *info2,
6167                              const char *remote_machine,
6168                              struct messaging_context *msg_ctx)
6169 {
6170         char *cmd = lp_addprinter_cmd(talloc_tos());
6171         char **qlines;
6172         char *command = NULL;
6173         int numlines;
6174         int ret;
6175         int fd;
6176         bool is_print_op = false;
6177
6178         if (!remote_machine) {
6179                 return false;
6180         }
6181
6182         command = talloc_asprintf(ctx,
6183                         "%s \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"",
6184                         cmd, info2->printername, info2->sharename,
6185                         info2->portname, info2->drivername,
6186                         info2->location, info2->comment, remote_machine);
6187         if (!command) {
6188                 return false;
6189         }
6190
6191         if ( token )
6192                 is_print_op = security_token_has_privilege(token, SEC_PRIV_PRINT_OPERATOR);
6193
6194         DEBUG(10,("Running [%s]\n", command));
6195
6196         /********* BEGIN SePrintOperatorPrivilege **********/
6197
6198         if ( is_print_op )
6199                 become_root();
6200
6201         if ( (ret = smbrun(command, &fd)) == 0 ) {
6202                 /* Tell everyone we updated smb.conf. */
6203                 message_send_all(msg_ctx, MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
6204         }
6205
6206         if ( is_print_op )
6207                 unbecome_root();
6208
6209         /********* END SePrintOperatorPrivilege **********/
6210
6211         DEBUGADD(10,("returned [%d]\n", ret));
6212
6213         TALLOC_FREE(command);
6214
6215         if ( ret != 0 ) {
6216                 if (fd != -1)
6217                         close(fd);
6218                 return false;
6219         }
6220
6221         /* reload our services immediately */
6222         become_root();
6223         reload_services(NULL, spoolss_conn_snum_used, false);
6224         unbecome_root();
6225
6226         numlines = 0;
6227         /* Get lines and convert them back to dos-codepage */
6228         qlines = fd_lines_load(fd, &numlines, 0, NULL);
6229         DEBUGADD(10,("Lines returned = [%d]\n", numlines));
6230         close(fd);
6231
6232         /* Set the portname to what the script says the portname should be. */
6233         /* but don't require anything to be return from the script exit a good error code */
6234
6235         if (numlines) {
6236                 /* Set the portname to what the script says the portname should be. */
6237                 info2->portname = talloc_strdup(ctx, qlines[0]);
6238                 DEBUGADD(6,("Line[0] = [%s]\n", qlines[0]));
6239         }
6240
6241         TALLOC_FREE(qlines);
6242         return true;
6243 }
6244
6245 static WERROR update_dsspooler(TALLOC_CTX *mem_ctx,
6246                                const struct auth_session_info *session_info,
6247                                struct messaging_context *msg_ctx,
6248                                int snum,
6249                                struct spoolss_SetPrinterInfo2 *printer,
6250                                struct spoolss_PrinterInfo2 *old_printer)
6251 {
6252         bool force_update = (old_printer == NULL);
6253         const char *dnsdomname;
6254         const char *longname;
6255         const char *uncname;
6256         const char *spooling;
6257         DATA_BLOB buffer;
6258         WERROR result = WERR_OK;
6259         struct dcerpc_binding_handle *b;
6260         TALLOC_CTX *tmp_ctx;
6261         bool ok;
6262
6263         tmp_ctx = talloc_new(mem_ctx);
6264         if (!tmp_ctx) {
6265                 return WERR_NOMEM;
6266         }
6267
6268         result = winreg_printer_binding_handle(tmp_ctx,
6269                                                session_info,
6270                                                msg_ctx,
6271                                                &b);
6272         if (!W_ERROR_IS_OK(result)) {
6273                 goto done;
6274         }
6275
6276         if (printer->drivername != NULL &&
6277             (force_update ||
6278              !strequal(printer->drivername, old_printer->drivername))) {
6279                 ok = push_reg_sz(tmp_ctx, &buffer, printer->drivername);
6280                 if (!ok) {
6281                         DEBUG(0, ("%s data corrupted\n", SPOOL_REG_DRIVERNAME));
6282                         result = WERR_INVALID_DATA;
6283                         goto done;
6284                 }
6285                 result = winreg_set_printer_dataex(tmp_ctx, b,
6286                                           printer->sharename,
6287                                           SPOOL_DSSPOOLER_KEY,
6288                                           SPOOL_REG_DRIVERNAME,
6289                                           REG_SZ,
6290                                           buffer.data,
6291                                           buffer.length);
6292                 if (!W_ERROR_IS_OK(result)) {
6293                         DEBUG(0, ("Failed to set %s\n", SPOOL_REG_DRIVERNAME));
6294                         goto done;
6295                 }
6296
6297                 if (!force_update) {
6298                         DEBUG(10,("update_printer: changing driver [%s]!  Sending event!\n",
6299                                 printer->drivername));
6300
6301                         notify_printer_driver(server_event_context(), msg_ctx,
6302                                               snum, printer->drivername ?
6303                                               printer->drivername : "");
6304                 }
6305         }
6306
6307         if (printer->comment != NULL &&
6308             (force_update ||
6309              !strequal(printer->comment, old_printer->comment))) {
6310                 ok = push_reg_sz(tmp_ctx, &buffer, printer->comment);
6311                 if (!ok) {
6312                         DEBUG(0, ("comment data corrupted\n"));
6313                         result = WERR_INVALID_DATA;
6314                         goto done;
6315                 }
6316                 result = winreg_set_printer_dataex(tmp_ctx, b,
6317                                           printer->sharename,
6318                                           SPOOL_DSSPOOLER_KEY,
6319                                           SPOOL_REG_DESCRIPTION,
6320                                           REG_SZ,
6321                                           buffer.data,
6322                                           buffer.length);
6323                 if (!W_ERROR_IS_OK(result)) {
6324                         DEBUG(0, ("Failed to set %s\n", SPOOL_REG_DESCRIPTION));
6325                         goto done;
6326                 }
6327
6328                 if (!force_update) {
6329                         notify_printer_comment(server_event_context(), msg_ctx,
6330                                                snum, printer->comment ?
6331                                                printer->comment : "");
6332                 }
6333         }
6334
6335         if (printer->sharename != NULL &&
6336             (force_update ||
6337              !strequal(printer->sharename, old_printer->sharename))) {
6338                 ok = push_reg_sz(tmp_ctx, &buffer, printer->sharename);
6339                 if (!ok) {
6340                         DEBUG(0, ("sharename data corrupted\n"));
6341                         result = WERR_INVALID_DATA;
6342                         goto done;
6343                 }
6344                 result = winreg_set_printer_dataex(tmp_ctx, b,
6345                                           printer->sharename,
6346                                           SPOOL_DSSPOOLER_KEY,
6347                                           SPOOL_REG_PRINTSHARENAME,
6348                                           REG_SZ,
6349                                           buffer.data,
6350                                           buffer.length);
6351                 if (!W_ERROR_IS_OK(result)) {
6352                         DEBUG(0, ("Failed to set %s\n", SPOOL_REG_PRINTSHARENAME));
6353                         goto done;
6354                 }
6355
6356                 if (!force_update) {
6357                         notify_printer_sharename(server_event_context(),
6358                                                  msg_ctx,
6359                                                  snum, printer->sharename ?
6360                                                  printer->sharename : "");
6361                 }
6362         }
6363
6364         if (printer->printername != NULL &&
6365             (force_update ||
6366              !strequal(printer->printername, old_printer->printername))) {
6367                 const char *p;
6368
6369                 p = strrchr(printer->printername, '\\' );
6370                 if (p != NULL) {
6371                         p++;
6372                 } else {
6373                         p = printer->printername;
6374                 }
6375
6376                 ok = push_reg_sz(tmp_ctx, &buffer, p);
6377                 if (!ok) {
6378                         DEBUG(0, ("printername data corrupted\n"));
6379                         result = WERR_INVALID_DATA;
6380                         goto done;
6381                 }
6382                 result = winreg_set_printer_dataex(tmp_ctx, b,
6383                                           printer->sharename,
6384                                           SPOOL_DSSPOOLER_KEY,
6385                                           SPOOL_REG_PRINTERNAME,
6386                                           REG_SZ,
6387                                           buffer.data,
6388                                           buffer.length);
6389                 if (!W_ERROR_IS_OK(result)) {
6390                         DEBUG(0, ("Failed to set %s\n", SPOOL_REG_PRINTSHARENAME));
6391                         goto done;
6392                 }
6393
6394                 if (!force_update) {
6395                         notify_printer_printername(server_event_context(),
6396                                                    msg_ctx, snum, p ? p : "");
6397                 }
6398         }
6399
6400         if (printer->portname != NULL &&
6401             (force_update ||
6402              !strequal(printer->portname, old_printer->portname))) {
6403                 ok = push_reg_sz(tmp_ctx, &buffer, printer->portname);
6404                 if (!ok) {
6405                         DEBUG(0, ("portname data corrupted\n"));
6406                         result = WERR_INVALID_DATA;
6407                         goto done;
6408                 }
6409                 result = winreg_set_printer_dataex(tmp_ctx, b,
6410                                           printer->sharename,
6411                                           SPOOL_DSSPOOLER_KEY,
6412                                           SPOOL_REG_PORTNAME,
6413                                           REG_SZ,
6414                                           buffer.data,
6415                                           buffer.length);
6416                 if (!W_ERROR_IS_OK(result)) {
6417                         DEBUG(0, ("Failed to set %s\n", SPOOL_REG_PORTNAME));
6418                         goto done;
6419                 }
6420
6421                 if (!force_update) {
6422                         notify_printer_port(server_event_context(),
6423                                             msg_ctx, snum, printer->portname ?
6424                                             printer->portname : "");
6425                 }
6426         }
6427
6428         if (printer->location != NULL &&
6429             (force_update ||
6430              !strequal(printer->location, old_printer->location))) {
6431                 ok = push_reg_sz(tmp_ctx, &buffer, printer->location);
6432                 if (!ok) {
6433                         DEBUG(0, ("location data corrupted\n"));
6434                         result = WERR_INVALID_DATA;
6435                         goto done;
6436                 }
6437                 result = winreg_set_printer_dataex(tmp_ctx, b,
6438                                           printer->sharename,
6439                                           SPOOL_DSSPOOLER_KEY,
6440                                           SPOOL_REG_LOCATION,
6441                                           REG_SZ,
6442                                           buffer.data,
6443                                           buffer.length);
6444                 if (!W_ERROR_IS_OK(result)) {
6445                         DEBUG(0, ("Failed to set %s\n", SPOOL_REG_LOCATION));
6446                         goto done;
6447                 }
6448
6449                 if (!force_update) {
6450                         notify_printer_location(server_event_context(),
6451                                                 msg_ctx, snum,
6452                                                 printer->location ?
6453                                                 printer->location : "");
6454                 }
6455         }
6456
6457         if (printer->sepfile != NULL &&
6458             (force_update ||
6459              !strequal(printer->sepfile, old_printer->sepfile))) {
6460                 ok = push_reg_sz(tmp_ctx, &buffer, printer->sepfile);
6461                 if (!ok) {
6462                         DEBUG(0, ("sepfile data corrupted\n"));
6463                         result = WERR_INVALID_DATA;
6464                         goto done;
6465                 }
6466                 result = winreg_set_printer_dataex(tmp_ctx, b,
6467                                           printer->sharename,
6468                                           SPOOL_DSSPOOLER_KEY,
6469                                           SPOOL_REG_PRINTSEPARATORFILE,
6470                                           REG_SZ,
6471                                           buffer.data,
6472                                           buffer.length);
6473                 if (!W_ERROR_IS_OK(result)) {
6474                         DEBUG(0, ("Failed to set %s\n", SPOOL_REG_PRINTSEPARATORFILE));
6475                         goto done;
6476                 }
6477
6478                 if (!force_update) {
6479                         notify_printer_sepfile(server_event_context(),
6480                                                msg_ctx, snum,
6481                                                printer->sepfile ?
6482                                                printer->sepfile : "");
6483                 }
6484         }
6485
6486         if (printer->starttime != 0 &&
6487             (force_update ||
6488              printer->starttime != old_printer->starttime)) {
6489                 buffer = data_blob_talloc(tmp_ctx, NULL, 4);
6490                 SIVAL(buffer.data, 0, printer->starttime);
6491                 result = winreg_set_printer_dataex(tmp_ctx, b,
6492                                           printer->sharename,
6493                                           SPOOL_DSSPOOLER_KEY,
6494                                           SPOOL_REG_PRINTSTARTTIME,
6495                                           REG_DWORD,
6496                                           buffer.data,
6497                                           buffer.length);
6498                 if (!W_ERROR_IS_OK(result)) {
6499                         DEBUG(0, ("Failed to set %s\n", SPOOL_REG_PRINTSTARTTIME));
6500                         goto done;
6501                 }
6502         }
6503
6504         if (printer->untiltime != 0 &&
6505             (force_update ||
6506              printer->untiltime != old_printer->untiltime)) {
6507                 buffer = data_blob_talloc(tmp_ctx, NULL, 4);
6508                 SIVAL(buffer.data, 0, printer->untiltime);
6509                 result = winreg_set_printer_dataex(tmp_ctx, b,
6510                                           printer->sharename,
6511                                           SPOOL_DSSPOOLER_KEY,
6512                                           SPOOL_REG_PRINTENDTIME,
6513                                           REG_DWORD,
6514                                           buffer.data,
6515                                           buffer.length);
6516                 if (!W_ERROR_IS_OK(result)) {
6517                         DEBUG(0, ("Failed to set %s\n", SPOOL_REG_PRINTENDTIME));
6518                         goto done;
6519                 }
6520         }
6521
6522         if (force_update || printer->priority != old_printer->priority) {
6523                 buffer = data_blob_talloc(tmp_ctx, NULL, 4);
6524                 SIVAL(buffer.data, 0, printer->priority);
6525                 result = winreg_set_printer_dataex(tmp_ctx, b,
6526                                           printer->sharename,
6527                                           SPOOL_DSSPOOLER_KEY,
6528                                           SPOOL_REG_PRIORITY,
6529                                           REG_DWORD,
6530                                           buffer.data,
6531                                           buffer.length);
6532                 if (!W_ERROR_IS_OK(result)) {
6533                         DEBUG(0, ("Failed to set %s\n", SPOOL_REG_PRINTENDTIME));
6534                         goto done;
6535                 }
6536         }
6537
6538         if (force_update || printer->attributes != old_printer->attributes) {
6539                 buffer = data_blob_talloc(tmp_ctx, NULL, 4);
6540                 SIVAL(buffer.data, 0, (printer->attributes &
6541                                        PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS));
6542                 result = winreg_set_printer_dataex(tmp_ctx, b,
6543                                           printer->sharename,
6544                                           SPOOL_DSSPOOLER_KEY,
6545                                           SPOOL_REG_PRINTKEEPPRINTEDJOBS,
6546                                           REG_DWORD,
6547                                           buffer.data,
6548                                           buffer.length);
6549                 if (!W_ERROR_IS_OK(result)) {
6550                         DEBUG(0, ("Failed to set %s\n", SPOOL_REG_PRINTENDTIME));
6551                         goto done;
6552                 }
6553
6554                 switch (printer->attributes & 0x3) {
6555                         case 0:
6556                                 spooling = SPOOL_REGVAL_PRINTWHILESPOOLING;
6557                                 break;
6558                         case 1:
6559                                 spooling = SPOOL_REGVAL_PRINTAFTERSPOOLED;
6560                                 break;
6561                         case 2:
6562                                 spooling = SPOOL_REGVAL_PRINTDIRECT;
6563                                 break;
6564                         default:
6565                                 spooling = "unknown";
6566                 }
6567                 ok = push_reg_sz(tmp_ctx, &buffer, spooling);
6568                 if (!ok) {
6569                         DEBUG(0, ("printSpooling data corrupted\n"));
6570                         result = WERR_INVALID_DATA;
6571                         goto done;
6572                 }
6573                 winreg_set_printer_dataex(tmp_ctx, b,
6574                                           printer->sharename,
6575                                           SPOOL_DSSPOOLER_KEY,
6576                                           SPOOL_REG_PRINTSPOOLING,
6577                                           REG_SZ,
6578                                           buffer.data,
6579                                           buffer.length);
6580         }
6581
6582         ok = push_reg_sz(tmp_ctx, &buffer, lp_netbios_name());
6583         if (!ok) {
6584                 DEBUG(0, ("shortServerName data corrupted\n"));
6585                 result = WERR_INVALID_DATA;
6586                 goto done;
6587         }
6588         result = winreg_set_printer_dataex(tmp_ctx, b,
6589                                   printer->sharename,
6590                                   SPOOL_DSSPOOLER_KEY,
6591                                   SPOOL_REG_SHORTSERVERNAME,
6592                                   REG_SZ,
6593                                   buffer.data,
6594                                   buffer.length);
6595         if (!W_ERROR_IS_OK(result)) {
6596                 DEBUG(0, ("Failed to set %s\n", SPOOL_REG_SHORTSERVERNAME));
6597                 goto done;
6598         }
6599
6600         dnsdomname = get_mydnsfullname();
6601         if (dnsdomname != NULL && dnsdomname[0] != '\0') {
6602                 longname = talloc_strdup(tmp_ctx, dnsdomname);
6603         } else {
6604                 longname = talloc_strdup(tmp_ctx, lp_netbios_name());
6605         }
6606         if (longname == NULL) {
6607                 result = WERR_NOMEM;
6608                 goto done;
6609         }
6610
6611         ok = push_reg_sz(tmp_ctx, &buffer, longname);
6612         if (!ok) {
6613                 DEBUG(0, ("longname data corrupted\n"));
6614                 result = WERR_INVALID_DATA;
6615                 goto done;
6616         }
6617         result = winreg_set_printer_dataex(tmp_ctx, b,
6618                                            printer->sharename,
6619                                            SPOOL_DSSPOOLER_KEY,
6620                                            SPOOL_REG_SERVERNAME,
6621                                            REG_SZ,
6622                                            buffer.data,
6623                                            buffer.length);
6624         if (!W_ERROR_IS_OK(result)) {
6625                 DEBUG(0, ("Failed to set %s\n", SPOOL_REG_SERVERNAME));
6626                 goto done;
6627         }
6628
6629         uncname = talloc_asprintf(tmp_ctx, "\\\\%s\\%s",
6630                                   lp_netbios_name(), printer->sharename);
6631         ok = push_reg_sz(tmp_ctx, &buffer, uncname);
6632         if (!ok) {
6633                 DEBUG(0, ("uncName data corrupted\n"));
6634                 result = WERR_INVALID_DATA;
6635                 goto done;
6636         }
6637         result = winreg_set_printer_dataex(tmp_ctx, b,
6638                                   printer->sharename,
6639                                   SPOOL_DSSPOOLER_KEY,
6640                                   SPOOL_REG_UNCNAME,
6641                                   REG_SZ,
6642                                   buffer.data,
6643                                   buffer.length);
6644         if (!W_ERROR_IS_OK(result)) {
6645                 DEBUG(0, ("Failed to set %s\n", SPOOL_REG_UNCNAME));
6646                 goto done;
6647         }
6648
6649 done:
6650         talloc_free(tmp_ctx);
6651         return result;
6652 }
6653
6654 /********************************************************************
6655  * Called by spoolss_api_setprinter
6656  * when updating a printer description.
6657  ********************************************************************/
6658
6659 static WERROR update_printer(struct pipes_struct *p,
6660                              struct policy_handle *handle,
6661                              struct spoolss_SetPrinterInfoCtr *info_ctr,
6662                              struct spoolss_DeviceMode *devmode)
6663 {
6664         uint32_t printer_mask = SPOOLSS_PRINTER_INFO_ALL;
6665         struct spoolss_SetPrinterInfo2 *printer = info_ctr->info.info2;
6666         struct spoolss_PrinterInfo2 *old_printer;
6667         struct printer_handle *Printer = find_printer_index_by_hnd(p, handle);
6668         int snum;
6669         WERROR result = WERR_OK;
6670         TALLOC_CTX *tmp_ctx;
6671         struct dcerpc_binding_handle *b;
6672
6673         DEBUG(8,("update_printer\n"));
6674
6675         tmp_ctx = talloc_new(p->mem_ctx);
6676         if (tmp_ctx == NULL) {
6677                 return WERR_NOMEM;
6678         }
6679
6680         if (!Printer) {
6681                 result = WERR_BADFID;
6682                 goto done;
6683         }
6684
6685         if (!get_printer_snum(p, handle, &snum, NULL)) {
6686                 result = WERR_BADFID;
6687                 goto done;
6688         }
6689
6690         result = winreg_printer_binding_handle(tmp_ctx,
6691                                                get_session_info_system(),
6692                                                p->msg_ctx,
6693                                                &b);
6694         if (!W_ERROR_IS_OK(result)) {
6695                 goto done;
6696         }
6697
6698         result = winreg_get_printer(tmp_ctx, b,
6699                                     lp_const_servicename(snum),
6700                                     &old_printer);
6701         if (!W_ERROR_IS_OK(result)) {
6702                 result = WERR_BADFID;
6703                 goto done;
6704         }
6705
6706         /* Do sanity check on the requested changes for Samba */
6707         if (!check_printer_ok(tmp_ctx, printer, snum)) {
6708                 result = WERR_INVALID_PARAM;
6709                 goto done;
6710         }
6711
6712         /* FIXME!!! If the driver has changed we really should verify that
6713            it is installed before doing much else   --jerry */
6714
6715         /* Check calling user has permission to update printer description */
6716         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
6717                 DEBUG(3, ("update_printer: printer property change denied by handle\n"));
6718                 result = WERR_ACCESS_DENIED;
6719                 goto done;
6720         }
6721
6722         /* Call addprinter hook */
6723         /* Check changes to see if this is really needed */
6724
6725         if (*lp_addprinter_cmd(talloc_tos()) &&
6726                         (!strequal(printer->drivername, old_printer->drivername) ||
6727                          !strequal(printer->comment, old_printer->comment) ||
6728                          !strequal(printer->portname, old_printer->portname) ||
6729                          !strequal(printer->location, old_printer->location)) )
6730         {
6731                 char *raddr;
6732
6733                 raddr = tsocket_address_inet_addr_string(p->remote_address,
6734                                                          p->mem_ctx);
6735                 if (raddr == NULL) {
6736                         return WERR_NOMEM;
6737                 }
6738
6739                 /* add_printer_hook() will call reload_services() */
6740                 if (!add_printer_hook(tmp_ctx, p->session_info->security_token,
6741                                       printer, raddr,
6742                                       p->msg_ctx)) {
6743                         result = WERR_ACCESS_DENIED;
6744                         goto done;
6745                 }
6746         }
6747
6748         result = update_dsspooler(tmp_ctx,
6749                                   get_session_info_system(),
6750                                   p->msg_ctx,
6751                                   snum,
6752                                   printer,
6753                                   old_printer);
6754         if (!W_ERROR_IS_OK(result)) {
6755                 goto done;
6756         }
6757
6758         printer_mask &= ~SPOOLSS_PRINTER_INFO_SECDESC;
6759
6760         if (devmode == NULL) {
6761                 printer_mask &= ~SPOOLSS_PRINTER_INFO_DEVMODE;
6762         }
6763         result = winreg_update_printer(tmp_ctx, b,
6764                                        printer->sharename,
6765                                        printer_mask,
6766                                        printer,
6767                                        devmode,
6768                                        NULL);
6769
6770 done:
6771         talloc_free(tmp_ctx);
6772
6773         return result;
6774 }
6775
6776 /****************************************************************************
6777 ****************************************************************************/
6778 static WERROR publish_or_unpublish_printer(struct pipes_struct *p,
6779                                            struct policy_handle *handle,
6780                                            struct spoolss_SetPrinterInfo7 *info7)
6781 {
6782 #ifdef HAVE_ADS
6783         struct spoolss_PrinterInfo2 *pinfo2 = NULL;
6784         WERROR result;
6785         int snum;
6786         struct printer_handle *Printer;
6787
6788         if ( lp_security() != SEC_ADS ) {
6789                 return WERR_UNKNOWN_LEVEL;
6790         }
6791
6792         Printer = find_printer_index_by_hnd(p, handle);
6793
6794         DEBUG(5,("publish_or_unpublish_printer, action = %d\n",info7->action));
6795
6796         if (!Printer)
6797                 return WERR_BADFID;
6798
6799         if (!get_printer_snum(p, handle, &snum, NULL))
6800                 return WERR_BADFID;
6801
6802         result = winreg_get_printer_internal(p->mem_ctx,
6803                                     get_session_info_system(),
6804                                     p->msg_ctx,
6805                                     lp_servicename(talloc_tos(), snum),
6806                                     &pinfo2);
6807         if (!W_ERROR_IS_OK(result)) {
6808                 return WERR_BADFID;
6809         }
6810
6811         nt_printer_publish(pinfo2,
6812                            get_session_info_system(),
6813                            p->msg_ctx,
6814                            pinfo2,
6815                            info7->action);
6816
6817         TALLOC_FREE(pinfo2);
6818         return WERR_OK;
6819 #else
6820         return WERR_UNKNOWN_LEVEL;
6821 #endif
6822 }
6823
6824 /********************************************************************
6825  ********************************************************************/
6826
6827 static WERROR update_printer_devmode(struct pipes_struct *p,
6828                                      struct policy_handle *handle,
6829                                      struct spoolss_DeviceMode *devmode)
6830 {
6831         int snum;
6832         struct printer_handle *Printer = find_printer_index_by_hnd(p, handle);
6833         uint32_t info2_mask = SPOOLSS_PRINTER_INFO_DEVMODE;
6834
6835         DEBUG(8,("update_printer_devmode\n"));
6836
6837         if (!Printer) {
6838                 return WERR_BADFID;
6839         }
6840
6841         if (!get_printer_snum(p, handle, &snum, NULL)) {
6842                 return WERR_BADFID;
6843         }
6844
6845         /* Check calling user has permission to update printer description */
6846         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
6847                 DEBUG(3, ("update_printer: printer property change denied by handle\n"));
6848                 return WERR_ACCESS_DENIED;
6849         }
6850
6851         return winreg_update_printer_internal(p->mem_ctx,
6852                                      get_session_info_system(),
6853                                      p->msg_ctx,
6854                                      lp_const_servicename(snum),
6855                                      info2_mask,
6856                                      NULL,
6857                                      devmode,
6858                                      NULL);
6859 }
6860
6861
6862 /****************************************************************
6863  _spoolss_SetPrinter
6864 ****************************************************************/
6865
6866 WERROR _spoolss_SetPrinter(struct pipes_struct *p,
6867                            struct spoolss_SetPrinter *r)
6868 {
6869         WERROR result;
6870
6871         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
6872
6873         if (!Printer) {
6874                 DEBUG(2,("_spoolss_SetPrinter: Invalid handle (%s:%u:%u)\n",
6875                         OUR_HANDLE(r->in.handle)));
6876                 return WERR_BADFID;
6877         }
6878
6879         /* check the level */
6880         switch (r->in.info_ctr->level) {
6881                 case 0:
6882                         return control_printer(r->in.handle, r->in.command, p);
6883                 case 2:
6884                         result = update_printer(p, r->in.handle,
6885                                                 r->in.info_ctr,
6886                                                 r->in.devmode_ctr->devmode);
6887                         if (!W_ERROR_IS_OK(result))
6888                                 return result;
6889                         if (r->in.secdesc_ctr->sd)
6890                                 result = update_printer_sec(r->in.handle, p,
6891                                                             r->in.secdesc_ctr);
6892                         return result;
6893                 case 3:
6894                         return update_printer_sec(r->in.handle, p,
6895                                                   r->in.secdesc_ctr);
6896                 case 7:
6897                         return publish_or_unpublish_printer(p, r->in.handle,
6898                                                             r->in.info_ctr->info.info7);
6899                 case 8:
6900                         return update_printer_devmode(p, r->in.handle,
6901                                                       r->in.devmode_ctr->devmode);
6902                 default:
6903                         return WERR_UNKNOWN_LEVEL;
6904         }
6905 }
6906
6907 /****************************************************************
6908  _spoolss_FindClosePrinterNotify
6909 ****************************************************************/
6910
6911 WERROR _spoolss_FindClosePrinterNotify(struct pipes_struct *p,
6912                                        struct spoolss_FindClosePrinterNotify *r)
6913 {
6914         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
6915
6916         if (!Printer) {
6917                 DEBUG(2,("_spoolss_FindClosePrinterNotify: "
6918                         "Invalid handle (%s:%u:%u)\n", OUR_HANDLE(r->in.handle)));
6919                 return WERR_BADFID;
6920         }
6921
6922         if (Printer->notify.cli_chan != NULL &&
6923             Printer->notify.cli_chan->active_connections > 0) {
6924                 int snum = -1;
6925
6926                 if (Printer->printer_type == SPLHND_PRINTER) {
6927                         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
6928                                 return WERR_BADFID;
6929                         }
6930                 }
6931
6932                 srv_spoolss_replycloseprinter(snum, Printer);
6933         }
6934
6935         Printer->notify.flags=0;
6936         Printer->notify.options=0;
6937         Printer->notify.localmachine[0]='\0';
6938         Printer->notify.printerlocal=0;
6939         TALLOC_FREE(Printer->notify.option);
6940
6941         return WERR_OK;
6942 }
6943
6944 /****************************************************************
6945  _spoolss_AddJob
6946 ****************************************************************/
6947
6948 WERROR _spoolss_AddJob(struct pipes_struct *p,
6949                        struct spoolss_AddJob *r)
6950 {
6951         if (!r->in.buffer && (r->in.offered != 0)) {
6952                 return WERR_INVALID_PARAM;
6953         }
6954
6955         /* this is what a NT server returns for AddJob. AddJob must fail on
6956          * non-local printers */
6957
6958         if (r->in.level != 1) {
6959                 return WERR_UNKNOWN_LEVEL;
6960         }
6961
6962         return WERR_INVALID_PARAM;
6963 }
6964
6965 /****************************************************************************
6966 fill_job_info1
6967 ****************************************************************************/
6968
6969 static WERROR fill_job_info1(TALLOC_CTX *mem_ctx,
6970                              struct spoolss_JobInfo1 *r,
6971                              const print_queue_struct *queue,
6972                              int position, int snum,
6973                              struct spoolss_PrinterInfo2 *pinfo2)
6974 {
6975         struct tm *t;
6976
6977         t = gmtime(&queue->time);
6978
6979         r->job_id               = queue->sysjob;
6980
6981         r->printer_name         = lp_servicename(mem_ctx, snum);
6982         W_ERROR_HAVE_NO_MEMORY(r->printer_name);
6983         r->server_name          = talloc_strdup(mem_ctx, pinfo2->servername);
6984         W_ERROR_HAVE_NO_MEMORY(r->server_name);
6985         r->user_name            = talloc_strdup(mem_ctx, queue->fs_user);
6986         W_ERROR_HAVE_NO_MEMORY(r->user_name);
6987         r->document_name        = talloc_strdup(mem_ctx, queue->fs_file);
6988         W_ERROR_HAVE_NO_MEMORY(r->document_name);
6989         r->data_type            = talloc_strdup(mem_ctx, "RAW");
6990         W_ERROR_HAVE_NO_MEMORY(r->data_type);
6991         r->text_status          = talloc_strdup(mem_ctx, "");
6992         W_ERROR_HAVE_NO_MEMORY(r->text_status);
6993
6994         r->status               = nt_printj_status(queue->status);
6995         r->priority             = queue->priority;
6996         r->position             = position;
6997         r->total_pages          = queue->page_count;
6998         r->pages_printed        = 0; /* ??? */
6999
7000         init_systemtime(&r->submitted, t);
7001
7002         return WERR_OK;
7003 }
7004
7005 /****************************************************************************
7006 fill_job_info2
7007 ****************************************************************************/
7008
7009 static WERROR fill_job_info2(TALLOC_CTX *mem_ctx,
7010                              struct spoolss_JobInfo2 *r,
7011                              const print_queue_struct *queue,
7012                              int position, int snum,
7013                              struct spoolss_PrinterInfo2 *pinfo2,
7014                              struct spoolss_DeviceMode *devmode)
7015 {
7016         struct tm *t;
7017
7018         t = gmtime(&queue->time);
7019
7020         r->job_id               = queue->sysjob;
7021
7022         r->printer_name         = lp_servicename(mem_ctx, snum);
7023         W_ERROR_HAVE_NO_MEMORY(r->printer_name);
7024         r->server_name          = talloc_strdup(mem_ctx, pinfo2->servername);
7025         W_ERROR_HAVE_NO_MEMORY(r->server_name);
7026         r->user_name            = talloc_strdup(mem_ctx, queue->fs_user);
7027         W_ERROR_HAVE_NO_MEMORY(r->user_name);
7028         r->document_name        = talloc_strdup(mem_ctx, queue->fs_file);
7029         W_ERROR_HAVE_NO_MEMORY(r->document_name);
7030         r->notify_name          = talloc_strdup(mem_ctx, queue->fs_user);
7031         W_ERROR_HAVE_NO_MEMORY(r->notify_name);
7032         r->data_type            = talloc_strdup(mem_ctx, "RAW");
7033         W_ERROR_HAVE_NO_MEMORY(r->data_type);
7034         r->print_processor      = talloc_strdup(mem_ctx, "winprint");
7035         W_ERROR_HAVE_NO_MEMORY(r->print_processor);
7036         r->parameters           = talloc_strdup(mem_ctx, "");
7037         W_ERROR_HAVE_NO_MEMORY(r->parameters);
7038         r->driver_name          = talloc_strdup(mem_ctx, pinfo2->drivername);
7039         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
7040
7041         r->devmode              = devmode;
7042
7043         r->text_status          = talloc_strdup(mem_ctx, "");
7044         W_ERROR_HAVE_NO_MEMORY(r->text_status);
7045
7046         r->secdesc              = NULL;
7047
7048         r->status               = nt_printj_status(queue->status);
7049         r->priority             = queue->priority;
7050         r->position             = position;
7051         r->start_time           = 0;
7052         r->until_time           = 0;
7053         r->total_pages          = queue->page_count;
7054         r->size                 = queue->size;
7055         init_systemtime(&r->submitted, t);
7056         r->time                 = 0;
7057         r->pages_printed        = 0; /* ??? */
7058
7059         return WERR_OK;
7060 }
7061
7062 /****************************************************************************
7063 fill_job_info3
7064 ****************************************************************************/
7065
7066 static WERROR fill_job_info3(TALLOC_CTX *mem_ctx,
7067                              struct spoolss_JobInfo3 *r,
7068                              const print_queue_struct *queue,
7069                              const print_queue_struct *next_queue,
7070                              int position, int snum,
7071                              struct spoolss_PrinterInfo2 *pinfo2)
7072 {
7073         r->job_id               = queue->sysjob;
7074         r->next_job_id          = 0;
7075         if (next_queue) {
7076                 r->next_job_id  = next_queue->sysjob;
7077         }
7078         r->reserved             = 0;
7079
7080         return WERR_OK;
7081 }
7082
7083 /****************************************************************************
7084  Enumjobs at level 1.
7085 ****************************************************************************/
7086
7087 static WERROR enumjobs_level1(TALLOC_CTX *mem_ctx,
7088                               const print_queue_struct *queue,
7089                               uint32_t num_queues, int snum,
7090                               struct spoolss_PrinterInfo2 *pinfo2,
7091                               union spoolss_JobInfo **info_p,
7092                               uint32_t *count)
7093 {
7094         union spoolss_JobInfo *info;
7095         int i;
7096         WERROR result = WERR_OK;
7097
7098         info = talloc_array(mem_ctx, union spoolss_JobInfo, num_queues);
7099         W_ERROR_HAVE_NO_MEMORY(info);
7100
7101         *count = num_queues;
7102
7103         for (i=0; i<*count; i++) {
7104                 result = fill_job_info1(info,
7105                                         &info[i].info1,
7106                                         &queue[i],
7107                                         i,
7108                                         snum,
7109                                         pinfo2);
7110                 if (!W_ERROR_IS_OK(result)) {
7111                         goto out;
7112                 }
7113         }
7114
7115  out:
7116         if (!W_ERROR_IS_OK(result)) {
7117                 TALLOC_FREE(info);
7118                 *count = 0;
7119                 return result;
7120         }
7121
7122         *info_p = info;
7123
7124         return WERR_OK;
7125 }
7126
7127 /****************************************************************************
7128  Enumjobs at level 2.
7129 ****************************************************************************/
7130
7131 static WERROR enumjobs_level2(TALLOC_CTX *mem_ctx,
7132                               const print_queue_struct *queue,
7133                               uint32_t num_queues, int snum,
7134                               struct spoolss_PrinterInfo2 *pinfo2,
7135                               union spoolss_JobInfo **info_p,
7136                               uint32_t *count)
7137 {
7138         union spoolss_JobInfo *info;
7139         int i;
7140         WERROR result = WERR_OK;
7141
7142         info = talloc_array(mem_ctx, union spoolss_JobInfo, num_queues);
7143         W_ERROR_HAVE_NO_MEMORY(info);
7144
7145         *count = num_queues;
7146
7147         for (i=0; i<*count; i++) {
7148                 struct spoolss_DeviceMode *devmode;
7149
7150                 result = spoolss_create_default_devmode(info,
7151                                                         pinfo2->printername,
7152                                                         &devmode);
7153                 if (!W_ERROR_IS_OK(result)) {
7154                         DEBUG(3, ("Can't proceed w/o a devmode!"));
7155                         goto out;
7156                 }
7157
7158                 result = fill_job_info2(info,
7159                                         &info[i].info2,
7160                                         &queue[i],
7161                                         i,
7162                                         snum,
7163                                         pinfo2,
7164                                         devmode);
7165                 if (!W_ERROR_IS_OK(result)) {
7166                         goto out;
7167                 }
7168         }
7169
7170  out:
7171         if (!W_ERROR_IS_OK(result)) {
7172                 TALLOC_FREE(info);
7173                 *count = 0;
7174                 return result;
7175         }
7176
7177         *info_p = info;
7178
7179         return WERR_OK;
7180 }
7181
7182 /****************************************************************************
7183  Enumjobs at level 3.
7184 ****************************************************************************/
7185
7186 static WERROR enumjobs_level3(TALLOC_CTX *mem_ctx,
7187                               const print_queue_struct *queue,
7188                               uint32_t num_queues, int snum,
7189                               struct spoolss_PrinterInfo2 *pinfo2,
7190                               union spoolss_JobInfo **info_p,
7191                               uint32_t *count)
7192 {
7193         union spoolss_JobInfo *info;
7194         int i;
7195         WERROR result = WERR_OK;
7196
7197         info = talloc_array(mem_ctx, union spoolss_JobInfo, num_queues);
7198         W_ERROR_HAVE_NO_MEMORY(info);
7199
7200         *count = num_queues;
7201
7202         for (i=0; i<*count; i++) {
7203                 const print_queue_struct *next_queue = NULL;
7204
7205                 if (i+1 < *count) {
7206                         next_queue = &queue[i+1];
7207                 }
7208
7209                 result = fill_job_info3(info,
7210                                         &info[i].info3,
7211                                         &queue[i],
7212                                         next_queue,
7213                                         i,
7214                                         snum,
7215                                         pinfo2);
7216                 if (!W_ERROR_IS_OK(result)) {
7217                         goto out;
7218                 }
7219         }
7220
7221  out:
7222         if (!W_ERROR_IS_OK(result)) {
7223                 TALLOC_FREE(info);
7224                 *count = 0;
7225                 return result;
7226         }
7227
7228         *info_p = info;
7229
7230         return WERR_OK;
7231 }
7232
7233 /****************************************************************
7234  _spoolss_EnumJobs
7235 ****************************************************************/
7236
7237 WERROR _spoolss_EnumJobs(struct pipes_struct *p,
7238                          struct spoolss_EnumJobs *r)
7239 {
7240         WERROR result;
7241         struct spoolss_PrinterInfo2 *pinfo2 = NULL;
7242         int snum;
7243         print_status_struct prt_status;
7244         print_queue_struct *queue = NULL;
7245         uint32_t count;
7246
7247         /* that's an [in out] buffer */
7248
7249         if (!r->in.buffer && (r->in.offered != 0)) {
7250                 return WERR_INVALID_PARAM;
7251         }
7252
7253         DEBUG(4,("_spoolss_EnumJobs\n"));
7254
7255         *r->out.needed = 0;
7256         *r->out.count = 0;
7257         *r->out.info = NULL;
7258
7259         /* lookup the printer snum and tdb entry */
7260
7261         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
7262                 return WERR_BADFID;
7263         }
7264
7265         result = winreg_get_printer_internal(p->mem_ctx,
7266                                     get_session_info_system(),
7267                                     p->msg_ctx,
7268                                     lp_const_servicename(snum),
7269                                     &pinfo2);
7270         if (!W_ERROR_IS_OK(result)) {
7271                 return result;
7272         }
7273
7274         count = print_queue_status(p->msg_ctx, snum, &queue, &prt_status);
7275         DEBUGADD(4,("count:[%d], status:[%d], [%s]\n",
7276                 count, prt_status.status, prt_status.message));
7277
7278         if (count == 0) {
7279                 SAFE_FREE(queue);
7280                 TALLOC_FREE(pinfo2);
7281                 return WERR_OK;
7282         }
7283
7284         switch (r->in.level) {
7285         case 1:
7286                 result = enumjobs_level1(p->mem_ctx, queue, count, snum,
7287                                          pinfo2, r->out.info, r->out.count);
7288                 break;
7289         case 2:
7290                 result = enumjobs_level2(p->mem_ctx, queue, count, snum,
7291                                          pinfo2, r->out.info, r->out.count);
7292                 break;
7293         case 3:
7294                 result = enumjobs_level3(p->mem_ctx, queue, count, snum,
7295                                          pinfo2, r->out.info, r->out.count);
7296                 break;
7297         default:
7298                 result = WERR_UNKNOWN_LEVEL;
7299                 break;
7300         }
7301
7302         SAFE_FREE(queue);
7303         TALLOC_FREE(pinfo2);
7304
7305         if (!W_ERROR_IS_OK(result)) {
7306                 return result;
7307         }
7308
7309         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
7310                                                      spoolss_EnumJobs,
7311                                                      *r->out.info, r->in.level,
7312                                                      *r->out.count);
7313         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
7314         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
7315
7316         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7317 }
7318
7319 /****************************************************************
7320  _spoolss_ScheduleJob
7321 ****************************************************************/
7322
7323 WERROR _spoolss_ScheduleJob(struct pipes_struct *p,
7324                             struct spoolss_ScheduleJob *r)
7325 {
7326         return WERR_OK;
7327 }
7328
7329 /****************************************************************
7330 ****************************************************************/
7331
7332 static WERROR spoolss_setjob_1(TALLOC_CTX *mem_ctx,
7333                                struct messaging_context *msg_ctx,
7334                                const char *printer_name,
7335                                uint32_t job_id,
7336                                struct spoolss_SetJobInfo1 *r)
7337 {
7338         char *old_doc_name;
7339
7340         if (!print_job_get_name(mem_ctx, printer_name, job_id, &old_doc_name)) {
7341                 return WERR_BADFID;
7342         }
7343
7344         if (strequal(old_doc_name, r->document_name)) {
7345                 return WERR_OK;
7346         }
7347
7348         if (!print_job_set_name(server_event_context(), msg_ctx,
7349                                 printer_name, job_id, r->document_name)) {
7350                 return WERR_BADFID;
7351         }
7352
7353         return WERR_OK;
7354 }
7355
7356 /****************************************************************
7357  _spoolss_SetJob
7358 ****************************************************************/
7359
7360 WERROR _spoolss_SetJob(struct pipes_struct *p,
7361                        struct spoolss_SetJob *r)
7362 {
7363         const struct auth_session_info *session_info = p->session_info;
7364         int snum;
7365         WERROR errcode = WERR_BADFUNC;
7366
7367         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
7368                 return WERR_BADFID;
7369         }
7370
7371         if (!print_job_exists(lp_const_servicename(snum), r->in.job_id)) {
7372                 return WERR_INVALID_PRINTER_NAME;
7373         }
7374
7375         switch (r->in.command) {
7376         case SPOOLSS_JOB_CONTROL_CANCEL:
7377         case SPOOLSS_JOB_CONTROL_DELETE:
7378                 errcode = print_job_delete(session_info, p->msg_ctx,
7379                                            snum, r->in.job_id);
7380                 if (W_ERROR_EQUAL(errcode, WERR_PRINTER_HAS_JOBS_QUEUED)) {
7381                         errcode = WERR_OK;
7382                 }
7383                 break;
7384         case SPOOLSS_JOB_CONTROL_PAUSE:
7385                 errcode = print_job_pause(session_info, p->msg_ctx,
7386                                           snum, r->in.job_id);
7387                 break;
7388         case SPOOLSS_JOB_CONTROL_RESTART:
7389         case SPOOLSS_JOB_CONTROL_RESUME:
7390                 errcode = print_job_resume(session_info, p->msg_ctx,
7391                                            snum, r->in.job_id);
7392                 break;
7393         case 0:
7394                 errcode = WERR_OK;
7395                 break;
7396         default:
7397                 return WERR_UNKNOWN_LEVEL;
7398         }
7399
7400         if (!W_ERROR_IS_OK(errcode)) {
7401                 return errcode;
7402         }
7403
7404         if (r->in.ctr == NULL) {
7405                 return errcode;
7406         }
7407
7408         switch (r->in.ctr->level) {
7409         case 1:
7410                 errcode = spoolss_setjob_1(p->mem_ctx, p->msg_ctx,
7411                                            lp_const_servicename(snum),
7412                                            r->in.job_id,
7413                                            r->in.ctr->info.info1);
7414                 break;
7415         case 2:
7416         case 3:
7417         case 4:
7418         default:
7419                 return WERR_UNKNOWN_LEVEL;
7420         }
7421
7422         return errcode;
7423 }
7424
7425 /****************************************************************************
7426  Enumerates all printer drivers by level and architecture.
7427 ****************************************************************************/
7428
7429 static WERROR enumprinterdrivers_level_by_architecture(TALLOC_CTX *mem_ctx,
7430                                                        const struct auth_session_info *session_info,
7431                                                        struct messaging_context *msg_ctx,
7432                                                        const char *servername,
7433                                                        const char *architecture,
7434                                                        uint32_t level,
7435                                                        union spoolss_DriverInfo **info_p,
7436                                                        uint32_t *count_p)
7437 {
7438         int i;
7439         uint32_t version;
7440         struct spoolss_DriverInfo8 *driver;
7441         union spoolss_DriverInfo *info = NULL;
7442         uint32_t count = 0;
7443         WERROR result = WERR_OK;
7444         uint32_t num_drivers;
7445         const char **drivers;
7446         struct dcerpc_binding_handle *b;
7447         TALLOC_CTX *tmp_ctx = NULL;
7448
7449         *count_p = 0;
7450         *info_p = NULL;
7451
7452         tmp_ctx = talloc_new(mem_ctx);
7453         if (!tmp_ctx) {
7454                 return WERR_NOMEM;
7455         }
7456
7457         result = winreg_printer_binding_handle(tmp_ctx,
7458                                                session_info,
7459                                                msg_ctx,
7460                                                &b);
7461         if (!W_ERROR_IS_OK(result)) {
7462                 goto out;
7463         }
7464
7465         for (version=0; version<DRIVER_MAX_VERSION; version++) {
7466                 result = winreg_get_driver_list(tmp_ctx, b,
7467                                                 architecture, version,
7468                                                 &num_drivers, &drivers);
7469                 if (!W_ERROR_IS_OK(result)) {
7470                         goto out;
7471                 }
7472                 DEBUG(4, ("we have:[%d] drivers in environment"
7473                           " [%s] and version [%d]\n",
7474                           num_drivers, architecture, version));
7475
7476                 if (num_drivers != 0) {
7477                         info = talloc_realloc(tmp_ctx, info,
7478                                                     union spoolss_DriverInfo,
7479                                                     count + num_drivers);
7480                         if (!info) {
7481                                 DEBUG(0,("enumprinterdrivers_level_by_architecture: "
7482                                         "failed to enlarge driver info buffer!\n"));
7483                                 result = WERR_NOMEM;
7484                                 goto out;
7485                         }
7486                 }
7487
7488                 for (i = 0; i < num_drivers; i++) {
7489                         DEBUG(5, ("\tdriver: [%s]\n", drivers[i]));
7490
7491                         result = winreg_get_driver(tmp_ctx, b,
7492                                                    architecture, drivers[i],
7493                                                    version, &driver);
7494                         if (!W_ERROR_IS_OK(result)) {
7495                                 goto out;
7496                         }
7497
7498                         switch (level) {
7499                         case 1:
7500                                 result = fill_printer_driver_info1(info, &info[count+i].info1,
7501                                                                    driver, servername);
7502                                 break;
7503                         case 2:
7504                                 result = fill_printer_driver_info2(info, &info[count+i].info2,
7505                                                                    driver, servername);
7506                                 break;
7507                         case 3:
7508                                 result = fill_printer_driver_info3(info, &info[count+i].info3,
7509                                                                    driver, servername);
7510                                 break;
7511                         case 4:
7512                                 result = fill_printer_driver_info4(info, &info[count+i].info4,
7513                                                                    driver, servername);
7514                                 break;
7515                         case 5:
7516                                 result = fill_printer_driver_info5(info, &info[count+i].info5,
7517                                                                    driver, servername);
7518                                 break;
7519                         case 6:
7520                                 result = fill_printer_driver_info6(info, &info[count+i].info6,
7521                                                                    driver, servername);
7522                                 break;
7523                         case 8:
7524                                 result = fill_printer_driver_info8(info, &info[count+i].info8,
7525                                                                    driver, servername);
7526                                 break;
7527                         default:
7528                                 result = WERR_UNKNOWN_LEVEL;
7529                                 break;
7530                         }
7531
7532                         TALLOC_FREE(driver);
7533
7534                         if (!W_ERROR_IS_OK(result)) {
7535                                 goto out;
7536                         }
7537                 }
7538
7539                 count += num_drivers;
7540                 TALLOC_FREE(drivers);
7541         }
7542
7543 out:
7544         if (W_ERROR_IS_OK(result)) {
7545                 *info_p = talloc_move(mem_ctx, &info);
7546                 *count_p = count;
7547         }
7548
7549         talloc_free(tmp_ctx);
7550         return result;
7551 }
7552
7553 /****************************************************************************
7554  Enumerates all printer drivers by level.
7555 ****************************************************************************/
7556
7557 static WERROR enumprinterdrivers_level(TALLOC_CTX *mem_ctx,
7558                                        const struct auth_session_info *session_info,
7559                                        struct messaging_context *msg_ctx,
7560                                        const char *servername,
7561                                        const char *architecture,
7562                                        uint32_t level,
7563                                        union spoolss_DriverInfo **info_p,
7564                                        uint32_t *count_p)
7565 {
7566         uint32_t a,i;
7567         WERROR result = WERR_OK;
7568
7569         if (strequal(architecture, SPOOLSS_ARCHITECTURE_ALL)) {
7570
7571                 for (a=0; archi_table[a].long_archi != NULL; a++) {
7572
7573                         union spoolss_DriverInfo *info = NULL;
7574                         uint32_t count = 0;
7575
7576                         result = enumprinterdrivers_level_by_architecture(mem_ctx,
7577                                                                           session_info,
7578                                                                           msg_ctx,
7579                                                                           servername,
7580                                                                           archi_table[a].long_archi,
7581                                                                           level,
7582                                                                           &info,
7583                                                                           &count);
7584                         if (!W_ERROR_IS_OK(result)) {
7585                                 continue;
7586                         }
7587
7588                         for (i=0; i < count; i++) {
7589                                 ADD_TO_ARRAY(mem_ctx, union spoolss_DriverInfo,
7590                                              info[i], info_p, count_p);
7591                         }
7592                 }
7593
7594                 return result;
7595         }
7596
7597         return enumprinterdrivers_level_by_architecture(mem_ctx,
7598                                                         session_info,
7599                                                         msg_ctx,
7600                                                         servername,
7601                                                         architecture,
7602                                                         level,
7603                                                         info_p,
7604                                                         count_p);
7605 }
7606
7607 /****************************************************************
7608  _spoolss_EnumPrinterDrivers
7609 ****************************************************************/
7610
7611 WERROR _spoolss_EnumPrinterDrivers(struct pipes_struct *p,
7612                                    struct spoolss_EnumPrinterDrivers *r)
7613 {
7614         const char *cservername;
7615         WERROR result;
7616
7617         /* that's an [in out] buffer */
7618
7619         if (!r->in.buffer && (r->in.offered != 0)) {
7620                 return WERR_INVALID_PARAM;
7621         }
7622
7623         DEBUG(4,("_spoolss_EnumPrinterDrivers\n"));
7624
7625         *r->out.needed = 0;
7626         *r->out.count = 0;
7627         *r->out.info = NULL;
7628
7629         cservername = canon_servername(r->in.server);
7630
7631         if (!is_myname_or_ipaddr(cservername)) {
7632                 return WERR_UNKNOWN_PRINTER_DRIVER;
7633         }
7634
7635         result = enumprinterdrivers_level(p->mem_ctx,
7636                                           get_session_info_system(),
7637                                           p->msg_ctx,
7638                                           cservername,
7639                                           r->in.environment,
7640                                           r->in.level,
7641                                           r->out.info,
7642                                           r->out.count);
7643         if (!W_ERROR_IS_OK(result)) {
7644                 return result;
7645         }
7646
7647         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
7648                                                      spoolss_EnumPrinterDrivers,
7649                                                      *r->out.info, r->in.level,
7650                                                      *r->out.count);
7651         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
7652         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
7653
7654         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7655 }
7656
7657 /****************************************************************
7658  _spoolss_EnumForms
7659 ****************************************************************/
7660
7661 WERROR _spoolss_EnumForms(struct pipes_struct *p,
7662                           struct spoolss_EnumForms *r)
7663 {
7664         WERROR result;
7665
7666         *r->out.count = 0;
7667         *r->out.needed = 0;
7668         *r->out.info = NULL;
7669
7670         /* that's an [in out] buffer */
7671
7672         if (!r->in.buffer && (r->in.offered != 0) ) {
7673                 return WERR_INVALID_PARAM;
7674         }
7675
7676         DEBUG(4,("_spoolss_EnumForms\n"));
7677         DEBUGADD(5,("Offered buffer size [%d]\n", r->in.offered));
7678         DEBUGADD(5,("Info level [%d]\n",          r->in.level));
7679
7680         switch (r->in.level) {
7681         case 1:
7682                 result = winreg_printer_enumforms1_internal(p->mem_ctx,
7683                                                    get_session_info_system(),
7684                                                    p->msg_ctx,
7685                                                    r->out.count,
7686                                                    r->out.info);
7687                 break;
7688         default:
7689                 result = WERR_UNKNOWN_LEVEL;
7690                 break;
7691         }
7692
7693         if (!W_ERROR_IS_OK(result)) {
7694                 return result;
7695         }
7696
7697         if (*r->out.count == 0) {
7698                 return WERR_NO_MORE_ITEMS;
7699         }
7700
7701         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
7702                                                      spoolss_EnumForms,
7703                                                      *r->out.info, r->in.level,
7704                                                      *r->out.count);
7705         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
7706         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
7707
7708         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7709 }
7710
7711 /****************************************************************
7712  _spoolss_GetForm
7713 ****************************************************************/
7714
7715 WERROR _spoolss_GetForm(struct pipes_struct *p,
7716                         struct spoolss_GetForm *r)
7717 {
7718         WERROR result;
7719
7720         /* that's an [in out] buffer */
7721
7722         if (!r->in.buffer && (r->in.offered != 0)) {
7723                 return WERR_INVALID_PARAM;
7724         }
7725
7726         DEBUG(4,("_spoolss_GetForm\n"));
7727         DEBUGADD(5,("Offered buffer size [%d]\n", r->in.offered));
7728         DEBUGADD(5,("Info level [%d]\n",          r->in.level));
7729
7730         switch (r->in.level) {
7731         case 1:
7732                 result = winreg_printer_getform1_internal(p->mem_ctx,
7733                                                  get_session_info_system(),
7734                                                  p->msg_ctx,
7735                                                  r->in.form_name,
7736                                                  &r->out.info->info1);
7737                 break;
7738         default:
7739                 result = WERR_UNKNOWN_LEVEL;
7740                 break;
7741         }
7742
7743         if (!W_ERROR_IS_OK(result)) {
7744                 TALLOC_FREE(r->out.info);
7745                 return result;
7746         }
7747
7748         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_FormInfo,
7749                                                r->out.info, r->in.level);
7750         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
7751
7752         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7753 }
7754
7755 /****************************************************************************
7756 ****************************************************************************/
7757
7758 static WERROR fill_port_1(TALLOC_CTX *mem_ctx,
7759                           struct spoolss_PortInfo1 *r,
7760                           const char *name)
7761 {
7762         r->port_name = talloc_strdup(mem_ctx, name);
7763         W_ERROR_HAVE_NO_MEMORY(r->port_name);
7764
7765         return WERR_OK;
7766 }
7767
7768 /****************************************************************************
7769  TODO: This probably needs distinguish between TCP/IP and Local ports
7770  somehow.
7771 ****************************************************************************/
7772
7773 static WERROR fill_port_2(TALLOC_CTX *mem_ctx,
7774                           struct spoolss_PortInfo2 *r,
7775                           const char *name)
7776 {
7777         r->port_name = talloc_strdup(mem_ctx, name);
7778         W_ERROR_HAVE_NO_MEMORY(r->port_name);
7779
7780         r->monitor_name = talloc_strdup(mem_ctx, "Local Monitor");
7781         W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
7782
7783         r->description = talloc_strdup(mem_ctx, SPL_LOCAL_PORT);
7784         W_ERROR_HAVE_NO_MEMORY(r->description);
7785
7786         r->port_type = SPOOLSS_PORT_TYPE_WRITE;
7787         r->reserved = 0;
7788
7789         return WERR_OK;
7790 }
7791
7792
7793 /****************************************************************************
7794  wrapper around the enumer ports command
7795 ****************************************************************************/
7796
7797 static WERROR enumports_hook(TALLOC_CTX *ctx, int *count, char ***lines)
7798 {
7799         char *cmd = lp_enumports_cmd(talloc_tos());
7800         char **qlines = NULL;
7801         char *command = NULL;
7802         int numlines;
7803         int ret;
7804         int fd;
7805
7806         *count = 0;
7807         *lines = NULL;
7808
7809         /* if no hook then just fill in the default port */
7810
7811         if ( !*cmd ) {
7812                 if (!(qlines = talloc_array( NULL, char*, 2 ))) {
7813                         return WERR_NOMEM;
7814                 }
7815                 if (!(qlines[0] = talloc_strdup(qlines, SAMBA_PRINTER_PORT_NAME ))) {
7816                         TALLOC_FREE(qlines);
7817                         return WERR_NOMEM;
7818                 }
7819                 qlines[1] = NULL;
7820                 numlines = 1;
7821         }
7822         else {
7823                 /* we have a valid enumport command */
7824
7825                 command = talloc_asprintf(ctx, "%s \"%d\"", cmd, 1);
7826                 if (!command) {
7827                         return WERR_NOMEM;
7828                 }
7829
7830                 DEBUG(10,("Running [%s]\n", command));
7831                 ret = smbrun(command, &fd);
7832                 DEBUG(10,("Returned [%d]\n", ret));
7833                 TALLOC_FREE(command);
7834                 if (ret != 0) {
7835                         if (fd != -1) {
7836                                 close(fd);
7837                         }
7838                         return WERR_ACCESS_DENIED;
7839                 }
7840
7841                 numlines = 0;
7842                 qlines = fd_lines_load(fd, &numlines, 0, NULL);
7843                 DEBUGADD(10,("Lines returned = [%d]\n", numlines));
7844                 close(fd);
7845         }
7846
7847         *count = numlines;
7848         *lines = qlines;
7849
7850         return WERR_OK;
7851 }
7852
7853 /****************************************************************************
7854  enumports level 1.
7855 ****************************************************************************/
7856
7857 static WERROR enumports_level_1(TALLOC_CTX *mem_ctx,
7858                                 union spoolss_PortInfo **info_p,
7859                                 uint32_t *count)
7860 {
7861         union spoolss_PortInfo *info = NULL;
7862         int i=0;
7863         WERROR result = WERR_OK;
7864         char **qlines = NULL;
7865         int numlines = 0;
7866
7867         result = enumports_hook(talloc_tos(), &numlines, &qlines );
7868         if (!W_ERROR_IS_OK(result)) {
7869                 goto out;
7870         }
7871
7872         if (numlines) {
7873                 info = talloc_array(mem_ctx, union spoolss_PortInfo, numlines);
7874                 if (!info) {
7875                         DEBUG(10,("Returning WERR_NOMEM\n"));
7876                         result = WERR_NOMEM;
7877                         goto out;
7878                 }
7879
7880                 for (i=0; i<numlines; i++) {
7881                         DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
7882                         result = fill_port_1(info, &info[i].info1, qlines[i]);
7883                         if (!W_ERROR_IS_OK(result)) {
7884                                 goto out;
7885                         }
7886                 }
7887         }
7888         TALLOC_FREE(qlines);
7889
7890 out:
7891         if (!W_ERROR_IS_OK(result)) {
7892                 TALLOC_FREE(info);
7893                 TALLOC_FREE(qlines);
7894                 *count = 0;
7895                 *info_p = NULL;
7896                 return result;
7897         }
7898
7899         *info_p = info;
7900         *count = numlines;
7901
7902         return WERR_OK;
7903 }
7904
7905 /****************************************************************************
7906  enumports level 2.
7907 ****************************************************************************/
7908
7909 static WERROR enumports_level_2(TALLOC_CTX *mem_ctx,
7910                                 union spoolss_PortInfo **info_p,
7911                                 uint32_t *count)
7912 {
7913         union spoolss_PortInfo *info = NULL;
7914         int i=0;
7915         WERROR result = WERR_OK;
7916         char **qlines = NULL;
7917         int numlines = 0;
7918
7919         result = enumports_hook(talloc_tos(), &numlines, &qlines );
7920         if (!W_ERROR_IS_OK(result)) {
7921                 goto out;
7922         }
7923
7924         if (numlines) {
7925                 info = talloc_array(mem_ctx, union spoolss_PortInfo, numlines);
7926                 if (!info) {
7927                         DEBUG(10,("Returning WERR_NOMEM\n"));
7928                         result = WERR_NOMEM;
7929                         goto out;
7930                 }
7931
7932                 for (i=0; i<numlines; i++) {
7933                         DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
7934                         result = fill_port_2(info, &info[i].info2, qlines[i]);
7935                         if (!W_ERROR_IS_OK(result)) {
7936                                 goto out;
7937                         }
7938                 }
7939         }
7940         TALLOC_FREE(qlines);
7941
7942 out:
7943         if (!W_ERROR_IS_OK(result)) {
7944                 TALLOC_FREE(info);
7945                 TALLOC_FREE(qlines);
7946                 *count = 0;
7947                 *info_p = NULL;
7948                 return result;
7949         }
7950
7951         *info_p = info;
7952         *count = numlines;
7953
7954         return WERR_OK;
7955 }
7956
7957 /****************************************************************
7958  _spoolss_EnumPorts
7959 ****************************************************************/
7960
7961 WERROR _spoolss_EnumPorts(struct pipes_struct *p,
7962                           struct spoolss_EnumPorts *r)
7963 {
7964         WERROR result;
7965
7966         /* that's an [in out] buffer */
7967
7968         if (!r->in.buffer && (r->in.offered != 0)) {
7969                 return WERR_INVALID_PARAM;
7970         }
7971
7972         DEBUG(4,("_spoolss_EnumPorts\n"));
7973
7974         *r->out.count = 0;
7975         *r->out.needed = 0;
7976         *r->out.info = NULL;
7977
7978         switch (r->in.level) {
7979         case 1:
7980                 result = enumports_level_1(p->mem_ctx, r->out.info,
7981                                            r->out.count);
7982                 break;
7983         case 2:
7984                 result = enumports_level_2(p->mem_ctx, r->out.info,
7985                                            r->out.count);
7986                 break;
7987         default:
7988                 return WERR_UNKNOWN_LEVEL;
7989         }
7990
7991         if (!W_ERROR_IS_OK(result)) {
7992                 return result;
7993         }
7994
7995         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
7996                                                      spoolss_EnumPorts,
7997                                                      *r->out.info, r->in.level,
7998                                                      *r->out.count);
7999         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8000         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8001
8002         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8003 }
8004
8005 /****************************************************************************
8006 ****************************************************************************/
8007
8008 static WERROR spoolss_addprinterex_level_2(struct pipes_struct *p,
8009                                            const char *server,
8010                                            struct spoolss_SetPrinterInfoCtr *info_ctr,
8011                                            struct spoolss_DeviceMode *devmode,
8012                                            struct security_descriptor *secdesc,
8013                                            struct spoolss_UserLevelCtr *user_ctr,
8014                                            struct policy_handle *handle)
8015 {
8016         struct spoolss_SetPrinterInfo2 *info2 = info_ctr->info.info2;
8017         uint32_t info2_mask = SPOOLSS_PRINTER_INFO_ALL;
8018         int     snum;
8019         WERROR err = WERR_OK;
8020
8021         /* samba does not have a concept of local, non-shared printers yet, so
8022          * make sure we always setup sharename - gd */
8023         if ((info2->sharename == NULL || info2->sharename[0] == '\0') &&
8024             (info2->printername != NULL && info2->printername[0] != '\0')) {
8025                 DEBUG(5, ("spoolss_addprinterex_level_2: "
8026                         "no sharename has been set, setting printername %s as sharename\n",
8027                         info2->printername));
8028                 info2->sharename = info2->printername;
8029         }
8030
8031         /* check to see if the printer already exists */
8032         if ((snum = print_queue_snum(info2->sharename)) != -1) {
8033                 DEBUG(5, ("spoolss_addprinterex_level_2: Attempted to add a printer named [%s] when one already existed!\n",
8034                         info2->sharename));
8035                 return WERR_PRINTER_ALREADY_EXISTS;
8036         }
8037
8038         if (!lp_force_printername(GLOBAL_SECTION_SNUM)) {
8039                 if ((snum = print_queue_snum(info2->printername)) != -1) {
8040                         DEBUG(5, ("spoolss_addprinterex_level_2: Attempted to add a printer named [%s] when one already existed!\n",
8041                                 info2->printername));
8042                         return WERR_PRINTER_ALREADY_EXISTS;
8043                 }
8044         }
8045
8046         /* validate printer info struct */
8047         if (!info2->printername || strlen(info2->printername) == 0) {
8048                 return WERR_INVALID_PRINTER_NAME;
8049         }
8050         if (!info2->portname || strlen(info2->portname) == 0) {
8051                 return WERR_UNKNOWN_PORT;
8052         }
8053         if (!info2->drivername || strlen(info2->drivername) == 0) {
8054                 return WERR_UNKNOWN_PRINTER_DRIVER;
8055         }
8056         if (!info2->printprocessor || strlen(info2->printprocessor) == 0) {
8057                 return WERR_UNKNOWN_PRINTPROCESSOR;
8058         }
8059
8060         /* FIXME!!!  smbd should check to see if the driver is installed before
8061            trying to add a printer like this  --jerry */
8062
8063         if (*lp_addprinter_cmd(talloc_tos()) ) {
8064                 char *raddr;
8065
8066                 raddr = tsocket_address_inet_addr_string(p->remote_address,
8067                                                          p->mem_ctx);
8068                 if (raddr == NULL) {
8069                         return WERR_NOMEM;
8070                 }
8071
8072                 if ( !add_printer_hook(p->mem_ctx, p->session_info->security_token,
8073                                        info2, raddr,
8074                                        p->msg_ctx) ) {
8075                         return WERR_ACCESS_DENIED;
8076                 }
8077         } else {
8078                 DEBUG(0,("spoolss_addprinterex_level_2: add printer for printer %s called and no "
8079                         "smb.conf parameter \"addprinter command\" is defined. This "
8080                         "parameter must exist for this call to succeed\n",
8081                         info2->sharename ));
8082         }
8083
8084         if ((snum = print_queue_snum(info2->sharename)) == -1) {
8085                 return WERR_ACCESS_DENIED;
8086         }
8087
8088         /* you must be a printer admin to add a new printer */
8089         if (!print_access_check(p->session_info,
8090                                 p->msg_ctx,
8091                                 snum,
8092                                 PRINTER_ACCESS_ADMINISTER)) {
8093                 return WERR_ACCESS_DENIED;
8094         }
8095
8096         /*
8097          * Do sanity check on the requested changes for Samba.
8098          */
8099
8100         if (!check_printer_ok(p->mem_ctx, info2, snum)) {
8101                 return WERR_INVALID_PARAM;
8102         }
8103
8104         if (devmode == NULL) {
8105                 info2_mask = ~SPOOLSS_PRINTER_INFO_DEVMODE;
8106         }
8107
8108         err = update_dsspooler(p->mem_ctx,
8109                                get_session_info_system(),
8110                                p->msg_ctx,
8111                                0,
8112                                info2,
8113                                NULL);
8114         if (!W_ERROR_IS_OK(err)) {
8115                 return err;
8116         }
8117
8118         err = winreg_update_printer_internal(p->mem_ctx,
8119                                     get_session_info_system(),
8120                                     p->msg_ctx,
8121                                     info2->sharename,
8122                                     info2_mask,
8123                                     info2,
8124                                     devmode,
8125                                     secdesc);
8126         if (!W_ERROR_IS_OK(err)) {
8127                 return err;
8128         }
8129
8130         err = open_printer_hnd(p, handle, info2->printername, PRINTER_ACCESS_ADMINISTER);
8131         if (!W_ERROR_IS_OK(err)) {
8132                 /* Handle open failed - remove addition. */
8133                 ZERO_STRUCTP(handle);
8134                 return err;
8135         }
8136
8137         return WERR_OK;
8138 }
8139
8140 /****************************************************************
8141  _spoolss_AddPrinterEx
8142 ****************************************************************/
8143
8144 WERROR _spoolss_AddPrinterEx(struct pipes_struct *p,
8145                              struct spoolss_AddPrinterEx *r)
8146 {
8147         switch (r->in.info_ctr->level) {
8148         case 1:
8149                 /* we don't handle yet */
8150                 /* but I know what to do ... */
8151                 return WERR_UNKNOWN_LEVEL;
8152         case 2:
8153                 return spoolss_addprinterex_level_2(p, r->in.server,
8154                                                     r->in.info_ctr,
8155                                                     r->in.devmode_ctr->devmode,
8156                                                     r->in.secdesc_ctr->sd,
8157                                                     r->in.userlevel_ctr,
8158                                                     r->out.handle);
8159         default:
8160                 return WERR_UNKNOWN_LEVEL;
8161         }
8162 }
8163
8164 /****************************************************************
8165  _spoolss_AddPrinter
8166 ****************************************************************/
8167
8168 WERROR _spoolss_AddPrinter(struct pipes_struct *p,
8169                            struct spoolss_AddPrinter *r)
8170 {
8171         struct spoolss_AddPrinterEx a;
8172         struct spoolss_UserLevelCtr userlevel_ctr;
8173
8174         ZERO_STRUCT(userlevel_ctr);
8175
8176         userlevel_ctr.level = 1;
8177
8178         a.in.server             = r->in.server;
8179         a.in.info_ctr           = r->in.info_ctr;
8180         a.in.devmode_ctr        = r->in.devmode_ctr;
8181         a.in.secdesc_ctr        = r->in.secdesc_ctr;
8182         a.in.userlevel_ctr      = &userlevel_ctr;
8183         a.out.handle            = r->out.handle;
8184
8185         return _spoolss_AddPrinterEx(p, &a);
8186 }
8187
8188 /****************************************************************
8189  _spoolss_AddPrinterDriverEx
8190 ****************************************************************/
8191
8192 WERROR _spoolss_AddPrinterDriverEx(struct pipes_struct *p,
8193                                    struct spoolss_AddPrinterDriverEx *r)
8194 {
8195         WERROR err = WERR_OK;
8196         const char *driver_name = NULL;
8197         uint32_t version;
8198         const char *fn;
8199
8200         switch (p->opnum) {
8201                 case NDR_SPOOLSS_ADDPRINTERDRIVER:
8202                         fn = "_spoolss_AddPrinterDriver";
8203                         break;
8204                 case NDR_SPOOLSS_ADDPRINTERDRIVEREX:
8205                         fn = "_spoolss_AddPrinterDriverEx";
8206                         break;
8207                 default:
8208                         return WERR_INVALID_PARAM;
8209         }
8210
8211         /*
8212          * we only support the semantics of AddPrinterDriver()
8213          * i.e. only copy files that are newer than existing ones
8214          */
8215
8216         if (r->in.flags == 0) {
8217                 return WERR_INVALID_PARAM;
8218         }
8219
8220         if (r->in.flags != APD_COPY_NEW_FILES) {
8221                 return WERR_ACCESS_DENIED;
8222         }
8223
8224         /* FIXME */
8225         if (r->in.info_ctr->level != 3 && r->in.info_ctr->level != 6) {
8226                 /* Clever hack from Martin Zielinski <mz@seh.de>
8227                  * to allow downgrade from level 8 (Vista).
8228                  */
8229                 DEBUG(0,("%s: level %d not yet implemented\n", fn,
8230                         r->in.info_ctr->level));
8231                 return WERR_UNKNOWN_LEVEL;
8232         }
8233
8234         DEBUG(5,("Cleaning driver's information\n"));
8235         err = clean_up_driver_struct(p->mem_ctx, p->session_info, r->in.info_ctr);
8236         if (!W_ERROR_IS_OK(err))
8237                 goto done;
8238
8239         DEBUG(5,("Moving driver to final destination\n"));
8240         err = move_driver_to_download_area(p->session_info, r->in.info_ctr);
8241         if (!W_ERROR_IS_OK(err)) {
8242                 goto done;
8243         }
8244
8245         err = winreg_add_driver_internal(p->mem_ctx,
8246                                 get_session_info_system(),
8247                                 p->msg_ctx,
8248                                 r->in.info_ctr,
8249                                 &driver_name,
8250                                 &version);
8251         if (!W_ERROR_IS_OK(err)) {
8252                 goto done;
8253         }
8254
8255         /*
8256          * I think this is where he DrvUpgradePrinter() hook would be
8257          * be called in a driver's interface DLL on a Windows NT 4.0/2k
8258          * server.  Right now, we just need to send ourselves a message
8259          * to update each printer bound to this driver.   --jerry
8260          */
8261
8262         if (!srv_spoolss_drv_upgrade_printer(driver_name, p->msg_ctx)) {
8263                 DEBUG(0,("%s: Failed to send message about upgrading driver [%s]!\n",
8264                         fn, driver_name));
8265         }
8266
8267 done:
8268         return err;
8269 }
8270
8271 /****************************************************************
8272  _spoolss_AddPrinterDriver
8273 ****************************************************************/
8274
8275 WERROR _spoolss_AddPrinterDriver(struct pipes_struct *p,
8276                                  struct spoolss_AddPrinterDriver *r)
8277 {
8278         struct spoolss_AddPrinterDriverEx a;
8279
8280         switch (r->in.info_ctr->level) {
8281         case 2:
8282         case 3:
8283         case 4:
8284         case 5:
8285                 break;
8286         default:
8287                 return WERR_UNKNOWN_LEVEL;
8288         }
8289
8290         a.in.servername         = r->in.servername;
8291         a.in.info_ctr           = r->in.info_ctr;
8292         a.in.flags              = APD_COPY_NEW_FILES;
8293
8294         return _spoolss_AddPrinterDriverEx(p, &a);
8295 }
8296
8297 /****************************************************************************
8298 ****************************************************************************/
8299
8300 struct _spoolss_paths {
8301         int type;
8302         const char *share;
8303         const char *dir;
8304 };
8305
8306 enum { SPOOLSS_DRIVER_PATH, SPOOLSS_PRTPROCS_PATH };
8307
8308 static const struct _spoolss_paths spoolss_paths[]= {
8309         { SPOOLSS_DRIVER_PATH,          "print$",       "DRIVERS" },
8310         { SPOOLSS_PRTPROCS_PATH,        "prnproc$",     "PRTPROCS" }
8311 };
8312
8313 static WERROR compose_spoolss_server_path(TALLOC_CTX *mem_ctx,
8314                                           const char *servername,
8315                                           const char *environment,
8316                                           int component,
8317                                           char **path)
8318 {
8319         const char *pservername = NULL;
8320         const char *long_archi = SPOOLSS_ARCHITECTURE_NT_X86;
8321         const char *short_archi;
8322
8323         *path = NULL;
8324
8325         /* environment may be empty */
8326         if (environment && strlen(environment)) {
8327                 long_archi = environment;
8328         }
8329
8330         /* servername may be empty */
8331         if (servername && strlen(servername)) {
8332                 pservername = canon_servername(servername);
8333
8334                 if (!is_myname_or_ipaddr(pservername)) {
8335                         return WERR_INVALID_PARAM;
8336                 }
8337         }
8338
8339         if (!(short_archi = get_short_archi(long_archi))) {
8340                 return WERR_INVALID_ENVIRONMENT;
8341         }
8342
8343         switch (component) {
8344         case SPOOLSS_PRTPROCS_PATH:
8345         case SPOOLSS_DRIVER_PATH:
8346                 if (pservername) {
8347                         *path = talloc_asprintf(mem_ctx,
8348                                         "\\\\%s\\%s\\%s",
8349                                         pservername,
8350                                         spoolss_paths[component].share,
8351                                         short_archi);
8352                 } else {
8353                         *path = talloc_asprintf(mem_ctx, "%s\\%s\\%s",
8354                                         SPOOLSS_DEFAULT_SERVER_PATH,
8355                                         spoolss_paths[component].dir,
8356                                         short_archi);
8357                 }
8358                 break;
8359         default:
8360                 return WERR_INVALID_PARAM;
8361         }
8362
8363         if (!*path) {
8364                 return WERR_NOMEM;
8365         }
8366
8367         return WERR_OK;
8368 }
8369
8370 /****************************************************************************
8371 ****************************************************************************/
8372
8373 static WERROR getprinterdriverdir_level_1(TALLOC_CTX *mem_ctx,
8374                                           const char *servername,
8375                                           const char *environment,
8376                                           struct spoolss_DriverDirectoryInfo1 *r)
8377 {
8378         WERROR werr;
8379         char *path = NULL;
8380
8381         werr = compose_spoolss_server_path(mem_ctx,
8382                                            servername,
8383                                            environment,
8384                                            SPOOLSS_DRIVER_PATH,
8385                                            &path);
8386         if (!W_ERROR_IS_OK(werr)) {
8387                 return werr;
8388         }
8389
8390         DEBUG(4,("printer driver directory: [%s]\n", path));
8391
8392         r->directory_name = path;
8393
8394         return WERR_OK;
8395 }
8396
8397 /****************************************************************
8398  _spoolss_GetPrinterDriverDirectory
8399 ****************************************************************/
8400
8401 WERROR _spoolss_GetPrinterDriverDirectory(struct pipes_struct *p,
8402                                           struct spoolss_GetPrinterDriverDirectory *r)
8403 {
8404         WERROR werror;
8405
8406         /* that's an [in out] buffer */
8407
8408         if (!r->in.buffer && (r->in.offered != 0)) {
8409                 return WERR_INVALID_PARAM;
8410         }
8411
8412         DEBUG(5,("_spoolss_GetPrinterDriverDirectory: level %d\n",
8413                 r->in.level));
8414
8415         *r->out.needed = 0;
8416
8417         /* r->in.level is ignored */
8418
8419         werror = getprinterdriverdir_level_1(p->mem_ctx,
8420                                              r->in.server,
8421                                              r->in.environment,
8422                                              &r->out.info->info1);
8423         if (!W_ERROR_IS_OK(werror)) {
8424                 TALLOC_FREE(r->out.info);
8425                 return werror;
8426         }
8427
8428         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_DriverDirectoryInfo,
8429                                                r->out.info, r->in.level);
8430         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
8431
8432         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8433 }
8434
8435 /****************************************************************
8436  _spoolss_EnumPrinterData
8437 ****************************************************************/
8438
8439 WERROR _spoolss_EnumPrinterData(struct pipes_struct *p,
8440                                 struct spoolss_EnumPrinterData *r)
8441 {
8442         WERROR result;
8443         struct spoolss_EnumPrinterDataEx r2;
8444         uint32_t count;
8445         struct spoolss_PrinterEnumValues *info, *val = NULL;
8446         uint32_t needed;
8447
8448         r2.in.handle    = r->in.handle;
8449         r2.in.key_name  = "PrinterDriverData";
8450         r2.in.offered   = 0;
8451         r2.out.count    = &count;
8452         r2.out.info     = &info;
8453         r2.out.needed   = &needed;
8454
8455         result = _spoolss_EnumPrinterDataEx(p, &r2);
8456         if (W_ERROR_EQUAL(result, WERR_MORE_DATA)) {
8457                 r2.in.offered = needed;
8458                 result = _spoolss_EnumPrinterDataEx(p, &r2);
8459         }
8460         if (!W_ERROR_IS_OK(result)) {
8461                 return result;
8462         }
8463
8464         /*
8465          * The NT machine wants to know the biggest size of value and data
8466          *
8467          * cf: MSDN EnumPrinterData remark section
8468          */
8469
8470         if (!r->in.value_offered && !r->in.data_offered) {
8471                 uint32_t biggest_valuesize = 0;
8472                 uint32_t biggest_datasize = 0;
8473                 int i, name_length;
8474
8475                 DEBUGADD(6,("Activating NT mega-hack to find sizes\n"));
8476
8477                 for (i=0; i<count; i++) {
8478
8479                         name_length = strlen(info[i].value_name);
8480                         if (strlen(info[i].value_name) > biggest_valuesize) {
8481                                 biggest_valuesize = name_length;
8482                         }
8483
8484                         if (info[i].data_length > biggest_datasize) {
8485                                 biggest_datasize = info[i].data_length;
8486                         }
8487
8488                         DEBUG(6,("current values: [%d], [%d]\n", biggest_valuesize,
8489                                 biggest_datasize));
8490                 }
8491
8492                 /* the value is an UNICODE string but real_value_size is the length
8493                    in bytes including the trailing 0 */
8494
8495                 *r->out.value_needed = 2 * (1 + biggest_valuesize);
8496                 *r->out.data_needed  = biggest_datasize;
8497
8498                 DEBUG(6,("final values: [%d], [%d]\n",
8499                         *r->out.value_needed, *r->out.data_needed));
8500
8501                 return WERR_OK;
8502         }
8503
8504         if (r->in.enum_index < count) {
8505                 val = &info[r->in.enum_index];
8506         }
8507
8508         if (val == NULL) {
8509                 /* out_value should default to "" or else NT4 has
8510                    problems unmarshalling the response */
8511
8512                 if (r->in.value_offered) {
8513                         *r->out.value_needed = 1;
8514                         r->out.value_name = talloc_strdup(r, "");
8515                         if (!r->out.value_name) {
8516                                 return WERR_NOMEM;
8517                         }
8518                 } else {
8519                         r->out.value_name = NULL;
8520                         *r->out.value_needed = 0;
8521                 }
8522
8523                 /* the data is counted in bytes */
8524
8525                 *r->out.data_needed = r->in.data_offered;
8526
8527                 result = WERR_NO_MORE_ITEMS;
8528         } else {
8529                 /*
8530                  * the value is:
8531                  * - counted in bytes in the request
8532                  * - counted in UNICODE chars in the max reply
8533                  * - counted in bytes in the real size
8534                  *
8535                  * take a pause *before* coding not *during* coding
8536                  */
8537
8538                 /* name */
8539                 if (r->in.value_offered) {
8540                         r->out.value_name = talloc_strdup(r, val->value_name);
8541                         if (!r->out.value_name) {
8542                                 return WERR_NOMEM;
8543                         }
8544                         *r->out.value_needed = val->value_name_len;
8545                 } else {
8546                         r->out.value_name = NULL;
8547                         *r->out.value_needed = 0;
8548                 }
8549
8550                 /* type */
8551
8552                 *r->out.type = val->type;
8553
8554                 /* data - counted in bytes */
8555
8556                 /*
8557                  * See the section "Dynamically Typed Query Parameters"
8558                  * in MS-RPRN.
8559                  */
8560
8561                 if (r->out.data && val->data && val->data->data &&
8562                                 val->data_length && r->in.data_offered) {
8563                         memcpy(r->out.data, val->data->data,
8564                                 MIN(val->data_length,r->in.data_offered));
8565                 }
8566
8567                 *r->out.data_needed = val->data_length;
8568
8569                 result = WERR_OK;
8570         }
8571
8572         return result;
8573 }
8574
8575 /****************************************************************
8576  _spoolss_SetPrinterData
8577 ****************************************************************/
8578
8579 WERROR _spoolss_SetPrinterData(struct pipes_struct *p,
8580                                struct spoolss_SetPrinterData *r)
8581 {
8582         struct spoolss_SetPrinterDataEx r2;
8583
8584         r2.in.handle            = r->in.handle;
8585         r2.in.key_name          = "PrinterDriverData";
8586         r2.in.value_name        = r->in.value_name;
8587         r2.in.type              = r->in.type;
8588         r2.in.data              = r->in.data;
8589         r2.in.offered           = r->in.offered;
8590
8591         return _spoolss_SetPrinterDataEx(p, &r2);
8592 }
8593
8594 /****************************************************************
8595  _spoolss_ResetPrinter
8596 ****************************************************************/
8597
8598 WERROR _spoolss_ResetPrinter(struct pipes_struct *p,
8599                              struct spoolss_ResetPrinter *r)
8600 {
8601         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
8602         int             snum;
8603
8604         DEBUG(5,("_spoolss_ResetPrinter\n"));
8605
8606         /*
8607          * All we do is to check to see if the handle and queue is valid.
8608          * This call really doesn't mean anything to us because we only
8609          * support RAW printing.   --jerry
8610          */
8611
8612         if (!Printer) {
8613                 DEBUG(2,("_spoolss_ResetPrinter: Invalid handle (%s:%u:%u).\n",
8614                         OUR_HANDLE(r->in.handle)));
8615                 return WERR_BADFID;
8616         }
8617
8618         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8619                 return WERR_BADFID;
8620
8621
8622         /* blindly return success */
8623         return WERR_OK;
8624 }
8625
8626 /****************************************************************
8627  _spoolss_DeletePrinterData
8628 ****************************************************************/
8629
8630 WERROR _spoolss_DeletePrinterData(struct pipes_struct *p,
8631                                   struct spoolss_DeletePrinterData *r)
8632 {
8633         struct spoolss_DeletePrinterDataEx r2;
8634
8635         r2.in.handle            = r->in.handle;
8636         r2.in.key_name          = "PrinterDriverData";
8637         r2.in.value_name        = r->in.value_name;
8638
8639         return _spoolss_DeletePrinterDataEx(p, &r2);
8640 }
8641
8642 /****************************************************************
8643  _spoolss_AddForm
8644 ****************************************************************/
8645
8646 WERROR _spoolss_AddForm(struct pipes_struct *p,
8647                         struct spoolss_AddForm *r)
8648 {
8649         struct spoolss_AddFormInfo1 *form = r->in.info.info1;
8650         int snum = -1;
8651         WERROR status = WERR_OK;
8652         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
8653         struct dcerpc_binding_handle *b;
8654         TALLOC_CTX *tmp_ctx = NULL;
8655
8656         DEBUG(5,("_spoolss_AddForm\n"));
8657
8658         if (!Printer) {
8659                 DEBUG(2,("_spoolss_AddForm: Invalid handle (%s:%u:%u).\n",
8660                         OUR_HANDLE(r->in.handle)));
8661                 return WERR_BADFID;
8662         }
8663
8664         /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
8665            and not a printer admin, then fail */
8666
8667         if ((p->session_info->unix_token->uid != sec_initial_uid()) &&
8668             !security_token_has_privilege(p->session_info->security_token,
8669                                           SEC_PRIV_PRINT_OPERATOR)) {
8670                 DEBUG(2,("_spoolss_Addform: denied by insufficient permissions.\n"));
8671                 return WERR_ACCESS_DENIED;
8672         }
8673
8674         switch (form->flags) {
8675         case SPOOLSS_FORM_USER:
8676         case SPOOLSS_FORM_BUILTIN:
8677         case SPOOLSS_FORM_PRINTER:
8678                 break;
8679         default:
8680                 return WERR_INVALID_PARAM;
8681         }
8682
8683         tmp_ctx = talloc_new(p->mem_ctx);
8684         if (!tmp_ctx) {
8685                 return WERR_NOMEM;
8686         }
8687
8688         status = winreg_printer_binding_handle(tmp_ctx,
8689                                                get_session_info_system(),
8690                                                p->msg_ctx,
8691                                                &b);
8692         if (!W_ERROR_IS_OK(status)) {
8693                 goto done;
8694         }
8695
8696         status = winreg_printer_addform1(tmp_ctx, b, form);
8697         if (!W_ERROR_IS_OK(status)) {
8698                 goto done;
8699         }
8700
8701         /*
8702          * ChangeID must always be set if this is a printer
8703          */
8704         if (Printer->printer_type == SPLHND_PRINTER) {
8705                 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8706                         status = WERR_BADFID;
8707                         goto done;
8708                 }
8709
8710                 status = winreg_printer_update_changeid(tmp_ctx, b,
8711                                                         lp_const_servicename(snum));
8712         }
8713
8714 done:
8715         talloc_free(tmp_ctx);
8716         return status;
8717 }
8718
8719 /****************************************************************
8720  _spoolss_DeleteForm
8721 ****************************************************************/
8722
8723 WERROR _spoolss_DeleteForm(struct pipes_struct *p,
8724                            struct spoolss_DeleteForm *r)
8725 {
8726         const char *form_name = r->in.form_name;
8727         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
8728         int snum = -1;
8729         WERROR status = WERR_OK;
8730         struct dcerpc_binding_handle *b;
8731         TALLOC_CTX *tmp_ctx = NULL;
8732
8733         DEBUG(5,("_spoolss_DeleteForm\n"));
8734
8735         if (!Printer) {
8736                 DEBUG(2,("_spoolss_DeleteForm: Invalid handle (%s:%u:%u).\n",
8737                         OUR_HANDLE(r->in.handle)));
8738                 return WERR_BADFID;
8739         }
8740
8741         if ((p->session_info->unix_token->uid != sec_initial_uid()) &&
8742             !security_token_has_privilege(p->session_info->security_token,
8743                                           SEC_PRIV_PRINT_OPERATOR)) {
8744                 DEBUG(2,("_spoolss_DeleteForm: denied by insufficient permissions.\n"));
8745                 return WERR_ACCESS_DENIED;
8746         }
8747
8748         tmp_ctx = talloc_new(p->mem_ctx);
8749         if (!tmp_ctx) {
8750                 return WERR_NOMEM;
8751         }
8752
8753         status = winreg_printer_binding_handle(tmp_ctx,
8754                                                get_session_info_system(),
8755                                                p->msg_ctx,
8756                                                &b);
8757         if (!W_ERROR_IS_OK(status)) {
8758                 goto done;
8759         }
8760
8761         status = winreg_printer_deleteform1(tmp_ctx, b, form_name);
8762         if (!W_ERROR_IS_OK(status)) {
8763                 goto done;
8764         }
8765
8766         /*
8767          * ChangeID must always be set if this is a printer
8768          */
8769         if (Printer->printer_type == SPLHND_PRINTER) {
8770                 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8771                         status = WERR_BADFID;
8772                         goto done;
8773                 }
8774
8775                 status = winreg_printer_update_changeid(tmp_ctx, b,
8776                                                         lp_const_servicename(snum));
8777         }
8778
8779 done:
8780         talloc_free(tmp_ctx);
8781         return status;
8782 }
8783
8784 /****************************************************************
8785  _spoolss_SetForm
8786 ****************************************************************/
8787
8788 WERROR _spoolss_SetForm(struct pipes_struct *p,
8789                         struct spoolss_SetForm *r)
8790 {
8791         struct spoolss_AddFormInfo1 *form = r->in.info.info1;
8792         const char *form_name = r->in.form_name;
8793         int snum = -1;
8794         WERROR status = WERR_OK;
8795         struct dcerpc_binding_handle *b;
8796         TALLOC_CTX *tmp_ctx = NULL;
8797
8798         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
8799
8800         DEBUG(5,("_spoolss_SetForm\n"));
8801
8802         if (!Printer) {
8803                 DEBUG(2,("_spoolss_SetForm: Invalid handle (%s:%u:%u).\n",
8804                         OUR_HANDLE(r->in.handle)));
8805                 return WERR_BADFID;
8806         }
8807
8808         /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
8809            and not a printer admin, then fail */
8810
8811         if ((p->session_info->unix_token->uid != sec_initial_uid()) &&
8812              !security_token_has_privilege(p->session_info->security_token,
8813                                            SEC_PRIV_PRINT_OPERATOR)) {
8814                 DEBUG(2,("_spoolss_Setform: denied by insufficient permissions.\n"));
8815                 return WERR_ACCESS_DENIED;
8816         }
8817
8818         tmp_ctx = talloc_new(p->mem_ctx);
8819         if (!tmp_ctx) {
8820                 return WERR_NOMEM;
8821         }
8822
8823         status = winreg_printer_binding_handle(tmp_ctx,
8824                                                get_session_info_system(),
8825                                                p->msg_ctx,
8826                                                &b);
8827         if (!W_ERROR_IS_OK(status)) {
8828                 goto done;
8829         }
8830
8831         status = winreg_printer_setform1(tmp_ctx, b,
8832                                          form_name,
8833                                          form);
8834         if (!W_ERROR_IS_OK(status)) {
8835                 goto done;
8836         }
8837
8838         /*
8839          * ChangeID must always be set if this is a printer
8840          */
8841         if (Printer->printer_type == SPLHND_PRINTER) {
8842                 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8843                         status = WERR_BADFID;
8844                         goto done;
8845                 }
8846
8847                 status = winreg_printer_update_changeid(tmp_ctx, b,
8848                                                         lp_const_servicename(snum));
8849         }
8850
8851 done:
8852         talloc_free(tmp_ctx);
8853         return status;
8854 }
8855
8856 /****************************************************************************
8857  fill_print_processor1
8858 ****************************************************************************/
8859
8860 static WERROR fill_print_processor1(TALLOC_CTX *mem_ctx,
8861                                     struct spoolss_PrintProcessorInfo1 *r,
8862                                     const char *print_processor_name)
8863 {
8864         r->print_processor_name = talloc_strdup(mem_ctx, print_processor_name);
8865         W_ERROR_HAVE_NO_MEMORY(r->print_processor_name);
8866
8867         return WERR_OK;
8868 }
8869
8870 /****************************************************************************
8871  enumprintprocessors level 1.
8872 ****************************************************************************/
8873
8874 static WERROR enumprintprocessors_level_1(TALLOC_CTX *mem_ctx,
8875                                           union spoolss_PrintProcessorInfo **info_p,
8876                                           uint32_t *count)
8877 {
8878         union spoolss_PrintProcessorInfo *info;
8879         WERROR result;
8880
8881         info = talloc_array(mem_ctx, union spoolss_PrintProcessorInfo, 1);
8882         W_ERROR_HAVE_NO_MEMORY(info);
8883
8884         *count = 1;
8885
8886         result = fill_print_processor1(info, &info[0].info1, "winprint");
8887         if (!W_ERROR_IS_OK(result)) {
8888                 goto out;
8889         }
8890
8891  out:
8892         if (!W_ERROR_IS_OK(result)) {
8893                 TALLOC_FREE(info);
8894                 *count = 0;
8895                 return result;
8896         }
8897
8898         *info_p = info;
8899
8900         return WERR_OK;
8901 }
8902
8903 /****************************************************************
8904  _spoolss_EnumPrintProcessors
8905 ****************************************************************/
8906
8907 WERROR _spoolss_EnumPrintProcessors(struct pipes_struct *p,
8908                                     struct spoolss_EnumPrintProcessors *r)
8909 {
8910         WERROR result;
8911
8912         /* that's an [in out] buffer */
8913
8914         if (!r->in.buffer && (r->in.offered != 0)) {
8915                 return WERR_INVALID_PARAM;
8916         }
8917
8918         DEBUG(5,("_spoolss_EnumPrintProcessors\n"));
8919
8920         /*
8921          * Enumerate the print processors ...
8922          *
8923          * Just reply with "winprint", to keep NT happy
8924          * and I can use my nice printer checker.
8925          */
8926
8927         *r->out.count = 0;
8928         *r->out.needed = 0;
8929         *r->out.info = NULL;
8930
8931         if (!get_short_archi(r->in.environment)) {
8932                 return WERR_INVALID_ENVIRONMENT;
8933         }
8934
8935         switch (r->in.level) {
8936         case 1:
8937                 result = enumprintprocessors_level_1(p->mem_ctx, r->out.info,
8938                                                      r->out.count);
8939                 break;
8940         default:
8941                 return WERR_UNKNOWN_LEVEL;
8942         }
8943
8944         if (!W_ERROR_IS_OK(result)) {
8945                 return result;
8946         }
8947
8948         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8949                                                      spoolss_EnumPrintProcessors,
8950                                                      *r->out.info, r->in.level,
8951                                                      *r->out.count);
8952         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8953         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8954
8955         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8956 }
8957
8958 /****************************************************************************
8959  fill_printprocdatatype1
8960 ****************************************************************************/
8961
8962 static WERROR fill_printprocdatatype1(TALLOC_CTX *mem_ctx,
8963                                       struct spoolss_PrintProcDataTypesInfo1 *r,
8964                                       const char *name_array)
8965 {
8966         r->name_array = talloc_strdup(mem_ctx, name_array);
8967         W_ERROR_HAVE_NO_MEMORY(r->name_array);
8968
8969         return WERR_OK;
8970 }
8971
8972 /****************************************************************************
8973  enumprintprocdatatypes level 1.
8974 ****************************************************************************/
8975
8976 static WERROR enumprintprocdatatypes_level_1(TALLOC_CTX *mem_ctx,
8977                                              union spoolss_PrintProcDataTypesInfo **info_p,
8978                                              uint32_t *count)
8979 {
8980         WERROR result;
8981         union spoolss_PrintProcDataTypesInfo *info;
8982
8983         info = talloc_array(mem_ctx, union spoolss_PrintProcDataTypesInfo, 1);
8984         W_ERROR_HAVE_NO_MEMORY(info);
8985
8986         *count = 1;
8987
8988         result = fill_printprocdatatype1(info, &info[0].info1, "RAW");
8989         if (!W_ERROR_IS_OK(result)) {
8990                 goto out;
8991         }
8992
8993  out:
8994         if (!W_ERROR_IS_OK(result)) {
8995                 TALLOC_FREE(info);
8996                 *count = 0;
8997                 return result;
8998         }
8999
9000         *info_p = info;
9001
9002         return WERR_OK;
9003 }
9004
9005 /****************************************************************
9006  _spoolss_EnumPrintProcDataTypes
9007 ****************************************************************/
9008
9009 WERROR _spoolss_EnumPrintProcDataTypes(struct pipes_struct *p,
9010                                        struct spoolss_EnumPrintProcDataTypes *r)
9011 {
9012         WERROR result;
9013
9014         /* that's an [in out] buffer */
9015
9016         if (!r->in.buffer && (r->in.offered != 0)) {
9017                 return WERR_INVALID_PARAM;
9018         }
9019
9020         DEBUG(5,("_spoolss_EnumPrintProcDataTypes\n"));
9021
9022         *r->out.count = 0;
9023         *r->out.needed = 0;
9024         *r->out.info = NULL;
9025
9026         if (r->in.print_processor_name == NULL ||
9027             !strequal(r->in.print_processor_name, "winprint")) {
9028                 return WERR_UNKNOWN_PRINTPROCESSOR;
9029         }
9030
9031         switch (r->in.level) {
9032         case 1:
9033                 result = enumprintprocdatatypes_level_1(p->mem_ctx, r->out.info,
9034                                                         r->out.count);
9035                 break;
9036         default:
9037                 return WERR_UNKNOWN_LEVEL;
9038         }
9039
9040         if (!W_ERROR_IS_OK(result)) {
9041                 return result;
9042         }
9043
9044         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
9045                                                      spoolss_EnumPrintProcDataTypes,
9046                                                      *r->out.info, r->in.level,
9047                                                      *r->out.count);
9048         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
9049         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
9050
9051         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
9052 }
9053
9054 /****************************************************************************
9055  fill_monitor_1
9056 ****************************************************************************/
9057
9058 static WERROR fill_monitor_1(TALLOC_CTX *mem_ctx,
9059                              struct spoolss_MonitorInfo1 *r,
9060                              const char *monitor_name)
9061 {
9062         r->monitor_name                 = talloc_strdup(mem_ctx, monitor_name);
9063         W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
9064
9065         return WERR_OK;
9066 }
9067
9068 /****************************************************************************
9069  fill_monitor_2
9070 ****************************************************************************/
9071
9072 static WERROR fill_monitor_2(TALLOC_CTX *mem_ctx,
9073                              struct spoolss_MonitorInfo2 *r,
9074                              const char *monitor_name,
9075                              const char *environment,
9076                              const char *dll_name)
9077 {
9078         r->monitor_name                 = talloc_strdup(mem_ctx, monitor_name);
9079         W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
9080         r->environment                  = talloc_strdup(mem_ctx, environment);
9081         W_ERROR_HAVE_NO_MEMORY(r->environment);
9082         r->dll_name                     = talloc_strdup(mem_ctx, dll_name);
9083         W_ERROR_HAVE_NO_MEMORY(r->dll_name);
9084
9085         return WERR_OK;
9086 }
9087
9088 /****************************************************************************
9089  enumprintmonitors level 1.
9090 ****************************************************************************/
9091
9092 static WERROR enumprintmonitors_level_1(TALLOC_CTX *mem_ctx,
9093                                         union spoolss_MonitorInfo **info_p,
9094                                         uint32_t *count)
9095 {
9096         union spoolss_MonitorInfo *info;
9097         WERROR result = WERR_OK;
9098
9099         info = talloc_array(mem_ctx, union spoolss_MonitorInfo, 2);
9100         W_ERROR_HAVE_NO_MEMORY(info);
9101
9102         *count = 2;
9103
9104         result = fill_monitor_1(info, &info[0].info1,
9105                                 SPL_LOCAL_PORT);
9106         if (!W_ERROR_IS_OK(result)) {
9107                 goto out;
9108         }
9109
9110         result = fill_monitor_1(info, &info[1].info1,
9111                                 SPL_TCPIP_PORT);
9112         if (!W_ERROR_IS_OK(result)) {
9113                 goto out;
9114         }
9115
9116 out:
9117         if (!W_ERROR_IS_OK(result)) {
9118                 TALLOC_FREE(info);
9119                 *count = 0;
9120                 return result;
9121         }
9122
9123         *info_p = info;
9124
9125         return WERR_OK;
9126 }
9127
9128 /****************************************************************************
9129  enumprintmonitors level 2.
9130 ****************************************************************************/
9131
9132 static WERROR enumprintmonitors_level_2(TALLOC_CTX *mem_ctx,
9133                                         union spoolss_MonitorInfo **info_p,
9134                                         uint32_t *count)
9135 {
9136         union spoolss_MonitorInfo *info;
9137         WERROR result = WERR_OK;
9138
9139         info = talloc_array(mem_ctx, union spoolss_MonitorInfo, 2);
9140         W_ERROR_HAVE_NO_MEMORY(info);
9141
9142         *count = 2;
9143
9144         result = fill_monitor_2(info, &info[0].info2,
9145                                 SPL_LOCAL_PORT,
9146                                 "Windows NT X86", /* FIXME */
9147                                 "localmon.dll");
9148         if (!W_ERROR_IS_OK(result)) {
9149                 goto out;
9150         }
9151
9152         result = fill_monitor_2(info, &info[1].info2,
9153                                 SPL_TCPIP_PORT,
9154                                 "Windows NT X86", /* FIXME */
9155                                 "tcpmon.dll");
9156         if (!W_ERROR_IS_OK(result)) {
9157                 goto out;
9158         }
9159
9160 out:
9161         if (!W_ERROR_IS_OK(result)) {
9162                 TALLOC_FREE(info);
9163                 *count = 0;
9164                 return result;
9165         }
9166
9167         *info_p = info;
9168
9169         return WERR_OK;
9170 }
9171
9172 /****************************************************************
9173  _spoolss_EnumMonitors
9174 ****************************************************************/
9175
9176 WERROR _spoolss_EnumMonitors(struct pipes_struct *p,
9177                              struct spoolss_EnumMonitors *r)
9178 {
9179         WERROR result;
9180
9181         /* that's an [in out] buffer */
9182
9183         if (!r->in.buffer && (r->in.offered != 0)) {
9184                 return WERR_INVALID_PARAM;
9185         }
9186
9187         DEBUG(5,("_spoolss_EnumMonitors\n"));
9188
9189         /*
9190          * Enumerate the print monitors ...
9191          *
9192          * Just reply with "Local Port", to keep NT happy
9193          * and I can use my nice printer checker.
9194          */
9195
9196         *r->out.count = 0;
9197         *r->out.needed = 0;
9198         *r->out.info = NULL;
9199
9200         switch (r->in.level) {
9201         case 1:
9202                 result = enumprintmonitors_level_1(p->mem_ctx, r->out.info,
9203                                                    r->out.count);
9204                 break;
9205         case 2:
9206                 result = enumprintmonitors_level_2(p->mem_ctx, r->out.info,
9207                                                    r->out.count);
9208                 break;
9209         default:
9210                 return WERR_UNKNOWN_LEVEL;
9211         }
9212
9213         if (!W_ERROR_IS_OK(result)) {
9214                 return result;
9215         }
9216
9217         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
9218                                                      spoolss_EnumMonitors,
9219                                                      *r->out.info, r->in.level,
9220                                                      *r->out.count);
9221         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
9222         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
9223
9224         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
9225 }
9226
9227 /****************************************************************************
9228 ****************************************************************************/
9229
9230 static WERROR getjob_level_1(TALLOC_CTX *mem_ctx,
9231                              const print_queue_struct *queue,
9232                              int count, int snum,
9233                              struct spoolss_PrinterInfo2 *pinfo2,
9234                              uint32_t jobid,
9235                              struct spoolss_JobInfo1 *r)
9236 {
9237         int i = 0;
9238         bool found = false;
9239
9240         for (i=0; i<count; i++) {
9241                 if (queue[i].sysjob == (int)jobid) {
9242                         found = true;
9243                         break;
9244                 }
9245         }
9246
9247         if (found == false) {
9248                 /* NT treats not found as bad param... yet another bad choice */
9249                 return WERR_INVALID_PARAM;
9250         }
9251
9252         return fill_job_info1(mem_ctx,
9253                               r,
9254                               &queue[i],
9255                               i,
9256                               snum,
9257                               pinfo2);
9258 }
9259
9260 /****************************************************************************
9261 ****************************************************************************/
9262
9263 static WERROR getjob_level_2(TALLOC_CTX *mem_ctx,
9264                              const print_queue_struct *queue,
9265                              int count, int snum,
9266                              struct spoolss_PrinterInfo2 *pinfo2,
9267                              uint32_t jobid,
9268                              struct spoolss_JobInfo2 *r)
9269 {
9270         int i = 0;
9271         bool found = false;
9272         struct spoolss_DeviceMode *devmode;
9273         WERROR result;
9274
9275         for (i=0; i<count; i++) {
9276                 if (queue[i].sysjob == (int)jobid) {
9277                         found = true;
9278                         break;
9279                 }
9280         }
9281
9282         if (found == false) {
9283                 /* NT treats not found as bad param... yet another bad
9284                    choice */
9285                 return WERR_INVALID_PARAM;
9286         }
9287
9288         /*
9289          * if the print job does not have a DEVMODE associated with it,
9290          * just use the one for the printer. A NULL devicemode is not
9291          *  a failure condition
9292          */
9293
9294         devmode = print_job_devmode(mem_ctx, lp_const_servicename(snum), jobid);
9295         if (!devmode) {
9296                 result = spoolss_create_default_devmode(mem_ctx,
9297                                                 pinfo2->printername,
9298                                                 &devmode);
9299                 if (!W_ERROR_IS_OK(result)) {
9300                         DEBUG(3, ("Can't proceed w/o a devmode!"));
9301                         return result;
9302                 }
9303         }
9304
9305         return fill_job_info2(mem_ctx,
9306                               r,
9307                               &queue[i],
9308                               i,
9309                               snum,
9310                               pinfo2,
9311                               devmode);
9312 }
9313
9314 /****************************************************************
9315  _spoolss_GetJob
9316 ****************************************************************/
9317
9318 WERROR _spoolss_GetJob(struct pipes_struct *p,
9319                        struct spoolss_GetJob *r)
9320 {
9321         WERROR result = WERR_OK;
9322         struct spoolss_PrinterInfo2 *pinfo2 = NULL;
9323         int snum;
9324         int count;
9325         print_queue_struct      *queue = NULL;
9326         print_status_struct prt_status;
9327
9328         /* that's an [in out] buffer */
9329
9330         if (!r->in.buffer && (r->in.offered != 0)) {
9331                 return WERR_INVALID_PARAM;
9332         }
9333
9334         DEBUG(5,("_spoolss_GetJob\n"));
9335
9336         *r->out.needed = 0;
9337
9338         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9339                 return WERR_BADFID;
9340         }
9341
9342         result = winreg_get_printer_internal(p->mem_ctx,
9343                                     get_session_info_system(),
9344                                     p->msg_ctx,
9345                                     lp_const_servicename(snum),
9346                                     &pinfo2);
9347         if (!W_ERROR_IS_OK(result)) {
9348                 return result;
9349         }
9350
9351         count = print_queue_status(p->msg_ctx, snum, &queue, &prt_status);
9352
9353         DEBUGADD(4,("count:[%d], prt_status:[%d], [%s]\n",
9354                      count, prt_status.status, prt_status.message));
9355
9356         switch (r->in.level) {
9357         case 1:
9358                 result = getjob_level_1(p->mem_ctx,
9359                                         queue, count, snum, pinfo2,
9360                                         r->in.job_id, &r->out.info->info1);
9361                 break;
9362         case 2:
9363                 result = getjob_level_2(p->mem_ctx,
9364                                         queue, count, snum, pinfo2,
9365                                         r->in.job_id, &r->out.info->info2);
9366                 break;
9367         default:
9368                 result = WERR_UNKNOWN_LEVEL;
9369                 break;
9370         }
9371
9372         SAFE_FREE(queue);
9373         TALLOC_FREE(pinfo2);
9374
9375         if (!W_ERROR_IS_OK(result)) {
9376                 TALLOC_FREE(r->out.info);
9377                 return result;
9378         }
9379
9380         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_JobInfo, r->out.info,
9381                                                                                    r->in.level);
9382         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
9383
9384         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
9385 }
9386
9387 /****************************************************************
9388  _spoolss_GetPrinterDataEx
9389 ****************************************************************/
9390
9391 WERROR _spoolss_GetPrinterDataEx(struct pipes_struct *p,
9392                                  struct spoolss_GetPrinterDataEx *r)
9393 {
9394
9395         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
9396         const char *printer;
9397         int                     snum = 0;
9398         WERROR result = WERR_OK;
9399         DATA_BLOB blob;
9400         enum winreg_Type val_type = REG_NONE;
9401         uint8_t *val_data = NULL;
9402         uint32_t val_size = 0;
9403         struct dcerpc_binding_handle *b;
9404         TALLOC_CTX *tmp_ctx;
9405
9406         DEBUG(4,("_spoolss_GetPrinterDataEx\n"));
9407
9408         DEBUG(10, ("_spoolss_GetPrinterDataEx: key => [%s], value => [%s]\n",
9409                 r->in.key_name, r->in.value_name));
9410
9411         /* in case of problem, return some default values */
9412
9413         *r->out.needed  = 0;
9414         *r->out.type    = REG_NONE;
9415
9416         tmp_ctx = talloc_new(p->mem_ctx);
9417         if (!tmp_ctx) {
9418                 return WERR_NOMEM;
9419         }
9420
9421         if (!Printer) {
9422                 DEBUG(2,("_spoolss_GetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
9423                         OUR_HANDLE(r->in.handle)));
9424                 result = WERR_BADFID;
9425                 goto done;
9426         }
9427
9428         /* check to see if the keyname is valid */
9429         if (!strlen(r->in.key_name)) {
9430                 result = WERR_INVALID_PARAM;
9431                 goto done;
9432         }
9433
9434         /* Is the handle to a printer or to the server? */
9435
9436         if (Printer->printer_type == SPLHND_SERVER) {
9437
9438                 union spoolss_PrinterData data;
9439
9440                 result = getprinterdata_printer_server(tmp_ctx,
9441                                                        r->in.value_name,
9442                                                        r->out.type,
9443                                                        &data);
9444                 if (!W_ERROR_IS_OK(result)) {
9445                         goto done;
9446                 }
9447
9448                 result = push_spoolss_PrinterData(tmp_ctx, &blob,
9449                                                   *r->out.type, &data);
9450                 if (!W_ERROR_IS_OK(result)) {
9451                         goto done;
9452                 }
9453
9454                 *r->out.needed = blob.length;
9455
9456                 if (r->in.offered >= *r->out.needed) {
9457                         memcpy(r->out.data, blob.data, blob.length);
9458                 }
9459
9460                 result = WERR_OK;
9461                 goto done;
9462         }
9463
9464         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9465                 result = WERR_BADFID;
9466                 goto done;
9467         }
9468         printer = lp_const_servicename(snum);
9469
9470         result = winreg_printer_binding_handle(tmp_ctx,
9471                                                get_session_info_system(),
9472                                                p->msg_ctx,
9473                                                &b);
9474         if (!W_ERROR_IS_OK(result)) {
9475                 goto done;
9476         }
9477
9478         /* XP sends this and wants the ChangeID value from PRINTER_INFO_0 */
9479         if (strequal(r->in.key_name, SPOOL_PRINTERDATA_KEY) &&
9480             strequal(r->in.value_name, "ChangeId")) {
9481                 *r->out.type = REG_DWORD;
9482                 *r->out.needed = 4;
9483                 if (r->in.offered >= *r->out.needed) {
9484                         uint32_t changeid = 0;
9485
9486                         result = winreg_printer_get_changeid(tmp_ctx, b,
9487                                                              printer,
9488                                                              &changeid);
9489                         if (!W_ERROR_IS_OK(result)) {
9490                                 goto done;
9491                         }
9492
9493                         SIVAL(r->out.data, 0, changeid);
9494                         result = WERR_OK;
9495                 }
9496                 goto done;
9497         }
9498
9499         result = winreg_get_printer_dataex(tmp_ctx, b,
9500                                            printer,
9501                                            r->in.key_name,
9502                                            r->in.value_name,
9503                                            &val_type,
9504                                            &val_data,
9505                                            &val_size);
9506         if (!W_ERROR_IS_OK(result)) {
9507                 goto done;
9508         }
9509
9510         *r->out.needed = val_size;
9511         *r->out.type = val_type;
9512
9513         if (r->in.offered >= *r->out.needed) {
9514                 memcpy(r->out.data, val_data, val_size);
9515         }
9516
9517 done:
9518         /* NOTE: do not replace type when returning WERR_MORE_DATA */
9519
9520         if (W_ERROR_IS_OK(result)) {
9521                 result = SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
9522         }
9523
9524         talloc_free(tmp_ctx);
9525         return result;
9526 }
9527
9528 /****************************************************************
9529  _spoolss_SetPrinterDataEx
9530 ****************************************************************/
9531
9532 WERROR _spoolss_SetPrinterDataEx(struct pipes_struct *p,
9533                                  struct spoolss_SetPrinterDataEx *r)
9534 {
9535         struct spoolss_PrinterInfo2 *pinfo2 = NULL;
9536         int                     snum = 0;
9537         WERROR                  result = WERR_OK;
9538         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
9539         char                    *oid_string;
9540         struct dcerpc_binding_handle *b;
9541         TALLOC_CTX *tmp_ctx;
9542
9543         DEBUG(4,("_spoolss_SetPrinterDataEx\n"));
9544
9545         /* From MSDN documentation of SetPrinterDataEx: pass request to
9546            SetPrinterData if key is "PrinterDriverData" */
9547
9548         if (!Printer) {
9549                 DEBUG(2,("_spoolss_SetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
9550                         OUR_HANDLE(r->in.handle)));
9551                 return WERR_BADFID;
9552         }
9553
9554         if (Printer->printer_type == SPLHND_SERVER) {
9555                 DEBUG(10,("_spoolss_SetPrinterDataEx: "
9556                         "Not implemented for server handles yet\n"));
9557                 return WERR_INVALID_PARAM;
9558         }
9559
9560         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9561                 return WERR_BADFID;
9562         }
9563
9564         /*
9565          * Access check : NT returns "access denied" if you make a
9566          * SetPrinterData call without the necessary privildge.
9567          * we were originally returning OK if nothing changed
9568          * which made Win2k issue **a lot** of SetPrinterData
9569          * when connecting to a printer  --jerry
9570          */
9571
9572         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9573                 DEBUG(3, ("_spoolss_SetPrinterDataEx: "
9574                         "change denied by handle access permissions\n"));
9575                 return WERR_ACCESS_DENIED;
9576         }
9577
9578         tmp_ctx = talloc_new(p->mem_ctx);
9579         if (!tmp_ctx) {
9580                 return WERR_NOMEM;
9581         }
9582
9583         result = winreg_printer_binding_handle(tmp_ctx,
9584                                                get_session_info_system(),
9585                                                p->msg_ctx,
9586                                                &b);
9587         if (!W_ERROR_IS_OK(result)) {
9588                 goto done;
9589         }
9590
9591         result = winreg_get_printer(tmp_ctx, b,
9592                                     lp_servicename(talloc_tos(), snum),
9593                                     &pinfo2);
9594         if (!W_ERROR_IS_OK(result)) {
9595                 goto done;
9596         }
9597
9598         /* check for OID in valuename */
9599
9600         oid_string = strchr(r->in.value_name, ',');
9601         if (oid_string) {
9602                 *oid_string = '\0';
9603                 oid_string++;
9604         }
9605
9606         /* save the registry data */
9607
9608         result = winreg_set_printer_dataex(tmp_ctx, b,
9609                                            pinfo2->sharename,
9610                                            r->in.key_name,
9611                                            r->in.value_name,
9612                                            r->in.type,
9613                                            r->in.data,
9614                                            r->in.offered);
9615
9616         if (W_ERROR_IS_OK(result)) {
9617                 /* save the OID if one was specified */
9618                 if (oid_string) {
9619                         char *str = talloc_asprintf(tmp_ctx, "%s\\%s",
9620                                 r->in.key_name, SPOOL_OID_KEY);
9621                         if (!str) {
9622                                 result = WERR_NOMEM;
9623                                 goto done;
9624                         }
9625
9626                         /*
9627                          * I'm not checking the status here on purpose.  Don't know
9628                          * if this is right, but I'm returning the status from the
9629                          * previous set_printer_dataex() call.  I have no idea if
9630                          * this is right.    --jerry
9631                          */
9632                         winreg_set_printer_dataex(tmp_ctx, b,
9633                                                   pinfo2->sharename,
9634                                                   str,
9635                                                   r->in.value_name,
9636                                                   REG_SZ,
9637                                                   (uint8_t *) oid_string,
9638                                                   strlen(oid_string) + 1);
9639                 }
9640
9641                 result = winreg_printer_update_changeid(tmp_ctx, b,
9642                                                         lp_const_servicename(snum));
9643
9644         }
9645
9646 done:
9647         talloc_free(tmp_ctx);
9648         return result;
9649 }
9650
9651 /****************************************************************
9652  _spoolss_DeletePrinterDataEx
9653 ****************************************************************/
9654
9655 WERROR _spoolss_DeletePrinterDataEx(struct pipes_struct *p,
9656                                     struct spoolss_DeletePrinterDataEx *r)
9657 {
9658         const char *printer;
9659         int             snum=0;
9660         WERROR          status = WERR_OK;
9661         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
9662
9663         DEBUG(5,("_spoolss_DeletePrinterDataEx\n"));
9664
9665         if (!Printer) {
9666                 DEBUG(2,("_spoolss_DeletePrinterDataEx: "
9667                         "Invalid handle (%s:%u:%u).\n",
9668                         OUR_HANDLE(r->in.handle)));
9669                 return WERR_BADFID;
9670         }
9671
9672         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9673                 DEBUG(3, ("_spoolss_DeletePrinterDataEx: "
9674                         "printer properties change denied by handle\n"));
9675                 return WERR_ACCESS_DENIED;
9676         }
9677
9678         if (!r->in.value_name || !r->in.key_name) {
9679                 return WERR_NOMEM;
9680         }
9681
9682         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9683                 return WERR_BADFID;
9684         }
9685         printer = lp_const_servicename(snum);
9686
9687         status = winreg_delete_printer_dataex_internal(p->mem_ctx,
9688                                               get_session_info_system(),
9689                                               p->msg_ctx,
9690                                               printer,
9691                                               r->in.key_name,
9692                                               r->in.value_name);
9693         if (W_ERROR_IS_OK(status)) {
9694                 status = winreg_printer_update_changeid_internal(p->mem_ctx,
9695                                                         get_session_info_system(),
9696                                                         p->msg_ctx,
9697                                                         printer);
9698         }
9699
9700         return status;
9701 }
9702
9703 /****************************************************************
9704  _spoolss_EnumPrinterKey
9705 ****************************************************************/
9706
9707 WERROR _spoolss_EnumPrinterKey(struct pipes_struct *p,
9708                                struct spoolss_EnumPrinterKey *r)
9709 {
9710         uint32_t        num_keys;
9711         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
9712         int             snum = 0;
9713         WERROR          result = WERR_BADFILE;
9714         const char **array = NULL;
9715         DATA_BLOB blob;
9716
9717         DEBUG(4,("_spoolss_EnumPrinterKey\n"));
9718
9719         if (!Printer) {
9720                 DEBUG(2,("_spoolss_EnumPrinterKey: Invalid handle (%s:%u:%u).\n",
9721                         OUR_HANDLE(r->in.handle)));
9722                 return WERR_BADFID;
9723         }
9724
9725         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9726                 return WERR_BADFID;
9727         }
9728
9729         result = winreg_enum_printer_key_internal(p->mem_ctx,
9730                                          get_session_info_system(),
9731                                          p->msg_ctx,
9732                                          lp_const_servicename(snum),
9733                                          r->in.key_name,
9734                                          &num_keys,
9735                                          &array);
9736         if (!W_ERROR_IS_OK(result)) {
9737                 goto done;
9738         }
9739
9740         if (!push_reg_multi_sz(p->mem_ctx, &blob, array)) {
9741                 result = WERR_NOMEM;
9742                 goto done;
9743         }
9744
9745         *r->out._ndr_size = r->in.offered / 2;
9746         *r->out.needed = blob.length;
9747
9748         if (r->in.offered < *r->out.needed) {
9749                 result = WERR_MORE_DATA;
9750         } else {
9751                 result = WERR_OK;
9752                 r->out.key_buffer->string_array = array;
9753         }
9754
9755  done:
9756         if (!W_ERROR_IS_OK(result)) {
9757                 TALLOC_FREE(array);
9758                 if (!W_ERROR_EQUAL(result, WERR_MORE_DATA)) {
9759                         *r->out.needed = 0;
9760                 }
9761         }
9762
9763         return result;
9764 }
9765
9766 /****************************************************************
9767  _spoolss_DeletePrinterKey
9768 ****************************************************************/
9769
9770 WERROR _spoolss_DeletePrinterKey(struct pipes_struct *p,
9771                                  struct spoolss_DeletePrinterKey *r)
9772 {
9773         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
9774         int                     snum=0;
9775         WERROR                  status;
9776         const char *printer;
9777         struct dcerpc_binding_handle *b;
9778         TALLOC_CTX *tmp_ctx;
9779
9780         DEBUG(5,("_spoolss_DeletePrinterKey\n"));
9781
9782         if (!Printer) {
9783                 DEBUG(2,("_spoolss_DeletePrinterKey: Invalid handle (%s:%u:%u).\n",
9784                         OUR_HANDLE(r->in.handle)));
9785                 return WERR_BADFID;
9786         }
9787
9788         /* if keyname == NULL, return error */
9789         if ( !r->in.key_name )
9790                 return WERR_INVALID_PARAM;
9791
9792         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9793                 return WERR_BADFID;
9794         }
9795
9796         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9797                 DEBUG(3, ("_spoolss_DeletePrinterKey: "
9798                         "printer properties change denied by handle\n"));
9799                 return WERR_ACCESS_DENIED;
9800         }
9801
9802         printer = lp_const_servicename(snum);
9803
9804         tmp_ctx = talloc_new(p->mem_ctx);
9805         if (!tmp_ctx) {
9806                 return WERR_NOMEM;
9807         }
9808
9809         status = winreg_printer_binding_handle(tmp_ctx,
9810                                                get_session_info_system(),
9811                                                p->msg_ctx,
9812                                                &b);
9813         if (!W_ERROR_IS_OK(status)) {
9814                 goto done;
9815         }
9816
9817         /* delete the key and all subkeys */
9818         status = winreg_delete_printer_key(tmp_ctx, b,
9819                                            printer,
9820                                            r->in.key_name);
9821         if (W_ERROR_IS_OK(status)) {
9822                 status = winreg_printer_update_changeid(tmp_ctx, b,
9823                                                         printer);
9824         }
9825
9826 done:
9827         talloc_free(tmp_ctx);
9828         return status;
9829 }
9830
9831 /****************************************************************
9832  _spoolss_EnumPrinterDataEx
9833 ****************************************************************/
9834
9835 WERROR _spoolss_EnumPrinterDataEx(struct pipes_struct *p,
9836                                   struct spoolss_EnumPrinterDataEx *r)
9837 {
9838         uint32_t        count = 0;
9839         struct spoolss_PrinterEnumValues *info = NULL;
9840         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
9841         int             snum;
9842         WERROR          result;
9843
9844         DEBUG(4,("_spoolss_EnumPrinterDataEx\n"));
9845
9846         *r->out.count = 0;
9847         *r->out.needed = 0;
9848         *r->out.info = NULL;
9849
9850         if (!Printer) {
9851                 DEBUG(2,("_spoolss_EnumPrinterDataEx: Invalid handle (%s:%u:%u1<).\n",
9852                         OUR_HANDLE(r->in.handle)));
9853                 return WERR_BADFID;
9854         }
9855
9856         /*
9857          * first check for a keyname of NULL or "".  Win2k seems to send
9858          * this a lot and we should send back WERR_INVALID_PARAM
9859          * no need to spend time looking up the printer in this case.
9860          * --jerry
9861          */
9862
9863         if (!strlen(r->in.key_name)) {
9864                 result = WERR_INVALID_PARAM;
9865                 goto done;
9866         }
9867
9868         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9869                 return WERR_BADFID;
9870         }
9871
9872         /* now look for a match on the key name */
9873         result = winreg_enum_printer_dataex_internal(p->mem_ctx,
9874                                             get_session_info_system(),
9875                                             p->msg_ctx,
9876                                             lp_const_servicename(snum),
9877                                             r->in.key_name,
9878                                             &count,
9879                                             &info);
9880         if (!W_ERROR_IS_OK(result)) {
9881                 goto done;
9882         }
9883
9884 #if 0 /* FIXME - gd */
9885         /* housekeeping information in the reply */
9886
9887         /* Fix from Martin Zielinski <mz@seh.de> - ensure
9888          * the hand marshalled container size is a multiple
9889          * of 4 bytes for RPC alignment.
9890          */
9891
9892         if (needed % 4) {
9893                 needed += 4-(needed % 4);
9894         }
9895 #endif
9896         *r->out.count   = count;
9897         *r->out.info    = info;
9898
9899  done:
9900         if (!W_ERROR_IS_OK(result)) {
9901                 return result;
9902         }
9903
9904         *r->out.needed  = SPOOLSS_BUFFER_ARRAY(p->mem_ctx,
9905                                                spoolss_EnumPrinterDataEx,
9906                                                *r->out.info,
9907                                                *r->out.count);
9908         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
9909         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, *r->out.count);
9910
9911         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
9912 }
9913
9914 /****************************************************************************
9915 ****************************************************************************/
9916
9917 static WERROR getprintprocessordirectory_level_1(TALLOC_CTX *mem_ctx,
9918                                                  const char *servername,
9919                                                  const char *environment,
9920                                                  struct spoolss_PrintProcessorDirectoryInfo1 *r)
9921 {
9922         WERROR werr;
9923         char *path = NULL;
9924
9925         werr = compose_spoolss_server_path(mem_ctx,
9926                                            servername,
9927                                            environment,
9928                                            SPOOLSS_PRTPROCS_PATH,
9929                                            &path);
9930         if (!W_ERROR_IS_OK(werr)) {
9931                 return werr;
9932         }
9933
9934         DEBUG(4,("print processor directory: [%s]\n", path));
9935
9936         r->directory_name = path;
9937
9938         return WERR_OK;
9939 }
9940
9941 /****************************************************************
9942  _spoolss_GetPrintProcessorDirectory
9943 ****************************************************************/
9944
9945 WERROR _spoolss_GetPrintProcessorDirectory(struct pipes_struct *p,
9946                                            struct spoolss_GetPrintProcessorDirectory *r)
9947 {
9948         WERROR result;
9949         char *prnproc_share = NULL;
9950         bool prnproc_share_exists = false;
9951         int snum;
9952
9953         /* that's an [in out] buffer */
9954
9955         if (!r->in.buffer && (r->in.offered != 0)) {
9956                 return WERR_INVALID_PARAM;
9957         }
9958
9959         DEBUG(5,("_spoolss_GetPrintProcessorDirectory: level %d\n",
9960                 r->in.level));
9961
9962         *r->out.needed = 0;
9963
9964         /* r->in.level is ignored */
9965
9966         /* We always should reply with a local print processor directory so that
9967          * users are not forced to have a [prnproc$] share on the Samba spoolss
9968          * server, if users decide to do so, lets announce it though - Guenther */
9969
9970         snum = find_service(talloc_tos(), "prnproc$", &prnproc_share);
9971         if (!prnproc_share) {
9972                 return WERR_NOMEM;
9973         }
9974         if (snum != -1) {
9975                 prnproc_share_exists = true;
9976         }
9977
9978         result = getprintprocessordirectory_level_1(p->mem_ctx,
9979                                                     prnproc_share_exists ? r->in.server : NULL,
9980                                                     r->in.environment,
9981                                                     &r->out.info->info1);
9982         if (!W_ERROR_IS_OK(result)) {
9983                 TALLOC_FREE(r->out.info);
9984                 return result;
9985         }
9986
9987         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_PrintProcessorDirectoryInfo,
9988                                                                                    r->out.info, r->in.level);
9989         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
9990
9991         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
9992 }
9993
9994 /*******************************************************************
9995  ********************************************************************/
9996
9997 static bool push_monitorui_buf(TALLOC_CTX *mem_ctx, DATA_BLOB *buf,
9998                                const char *dllname)
9999 {
10000         enum ndr_err_code ndr_err;
10001         struct spoolss_MonitorUi ui;
10002
10003         ui.dll_name = dllname;
10004
10005         ndr_err = ndr_push_struct_blob(buf, mem_ctx, &ui,
10006                        (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorUi);
10007         if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
10008                 NDR_PRINT_DEBUG(spoolss_MonitorUi, &ui);
10009         }
10010         return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
10011 }
10012
10013 /*******************************************************************
10014  Streams the monitor UI DLL name in UNICODE
10015 *******************************************************************/
10016
10017 static WERROR xcvtcp_monitorui(TALLOC_CTX *mem_ctx,
10018                                struct security_token *token, DATA_BLOB *in,
10019                                DATA_BLOB *out, uint32_t *needed)
10020 {
10021         const char *dllname = "tcpmonui.dll";
10022
10023         *needed = (strlen(dllname)+1) * 2;
10024
10025         if (out->length < *needed) {
10026                 return WERR_INSUFFICIENT_BUFFER;
10027         }
10028
10029         if (!push_monitorui_buf(mem_ctx, out, dllname)) {
10030                 return WERR_NOMEM;
10031         }
10032
10033         return WERR_OK;
10034 }
10035
10036 /*******************************************************************
10037  ********************************************************************/
10038
10039 static bool pull_port_data_1(TALLOC_CTX *mem_ctx,
10040                              struct spoolss_PortData1 *port1,
10041                              const DATA_BLOB *buf)
10042 {
10043         enum ndr_err_code ndr_err;
10044         ndr_err = ndr_pull_struct_blob(buf, mem_ctx, port1,
10045                        (ndr_pull_flags_fn_t)ndr_pull_spoolss_PortData1);
10046         if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
10047                 NDR_PRINT_DEBUG(spoolss_PortData1, port1);
10048         }
10049         return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
10050 }
10051
10052 /*******************************************************************
10053  ********************************************************************/
10054
10055 static bool pull_port_data_2(TALLOC_CTX *mem_ctx,
10056                              struct spoolss_PortData2 *port2,
10057                              const DATA_BLOB *buf)
10058 {
10059         enum ndr_err_code ndr_err;
10060         ndr_err = ndr_pull_struct_blob(buf, mem_ctx, port2,
10061                        (ndr_pull_flags_fn_t)ndr_pull_spoolss_PortData2);
10062         if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
10063                 NDR_PRINT_DEBUG(spoolss_PortData2, port2);
10064         }
10065         return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
10066 }
10067
10068 /*******************************************************************
10069  Create a new TCP/IP port
10070 *******************************************************************/
10071
10072 static WERROR xcvtcp_addport(TALLOC_CTX *mem_ctx,
10073                              struct security_token *token, DATA_BLOB *in,
10074                              DATA_BLOB *out, uint32_t *needed)
10075 {
10076         struct spoolss_PortData1 port1;
10077         struct spoolss_PortData2 port2;
10078         char *device_uri = NULL;
10079         uint32_t version;
10080
10081         const char *portname;
10082         const char *hostaddress;
10083         const char *queue;
10084         uint32_t port_number;
10085         uint32_t protocol;
10086
10087         /* peek for spoolss_PortData version */
10088
10089         if (!in || (in->length < (128 + 4))) {
10090                 return WERR_GENERAL_FAILURE;
10091         }
10092
10093         version = IVAL(in->data, 128);
10094
10095         switch (version) {
10096                 case 1:
10097                         ZERO_STRUCT(port1);
10098
10099                         if (!pull_port_data_1(mem_ctx, &port1, in)) {
10100                                 return WERR_NOMEM;
10101                         }
10102
10103                         portname        = port1.portname;
10104                         hostaddress     = port1.hostaddress;
10105                         queue           = port1.queue;
10106                         protocol        = port1.protocol;
10107                         port_number     = port1.port_number;
10108
10109                         break;
10110                 case 2:
10111                         ZERO_STRUCT(port2);
10112
10113                         if (!pull_port_data_2(mem_ctx, &port2, in)) {
10114                                 return WERR_NOMEM;
10115                         }
10116
10117                         portname        = port2.portname;
10118                         hostaddress     = port2.hostaddress;
10119                         queue           = port2.queue;
10120                         protocol        = port2.protocol;
10121                         port_number     = port2.port_number;
10122
10123                         break;
10124                 default:
10125                         DEBUG(1,("xcvtcp_addport: "
10126                                 "unknown version of port_data: %d\n", version));
10127                         return WERR_UNKNOWN_PORT;
10128         }
10129
10130         /* create the device URI and call the add_port_hook() */
10131
10132         switch (protocol) {
10133         case PROTOCOL_RAWTCP_TYPE:
10134                 device_uri = talloc_asprintf(mem_ctx,
10135                                 "socket://%s:%d/", hostaddress,
10136                                 port_number);
10137                 break;
10138
10139         case PROTOCOL_LPR_TYPE:
10140                 device_uri = talloc_asprintf(mem_ctx,
10141                         "lpr://%s/%s", hostaddress, queue );
10142                 break;
10143
10144         default:
10145                 return WERR_UNKNOWN_PORT;
10146         }
10147
10148         if (!device_uri) {
10149                 return WERR_NOMEM;
10150         }
10151
10152         return add_port_hook(mem_ctx, token, portname, device_uri);
10153 }
10154
10155 /*******************************************************************
10156 *******************************************************************/
10157
10158 struct xcv_api_table xcvtcp_cmds[] = {
10159         { "MonitorUI",  xcvtcp_monitorui },
10160         { "AddPort",    xcvtcp_addport},
10161         { NULL,         NULL }
10162 };
10163
10164 static WERROR process_xcvtcp_command(TALLOC_CTX *mem_ctx,
10165                                      struct security_token *token, const char *command,
10166                                      DATA_BLOB *inbuf,
10167                                      DATA_BLOB *outbuf,
10168                                      uint32_t *needed )
10169 {
10170         int i;
10171
10172         DEBUG(10,("process_xcvtcp_command: Received command \"%s\"\n", command));
10173
10174         for ( i=0; xcvtcp_cmds[i].name; i++ ) {
10175                 if ( strcmp( command, xcvtcp_cmds[i].name ) == 0 )
10176                         return xcvtcp_cmds[i].fn(mem_ctx, token, inbuf, outbuf, needed);
10177         }
10178
10179         return WERR_BADFUNC;
10180 }
10181
10182 /*******************************************************************
10183 *******************************************************************/
10184 #if 0   /* don't support management using the "Local Port" monitor */
10185
10186 static WERROR xcvlocal_monitorui(TALLOC_CTX *mem_ctx,
10187                                  struct security_token *token, DATA_BLOB *in,
10188                                  DATA_BLOB *out, uint32_t *needed)
10189 {
10190         const char *dllname = "localui.dll";
10191
10192         *needed = (strlen(dllname)+1) * 2;
10193
10194         if (out->length < *needed) {
10195                 return WERR_INSUFFICIENT_BUFFER;
10196         }
10197
10198         if (!push_monitorui_buf(mem_ctx, out, dllname)) {
10199                 return WERR_NOMEM;
10200         }
10201
10202         return WERR_OK;
10203 }
10204
10205 /*******************************************************************
10206 *******************************************************************/
10207
10208 struct xcv_api_table xcvlocal_cmds[] = {
10209         { "MonitorUI",  xcvlocal_monitorui },
10210         { NULL,         NULL }
10211 };
10212 #else
10213 struct xcv_api_table xcvlocal_cmds[] = {
10214         { NULL,         NULL }
10215 };
10216 #endif
10217
10218
10219
10220 /*******************************************************************
10221 *******************************************************************/
10222
10223 static WERROR process_xcvlocal_command(TALLOC_CTX *mem_ctx,
10224                                        struct security_token *token, const char *command,
10225                                        DATA_BLOB *inbuf, DATA_BLOB *outbuf,
10226                                        uint32_t *needed)
10227 {
10228         int i;
10229
10230         DEBUG(10,("process_xcvlocal_command: Received command \"%s\"\n", command));
10231
10232         for ( i=0; xcvlocal_cmds[i].name; i++ ) {
10233                 if ( strcmp( command, xcvlocal_cmds[i].name ) == 0 )
10234                         return xcvlocal_cmds[i].fn(mem_ctx, token, inbuf, outbuf, needed);
10235         }
10236         return WERR_BADFUNC;
10237 }
10238
10239 /****************************************************************
10240  _spoolss_XcvData
10241 ****************************************************************/
10242
10243 WERROR _spoolss_XcvData(struct pipes_struct *p,
10244                         struct spoolss_XcvData *r)
10245 {
10246         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
10247         DATA_BLOB out_data = data_blob_null;
10248         WERROR werror;
10249
10250         if (!Printer) {
10251                 DEBUG(2,("_spoolss_XcvData: Invalid handle (%s:%u:%u).\n",
10252                         OUR_HANDLE(r->in.handle)));
10253                 return WERR_BADFID;
10254         }
10255
10256         /* Has to be a handle to the TCP/IP port monitor */
10257
10258         if ( !(Printer->printer_type & (SPLHND_PORTMON_LOCAL|SPLHND_PORTMON_TCP)) ) {
10259                 DEBUG(2,("_spoolss_XcvData: Call only valid for Port Monitors\n"));
10260                 return WERR_BADFID;
10261         }
10262
10263         /* requires administrative access to the server */
10264
10265         if ( !(Printer->access_granted & SERVER_ACCESS_ADMINISTER) ) {
10266                 DEBUG(2,("_spoolss_XcvData: denied by handle permissions.\n"));
10267                 return WERR_ACCESS_DENIED;
10268         }
10269
10270         /* Allocate the outgoing buffer */
10271
10272         if (r->in.out_data_size) {
10273                 out_data = data_blob_talloc_zero(p->mem_ctx, r->in.out_data_size);
10274                 if (out_data.data == NULL) {
10275                         return WERR_NOMEM;
10276                 }
10277         }
10278
10279         switch ( Printer->printer_type ) {
10280         case SPLHND_PORTMON_TCP:
10281                 werror = process_xcvtcp_command(p->mem_ctx,
10282                                                 p->session_info->security_token,
10283                                                 r->in.function_name,
10284                                                 &r->in.in_data, &out_data,
10285                                                 r->out.needed);
10286                 break;
10287         case SPLHND_PORTMON_LOCAL:
10288                 werror = process_xcvlocal_command(p->mem_ctx,
10289                                                   p->session_info->security_token,
10290                                                   r->in.function_name,
10291                                                   &r->in.in_data, &out_data,
10292                                                   r->out.needed);
10293                 break;
10294         default:
10295                 werror = WERR_INVALID_PRINT_MONITOR;
10296         }
10297
10298         if (!W_ERROR_IS_OK(werror)) {
10299                 return werror;
10300         }
10301
10302         *r->out.status_code = 0;
10303
10304         if (r->out.out_data && out_data.data && r->in.out_data_size && out_data.length) {
10305                 memcpy(r->out.out_data, out_data.data,
10306                         MIN(r->in.out_data_size, out_data.length));
10307         }
10308
10309         return WERR_OK;
10310 }
10311
10312 /****************************************************************
10313  _spoolss_AddPrintProcessor
10314 ****************************************************************/
10315
10316 WERROR _spoolss_AddPrintProcessor(struct pipes_struct *p,
10317                                   struct spoolss_AddPrintProcessor *r)
10318 {
10319         /* for now, just indicate success and ignore the add.  We'll
10320            automatically set the winprint processor for printer
10321            entries later.  Used to debug the LexMark Optra S 1855 PCL
10322            driver --jerry */
10323
10324         return WERR_OK;
10325 }
10326
10327 /****************************************************************
10328  _spoolss_AddPort
10329 ****************************************************************/
10330
10331 WERROR _spoolss_AddPort(struct pipes_struct *p,
10332                         struct spoolss_AddPort *r)
10333 {
10334         /* do what w2k3 does */
10335
10336         return WERR_NOT_SUPPORTED;
10337 }
10338
10339 /****************************************************************
10340  _spoolss_GetPrinterDriver
10341 ****************************************************************/
10342
10343 WERROR _spoolss_GetPrinterDriver(struct pipes_struct *p,
10344                                  struct spoolss_GetPrinterDriver *r)
10345 {
10346         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10347         return WERR_NOT_SUPPORTED;
10348 }
10349
10350 /****************************************************************
10351  _spoolss_ReadPrinter
10352 ****************************************************************/
10353
10354 WERROR _spoolss_ReadPrinter(struct pipes_struct *p,
10355                             struct spoolss_ReadPrinter *r)
10356 {
10357         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10358         return WERR_NOT_SUPPORTED;
10359 }
10360
10361 /****************************************************************
10362  _spoolss_WaitForPrinterChange
10363 ****************************************************************/
10364
10365 WERROR _spoolss_WaitForPrinterChange(struct pipes_struct *p,
10366                                      struct spoolss_WaitForPrinterChange *r)
10367 {
10368         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10369         return WERR_NOT_SUPPORTED;
10370 }
10371
10372 /****************************************************************
10373  _spoolss_ConfigurePort
10374 ****************************************************************/
10375
10376 WERROR _spoolss_ConfigurePort(struct pipes_struct *p,
10377                               struct spoolss_ConfigurePort *r)
10378 {
10379         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10380         return WERR_NOT_SUPPORTED;
10381 }
10382
10383 /****************************************************************
10384  _spoolss_DeletePort
10385 ****************************************************************/
10386
10387 WERROR _spoolss_DeletePort(struct pipes_struct *p,
10388                            struct spoolss_DeletePort *r)
10389 {
10390         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10391         return WERR_NOT_SUPPORTED;
10392 }
10393
10394 /****************************************************************
10395  _spoolss_CreatePrinterIC
10396 ****************************************************************/
10397
10398 WERROR _spoolss_CreatePrinterIC(struct pipes_struct *p,
10399                                 struct spoolss_CreatePrinterIC *r)
10400 {
10401         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10402         return WERR_NOT_SUPPORTED;
10403 }
10404
10405 /****************************************************************
10406  _spoolss_PlayGDIScriptOnPrinterIC
10407 ****************************************************************/
10408
10409 WERROR _spoolss_PlayGDIScriptOnPrinterIC(struct pipes_struct *p,
10410                                          struct spoolss_PlayGDIScriptOnPrinterIC *r)
10411 {
10412         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10413         return WERR_NOT_SUPPORTED;
10414 }
10415
10416 /****************************************************************
10417  _spoolss_DeletePrinterIC
10418 ****************************************************************/
10419
10420 WERROR _spoolss_DeletePrinterIC(struct pipes_struct *p,
10421                                 struct spoolss_DeletePrinterIC *r)
10422 {
10423         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10424         return WERR_NOT_SUPPORTED;
10425 }
10426
10427 /****************************************************************
10428  _spoolss_AddPrinterConnection
10429 ****************************************************************/
10430
10431 WERROR _spoolss_AddPrinterConnection(struct pipes_struct *p,
10432                                      struct spoolss_AddPrinterConnection *r)
10433 {
10434         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10435         return WERR_NOT_SUPPORTED;
10436 }
10437
10438 /****************************************************************
10439  _spoolss_DeletePrinterConnection
10440 ****************************************************************/
10441
10442 WERROR _spoolss_DeletePrinterConnection(struct pipes_struct *p,
10443                                         struct spoolss_DeletePrinterConnection *r)
10444 {
10445         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10446         return WERR_NOT_SUPPORTED;
10447 }
10448
10449 /****************************************************************
10450  _spoolss_PrinterMessageBox
10451 ****************************************************************/
10452
10453 WERROR _spoolss_PrinterMessageBox(struct pipes_struct *p,
10454                                   struct spoolss_PrinterMessageBox *r)
10455 {
10456         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10457         return WERR_NOT_SUPPORTED;
10458 }
10459
10460 /****************************************************************
10461  _spoolss_AddMonitor
10462 ****************************************************************/
10463
10464 WERROR _spoolss_AddMonitor(struct pipes_struct *p,
10465                            struct spoolss_AddMonitor *r)
10466 {
10467         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10468         return WERR_NOT_SUPPORTED;
10469 }
10470
10471 /****************************************************************
10472  _spoolss_DeleteMonitor
10473 ****************************************************************/
10474
10475 WERROR _spoolss_DeleteMonitor(struct pipes_struct *p,
10476                               struct spoolss_DeleteMonitor *r)
10477 {
10478         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10479         return WERR_NOT_SUPPORTED;
10480 }
10481
10482 /****************************************************************
10483  _spoolss_DeletePrintProcessor
10484 ****************************************************************/
10485
10486 WERROR _spoolss_DeletePrintProcessor(struct pipes_struct *p,
10487                                      struct spoolss_DeletePrintProcessor *r)
10488 {
10489         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10490         return WERR_NOT_SUPPORTED;
10491 }
10492
10493 /****************************************************************
10494  _spoolss_AddPrintProvidor
10495 ****************************************************************/
10496
10497 WERROR _spoolss_AddPrintProvidor(struct pipes_struct *p,
10498                                  struct spoolss_AddPrintProvidor *r)
10499 {
10500         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10501         return WERR_NOT_SUPPORTED;
10502 }
10503
10504 /****************************************************************
10505  _spoolss_DeletePrintProvidor
10506 ****************************************************************/
10507
10508 WERROR _spoolss_DeletePrintProvidor(struct pipes_struct *p,
10509                                     struct spoolss_DeletePrintProvidor *r)
10510 {
10511         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10512         return WERR_NOT_SUPPORTED;
10513 }
10514
10515 /****************************************************************
10516  _spoolss_FindFirstPrinterChangeNotification
10517 ****************************************************************/
10518
10519 WERROR _spoolss_FindFirstPrinterChangeNotification(struct pipes_struct *p,
10520                                                    struct spoolss_FindFirstPrinterChangeNotification *r)
10521 {
10522         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10523         return WERR_NOT_SUPPORTED;
10524 }
10525
10526 /****************************************************************
10527  _spoolss_FindNextPrinterChangeNotification
10528 ****************************************************************/
10529
10530 WERROR _spoolss_FindNextPrinterChangeNotification(struct pipes_struct *p,
10531                                                   struct spoolss_FindNextPrinterChangeNotification *r)
10532 {
10533         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10534         return WERR_NOT_SUPPORTED;
10535 }
10536
10537 /****************************************************************
10538  _spoolss_RouterFindFirstPrinterChangeNotificationOld
10539 ****************************************************************/
10540
10541 WERROR _spoolss_RouterFindFirstPrinterChangeNotificationOld(struct pipes_struct *p,
10542                                                             struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
10543 {
10544         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10545         return WERR_NOT_SUPPORTED;
10546 }
10547
10548 /****************************************************************
10549  _spoolss_ReplyOpenPrinter
10550 ****************************************************************/
10551
10552 WERROR _spoolss_ReplyOpenPrinter(struct pipes_struct *p,
10553                                  struct spoolss_ReplyOpenPrinter *r)
10554 {
10555         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10556         return WERR_NOT_SUPPORTED;
10557 }
10558
10559 /****************************************************************
10560  _spoolss_RouterReplyPrinter
10561 ****************************************************************/
10562
10563 WERROR _spoolss_RouterReplyPrinter(struct pipes_struct *p,
10564                                    struct spoolss_RouterReplyPrinter *r)
10565 {
10566         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10567         return WERR_NOT_SUPPORTED;
10568 }
10569
10570 /****************************************************************
10571  _spoolss_ReplyClosePrinter
10572 ****************************************************************/
10573
10574 WERROR _spoolss_ReplyClosePrinter(struct pipes_struct *p,
10575                                   struct spoolss_ReplyClosePrinter *r)
10576 {
10577         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10578         return WERR_NOT_SUPPORTED;
10579 }
10580
10581 /****************************************************************
10582  _spoolss_AddPortEx
10583 ****************************************************************/
10584
10585 WERROR _spoolss_AddPortEx(struct pipes_struct *p,
10586                           struct spoolss_AddPortEx *r)
10587 {
10588         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10589         return WERR_NOT_SUPPORTED;
10590 }
10591
10592 /****************************************************************
10593  _spoolss_RouterFindFirstPrinterChangeNotification
10594 ****************************************************************/
10595
10596 WERROR _spoolss_RouterFindFirstPrinterChangeNotification(struct pipes_struct *p,
10597                                                          struct spoolss_RouterFindFirstPrinterChangeNotification *r)
10598 {
10599         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10600         return WERR_NOT_SUPPORTED;
10601 }
10602
10603 /****************************************************************
10604  _spoolss_SpoolerInit
10605 ****************************************************************/
10606
10607 WERROR _spoolss_SpoolerInit(struct pipes_struct *p,
10608                             struct spoolss_SpoolerInit *r)
10609 {
10610         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10611         return WERR_NOT_SUPPORTED;
10612 }
10613
10614 /****************************************************************
10615  _spoolss_ResetPrinterEx
10616 ****************************************************************/
10617
10618 WERROR _spoolss_ResetPrinterEx(struct pipes_struct *p,
10619                                struct spoolss_ResetPrinterEx *r)
10620 {
10621         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10622         return WERR_NOT_SUPPORTED;
10623 }
10624
10625 /****************************************************************
10626  _spoolss_RouterReplyPrinterEx
10627 ****************************************************************/
10628
10629 WERROR _spoolss_RouterReplyPrinterEx(struct pipes_struct *p,
10630                                      struct spoolss_RouterReplyPrinterEx *r)
10631 {
10632         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10633         return WERR_NOT_SUPPORTED;
10634 }
10635
10636 /****************************************************************
10637  _spoolss_44
10638 ****************************************************************/
10639
10640 WERROR _spoolss_44(struct pipes_struct *p,
10641                    struct spoolss_44 *r)
10642 {
10643         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10644         return WERR_NOT_SUPPORTED;
10645 }
10646
10647 /****************************************************************
10648  _spoolss_SetPort
10649 ****************************************************************/
10650
10651 WERROR _spoolss_SetPort(struct pipes_struct *p,
10652                         struct spoolss_SetPort *r)
10653 {
10654         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10655         return WERR_NOT_SUPPORTED;
10656 }
10657
10658 /****************************************************************
10659  _spoolss_4a
10660 ****************************************************************/
10661
10662 WERROR _spoolss_4a(struct pipes_struct *p,
10663                    struct spoolss_4a *r)
10664 {
10665         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10666         return WERR_NOT_SUPPORTED;
10667 }
10668
10669 /****************************************************************
10670  _spoolss_4b
10671 ****************************************************************/
10672
10673 WERROR _spoolss_4b(struct pipes_struct *p,
10674                    struct spoolss_4b *r)
10675 {
10676         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10677         return WERR_NOT_SUPPORTED;
10678 }
10679
10680 /****************************************************************
10681  _spoolss_4c
10682 ****************************************************************/
10683
10684 WERROR _spoolss_4c(struct pipes_struct *p,
10685                    struct spoolss_4c *r)
10686 {
10687         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10688         return WERR_NOT_SUPPORTED;
10689 }
10690
10691 /****************************************************************
10692  _spoolss_53
10693 ****************************************************************/
10694
10695 WERROR _spoolss_53(struct pipes_struct *p,
10696                    struct spoolss_53 *r)
10697 {
10698         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10699         return WERR_NOT_SUPPORTED;
10700 }
10701
10702 /****************************************************************
10703  _spoolss_AddPerMachineConnection
10704 ****************************************************************/
10705
10706 WERROR _spoolss_AddPerMachineConnection(struct pipes_struct *p,
10707                                         struct spoolss_AddPerMachineConnection *r)
10708 {
10709         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10710         return WERR_NOT_SUPPORTED;
10711 }
10712
10713 /****************************************************************
10714  _spoolss_DeletePerMachineConnection
10715 ****************************************************************/
10716
10717 WERROR _spoolss_DeletePerMachineConnection(struct pipes_struct *p,
10718                                            struct spoolss_DeletePerMachineConnection *r)
10719 {
10720         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10721         return WERR_NOT_SUPPORTED;
10722 }
10723
10724 /****************************************************************
10725  _spoolss_EnumPerMachineConnections
10726 ****************************************************************/
10727
10728 WERROR _spoolss_EnumPerMachineConnections(struct pipes_struct *p,
10729                                           struct spoolss_EnumPerMachineConnections *r)
10730 {
10731         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10732         return WERR_NOT_SUPPORTED;
10733 }
10734
10735 /****************************************************************
10736  _spoolss_5a
10737 ****************************************************************/
10738
10739 WERROR _spoolss_5a(struct pipes_struct *p,
10740                    struct spoolss_5a *r)
10741 {
10742         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10743         return WERR_NOT_SUPPORTED;
10744 }
10745
10746 /****************************************************************
10747  _spoolss_5b
10748 ****************************************************************/
10749
10750 WERROR _spoolss_5b(struct pipes_struct *p,
10751                    struct spoolss_5b *r)
10752 {
10753         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10754         return WERR_NOT_SUPPORTED;
10755 }
10756
10757 /****************************************************************
10758  _spoolss_5c
10759 ****************************************************************/
10760
10761 WERROR _spoolss_5c(struct pipes_struct *p,
10762                    struct spoolss_5c *r)
10763 {
10764         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10765         return WERR_NOT_SUPPORTED;
10766 }
10767
10768 /****************************************************************
10769  _spoolss_5d
10770 ****************************************************************/
10771
10772 WERROR _spoolss_5d(struct pipes_struct *p,
10773                    struct spoolss_5d *r)
10774 {
10775         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10776         return WERR_NOT_SUPPORTED;
10777 }
10778
10779 /****************************************************************
10780  _spoolss_5e
10781 ****************************************************************/
10782
10783 WERROR _spoolss_5e(struct pipes_struct *p,
10784                    struct spoolss_5e *r)
10785 {
10786         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10787         return WERR_NOT_SUPPORTED;
10788 }
10789
10790 /****************************************************************
10791  _spoolss_5f
10792 ****************************************************************/
10793
10794 WERROR _spoolss_5f(struct pipes_struct *p,
10795                    struct spoolss_5f *r)
10796 {
10797         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10798         return WERR_NOT_SUPPORTED;
10799 }
10800
10801 /****************************************************************
10802  _spoolss_60
10803 ****************************************************************/
10804
10805 WERROR _spoolss_60(struct pipes_struct *p,
10806                    struct spoolss_60 *r)
10807 {
10808         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10809         return WERR_NOT_SUPPORTED;
10810 }
10811
10812 /****************************************************************
10813  _spoolss_61
10814 ****************************************************************/
10815
10816 WERROR _spoolss_61(struct pipes_struct *p,
10817                    struct spoolss_61 *r)
10818 {
10819         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10820         return WERR_NOT_SUPPORTED;
10821 }
10822
10823 /****************************************************************
10824  _spoolss_62
10825 ****************************************************************/
10826
10827 WERROR _spoolss_62(struct pipes_struct *p,
10828                    struct spoolss_62 *r)
10829 {
10830         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10831         return WERR_NOT_SUPPORTED;
10832 }
10833
10834 /****************************************************************
10835  _spoolss_63
10836 ****************************************************************/
10837
10838 WERROR _spoolss_63(struct pipes_struct *p,
10839                    struct spoolss_63 *r)
10840 {
10841         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10842         return WERR_NOT_SUPPORTED;
10843 }
10844
10845 /****************************************************************
10846  _spoolss_64
10847 ****************************************************************/
10848
10849 WERROR _spoolss_64(struct pipes_struct *p,
10850                    struct spoolss_64 *r)
10851 {
10852         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10853         return WERR_NOT_SUPPORTED;
10854 }
10855
10856 /****************************************************************
10857  _spoolss_65
10858 ****************************************************************/
10859
10860 WERROR _spoolss_65(struct pipes_struct *p,
10861                    struct spoolss_65 *r)
10862 {
10863         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10864         return WERR_NOT_SUPPORTED;
10865 }
10866
10867 /****************************************************************
10868  _spoolss_GetCorePrinterDrivers
10869 ****************************************************************/
10870
10871 WERROR _spoolss_GetCorePrinterDrivers(struct pipes_struct *p,
10872                                       struct spoolss_GetCorePrinterDrivers *r)
10873 {
10874         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10875         return WERR_NOT_SUPPORTED;
10876 }
10877
10878 /****************************************************************
10879  _spoolss_67
10880 ****************************************************************/
10881
10882 WERROR _spoolss_67(struct pipes_struct *p,
10883                    struct spoolss_67 *r)
10884 {
10885         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10886         return WERR_NOT_SUPPORTED;
10887 }
10888
10889 /****************************************************************
10890  _spoolss_GetPrinterDriverPackagePath
10891 ****************************************************************/
10892
10893 WERROR _spoolss_GetPrinterDriverPackagePath(struct pipes_struct *p,
10894                                             struct spoolss_GetPrinterDriverPackagePath *r)
10895 {
10896         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10897         return WERR_NOT_SUPPORTED;
10898 }
10899
10900 /****************************************************************
10901  _spoolss_69
10902 ****************************************************************/
10903
10904 WERROR _spoolss_69(struct pipes_struct *p,
10905                    struct spoolss_69 *r)
10906 {
10907         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10908         return WERR_NOT_SUPPORTED;
10909 }
10910
10911 /****************************************************************
10912  _spoolss_6a
10913 ****************************************************************/
10914
10915 WERROR _spoolss_6a(struct pipes_struct *p,
10916                    struct spoolss_6a *r)
10917 {
10918         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10919         return WERR_NOT_SUPPORTED;
10920 }
10921
10922 /****************************************************************
10923  _spoolss_6b
10924 ****************************************************************/
10925
10926 WERROR _spoolss_6b(struct pipes_struct *p,
10927                    struct spoolss_6b *r)
10928 {
10929         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10930         return WERR_NOT_SUPPORTED;
10931 }
10932
10933 /****************************************************************
10934  _spoolss_6c
10935 ****************************************************************/
10936
10937 WERROR _spoolss_6c(struct pipes_struct *p,
10938                    struct spoolss_6c *r)
10939 {
10940         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10941         return WERR_NOT_SUPPORTED;
10942 }
10943
10944 /****************************************************************
10945  _spoolss_6d
10946 ****************************************************************/
10947
10948 WERROR _spoolss_6d(struct pipes_struct *p,
10949                    struct spoolss_6d *r)
10950 {
10951         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10952         return WERR_NOT_SUPPORTED;
10953 }