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         struct spoolss_UserLevel1 level1;
1636         WERROR werr;
1637
1638         ZERO_STRUCT(level1);
1639
1640         e.in.printername        = r->in.printername;
1641         e.in.datatype           = r->in.datatype;
1642         e.in.devmode_ctr        = r->in.devmode_ctr;
1643         e.in.access_mask        = r->in.access_mask;
1644         e.in.userlevel_ctr.level                = 1;
1645         e.in.userlevel_ctr.user_info.level1     = &level1;
1646
1647         e.out.handle            = r->out.handle;
1648
1649         werr = _spoolss_OpenPrinterEx(p, &e);
1650
1651         if (W_ERROR_EQUAL(werr, WERR_INVALID_PARAM)) {
1652                 /* OpenPrinterEx returns this for a bad
1653                  * printer name. We must return WERR_INVALID_PRINTER_NAME
1654                  * instead.
1655                  */
1656                 werr = WERR_INVALID_PRINTER_NAME;
1657         }
1658
1659         return werr;
1660 }
1661
1662 static WERROR copy_devicemode(TALLOC_CTX *mem_ctx,
1663                               struct spoolss_DeviceMode *orig,
1664                               struct spoolss_DeviceMode **dest)
1665 {
1666         struct spoolss_DeviceMode *dm;
1667
1668         dm = talloc(mem_ctx, struct spoolss_DeviceMode);
1669         if (!dm) {
1670                 return WERR_NOMEM;
1671         }
1672
1673         /* copy all values, then duplicate strings and structs */
1674         *dm = *orig;
1675
1676         dm->devicename = talloc_strdup(dm, orig->devicename);
1677         if (!dm->devicename) {
1678                 return WERR_NOMEM;
1679         }
1680         dm->formname = talloc_strdup(dm, orig->formname);
1681         if (!dm->formname) {
1682                 return WERR_NOMEM;
1683         }
1684         if (orig->driverextra_data.data) {
1685                 dm->driverextra_data.data =
1686                         (uint8_t *) talloc_memdup(dm, orig->driverextra_data.data,
1687                                         orig->driverextra_data.length);
1688                 if (!dm->driverextra_data.data) {
1689                         return WERR_NOMEM;
1690                 }
1691         }
1692
1693         *dest = dm;
1694         return WERR_OK;
1695 }
1696
1697 /****************************************************************
1698  _spoolss_OpenPrinterEx
1699 ****************************************************************/
1700
1701 WERROR _spoolss_OpenPrinterEx(struct pipes_struct *p,
1702                               struct spoolss_OpenPrinterEx *r)
1703 {
1704         int snum;
1705         char *raddr;
1706         char *rhost;
1707         struct printer_handle *Printer=NULL;
1708         WERROR result;
1709         int rc;
1710
1711         if (!r->in.printername) {
1712                 return WERR_INVALID_PARAM;
1713         }
1714
1715         if (!*r->in.printername) {
1716                 return WERR_INVALID_PARAM;
1717         }
1718
1719         if (r->in.userlevel_ctr.level > 3) {
1720                 return WERR_INVALID_PARAM;
1721         }
1722         if ((r->in.userlevel_ctr.level == 1 && !r->in.userlevel_ctr.user_info.level1) ||
1723             (r->in.userlevel_ctr.level == 2 && !r->in.userlevel_ctr.user_info.level2) ||
1724             (r->in.userlevel_ctr.level == 3 && !r->in.userlevel_ctr.user_info.level3)) {
1725                 return WERR_INVALID_PARAM;
1726         }
1727
1728         /* some sanity check because you can open a printer or a print server */
1729         /* aka: \\server\printer or \\server */
1730
1731         DEBUGADD(3,("checking name: %s\n", r->in.printername));
1732
1733         result = open_printer_hnd(p, r->out.handle, r->in.printername, 0);
1734         if (!W_ERROR_IS_OK(result)) {
1735                 DEBUG(0,("_spoolss_OpenPrinterEx: Cannot open a printer handle "
1736                         "for printer %s\n", r->in.printername));
1737                 ZERO_STRUCTP(r->out.handle);
1738                 return result;
1739         }
1740
1741         Printer = find_printer_index_by_hnd(p, r->out.handle);
1742         if ( !Printer ) {
1743                 DEBUG(0,("_spoolss_OpenPrinterEx: logic error.  Can't find printer "
1744                         "handle we created for printer %s\n", r->in.printername));
1745                 close_printer_handle(p, r->out.handle);
1746                 ZERO_STRUCTP(r->out.handle);
1747                 return WERR_INVALID_PARAM;
1748         }
1749
1750         /*
1751          * First case: the user is opening the print server:
1752          *
1753          * Disallow MS AddPrinterWizard if parameter disables it. A Win2k
1754          * client 1st tries an OpenPrinterEx with access==0, MUST be allowed.
1755          *
1756          * Then both Win2k and WinNT clients try an OpenPrinterEx with
1757          * SERVER_ALL_ACCESS, which we allow only if the user is root (uid=0)
1758          * or if the user is listed in the smb.conf printer admin parameter.
1759          *
1760          * Then they try OpenPrinterEx with SERVER_READ which we allow. This lets the
1761          * client view printer folder, but does not show the MSAPW.
1762          *
1763          * Note: this test needs code to check access rights here too. Jeremy
1764          * could you look at this?
1765          *
1766          * Second case: the user is opening a printer:
1767          * NT doesn't let us connect to a printer if the connecting user
1768          * doesn't have print permission.
1769          *
1770          * Third case: user is opening a Port Monitor
1771          * access checks same as opening a handle to the print server.
1772          */
1773
1774         switch (Printer->printer_type )
1775         {
1776         case SPLHND_SERVER:
1777         case SPLHND_PORTMON_TCP:
1778         case SPLHND_PORTMON_LOCAL:
1779                 /* Printserver handles use global struct... */
1780
1781                 snum = -1;
1782
1783                 /* Map standard access rights to object specific access rights */
1784
1785                 se_map_standard(&r->in.access_mask,
1786                                 &printserver_std_mapping);
1787
1788                 /* Deny any object specific bits that don't apply to print
1789                    servers (i.e printer and job specific bits) */
1790
1791                 r->in.access_mask &= SEC_MASK_SPECIFIC;
1792
1793                 if (r->in.access_mask &
1794                     ~(SERVER_ACCESS_ADMINISTER | SERVER_ACCESS_ENUMERATE)) {
1795                         DEBUG(3, ("access DENIED for non-printserver bits\n"));
1796                         close_printer_handle(p, r->out.handle);
1797                         ZERO_STRUCTP(r->out.handle);
1798                         return WERR_ACCESS_DENIED;
1799                 }
1800
1801                 /* Allow admin access */
1802
1803                 if ( r->in.access_mask & SERVER_ACCESS_ADMINISTER )
1804                 {
1805                         if (!lp_ms_add_printer_wizard()) {
1806                                 close_printer_handle(p, r->out.handle);
1807                                 ZERO_STRUCTP(r->out.handle);
1808                                 return WERR_ACCESS_DENIED;
1809                         }
1810
1811                         /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
1812                            and not a printer admin, then fail */
1813
1814                         if ((p->session_info->unix_token->uid != sec_initial_uid()) &&
1815                             !security_token_has_privilege(p->session_info->security_token, SEC_PRIV_PRINT_OPERATOR) &&
1816                             !nt_token_check_sid(&global_sid_Builtin_Print_Operators,
1817                                                 p->session_info->security_token)) {
1818                                 close_printer_handle(p, r->out.handle);
1819                                 ZERO_STRUCTP(r->out.handle);
1820                                 DEBUG(3,("access DENIED as user is not root, "
1821                                         "has no printoperator privilege, "
1822                                         "not a member of the printoperator builtin group and "
1823                                         "is not in printer admin list"));
1824                                 return WERR_ACCESS_DENIED;
1825                         }
1826
1827                         r->in.access_mask = SERVER_ACCESS_ADMINISTER;
1828                 }
1829                 else
1830                 {
1831                         r->in.access_mask = SERVER_ACCESS_ENUMERATE;
1832                 }
1833
1834                 DEBUG(4,("Setting print server access = %s\n", (r->in.access_mask == SERVER_ACCESS_ADMINISTER)
1835                         ? "SERVER_ACCESS_ADMINISTER" : "SERVER_ACCESS_ENUMERATE" ));
1836
1837                 /* We fall through to return WERR_OK */
1838                 break;
1839
1840         case SPLHND_PRINTER:
1841                 /* NT doesn't let us connect to a printer if the connecting user
1842                    doesn't have print permission.  */
1843
1844                 if (!get_printer_snum(p, r->out.handle, &snum, NULL)) {
1845                         close_printer_handle(p, r->out.handle);
1846                         ZERO_STRUCTP(r->out.handle);
1847                         return WERR_BADFID;
1848                 }
1849
1850                 if (r->in.access_mask == SEC_FLAG_MAXIMUM_ALLOWED) {
1851                         r->in.access_mask = PRINTER_ACCESS_ADMINISTER;
1852                 }
1853
1854                 se_map_standard(&r->in.access_mask, &printer_std_mapping);
1855
1856                 /* map an empty access mask to the minimum access mask */
1857                 if (r->in.access_mask == 0x0)
1858                         r->in.access_mask = PRINTER_ACCESS_USE;
1859
1860                 /*
1861                  * If we are not serving the printer driver for this printer,
1862                  * map PRINTER_ACCESS_ADMINISTER to PRINTER_ACCESS_USE.  This
1863                  * will keep NT clients happy  --jerry
1864                  */
1865
1866                 if (lp_use_client_driver(snum)
1867                         && (r->in.access_mask & PRINTER_ACCESS_ADMINISTER))
1868                 {
1869                         r->in.access_mask = PRINTER_ACCESS_USE;
1870                 }
1871
1872                 /* check smb.conf parameters and the the sec_desc */
1873                 raddr = tsocket_address_inet_addr_string(p->remote_address,
1874                                                          p->mem_ctx);
1875                 if (raddr == NULL) {
1876                         return WERR_NOMEM;
1877                 }
1878
1879                 rc = get_remote_hostname(p->remote_address,
1880                                          &rhost,
1881                                          p->mem_ctx);
1882                 if (rc < 0) {
1883                         return WERR_NOMEM;
1884                 }
1885                 if (strequal(rhost, "UNKNOWN")) {
1886                         rhost = raddr;
1887                 }
1888
1889                 if (!allow_access(lp_hostsdeny(snum), lp_hostsallow(snum),
1890                                   rhost, raddr)) {
1891                         DEBUG(3, ("access DENIED (hosts allow/deny) for printer open\n"));
1892                         ZERO_STRUCTP(r->out.handle);
1893                         return WERR_ACCESS_DENIED;
1894                 }
1895
1896                 if (!user_ok_token(uidtoname(p->session_info->unix_token->uid), NULL,
1897                                    p->session_info->security_token, snum) ||
1898                     !print_access_check(p->session_info,
1899                                         p->msg_ctx,
1900                                         snum,
1901                                         r->in.access_mask)) {
1902                         DEBUG(3, ("access DENIED for printer open\n"));
1903                         close_printer_handle(p, r->out.handle);
1904                         ZERO_STRUCTP(r->out.handle);
1905                         return WERR_ACCESS_DENIED;
1906                 }
1907
1908                 if ((r->in.access_mask & SEC_MASK_SPECIFIC)& ~(PRINTER_ACCESS_ADMINISTER|PRINTER_ACCESS_USE)) {
1909                         DEBUG(3, ("access DENIED for printer open - unknown bits\n"));
1910                         close_printer_handle(p, r->out.handle);
1911                         ZERO_STRUCTP(r->out.handle);
1912                         return WERR_ACCESS_DENIED;
1913                 }
1914
1915                 if (r->in.access_mask & PRINTER_ACCESS_ADMINISTER)
1916                         r->in.access_mask = PRINTER_ACCESS_ADMINISTER;
1917                 else
1918                         r->in.access_mask = PRINTER_ACCESS_USE;
1919
1920                 DEBUG(4,("Setting printer access = %s\n", (r->in.access_mask == PRINTER_ACCESS_ADMINISTER)
1921                         ? "PRINTER_ACCESS_ADMINISTER" : "PRINTER_ACCESS_USE" ));
1922
1923                 winreg_create_printer_internal(p->mem_ctx,
1924                                       get_session_info_system(),
1925                                       p->msg_ctx,
1926                                       lp_const_servicename(snum));
1927
1928                 break;
1929
1930         default:
1931                 /* sanity check to prevent programmer error */
1932                 ZERO_STRUCTP(r->out.handle);
1933                 return WERR_BADFID;
1934         }
1935
1936         Printer->access_granted = r->in.access_mask;
1937
1938         /*
1939          * If the client sent a devmode in the OpenPrinter() call, then
1940          * save it here in case we get a job submission on this handle
1941          */
1942
1943          if ((Printer->printer_type != SPLHND_SERVER)
1944           && (r->in.devmode_ctr.devmode != NULL)) {
1945                 copy_devicemode(NULL, r->in.devmode_ctr.devmode,
1946                                 &Printer->devmode);
1947          }
1948
1949         return WERR_OK;
1950 }
1951
1952 /****************************************************************
1953  _spoolss_ClosePrinter
1954 ****************************************************************/
1955
1956 WERROR _spoolss_ClosePrinter(struct pipes_struct *p,
1957                              struct spoolss_ClosePrinter *r)
1958 {
1959         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
1960
1961         if (Printer && Printer->document_started) {
1962                 struct spoolss_EndDocPrinter e;
1963
1964                 e.in.handle = r->in.handle;
1965
1966                 _spoolss_EndDocPrinter(p, &e);
1967         }
1968
1969         if (!close_printer_handle(p, r->in.handle))
1970                 return WERR_BADFID;
1971
1972         /* clear the returned printer handle.  Observed behavior
1973            from Win2k server.  Don't think this really matters.
1974            Previous code just copied the value of the closed
1975            handle.    --jerry */
1976
1977         ZERO_STRUCTP(r->out.handle);
1978
1979         return WERR_OK;
1980 }
1981
1982 /****************************************************************
1983  _spoolss_DeletePrinter
1984 ****************************************************************/
1985
1986 WERROR _spoolss_DeletePrinter(struct pipes_struct *p,
1987                               struct spoolss_DeletePrinter *r)
1988 {
1989         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
1990         WERROR result;
1991         int snum;
1992
1993         if (Printer && Printer->document_started) {
1994                 struct spoolss_EndDocPrinter e;
1995
1996                 e.in.handle = r->in.handle;
1997
1998                 _spoolss_EndDocPrinter(p, &e);
1999         }
2000
2001         if (get_printer_snum(p, r->in.handle, &snum, NULL)) {
2002                 winreg_delete_printer_key_internal(p->mem_ctx,
2003                                           get_session_info_system(),
2004                                           p->msg_ctx,
2005                                           lp_const_servicename(snum),
2006                                           "");
2007         }
2008
2009         result = delete_printer_handle(p, r->in.handle);
2010
2011         return result;
2012 }
2013
2014 /*******************************************************************
2015  * static function to lookup the version id corresponding to an
2016  * long architecture string
2017  ******************************************************************/
2018
2019 static const struct print_architecture_table_node archi_table[]= {
2020
2021         {"Windows 4.0",          SPL_ARCH_WIN40,        0 },
2022         {"Windows NT x86",       SPL_ARCH_W32X86,       2 },
2023         {"Windows NT R4000",     SPL_ARCH_W32MIPS,      2 },
2024         {"Windows NT Alpha_AXP", SPL_ARCH_W32ALPHA,     2 },
2025         {"Windows NT PowerPC",   SPL_ARCH_W32PPC,       2 },
2026         {"Windows IA64",         SPL_ARCH_IA64,         3 },
2027         {"Windows x64",          SPL_ARCH_X64,          3 },
2028         {NULL,                   "",            -1 }
2029 };
2030
2031 static const int drv_cversion[] = {SPOOLSS_DRIVER_VERSION_9X,
2032                                    SPOOLSS_DRIVER_VERSION_NT35,
2033                                    SPOOLSS_DRIVER_VERSION_NT4,
2034                                    SPOOLSS_DRIVER_VERSION_200X,
2035                                    -1};
2036
2037 static int get_version_id(const char *arch)
2038 {
2039         int i;
2040
2041         for (i=0; archi_table[i].long_archi != NULL; i++)
2042         {
2043                 if (strcmp(arch, archi_table[i].long_archi) == 0)
2044                         return (archi_table[i].version);
2045         }
2046
2047         return -1;
2048 }
2049
2050 /****************************************************************
2051  _spoolss_DeletePrinterDriver
2052 ****************************************************************/
2053
2054 WERROR _spoolss_DeletePrinterDriver(struct pipes_struct *p,
2055                                     struct spoolss_DeletePrinterDriver *r)
2056 {
2057
2058         struct spoolss_DriverInfo8 *info = NULL;
2059         int                             version;
2060         WERROR                          status;
2061         struct dcerpc_binding_handle *b;
2062         TALLOC_CTX *tmp_ctx = NULL;
2063         int i;
2064         bool found;
2065
2066         /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
2067            and not a printer admin, then fail */
2068
2069         if ((p->session_info->unix_token->uid != sec_initial_uid()) &&
2070             !security_token_has_privilege(p->session_info->security_token,
2071                                           SEC_PRIV_PRINT_OPERATOR)) {
2072                 return WERR_ACCESS_DENIED;
2073         }
2074
2075         /* check that we have a valid driver name first */
2076
2077         if ((version = get_version_id(r->in.architecture)) == -1) {
2078                 return WERR_INVALID_ENVIRONMENT;
2079         }
2080
2081         tmp_ctx = talloc_new(p->mem_ctx);
2082         if (!tmp_ctx) {
2083                 return WERR_NOMEM;
2084         }
2085
2086         status = winreg_printer_binding_handle(tmp_ctx,
2087                                                get_session_info_system(),
2088                                                p->msg_ctx,
2089                                                &b);
2090         if (!W_ERROR_IS_OK(status)) {
2091                 goto done;
2092         }
2093
2094         for (found = false, i = 0; drv_cversion[i] >= 0; i++) {
2095                 status = winreg_get_driver(tmp_ctx, b,
2096                                            r->in.architecture, r->in.driver,
2097                                            drv_cversion[i], &info);
2098                 if (!W_ERROR_IS_OK(status)) {
2099                         DEBUG(5, ("skipping del of driver with version %d\n",
2100                                   drv_cversion[i]));
2101                         continue;
2102                 }
2103                 found = true;
2104
2105                 if (printer_driver_in_use(tmp_ctx, b, info)) {
2106                         status = WERR_PRINTER_DRIVER_IN_USE;
2107                         goto done;
2108                 }
2109
2110                 status = winreg_del_driver(tmp_ctx, b, info, drv_cversion[i]);
2111                 if (!W_ERROR_IS_OK(status)) {
2112                         DEBUG(0, ("failed del of driver with version %d\n",
2113                                   drv_cversion[i]));
2114                         goto done;
2115                 }
2116         }
2117         if (found == false) {
2118                 DEBUG(0, ("driver %s not found for deletion\n", r->in.driver));
2119                 status = WERR_UNKNOWN_PRINTER_DRIVER;
2120         } else {
2121                 status = WERR_OK;
2122         }
2123
2124 done:
2125         talloc_free(tmp_ctx);
2126
2127         return status;
2128 }
2129
2130 static WERROR spoolss_dpd_version(TALLOC_CTX *mem_ctx,
2131                                   struct pipes_struct *p,
2132                                   struct spoolss_DeletePrinterDriverEx *r,
2133                                   struct dcerpc_binding_handle *b,
2134                                   struct spoolss_DriverInfo8 *info)
2135 {
2136         WERROR status;
2137         bool delete_files;
2138
2139         if (printer_driver_in_use(mem_ctx, b, info)) {
2140                 status = WERR_PRINTER_DRIVER_IN_USE;
2141                 goto done;
2142         }
2143
2144         /*
2145          * we have a couple of cases to consider.
2146          * (1) Are any files in use?  If so and DPD_DELETE_ALL_FILES is set,
2147          *     then the delete should fail if **any** files overlap with
2148          *     other drivers
2149          * (2) If DPD_DELETE_UNUSED_FILES is set, then delete all
2150          *     non-overlapping files
2151          * (3) If neither DPD_DELETE_ALL_FILES nor DPD_DELETE_UNUSED_FILES
2152          *     are set, then do not delete any files
2153          * Refer to MSDN docs on DeletePrinterDriverEx() for details.
2154          */
2155
2156         delete_files = r->in.delete_flags
2157                         & (DPD_DELETE_ALL_FILES | DPD_DELETE_UNUSED_FILES);
2158
2159
2160         if (delete_files) {
2161                 bool in_use = printer_driver_files_in_use(mem_ctx, b, info);
2162                 if (in_use && (r->in.delete_flags & DPD_DELETE_ALL_FILES)) {
2163                         status = WERR_PRINTER_DRIVER_IN_USE;
2164                         goto done;
2165                 }
2166                 /*
2167                  * printer_driver_files_in_use() has trimmed overlapping files
2168                  * from info so they are not removed on DPD_DELETE_UNUSED_FILES
2169                  */
2170         }
2171
2172
2173         status = winreg_del_driver(mem_ctx, b, info, info->version);
2174         if (!W_ERROR_IS_OK(status)) {
2175                 goto done;
2176         }
2177
2178         /*
2179          * now delete any associated files if delete_files is
2180          * true. Even if this part failes, we return succes
2181          * because the driver doesn not exist any more
2182          */
2183         if (delete_files) {
2184                 delete_driver_files(p->session_info, info);
2185         }
2186
2187 done:
2188         return status;
2189 }
2190
2191 /****************************************************************
2192  _spoolss_DeletePrinterDriverEx
2193 ****************************************************************/
2194
2195 WERROR _spoolss_DeletePrinterDriverEx(struct pipes_struct *p,
2196                                       struct spoolss_DeletePrinterDriverEx *r)
2197 {
2198         struct spoolss_DriverInfo8 *info = NULL;
2199         WERROR                          status;
2200         struct dcerpc_binding_handle *b;
2201         TALLOC_CTX *tmp_ctx = NULL;
2202         int i;
2203         bool found;
2204
2205         /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
2206            and not a printer admin, then fail */
2207
2208         if ((p->session_info->unix_token->uid != sec_initial_uid()) &&
2209             !security_token_has_privilege(p->session_info->security_token,
2210                                           SEC_PRIV_PRINT_OPERATOR)) {
2211                 return WERR_ACCESS_DENIED;
2212         }
2213
2214         /* check that we have a valid driver name first */
2215         if (get_version_id(r->in.architecture) == -1) {
2216                 /* this is what NT returns */
2217                 return WERR_INVALID_ENVIRONMENT;
2218         }
2219
2220         tmp_ctx = talloc_new(p->mem_ctx);
2221         if (!tmp_ctx) {
2222                 return WERR_NOMEM;
2223         }
2224
2225         status = winreg_printer_binding_handle(tmp_ctx,
2226                                                get_session_info_system(),
2227                                                p->msg_ctx,
2228                                                &b);
2229         if (!W_ERROR_IS_OK(status)) {
2230                 goto done;
2231         }
2232
2233         for (found = false, i = 0; drv_cversion[i] >= 0; i++) {
2234                 if ((r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION)
2235                  && (drv_cversion[i] != r->in.version)) {
2236                         continue;
2237                 }
2238
2239                 /* check if a driver with this version exists before delete */
2240                 status = winreg_get_driver(tmp_ctx, b,
2241                                            r->in.architecture, r->in.driver,
2242                                            drv_cversion[i], &info);
2243                 if (!W_ERROR_IS_OK(status)) {
2244                         DEBUG(5, ("skipping del of driver with version %d\n",
2245                                   drv_cversion[i]));
2246                         continue;
2247                 }
2248                 found = true;
2249
2250                 status = spoolss_dpd_version(tmp_ctx, p, r, b, info);
2251                 if (!W_ERROR_IS_OK(status)) {
2252                         DEBUG(0, ("failed to delete driver with version %d\n",
2253                                   drv_cversion[i]));
2254                         goto done;
2255                 }
2256         }
2257         if (found == false) {
2258                 DEBUG(0, ("driver %s not found for deletion\n", r->in.driver));
2259                 status = WERR_UNKNOWN_PRINTER_DRIVER;
2260         } else {
2261                 status = WERR_OK;
2262         }
2263
2264 done:
2265         talloc_free(tmp_ctx);
2266         return status;
2267 }
2268
2269
2270 /********************************************************************
2271  GetPrinterData on a printer server Handle.
2272 ********************************************************************/
2273
2274 static WERROR getprinterdata_printer_server(TALLOC_CTX *mem_ctx,
2275                                             const char *value,
2276                                             enum winreg_Type *type,
2277                                             union spoolss_PrinterData *data)
2278 {
2279         DEBUG(8,("getprinterdata_printer_server:%s\n", value));
2280
2281         if (!strcasecmp_m(value, "W3SvcInstalled")) {
2282                 *type = REG_DWORD;
2283                 SIVAL(&data->value, 0, 0x00);
2284                 return WERR_OK;
2285         }
2286
2287         if (!strcasecmp_m(value, "BeepEnabled")) {
2288                 *type = REG_DWORD;
2289                 SIVAL(&data->value, 0, 0x00);
2290                 return WERR_OK;
2291         }
2292
2293         if (!strcasecmp_m(value, "EventLog")) {
2294                 *type = REG_DWORD;
2295                 /* formally was 0x1b */
2296                 SIVAL(&data->value, 0, 0x00);
2297                 return WERR_OK;
2298         }
2299
2300         if (!strcasecmp_m(value, "NetPopup")) {
2301                 *type = REG_DWORD;
2302                 SIVAL(&data->value, 0, 0x00);
2303                 return WERR_OK;
2304         }
2305
2306         if (!strcasecmp_m(value, "MajorVersion")) {
2307                 *type = REG_DWORD;
2308
2309                 /* Windows NT 4.0 seems to not allow uploading of drivers
2310                    to a server that reports 0x3 as the MajorVersion.
2311                    need to investigate more how Win2k gets around this .
2312                    -- jerry */
2313
2314                 if (RA_WINNT == get_remote_arch()) {
2315                         SIVAL(&data->value, 0, 0x02);
2316                 } else {
2317                         SIVAL(&data->value, 0, 0x03);
2318                 }
2319
2320                 return WERR_OK;
2321         }
2322
2323         if (!strcasecmp_m(value, "MinorVersion")) {
2324                 *type = REG_DWORD;
2325                 SIVAL(&data->value, 0, 0x00);
2326                 return WERR_OK;
2327         }
2328
2329         /* REG_BINARY
2330          *  uint32_t size        = 0x114
2331          *  uint32_t major       = 5
2332          *  uint32_t minor       = [0|1]
2333          *  uint32_t build       = [2195|2600]
2334          *  extra unicode string = e.g. "Service Pack 3"
2335          */
2336         if (!strcasecmp_m(value, "OSVersion")) {
2337                 DATA_BLOB blob;
2338                 enum ndr_err_code ndr_err;
2339                 struct spoolss_OSVersion os;
2340
2341                 os.major                = lp_parm_int(GLOBAL_SECTION_SNUM,
2342                                                       "spoolss", "os_major", 5);
2343                                                       /* Windows 2000 == 5.0 */
2344                 os.minor                = lp_parm_int(GLOBAL_SECTION_SNUM,
2345                                                       "spoolss", "os_minor", 0);
2346                 os.build                = lp_parm_int(GLOBAL_SECTION_SNUM,
2347                                                       "spoolss", "os_build", 2195);
2348                 os.extra_string         = "";   /* leave extra string empty */
2349
2350                 ndr_err = ndr_push_struct_blob(&blob, mem_ctx, &os,
2351                         (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion);
2352                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2353                         return WERR_GENERAL_FAILURE;
2354                 }
2355
2356                 if (DEBUGLEVEL >= 10) {
2357                         NDR_PRINT_DEBUG(spoolss_OSVersion, &os);
2358                 }
2359
2360                 *type = REG_BINARY;
2361                 data->binary = blob;
2362
2363                 return WERR_OK;
2364         }
2365
2366
2367         if (!strcasecmp_m(value, "DefaultSpoolDirectory")) {
2368                 *type = REG_SZ;
2369
2370                 data->string = talloc_strdup(mem_ctx, "C:\\PRINTERS");
2371                 W_ERROR_HAVE_NO_MEMORY(data->string);
2372
2373                 return WERR_OK;
2374         }
2375
2376         if (!strcasecmp_m(value, "Architecture")) {
2377                 *type = REG_SZ;
2378                 data->string = talloc_strdup(mem_ctx,
2379                         lp_parm_const_string(GLOBAL_SECTION_SNUM, "spoolss", "architecture", SPOOLSS_ARCHITECTURE_NT_X86));
2380                 W_ERROR_HAVE_NO_MEMORY(data->string);
2381
2382                 return WERR_OK;
2383         }
2384
2385         if (!strcasecmp_m(value, "DsPresent")) {
2386                 *type = REG_DWORD;
2387
2388                 /* only show the publish check box if we are a
2389                    member of a AD domain */
2390
2391                 if (lp_security() == SEC_ADS) {
2392                         SIVAL(&data->value, 0, 0x01);
2393                 } else {
2394                         SIVAL(&data->value, 0, 0x00);
2395                 }
2396                 return WERR_OK;
2397         }
2398
2399         if (!strcasecmp_m(value, "DNSMachineName")) {
2400                 const char *hostname = get_mydnsfullname();
2401
2402                 if (!hostname) {
2403                         return WERR_BADFILE;
2404                 }
2405
2406                 *type = REG_SZ;
2407                 data->string = talloc_strdup(mem_ctx, hostname);
2408                 W_ERROR_HAVE_NO_MEMORY(data->string);
2409
2410                 return WERR_OK;
2411         }
2412
2413         *type = REG_NONE;
2414
2415         return WERR_INVALID_PARAM;
2416 }
2417
2418 /****************************************************************
2419  _spoolss_GetPrinterData
2420 ****************************************************************/
2421
2422 WERROR _spoolss_GetPrinterData(struct pipes_struct *p,
2423                                struct spoolss_GetPrinterData *r)
2424 {
2425         struct spoolss_GetPrinterDataEx r2;
2426
2427         r2.in.handle            = r->in.handle;
2428         r2.in.key_name          = "PrinterDriverData";
2429         r2.in.value_name        = r->in.value_name;
2430         r2.in.offered           = r->in.offered;
2431         r2.out.type             = r->out.type;
2432         r2.out.data             = r->out.data;
2433         r2.out.needed           = r->out.needed;
2434
2435         return _spoolss_GetPrinterDataEx(p, &r2);
2436 }
2437
2438 /*********************************************************
2439  Connect to the client machine.
2440 **********************************************************/
2441
2442 static bool spoolss_connect_to_client(struct rpc_pipe_client **pp_pipe,
2443                         struct sockaddr_storage *client_ss, const char *remote_machine)
2444 {
2445         NTSTATUS ret;
2446         struct cli_state *the_cli;
2447         struct sockaddr_storage rm_addr;
2448         char addr[INET6_ADDRSTRLEN];
2449
2450         if ( is_zero_addr(client_ss) ) {
2451                 DEBUG(2,("spoolss_connect_to_client: resolving %s\n",
2452                         remote_machine));
2453                 if ( !resolve_name( remote_machine, &rm_addr, 0x20, false) ) {
2454                         DEBUG(2,("spoolss_connect_to_client: Can't resolve address for %s\n", remote_machine));
2455                         return false;
2456                 }
2457                 print_sockaddr(addr, sizeof(addr), &rm_addr);
2458         } else {
2459                 rm_addr = *client_ss;
2460                 print_sockaddr(addr, sizeof(addr), &rm_addr);
2461                 DEBUG(5,("spoolss_connect_to_client: Using address %s (no name resolution necessary)\n",
2462                         addr));
2463         }
2464
2465         if (ismyaddr((struct sockaddr *)(void *)&rm_addr)) {
2466                 DEBUG(0,("spoolss_connect_to_client: Machine %s is one of our addresses. Cannot add to ourselves.\n",
2467                         addr));
2468                 return false;
2469         }
2470
2471         /* setup the connection */
2472         ret = cli_full_connection( &the_cli, lp_netbios_name(), remote_machine,
2473                 &rm_addr, 0, "IPC$", "IPC",
2474                 "", /* username */
2475                 "", /* domain */
2476                 "", /* password */
2477                 0, lp_client_signing());
2478
2479         if ( !NT_STATUS_IS_OK( ret ) ) {
2480                 DEBUG(2,("spoolss_connect_to_client: connection to [%s] failed!\n",
2481                         remote_machine ));
2482                 return false;
2483         }
2484
2485         if ( smbXcli_conn_protocol(the_cli->conn) != PROTOCOL_NT1 ) {
2486                 DEBUG(0,("spoolss_connect_to_client: machine %s didn't negotiate NT protocol.\n", remote_machine));
2487                 cli_shutdown(the_cli);
2488                 return false;
2489         }
2490
2491         /*
2492          * Ok - we have an anonymous connection to the IPC$ share.
2493          * Now start the NT Domain stuff :-).
2494          */
2495
2496         ret = cli_rpc_pipe_open_noauth(the_cli, &ndr_table_spoolss.syntax_id, pp_pipe);
2497         if (!NT_STATUS_IS_OK(ret)) {
2498                 DEBUG(2,("spoolss_connect_to_client: unable to open the spoolss pipe on machine %s. Error was : %s.\n",
2499                         remote_machine, nt_errstr(ret)));
2500                 cli_shutdown(the_cli);
2501                 return false;
2502         }
2503
2504         return true;
2505 }
2506
2507 /***************************************************************************
2508  Connect to the client.
2509 ****************************************************************************/
2510
2511 static bool srv_spoolss_replyopenprinter(int snum, const char *printer,
2512                                         uint32_t localprinter,
2513                                         enum winreg_Type type,
2514                                         struct policy_handle *handle,
2515                                         struct notify_back_channel **_chan,
2516                                         struct sockaddr_storage *client_ss,
2517                                         struct messaging_context *msg_ctx)
2518 {
2519         WERROR result;
2520         NTSTATUS status;
2521         struct notify_back_channel *chan;
2522
2523         for (chan = back_channels; chan; chan = chan->next) {
2524                 if (memcmp(&chan->client_address, client_ss,
2525                            sizeof(struct sockaddr_storage)) == 0) {
2526                         break;
2527                 }
2528         }
2529
2530         /*
2531          * If it's the first connection, contact the client
2532          * and connect to the IPC$ share anonymously
2533          */
2534         if (!chan) {
2535                 fstring unix_printer;
2536
2537                 /* the +2 is to strip the leading 2 backslashs */
2538                 fstrcpy(unix_printer, printer + 2);
2539
2540                 chan = talloc_zero(NULL, struct notify_back_channel);
2541                 if (!chan) {
2542                         return false;
2543                 }
2544                 chan->client_address = *client_ss;
2545
2546                 if (!spoolss_connect_to_client(&chan->cli_pipe, client_ss, unix_printer)) {
2547                         TALLOC_FREE(chan);
2548                         return false;
2549                 }
2550
2551                 DLIST_ADD(back_channels, chan);
2552
2553                 messaging_register(msg_ctx, NULL, MSG_PRINTER_NOTIFY2,
2554                                    receive_notify2_message_list);
2555         }
2556
2557         if (chan->cli_pipe == NULL ||
2558             chan->cli_pipe->binding_handle == NULL) {
2559                 DEBUG(0, ("srv_spoolss_replyopenprinter: error - "
2560                         "NULL %s for printer %s\n",
2561                         chan->cli_pipe == NULL ?
2562                         "chan->cli_pipe" : "chan->cli_pipe->binding_handle",
2563                         printer));
2564                 return false;
2565         }
2566
2567         /*
2568          * Tell the specific printing tdb we want messages for this printer
2569          * by registering our PID.
2570          */
2571
2572         if (!print_notify_register_pid(snum)) {
2573                 DEBUG(0, ("Failed to register our pid for printer %s\n",
2574                           printer));
2575         }
2576
2577         status = dcerpc_spoolss_ReplyOpenPrinter(chan->cli_pipe->binding_handle,
2578                                                  talloc_tos(),
2579                                                  printer,
2580                                                  localprinter,
2581                                                  type,
2582                                                  0,
2583                                                  NULL,
2584                                                  handle,
2585                                                  &result);
2586         if (!NT_STATUS_IS_OK(status)) {
2587                 DEBUG(5, ("dcerpc_spoolss_ReplyOpenPrinter returned [%s]\n", nt_errstr(status)));
2588                 result = ntstatus_to_werror(status);
2589         } else if (!W_ERROR_IS_OK(result)) {
2590                 DEBUG(5, ("ReplyOpenPrinter returned [%s]\n", win_errstr(result)));
2591         }
2592
2593         chan->active_connections++;
2594         *_chan = chan;
2595
2596         return (W_ERROR_IS_OK(result));
2597 }
2598
2599 /****************************************************************
2600  ****************************************************************/
2601
2602 static struct spoolss_NotifyOption *dup_spoolss_NotifyOption(TALLOC_CTX *mem_ctx,
2603                                                              const struct spoolss_NotifyOption *r)
2604 {
2605         struct spoolss_NotifyOption *option;
2606         uint32_t i,k;
2607
2608         if (!r) {
2609                 return NULL;
2610         }
2611
2612         option = talloc_zero(mem_ctx, struct spoolss_NotifyOption);
2613         if (!option) {
2614                 return NULL;
2615         }
2616
2617         *option = *r;
2618
2619         if (!option->count) {
2620                 return option;
2621         }
2622
2623         option->types = talloc_zero_array(option,
2624                 struct spoolss_NotifyOptionType, option->count);
2625         if (!option->types) {
2626                 talloc_free(option);
2627                 return NULL;
2628         }
2629
2630         for (i=0; i < option->count; i++) {
2631                 option->types[i] = r->types[i];
2632
2633                 if (option->types[i].count) {
2634                         option->types[i].fields = talloc_zero_array(option,
2635                                 union spoolss_Field, option->types[i].count);
2636                         if (!option->types[i].fields) {
2637                                 talloc_free(option);
2638                                 return NULL;
2639                         }
2640                         for (k=0; k<option->types[i].count; k++) {
2641                                 option->types[i].fields[k] =
2642                                         r->types[i].fields[k];
2643                         }
2644                 }
2645         }
2646
2647         return option;
2648 }
2649
2650 /****************************************************************
2651  * _spoolss_RemoteFindFirstPrinterChangeNotifyEx
2652  *
2653  * before replying OK: status=0 a rpc call is made to the workstation
2654  * asking ReplyOpenPrinter
2655  *
2656  * in fact ReplyOpenPrinter is the changenotify equivalent on the spoolss pipe
2657  * called from api_spoolss_rffpcnex
2658 ****************************************************************/
2659
2660 WERROR _spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct pipes_struct *p,
2661                                                      struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
2662 {
2663         int snum = -1;
2664         struct spoolss_NotifyOption *option = r->in.notify_options;
2665         struct sockaddr_storage client_ss;
2666         ssize_t client_len;
2667
2668         /* store the notify value in the printer struct */
2669
2670         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
2671
2672         if (!Printer) {
2673                 DEBUG(2,("_spoolss_RemoteFindFirstPrinterChangeNotifyEx: "
2674                         "Invalid handle (%s:%u:%u).\n",
2675                         OUR_HANDLE(r->in.handle)));
2676                 return WERR_BADFID;
2677         }
2678
2679         Printer->notify.flags           = r->in.flags;
2680         Printer->notify.options         = r->in.options;
2681         Printer->notify.printerlocal    = r->in.printer_local;
2682         Printer->notify.msg_ctx         = p->msg_ctx;
2683
2684         TALLOC_FREE(Printer->notify.option);
2685         Printer->notify.option = dup_spoolss_NotifyOption(Printer, option);
2686
2687         fstrcpy(Printer->notify.localmachine, r->in.local_machine);
2688
2689         /* Connect to the client machine and send a ReplyOpenPrinter */
2690
2691         if ( Printer->printer_type == SPLHND_SERVER)
2692                 snum = -1;
2693         else if ( (Printer->printer_type == SPLHND_PRINTER) &&
2694                         !get_printer_snum(p, r->in.handle, &snum, NULL) )
2695                 return WERR_BADFID;
2696
2697         DEBUG(10,("_spoolss_RemoteFindFirstPrinterChangeNotifyEx: "
2698                   "remote_address is %s\n",
2699                   tsocket_address_string(p->remote_address, p->mem_ctx)));
2700
2701         if (!lp_print_notify_backchannel(snum)) {
2702                 DEBUG(10, ("_spoolss_RemoteFindFirstPrinterChangeNotifyEx: "
2703                         "backchannel disabled\n"));
2704                 return WERR_SERVER_UNAVAILABLE;
2705         }
2706
2707         client_len = tsocket_address_bsd_sockaddr(p->remote_address,
2708                                                   (struct sockaddr *) &client_ss,
2709                                                   sizeof(struct sockaddr_storage));
2710         if (client_len < 0) {
2711                 return WERR_NOMEM;
2712         }
2713
2714         if(!srv_spoolss_replyopenprinter(snum, Printer->notify.localmachine,
2715                                         Printer->notify.printerlocal, REG_SZ,
2716                                         &Printer->notify.cli_hnd,
2717                                         &Printer->notify.cli_chan,
2718                                         &client_ss, p->msg_ctx)) {
2719                 return WERR_SERVER_UNAVAILABLE;
2720         }
2721
2722         return WERR_OK;
2723 }
2724
2725 /*******************************************************************
2726  * fill a notify_info_data with the servername
2727  ********************************************************************/
2728
2729 static void spoolss_notify_server_name(struct messaging_context *msg_ctx,
2730                                        int snum,
2731                                        struct spoolss_Notify *data,
2732                                        print_queue_struct *queue,
2733                                        struct spoolss_PrinterInfo2 *pinfo2,
2734                                        TALLOC_CTX *mem_ctx)
2735 {
2736         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->servername);
2737 }
2738
2739 /*******************************************************************
2740  * fill a notify_info_data with the printername (not including the servername).
2741  ********************************************************************/
2742
2743 static void spoolss_notify_printer_name(struct messaging_context *msg_ctx,
2744                                         int snum,
2745                                         struct spoolss_Notify *data,
2746                                         print_queue_struct *queue,
2747                                         struct spoolss_PrinterInfo2 *pinfo2,
2748                                         TALLOC_CTX *mem_ctx)
2749 {
2750         /* the notify name should not contain the \\server\ part */
2751         const char *p = strrchr(pinfo2->printername, '\\');
2752
2753         if (!p) {
2754                 p = pinfo2->printername;
2755         } else {
2756                 p++;
2757         }
2758
2759         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, p);
2760 }
2761
2762 /*******************************************************************
2763  * fill a notify_info_data with the servicename
2764  ********************************************************************/
2765
2766 static void spoolss_notify_share_name(struct messaging_context *msg_ctx,
2767                                       int snum,
2768                                       struct spoolss_Notify *data,
2769                                       print_queue_struct *queue,
2770                                       struct spoolss_PrinterInfo2 *pinfo2,
2771                                       TALLOC_CTX *mem_ctx)
2772 {
2773         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, lp_servicename(talloc_tos(), snum));
2774 }
2775
2776 /*******************************************************************
2777  * fill a notify_info_data with the port name
2778  ********************************************************************/
2779
2780 static void spoolss_notify_port_name(struct messaging_context *msg_ctx,
2781                                      int snum,
2782                                      struct spoolss_Notify *data,
2783                                      print_queue_struct *queue,
2784                                      struct spoolss_PrinterInfo2 *pinfo2,
2785                                      TALLOC_CTX *mem_ctx)
2786 {
2787         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->portname);
2788 }
2789
2790 /*******************************************************************
2791  * fill a notify_info_data with the printername
2792  * but it doesn't exist, have to see what to do
2793  ********************************************************************/
2794
2795 static void spoolss_notify_driver_name(struct messaging_context *msg_ctx,
2796                                        int snum,
2797                                        struct spoolss_Notify *data,
2798                                        print_queue_struct *queue,
2799                                        struct spoolss_PrinterInfo2 *pinfo2,
2800                                        TALLOC_CTX *mem_ctx)
2801 {
2802         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->drivername);
2803 }
2804
2805 /*******************************************************************
2806  * fill a notify_info_data with the comment
2807  ********************************************************************/
2808
2809 static void spoolss_notify_comment(struct messaging_context *msg_ctx,
2810                                    int snum,
2811                                    struct spoolss_Notify *data,
2812                                    print_queue_struct *queue,
2813                                    struct spoolss_PrinterInfo2 *pinfo2,
2814                                    TALLOC_CTX *mem_ctx)
2815 {
2816         const char *p;
2817
2818         if (*pinfo2->comment == '\0') {
2819                 p = lp_comment(talloc_tos(), snum);
2820         } else {
2821                 p = pinfo2->comment;
2822         }
2823
2824         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, p);
2825 }
2826
2827 /*******************************************************************
2828  * fill a notify_info_data with the comment
2829  * location = "Room 1, floor 2, building 3"
2830  ********************************************************************/
2831
2832 static void spoolss_notify_location(struct messaging_context *msg_ctx,
2833                                     int snum,
2834                                     struct spoolss_Notify *data,
2835                                     print_queue_struct *queue,
2836                                     struct spoolss_PrinterInfo2 *pinfo2,
2837                                     TALLOC_CTX *mem_ctx)
2838 {
2839         const char *loc = pinfo2->location;
2840         NTSTATUS status;
2841
2842         status = printer_list_get_printer(mem_ctx,
2843                                           pinfo2->sharename,
2844                                           NULL,
2845                                           &loc,
2846                                           NULL);
2847         if (NT_STATUS_IS_OK(status)) {
2848                 if (loc == NULL) {
2849                         loc = pinfo2->location;
2850                 }
2851         }
2852
2853         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, loc);
2854 }
2855
2856 /*******************************************************************
2857  * fill a notify_info_data with the device mode
2858  * jfm:xxxx don't to it for know but that's a real problem !!!
2859  ********************************************************************/
2860
2861 static void spoolss_notify_devmode(struct messaging_context *msg_ctx,
2862                                    int snum,
2863                                    struct spoolss_Notify *data,
2864                                    print_queue_struct *queue,
2865                                    struct spoolss_PrinterInfo2 *pinfo2,
2866                                    TALLOC_CTX *mem_ctx)
2867 {
2868         /* for a dummy implementation we have to zero the fields */
2869         SETUP_SPOOLSS_NOTIFY_DATA_DEVMODE(data, NULL);
2870 }
2871
2872 /*******************************************************************
2873  * fill a notify_info_data with the separator file name
2874  ********************************************************************/
2875
2876 static void spoolss_notify_sepfile(struct messaging_context *msg_ctx,
2877                                    int snum,
2878                                    struct spoolss_Notify *data,
2879                                    print_queue_struct *queue,
2880                                    struct spoolss_PrinterInfo2 *pinfo2,
2881                                    TALLOC_CTX *mem_ctx)
2882 {
2883         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->sepfile);
2884 }
2885
2886 /*******************************************************************
2887  * fill a notify_info_data with the print processor
2888  * jfm:xxxx return always winprint to indicate we don't do anything to it
2889  ********************************************************************/
2890
2891 static void spoolss_notify_print_processor(struct messaging_context *msg_ctx,
2892                                            int snum,
2893                                            struct spoolss_Notify *data,
2894                                            print_queue_struct *queue,
2895                                            struct spoolss_PrinterInfo2 *pinfo2,
2896                                            TALLOC_CTX *mem_ctx)
2897 {
2898         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->printprocessor);
2899 }
2900
2901 /*******************************************************************
2902  * fill a notify_info_data with the print processor options
2903  * jfm:xxxx send an empty string
2904  ********************************************************************/
2905
2906 static void spoolss_notify_parameters(struct messaging_context *msg_ctx,
2907                                       int snum,
2908                                       struct spoolss_Notify *data,
2909                                       print_queue_struct *queue,
2910                                       struct spoolss_PrinterInfo2 *pinfo2,
2911                                       TALLOC_CTX *mem_ctx)
2912 {
2913         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->parameters);
2914 }
2915
2916 /*******************************************************************
2917  * fill a notify_info_data with the data type
2918  * jfm:xxxx always send RAW as data type
2919  ********************************************************************/
2920
2921 static void spoolss_notify_datatype(struct messaging_context *msg_ctx,
2922                                     int snum,
2923                                     struct spoolss_Notify *data,
2924                                     print_queue_struct *queue,
2925                                     struct spoolss_PrinterInfo2 *pinfo2,
2926                                     TALLOC_CTX *mem_ctx)
2927 {
2928         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->datatype);
2929 }
2930
2931 /*******************************************************************
2932  * fill a notify_info_data with the security descriptor
2933  * jfm:xxxx send an null pointer to say no security desc
2934  * have to implement security before !
2935  ********************************************************************/
2936
2937 static void spoolss_notify_security_desc(struct messaging_context *msg_ctx,
2938                                          int snum,
2939                                          struct spoolss_Notify *data,
2940                                          print_queue_struct *queue,
2941                                          struct spoolss_PrinterInfo2 *pinfo2,
2942                                          TALLOC_CTX *mem_ctx)
2943 {
2944         SETUP_SPOOLSS_NOTIFY_DATA_SECDESC(data, pinfo2->secdesc);
2945 }
2946
2947 /*******************************************************************
2948  * fill a notify_info_data with the attributes
2949  * jfm:xxxx a samba printer is always shared
2950  ********************************************************************/
2951
2952 static void spoolss_notify_attributes(struct messaging_context *msg_ctx,
2953                                       int snum,
2954                                       struct spoolss_Notify *data,
2955                                       print_queue_struct *queue,
2956                                       struct spoolss_PrinterInfo2 *pinfo2,
2957                                       TALLOC_CTX *mem_ctx)
2958 {
2959         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->attributes);
2960 }
2961
2962 /*******************************************************************
2963  * fill a notify_info_data with the priority
2964  ********************************************************************/
2965
2966 static void spoolss_notify_priority(struct messaging_context *msg_ctx,
2967                                     int snum,
2968                                     struct spoolss_Notify *data,
2969                                     print_queue_struct *queue,
2970                                     struct spoolss_PrinterInfo2 *pinfo2,
2971                                     TALLOC_CTX *mem_ctx)
2972 {
2973         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->priority);
2974 }
2975
2976 /*******************************************************************
2977  * fill a notify_info_data with the default priority
2978  ********************************************************************/
2979
2980 static void spoolss_notify_default_priority(struct messaging_context *msg_ctx,
2981                                             int snum,
2982                                             struct spoolss_Notify *data,
2983                                             print_queue_struct *queue,
2984                                             struct spoolss_PrinterInfo2 *pinfo2,
2985                                             TALLOC_CTX *mem_ctx)
2986 {
2987         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->defaultpriority);
2988 }
2989
2990 /*******************************************************************
2991  * fill a notify_info_data with the start time
2992  ********************************************************************/
2993
2994 static void spoolss_notify_start_time(struct messaging_context *msg_ctx,
2995                                       int snum,
2996                                       struct spoolss_Notify *data,
2997                                       print_queue_struct *queue,
2998                                       struct spoolss_PrinterInfo2 *pinfo2,
2999                                       TALLOC_CTX *mem_ctx)
3000 {
3001         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->starttime);
3002 }
3003
3004 /*******************************************************************
3005  * fill a notify_info_data with the until time
3006  ********************************************************************/
3007
3008 static void spoolss_notify_until_time(struct messaging_context *msg_ctx,
3009                                       int snum,
3010                                       struct spoolss_Notify *data,
3011                                       print_queue_struct *queue,
3012                                       struct spoolss_PrinterInfo2 *pinfo2,
3013                                       TALLOC_CTX *mem_ctx)
3014 {
3015         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->untiltime);
3016 }
3017
3018 /*******************************************************************
3019  * fill a notify_info_data with the status
3020  ********************************************************************/
3021
3022 static void spoolss_notify_status(struct messaging_context *msg_ctx,
3023                                   int snum,
3024                                   struct spoolss_Notify *data,
3025                                   print_queue_struct *queue,
3026                                   struct spoolss_PrinterInfo2 *pinfo2,
3027                                   TALLOC_CTX *mem_ctx)
3028 {
3029         print_status_struct status;
3030
3031         print_queue_length(msg_ctx, snum, &status);
3032         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, status.status);
3033 }
3034
3035 /*******************************************************************
3036  * fill a notify_info_data with the number of jobs queued
3037  ********************************************************************/
3038
3039 static void spoolss_notify_cjobs(struct messaging_context *msg_ctx,
3040                                  int snum,
3041                                  struct spoolss_Notify *data,
3042                                  print_queue_struct *queue,
3043                                  struct spoolss_PrinterInfo2 *pinfo2,
3044                                  TALLOC_CTX *mem_ctx)
3045 {
3046         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(
3047                 data, print_queue_length(msg_ctx, snum, NULL));
3048 }
3049
3050 /*******************************************************************
3051  * fill a notify_info_data with the average ppm
3052  ********************************************************************/
3053
3054 static void spoolss_notify_average_ppm(struct messaging_context *msg_ctx,
3055                                        int snum,
3056                                        struct spoolss_Notify *data,
3057                                        print_queue_struct *queue,
3058                                        struct spoolss_PrinterInfo2 *pinfo2,
3059                                        TALLOC_CTX *mem_ctx)
3060 {
3061         /* always respond 8 pages per minutes */
3062         /* a little hard ! */
3063         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->averageppm);
3064 }
3065
3066 /*******************************************************************
3067  * fill a notify_info_data with username
3068  ********************************************************************/
3069
3070 static void spoolss_notify_username(struct messaging_context *msg_ctx,
3071                                     int snum,
3072                                     struct spoolss_Notify *data,
3073                                     print_queue_struct *queue,
3074                                     struct spoolss_PrinterInfo2 *pinfo2,
3075                                     TALLOC_CTX *mem_ctx)
3076 {
3077         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, queue->fs_user);
3078 }
3079
3080 /*******************************************************************
3081  * fill a notify_info_data with job status
3082  ********************************************************************/
3083
3084 static void spoolss_notify_job_status(struct messaging_context *msg_ctx,
3085                                       int snum,
3086                                       struct spoolss_Notify *data,
3087                                       print_queue_struct *queue,
3088                                       struct spoolss_PrinterInfo2 *pinfo2,
3089                                       TALLOC_CTX *mem_ctx)
3090 {
3091         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, nt_printj_status(queue->status));
3092 }
3093
3094 /*******************************************************************
3095  * fill a notify_info_data with job name
3096  ********************************************************************/
3097
3098 static void spoolss_notify_job_name(struct messaging_context *msg_ctx,
3099                                     int snum,
3100                                     struct spoolss_Notify *data,
3101                                     print_queue_struct *queue,
3102                                     struct spoolss_PrinterInfo2 *pinfo2,
3103                                     TALLOC_CTX *mem_ctx)
3104 {
3105         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, queue->fs_file);
3106 }
3107
3108 /*******************************************************************
3109  * fill a notify_info_data with job status
3110  ********************************************************************/
3111
3112 static void spoolss_notify_job_status_string(struct messaging_context *msg_ctx,
3113                                              int snum,
3114                                              struct spoolss_Notify *data,
3115                                              print_queue_struct *queue,
3116                                              struct spoolss_PrinterInfo2 *pinfo2,
3117                                              TALLOC_CTX *mem_ctx)
3118 {
3119         /*
3120          * Now we're returning job status codes we just return a "" here. JRA.
3121          */
3122
3123         const char *p = "";
3124
3125 #if 0 /* NO LONGER NEEDED - JRA. 02/22/2001 */
3126         p = "unknown";
3127
3128         switch (queue->status) {
3129         case LPQ_QUEUED:
3130                 p = "Queued";
3131                 break;
3132         case LPQ_PAUSED:
3133                 p = "";    /* NT provides the paused string */
3134                 break;
3135         case LPQ_SPOOLING:
3136                 p = "Spooling";
3137                 break;
3138         case LPQ_PRINTING:
3139                 p = "Printing";
3140                 break;
3141         }
3142 #endif /* NO LONGER NEEDED. */
3143
3144         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, p);
3145 }
3146
3147 /*******************************************************************
3148  * fill a notify_info_data with job time
3149  ********************************************************************/
3150
3151 static void spoolss_notify_job_time(struct messaging_context *msg_ctx,
3152                                     int snum,
3153                                     struct spoolss_Notify *data,
3154                                     print_queue_struct *queue,
3155                                     struct spoolss_PrinterInfo2 *pinfo2,
3156                                     TALLOC_CTX *mem_ctx)
3157 {
3158         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, 0);
3159 }
3160
3161 /*******************************************************************
3162  * fill a notify_info_data with job size
3163  ********************************************************************/
3164
3165 static void spoolss_notify_job_size(struct messaging_context *msg_ctx,
3166                                     int snum,
3167                                     struct spoolss_Notify *data,
3168                                     print_queue_struct *queue,
3169                                     struct spoolss_PrinterInfo2 *pinfo2,
3170                                     TALLOC_CTX *mem_ctx)
3171 {
3172         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->size);
3173 }
3174
3175 /*******************************************************************
3176  * fill a notify_info_data with page info
3177  ********************************************************************/
3178 static void spoolss_notify_total_pages(struct messaging_context *msg_ctx,
3179                                        int snum,
3180                                 struct spoolss_Notify *data,
3181                                 print_queue_struct *queue,
3182                                 struct spoolss_PrinterInfo2 *pinfo2,
3183                                 TALLOC_CTX *mem_ctx)
3184 {
3185         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->page_count);
3186 }
3187
3188 /*******************************************************************
3189  * fill a notify_info_data with pages printed info.
3190  ********************************************************************/
3191 static void spoolss_notify_pages_printed(struct messaging_context *msg_ctx,
3192                                          int snum,
3193                                 struct spoolss_Notify *data,
3194                                 print_queue_struct *queue,
3195                                 struct spoolss_PrinterInfo2 *pinfo2,
3196                                 TALLOC_CTX *mem_ctx)
3197 {
3198         /* Add code when back-end tracks this */
3199         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, 0);
3200 }
3201
3202 /*******************************************************************
3203  Fill a notify_info_data with job position.
3204  ********************************************************************/
3205
3206 static void spoolss_notify_job_position(struct messaging_context *msg_ctx,
3207                                         int snum,
3208                                         struct spoolss_Notify *data,
3209                                         print_queue_struct *queue,
3210                                         struct spoolss_PrinterInfo2 *pinfo2,
3211                                         TALLOC_CTX *mem_ctx)
3212 {
3213         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->sysjob);
3214 }
3215
3216 /*******************************************************************
3217  Fill a notify_info_data with submitted time.
3218  ********************************************************************/
3219
3220 static void spoolss_notify_submitted_time(struct messaging_context *msg_ctx,
3221                                           int snum,
3222                                           struct spoolss_Notify *data,
3223                                           print_queue_struct *queue,
3224                                           struct spoolss_PrinterInfo2 *pinfo2,
3225                                           TALLOC_CTX *mem_ctx)
3226 {
3227         data->data.string.string = NULL;
3228         data->data.string.size = 0;
3229
3230         init_systemtime_buffer(mem_ctx, gmtime(&queue->time),
3231                                &data->data.string.string,
3232                                &data->data.string.size);
3233
3234 }
3235
3236 struct s_notify_info_data_table
3237 {
3238         enum spoolss_NotifyType type;
3239         uint16_t field;
3240         const char *name;
3241         enum spoolss_NotifyTable variable_type;
3242         void (*fn) (struct messaging_context *msg_ctx,
3243                     int snum, struct spoolss_Notify *data,
3244                     print_queue_struct *queue,
3245                     struct spoolss_PrinterInfo2 *pinfo2,
3246                     TALLOC_CTX *mem_ctx);
3247 };
3248
3249 /* A table describing the various print notification constants and
3250    whether the notification data is a pointer to a variable sized
3251    buffer, a one value uint32_t or a two value uint32_t. */
3252
3253 static const struct s_notify_info_data_table notify_info_data_table[] =
3254 {
3255 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SERVER_NAME,         "PRINTER_NOTIFY_FIELD_SERVER_NAME",         NOTIFY_TABLE_STRING,   spoolss_notify_server_name },
3256 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRINTER_NAME,        "PRINTER_NOTIFY_FIELD_PRINTER_NAME",        NOTIFY_TABLE_STRING,   spoolss_notify_printer_name },
3257 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SHARE_NAME,          "PRINTER_NOTIFY_FIELD_SHARE_NAME",          NOTIFY_TABLE_STRING,   spoolss_notify_share_name },
3258 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PORT_NAME,           "PRINTER_NOTIFY_FIELD_PORT_NAME",           NOTIFY_TABLE_STRING,   spoolss_notify_port_name },
3259 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DRIVER_NAME,         "PRINTER_NOTIFY_FIELD_DRIVER_NAME",         NOTIFY_TABLE_STRING,   spoolss_notify_driver_name },
3260 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_COMMENT,             "PRINTER_NOTIFY_FIELD_COMMENT",             NOTIFY_TABLE_STRING,   spoolss_notify_comment },
3261 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_LOCATION,            "PRINTER_NOTIFY_FIELD_LOCATION",            NOTIFY_TABLE_STRING,   spoolss_notify_location },
3262 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DEVMODE,             "PRINTER_NOTIFY_FIELD_DEVMODE",             NOTIFY_TABLE_DEVMODE,  spoolss_notify_devmode },
3263 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SEPFILE,             "PRINTER_NOTIFY_FIELD_SEPFILE",             NOTIFY_TABLE_STRING,   spoolss_notify_sepfile },
3264 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR,     "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR",     NOTIFY_TABLE_STRING,   spoolss_notify_print_processor },
3265 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PARAMETERS,          "PRINTER_NOTIFY_FIELD_PARAMETERS",          NOTIFY_TABLE_STRING,   spoolss_notify_parameters },
3266 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DATATYPE,            "PRINTER_NOTIFY_FIELD_DATATYPE",            NOTIFY_TABLE_STRING,   spoolss_notify_datatype },
3267 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR, "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NOTIFY_TABLE_SECURITYDESCRIPTOR,   spoolss_notify_security_desc },
3268 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_ATTRIBUTES,          "PRINTER_NOTIFY_FIELD_ATTRIBUTES",          NOTIFY_TABLE_DWORD,    spoolss_notify_attributes },
3269 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRIORITY,            "PRINTER_NOTIFY_FIELD_PRIORITY",            NOTIFY_TABLE_DWORD,    spoolss_notify_priority },
3270 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY,    "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY",    NOTIFY_TABLE_DWORD,    spoolss_notify_default_priority },
3271 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_START_TIME,          "PRINTER_NOTIFY_FIELD_START_TIME",          NOTIFY_TABLE_DWORD,    spoolss_notify_start_time },
3272 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_UNTIL_TIME,          "PRINTER_NOTIFY_FIELD_UNTIL_TIME",          NOTIFY_TABLE_DWORD,    spoolss_notify_until_time },
3273 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_STATUS,              "PRINTER_NOTIFY_FIELD_STATUS",              NOTIFY_TABLE_DWORD,    spoolss_notify_status },
3274 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_STATUS_STRING,       "PRINTER_NOTIFY_FIELD_STATUS_STRING",       NOTIFY_TABLE_STRING,   NULL },
3275 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_CJOBS,               "PRINTER_NOTIFY_FIELD_CJOBS",               NOTIFY_TABLE_DWORD,    spoolss_notify_cjobs },
3276 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_AVERAGE_PPM,         "PRINTER_NOTIFY_FIELD_AVERAGE_PPM",         NOTIFY_TABLE_DWORD,    spoolss_notify_average_ppm },
3277 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_TOTAL_PAGES,         "PRINTER_NOTIFY_FIELD_TOTAL_PAGES",         NOTIFY_TABLE_DWORD,    NULL },
3278 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PAGES_PRINTED,       "PRINTER_NOTIFY_FIELD_PAGES_PRINTED",       NOTIFY_TABLE_DWORD,    NULL },
3279 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_TOTAL_BYTES,         "PRINTER_NOTIFY_FIELD_TOTAL_BYTES",         NOTIFY_TABLE_DWORD,    NULL },
3280 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_BYTES_PRINTED,       "PRINTER_NOTIFY_FIELD_BYTES_PRINTED",       NOTIFY_TABLE_DWORD,    NULL },
3281 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_PRINTER_NAME,            "JOB_NOTIFY_FIELD_PRINTER_NAME",            NOTIFY_TABLE_STRING,   spoolss_notify_printer_name },
3282 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_MACHINE_NAME,            "JOB_NOTIFY_FIELD_MACHINE_NAME",            NOTIFY_TABLE_STRING,   spoolss_notify_server_name },
3283 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_PORT_NAME,               "JOB_NOTIFY_FIELD_PORT_NAME",               NOTIFY_TABLE_STRING,   spoolss_notify_port_name },
3284 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_USER_NAME,               "JOB_NOTIFY_FIELD_USER_NAME",               NOTIFY_TABLE_STRING,   spoolss_notify_username },
3285 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_NOTIFY_NAME,             "JOB_NOTIFY_FIELD_NOTIFY_NAME",             NOTIFY_TABLE_STRING,   spoolss_notify_username },
3286 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_DATATYPE,                "JOB_NOTIFY_FIELD_DATATYPE",                NOTIFY_TABLE_STRING,   spoolss_notify_datatype },
3287 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_PRINT_PROCESSOR,         "JOB_NOTIFY_FIELD_PRINT_PROCESSOR",         NOTIFY_TABLE_STRING,   spoolss_notify_print_processor },
3288 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_PARAMETERS,              "JOB_NOTIFY_FIELD_PARAMETERS",              NOTIFY_TABLE_STRING,   spoolss_notify_parameters },
3289 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_DRIVER_NAME,             "JOB_NOTIFY_FIELD_DRIVER_NAME",             NOTIFY_TABLE_STRING,   spoolss_notify_driver_name },
3290 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_DEVMODE,                 "JOB_NOTIFY_FIELD_DEVMODE",                 NOTIFY_TABLE_DEVMODE,  spoolss_notify_devmode },
3291 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_STATUS,                  "JOB_NOTIFY_FIELD_STATUS",                  NOTIFY_TABLE_DWORD,    spoolss_notify_job_status },
3292 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_STATUS_STRING,           "JOB_NOTIFY_FIELD_STATUS_STRING",           NOTIFY_TABLE_STRING,   spoolss_notify_job_status_string },
3293 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR,     "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR",     NOTIFY_TABLE_SECURITYDESCRIPTOR,   NULL },
3294 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_DOCUMENT,                "JOB_NOTIFY_FIELD_DOCUMENT",                NOTIFY_TABLE_STRING,   spoolss_notify_job_name },
3295 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_PRIORITY,                "JOB_NOTIFY_FIELD_PRIORITY",                NOTIFY_TABLE_DWORD,    spoolss_notify_priority },
3296 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_POSITION,                "JOB_NOTIFY_FIELD_POSITION",                NOTIFY_TABLE_DWORD,    spoolss_notify_job_position },
3297 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_SUBMITTED,               "JOB_NOTIFY_FIELD_SUBMITTED",               NOTIFY_TABLE_TIME,     spoolss_notify_submitted_time },
3298 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_START_TIME,              "JOB_NOTIFY_FIELD_START_TIME",              NOTIFY_TABLE_DWORD,    spoolss_notify_start_time },
3299 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_UNTIL_TIME,              "JOB_NOTIFY_FIELD_UNTIL_TIME",              NOTIFY_TABLE_DWORD,    spoolss_notify_until_time },
3300 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_TIME,                    "JOB_NOTIFY_FIELD_TIME",                    NOTIFY_TABLE_DWORD,    spoolss_notify_job_time },
3301 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_TOTAL_PAGES,             "JOB_NOTIFY_FIELD_TOTAL_PAGES",             NOTIFY_TABLE_DWORD,    spoolss_notify_total_pages },
3302 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_PAGES_PRINTED,           "JOB_NOTIFY_FIELD_PAGES_PRINTED",           NOTIFY_TABLE_DWORD,    spoolss_notify_pages_printed },
3303 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_TOTAL_BYTES,             "JOB_NOTIFY_FIELD_TOTAL_BYTES",             NOTIFY_TABLE_DWORD,    spoolss_notify_job_size },
3304 };
3305
3306 /*******************************************************************
3307  Return the variable_type of info_data structure.
3308 ********************************************************************/
3309
3310 static enum spoolss_NotifyTable variable_type_of_notify_info_data(enum spoolss_NotifyType type,
3311                                                                   uint16_t field)
3312 {
3313         int i=0;
3314
3315         for (i = 0; i < ARRAY_SIZE(notify_info_data_table); i++) {
3316                 if ( (notify_info_data_table[i].type == type) &&
3317                      (notify_info_data_table[i].field == field) ) {
3318                         return notify_info_data_table[i].variable_type;
3319                 }
3320         }
3321
3322         DEBUG(5, ("invalid notify data type %d/%d\n", type, field));
3323
3324         return (enum spoolss_NotifyTable) 0;
3325 }
3326
3327 /****************************************************************************
3328 ****************************************************************************/
3329
3330 static bool search_notify(enum spoolss_NotifyType type,
3331                           uint16_t field,
3332                           int *value)
3333 {
3334         int i;
3335
3336         for (i = 0; i < ARRAY_SIZE(notify_info_data_table); i++) {
3337                 if (notify_info_data_table[i].type == type &&
3338                     notify_info_data_table[i].field == field &&
3339                     notify_info_data_table[i].fn != NULL) {
3340                         *value = i;
3341                         return true;
3342                 }
3343         }
3344
3345         return false;
3346 }
3347
3348 /****************************************************************************
3349 ****************************************************************************/
3350
3351 static void construct_info_data(struct spoolss_Notify *info_data,
3352                                 enum spoolss_NotifyType type,
3353                                 uint16_t field, int id)
3354 {
3355         info_data->type                 = type;
3356         info_data->field.field          = field;
3357         info_data->variable_type        = variable_type_of_notify_info_data(type, field);
3358         info_data->job_id               = id;
3359 }
3360
3361 /*******************************************************************
3362  *
3363  * fill a notify_info struct with info asked
3364  *
3365  ********************************************************************/
3366
3367 static bool construct_notify_printer_info(struct messaging_context *msg_ctx,
3368                                           struct printer_handle *print_hnd,
3369                                           struct spoolss_NotifyInfo *info,
3370                                           struct spoolss_PrinterInfo2 *pinfo2,
3371                                           int snum,
3372                                           const struct spoolss_NotifyOptionType *option_type,
3373                                           uint32_t id,
3374                                           TALLOC_CTX *mem_ctx)
3375 {
3376         int field_num,j;
3377         enum spoolss_NotifyType type;
3378         uint16_t field;
3379
3380         struct spoolss_Notify *current_data;
3381
3382         type = option_type->type;
3383
3384         DEBUG(4,("construct_notify_printer_info: Notify type: [%s], number of notify info: [%d] on printer: [%s]\n",
3385                 (type == PRINTER_NOTIFY_TYPE ? "PRINTER_NOTIFY_TYPE" : "JOB_NOTIFY_TYPE"),
3386                 option_type->count, lp_servicename(talloc_tos(), snum)));
3387
3388         for(field_num=0; field_num < option_type->count; field_num++) {
3389                 field = option_type->fields[field_num].field;
3390
3391                 DEBUG(4,("construct_notify_printer_info: notify [%d]: type [%x], field [%x]\n", field_num, type, field));
3392
3393                 if (!search_notify(type, field, &j) )
3394                         continue;
3395
3396                 info->notifies = talloc_realloc(info, info->notifies,
3397                                                       struct spoolss_Notify,
3398                                                       info->count + 1);
3399                 if (info->notifies == NULL) {
3400                         DEBUG(2,("construct_notify_printer_info: failed to enlarge buffer info->data!\n"));
3401                         return false;
3402                 }
3403
3404                 current_data = &info->notifies[info->count];
3405
3406                 construct_info_data(current_data, type, field, id);
3407
3408                 DEBUG(10, ("construct_notify_printer_info: "
3409                            "calling [%s]  snum=%d  printername=[%s])\n",
3410                            notify_info_data_table[j].name, snum,
3411                            pinfo2->printername));
3412
3413                 notify_info_data_table[j].fn(msg_ctx, snum, current_data,
3414                                              NULL, pinfo2, mem_ctx);
3415
3416                 info->count++;
3417         }
3418
3419         return true;
3420 }
3421
3422 /*******************************************************************
3423  *
3424  * fill a notify_info struct with info asked
3425  *
3426  ********************************************************************/
3427
3428 static bool construct_notify_jobs_info(struct messaging_context *msg_ctx,
3429                                        print_queue_struct *queue,
3430                                        struct spoolss_NotifyInfo *info,
3431                                        struct spoolss_PrinterInfo2 *pinfo2,
3432                                        int snum,
3433                                        const struct spoolss_NotifyOptionType *option_type,
3434                                        uint32_t id,
3435                                        TALLOC_CTX *mem_ctx)
3436 {
3437         int field_num,j;
3438         enum spoolss_NotifyType type;
3439         uint16_t field;
3440         struct spoolss_Notify *current_data;
3441
3442         DEBUG(4,("construct_notify_jobs_info\n"));
3443
3444         type = option_type->type;
3445
3446         DEBUGADD(4,("Notify type: [%s], number of notify info: [%d]\n",
3447                 (type == PRINTER_NOTIFY_TYPE ? "PRINTER_NOTIFY_TYPE" : "JOB_NOTIFY_TYPE"),
3448                 option_type->count));
3449
3450         for(field_num=0; field_num<option_type->count; field_num++) {
3451                 field = option_type->fields[field_num].field;
3452
3453                 if (!search_notify(type, field, &j) )
3454                         continue;
3455
3456                 info->notifies = talloc_realloc(info, info->notifies,
3457                                                       struct spoolss_Notify,
3458                                                       info->count + 1);
3459                 if (info->notifies == NULL) {
3460                         DEBUG(2,("construct_notify_jobs_info: failed to enlarg buffer info->data!\n"));
3461                         return false;
3462                 }
3463
3464                 current_data=&(info->notifies[info->count]);
3465
3466                 construct_info_data(current_data, type, field, id);
3467                 notify_info_data_table[j].fn(msg_ctx, snum, current_data,
3468                                              queue, pinfo2, mem_ctx);
3469                 info->count++;
3470         }
3471
3472         return true;
3473 }
3474
3475 /*
3476  * JFM: The enumeration is not that simple, it's even non obvious.
3477  *
3478  * let's take an example: I want to monitor the PRINTER SERVER for
3479  * the printer's name and the number of jobs currently queued.
3480  * So in the NOTIFY_OPTION, I have one NOTIFY_OPTION_TYPE structure.
3481  * Its type is PRINTER_NOTIFY_TYPE and it has 2 fields NAME and CJOBS.
3482  *
3483  * I have 3 printers on the back of my server.
3484  *
3485  * Now the response is a NOTIFY_INFO structure, with 6 NOTIFY_INFO_DATA
3486  * structures.
3487  *   Number     Data                    Id
3488  *      1       printer 1 name          1
3489  *      2       printer 1 cjob          1
3490  *      3       printer 2 name          2
3491  *      4       printer 2 cjob          2
3492  *      5       printer 3 name          3
3493  *      6       printer 3 name          3
3494  *
3495  * that's the print server case, the printer case is even worse.
3496  */
3497
3498 /*******************************************************************
3499  *
3500  * enumerate all printers on the printserver
3501  * fill a notify_info struct with info asked
3502  *
3503  ********************************************************************/
3504
3505 static WERROR printserver_notify_info(struct pipes_struct *p,
3506                                       struct policy_handle *hnd,
3507                                       struct spoolss_NotifyInfo *info,
3508                                       TALLOC_CTX *mem_ctx)
3509 {
3510         int snum;
3511         struct printer_handle *Printer = find_printer_index_by_hnd(p, hnd);
3512         int n_services=lp_numservices();
3513         int i;
3514         struct spoolss_NotifyOption *option;
3515         struct spoolss_NotifyOptionType option_type;
3516         struct spoolss_PrinterInfo2 *pinfo2 = NULL;
3517         WERROR result;
3518
3519         DEBUG(4,("printserver_notify_info\n"));
3520
3521         if (!Printer)
3522                 return WERR_BADFID;
3523
3524         option = Printer->notify.option;
3525
3526         info->version   = 2;
3527         info->notifies  = NULL;
3528         info->count     = 0;
3529
3530         /* a bug in xp sp2 rc2 causes it to send a fnpcn request without
3531            sending a ffpcn() request first */
3532
3533         if ( !option )
3534                 return WERR_BADFID;
3535
3536         for (i=0; i<option->count; i++) {
3537                 option_type = option->types[i];
3538
3539                 if (option_type.type != PRINTER_NOTIFY_TYPE)
3540                         continue;
3541
3542                 for (snum = 0; snum < n_services; snum++) {
3543                         if (!lp_browseable(snum) ||
3544                             !lp_snum_ok(snum) ||
3545                             !lp_print_ok(snum)) {
3546                                 continue; /* skip */
3547                         }
3548
3549                         /* Maybe we should use the SYSTEM session_info here... */
3550                         result = winreg_get_printer_internal(mem_ctx,
3551                                                     get_session_info_system(),
3552                                                     p->msg_ctx,
3553                                                     lp_servicename(talloc_tos(), snum),
3554                                                     &pinfo2);
3555                         if (!W_ERROR_IS_OK(result)) {
3556                                 DEBUG(4, ("printserver_notify_info: "
3557                                           "Failed to get printer [%s]\n",
3558                                           lp_servicename(talloc_tos(), snum)));
3559                                 continue;
3560                         }
3561
3562
3563                         construct_notify_printer_info(p->msg_ctx,
3564                                                       Printer, info,
3565                                                       pinfo2, snum,
3566                                                       &option_type, snum,
3567                                                       mem_ctx);
3568
3569                         TALLOC_FREE(pinfo2);
3570                 }
3571         }
3572
3573 #if 0
3574         /*
3575          * Debugging information, don't delete.
3576          */
3577
3578         DEBUG(1,("dumping the NOTIFY_INFO\n"));
3579         DEBUGADD(1,("info->version:[%d], info->flags:[%d], info->count:[%d]\n", info->version, info->flags, info->count));
3580         DEBUGADD(1,("num\ttype\tfield\tres\tid\tsize\tenc_type\n"));
3581
3582         for (i=0; i<info->count; i++) {
3583                 DEBUGADD(1,("[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\n",
3584                 i, info->data[i].type, info->data[i].field, info->data[i].reserved,
3585                 info->data[i].id, info->data[i].size, info->data[i].enc_type));
3586         }
3587 #endif
3588
3589         return WERR_OK;
3590 }
3591
3592 /*******************************************************************
3593  *
3594  * fill a notify_info struct with info asked
3595  *
3596  ********************************************************************/
3597
3598 static WERROR printer_notify_info(struct pipes_struct *p,
3599                                   struct policy_handle *hnd,
3600                                   struct spoolss_NotifyInfo *info,
3601                                   TALLOC_CTX *mem_ctx)
3602 {
3603         int snum;
3604         struct printer_handle *Printer = find_printer_index_by_hnd(p, hnd);
3605         int i;
3606         uint32_t id;
3607         struct spoolss_NotifyOption *option;
3608         struct spoolss_NotifyOptionType option_type;
3609         int count,j;
3610         print_queue_struct *queue=NULL;
3611         print_status_struct status;
3612         struct spoolss_PrinterInfo2 *pinfo2 = NULL;
3613         WERROR result;
3614
3615         DEBUG(4,("printer_notify_info\n"));
3616
3617         if (!Printer)
3618                 return WERR_BADFID;
3619
3620         option = Printer->notify.option;
3621         id = 0x0;
3622
3623         info->version   = 2;
3624         info->notifies  = NULL;
3625         info->count     = 0;
3626
3627         /* a bug in xp sp2 rc2 causes it to send a fnpcn request without
3628            sending a ffpcn() request first */
3629
3630         if ( !option )
3631                 return WERR_BADFID;
3632
3633         if (!get_printer_snum(p, hnd, &snum, NULL)) {
3634                 return WERR_BADFID;
3635         }
3636
3637         /* Maybe we should use the SYSTEM session_info here... */
3638         result = winreg_get_printer_internal(mem_ctx,
3639                                     get_session_info_system(),
3640                                     p->msg_ctx,
3641                                     lp_servicename(talloc_tos(), snum), &pinfo2);
3642         if (!W_ERROR_IS_OK(result)) {
3643                 return WERR_BADFID;
3644         }
3645
3646         /*
3647          * When sending a PRINTER_NOTIFY_FIELD_SERVER_NAME we should send the
3648          * correct servername.
3649          */
3650         pinfo2->servername = talloc_strdup(pinfo2, Printer->servername);
3651         if (pinfo2->servername == NULL) {
3652                 return WERR_NOMEM;
3653         }
3654
3655         for (i=0; i<option->count; i++) {
3656                 option_type = option->types[i];
3657
3658                 switch (option_type.type) {
3659                 case PRINTER_NOTIFY_TYPE:
3660                         if (construct_notify_printer_info(p->msg_ctx,
3661                                                           Printer, info,
3662                                                           pinfo2, snum,
3663                                                           &option_type, id,
3664                                                           mem_ctx)) {
3665                                 id--;
3666                         }
3667                         break;
3668
3669                 case JOB_NOTIFY_TYPE:
3670
3671                         count = print_queue_status(p->msg_ctx, snum, &queue,
3672                                                    &status);
3673
3674                         for (j=0; j<count; j++) {
3675                                 construct_notify_jobs_info(p->msg_ctx,
3676                                                            &queue[j], info,
3677                                                            pinfo2, snum,
3678                                                            &option_type,
3679                                                            queue[j].sysjob,
3680                                                            mem_ctx);
3681                         }
3682
3683                         SAFE_FREE(queue);
3684                         break;
3685                 }
3686         }
3687
3688         /*
3689          * Debugging information, don't delete.
3690          */
3691         /*
3692         DEBUG(1,("dumping the NOTIFY_INFO\n"));
3693         DEBUGADD(1,("info->version:[%d], info->flags:[%d], info->count:[%d]\n", info->version, info->flags, info->count));
3694         DEBUGADD(1,("num\ttype\tfield\tres\tid\tsize\tenc_type\n"));
3695
3696         for (i=0; i<info->count; i++) {
3697                 DEBUGADD(1,("[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\n",
3698                 i, info->data[i].type, info->data[i].field, info->data[i].reserved,
3699                 info->data[i].id, info->data[i].size, info->data[i].enc_type));
3700         }
3701         */
3702
3703         talloc_free(pinfo2);
3704         return WERR_OK;
3705 }
3706
3707 /****************************************************************
3708  _spoolss_RouterRefreshPrinterChangeNotify
3709 ****************************************************************/
3710
3711 WERROR _spoolss_RouterRefreshPrinterChangeNotify(struct pipes_struct *p,
3712                                                  struct spoolss_RouterRefreshPrinterChangeNotify *r)
3713 {
3714         struct spoolss_NotifyInfo *info;
3715
3716         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
3717         WERROR result = WERR_BADFID;
3718
3719         /* we always have a spoolss_NotifyInfo struct */
3720         info = talloc_zero(p->mem_ctx, struct spoolss_NotifyInfo);
3721         if (!info) {
3722                 result = WERR_NOMEM;
3723                 goto done;
3724         }
3725
3726         *r->out.info = info;
3727
3728         if (!Printer) {
3729                 DEBUG(2,("_spoolss_RouterRefreshPrinterChangeNotify: "
3730                         "Invalid handle (%s:%u:%u).\n",
3731                         OUR_HANDLE(r->in.handle)));
3732                 goto done;
3733         }
3734
3735         DEBUG(4,("Printer type %x\n",Printer->printer_type));
3736
3737         /*
3738          *      We are now using the change value, and
3739          *      I should check for PRINTER_NOTIFY_OPTIONS_REFRESH but as
3740          *      I don't have a global notification system, I'm sending back all the
3741          *      information even when _NOTHING_ has changed.
3742          */
3743
3744         /* We need to keep track of the change value to send back in
3745            RRPCN replies otherwise our updates are ignored. */
3746
3747         Printer->notify.fnpcn = true;
3748
3749         if (Printer->notify.cli_chan != NULL &&
3750             Printer->notify.cli_chan->active_connections > 0) {
3751                 DEBUG(10,("_spoolss_RouterRefreshPrinterChangeNotify: "
3752                         "Saving change value in request [%x]\n",
3753                         r->in.change_low));
3754                 Printer->notify.change = r->in.change_low;
3755         }
3756
3757         /* just ignore the spoolss_NotifyOption */
3758
3759         switch (Printer->printer_type) {
3760                 case SPLHND_SERVER:
3761                         result = printserver_notify_info(p, r->in.handle,
3762                                                          info, p->mem_ctx);
3763                         break;
3764
3765                 case SPLHND_PRINTER:
3766                         result = printer_notify_info(p, r->in.handle,
3767                                                      info, p->mem_ctx);
3768                         break;
3769         }
3770
3771         Printer->notify.fnpcn = false;
3772
3773 done:
3774         return result;
3775 }
3776
3777 /********************************************************************
3778  ********************************************************************/
3779
3780 static WERROR create_printername(TALLOC_CTX *mem_ctx,
3781                                  const char *servername,
3782                                  const char *printername,
3783                                  const char **printername_p)
3784 {
3785         /* FIXME: add lp_force_printername() */
3786
3787         if (servername == NULL) {
3788                 *printername_p = talloc_strdup(mem_ctx, printername);
3789                 W_ERROR_HAVE_NO_MEMORY(*printername_p);
3790                 return WERR_OK;
3791         }
3792
3793         if (servername[0] == '\\' && servername[1] == '\\') {
3794                 servername += 2;
3795         }
3796
3797         *printername_p = talloc_asprintf(mem_ctx, "\\\\%s\\%s", servername, printername);
3798         W_ERROR_HAVE_NO_MEMORY(*printername_p);
3799
3800         return WERR_OK;
3801 }
3802
3803 /********************************************************************
3804  ********************************************************************/
3805
3806 static void compose_devicemode_devicename(struct spoolss_DeviceMode *dm,
3807                                           const char *printername)
3808 {
3809         if (dm == NULL) {
3810                 return;
3811         }
3812
3813         dm->devicename = talloc_strndup(dm, printername,
3814                                         MIN(strlen(printername), 31));
3815 }
3816
3817 /********************************************************************
3818  * construct_printer_info_0
3819  * fill a printer_info_0 struct
3820  ********************************************************************/
3821
3822 static WERROR construct_printer_info0(TALLOC_CTX *mem_ctx,
3823                                       const struct auth_session_info *session_info,
3824                                       struct messaging_context *msg_ctx,
3825                                       struct spoolss_PrinterInfo2 *info2,
3826                                       const char *servername,
3827                                       struct spoolss_PrinterInfo0 *r,
3828                                       int snum)
3829 {
3830         int count;
3831         struct printer_session_counter *session_counter;
3832         struct timeval setuptime;
3833         print_status_struct status;
3834         WERROR result;
3835
3836         result = create_printername(mem_ctx, servername, info2->printername, &r->printername);
3837         if (!W_ERROR_IS_OK(result)) {
3838                 return result;
3839         }
3840
3841         if (servername) {
3842                 r->servername = talloc_strdup(mem_ctx, servername);
3843                 W_ERROR_HAVE_NO_MEMORY(r->servername);
3844         } else {
3845                 r->servername = NULL;
3846         }
3847
3848         count = print_queue_length(msg_ctx, snum, &status);
3849
3850         /* check if we already have a counter for this printer */
3851         for (session_counter = counter_list; session_counter; session_counter = session_counter->next) {
3852                 if (session_counter->snum == snum)
3853                         break;
3854         }
3855
3856         /* it's the first time, add it to the list */
3857         if (session_counter == NULL) {
3858                 session_counter = talloc_zero(counter_list, struct printer_session_counter);
3859                 W_ERROR_HAVE_NO_MEMORY(session_counter);
3860                 session_counter->snum           = snum;
3861                 session_counter->counter        = 0;
3862                 DLIST_ADD(counter_list, session_counter);
3863         }
3864
3865         /* increment it */
3866         session_counter->counter++;
3867
3868         r->cjobs                        = count;
3869         r->total_jobs                   = 0;
3870         r->total_bytes                  = 0;
3871
3872         get_startup_time(&setuptime);
3873         init_systemtime(&r->time, gmtime(&setuptime.tv_sec));
3874
3875         /* JFM:
3876          * the global_counter should be stored in a TDB as it's common to all the clients
3877          * and should be zeroed on samba startup
3878          */
3879         r->global_counter               = session_counter->counter;
3880         r->total_pages                  = 0;
3881         /* in 2.2 we reported ourselves as 0x0004 and 0x0565 */
3882         SSVAL(&r->version, 0, 0x0005); /* NT 5 */
3883         SSVAL(&r->version, 2, 0x0893); /* build 2195 */
3884         r->free_build                   = SPOOLSS_RELEASE_BUILD;
3885         r->spooling                     = 0;
3886         r->max_spooling                 = 0;
3887         r->session_counter              = session_counter->counter;
3888         r->num_error_out_of_paper       = 0x0;
3889         r->num_error_not_ready          = 0x0;          /* number of print failure */
3890         r->job_error                    = 0x0;
3891         r->number_of_processors         = 0x1;
3892         r->processor_type               = PROCESSOR_INTEL_PENTIUM; /* 586 Pentium ? */
3893         r->high_part_total_bytes        = 0x0;
3894
3895         /* ChangeID in milliseconds*/
3896         winreg_printer_get_changeid_internal(mem_ctx, session_info, msg_ctx,
3897                                     info2->sharename, &r->change_id);
3898
3899         r->last_error                   = WERR_OK;
3900         r->status                       = nt_printq_status(status.status);
3901         r->enumerate_network_printers   = 0x0;
3902         r->c_setprinter                 = 0x0;
3903         r->processor_architecture       = PROCESSOR_ARCHITECTURE_INTEL;
3904         r->processor_level              = 0x6;          /* 6  ???*/
3905         r->ref_ic                       = 0;
3906         r->reserved2                    = 0;
3907         r->reserved3                    = 0;
3908
3909         return WERR_OK;
3910 }
3911
3912
3913 /********************************************************************
3914  * construct_printer_info1
3915  * fill a spoolss_PrinterInfo1 struct
3916 ********************************************************************/
3917
3918 static WERROR construct_printer_info1(TALLOC_CTX *mem_ctx,
3919                                       const struct spoolss_PrinterInfo2 *info2,
3920                                       uint32_t flags,
3921                                       const char *servername,
3922                                       struct spoolss_PrinterInfo1 *r,
3923                                       int snum)
3924 {
3925         WERROR result;
3926
3927         r->flags                = flags;
3928
3929         if (info2->comment == NULL || info2->comment[0] == '\0') {
3930                 r->comment      = lp_comment(mem_ctx, snum);
3931         } else {
3932                 r->comment      = talloc_strdup(mem_ctx, info2->comment); /* saved comment */
3933         }
3934         W_ERROR_HAVE_NO_MEMORY(r->comment);
3935
3936         result = create_printername(mem_ctx, servername, info2->printername, &r->name);
3937         if (!W_ERROR_IS_OK(result)) {
3938                 return result;
3939         }
3940
3941         r->description          = talloc_asprintf(mem_ctx, "%s,%s,%s",
3942                                                   r->name,
3943                                                   info2->drivername,
3944                                                   r->comment);
3945         W_ERROR_HAVE_NO_MEMORY(r->description);
3946
3947         return WERR_OK;
3948 }
3949
3950 /********************************************************************
3951  * construct_printer_info2
3952  * fill a spoolss_PrinterInfo2 struct
3953 ********************************************************************/
3954
3955 static WERROR construct_printer_info2(TALLOC_CTX *mem_ctx,
3956                                       struct messaging_context *msg_ctx,
3957                                       const struct spoolss_PrinterInfo2 *info2,
3958                                       const char *servername,
3959                                       struct spoolss_PrinterInfo2 *r,
3960                                       int snum)
3961 {
3962         int count;
3963         print_status_struct status;
3964         WERROR result;
3965
3966         count = print_queue_length(msg_ctx, snum, &status);
3967
3968         if (servername) {
3969                 r->servername           = talloc_strdup(mem_ctx, servername);
3970                 W_ERROR_HAVE_NO_MEMORY(r->servername);
3971         } else {
3972                 r->servername           = NULL;
3973         }
3974
3975         result = create_printername(mem_ctx, servername, info2->printername, &r->printername);
3976         if (!W_ERROR_IS_OK(result)) {
3977                 return result;
3978         }
3979
3980         r->sharename            = lp_servicename(mem_ctx, snum);
3981         W_ERROR_HAVE_NO_MEMORY(r->sharename);
3982         r->portname             = talloc_strdup(mem_ctx, info2->portname);
3983         W_ERROR_HAVE_NO_MEMORY(r->portname);
3984         r->drivername           = talloc_strdup(mem_ctx, info2->drivername);
3985         W_ERROR_HAVE_NO_MEMORY(r->drivername);
3986
3987         if (info2->comment[0] == '\0') {
3988                 r->comment      = lp_comment(mem_ctx, snum);
3989         } else {
3990                 r->comment      = talloc_strdup(mem_ctx, info2->comment);
3991         }
3992         W_ERROR_HAVE_NO_MEMORY(r->comment);
3993
3994         r->location     = talloc_strdup(mem_ctx, info2->location);
3995         if (info2->location[0] == '\0') {
3996                 const char *loc = NULL;
3997                 NTSTATUS nt_status;
3998
3999                 nt_status = printer_list_get_printer(mem_ctx,
4000                                                      info2->sharename,
4001                                                      NULL,
4002                                                      &loc,
4003                                                      NULL);
4004                 if (NT_STATUS_IS_OK(nt_status)) {
4005                         if (loc != NULL) {
4006                                 r->location = talloc_strdup(mem_ctx, loc);
4007                         }
4008                 }
4009         }
4010         W_ERROR_HAVE_NO_MEMORY(r->location);
4011
4012         r->sepfile              = talloc_strdup(mem_ctx, info2->sepfile);
4013         W_ERROR_HAVE_NO_MEMORY(r->sepfile);
4014         r->printprocessor       = talloc_strdup(mem_ctx, info2->printprocessor);
4015         W_ERROR_HAVE_NO_MEMORY(r->printprocessor);
4016         r->datatype             = talloc_strdup(mem_ctx, info2->datatype);
4017         W_ERROR_HAVE_NO_MEMORY(r->datatype);
4018         r->parameters           = talloc_strdup(mem_ctx, info2->parameters);
4019         W_ERROR_HAVE_NO_MEMORY(r->parameters);
4020
4021         r->attributes           = info2->attributes;
4022
4023         r->priority             = info2->priority;
4024         r->defaultpriority      = info2->defaultpriority;
4025         r->starttime            = info2->starttime;
4026         r->untiltime            = info2->untiltime;
4027         r->status               = nt_printq_status(status.status);
4028         r->cjobs                = count;
4029         r->averageppm           = info2->averageppm;
4030
4031         if (info2->devmode != NULL) {
4032                 result = copy_devicemode(mem_ctx,
4033                                          info2->devmode,
4034                                          &r->devmode);
4035                 if (!W_ERROR_IS_OK(result)) {
4036                         return result;
4037                 }
4038         } else if (lp_default_devmode(snum)) {
4039                 result = spoolss_create_default_devmode(mem_ctx,
4040                                                         info2->printername,
4041                                                         &r->devmode);
4042                 if (!W_ERROR_IS_OK(result)) {
4043                         return result;
4044                 }
4045         } else {
4046                 r->devmode = NULL;
4047                 DEBUG(8,("Returning NULL Devicemode!\n"));
4048         }
4049
4050         compose_devicemode_devicename(r->devmode, r->printername);
4051
4052         r->secdesc = NULL;
4053
4054         if (info2->secdesc != NULL) {
4055                 /* don't use talloc_steal() here unless you do a deep steal of all
4056                    the SEC_DESC members */
4057
4058                 r->secdesc      = dup_sec_desc(mem_ctx, info2->secdesc);
4059         }
4060
4061         return WERR_OK;
4062 }
4063
4064 /********************************************************************
4065  * construct_printer_info3
4066  * fill a spoolss_PrinterInfo3 struct
4067  ********************************************************************/
4068
4069 static WERROR construct_printer_info3(TALLOC_CTX *mem_ctx,
4070                                       const struct spoolss_PrinterInfo2 *info2,
4071                                       const char *servername,
4072                                       struct spoolss_PrinterInfo3 *r,
4073                                       int snum)
4074 {
4075         /* These are the components of the SD we are returning. */
4076
4077         if (info2->secdesc != NULL) {
4078                 /* don't use talloc_steal() here unless you do a deep steal of all
4079                    the SEC_DESC members */
4080
4081                 r->secdesc = dup_sec_desc(mem_ctx, info2->secdesc);
4082                 W_ERROR_HAVE_NO_MEMORY(r->secdesc);
4083         }
4084
4085         return WERR_OK;
4086 }
4087
4088 /********************************************************************
4089  * construct_printer_info4
4090  * fill a spoolss_PrinterInfo4 struct
4091  ********************************************************************/
4092
4093 static WERROR construct_printer_info4(TALLOC_CTX *mem_ctx,
4094                                       const struct spoolss_PrinterInfo2 *info2,
4095                                       const char *servername,
4096                                       struct spoolss_PrinterInfo4 *r,
4097                                       int snum)
4098 {
4099         WERROR result;
4100
4101         result = create_printername(mem_ctx, servername, info2->printername, &r->printername);
4102         if (!W_ERROR_IS_OK(result)) {
4103                 return result;
4104         }
4105
4106         if (servername) {
4107                 r->servername   = talloc_strdup(mem_ctx, servername);
4108                 W_ERROR_HAVE_NO_MEMORY(r->servername);
4109         } else {
4110                 r->servername = NULL;
4111         }
4112
4113         r->attributes   = info2->attributes;
4114
4115         return WERR_OK;
4116 }
4117
4118 /********************************************************************
4119  * construct_printer_info5
4120  * fill a spoolss_PrinterInfo5 struct
4121  ********************************************************************/
4122
4123 static WERROR construct_printer_info5(TALLOC_CTX *mem_ctx,
4124                                       const struct spoolss_PrinterInfo2 *info2,
4125                                       const char *servername,
4126                                       struct spoolss_PrinterInfo5 *r,
4127                                       int snum)
4128 {
4129         WERROR result;
4130
4131         result = create_printername(mem_ctx, servername, info2->printername, &r->printername);
4132         if (!W_ERROR_IS_OK(result)) {
4133                 return result;
4134         }
4135
4136         r->portname     = talloc_strdup(mem_ctx, info2->portname);
4137         W_ERROR_HAVE_NO_MEMORY(r->portname);
4138
4139         r->attributes   = info2->attributes;
4140
4141         /* these two are not used by NT+ according to MSDN */
4142         r->device_not_selected_timeout          = 0x0;  /* have seen 0x3a98 */
4143         r->transmission_retry_timeout           = 0x0;  /* have seen 0xafc8 */
4144
4145         return WERR_OK;
4146 }
4147
4148 /********************************************************************
4149  * construct_printer_info_6
4150  * fill a spoolss_PrinterInfo6 struct
4151  ********************************************************************/
4152
4153 static WERROR construct_printer_info6(TALLOC_CTX *mem_ctx,
4154                                       struct messaging_context *msg_ctx,
4155                                       const struct spoolss_PrinterInfo2 *info2,
4156                                       const char *servername,
4157                                       struct spoolss_PrinterInfo6 *r,
4158                                       int snum)
4159 {
4160         print_status_struct status;
4161
4162         print_queue_length(msg_ctx, snum, &status);
4163
4164         r->status = nt_printq_status(status.status);
4165
4166         return WERR_OK;
4167 }
4168
4169 /********************************************************************
4170  * construct_printer_info7
4171  * fill a spoolss_PrinterInfo7 struct
4172  ********************************************************************/
4173
4174 static WERROR construct_printer_info7(TALLOC_CTX *mem_ctx,
4175                                       struct messaging_context *msg_ctx,
4176                                       const char *servername,
4177                                       struct spoolss_PrinterInfo7 *r,
4178                                       int snum)
4179 {
4180         const struct auth_session_info *session_info;
4181         char *printer;
4182         WERROR werr;
4183         TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
4184         if (tmp_ctx == NULL) {
4185                 return WERR_NOMEM;
4186         }
4187
4188         session_info = get_session_info_system();
4189         SMB_ASSERT(session_info != NULL);
4190
4191         printer = lp_servicename(tmp_ctx, snum);
4192         if (printer == NULL) {
4193                 DEBUG(0, ("invalid printer snum %d\n", snum));
4194                 werr = WERR_INVALID_PARAM;
4195                 goto out_tmp_free;
4196         }
4197
4198         if (is_printer_published(tmp_ctx, session_info, msg_ctx,
4199                                  servername, printer, NULL)) {
4200                 struct GUID guid;
4201                 werr = nt_printer_guid_get(tmp_ctx, session_info, msg_ctx,
4202                                            printer, &guid);
4203                 if (!W_ERROR_IS_OK(werr)) {
4204                         goto out_tmp_free;
4205                 }
4206                 r->guid = talloc_strdup_upper(mem_ctx, GUID_string2(mem_ctx, &guid));
4207                 r->action = DSPRINT_PUBLISH;
4208         } else {
4209                 r->guid = talloc_strdup(mem_ctx, "");
4210                 r->action = DSPRINT_UNPUBLISH;
4211         }
4212         if (r->guid == NULL) {
4213                 werr = WERR_NOMEM;
4214                 goto out_tmp_free;
4215         }
4216
4217         werr = WERR_OK;
4218 out_tmp_free:
4219         talloc_free(tmp_ctx);
4220         return werr;
4221 }
4222
4223 /********************************************************************
4224  * construct_printer_info8
4225  * fill a spoolss_PrinterInfo8 struct
4226  ********************************************************************/
4227
4228 static WERROR construct_printer_info8(TALLOC_CTX *mem_ctx,
4229                                       const struct spoolss_PrinterInfo2 *info2,
4230                                       const char *servername,
4231                                       struct spoolss_DeviceModeInfo *r,
4232                                       int snum)
4233 {
4234         WERROR result;
4235         const char *printername;
4236
4237         result = create_printername(mem_ctx, servername, info2->printername, &printername);
4238         if (!W_ERROR_IS_OK(result)) {
4239                 return result;
4240         }
4241
4242         if (info2->devmode != NULL) {
4243                 result = copy_devicemode(mem_ctx,
4244                                          info2->devmode,
4245                                          &r->devmode);
4246                 if (!W_ERROR_IS_OK(result)) {
4247                         return result;
4248                 }
4249         } else if (lp_default_devmode(snum)) {
4250                 result = spoolss_create_default_devmode(mem_ctx,
4251                                                         info2->printername,
4252                                                         &r->devmode);
4253                 if (!W_ERROR_IS_OK(result)) {
4254                         return result;
4255                 }
4256         } else {
4257                 r->devmode = NULL;
4258                 DEBUG(8,("Returning NULL Devicemode!\n"));
4259         }
4260
4261         compose_devicemode_devicename(r->devmode, printername);
4262
4263         return WERR_OK;
4264 }
4265
4266
4267 /********************************************************************
4268 ********************************************************************/
4269
4270 static bool snum_is_shared_printer(int snum)
4271 {
4272         return (lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum));
4273 }
4274
4275 /********************************************************************
4276  Spoolss_enumprinters.
4277 ********************************************************************/
4278
4279 static WERROR enum_all_printers_info_level(TALLOC_CTX *mem_ctx,
4280                                            const struct auth_session_info *session_info,
4281                                            struct messaging_context *msg_ctx,
4282                                            const char *servername,
4283                                            uint32_t level,
4284                                            uint32_t flags,
4285                                            union spoolss_PrinterInfo **info_p,
4286                                            uint32_t *count_p)
4287 {
4288         int snum;
4289         int n_services = lp_numservices();
4290         union spoolss_PrinterInfo *info = NULL;
4291         uint32_t count = 0;
4292         WERROR result = WERR_OK;
4293         struct dcerpc_binding_handle *b = NULL;
4294         TALLOC_CTX *tmp_ctx = NULL;
4295
4296         tmp_ctx = talloc_new(mem_ctx);
4297         if (!tmp_ctx) {
4298                 return WERR_NOMEM;
4299         }
4300
4301         *count_p = 0;
4302         *info_p = NULL;
4303
4304         for (snum = 0; snum < n_services; snum++) {
4305
4306                 const char *printer;
4307                 struct spoolss_PrinterInfo2 *info2;
4308
4309                 if (!snum_is_shared_printer(snum)) {
4310                         continue;
4311                 }
4312
4313                 printer = lp_const_servicename(snum);
4314
4315                 DEBUG(4,("Found a printer in smb.conf: %s[%x]\n",
4316                         printer, snum));
4317
4318                 if (b == NULL) {
4319                         result = winreg_printer_binding_handle(tmp_ctx,
4320                                                                session_info,
4321                                                                msg_ctx,
4322                                                                &b);
4323                         if (!W_ERROR_IS_OK(result)) {
4324                                 goto out;
4325                         }
4326                 }
4327
4328                 result = winreg_create_printer(tmp_ctx, b,
4329                                                printer);
4330                 if (!W_ERROR_IS_OK(result)) {
4331                         goto out;
4332                 }
4333
4334                 info = talloc_realloc(tmp_ctx, info,
4335                                             union spoolss_PrinterInfo,
4336                                             count + 1);
4337                 if (!info) {
4338                         result = WERR_NOMEM;
4339                         goto out;
4340                 }
4341
4342                 result = winreg_get_printer(tmp_ctx, b,
4343                                             printer, &info2);
4344                 if (!W_ERROR_IS_OK(result)) {
4345                         goto out;
4346                 }
4347
4348                 switch (level) {
4349                 case 0:
4350                         result = construct_printer_info0(info, session_info,
4351                                                          msg_ctx, info2,
4352                                                          servername,
4353                                                          &info[count].info0, snum);
4354                         break;
4355                 case 1:
4356                         result = construct_printer_info1(info, info2, flags,
4357                                                          servername,
4358                                                          &info[count].info1, snum);
4359                         break;
4360                 case 2:
4361                         result = construct_printer_info2(info, msg_ctx, info2,
4362                                                          servername,
4363                                                          &info[count].info2, snum);
4364                         break;
4365                 case 4:
4366                         result = construct_printer_info4(info, info2,
4367                                                          servername,
4368                                                          &info[count].info4, snum);
4369                         break;
4370                 case 5:
4371                         result = construct_printer_info5(info, info2,
4372                                                          servername,
4373                                                          &info[count].info5, snum);
4374                         break;
4375
4376                 default:
4377                         result = WERR_UNKNOWN_LEVEL;
4378                         goto out;
4379                 }
4380
4381                 if (!W_ERROR_IS_OK(result)) {
4382                         goto out;
4383                 }
4384
4385                 count++;
4386         }
4387
4388 out:
4389         if (W_ERROR_IS_OK(result)) {
4390                 *info_p = talloc_move(mem_ctx, &info);
4391                 *count_p = count;
4392         }
4393
4394         talloc_free(tmp_ctx);
4395
4396         return result;
4397 }
4398
4399 /********************************************************************
4400  * handle enumeration of printers at level 0
4401  ********************************************************************/
4402
4403 static WERROR enumprinters_level0(TALLOC_CTX *mem_ctx,
4404                                   const struct auth_session_info *session_info,
4405                                   struct messaging_context *msg_ctx,
4406                                   uint32_t flags,
4407                                   const char *servername,
4408                                   union spoolss_PrinterInfo **info,
4409                                   uint32_t *count)
4410 {
4411         DEBUG(4,("enum_all_printers_info_0\n"));
4412
4413         return enum_all_printers_info_level(mem_ctx, session_info, msg_ctx,
4414                                             servername, 0, flags, info, count);
4415 }
4416
4417
4418 /********************************************************************
4419 ********************************************************************/
4420
4421 static WERROR enum_all_printers_info_1(TALLOC_CTX *mem_ctx,
4422                                        const struct auth_session_info *session_info,
4423                                        struct messaging_context *msg_ctx,
4424                                        const char *servername,
4425                                        uint32_t flags,
4426                                        union spoolss_PrinterInfo **info,
4427                                        uint32_t *count)
4428 {
4429         DEBUG(4,("enum_all_printers_info_1\n"));
4430
4431         return enum_all_printers_info_level(mem_ctx, session_info, msg_ctx,
4432                                             servername, 1, flags, info, count);
4433 }
4434
4435 /********************************************************************
4436  enum_all_printers_info_1_local.
4437 *********************************************************************/
4438
4439 static WERROR enum_all_printers_info_1_local(TALLOC_CTX *mem_ctx,
4440                                              const struct auth_session_info *session_info,
4441                                              struct messaging_context *msg_ctx,
4442                                              const char *servername,
4443                                              union spoolss_PrinterInfo **info,
4444                                              uint32_t *count)
4445 {
4446         DEBUG(4,("enum_all_printers_info_1_local\n"));
4447
4448         return enum_all_printers_info_1(mem_ctx, session_info, msg_ctx,
4449                                         servername, PRINTER_ENUM_ICON8, info, count);
4450 }
4451
4452 /********************************************************************
4453  enum_all_printers_info_1_name.
4454 *********************************************************************/
4455
4456 static WERROR enum_all_printers_info_1_name(TALLOC_CTX *mem_ctx,
4457                                             const struct auth_session_info *session_info,
4458                                             struct messaging_context *msg_ctx,
4459                                             const char *servername,
4460                                             union spoolss_PrinterInfo **info,
4461                                             uint32_t *count)
4462 {
4463         const char *s = servername;
4464
4465         DEBUG(4,("enum_all_printers_info_1_name\n"));
4466
4467         if (servername != NULL &&
4468             (servername[0] == '\\') && (servername[1] == '\\')) {
4469                 s = servername + 2;
4470         }
4471
4472         if (!is_myname_or_ipaddr(s)) {
4473                 return WERR_INVALID_NAME;
4474         }
4475
4476         return enum_all_printers_info_1(mem_ctx, session_info, msg_ctx,
4477                                         servername, PRINTER_ENUM_ICON8, info, count);
4478 }
4479
4480 /********************************************************************
4481  enum_all_printers_info_1_network.
4482 *********************************************************************/
4483
4484 static WERROR enum_all_printers_info_1_network(TALLOC_CTX *mem_ctx,
4485                                                const struct auth_session_info *session_info,
4486                                                struct messaging_context *msg_ctx,
4487                                                const char *servername,
4488                                                union spoolss_PrinterInfo **info,
4489                                                uint32_t *count)
4490 {
4491         const char *s = servername;
4492
4493         DEBUG(4,("enum_all_printers_info_1_network\n"));
4494
4495         /* If we respond to a enum_printers level 1 on our name with flags
4496            set to PRINTER_ENUM_REMOTE with a list of printers then these
4497            printers incorrectly appear in the APW browse list.
4498            Specifically the printers for the server appear at the workgroup
4499            level where all the other servers in the domain are
4500            listed. Windows responds to this call with a
4501            WERR_CAN_NOT_COMPLETE so we should do the same. */
4502
4503         if (servername != NULL &&
4504             (servername[0] == '\\') && (servername[1] == '\\')) {
4505                  s = servername + 2;
4506         }
4507
4508         if (is_myname_or_ipaddr(s)) {
4509                  return WERR_CAN_NOT_COMPLETE;
4510         }
4511
4512         return enum_all_printers_info_1(mem_ctx, session_info, msg_ctx,
4513                                         servername, PRINTER_ENUM_NAME, info, count);
4514 }
4515
4516 /********************************************************************
4517  * api_spoolss_enumprinters
4518  *
4519  * called from api_spoolss_enumprinters (see this to understand)
4520  ********************************************************************/
4521
4522 static WERROR enum_all_printers_info_2(TALLOC_CTX *mem_ctx,
4523                                        const struct auth_session_info *session_info,
4524                                        struct messaging_context *msg_ctx,
4525                                        const char *servername,
4526                                        union spoolss_PrinterInfo **info,
4527                                        uint32_t *count)
4528 {
4529         DEBUG(4,("enum_all_printers_info_2\n"));
4530
4531         return enum_all_printers_info_level(mem_ctx, session_info, msg_ctx,
4532                                             servername, 2, 0, info, count);
4533 }
4534
4535 /********************************************************************
4536  * handle enumeration of printers at level 1
4537  ********************************************************************/
4538
4539 static WERROR enumprinters_level1(TALLOC_CTX *mem_ctx,
4540                                   const struct auth_session_info *session_info,
4541                                   struct messaging_context *msg_ctx,
4542                                   uint32_t flags,
4543                                   const char *servername,
4544                                   union spoolss_PrinterInfo **info,
4545                                   uint32_t *count)
4546 {
4547         /* Not all the flags are equals */
4548
4549         if (flags & PRINTER_ENUM_LOCAL) {
4550                 return enum_all_printers_info_1_local(mem_ctx, session_info,
4551                                                       msg_ctx, servername, info, count);
4552         }
4553
4554         if (flags & PRINTER_ENUM_NAME) {
4555                 return enum_all_printers_info_1_name(mem_ctx, session_info,
4556                                                      msg_ctx, servername, info,
4557                                                      count);
4558         }
4559
4560         if (flags & PRINTER_ENUM_NETWORK) {
4561                 return enum_all_printers_info_1_network(mem_ctx, session_info,
4562                                                         msg_ctx, servername, info,
4563                                                         count);
4564         }
4565
4566         return WERR_OK; /* NT4sp5 does that */
4567 }
4568
4569 /********************************************************************
4570  * handle enumeration of printers at level 2
4571  ********************************************************************/
4572
4573 static WERROR enumprinters_level2(TALLOC_CTX *mem_ctx,
4574                                   const struct auth_session_info *session_info,
4575                                   struct messaging_context *msg_ctx,
4576                                   uint32_t flags,
4577                                   const char *servername,
4578                                   union spoolss_PrinterInfo **info,
4579                                   uint32_t *count)
4580 {
4581         if (flags & PRINTER_ENUM_LOCAL) {
4582
4583                 return enum_all_printers_info_2(mem_ctx, session_info, msg_ctx,
4584                                                 servername,
4585                                                 info, count);
4586         }
4587
4588         if (flags & PRINTER_ENUM_NAME) {
4589                 if (servername && !is_myname_or_ipaddr(canon_servername(servername))) {
4590                         return WERR_INVALID_NAME;
4591                 }
4592
4593                 return enum_all_printers_info_2(mem_ctx, session_info, msg_ctx,
4594                                                 servername,
4595                                                 info, count);
4596         }
4597
4598         if (flags & PRINTER_ENUM_REMOTE) {
4599                 return WERR_UNKNOWN_LEVEL;
4600         }
4601
4602         return WERR_OK;
4603 }
4604
4605 /********************************************************************
4606  * handle enumeration of printers at level 4
4607  ********************************************************************/
4608
4609 static WERROR enumprinters_level4(TALLOC_CTX *mem_ctx,
4610                                   const struct auth_session_info *session_info,
4611                                   struct messaging_context *msg_ctx,
4612                                   uint32_t flags,
4613                                   const char *servername,
4614                                   union spoolss_PrinterInfo **info,
4615                                   uint32_t *count)
4616 {
4617         DEBUG(4,("enum_all_printers_info_4\n"));
4618
4619         return enum_all_printers_info_level(mem_ctx, session_info, msg_ctx,
4620                                             servername, 4, flags, info, count);
4621 }
4622
4623
4624 /********************************************************************
4625  * handle enumeration of printers at level 5
4626  ********************************************************************/
4627
4628 static WERROR enumprinters_level5(TALLOC_CTX *mem_ctx,
4629                                   const struct auth_session_info *session_info,
4630                                   struct messaging_context *msg_ctx,
4631                                   uint32_t flags,
4632                                   const char *servername,
4633                                   union spoolss_PrinterInfo **info,
4634                                   uint32_t *count)
4635 {
4636         DEBUG(4,("enum_all_printers_info_5\n"));
4637
4638         return enum_all_printers_info_level(mem_ctx, session_info, msg_ctx,
4639                                             servername, 5, flags, info, count);
4640 }
4641
4642 /****************************************************************
4643  _spoolss_EnumPrinters
4644 ****************************************************************/
4645
4646 WERROR _spoolss_EnumPrinters(struct pipes_struct *p,
4647                              struct spoolss_EnumPrinters *r)
4648 {
4649         const struct auth_session_info *session_info = get_session_info_system();
4650         WERROR result;
4651
4652         /* that's an [in out] buffer */
4653
4654         if (!r->in.buffer && (r->in.offered != 0)) {
4655                 return WERR_INVALID_PARAM;
4656         }
4657
4658         DEBUG(4,("_spoolss_EnumPrinters\n"));
4659
4660         *r->out.needed = 0;
4661         *r->out.count = 0;
4662         *r->out.info = NULL;
4663
4664         /*
4665          * Level 1:
4666          *          flags==PRINTER_ENUM_NAME
4667          *           if name=="" then enumerates all printers
4668          *           if name!="" then enumerate the printer
4669          *          flags==PRINTER_ENUM_REMOTE
4670          *          name is NULL, enumerate printers
4671          * Level 2: name!="" enumerates printers, name can't be NULL
4672          * Level 3: doesn't exist
4673          * Level 4: does a local registry lookup
4674          * Level 5: same as Level 2
4675          */
4676
4677         if (r->in.server && r->in.server[0] == '\0') {
4678                 r->in.server = NULL;
4679         }
4680
4681         switch (r->in.level) {
4682         case 0:
4683                 result = enumprinters_level0(p->mem_ctx, session_info,
4684                                              p->msg_ctx, r->in.flags,
4685                                              r->in.server,
4686                                              r->out.info, r->out.count);
4687                 break;
4688         case 1:
4689                 result = enumprinters_level1(p->mem_ctx, session_info,
4690                                              p->msg_ctx, r->in.flags,
4691                                              r->in.server,
4692                                              r->out.info, r->out.count);
4693                 break;
4694         case 2:
4695                 result = enumprinters_level2(p->mem_ctx, session_info,
4696                                              p->msg_ctx, r->in.flags,
4697                                              r->in.server,
4698                                              r->out.info, r->out.count);
4699                 break;
4700         case 4:
4701                 result = enumprinters_level4(p->mem_ctx, session_info,
4702                                              p->msg_ctx, r->in.flags,
4703                                              r->in.server,
4704                                              r->out.info, r->out.count);
4705                 break;
4706         case 5:
4707                 result = enumprinters_level5(p->mem_ctx, session_info,
4708                                              p->msg_ctx, r->in.flags,
4709                                              r->in.server,
4710                                              r->out.info, r->out.count);
4711                 break;
4712         default:
4713                 return WERR_UNKNOWN_LEVEL;
4714         }
4715
4716         if (!W_ERROR_IS_OK(result)) {
4717                 return result;
4718         }
4719
4720         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
4721                                                      spoolss_EnumPrinters,
4722                                                      *r->out.info, r->in.level,
4723                                                      *r->out.count);
4724         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
4725         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
4726
4727         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
4728 }
4729
4730 /****************************************************************
4731  _spoolss_GetPrinter
4732 ****************************************************************/
4733
4734 WERROR _spoolss_GetPrinter(struct pipes_struct *p,
4735                            struct spoolss_GetPrinter *r)
4736 {
4737         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
4738         struct spoolss_PrinterInfo2 *info2 = NULL;
4739         WERROR result = WERR_OK;
4740         int snum;
4741
4742         /* that's an [in out] buffer */
4743
4744         if (!r->in.buffer && (r->in.offered != 0)) {
4745                 return WERR_INVALID_PARAM;
4746         }
4747
4748         *r->out.needed = 0;
4749
4750         if (Printer == NULL) {
4751                 return WERR_BADFID;
4752         }
4753
4754         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
4755                 return WERR_BADFID;
4756         }
4757
4758         result = winreg_get_printer_internal(p->mem_ctx,
4759                                     get_session_info_system(),
4760                                     p->msg_ctx,
4761                                     lp_const_servicename(snum),
4762                                     &info2);
4763         if (!W_ERROR_IS_OK(result)) {
4764                 goto out;
4765         }
4766
4767         switch (r->in.level) {
4768         case 0:
4769                 result = construct_printer_info0(p->mem_ctx,
4770                                                  get_session_info_system(),
4771                                                  p->msg_ctx,
4772                                                  info2,
4773                                                  Printer->servername,
4774                                                  &r->out.info->info0,
4775                                                  snum);
4776                 break;
4777         case 1:
4778                 result = construct_printer_info1(p->mem_ctx, info2,
4779                                                  PRINTER_ENUM_ICON8,
4780                                                  Printer->servername,
4781                                                  &r->out.info->info1, snum);
4782                 break;
4783         case 2:
4784                 result = construct_printer_info2(p->mem_ctx, p->msg_ctx, info2,
4785                                                  Printer->servername,
4786                                                  &r->out.info->info2, snum);
4787                 break;
4788         case 3:
4789                 result = construct_printer_info3(p->mem_ctx, info2,
4790                                                  Printer->servername,
4791                                                  &r->out.info->info3, snum);
4792                 break;
4793         case 4:
4794                 result = construct_printer_info4(p->mem_ctx, info2,
4795                                                  Printer->servername,
4796                                                  &r->out.info->info4, snum);
4797                 break;
4798         case 5:
4799                 result = construct_printer_info5(p->mem_ctx, info2,
4800                                                  Printer->servername,
4801                                                  &r->out.info->info5, snum);
4802                 break;
4803         case 6:
4804                 result = construct_printer_info6(p->mem_ctx, p->msg_ctx, info2,
4805                                                  Printer->servername,
4806                                                  &r->out.info->info6, snum);
4807                 break;
4808         case 7:
4809                 result = construct_printer_info7(p->mem_ctx, p->msg_ctx,
4810                                                  Printer->servername,
4811                                                  &r->out.info->info7, snum);
4812                 break;
4813         case 8:
4814                 result = construct_printer_info8(p->mem_ctx, info2,
4815                                                  Printer->servername,
4816                                                  &r->out.info->info8, snum);
4817                 break;
4818         default:
4819                 result = WERR_UNKNOWN_LEVEL;
4820                 break;
4821         }
4822         TALLOC_FREE(info2);
4823
4824  out:
4825         if (!W_ERROR_IS_OK(result)) {
4826                 DEBUG(0, ("_spoolss_GetPrinter: failed to construct printer info level %d - %s\n",
4827                           r->in.level, win_errstr(result)));
4828                 TALLOC_FREE(r->out.info);
4829                 return result;
4830         }
4831
4832         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_PrinterInfo,
4833                                                r->out.info, r->in.level);
4834         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
4835
4836         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
4837 }
4838
4839 /********************************************************************
4840  ********************************************************************/
4841
4842 #define FILL_DRIVER_STRING(mem_ctx, in, out) \
4843         do { \
4844                 if (in && strlen(in)) { \
4845                         out = talloc_strdup(mem_ctx, in); \
4846                 } else { \
4847                         out = talloc_strdup(mem_ctx, ""); \
4848                 } \
4849                 W_ERROR_HAVE_NO_MEMORY(out); \
4850         } while (0);
4851
4852 #define FILL_DRIVER_UNC_STRING(mem_ctx, server, arch, ver, in, out) \
4853         do { \
4854                 if (in && strlen(in)) { \
4855                         out = talloc_asprintf(mem_ctx, "\\\\%s\\print$\\%s\\%d\\%s", server, get_short_archi(arch), ver, in); \
4856                 } else { \
4857                         out = talloc_strdup(mem_ctx, ""); \
4858                 } \
4859                 W_ERROR_HAVE_NO_MEMORY(out); \
4860         } while (0);
4861
4862 static WERROR string_array_from_driver_info(TALLOC_CTX *mem_ctx,
4863                                                   const char **string_array,
4864                                                   const char ***presult,
4865                                                   const char *cservername,
4866                                                   const char *arch,
4867                                                   int version)
4868 {
4869         int i, num_strings = 0;
4870         const char **array = NULL;
4871
4872         if (string_array == NULL) {
4873                 return WERR_INVALID_PARAMETER;
4874         }
4875
4876         for (i=0; string_array[i] && string_array[i][0] != '\0'; i++) {
4877                 const char *str = NULL;
4878
4879                 if (cservername == NULL || arch == NULL) {
4880                         FILL_DRIVER_STRING(mem_ctx, string_array[i], str);
4881                 } else {
4882                         FILL_DRIVER_UNC_STRING(mem_ctx, cservername, arch, version, string_array[i], str);
4883                 }
4884
4885                 if (!add_string_to_array(mem_ctx, str, &array, &num_strings)) {
4886                         TALLOC_FREE(array);
4887                         return WERR_NOMEM;
4888                 }
4889         }
4890
4891         if (i > 0) {
4892                 ADD_TO_ARRAY(mem_ctx, const char *, NULL,
4893                              &array, &num_strings);
4894         }
4895
4896         if (presult != NULL) {
4897                 *presult = array;
4898         } else {
4899                 talloc_free(array);
4900         }
4901
4902         return WERR_OK;
4903 }
4904
4905 /********************************************************************
4906  * fill a spoolss_DriverInfo1 struct
4907  ********************************************************************/
4908
4909 static WERROR fill_printer_driver_info1(TALLOC_CTX *mem_ctx,
4910                                         struct spoolss_DriverInfo1 *r,
4911                                         const struct spoolss_DriverInfo8 *driver,
4912                                         const char *servername)
4913 {
4914         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
4915         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4916
4917         return WERR_OK;
4918 }
4919
4920 /********************************************************************
4921  * fill a spoolss_DriverInfo2 struct
4922  ********************************************************************/
4923
4924 static WERROR fill_printer_driver_info2(TALLOC_CTX *mem_ctx,
4925                                         struct spoolss_DriverInfo2 *r,
4926                                         const struct spoolss_DriverInfo8 *driver,
4927                                         const char *servername)
4928
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         return WERR_OK;
4958 }
4959
4960 /********************************************************************
4961  * fill a spoolss_DriverInfo3 struct
4962  ********************************************************************/
4963
4964 static WERROR fill_printer_driver_info3(TALLOC_CTX *mem_ctx,
4965                                         struct spoolss_DriverInfo3 *r,
4966                                         const struct spoolss_DriverInfo8 *driver,
4967                                         const char *servername)
4968 {
4969         const char *cservername = canon_servername(servername);
4970
4971         r->version              = driver->version;
4972
4973         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
4974         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4975         r->architecture         = talloc_strdup(mem_ctx, driver->architecture);
4976         W_ERROR_HAVE_NO_MEMORY(r->architecture);
4977
4978         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4979                                driver->architecture,
4980                                driver->version,
4981                                driver->driver_path,
4982                                r->driver_path);
4983
4984         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4985                                driver->architecture,
4986                                driver->version,
4987                                driver->data_file,
4988                                r->data_file);
4989
4990         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4991                                driver->architecture,
4992                                driver->version,
4993                                driver->config_file,
4994                                r->config_file);
4995
4996         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4997                                driver->architecture,
4998                                driver->version,
4999                                driver->help_file,
5000                                r->help_file);
5001
5002         FILL_DRIVER_STRING(mem_ctx,
5003                            driver->monitor_name,
5004                            r->monitor_name);
5005
5006         FILL_DRIVER_STRING(mem_ctx,
5007                            driver->default_datatype,
5008                            r->default_datatype);
5009
5010         return string_array_from_driver_info(mem_ctx,
5011                                              driver->dependent_files,
5012                                              &r->dependent_files,
5013                                              cservername,
5014                                              driver->architecture,
5015                                              driver->version);
5016 }
5017
5018 /********************************************************************
5019  * fill a spoolss_DriverInfo4 struct
5020  ********************************************************************/
5021
5022 static WERROR fill_printer_driver_info4(TALLOC_CTX *mem_ctx,
5023                                         struct spoolss_DriverInfo4 *r,
5024                                         const struct spoolss_DriverInfo8 *driver,
5025                                         const char *servername)
5026 {
5027         const char *cservername = canon_servername(servername);
5028         WERROR result;
5029
5030         r->version              = driver->version;
5031
5032         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
5033         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
5034         r->architecture         = talloc_strdup(mem_ctx, driver->architecture);
5035         W_ERROR_HAVE_NO_MEMORY(r->architecture);
5036
5037         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5038                                driver->architecture,
5039                                driver->version,
5040                                driver->driver_path,
5041                                r->driver_path);
5042
5043         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5044                                driver->architecture,
5045                                driver->version,
5046                                driver->data_file,
5047                                r->data_file);
5048
5049         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5050                                driver->architecture,
5051                                driver->version,
5052                                driver->config_file,
5053                                r->config_file);
5054
5055         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5056                                driver->architecture,
5057                                driver->version,
5058                                driver->help_file,
5059                                r->help_file);
5060
5061         result = string_array_from_driver_info(mem_ctx,
5062                                                driver->dependent_files,
5063                                                &r->dependent_files,
5064                                                cservername,
5065                                                driver->architecture,
5066                                                driver->version);
5067         if (!W_ERROR_IS_OK(result)) {
5068                 return result;
5069         }
5070
5071         FILL_DRIVER_STRING(mem_ctx,
5072                            driver->monitor_name,
5073                            r->monitor_name);
5074
5075         FILL_DRIVER_STRING(mem_ctx,
5076                            driver->default_datatype,
5077                            r->default_datatype);
5078
5079
5080         result = string_array_from_driver_info(mem_ctx,
5081                                                driver->previous_names,
5082                                                &r->previous_names,
5083                                                NULL, NULL, 0);
5084
5085         return result;
5086 }
5087
5088 /********************************************************************
5089  * fill a spoolss_DriverInfo5 struct
5090  ********************************************************************/
5091
5092 static WERROR fill_printer_driver_info5(TALLOC_CTX *mem_ctx,
5093                                         struct spoolss_DriverInfo5 *r,
5094                                         const struct spoolss_DriverInfo8 *driver,
5095                                         const char *servername)
5096 {
5097         const char *cservername = canon_servername(servername);
5098
5099         r->version              = driver->version;
5100
5101         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
5102         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
5103         r->architecture         = talloc_strdup(mem_ctx, driver->architecture);
5104         W_ERROR_HAVE_NO_MEMORY(r->architecture);
5105
5106         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5107                                driver->architecture,
5108                                driver->version,
5109                                driver->driver_path,
5110                                r->driver_path);
5111
5112         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5113                                driver->architecture,
5114                                driver->version,
5115                                driver->data_file,
5116                                r->data_file);
5117
5118         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5119                                driver->architecture,
5120                                driver->version,
5121                                driver->config_file,
5122                                r->config_file);
5123
5124         r->driver_attributes    = 0;
5125         r->config_version       = 0;
5126         r->driver_version       = 0;
5127
5128         return WERR_OK;
5129 }
5130 /********************************************************************
5131  * fill a spoolss_DriverInfo6 struct
5132  ********************************************************************/
5133
5134 static WERROR fill_printer_driver_info6(TALLOC_CTX *mem_ctx,
5135                                         struct spoolss_DriverInfo6 *r,
5136                                         const struct spoolss_DriverInfo8 *driver,
5137                                         const char *servername)
5138 {
5139         const char *cservername = canon_servername(servername);
5140         WERROR result;
5141
5142         r->version              = driver->version;
5143
5144         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
5145         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
5146         r->architecture         = talloc_strdup(mem_ctx, driver->architecture);
5147         W_ERROR_HAVE_NO_MEMORY(r->architecture);
5148
5149         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5150                                driver->architecture,
5151                                driver->version,
5152                                driver->driver_path,
5153                                r->driver_path);
5154
5155         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5156                                driver->architecture,
5157                                driver->version,
5158                                driver->data_file,
5159                                r->data_file);
5160
5161         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5162                                driver->architecture,
5163                                driver->version,
5164                                driver->config_file,
5165                                r->config_file);
5166
5167         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5168                                driver->architecture,
5169                                driver->version,
5170                                driver->help_file,
5171                                r->help_file);
5172
5173         FILL_DRIVER_STRING(mem_ctx,
5174                            driver->monitor_name,
5175                            r->monitor_name);
5176
5177         FILL_DRIVER_STRING(mem_ctx,
5178                            driver->default_datatype,
5179                            r->default_datatype);
5180
5181         result = string_array_from_driver_info(mem_ctx,
5182                                                driver->dependent_files,
5183                                                &r->dependent_files,
5184                                                cservername,
5185                                                driver->architecture,
5186                                                driver->version);
5187         if (!W_ERROR_IS_OK(result)) {
5188                 return result;
5189         }
5190
5191         result = string_array_from_driver_info(mem_ctx,
5192                                                driver->previous_names,
5193                                                &r->previous_names,
5194                                                NULL, NULL, 0);
5195         if (!W_ERROR_IS_OK(result)) {
5196                 return result;
5197         }
5198
5199         r->driver_date          = driver->driver_date;
5200         r->driver_version       = driver->driver_version;
5201
5202         FILL_DRIVER_STRING(mem_ctx,
5203                            driver->manufacturer_name,
5204                            r->manufacturer_name);
5205         FILL_DRIVER_STRING(mem_ctx,
5206                            driver->manufacturer_url,
5207                            r->manufacturer_url);
5208         FILL_DRIVER_STRING(mem_ctx,
5209                            driver->hardware_id,
5210                            r->hardware_id);
5211         FILL_DRIVER_STRING(mem_ctx,
5212                            driver->provider,
5213                            r->provider);
5214
5215         return WERR_OK;
5216 }
5217
5218 /********************************************************************
5219  * fill a spoolss_DriverInfo8 struct
5220  ********************************************************************/
5221
5222 static WERROR fill_printer_driver_info8(TALLOC_CTX *mem_ctx,
5223                                         struct spoolss_DriverInfo8 *r,
5224                                         const struct spoolss_DriverInfo8 *driver,
5225                                         const char *servername)
5226 {
5227         const char *cservername = canon_servername(servername);
5228         WERROR result;
5229
5230         r->version              = driver->version;
5231
5232         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
5233         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
5234         r->architecture         = talloc_strdup(mem_ctx, driver->architecture);
5235         W_ERROR_HAVE_NO_MEMORY(r->architecture);
5236
5237         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5238                                driver->architecture,
5239                                driver->version,
5240                                driver->driver_path,
5241                                r->driver_path);
5242
5243         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5244                                driver->architecture,
5245                                driver->version,
5246                                driver->data_file,
5247                                r->data_file);
5248
5249         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5250                                driver->architecture,
5251                                driver->version,
5252                                driver->config_file,
5253                                r->config_file);
5254
5255         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5256                                driver->architecture,
5257                                driver->version,
5258                                driver->help_file,
5259                                r->help_file);
5260
5261         FILL_DRIVER_STRING(mem_ctx,
5262                            driver->monitor_name,
5263                            r->monitor_name);
5264
5265         FILL_DRIVER_STRING(mem_ctx,
5266                            driver->default_datatype,
5267                            r->default_datatype);
5268
5269         result = string_array_from_driver_info(mem_ctx,
5270                                                driver->dependent_files,
5271                                                &r->dependent_files,
5272                                                cservername,
5273                                                driver->architecture,
5274                                                driver->version);
5275         if (!W_ERROR_IS_OK(result)) {
5276                 return result;
5277         }
5278
5279         result = string_array_from_driver_info(mem_ctx,
5280                                                driver->previous_names,
5281                                                &r->previous_names,
5282                                                NULL, NULL, 0);
5283         if (!W_ERROR_IS_OK(result)) {
5284                 return result;
5285         }
5286
5287         r->driver_date          = driver->driver_date;
5288         r->driver_version       = driver->driver_version;
5289
5290         FILL_DRIVER_STRING(mem_ctx,
5291                            driver->manufacturer_name,
5292                            r->manufacturer_name);
5293         FILL_DRIVER_STRING(mem_ctx,
5294                            driver->manufacturer_url,
5295                            r->manufacturer_url);
5296         FILL_DRIVER_STRING(mem_ctx,
5297                            driver->hardware_id,
5298                            r->hardware_id);
5299         FILL_DRIVER_STRING(mem_ctx,
5300                            driver->provider,
5301                            r->provider);
5302
5303         FILL_DRIVER_STRING(mem_ctx,
5304                            driver->print_processor,
5305                            r->print_processor);
5306         FILL_DRIVER_STRING(mem_ctx,
5307                            driver->vendor_setup,
5308                            r->vendor_setup);
5309
5310         result = string_array_from_driver_info(mem_ctx,
5311                                                driver->color_profiles,
5312                                                &r->color_profiles,
5313                                                NULL, NULL, 0);
5314         if (!W_ERROR_IS_OK(result)) {
5315                 return result;
5316         }
5317
5318         FILL_DRIVER_STRING(mem_ctx,
5319                            driver->inf_path,
5320                            r->inf_path);
5321
5322         r->printer_driver_attributes    = driver->printer_driver_attributes;
5323
5324         result = string_array_from_driver_info(mem_ctx,
5325                                                driver->core_driver_dependencies,
5326                                                &r->core_driver_dependencies,
5327                                                NULL, NULL, 0);
5328         if (!W_ERROR_IS_OK(result)) {
5329                 return result;
5330         }
5331
5332         r->min_inbox_driver_ver_date    = driver->min_inbox_driver_ver_date;
5333         r->min_inbox_driver_ver_version = driver->min_inbox_driver_ver_version;
5334
5335         return WERR_OK;
5336 }
5337
5338 #if 0 /* disabled until marshalling issues are resolved - gd */
5339 /********************************************************************
5340  ********************************************************************/
5341
5342 static WERROR fill_spoolss_DriverFileInfo(TALLOC_CTX *mem_ctx,
5343                                           struct spoolss_DriverFileInfo *r,
5344                                           const char *cservername,
5345                                           const char *file_name,
5346                                           enum spoolss_DriverFileType file_type,
5347                                           uint32_t file_version)
5348 {
5349         r->file_name    = talloc_asprintf(mem_ctx, "\\\\%s%s",
5350                                           cservername, file_name);
5351         W_ERROR_HAVE_NO_MEMORY(r->file_name);
5352         r->file_type    = file_type;
5353         r->file_version = file_version;
5354
5355         return WERR_OK;
5356 }
5357
5358 /********************************************************************
5359  ********************************************************************/
5360
5361 static WERROR spoolss_DriverFileInfo_from_driver(TALLOC_CTX *mem_ctx,
5362                                                  const struct spoolss_DriverInfo8 *driver,
5363                                                  const char *cservername,
5364                                                  struct spoolss_DriverFileInfo **info_p,
5365                                                  uint32_t *count_p)
5366 {
5367         struct spoolss_DriverFileInfo *info = NULL;
5368         uint32_t count = 0;
5369         WERROR result;
5370         uint32_t i;
5371
5372         *info_p = NULL;
5373         *count_p = 0;
5374
5375         if (strlen(driver->driver_path)) {
5376                 info = talloc_realloc(mem_ctx, info,
5377                                             struct spoolss_DriverFileInfo,
5378                                             count + 1);
5379                 W_ERROR_HAVE_NO_MEMORY(info);
5380                 result = fill_spoolss_DriverFileInfo(info,
5381                                                      &info[count],
5382                                                      cservername,
5383                                                      driver->driver_path,
5384                                                      SPOOLSS_DRIVER_FILE_TYPE_RENDERING,
5385                                                      0);
5386                 W_ERROR_NOT_OK_RETURN(result);
5387                 count++;
5388         }
5389
5390         if (strlen(driver->config_file)) {
5391                 info = talloc_realloc(mem_ctx, info,
5392                                             struct spoolss_DriverFileInfo,
5393                                             count + 1);
5394                 W_ERROR_HAVE_NO_MEMORY(info);
5395                 result = fill_spoolss_DriverFileInfo(info,
5396                                                      &info[count],
5397                                                      cservername,
5398                                                      driver->config_file,
5399                                                      SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION,
5400                                                      0);
5401                 W_ERROR_NOT_OK_RETURN(result);
5402                 count++;
5403         }
5404
5405         if (strlen(driver->data_file)) {
5406                 info = talloc_realloc(mem_ctx, info,
5407                                             struct spoolss_DriverFileInfo,
5408                                             count + 1);
5409                 W_ERROR_HAVE_NO_MEMORY(info);
5410                 result = fill_spoolss_DriverFileInfo(info,
5411                                                      &info[count],
5412                                                      cservername,
5413                                                      driver->data_file,
5414                                                      SPOOLSS_DRIVER_FILE_TYPE_DATA,
5415                                                      0);
5416                 W_ERROR_NOT_OK_RETURN(result);
5417                 count++;
5418         }
5419
5420         if (strlen(driver->help_file)) {
5421                 info = talloc_realloc(mem_ctx, info,
5422                                             struct spoolss_DriverFileInfo,
5423                                             count + 1);
5424                 W_ERROR_HAVE_NO_MEMORY(info);
5425                 result = fill_spoolss_DriverFileInfo(info,
5426                                                      &info[count],
5427                                                      cservername,
5428                                                      driver->help_file,
5429                                                      SPOOLSS_DRIVER_FILE_TYPE_HELP,
5430                                                      0);
5431                 W_ERROR_NOT_OK_RETURN(result);
5432                 count++;
5433         }
5434
5435         for (i=0; driver->dependent_files[i] && driver->dependent_files[i][0] != '\0'; i++) {
5436                 info = talloc_realloc(mem_ctx, info,
5437                                             struct spoolss_DriverFileInfo,
5438                                             count + 1);
5439                 W_ERROR_HAVE_NO_MEMORY(info);
5440                 result = fill_spoolss_DriverFileInfo(info,
5441                                                      &info[count],
5442                                                      cservername,
5443                                                      driver->dependent_files[i],
5444                                                      SPOOLSS_DRIVER_FILE_TYPE_OTHER,
5445                                                      0);
5446                 W_ERROR_NOT_OK_RETURN(result);
5447                 count++;
5448         }
5449
5450         *info_p = info;
5451         *count_p = count;
5452
5453         return WERR_OK;
5454 }
5455
5456 /********************************************************************
5457  * fill a spoolss_DriverInfo101 struct
5458  ********************************************************************/
5459
5460 static WERROR fill_printer_driver_info101(TALLOC_CTX *mem_ctx,
5461                                           struct spoolss_DriverInfo101 *r,
5462                                           const struct spoolss_DriverInfo8 *driver,
5463                                           const char *servername)
5464 {
5465         const char *cservername = canon_servername(servername);
5466         WERROR result;
5467
5468         r->version              = driver->version;
5469
5470         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
5471         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
5472         r->architecture         = talloc_strdup(mem_ctx, driver->architecture);
5473         W_ERROR_HAVE_NO_MEMORY(r->architecture);
5474
5475         result = spoolss_DriverFileInfo_from_driver(mem_ctx, driver,
5476                                                     cservername,
5477                                                     &r->file_info,
5478                                                     &r->file_count);
5479         if (!W_ERROR_IS_OK(result)) {
5480                 return result;
5481         }
5482
5483         FILL_DRIVER_STRING(mem_ctx,
5484                            driver->monitor_name,
5485                            r->monitor_name);
5486
5487         FILL_DRIVER_STRING(mem_ctx,
5488                            driver->default_datatype,
5489                            r->default_datatype);
5490
5491         result = string_array_from_driver_info(mem_ctx,
5492                                                driver->previous_names,
5493                                                &r->previous_names,
5494                                                NULL, NULL, 0);
5495         if (!W_ERROR_IS_OK(result)) {
5496                 return result;
5497         }
5498
5499         r->driver_date          = driver->driver_date;
5500         r->driver_version       = driver->driver_version;
5501
5502         FILL_DRIVER_STRING(mem_ctx,
5503                            driver->manufacturer_name,
5504                            r->manufacturer_name);
5505         FILL_DRIVER_STRING(mem_ctx,
5506                            driver->manufacturer_url,
5507                            r->manufacturer_url);
5508         FILL_DRIVER_STRING(mem_ctx,
5509                            driver->hardware_id,
5510                            r->hardware_id);
5511         FILL_DRIVER_STRING(mem_ctx,
5512                            driver->provider,
5513                            r->provider);
5514
5515         return WERR_OK;
5516 }
5517 #endif
5518 /********************************************************************
5519  ********************************************************************/
5520
5521 static WERROR construct_printer_driver_info_level(TALLOC_CTX *mem_ctx,
5522                                                   const struct auth_session_info *session_info,
5523                                                   struct messaging_context *msg_ctx,
5524                                                   uint32_t level,
5525                                                   union spoolss_DriverInfo *r,
5526                                                   int snum,
5527                                                   const char *servername,
5528                                                   const char *architecture,
5529                                                   uint32_t version)
5530 {
5531         struct spoolss_PrinterInfo2 *pinfo2 = NULL;
5532         struct spoolss_DriverInfo8 *driver;
5533         WERROR result;
5534         struct dcerpc_binding_handle *b;
5535         TALLOC_CTX *tmp_ctx = NULL;
5536
5537         if (level == 101) {
5538                 return WERR_UNKNOWN_LEVEL;
5539         }
5540
5541         tmp_ctx = talloc_new(mem_ctx);
5542         if (!tmp_ctx) {
5543                 return WERR_NOMEM;
5544         }
5545
5546         result = winreg_printer_binding_handle(tmp_ctx,
5547                                                session_info,
5548                                                msg_ctx,
5549                                                &b);
5550         if (!W_ERROR_IS_OK(result)) {
5551                 goto done;
5552         }
5553
5554         result = winreg_get_printer(tmp_ctx, b,
5555                                     lp_const_servicename(snum),
5556                                     &pinfo2);
5557
5558         DEBUG(8,("construct_printer_driver_info_level: status: %s\n",
5559                 win_errstr(result)));
5560
5561         if (!W_ERROR_IS_OK(result)) {
5562                 result = WERR_INVALID_PRINTER_NAME;
5563                 goto done;
5564         }
5565
5566         result = winreg_get_driver(tmp_ctx, b,
5567                                    architecture,
5568                                    pinfo2->drivername, version, &driver);
5569
5570         DEBUG(8,("construct_printer_driver_info_level: status: %s\n",
5571                 win_errstr(result)));
5572
5573         if (!W_ERROR_IS_OK(result)) {
5574                 /*
5575                  * Is this a W2k client ?
5576                  */
5577
5578                 if (version < 3) {
5579                         result = WERR_UNKNOWN_PRINTER_DRIVER;
5580                         goto done;
5581                 }
5582
5583                 /* Yes - try again with a WinNT driver. */
5584                 version = 2;
5585                 result = winreg_get_driver(tmp_ctx, b,
5586                                            architecture,
5587                                            pinfo2->drivername,
5588                                            version, &driver);
5589                 DEBUG(8,("construct_printer_driver_level: status: %s\n",
5590                         win_errstr(result)));
5591                 if (!W_ERROR_IS_OK(result)) {
5592                         result = WERR_UNKNOWN_PRINTER_DRIVER;
5593                         goto done;
5594                 }
5595         }
5596
5597         /* these are allocated on mem_ctx and not tmp_ctx because they are
5598          * the 'return value' and need to utlive this call */
5599         switch (level) {
5600         case 1:
5601                 result = fill_printer_driver_info1(mem_ctx, &r->info1, driver, servername);
5602                 break;
5603         case 2:
5604                 result = fill_printer_driver_info2(mem_ctx, &r->info2, driver, servername);
5605                 break;
5606         case 3:
5607                 result = fill_printer_driver_info3(mem_ctx, &r->info3, driver, servername);
5608                 break;
5609         case 4:
5610                 result = fill_printer_driver_info4(mem_ctx, &r->info4, driver, servername);
5611                 break;
5612         case 5:
5613                 result = fill_printer_driver_info5(mem_ctx, &r->info5, driver, servername);
5614                 break;
5615         case 6:
5616                 result = fill_printer_driver_info6(mem_ctx, &r->info6, driver, servername);
5617                 break;
5618         case 8:
5619                 result = fill_printer_driver_info8(mem_ctx, &r->info8, driver, servername);
5620                 break;
5621 #if 0 /* disabled until marshalling issues are resolved - gd */
5622         case 101:
5623                 result = fill_printer_driver_info101(mem_ctx, &r->info101, driver, servername);
5624                 break;
5625 #endif
5626         default:
5627                 result = WERR_UNKNOWN_LEVEL;
5628                 break;
5629         }
5630
5631 done:
5632         talloc_free(tmp_ctx);
5633         return result;
5634 }
5635
5636 /****************************************************************
5637  _spoolss_GetPrinterDriver2
5638 ****************************************************************/
5639
5640 WERROR _spoolss_GetPrinterDriver2(struct pipes_struct *p,
5641                                   struct spoolss_GetPrinterDriver2 *r)
5642 {
5643         struct printer_handle *printer;
5644         WERROR result;
5645         uint32_t version = r->in.client_major_version;
5646
5647         int snum;
5648
5649         /* that's an [in out] buffer */
5650
5651         if (!r->in.buffer && (r->in.offered != 0)) {
5652                 return WERR_INVALID_PARAM;
5653         }
5654
5655         DEBUG(4,("_spoolss_GetPrinterDriver2\n"));
5656
5657         if (!(printer = find_printer_index_by_hnd(p, r->in.handle))) {
5658                 DEBUG(0,("_spoolss_GetPrinterDriver2: invalid printer handle!\n"));
5659                 return WERR_INVALID_PRINTER_NAME;
5660         }
5661
5662         *r->out.needed = 0;
5663         *r->out.server_major_version = 0;
5664         *r->out.server_minor_version = 0;
5665
5666         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5667                 return WERR_BADFID;
5668         }
5669
5670         if (r->in.client_major_version == SPOOLSS_DRIVER_VERSION_2012) {
5671                 DEBUG(3,("_spoolss_GetPrinterDriver2: v4 driver requested, "
5672                         "downgrading to v3\n"));
5673                 version = SPOOLSS_DRIVER_VERSION_200X;
5674         }
5675
5676         result = construct_printer_driver_info_level(p->mem_ctx,
5677                                                      get_session_info_system(),
5678                                                      p->msg_ctx,
5679                                                      r->in.level, r->out.info,
5680                                                      snum, printer->servername,
5681                                                      r->in.architecture,
5682                                                      version);
5683         if (!W_ERROR_IS_OK(result)) {
5684                 TALLOC_FREE(r->out.info);
5685                 return result;
5686         }
5687
5688         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_DriverInfo,
5689                                                r->out.info, r->in.level);
5690         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
5691
5692         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
5693 }
5694
5695
5696 /****************************************************************
5697  _spoolss_StartPagePrinter
5698 ****************************************************************/
5699
5700 WERROR _spoolss_StartPagePrinter(struct pipes_struct *p,
5701                                  struct spoolss_StartPagePrinter *r)
5702 {
5703         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
5704
5705         if (!Printer) {
5706                 DEBUG(3,("_spoolss_StartPagePrinter: "
5707                         "Error in startpageprinter printer handle\n"));
5708                 return WERR_BADFID;
5709         }
5710
5711         Printer->page_started = true;
5712         return WERR_OK;
5713 }
5714
5715 /****************************************************************
5716  _spoolss_EndPagePrinter
5717 ****************************************************************/
5718
5719 WERROR _spoolss_EndPagePrinter(struct pipes_struct *p,
5720                                struct spoolss_EndPagePrinter *r)
5721 {
5722         int snum;
5723
5724         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
5725
5726         if (!Printer) {
5727                 DEBUG(2,("_spoolss_EndPagePrinter: Invalid handle (%s:%u:%u).\n",
5728                         OUR_HANDLE(r->in.handle)));
5729                 return WERR_BADFID;
5730         }
5731
5732         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5733                 return WERR_BADFID;
5734
5735         Printer->page_started = false;
5736         print_job_endpage(p->msg_ctx, snum, Printer->jobid);
5737
5738         return WERR_OK;
5739 }
5740
5741 /****************************************************************
5742  _spoolss_StartDocPrinter
5743 ****************************************************************/
5744
5745 WERROR _spoolss_StartDocPrinter(struct pipes_struct *p,
5746                                 struct spoolss_StartDocPrinter *r)
5747 {
5748         struct spoolss_DocumentInfo1 *info_1;
5749         int snum;
5750         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
5751         WERROR werr;
5752         char *rhost;
5753         int rc;
5754
5755         if (!Printer) {
5756                 DEBUG(2,("_spoolss_StartDocPrinter: "
5757                         "Invalid handle (%s:%u:%u)\n",
5758                         OUR_HANDLE(r->in.handle)));
5759                 return WERR_BADFID;
5760         }
5761
5762         if (Printer->jobid) {
5763                 DEBUG(2, ("_spoolss_StartDocPrinter: "
5764                           "StartDocPrinter called twice! "
5765                           "(existing jobid = %d)\n", Printer->jobid));
5766                 return WERR_INVALID_HANDLE;
5767         }
5768
5769         if (r->in.info_ctr->level != 1) {
5770                 return WERR_UNKNOWN_LEVEL;
5771         }
5772
5773         info_1 = r->in.info_ctr->info.info1;
5774
5775         /*
5776          * a nice thing with NT is it doesn't listen to what you tell it.
5777          * when asked to send _only_ RAW datas, it tries to send datas
5778          * in EMF format.
5779          *
5780          * So I add checks like in NT Server ...
5781          */
5782
5783         if (info_1->datatype) {
5784                 if (strcmp(info_1->datatype, "RAW") != 0) {
5785                         *r->out.job_id = 0;
5786                         return WERR_INVALID_DATATYPE;
5787                 }
5788         }
5789
5790         /* get the share number of the printer */
5791         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5792                 return WERR_BADFID;
5793         }
5794
5795         rc = get_remote_hostname(p->remote_address,
5796                                  &rhost,
5797                                  p->mem_ctx);
5798         if (rc < 0) {
5799                 return WERR_NOMEM;
5800         }
5801         if (strequal(rhost,"UNKNOWN")) {
5802                 rhost = tsocket_address_inet_addr_string(p->remote_address,
5803                                                          p->mem_ctx);
5804                 if (rhost == NULL) {
5805                         return WERR_NOMEM;
5806                 }
5807         }
5808
5809         werr = print_job_start(p->session_info,
5810                                p->msg_ctx,
5811                                rhost,
5812                                snum,
5813                                info_1->document_name,
5814                                info_1->output_file,
5815                                Printer->devmode,
5816                                &Printer->jobid);
5817
5818         /* An error occured in print_job_start() so return an appropriate
5819            NT error code. */
5820
5821         if (!W_ERROR_IS_OK(werr)) {
5822                 return werr;
5823         }
5824
5825         Printer->document_started = true;
5826         *r->out.job_id = Printer->jobid;
5827
5828         return WERR_OK;
5829 }
5830
5831 /****************************************************************
5832  _spoolss_EndDocPrinter
5833 ****************************************************************/
5834
5835 WERROR _spoolss_EndDocPrinter(struct pipes_struct *p,
5836                               struct spoolss_EndDocPrinter *r)
5837 {
5838         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
5839         NTSTATUS status;
5840         int snum;
5841
5842         if (!Printer) {
5843                 DEBUG(2,("_spoolss_EndDocPrinter: Invalid handle (%s:%u:%u)\n",
5844                         OUR_HANDLE(r->in.handle)));
5845                 return WERR_BADFID;
5846         }
5847
5848         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5849                 return WERR_BADFID;
5850         }
5851
5852         Printer->document_started = false;
5853         status = print_job_end(p->msg_ctx, snum, Printer->jobid, NORMAL_CLOSE);
5854         if (!NT_STATUS_IS_OK(status)) {
5855                 DEBUG(2, ("_spoolss_EndDocPrinter: "
5856                           "print_job_end failed [%s]\n",
5857                           nt_errstr(status)));
5858         }
5859
5860         Printer->jobid = 0;
5861         return ntstatus_to_werror(status);
5862 }
5863
5864 /****************************************************************
5865  _spoolss_WritePrinter
5866 ****************************************************************/
5867
5868 WERROR _spoolss_WritePrinter(struct pipes_struct *p,
5869                              struct spoolss_WritePrinter *r)
5870 {
5871         ssize_t buffer_written;
5872         int snum;
5873         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
5874
5875         if (!Printer) {
5876                 DEBUG(2,("_spoolss_WritePrinter: Invalid handle (%s:%u:%u)\n",
5877                         OUR_HANDLE(r->in.handle)));
5878                 *r->out.num_written = r->in._data_size;
5879                 return WERR_BADFID;
5880         }
5881
5882         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5883                 return WERR_BADFID;
5884
5885         /* print_job_write takes care of checking for PJOB_SMBD_SPOOLING */
5886         buffer_written = print_job_write(server_event_context(),p->msg_ctx,
5887                                                    snum, Printer->jobid,
5888                                                    (const char *)r->in.data.data,
5889                                                    (size_t)r->in._data_size);
5890         if (buffer_written == (ssize_t)-1) {
5891                 *r->out.num_written = 0;
5892                 if (errno == ENOSPC)
5893                         return WERR_NO_SPOOL_SPACE;
5894                 else
5895                         return WERR_ACCESS_DENIED;
5896         }
5897
5898         *r->out.num_written = r->in._data_size;
5899
5900         return WERR_OK;
5901 }
5902
5903 /********************************************************************
5904  * api_spoolss_getprinter
5905  * called from the spoolss dispatcher
5906  *
5907  ********************************************************************/
5908
5909 static WERROR control_printer(struct policy_handle *handle, uint32_t command,
5910                               struct pipes_struct *p)
5911 {
5912         const struct auth_session_info *session_info = p->session_info;
5913         int snum;
5914         WERROR errcode = WERR_BADFUNC;
5915         struct printer_handle *Printer = find_printer_index_by_hnd(p, handle);
5916
5917         if (!Printer) {
5918                 DEBUG(2,("control_printer: Invalid handle (%s:%u:%u)\n",
5919                         OUR_HANDLE(handle)));
5920                 return WERR_BADFID;
5921         }
5922
5923         if (!get_printer_snum(p, handle, &snum, NULL))
5924                 return WERR_BADFID;
5925
5926         switch (command) {
5927         case SPOOLSS_PRINTER_CONTROL_PAUSE:
5928                 errcode = print_queue_pause(session_info, p->msg_ctx, snum);
5929                 break;
5930         case SPOOLSS_PRINTER_CONTROL_RESUME:
5931         case SPOOLSS_PRINTER_CONTROL_UNPAUSE:
5932                 errcode = print_queue_resume(session_info, p->msg_ctx, snum);
5933                 break;
5934         case SPOOLSS_PRINTER_CONTROL_PURGE:
5935                 errcode = print_queue_purge(session_info, p->msg_ctx, snum);
5936                 break;
5937         default:
5938                 return WERR_UNKNOWN_LEVEL;
5939         }
5940
5941         return errcode;
5942 }
5943
5944
5945 /****************************************************************
5946  _spoolss_AbortPrinter
5947  * From MSDN: "Deletes printer's spool file if printer is configured
5948  * for spooling"
5949 ****************************************************************/
5950
5951 WERROR _spoolss_AbortPrinter(struct pipes_struct *p,
5952                              struct spoolss_AbortPrinter *r)
5953 {
5954         struct printer_handle   *Printer = find_printer_index_by_hnd(p, r->in.handle);
5955         int             snum;
5956         WERROR          errcode = WERR_OK;
5957
5958         if (!Printer) {
5959                 DEBUG(2,("_spoolss_AbortPrinter: Invalid handle (%s:%u:%u)\n",
5960                         OUR_HANDLE(r->in.handle)));
5961                 return WERR_BADFID;
5962         }
5963
5964         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5965                 return WERR_BADFID;
5966
5967         if (!Printer->document_started) {
5968                 return WERR_SPL_NO_STARTDOC;
5969         }
5970
5971         errcode = print_job_delete(p->session_info,
5972                                    p->msg_ctx,
5973                                    snum,
5974                                    Printer->jobid);
5975
5976         return errcode;
5977 }
5978
5979 /********************************************************************
5980  * called by spoolss_api_setprinter
5981  * when updating a printer description
5982  ********************************************************************/
5983
5984 static WERROR update_printer_sec(struct policy_handle *handle,
5985                                  struct pipes_struct *p,
5986                                  struct sec_desc_buf *secdesc_ctr)
5987 {
5988         struct spoolss_security_descriptor *new_secdesc = NULL;
5989         struct spoolss_security_descriptor *old_secdesc = NULL;
5990         const char *printer;
5991         WERROR result;
5992         int snum;
5993         struct printer_handle *Printer = find_printer_index_by_hnd(p, handle);
5994         struct dcerpc_binding_handle *b;
5995         TALLOC_CTX *tmp_ctx = NULL;
5996
5997         if (!Printer || !get_printer_snum(p, handle, &snum, NULL)) {
5998                 DEBUG(2,("update_printer_sec: Invalid handle (%s:%u:%u)\n",
5999                          OUR_HANDLE(handle)));
6000
6001                 result = WERR_BADFID;
6002                 goto done;
6003         }
6004
6005         if (secdesc_ctr == NULL) {
6006                 DEBUG(10,("update_printer_sec: secdesc_ctr is NULL !\n"));
6007                 result = WERR_INVALID_PARAM;
6008                 goto done;
6009         }
6010         printer = lp_const_servicename(snum);
6011
6012         /* Check the user has permissions to change the security
6013            descriptor.  By experimentation with two NT machines, the user
6014            requires Full Access to the printer to change security
6015            information. */
6016
6017         if ( Printer->access_granted != PRINTER_ACCESS_ADMINISTER ) {
6018                 DEBUG(4,("update_printer_sec: updated denied by printer permissions\n"));
6019                 result = WERR_ACCESS_DENIED;
6020                 goto done;
6021         }
6022
6023         tmp_ctx = talloc_new(p->mem_ctx);
6024         if (!tmp_ctx) {
6025                 return WERR_NOMEM;
6026         }
6027
6028         result = winreg_printer_binding_handle(tmp_ctx,
6029                                                get_session_info_system(),
6030                                                p->msg_ctx,
6031                                                &b);
6032         if (!W_ERROR_IS_OK(result)) {
6033                 goto done;
6034         }
6035
6036         /* NT seems to like setting the security descriptor even though
6037            nothing may have actually changed. */
6038         result = winreg_get_printer_secdesc(tmp_ctx, b,
6039                                             printer,
6040                                             &old_secdesc);
6041         if (!W_ERROR_IS_OK(result)) {
6042                 DEBUG(2,("update_printer_sec: winreg_get_printer_secdesc_internal() failed\n"));
6043                 result = WERR_BADFID;
6044                 goto done;
6045         }
6046
6047         if (DEBUGLEVEL >= 10) {
6048                 struct security_acl *the_acl;
6049                 int i;
6050
6051                 the_acl = old_secdesc->dacl;
6052                 DEBUG(10, ("old_secdesc_ctr for %s has %d aces:\n",
6053                            printer, the_acl->num_aces));
6054
6055                 for (i = 0; i < the_acl->num_aces; i++) {
6056                         DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
6057                                            &the_acl->aces[i].trustee),
6058                                   the_acl->aces[i].access_mask));
6059                 }
6060
6061                 the_acl = secdesc_ctr->sd->dacl;
6062
6063                 if (the_acl) {
6064                         DEBUG(10, ("secdesc_ctr for %s has %d aces:\n",
6065                                    printer, the_acl->num_aces));
6066
6067                         for (i = 0; i < the_acl->num_aces; i++) {
6068                                 DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
6069                                                    &the_acl->aces[i].trustee),
6070                                            the_acl->aces[i].access_mask));
6071                         }
6072                 } else {
6073                         DEBUG(10, ("dacl for secdesc_ctr is NULL\n"));
6074                 }
6075         }
6076
6077         new_secdesc = sec_desc_merge(tmp_ctx, secdesc_ctr->sd, old_secdesc);
6078         if (new_secdesc == NULL) {
6079                 result = WERR_NOMEM;
6080                 goto done;
6081         }
6082
6083         if (security_descriptor_equal(new_secdesc, old_secdesc)) {
6084                 result = WERR_OK;
6085                 goto done;
6086         }
6087
6088         result = winreg_set_printer_secdesc(tmp_ctx, b,
6089                                             printer,
6090                                             new_secdesc);
6091
6092 done:
6093         talloc_free(tmp_ctx);
6094         return result;
6095 }
6096
6097 /********************************************************************
6098  Canonicalize printer info from a client
6099  ********************************************************************/
6100
6101 static bool check_printer_ok(TALLOC_CTX *mem_ctx,
6102                              struct spoolss_SetPrinterInfo2 *info2,
6103                              int snum)
6104 {
6105         fstring printername;
6106         const char *p;
6107
6108         DEBUG(5,("check_printer_ok: servername=%s printername=%s sharename=%s "
6109                 "portname=%s drivername=%s comment=%s location=%s\n",
6110                 info2->servername, info2->printername, info2->sharename,
6111                 info2->portname, info2->drivername, info2->comment,
6112                 info2->location));
6113
6114         /* we force some elements to "correct" values */
6115         info2->servername = talloc_asprintf(mem_ctx, "\\\\%s", lp_netbios_name());
6116         if (info2->servername == NULL) {
6117                 return false;
6118         }
6119         info2->sharename = talloc_strdup(mem_ctx, lp_const_servicename(snum));
6120         if (info2->sharename == NULL) {
6121                 return false;
6122         }
6123
6124         /* check to see if we allow printername != sharename */
6125         if (lp_force_printername(snum)) {
6126                 info2->printername = talloc_asprintf(mem_ctx, "\\\\%s\\%s",
6127                                         lp_netbios_name(), info2->sharename);
6128         } else {
6129                 /* make sure printername is in \\server\printername format */
6130                 fstrcpy(printername, info2->printername);
6131                 p = printername;
6132                 if ( printername[0] == '\\' && printername[1] == '\\' ) {
6133                         if ( (p = strchr_m( &printername[2], '\\' )) != NULL )
6134                                 p++;
6135                 }
6136
6137                 info2->printername = talloc_asprintf(mem_ctx, "\\\\%s\\%s",
6138                                         lp_netbios_name(), p);
6139         }
6140         if (info2->printername == NULL) {
6141                 return false;
6142         }
6143
6144         info2->attributes |= PRINTER_ATTRIBUTE_SAMBA;
6145         info2->attributes &= ~PRINTER_ATTRIBUTE_NOT_SAMBA;
6146
6147         return true;
6148 }
6149
6150 /****************************************************************************
6151 ****************************************************************************/
6152
6153 static WERROR add_port_hook(TALLOC_CTX *ctx, struct security_token *token, const char *portname, const char *uri)
6154 {
6155         char *cmd = lp_addport_cmd(talloc_tos());
6156         char *command = NULL;
6157         int ret;
6158         bool is_print_op = false;
6159
6160         if ( !*cmd ) {
6161                 return WERR_ACCESS_DENIED;
6162         }
6163
6164         command = talloc_asprintf(ctx,
6165                         "%s \"%s\" \"%s\"", cmd, portname, uri );
6166         if (!command) {
6167                 return WERR_NOMEM;
6168         }
6169
6170         if ( token )
6171                 is_print_op = security_token_has_privilege(token, SEC_PRIV_PRINT_OPERATOR);
6172
6173         DEBUG(10,("Running [%s]\n", command));
6174
6175         /********* BEGIN SePrintOperatorPrivilege **********/
6176
6177         if ( is_print_op )
6178                 become_root();
6179
6180         ret = smbrun(command, NULL);
6181
6182         if ( is_print_op )
6183                 unbecome_root();
6184
6185         /********* END SePrintOperatorPrivilege **********/
6186
6187         DEBUGADD(10,("returned [%d]\n", ret));
6188
6189         TALLOC_FREE(command);
6190
6191         if ( ret != 0 ) {
6192                 return WERR_ACCESS_DENIED;
6193         }
6194
6195         return WERR_OK;
6196 }
6197
6198 /****************************************************************************
6199 ****************************************************************************/
6200
6201 static bool spoolss_conn_snum_used(struct smbd_server_connection *sconn,
6202                                    int snum)
6203 {
6204         /*
6205          * As we do not know if we are embedded in the file server process
6206          * or not, we have to pretend that all shares are in use.
6207          */
6208         return true;
6209 }
6210
6211 static bool add_printer_hook(TALLOC_CTX *ctx, struct security_token *token,
6212                              struct spoolss_SetPrinterInfo2 *info2,
6213                              const char *remote_machine,
6214                              struct messaging_context *msg_ctx)
6215 {
6216         char *cmd = lp_addprinter_cmd(talloc_tos());
6217         char **qlines;
6218         char *command = NULL;
6219         int numlines;
6220         int ret;
6221         int fd;
6222         bool is_print_op = false;
6223
6224         if (!remote_machine) {
6225                 return false;
6226         }
6227
6228         command = talloc_asprintf(ctx,
6229                         "%s \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"",
6230                         cmd, info2->printername, info2->sharename,
6231                         info2->portname, info2->drivername,
6232                         info2->location, info2->comment, remote_machine);
6233         if (!command) {
6234                 return false;
6235         }
6236
6237         if ( token )
6238                 is_print_op = security_token_has_privilege(token, SEC_PRIV_PRINT_OPERATOR);
6239
6240         DEBUG(10,("Running [%s]\n", command));
6241
6242         /********* BEGIN SePrintOperatorPrivilege **********/
6243
6244         if ( is_print_op )
6245                 become_root();
6246
6247         if ( (ret = smbrun(command, &fd)) == 0 ) {
6248                 /* Tell everyone we updated smb.conf. */
6249                 message_send_all(msg_ctx, MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
6250         }
6251
6252         if ( is_print_op )
6253                 unbecome_root();
6254
6255         /********* END SePrintOperatorPrivilege **********/
6256
6257         DEBUGADD(10,("returned [%d]\n", ret));
6258
6259         TALLOC_FREE(command);
6260
6261         if ( ret != 0 ) {
6262                 if (fd != -1)
6263                         close(fd);
6264                 return false;
6265         }
6266
6267         /* reload our services immediately */
6268         become_root();
6269         reload_services(NULL, spoolss_conn_snum_used, false);
6270         unbecome_root();
6271
6272         numlines = 0;
6273         /* Get lines and convert them back to dos-codepage */
6274         qlines = fd_lines_load(fd, &numlines, 0, NULL);
6275         DEBUGADD(10,("Lines returned = [%d]\n", numlines));
6276         close(fd);
6277
6278         /* Set the portname to what the script says the portname should be. */
6279         /* but don't require anything to be return from the script exit a good error code */
6280
6281         if (numlines) {
6282                 /* Set the portname to what the script says the portname should be. */
6283                 info2->portname = talloc_strdup(ctx, qlines[0]);
6284                 DEBUGADD(6,("Line[0] = [%s]\n", qlines[0]));
6285         }
6286
6287         TALLOC_FREE(qlines);
6288         return true;
6289 }
6290
6291 static WERROR update_dsspooler(TALLOC_CTX *mem_ctx,
6292                                const struct auth_session_info *session_info,
6293                                struct messaging_context *msg_ctx,
6294                                int snum,
6295                                struct spoolss_SetPrinterInfo2 *printer,
6296                                struct spoolss_PrinterInfo2 *old_printer)
6297 {
6298         bool force_update = (old_printer == NULL);
6299         const char *dnsdomname;
6300         const char *longname;
6301         const char *uncname;
6302         const char *spooling;
6303         DATA_BLOB buffer;
6304         WERROR result = WERR_OK;
6305         struct dcerpc_binding_handle *b;
6306         TALLOC_CTX *tmp_ctx;
6307         bool ok;
6308
6309         tmp_ctx = talloc_new(mem_ctx);
6310         if (!tmp_ctx) {
6311                 return WERR_NOMEM;
6312         }
6313
6314         result = winreg_printer_binding_handle(tmp_ctx,
6315                                                session_info,
6316                                                msg_ctx,
6317                                                &b);
6318         if (!W_ERROR_IS_OK(result)) {
6319                 goto done;
6320         }
6321
6322         if (printer->drivername != NULL &&
6323             (force_update ||
6324              !strequal(printer->drivername, old_printer->drivername))) {
6325                 ok = push_reg_sz(tmp_ctx, &buffer, printer->drivername);
6326                 if (!ok) {
6327                         DEBUG(0, ("%s data corrupted\n", SPOOL_REG_DRIVERNAME));
6328                         result = WERR_INVALID_DATA;
6329                         goto done;
6330                 }
6331                 result = winreg_set_printer_dataex(tmp_ctx, b,
6332                                           printer->sharename,
6333                                           SPOOL_DSSPOOLER_KEY,
6334                                           SPOOL_REG_DRIVERNAME,
6335                                           REG_SZ,
6336                                           buffer.data,
6337                                           buffer.length);
6338                 if (!W_ERROR_IS_OK(result)) {
6339                         DEBUG(0, ("Failed to set %s\n", SPOOL_REG_DRIVERNAME));
6340                         goto done;
6341                 }
6342
6343                 if (!force_update) {
6344                         DEBUG(10,("update_printer: changing driver [%s]!  Sending event!\n",
6345                                 printer->drivername));
6346
6347                         notify_printer_driver(server_event_context(), msg_ctx,
6348                                               snum, printer->drivername ?
6349                                               printer->drivername : "");
6350                 }
6351         }
6352
6353         if (printer->comment != NULL &&
6354             (force_update ||
6355              !strequal(printer->comment, old_printer->comment))) {
6356                 ok = push_reg_sz(tmp_ctx, &buffer, printer->comment);
6357                 if (!ok) {
6358                         DEBUG(0, ("comment data corrupted\n"));
6359                         result = WERR_INVALID_DATA;
6360                         goto done;
6361                 }
6362                 result = winreg_set_printer_dataex(tmp_ctx, b,
6363                                           printer->sharename,
6364                                           SPOOL_DSSPOOLER_KEY,
6365                                           SPOOL_REG_DESCRIPTION,
6366                                           REG_SZ,
6367                                           buffer.data,
6368                                           buffer.length);
6369                 if (!W_ERROR_IS_OK(result)) {
6370                         DEBUG(0, ("Failed to set %s\n", SPOOL_REG_DESCRIPTION));
6371                         goto done;
6372                 }
6373
6374                 if (!force_update) {
6375                         notify_printer_comment(server_event_context(), msg_ctx,
6376                                                snum, printer->comment ?
6377                                                printer->comment : "");
6378                 }
6379         }
6380
6381         if (printer->sharename != NULL &&
6382             (force_update ||
6383              !strequal(printer->sharename, old_printer->sharename))) {
6384                 ok = push_reg_sz(tmp_ctx, &buffer, printer->sharename);
6385                 if (!ok) {
6386                         DEBUG(0, ("sharename data corrupted\n"));
6387                         result = WERR_INVALID_DATA;
6388                         goto done;
6389                 }
6390                 result = winreg_set_printer_dataex(tmp_ctx, b,
6391                                           printer->sharename,
6392                                           SPOOL_DSSPOOLER_KEY,
6393                                           SPOOL_REG_PRINTSHARENAME,
6394                                           REG_SZ,
6395                                           buffer.data,
6396                                           buffer.length);
6397                 if (!W_ERROR_IS_OK(result)) {
6398                         DEBUG(0, ("Failed to set %s\n", SPOOL_REG_PRINTSHARENAME));
6399                         goto done;
6400                 }
6401
6402                 if (!force_update) {
6403                         notify_printer_sharename(server_event_context(),
6404                                                  msg_ctx,
6405                                                  snum, printer->sharename ?
6406                                                  printer->sharename : "");
6407                 }
6408         }
6409
6410         if (printer->printername != NULL &&
6411             (force_update ||
6412              !strequal(printer->printername, old_printer->printername))) {
6413                 const char *p;
6414
6415                 p = strrchr(printer->printername, '\\' );
6416                 if (p != NULL) {
6417                         p++;
6418                 } else {
6419                         p = printer->printername;
6420                 }
6421
6422                 ok = push_reg_sz(tmp_ctx, &buffer, p);
6423                 if (!ok) {
6424                         DEBUG(0, ("printername data corrupted\n"));
6425                         result = WERR_INVALID_DATA;
6426                         goto done;
6427                 }
6428                 result = winreg_set_printer_dataex(tmp_ctx, b,
6429                                           printer->sharename,
6430                                           SPOOL_DSSPOOLER_KEY,
6431                                           SPOOL_REG_PRINTERNAME,
6432                                           REG_SZ,
6433                                           buffer.data,
6434                                           buffer.length);
6435                 if (!W_ERROR_IS_OK(result)) {
6436                         DEBUG(0, ("Failed to set %s\n", SPOOL_REG_PRINTSHARENAME));
6437                         goto done;
6438                 }
6439
6440                 if (!force_update) {
6441                         notify_printer_printername(server_event_context(),
6442                                                    msg_ctx, snum, p ? p : "");
6443                 }
6444         }
6445
6446         if (printer->portname != NULL &&
6447             (force_update ||
6448              !strequal(printer->portname, old_printer->portname))) {
6449                 ok = push_reg_sz(tmp_ctx, &buffer, printer->portname);
6450                 if (!ok) {
6451                         DEBUG(0, ("portname data corrupted\n"));
6452                         result = WERR_INVALID_DATA;
6453                         goto done;
6454                 }
6455                 result = winreg_set_printer_dataex(tmp_ctx, b,
6456                                           printer->sharename,
6457                                           SPOOL_DSSPOOLER_KEY,
6458                                           SPOOL_REG_PORTNAME,
6459                                           REG_SZ,
6460                                           buffer.data,
6461                                           buffer.length);
6462                 if (!W_ERROR_IS_OK(result)) {
6463                         DEBUG(0, ("Failed to set %s\n", SPOOL_REG_PORTNAME));
6464                         goto done;
6465                 }
6466
6467                 if (!force_update) {
6468                         notify_printer_port(server_event_context(),
6469                                             msg_ctx, snum, printer->portname ?
6470                                             printer->portname : "");
6471                 }
6472         }
6473
6474         if (printer->location != NULL &&
6475             (force_update ||
6476              !strequal(printer->location, old_printer->location))) {
6477                 ok = push_reg_sz(tmp_ctx, &buffer, printer->location);
6478                 if (!ok) {
6479                         DEBUG(0, ("location data corrupted\n"));
6480                         result = WERR_INVALID_DATA;
6481                         goto done;
6482                 }
6483                 result = winreg_set_printer_dataex(tmp_ctx, b,
6484                                           printer->sharename,
6485                                           SPOOL_DSSPOOLER_KEY,
6486                                           SPOOL_REG_LOCATION,
6487                                           REG_SZ,
6488                                           buffer.data,
6489                                           buffer.length);
6490                 if (!W_ERROR_IS_OK(result)) {
6491                         DEBUG(0, ("Failed to set %s\n", SPOOL_REG_LOCATION));
6492                         goto done;
6493                 }
6494
6495                 if (!force_update) {
6496                         notify_printer_location(server_event_context(),
6497                                                 msg_ctx, snum,
6498                                                 printer->location ?
6499                                                 printer->location : "");
6500                 }
6501         }
6502
6503         if (printer->sepfile != NULL &&
6504             (force_update ||
6505              !strequal(printer->sepfile, old_printer->sepfile))) {
6506                 ok = push_reg_sz(tmp_ctx, &buffer, printer->sepfile);
6507                 if (!ok) {
6508                         DEBUG(0, ("sepfile data corrupted\n"));
6509                         result = WERR_INVALID_DATA;
6510                         goto done;
6511                 }
6512                 result = winreg_set_printer_dataex(tmp_ctx, b,
6513                                           printer->sharename,
6514                                           SPOOL_DSSPOOLER_KEY,
6515                                           SPOOL_REG_PRINTSEPARATORFILE,
6516                                           REG_SZ,
6517                                           buffer.data,
6518                                           buffer.length);
6519                 if (!W_ERROR_IS_OK(result)) {
6520                         DEBUG(0, ("Failed to set %s\n", SPOOL_REG_PRINTSEPARATORFILE));
6521                         goto done;
6522                 }
6523
6524                 if (!force_update) {
6525                         notify_printer_sepfile(server_event_context(),
6526                                                msg_ctx, snum,
6527                                                printer->sepfile ?
6528                                                printer->sepfile : "");
6529                 }
6530         }
6531
6532         if (printer->starttime != 0 &&
6533             (force_update ||
6534              printer->starttime != old_printer->starttime)) {
6535                 buffer = data_blob_talloc(tmp_ctx, NULL, 4);
6536                 SIVAL(buffer.data, 0, printer->starttime);
6537                 result = winreg_set_printer_dataex(tmp_ctx, b,
6538                                           printer->sharename,
6539                                           SPOOL_DSSPOOLER_KEY,
6540                                           SPOOL_REG_PRINTSTARTTIME,
6541                                           REG_DWORD,
6542                                           buffer.data,
6543                                           buffer.length);
6544                 if (!W_ERROR_IS_OK(result)) {
6545                         DEBUG(0, ("Failed to set %s\n", SPOOL_REG_PRINTSTARTTIME));
6546                         goto done;
6547                 }
6548         }
6549
6550         if (printer->untiltime != 0 &&
6551             (force_update ||
6552              printer->untiltime != old_printer->untiltime)) {
6553                 buffer = data_blob_talloc(tmp_ctx, NULL, 4);
6554                 SIVAL(buffer.data, 0, printer->untiltime);
6555                 result = winreg_set_printer_dataex(tmp_ctx, b,
6556                                           printer->sharename,
6557                                           SPOOL_DSSPOOLER_KEY,
6558                                           SPOOL_REG_PRINTENDTIME,
6559                                           REG_DWORD,
6560                                           buffer.data,
6561                                           buffer.length);
6562                 if (!W_ERROR_IS_OK(result)) {
6563                         DEBUG(0, ("Failed to set %s\n", SPOOL_REG_PRINTENDTIME));
6564                         goto done;
6565                 }
6566         }
6567
6568         if (force_update || printer->priority != old_printer->priority) {
6569                 buffer = data_blob_talloc(tmp_ctx, NULL, 4);
6570                 SIVAL(buffer.data, 0, printer->priority);
6571                 result = winreg_set_printer_dataex(tmp_ctx, b,
6572                                           printer->sharename,
6573                                           SPOOL_DSSPOOLER_KEY,
6574                                           SPOOL_REG_PRIORITY,
6575                                           REG_DWORD,
6576                                           buffer.data,
6577                                           buffer.length);
6578                 if (!W_ERROR_IS_OK(result)) {
6579                         DEBUG(0, ("Failed to set %s\n", SPOOL_REG_PRINTENDTIME));
6580                         goto done;
6581                 }
6582         }
6583
6584         if (force_update || printer->attributes != old_printer->attributes) {
6585                 buffer = data_blob_talloc(tmp_ctx, NULL, 4);
6586                 SIVAL(buffer.data, 0, (printer->attributes &
6587                                        PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS));
6588                 result = winreg_set_printer_dataex(tmp_ctx, b,
6589                                           printer->sharename,
6590                                           SPOOL_DSSPOOLER_KEY,
6591                                           SPOOL_REG_PRINTKEEPPRINTEDJOBS,
6592                                           REG_DWORD,
6593                                           buffer.data,
6594                                           buffer.length);
6595                 if (!W_ERROR_IS_OK(result)) {
6596                         DEBUG(0, ("Failed to set %s\n", SPOOL_REG_PRINTENDTIME));
6597                         goto done;
6598                 }
6599
6600                 switch (printer->attributes & 0x3) {
6601                         case 0:
6602                                 spooling = SPOOL_REGVAL_PRINTWHILESPOOLING;
6603                                 break;
6604                         case 1:
6605                                 spooling = SPOOL_REGVAL_PRINTAFTERSPOOLED;
6606                                 break;
6607                         case 2:
6608                                 spooling = SPOOL_REGVAL_PRINTDIRECT;
6609                                 break;
6610                         default:
6611                                 spooling = "unknown";
6612                 }
6613                 ok = push_reg_sz(tmp_ctx, &buffer, spooling);
6614                 if (!ok) {
6615                         DEBUG(0, ("printSpooling data corrupted\n"));
6616                         result = WERR_INVALID_DATA;
6617                         goto done;
6618                 }
6619                 winreg_set_printer_dataex(tmp_ctx, b,
6620                                           printer->sharename,
6621                                           SPOOL_DSSPOOLER_KEY,
6622                                           SPOOL_REG_PRINTSPOOLING,
6623                                           REG_SZ,
6624                                           buffer.data,
6625                                           buffer.length);
6626         }
6627
6628         ok = push_reg_sz(tmp_ctx, &buffer, lp_netbios_name());
6629         if (!ok) {
6630                 DEBUG(0, ("shortServerName data corrupted\n"));
6631                 result = WERR_INVALID_DATA;
6632                 goto done;
6633         }
6634         result = winreg_set_printer_dataex(tmp_ctx, b,
6635                                   printer->sharename,
6636                                   SPOOL_DSSPOOLER_KEY,
6637                                   SPOOL_REG_SHORTSERVERNAME,
6638                                   REG_SZ,
6639                                   buffer.data,
6640                                   buffer.length);
6641         if (!W_ERROR_IS_OK(result)) {
6642                 DEBUG(0, ("Failed to set %s\n", SPOOL_REG_SHORTSERVERNAME));
6643                 goto done;
6644         }
6645
6646         dnsdomname = get_mydnsfullname();
6647         if (dnsdomname != NULL && dnsdomname[0] != '\0') {
6648                 longname = talloc_strdup(tmp_ctx, dnsdomname);
6649         } else {
6650                 longname = talloc_strdup(tmp_ctx, lp_netbios_name());
6651         }
6652         if (longname == NULL) {
6653                 result = WERR_NOMEM;
6654                 goto done;
6655         }
6656
6657         ok = push_reg_sz(tmp_ctx, &buffer, longname);
6658         if (!ok) {
6659                 DEBUG(0, ("longname data corrupted\n"));
6660                 result = WERR_INVALID_DATA;
6661                 goto done;
6662         }
6663         result = winreg_set_printer_dataex(tmp_ctx, b,
6664                                            printer->sharename,
6665                                            SPOOL_DSSPOOLER_KEY,
6666                                            SPOOL_REG_SERVERNAME,
6667                                            REG_SZ,
6668                                            buffer.data,
6669                                            buffer.length);
6670         if (!W_ERROR_IS_OK(result)) {
6671                 DEBUG(0, ("Failed to set %s\n", SPOOL_REG_SERVERNAME));
6672                 goto done;
6673         }
6674
6675         uncname = talloc_asprintf(tmp_ctx, "\\\\%s\\%s",
6676                                   lp_netbios_name(), printer->sharename);
6677         ok = push_reg_sz(tmp_ctx, &buffer, uncname);
6678         if (!ok) {
6679                 DEBUG(0, ("uncName data corrupted\n"));
6680                 result = WERR_INVALID_DATA;
6681                 goto done;
6682         }
6683         result = winreg_set_printer_dataex(tmp_ctx, b,
6684                                   printer->sharename,
6685                                   SPOOL_DSSPOOLER_KEY,
6686                                   SPOOL_REG_UNCNAME,
6687                                   REG_SZ,
6688                                   buffer.data,
6689                                   buffer.length);
6690         if (!W_ERROR_IS_OK(result)) {
6691                 DEBUG(0, ("Failed to set %s\n", SPOOL_REG_UNCNAME));
6692                 goto done;
6693         }
6694
6695 done:
6696         talloc_free(tmp_ctx);
6697         return result;
6698 }
6699
6700 /********************************************************************
6701  * Called by spoolss_api_setprinter
6702  * when updating a printer description.
6703  ********************************************************************/
6704
6705 static WERROR update_printer(struct pipes_struct *p,
6706                              struct policy_handle *handle,
6707                              struct spoolss_SetPrinterInfoCtr *info_ctr,
6708                              struct spoolss_DeviceMode *devmode)
6709 {
6710         uint32_t printer_mask = SPOOLSS_PRINTER_INFO_ALL;
6711         struct spoolss_SetPrinterInfo2 *printer = info_ctr->info.info2;
6712         struct spoolss_PrinterInfo2 *old_printer;
6713         struct printer_handle *Printer = find_printer_index_by_hnd(p, handle);
6714         int snum;
6715         WERROR result = WERR_OK;
6716         TALLOC_CTX *tmp_ctx;
6717         struct dcerpc_binding_handle *b;
6718
6719         DEBUG(8,("update_printer\n"));
6720
6721         tmp_ctx = talloc_new(p->mem_ctx);
6722         if (tmp_ctx == NULL) {
6723                 return WERR_NOMEM;
6724         }
6725
6726         if (!Printer) {
6727                 result = WERR_BADFID;
6728                 goto done;
6729         }
6730
6731         if (!get_printer_snum(p, handle, &snum, NULL)) {
6732                 result = WERR_BADFID;
6733                 goto done;
6734         }
6735
6736         result = winreg_printer_binding_handle(tmp_ctx,
6737                                                get_session_info_system(),
6738                                                p->msg_ctx,
6739                                                &b);
6740         if (!W_ERROR_IS_OK(result)) {
6741                 goto done;
6742         }
6743
6744         result = winreg_get_printer(tmp_ctx, b,
6745                                     lp_const_servicename(snum),
6746                                     &old_printer);
6747         if (!W_ERROR_IS_OK(result)) {
6748                 result = WERR_BADFID;
6749                 goto done;
6750         }
6751
6752         /* Do sanity check on the requested changes for Samba */
6753         if (!check_printer_ok(tmp_ctx, printer, snum)) {
6754                 result = WERR_INVALID_PARAM;
6755                 goto done;
6756         }
6757
6758         /* FIXME!!! If the driver has changed we really should verify that
6759            it is installed before doing much else   --jerry */
6760
6761         /* Check calling user has permission to update printer description */
6762         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
6763                 DEBUG(3, ("update_printer: printer property change denied by handle\n"));
6764                 result = WERR_ACCESS_DENIED;
6765                 goto done;
6766         }
6767
6768         /* Call addprinter hook */
6769         /* Check changes to see if this is really needed */
6770
6771         if (*lp_addprinter_cmd(talloc_tos()) &&
6772                         (!strequal(printer->drivername, old_printer->drivername) ||
6773                          !strequal(printer->comment, old_printer->comment) ||
6774                          !strequal(printer->portname, old_printer->portname) ||
6775                          !strequal(printer->location, old_printer->location)) )
6776         {
6777                 char *raddr;
6778
6779                 raddr = tsocket_address_inet_addr_string(p->remote_address,
6780                                                          p->mem_ctx);
6781                 if (raddr == NULL) {
6782                         return WERR_NOMEM;
6783                 }
6784
6785                 /* add_printer_hook() will call reload_services() */
6786                 if (!add_printer_hook(tmp_ctx, p->session_info->security_token,
6787                                       printer, raddr,
6788                                       p->msg_ctx)) {
6789                         result = WERR_ACCESS_DENIED;
6790                         goto done;
6791                 }
6792         }
6793
6794         result = update_dsspooler(tmp_ctx,
6795                                   get_session_info_system(),
6796                                   p->msg_ctx,
6797                                   snum,
6798                                   printer,
6799                                   old_printer);
6800         if (!W_ERROR_IS_OK(result)) {
6801                 goto done;
6802         }
6803
6804         printer_mask &= ~SPOOLSS_PRINTER_INFO_SECDESC;
6805
6806         if (devmode == NULL) {
6807                 printer_mask &= ~SPOOLSS_PRINTER_INFO_DEVMODE;
6808         }
6809         result = winreg_update_printer(tmp_ctx, b,
6810                                        printer->sharename,
6811                                        printer_mask,
6812                                        printer,
6813                                        devmode,
6814                                        NULL);
6815
6816 done:
6817         talloc_free(tmp_ctx);
6818
6819         return result;
6820 }
6821
6822 /****************************************************************************
6823 ****************************************************************************/
6824 static WERROR publish_or_unpublish_printer(struct pipes_struct *p,
6825                                            struct policy_handle *handle,
6826                                            struct spoolss_SetPrinterInfo7 *info7)
6827 {
6828 #ifdef HAVE_ADS
6829         struct spoolss_PrinterInfo2 *pinfo2 = NULL;
6830         WERROR result;
6831         int snum;
6832         struct printer_handle *Printer;
6833
6834         if ( lp_security() != SEC_ADS ) {
6835                 return WERR_UNKNOWN_LEVEL;
6836         }
6837
6838         Printer = find_printer_index_by_hnd(p, handle);
6839
6840         DEBUG(5,("publish_or_unpublish_printer, action = %d\n",info7->action));
6841
6842         if (!Printer)
6843                 return WERR_BADFID;
6844
6845         if (!get_printer_snum(p, handle, &snum, NULL))
6846                 return WERR_BADFID;
6847
6848         result = winreg_get_printer_internal(p->mem_ctx,
6849                                     get_session_info_system(),
6850                                     p->msg_ctx,
6851                                     lp_servicename(talloc_tos(), snum),
6852                                     &pinfo2);
6853         if (!W_ERROR_IS_OK(result)) {
6854                 return WERR_BADFID;
6855         }
6856
6857         nt_printer_publish(pinfo2,
6858                            get_session_info_system(),
6859                            p->msg_ctx,
6860                            pinfo2,
6861                            info7->action);
6862
6863         TALLOC_FREE(pinfo2);
6864         return WERR_OK;
6865 #else
6866         return WERR_UNKNOWN_LEVEL;
6867 #endif
6868 }
6869
6870 /********************************************************************
6871  ********************************************************************/
6872
6873 static WERROR update_printer_devmode(struct pipes_struct *p,
6874                                      struct policy_handle *handle,
6875                                      struct spoolss_DeviceMode *devmode)
6876 {
6877         int snum;
6878         struct printer_handle *Printer = find_printer_index_by_hnd(p, handle);
6879         uint32_t info2_mask = SPOOLSS_PRINTER_INFO_DEVMODE;
6880
6881         DEBUG(8,("update_printer_devmode\n"));
6882
6883         if (!Printer) {
6884                 return WERR_BADFID;
6885         }
6886
6887         if (!get_printer_snum(p, handle, &snum, NULL)) {
6888                 return WERR_BADFID;
6889         }
6890
6891         /* Check calling user has permission to update printer description */
6892         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
6893                 DEBUG(3, ("update_printer: printer property change denied by handle\n"));
6894                 return WERR_ACCESS_DENIED;
6895         }
6896
6897         return winreg_update_printer_internal(p->mem_ctx,
6898                                      get_session_info_system(),
6899                                      p->msg_ctx,
6900                                      lp_const_servicename(snum),
6901                                      info2_mask,
6902                                      NULL,
6903                                      devmode,
6904                                      NULL);
6905 }
6906
6907
6908 /****************************************************************
6909  _spoolss_SetPrinter
6910 ****************************************************************/
6911
6912 WERROR _spoolss_SetPrinter(struct pipes_struct *p,
6913                            struct spoolss_SetPrinter *r)
6914 {
6915         WERROR result;
6916
6917         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
6918
6919         if (!Printer) {
6920                 DEBUG(2,("_spoolss_SetPrinter: Invalid handle (%s:%u:%u)\n",
6921                         OUR_HANDLE(r->in.handle)));
6922                 return WERR_BADFID;
6923         }
6924
6925         /* check the level */
6926         switch (r->in.info_ctr->level) {
6927                 case 0:
6928                         return control_printer(r->in.handle, r->in.command, p);
6929                 case 2:
6930                         result = update_printer(p, r->in.handle,
6931                                                 r->in.info_ctr,
6932                                                 r->in.devmode_ctr->devmode);
6933                         if (!W_ERROR_IS_OK(result))
6934                                 return result;
6935                         if (r->in.secdesc_ctr->sd)
6936                                 result = update_printer_sec(r->in.handle, p,
6937                                                             r->in.secdesc_ctr);
6938                         return result;
6939                 case 3:
6940                         return update_printer_sec(r->in.handle, p,
6941                                                   r->in.secdesc_ctr);
6942                 case 7:
6943                         return publish_or_unpublish_printer(p, r->in.handle,
6944                                                             r->in.info_ctr->info.info7);
6945                 case 8:
6946                         return update_printer_devmode(p, r->in.handle,
6947                                                       r->in.devmode_ctr->devmode);
6948                 default:
6949                         return WERR_UNKNOWN_LEVEL;
6950         }
6951 }
6952
6953 /****************************************************************
6954  _spoolss_FindClosePrinterNotify
6955 ****************************************************************/
6956
6957 WERROR _spoolss_FindClosePrinterNotify(struct pipes_struct *p,
6958                                        struct spoolss_FindClosePrinterNotify *r)
6959 {
6960         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
6961
6962         if (!Printer) {
6963                 DEBUG(2,("_spoolss_FindClosePrinterNotify: "
6964                         "Invalid handle (%s:%u:%u)\n", OUR_HANDLE(r->in.handle)));
6965                 return WERR_BADFID;
6966         }
6967
6968         if (Printer->notify.cli_chan != NULL &&
6969             Printer->notify.cli_chan->active_connections > 0) {
6970                 int snum = -1;
6971
6972                 if (Printer->printer_type == SPLHND_PRINTER) {
6973                         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
6974                                 return WERR_BADFID;
6975                         }
6976                 }
6977
6978                 srv_spoolss_replycloseprinter(snum, Printer);
6979         }
6980
6981         Printer->notify.flags=0;
6982         Printer->notify.options=0;
6983         Printer->notify.localmachine[0]='\0';
6984         Printer->notify.printerlocal=0;
6985         TALLOC_FREE(Printer->notify.option);
6986
6987         return WERR_OK;
6988 }
6989
6990 /****************************************************************
6991  _spoolss_AddJob
6992 ****************************************************************/
6993
6994 WERROR _spoolss_AddJob(struct pipes_struct *p,
6995                        struct spoolss_AddJob *r)
6996 {
6997         if (!r->in.buffer && (r->in.offered != 0)) {
6998                 return WERR_INVALID_PARAM;
6999         }
7000
7001         /* this is what a NT server returns for AddJob. AddJob must fail on
7002          * non-local printers */
7003
7004         if (r->in.level != 1) {
7005                 return WERR_UNKNOWN_LEVEL;
7006         }
7007
7008         return WERR_INVALID_PARAM;
7009 }
7010
7011 /****************************************************************************
7012 fill_job_info1
7013 ****************************************************************************/
7014
7015 static WERROR fill_job_info1(TALLOC_CTX *mem_ctx,
7016                              struct spoolss_JobInfo1 *r,
7017                              const print_queue_struct *queue,
7018                              int position, int snum,
7019                              struct spoolss_PrinterInfo2 *pinfo2)
7020 {
7021         struct tm *t;
7022
7023         t = gmtime(&queue->time);
7024
7025         r->job_id               = queue->sysjob;
7026
7027         r->printer_name         = lp_servicename(mem_ctx, snum);
7028         W_ERROR_HAVE_NO_MEMORY(r->printer_name);
7029         r->server_name          = talloc_strdup(mem_ctx, pinfo2->servername);
7030         W_ERROR_HAVE_NO_MEMORY(r->server_name);
7031         r->user_name            = talloc_strdup(mem_ctx, queue->fs_user);
7032         W_ERROR_HAVE_NO_MEMORY(r->user_name);
7033         r->document_name        = talloc_strdup(mem_ctx, queue->fs_file);
7034         W_ERROR_HAVE_NO_MEMORY(r->document_name);
7035         r->data_type            = talloc_strdup(mem_ctx, "RAW");
7036         W_ERROR_HAVE_NO_MEMORY(r->data_type);
7037         r->text_status          = talloc_strdup(mem_ctx, "");
7038         W_ERROR_HAVE_NO_MEMORY(r->text_status);
7039
7040         r->status               = nt_printj_status(queue->status);
7041         r->priority             = queue->priority;
7042         r->position             = position;
7043         r->total_pages          = queue->page_count;
7044         r->pages_printed        = 0; /* ??? */
7045
7046         init_systemtime(&r->submitted, t);
7047
7048         return WERR_OK;
7049 }
7050
7051 /****************************************************************************
7052 fill_job_info2
7053 ****************************************************************************/
7054
7055 static WERROR fill_job_info2(TALLOC_CTX *mem_ctx,
7056                              struct spoolss_JobInfo2 *r,
7057                              const print_queue_struct *queue,
7058                              int position, int snum,
7059                              struct spoolss_PrinterInfo2 *pinfo2,
7060                              struct spoolss_DeviceMode *devmode)
7061 {
7062         struct tm *t;
7063
7064         t = gmtime(&queue->time);
7065
7066         r->job_id               = queue->sysjob;
7067
7068         r->printer_name         = lp_servicename(mem_ctx, snum);
7069         W_ERROR_HAVE_NO_MEMORY(r->printer_name);
7070         r->server_name          = talloc_strdup(mem_ctx, pinfo2->servername);
7071         W_ERROR_HAVE_NO_MEMORY(r->server_name);
7072         r->user_name            = talloc_strdup(mem_ctx, queue->fs_user);
7073         W_ERROR_HAVE_NO_MEMORY(r->user_name);
7074         r->document_name        = talloc_strdup(mem_ctx, queue->fs_file);
7075         W_ERROR_HAVE_NO_MEMORY(r->document_name);
7076         r->notify_name          = talloc_strdup(mem_ctx, queue->fs_user);
7077         W_ERROR_HAVE_NO_MEMORY(r->notify_name);
7078         r->data_type            = talloc_strdup(mem_ctx, "RAW");
7079         W_ERROR_HAVE_NO_MEMORY(r->data_type);
7080         r->print_processor      = talloc_strdup(mem_ctx, "winprint");
7081         W_ERROR_HAVE_NO_MEMORY(r->print_processor);
7082         r->parameters           = talloc_strdup(mem_ctx, "");
7083         W_ERROR_HAVE_NO_MEMORY(r->parameters);
7084         r->driver_name          = talloc_strdup(mem_ctx, pinfo2->drivername);
7085         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
7086
7087         r->devmode              = devmode;
7088
7089         r->text_status          = talloc_strdup(mem_ctx, "");
7090         W_ERROR_HAVE_NO_MEMORY(r->text_status);
7091
7092         r->secdesc              = NULL;
7093
7094         r->status               = nt_printj_status(queue->status);
7095         r->priority             = queue->priority;
7096         r->position             = position;
7097         r->start_time           = 0;
7098         r->until_time           = 0;
7099         r->total_pages          = queue->page_count;
7100         r->size                 = queue->size;
7101         init_systemtime(&r->submitted, t);
7102         r->time                 = 0;
7103         r->pages_printed        = 0; /* ??? */
7104
7105         return WERR_OK;
7106 }
7107
7108 /****************************************************************************
7109 fill_job_info3
7110 ****************************************************************************/
7111
7112 static WERROR fill_job_info3(TALLOC_CTX *mem_ctx,
7113                              struct spoolss_JobInfo3 *r,
7114                              const print_queue_struct *queue,
7115                              const print_queue_struct *next_queue,
7116                              int position, int snum,
7117                              struct spoolss_PrinterInfo2 *pinfo2)
7118 {
7119         r->job_id               = queue->sysjob;
7120         r->next_job_id          = 0;
7121         if (next_queue) {
7122                 r->next_job_id  = next_queue->sysjob;
7123         }
7124         r->reserved             = 0;
7125
7126         return WERR_OK;
7127 }
7128
7129 /****************************************************************************
7130  Enumjobs at level 1.
7131 ****************************************************************************/
7132
7133 static WERROR enumjobs_level1(TALLOC_CTX *mem_ctx,
7134                               const print_queue_struct *queue,
7135                               uint32_t num_queues, int snum,
7136                               struct spoolss_PrinterInfo2 *pinfo2,
7137                               union spoolss_JobInfo **info_p,
7138                               uint32_t *count)
7139 {
7140         union spoolss_JobInfo *info;
7141         int i;
7142         WERROR result = WERR_OK;
7143
7144         info = talloc_array(mem_ctx, union spoolss_JobInfo, num_queues);
7145         W_ERROR_HAVE_NO_MEMORY(info);
7146
7147         *count = num_queues;
7148
7149         for (i=0; i<*count; i++) {
7150                 result = fill_job_info1(info,
7151                                         &info[i].info1,
7152                                         &queue[i],
7153                                         i,
7154                                         snum,
7155                                         pinfo2);
7156                 if (!W_ERROR_IS_OK(result)) {
7157                         goto out;
7158                 }
7159         }
7160
7161  out:
7162         if (!W_ERROR_IS_OK(result)) {
7163                 TALLOC_FREE(info);
7164                 *count = 0;
7165                 return result;
7166         }
7167
7168         *info_p = info;
7169
7170         return WERR_OK;
7171 }
7172
7173 /****************************************************************************
7174  Enumjobs at level 2.
7175 ****************************************************************************/
7176
7177 static WERROR enumjobs_level2(TALLOC_CTX *mem_ctx,
7178                               const print_queue_struct *queue,
7179                               uint32_t num_queues, int snum,
7180                               struct spoolss_PrinterInfo2 *pinfo2,
7181                               union spoolss_JobInfo **info_p,
7182                               uint32_t *count)
7183 {
7184         union spoolss_JobInfo *info;
7185         int i;
7186         WERROR result = WERR_OK;
7187
7188         info = talloc_array(mem_ctx, union spoolss_JobInfo, num_queues);
7189         W_ERROR_HAVE_NO_MEMORY(info);
7190
7191         *count = num_queues;
7192
7193         for (i=0; i<*count; i++) {
7194                 struct spoolss_DeviceMode *devmode;
7195
7196                 result = spoolss_create_default_devmode(info,
7197                                                         pinfo2->printername,
7198                                                         &devmode);
7199                 if (!W_ERROR_IS_OK(result)) {
7200                         DEBUG(3, ("Can't proceed w/o a devmode!"));
7201                         goto out;
7202                 }
7203
7204                 result = fill_job_info2(info,
7205                                         &info[i].info2,
7206                                         &queue[i],
7207                                         i,
7208                                         snum,
7209                                         pinfo2,
7210                                         devmode);
7211                 if (!W_ERROR_IS_OK(result)) {
7212                         goto out;
7213                 }
7214         }
7215
7216  out:
7217         if (!W_ERROR_IS_OK(result)) {
7218                 TALLOC_FREE(info);
7219                 *count = 0;
7220                 return result;
7221         }
7222
7223         *info_p = info;
7224
7225         return WERR_OK;
7226 }
7227
7228 /****************************************************************************
7229  Enumjobs at level 3.
7230 ****************************************************************************/
7231
7232 static WERROR enumjobs_level3(TALLOC_CTX *mem_ctx,
7233                               const print_queue_struct *queue,
7234                               uint32_t num_queues, int snum,
7235                               struct spoolss_PrinterInfo2 *pinfo2,
7236                               union spoolss_JobInfo **info_p,
7237                               uint32_t *count)
7238 {
7239         union spoolss_JobInfo *info;
7240         int i;
7241         WERROR result = WERR_OK;
7242
7243         info = talloc_array(mem_ctx, union spoolss_JobInfo, num_queues);
7244         W_ERROR_HAVE_NO_MEMORY(info);
7245
7246         *count = num_queues;
7247
7248         for (i=0; i<*count; i++) {
7249                 const print_queue_struct *next_queue = NULL;
7250
7251                 if (i+1 < *count) {
7252                         next_queue = &queue[i+1];
7253                 }
7254
7255                 result = fill_job_info3(info,
7256                                         &info[i].info3,
7257                                         &queue[i],
7258                                         next_queue,
7259                                         i,
7260                                         snum,
7261                                         pinfo2);
7262                 if (!W_ERROR_IS_OK(result)) {
7263                         goto out;
7264                 }
7265         }
7266
7267  out:
7268         if (!W_ERROR_IS_OK(result)) {
7269                 TALLOC_FREE(info);
7270                 *count = 0;
7271                 return result;
7272         }
7273
7274         *info_p = info;
7275
7276         return WERR_OK;
7277 }
7278
7279 /****************************************************************
7280  _spoolss_EnumJobs
7281 ****************************************************************/
7282
7283 WERROR _spoolss_EnumJobs(struct pipes_struct *p,
7284                          struct spoolss_EnumJobs *r)
7285 {
7286         WERROR result;
7287         struct spoolss_PrinterInfo2 *pinfo2 = NULL;
7288         int snum;
7289         print_status_struct prt_status;
7290         print_queue_struct *queue = NULL;
7291         uint32_t count;
7292
7293         /* that's an [in out] buffer */
7294
7295         if (!r->in.buffer && (r->in.offered != 0)) {
7296                 return WERR_INVALID_PARAM;
7297         }
7298
7299         DEBUG(4,("_spoolss_EnumJobs\n"));
7300
7301         *r->out.needed = 0;
7302         *r->out.count = 0;
7303         *r->out.info = NULL;
7304
7305         /* lookup the printer snum and tdb entry */
7306
7307         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
7308                 return WERR_BADFID;
7309         }
7310
7311         result = winreg_get_printer_internal(p->mem_ctx,
7312                                     get_session_info_system(),
7313                                     p->msg_ctx,
7314                                     lp_const_servicename(snum),
7315                                     &pinfo2);
7316         if (!W_ERROR_IS_OK(result)) {
7317                 return result;
7318         }
7319
7320         count = print_queue_status(p->msg_ctx, snum, &queue, &prt_status);
7321         DEBUGADD(4,("count:[%d], status:[%d], [%s]\n",
7322                 count, prt_status.status, prt_status.message));
7323
7324         if (count == 0) {
7325                 SAFE_FREE(queue);
7326                 TALLOC_FREE(pinfo2);
7327                 return WERR_OK;
7328         }
7329
7330         switch (r->in.level) {
7331         case 1:
7332                 result = enumjobs_level1(p->mem_ctx, queue, count, snum,
7333                                          pinfo2, r->out.info, r->out.count);
7334                 break;
7335         case 2:
7336                 result = enumjobs_level2(p->mem_ctx, queue, count, snum,
7337                                          pinfo2, r->out.info, r->out.count);
7338                 break;
7339         case 3:
7340                 result = enumjobs_level3(p->mem_ctx, queue, count, snum,
7341                                          pinfo2, r->out.info, r->out.count);
7342                 break;
7343         default:
7344                 result = WERR_UNKNOWN_LEVEL;
7345                 break;
7346         }
7347
7348         SAFE_FREE(queue);
7349         TALLOC_FREE(pinfo2);
7350
7351         if (!W_ERROR_IS_OK(result)) {
7352                 return result;
7353         }
7354
7355         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
7356                                                      spoolss_EnumJobs,
7357                                                      *r->out.info, r->in.level,
7358                                                      *r->out.count);
7359         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
7360         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
7361
7362         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7363 }
7364
7365 /****************************************************************
7366  _spoolss_ScheduleJob
7367 ****************************************************************/
7368
7369 WERROR _spoolss_ScheduleJob(struct pipes_struct *p,
7370                             struct spoolss_ScheduleJob *r)
7371 {
7372         return WERR_OK;
7373 }
7374
7375 /****************************************************************
7376 ****************************************************************/
7377
7378 static WERROR spoolss_setjob_1(TALLOC_CTX *mem_ctx,
7379                                struct messaging_context *msg_ctx,
7380                                const char *printer_name,
7381                                uint32_t job_id,
7382                                struct spoolss_SetJobInfo1 *r)
7383 {
7384         char *old_doc_name;
7385
7386         if (!print_job_get_name(mem_ctx, printer_name, job_id, &old_doc_name)) {
7387                 return WERR_BADFID;
7388         }
7389
7390         if (strequal(old_doc_name, r->document_name)) {
7391                 return WERR_OK;
7392         }
7393
7394         if (!print_job_set_name(server_event_context(), msg_ctx,
7395                                 printer_name, job_id, r->document_name)) {
7396                 return WERR_BADFID;
7397         }
7398
7399         return WERR_OK;
7400 }
7401
7402 /****************************************************************
7403  _spoolss_SetJob
7404 ****************************************************************/
7405
7406 WERROR _spoolss_SetJob(struct pipes_struct *p,
7407                        struct spoolss_SetJob *r)
7408 {
7409         const struct auth_session_info *session_info = p->session_info;
7410         int snum;
7411         WERROR errcode = WERR_BADFUNC;
7412
7413         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
7414                 return WERR_BADFID;
7415         }
7416
7417         if (!print_job_exists(lp_const_servicename(snum), r->in.job_id)) {
7418                 return WERR_INVALID_PRINTER_NAME;
7419         }
7420
7421         switch (r->in.command) {
7422         case SPOOLSS_JOB_CONTROL_CANCEL:
7423         case SPOOLSS_JOB_CONTROL_DELETE:
7424                 errcode = print_job_delete(session_info, p->msg_ctx,
7425                                            snum, r->in.job_id);
7426                 if (W_ERROR_EQUAL(errcode, WERR_PRINTER_HAS_JOBS_QUEUED)) {
7427                         errcode = WERR_OK;
7428                 }
7429                 break;
7430         case SPOOLSS_JOB_CONTROL_PAUSE:
7431                 errcode = print_job_pause(session_info, p->msg_ctx,
7432                                           snum, r->in.job_id);
7433                 break;
7434         case SPOOLSS_JOB_CONTROL_RESTART:
7435         case SPOOLSS_JOB_CONTROL_RESUME:
7436                 errcode = print_job_resume(session_info, p->msg_ctx,
7437                                            snum, r->in.job_id);
7438                 break;
7439         case 0:
7440                 errcode = WERR_OK;
7441                 break;
7442         default:
7443                 return WERR_UNKNOWN_LEVEL;
7444         }
7445
7446         if (!W_ERROR_IS_OK(errcode)) {
7447                 return errcode;
7448         }
7449
7450         if (r->in.ctr == NULL) {
7451                 return errcode;
7452         }
7453
7454         switch (r->in.ctr->level) {
7455         case 1:
7456                 errcode = spoolss_setjob_1(p->mem_ctx, p->msg_ctx,
7457                                            lp_const_servicename(snum),
7458                                            r->in.job_id,
7459                                            r->in.ctr->info.info1);
7460                 break;
7461         case 2:
7462         case 3:
7463         case 4:
7464         default:
7465                 return WERR_UNKNOWN_LEVEL;
7466         }
7467
7468         return errcode;
7469 }
7470
7471 /****************************************************************************
7472  Enumerates all printer drivers by level and architecture.
7473 ****************************************************************************/
7474
7475 static WERROR enumprinterdrivers_level_by_architecture(TALLOC_CTX *mem_ctx,
7476                                                        const struct auth_session_info *session_info,
7477                                                        struct messaging_context *msg_ctx,
7478                                                        const char *servername,
7479                                                        const char *architecture,
7480                                                        uint32_t level,
7481                                                        union spoolss_DriverInfo **info_p,
7482                                                        uint32_t *count_p)
7483 {
7484         int i;
7485         uint32_t version;
7486         struct spoolss_DriverInfo8 *driver;
7487         union spoolss_DriverInfo *info = NULL;
7488         uint32_t count = 0;
7489         WERROR result = WERR_OK;
7490         uint32_t num_drivers;
7491         const char **drivers;
7492         struct dcerpc_binding_handle *b;
7493         TALLOC_CTX *tmp_ctx = NULL;
7494
7495         *count_p = 0;
7496         *info_p = NULL;
7497
7498         tmp_ctx = talloc_new(mem_ctx);
7499         if (!tmp_ctx) {
7500                 return WERR_NOMEM;
7501         }
7502
7503         result = winreg_printer_binding_handle(tmp_ctx,
7504                                                session_info,
7505                                                msg_ctx,
7506                                                &b);
7507         if (!W_ERROR_IS_OK(result)) {
7508                 goto out;
7509         }
7510
7511         for (version=0; version<DRIVER_MAX_VERSION; version++) {
7512                 result = winreg_get_driver_list(tmp_ctx, b,
7513                                                 architecture, version,
7514                                                 &num_drivers, &drivers);
7515                 if (!W_ERROR_IS_OK(result)) {
7516                         goto out;
7517                 }
7518                 DEBUG(4, ("we have:[%d] drivers in environment"
7519                           " [%s] and version [%d]\n",
7520                           num_drivers, architecture, version));
7521
7522                 if (num_drivers != 0) {
7523                         info = talloc_realloc(tmp_ctx, info,
7524                                                     union spoolss_DriverInfo,
7525                                                     count + num_drivers);
7526                         if (!info) {
7527                                 DEBUG(0,("enumprinterdrivers_level_by_architecture: "
7528                                         "failed to enlarge driver info buffer!\n"));
7529                                 result = WERR_NOMEM;
7530                                 goto out;
7531                         }
7532                 }
7533
7534                 for (i = 0; i < num_drivers; i++) {
7535                         DEBUG(5, ("\tdriver: [%s]\n", drivers[i]));
7536
7537                         result = winreg_get_driver(tmp_ctx, b,
7538                                                    architecture, drivers[i],
7539                                                    version, &driver);
7540                         if (!W_ERROR_IS_OK(result)) {
7541                                 goto out;
7542                         }
7543
7544                         switch (level) {
7545                         case 1:
7546                                 result = fill_printer_driver_info1(info, &info[count+i].info1,
7547                                                                    driver, servername);
7548                                 break;
7549                         case 2:
7550                                 result = fill_printer_driver_info2(info, &info[count+i].info2,
7551                                                                    driver, servername);
7552                                 break;
7553                         case 3:
7554                                 result = fill_printer_driver_info3(info, &info[count+i].info3,
7555                                                                    driver, servername);
7556                                 break;
7557                         case 4:
7558                                 result = fill_printer_driver_info4(info, &info[count+i].info4,
7559                                                                    driver, servername);
7560                                 break;
7561                         case 5:
7562                                 result = fill_printer_driver_info5(info, &info[count+i].info5,
7563                                                                    driver, servername);
7564                                 break;
7565                         case 6:
7566                                 result = fill_printer_driver_info6(info, &info[count+i].info6,
7567                                                                    driver, servername);
7568                                 break;
7569                         case 8:
7570                                 result = fill_printer_driver_info8(info, &info[count+i].info8,
7571                                                                    driver, servername);
7572                                 break;
7573                         default:
7574                                 result = WERR_UNKNOWN_LEVEL;
7575                                 break;
7576                         }
7577
7578                         TALLOC_FREE(driver);
7579
7580                         if (!W_ERROR_IS_OK(result)) {
7581                                 goto out;
7582                         }
7583                 }
7584
7585                 count += num_drivers;
7586                 TALLOC_FREE(drivers);
7587         }
7588
7589 out:
7590         if (W_ERROR_IS_OK(result)) {
7591                 *info_p = talloc_move(mem_ctx, &info);
7592                 *count_p = count;
7593         }
7594
7595         talloc_free(tmp_ctx);
7596         return result;
7597 }
7598
7599 /****************************************************************************
7600  Enumerates all printer drivers by level.
7601 ****************************************************************************/
7602
7603 static WERROR enumprinterdrivers_level(TALLOC_CTX *mem_ctx,
7604                                        const struct auth_session_info *session_info,
7605                                        struct messaging_context *msg_ctx,
7606                                        const char *servername,
7607                                        const char *architecture,
7608                                        uint32_t level,
7609                                        union spoolss_DriverInfo **info_p,
7610                                        uint32_t *count_p)
7611 {
7612         uint32_t a,i;
7613         WERROR result = WERR_OK;
7614
7615         if (strequal(architecture, SPOOLSS_ARCHITECTURE_ALL)) {
7616
7617                 for (a=0; archi_table[a].long_archi != NULL; a++) {
7618
7619                         union spoolss_DriverInfo *info = NULL;
7620                         uint32_t count = 0;
7621
7622                         result = enumprinterdrivers_level_by_architecture(mem_ctx,
7623                                                                           session_info,
7624                                                                           msg_ctx,
7625                                                                           servername,
7626                                                                           archi_table[a].long_archi,
7627                                                                           level,
7628                                                                           &info,
7629                                                                           &count);
7630                         if (!W_ERROR_IS_OK(result)) {
7631                                 continue;
7632                         }
7633
7634                         for (i=0; i < count; i++) {
7635                                 ADD_TO_ARRAY(mem_ctx, union spoolss_DriverInfo,
7636                                              info[i], info_p, count_p);
7637                         }
7638                 }
7639
7640                 return result;
7641         }
7642
7643         return enumprinterdrivers_level_by_architecture(mem_ctx,
7644                                                         session_info,
7645                                                         msg_ctx,
7646                                                         servername,
7647                                                         architecture,
7648                                                         level,
7649                                                         info_p,
7650                                                         count_p);
7651 }
7652
7653 /****************************************************************
7654  _spoolss_EnumPrinterDrivers
7655 ****************************************************************/
7656
7657 WERROR _spoolss_EnumPrinterDrivers(struct pipes_struct *p,
7658                                    struct spoolss_EnumPrinterDrivers *r)
7659 {
7660         const char *cservername;
7661         WERROR result;
7662
7663         /* that's an [in out] buffer */
7664
7665         if (!r->in.buffer && (r->in.offered != 0)) {
7666                 return WERR_INVALID_PARAM;
7667         }
7668
7669         DEBUG(4,("_spoolss_EnumPrinterDrivers\n"));
7670
7671         *r->out.needed = 0;
7672         *r->out.count = 0;
7673         *r->out.info = NULL;
7674
7675         cservername = canon_servername(r->in.server);
7676
7677         if (!is_myname_or_ipaddr(cservername)) {
7678                 return WERR_UNKNOWN_PRINTER_DRIVER;
7679         }
7680
7681         result = enumprinterdrivers_level(p->mem_ctx,
7682                                           get_session_info_system(),
7683                                           p->msg_ctx,
7684                                           cservername,
7685                                           r->in.environment,
7686                                           r->in.level,
7687                                           r->out.info,
7688                                           r->out.count);
7689         if (!W_ERROR_IS_OK(result)) {
7690                 return result;
7691         }
7692
7693         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
7694                                                      spoolss_EnumPrinterDrivers,
7695                                                      *r->out.info, r->in.level,
7696                                                      *r->out.count);
7697         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
7698         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
7699
7700         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7701 }
7702
7703 /****************************************************************
7704  _spoolss_EnumForms
7705 ****************************************************************/
7706
7707 WERROR _spoolss_EnumForms(struct pipes_struct *p,
7708                           struct spoolss_EnumForms *r)
7709 {
7710         WERROR result;
7711
7712         *r->out.count = 0;
7713         *r->out.needed = 0;
7714         *r->out.info = NULL;
7715
7716         /* that's an [in out] buffer */
7717
7718         if (!r->in.buffer && (r->in.offered != 0) ) {
7719                 return WERR_INVALID_PARAM;
7720         }
7721
7722         DEBUG(4,("_spoolss_EnumForms\n"));
7723         DEBUGADD(5,("Offered buffer size [%d]\n", r->in.offered));
7724         DEBUGADD(5,("Info level [%d]\n",          r->in.level));
7725
7726         switch (r->in.level) {
7727         case 1:
7728                 result = winreg_printer_enumforms1_internal(p->mem_ctx,
7729                                                    get_session_info_system(),
7730                                                    p->msg_ctx,
7731                                                    r->out.count,
7732                                                    r->out.info);
7733                 break;
7734         default:
7735                 result = WERR_UNKNOWN_LEVEL;
7736                 break;
7737         }
7738
7739         if (!W_ERROR_IS_OK(result)) {
7740                 return result;
7741         }
7742
7743         if (*r->out.count == 0) {
7744                 return WERR_NO_MORE_ITEMS;
7745         }
7746
7747         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
7748                                                      spoolss_EnumForms,
7749                                                      *r->out.info, r->in.level,
7750                                                      *r->out.count);
7751         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
7752         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
7753
7754         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7755 }
7756
7757 /****************************************************************
7758  _spoolss_GetForm
7759 ****************************************************************/
7760
7761 WERROR _spoolss_GetForm(struct pipes_struct *p,
7762                         struct spoolss_GetForm *r)
7763 {
7764         WERROR result;
7765
7766         /* that's an [in out] buffer */
7767
7768         if (!r->in.buffer && (r->in.offered != 0)) {
7769                 return WERR_INVALID_PARAM;
7770         }
7771
7772         DEBUG(4,("_spoolss_GetForm\n"));
7773         DEBUGADD(5,("Offered buffer size [%d]\n", r->in.offered));
7774         DEBUGADD(5,("Info level [%d]\n",          r->in.level));
7775
7776         switch (r->in.level) {
7777         case 1:
7778                 result = winreg_printer_getform1_internal(p->mem_ctx,
7779                                                  get_session_info_system(),
7780                                                  p->msg_ctx,
7781                                                  r->in.form_name,
7782                                                  &r->out.info->info1);
7783                 break;
7784         default:
7785                 result = WERR_UNKNOWN_LEVEL;
7786                 break;
7787         }
7788
7789         if (!W_ERROR_IS_OK(result)) {
7790                 TALLOC_FREE(r->out.info);
7791                 return result;
7792         }
7793
7794         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_FormInfo,
7795                                                r->out.info, r->in.level);
7796         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
7797
7798         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7799 }
7800
7801 /****************************************************************************
7802 ****************************************************************************/
7803
7804 static WERROR fill_port_1(TALLOC_CTX *mem_ctx,
7805                           struct spoolss_PortInfo1 *r,
7806                           const char *name)
7807 {
7808         r->port_name = talloc_strdup(mem_ctx, name);
7809         W_ERROR_HAVE_NO_MEMORY(r->port_name);
7810
7811         return WERR_OK;
7812 }
7813
7814 /****************************************************************************
7815  TODO: This probably needs distinguish between TCP/IP and Local ports
7816  somehow.
7817 ****************************************************************************/
7818
7819 static WERROR fill_port_2(TALLOC_CTX *mem_ctx,
7820                           struct spoolss_PortInfo2 *r,
7821                           const char *name)
7822 {
7823         r->port_name = talloc_strdup(mem_ctx, name);
7824         W_ERROR_HAVE_NO_MEMORY(r->port_name);
7825
7826         r->monitor_name = talloc_strdup(mem_ctx, "Local Monitor");
7827         W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
7828
7829         r->description = talloc_strdup(mem_ctx, SPL_LOCAL_PORT);
7830         W_ERROR_HAVE_NO_MEMORY(r->description);
7831
7832         r->port_type = SPOOLSS_PORT_TYPE_WRITE;
7833         r->reserved = 0;
7834
7835         return WERR_OK;
7836 }
7837
7838
7839 /****************************************************************************
7840  wrapper around the enumer ports command
7841 ****************************************************************************/
7842
7843 static WERROR enumports_hook(TALLOC_CTX *ctx, int *count, char ***lines)
7844 {
7845         char *cmd = lp_enumports_cmd(talloc_tos());
7846         char **qlines = NULL;
7847         char *command = NULL;
7848         int numlines;
7849         int ret;
7850         int fd;
7851
7852         *count = 0;
7853         *lines = NULL;
7854
7855         /* if no hook then just fill in the default port */
7856
7857         if ( !*cmd ) {
7858                 if (!(qlines = talloc_array( NULL, char*, 2 ))) {
7859                         return WERR_NOMEM;
7860                 }
7861                 if (!(qlines[0] = talloc_strdup(qlines, SAMBA_PRINTER_PORT_NAME ))) {
7862                         TALLOC_FREE(qlines);
7863                         return WERR_NOMEM;
7864                 }
7865                 qlines[1] = NULL;
7866                 numlines = 1;
7867         }
7868         else {
7869                 /* we have a valid enumport command */
7870
7871                 command = talloc_asprintf(ctx, "%s \"%d\"", cmd, 1);
7872                 if (!command) {
7873                         return WERR_NOMEM;
7874                 }
7875
7876                 DEBUG(10,("Running [%s]\n", command));
7877                 ret = smbrun(command, &fd);
7878                 DEBUG(10,("Returned [%d]\n", ret));
7879                 TALLOC_FREE(command);
7880                 if (ret != 0) {
7881                         if (fd != -1) {
7882                                 close(fd);
7883                         }
7884                         return WERR_ACCESS_DENIED;
7885                 }
7886
7887                 numlines = 0;
7888                 qlines = fd_lines_load(fd, &numlines, 0, NULL);
7889                 DEBUGADD(10,("Lines returned = [%d]\n", numlines));
7890                 close(fd);
7891         }
7892
7893         *count = numlines;
7894         *lines = qlines;
7895
7896         return WERR_OK;
7897 }
7898
7899 /****************************************************************************
7900  enumports level 1.
7901 ****************************************************************************/
7902
7903 static WERROR enumports_level_1(TALLOC_CTX *mem_ctx,
7904                                 union spoolss_PortInfo **info_p,
7905                                 uint32_t *count)
7906 {
7907         union spoolss_PortInfo *info = NULL;
7908         int i=0;
7909         WERROR result = WERR_OK;
7910         char **qlines = NULL;
7911         int numlines = 0;
7912
7913         result = enumports_hook(talloc_tos(), &numlines, &qlines );
7914         if (!W_ERROR_IS_OK(result)) {
7915                 goto out;
7916         }
7917
7918         if (numlines) {
7919                 info = talloc_array(mem_ctx, union spoolss_PortInfo, numlines);
7920                 if (!info) {
7921                         DEBUG(10,("Returning WERR_NOMEM\n"));
7922                         result = WERR_NOMEM;
7923                         goto out;
7924                 }
7925
7926                 for (i=0; i<numlines; i++) {
7927                         DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
7928                         result = fill_port_1(info, &info[i].info1, qlines[i]);
7929                         if (!W_ERROR_IS_OK(result)) {
7930                                 goto out;
7931                         }
7932                 }
7933         }
7934         TALLOC_FREE(qlines);
7935
7936 out:
7937         if (!W_ERROR_IS_OK(result)) {
7938                 TALLOC_FREE(info);
7939                 TALLOC_FREE(qlines);
7940                 *count = 0;
7941                 *info_p = NULL;
7942                 return result;
7943         }
7944
7945         *info_p = info;
7946         *count = numlines;
7947
7948         return WERR_OK;
7949 }
7950
7951 /****************************************************************************
7952  enumports level 2.
7953 ****************************************************************************/
7954
7955 static WERROR enumports_level_2(TALLOC_CTX *mem_ctx,
7956                                 union spoolss_PortInfo **info_p,
7957                                 uint32_t *count)
7958 {
7959         union spoolss_PortInfo *info = NULL;
7960         int i=0;
7961         WERROR result = WERR_OK;
7962         char **qlines = NULL;
7963         int numlines = 0;
7964
7965         result = enumports_hook(talloc_tos(), &numlines, &qlines );
7966         if (!W_ERROR_IS_OK(result)) {
7967                 goto out;
7968         }
7969
7970         if (numlines) {
7971                 info = talloc_array(mem_ctx, union spoolss_PortInfo, numlines);
7972                 if (!info) {
7973                         DEBUG(10,("Returning WERR_NOMEM\n"));
7974                         result = WERR_NOMEM;
7975                         goto out;
7976                 }
7977
7978                 for (i=0; i<numlines; i++) {
7979                         DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
7980                         result = fill_port_2(info, &info[i].info2, qlines[i]);
7981                         if (!W_ERROR_IS_OK(result)) {
7982                                 goto out;
7983                         }
7984                 }
7985         }
7986         TALLOC_FREE(qlines);
7987
7988 out:
7989         if (!W_ERROR_IS_OK(result)) {
7990                 TALLOC_FREE(info);
7991                 TALLOC_FREE(qlines);
7992                 *count = 0;
7993                 *info_p = NULL;
7994                 return result;
7995         }
7996
7997         *info_p = info;
7998         *count = numlines;
7999
8000         return WERR_OK;
8001 }
8002
8003 /****************************************************************
8004  _spoolss_EnumPorts
8005 ****************************************************************/
8006
8007 WERROR _spoolss_EnumPorts(struct pipes_struct *p,
8008                           struct spoolss_EnumPorts *r)
8009 {
8010         WERROR result;
8011
8012         /* that's an [in out] buffer */
8013
8014         if (!r->in.buffer && (r->in.offered != 0)) {
8015                 return WERR_INVALID_PARAM;
8016         }
8017
8018         DEBUG(4,("_spoolss_EnumPorts\n"));
8019
8020         *r->out.count = 0;
8021         *r->out.needed = 0;
8022         *r->out.info = NULL;
8023
8024         switch (r->in.level) {
8025         case 1:
8026                 result = enumports_level_1(p->mem_ctx, r->out.info,
8027                                            r->out.count);
8028                 break;
8029         case 2:
8030                 result = enumports_level_2(p->mem_ctx, r->out.info,
8031                                            r->out.count);
8032                 break;
8033         default:
8034                 return WERR_UNKNOWN_LEVEL;
8035         }
8036
8037         if (!W_ERROR_IS_OK(result)) {
8038                 return result;
8039         }
8040
8041         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8042                                                      spoolss_EnumPorts,
8043                                                      *r->out.info, r->in.level,
8044                                                      *r->out.count);
8045         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8046         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8047
8048         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8049 }
8050
8051 /****************************************************************************
8052 ****************************************************************************/
8053
8054 static WERROR spoolss_addprinterex_level_2(struct pipes_struct *p,
8055                                            const char *server,
8056                                            struct spoolss_SetPrinterInfoCtr *info_ctr,
8057                                            struct spoolss_DeviceMode *devmode,
8058                                            struct security_descriptor *secdesc,
8059                                            struct spoolss_UserLevelCtr *user_ctr,
8060                                            struct policy_handle *handle)
8061 {
8062         struct spoolss_SetPrinterInfo2 *info2 = info_ctr->info.info2;
8063         uint32_t info2_mask = SPOOLSS_PRINTER_INFO_ALL;
8064         int     snum;
8065         WERROR err = WERR_OK;
8066
8067         /* samba does not have a concept of local, non-shared printers yet, so
8068          * make sure we always setup sharename - gd */
8069         if ((info2->sharename == NULL || info2->sharename[0] == '\0') &&
8070             (info2->printername != NULL && info2->printername[0] != '\0')) {
8071                 DEBUG(5, ("spoolss_addprinterex_level_2: "
8072                         "no sharename has been set, setting printername %s as sharename\n",
8073                         info2->printername));
8074                 info2->sharename = info2->printername;
8075         }
8076
8077         /* check to see if the printer already exists */
8078         if ((snum = print_queue_snum(info2->sharename)) != -1) {
8079                 DEBUG(5, ("spoolss_addprinterex_level_2: Attempted to add a printer named [%s] when one already existed!\n",
8080                         info2->sharename));
8081                 return WERR_PRINTER_ALREADY_EXISTS;
8082         }
8083
8084         if (!lp_force_printername(GLOBAL_SECTION_SNUM)) {
8085                 if ((snum = print_queue_snum(info2->printername)) != -1) {
8086                         DEBUG(5, ("spoolss_addprinterex_level_2: Attempted to add a printer named [%s] when one already existed!\n",
8087                                 info2->printername));
8088                         return WERR_PRINTER_ALREADY_EXISTS;
8089                 }
8090         }
8091
8092         /* validate printer info struct */
8093         if (!info2->printername || strlen(info2->printername) == 0) {
8094                 return WERR_INVALID_PRINTER_NAME;
8095         }
8096         if (!info2->portname || strlen(info2->portname) == 0) {
8097                 return WERR_UNKNOWN_PORT;
8098         }
8099         if (!info2->drivername || strlen(info2->drivername) == 0) {
8100                 return WERR_UNKNOWN_PRINTER_DRIVER;
8101         }
8102         if (!info2->printprocessor || strlen(info2->printprocessor) == 0) {
8103                 return WERR_UNKNOWN_PRINTPROCESSOR;
8104         }
8105
8106         /* FIXME!!!  smbd should check to see if the driver is installed before
8107            trying to add a printer like this  --jerry */
8108
8109         if (*lp_addprinter_cmd(talloc_tos()) ) {
8110                 char *raddr;
8111
8112                 raddr = tsocket_address_inet_addr_string(p->remote_address,
8113                                                          p->mem_ctx);
8114                 if (raddr == NULL) {
8115                         return WERR_NOMEM;
8116                 }
8117
8118                 if ( !add_printer_hook(p->mem_ctx, p->session_info->security_token,
8119                                        info2, raddr,
8120                                        p->msg_ctx) ) {
8121                         return WERR_ACCESS_DENIED;
8122                 }
8123         } else {
8124                 DEBUG(0,("spoolss_addprinterex_level_2: add printer for printer %s called and no "
8125                         "smb.conf parameter \"addprinter command\" is defined. This "
8126                         "parameter must exist for this call to succeed\n",
8127                         info2->sharename ));
8128         }
8129
8130         if ((snum = print_queue_snum(info2->sharename)) == -1) {
8131                 return WERR_ACCESS_DENIED;
8132         }
8133
8134         /* you must be a printer admin to add a new printer */
8135         if (!print_access_check(p->session_info,
8136                                 p->msg_ctx,
8137                                 snum,
8138                                 PRINTER_ACCESS_ADMINISTER)) {
8139                 return WERR_ACCESS_DENIED;
8140         }
8141
8142         /*
8143          * Do sanity check on the requested changes for Samba.
8144          */
8145
8146         if (!check_printer_ok(p->mem_ctx, info2, snum)) {
8147                 return WERR_INVALID_PARAM;
8148         }
8149
8150         if (devmode == NULL) {
8151                 info2_mask = ~SPOOLSS_PRINTER_INFO_DEVMODE;
8152         }
8153
8154         err = update_dsspooler(p->mem_ctx,
8155                                get_session_info_system(),
8156                                p->msg_ctx,
8157                                0,
8158                                info2,
8159                                NULL);
8160         if (!W_ERROR_IS_OK(err)) {
8161                 return err;
8162         }
8163
8164         err = winreg_update_printer_internal(p->mem_ctx,
8165                                     get_session_info_system(),
8166                                     p->msg_ctx,
8167                                     info2->sharename,
8168                                     info2_mask,
8169                                     info2,
8170                                     devmode,
8171                                     secdesc);
8172         if (!W_ERROR_IS_OK(err)) {
8173                 return err;
8174         }
8175
8176         err = open_printer_hnd(p, handle, info2->printername, PRINTER_ACCESS_ADMINISTER);
8177         if (!W_ERROR_IS_OK(err)) {
8178                 /* Handle open failed - remove addition. */
8179                 ZERO_STRUCTP(handle);
8180                 return err;
8181         }
8182
8183         return WERR_OK;
8184 }
8185
8186 /****************************************************************
8187  _spoolss_AddPrinterEx
8188 ****************************************************************/
8189
8190 WERROR _spoolss_AddPrinterEx(struct pipes_struct *p,
8191                              struct spoolss_AddPrinterEx *r)
8192 {
8193         switch (r->in.info_ctr->level) {
8194         case 1:
8195                 /* we don't handle yet */
8196                 /* but I know what to do ... */
8197                 return WERR_UNKNOWN_LEVEL;
8198         case 2:
8199                 return spoolss_addprinterex_level_2(p, r->in.server,
8200                                                     r->in.info_ctr,
8201                                                     r->in.devmode_ctr->devmode,
8202                                                     r->in.secdesc_ctr->sd,
8203                                                     r->in.userlevel_ctr,
8204                                                     r->out.handle);
8205         default:
8206                 return WERR_UNKNOWN_LEVEL;
8207         }
8208 }
8209
8210 /****************************************************************
8211  _spoolss_AddPrinter
8212 ****************************************************************/
8213
8214 WERROR _spoolss_AddPrinter(struct pipes_struct *p,
8215                            struct spoolss_AddPrinter *r)
8216 {
8217         struct spoolss_AddPrinterEx a;
8218         struct spoolss_UserLevelCtr userlevel_ctr;
8219
8220         ZERO_STRUCT(userlevel_ctr);
8221
8222         userlevel_ctr.level = 1;
8223
8224         a.in.server             = r->in.server;
8225         a.in.info_ctr           = r->in.info_ctr;
8226         a.in.devmode_ctr        = r->in.devmode_ctr;
8227         a.in.secdesc_ctr        = r->in.secdesc_ctr;
8228         a.in.userlevel_ctr      = &userlevel_ctr;
8229         a.out.handle            = r->out.handle;
8230
8231         return _spoolss_AddPrinterEx(p, &a);
8232 }
8233
8234 /****************************************************************
8235  _spoolss_AddPrinterDriverEx
8236 ****************************************************************/
8237
8238 WERROR _spoolss_AddPrinterDriverEx(struct pipes_struct *p,
8239                                    struct spoolss_AddPrinterDriverEx *r)
8240 {
8241         WERROR err = WERR_OK;
8242         const char *driver_name = NULL;
8243         uint32_t version;
8244         const char *fn;
8245
8246         switch (p->opnum) {
8247                 case NDR_SPOOLSS_ADDPRINTERDRIVER:
8248                         fn = "_spoolss_AddPrinterDriver";
8249                         break;
8250                 case NDR_SPOOLSS_ADDPRINTERDRIVEREX:
8251                         fn = "_spoolss_AddPrinterDriverEx";
8252                         break;
8253                 default:
8254                         return WERR_INVALID_PARAM;
8255         }
8256
8257         /*
8258          * we only support the semantics of AddPrinterDriver()
8259          * i.e. only copy files that are newer than existing ones
8260          */
8261
8262         if (r->in.flags == 0) {
8263                 return WERR_INVALID_PARAM;
8264         }
8265
8266         if (r->in.flags != APD_COPY_NEW_FILES) {
8267                 return WERR_ACCESS_DENIED;
8268         }
8269
8270         /* FIXME */
8271         if (r->in.info_ctr->level != 3 && r->in.info_ctr->level != 6) {
8272                 /* Clever hack from Martin Zielinski <mz@seh.de>
8273                  * to allow downgrade from level 8 (Vista).
8274                  */
8275                 DEBUG(0,("%s: level %d not yet implemented\n", fn,
8276                         r->in.info_ctr->level));
8277                 return WERR_UNKNOWN_LEVEL;
8278         }
8279
8280         DEBUG(5,("Cleaning driver's information\n"));
8281         err = clean_up_driver_struct(p->mem_ctx, p->session_info, r->in.info_ctr);
8282         if (!W_ERROR_IS_OK(err))
8283                 goto done;
8284
8285         DEBUG(5,("Moving driver to final destination\n"));
8286         err = move_driver_to_download_area(p->session_info, r->in.info_ctr);
8287         if (!W_ERROR_IS_OK(err)) {
8288                 goto done;
8289         }
8290
8291         err = winreg_add_driver_internal(p->mem_ctx,
8292                                 get_session_info_system(),
8293                                 p->msg_ctx,
8294                                 r->in.info_ctr,
8295                                 &driver_name,
8296                                 &version);
8297         if (!W_ERROR_IS_OK(err)) {
8298                 goto done;
8299         }
8300
8301         /*
8302          * I think this is where he DrvUpgradePrinter() hook would be
8303          * be called in a driver's interface DLL on a Windows NT 4.0/2k
8304          * server.  Right now, we just need to send ourselves a message
8305          * to update each printer bound to this driver.   --jerry
8306          */
8307
8308         if (!srv_spoolss_drv_upgrade_printer(driver_name, p->msg_ctx)) {
8309                 DEBUG(0,("%s: Failed to send message about upgrading driver [%s]!\n",
8310                         fn, driver_name));
8311         }
8312
8313 done:
8314         return err;
8315 }
8316
8317 /****************************************************************
8318  _spoolss_AddPrinterDriver
8319 ****************************************************************/
8320
8321 WERROR _spoolss_AddPrinterDriver(struct pipes_struct *p,
8322                                  struct spoolss_AddPrinterDriver *r)
8323 {
8324         struct spoolss_AddPrinterDriverEx a;
8325
8326         switch (r->in.info_ctr->level) {
8327         case 2:
8328         case 3:
8329         case 4:
8330         case 5:
8331                 break;
8332         default:
8333                 return WERR_UNKNOWN_LEVEL;
8334         }
8335
8336         a.in.servername         = r->in.servername;
8337         a.in.info_ctr           = r->in.info_ctr;
8338         a.in.flags              = APD_COPY_NEW_FILES;
8339
8340         return _spoolss_AddPrinterDriverEx(p, &a);
8341 }
8342
8343 /****************************************************************************
8344 ****************************************************************************/
8345
8346 struct _spoolss_paths {
8347         int type;
8348         const char *share;
8349         const char *dir;
8350 };
8351
8352 enum { SPOOLSS_DRIVER_PATH, SPOOLSS_PRTPROCS_PATH };
8353
8354 static const struct _spoolss_paths spoolss_paths[]= {
8355         { SPOOLSS_DRIVER_PATH,          "print$",       "DRIVERS" },
8356         { SPOOLSS_PRTPROCS_PATH,        "prnproc$",     "PRTPROCS" }
8357 };
8358
8359 static WERROR compose_spoolss_server_path(TALLOC_CTX *mem_ctx,
8360                                           const char *servername,
8361                                           const char *environment,
8362                                           int component,
8363                                           char **path)
8364 {
8365         const char *pservername = NULL;
8366         const char *long_archi;
8367         const char *short_archi;
8368
8369         *path = NULL;
8370
8371         /* environment may be empty */
8372         if (environment && strlen(environment)) {
8373                 long_archi = environment;
8374         } else {
8375                 long_archi = lp_parm_const_string(GLOBAL_SECTION_SNUM,
8376                                                   "spoolss", "architecture",
8377                                                   SPOOLSS_ARCHITECTURE_NT_X86);
8378         }
8379
8380         /* servername may be empty */
8381         if (servername && strlen(servername)) {
8382                 pservername = canon_servername(servername);
8383
8384                 if (!is_myname_or_ipaddr(pservername)) {
8385                         return WERR_INVALID_PARAM;
8386                 }
8387         }
8388
8389         if (!(short_archi = get_short_archi(long_archi))) {
8390                 return WERR_INVALID_ENVIRONMENT;
8391         }
8392
8393         switch (component) {
8394         case SPOOLSS_PRTPROCS_PATH:
8395         case SPOOLSS_DRIVER_PATH:
8396                 if (pservername) {
8397                         *path = talloc_asprintf(mem_ctx,
8398                                         "\\\\%s\\%s\\%s",
8399                                         pservername,
8400                                         spoolss_paths[component].share,
8401                                         short_archi);
8402                 } else {
8403                         *path = talloc_asprintf(mem_ctx, "%s\\%s\\%s",
8404                                         SPOOLSS_DEFAULT_SERVER_PATH,
8405                                         spoolss_paths[component].dir,
8406                                         short_archi);
8407                 }
8408                 break;
8409         default:
8410                 return WERR_INVALID_PARAM;
8411         }
8412
8413         if (!*path) {
8414                 return WERR_NOMEM;
8415         }
8416
8417         return WERR_OK;
8418 }
8419
8420 /****************************************************************************
8421 ****************************************************************************/
8422
8423 static WERROR getprinterdriverdir_level_1(TALLOC_CTX *mem_ctx,
8424                                           const char *servername,
8425                                           const char *environment,
8426                                           struct spoolss_DriverDirectoryInfo1 *r)
8427 {
8428         WERROR werr;
8429         char *path = NULL;
8430
8431         werr = compose_spoolss_server_path(mem_ctx,
8432                                            servername,
8433                                            environment,
8434                                            SPOOLSS_DRIVER_PATH,
8435                                            &path);
8436         if (!W_ERROR_IS_OK(werr)) {
8437                 return werr;
8438         }
8439
8440         DEBUG(4,("printer driver directory: [%s]\n", path));
8441
8442         r->directory_name = path;
8443
8444         return WERR_OK;
8445 }
8446
8447 /****************************************************************
8448  _spoolss_GetPrinterDriverDirectory
8449 ****************************************************************/
8450
8451 WERROR _spoolss_GetPrinterDriverDirectory(struct pipes_struct *p,
8452                                           struct spoolss_GetPrinterDriverDirectory *r)
8453 {
8454         WERROR werror;
8455
8456         /* that's an [in out] buffer */
8457
8458         if (!r->in.buffer && (r->in.offered != 0)) {
8459                 return WERR_INVALID_PARAM;
8460         }
8461
8462         DEBUG(5,("_spoolss_GetPrinterDriverDirectory: level %d\n",
8463                 r->in.level));
8464
8465         *r->out.needed = 0;
8466
8467         /* r->in.level is ignored */
8468
8469         werror = getprinterdriverdir_level_1(p->mem_ctx,
8470                                              r->in.server,
8471                                              r->in.environment,
8472                                              &r->out.info->info1);
8473         if (!W_ERROR_IS_OK(werror)) {
8474                 TALLOC_FREE(r->out.info);
8475                 return werror;
8476         }
8477
8478         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_DriverDirectoryInfo,
8479                                                r->out.info, r->in.level);
8480         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
8481
8482         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8483 }
8484
8485 /****************************************************************
8486  _spoolss_EnumPrinterData
8487 ****************************************************************/
8488
8489 WERROR _spoolss_EnumPrinterData(struct pipes_struct *p,
8490                                 struct spoolss_EnumPrinterData *r)
8491 {
8492         WERROR result;
8493         struct spoolss_EnumPrinterDataEx r2;
8494         uint32_t count;
8495         struct spoolss_PrinterEnumValues *info, *val = NULL;
8496         uint32_t needed;
8497
8498         r2.in.handle    = r->in.handle;
8499         r2.in.key_name  = "PrinterDriverData";
8500         r2.in.offered   = 0;
8501         r2.out.count    = &count;
8502         r2.out.info     = &info;
8503         r2.out.needed   = &needed;
8504
8505         result = _spoolss_EnumPrinterDataEx(p, &r2);
8506         if (W_ERROR_EQUAL(result, WERR_MORE_DATA)) {
8507                 r2.in.offered = needed;
8508                 result = _spoolss_EnumPrinterDataEx(p, &r2);
8509         }
8510         if (!W_ERROR_IS_OK(result)) {
8511                 return result;
8512         }
8513
8514         /*
8515          * The NT machine wants to know the biggest size of value and data
8516          *
8517          * cf: MSDN EnumPrinterData remark section
8518          */
8519
8520         if (!r->in.value_offered && !r->in.data_offered) {
8521                 uint32_t biggest_valuesize = 0;
8522                 uint32_t biggest_datasize = 0;
8523                 int i, name_length;
8524
8525                 DEBUGADD(6,("Activating NT mega-hack to find sizes\n"));
8526
8527                 for (i=0; i<count; i++) {
8528
8529                         name_length = strlen(info[i].value_name);
8530                         if (strlen(info[i].value_name) > biggest_valuesize) {
8531                                 biggest_valuesize = name_length;
8532                         }
8533
8534                         if (info[i].data_length > biggest_datasize) {
8535                                 biggest_datasize = info[i].data_length;
8536                         }
8537
8538                         DEBUG(6,("current values: [%d], [%d]\n", biggest_valuesize,
8539                                 biggest_datasize));
8540                 }
8541
8542                 /* the value is an UNICODE string but real_value_size is the length
8543                    in bytes including the trailing 0 */
8544
8545                 *r->out.value_needed = 2 * (1 + biggest_valuesize);
8546                 *r->out.data_needed  = biggest_datasize;
8547
8548                 DEBUG(6,("final values: [%d], [%d]\n",
8549                         *r->out.value_needed, *r->out.data_needed));
8550
8551                 return WERR_OK;
8552         }
8553
8554         if (r->in.enum_index < count) {
8555                 val = &info[r->in.enum_index];
8556         }
8557
8558         if (val == NULL) {
8559                 /* out_value should default to "" or else NT4 has
8560                    problems unmarshalling the response */
8561
8562                 if (r->in.value_offered) {
8563                         *r->out.value_needed = 1;
8564                         r->out.value_name = talloc_strdup(r, "");
8565                         if (!r->out.value_name) {
8566                                 return WERR_NOMEM;
8567                         }
8568                 } else {
8569                         r->out.value_name = NULL;
8570                         *r->out.value_needed = 0;
8571                 }
8572
8573                 /* the data is counted in bytes */
8574
8575                 *r->out.data_needed = r->in.data_offered;
8576
8577                 result = WERR_NO_MORE_ITEMS;
8578         } else {
8579                 /*
8580                  * the value is:
8581                  * - counted in bytes in the request
8582                  * - counted in UNICODE chars in the max reply
8583                  * - counted in bytes in the real size
8584                  *
8585                  * take a pause *before* coding not *during* coding
8586                  */
8587
8588                 /* name */
8589                 if (r->in.value_offered) {
8590                         r->out.value_name = talloc_strdup(r, val->value_name);
8591                         if (!r->out.value_name) {
8592                                 return WERR_NOMEM;
8593                         }
8594                         *r->out.value_needed = val->value_name_len;
8595                 } else {
8596                         r->out.value_name = NULL;
8597                         *r->out.value_needed = 0;
8598                 }
8599
8600                 /* type */
8601
8602                 *r->out.type = val->type;
8603
8604                 /* data - counted in bytes */
8605
8606                 /*
8607                  * See the section "Dynamically Typed Query Parameters"
8608                  * in MS-RPRN.
8609                  */
8610
8611                 if (r->out.data && val->data && val->data->data &&
8612                                 val->data_length && r->in.data_offered) {
8613                         memcpy(r->out.data, val->data->data,
8614                                 MIN(val->data_length,r->in.data_offered));
8615                 }
8616
8617                 *r->out.data_needed = val->data_length;
8618
8619                 result = WERR_OK;
8620         }
8621
8622         return result;
8623 }
8624
8625 /****************************************************************
8626  _spoolss_SetPrinterData
8627 ****************************************************************/
8628
8629 WERROR _spoolss_SetPrinterData(struct pipes_struct *p,
8630                                struct spoolss_SetPrinterData *r)
8631 {
8632         struct spoolss_SetPrinterDataEx r2;
8633
8634         r2.in.handle            = r->in.handle;
8635         r2.in.key_name          = "PrinterDriverData";
8636         r2.in.value_name        = r->in.value_name;
8637         r2.in.type              = r->in.type;
8638         r2.in.data              = r->in.data;
8639         r2.in.offered           = r->in.offered;
8640
8641         return _spoolss_SetPrinterDataEx(p, &r2);
8642 }
8643
8644 /****************************************************************
8645  _spoolss_ResetPrinter
8646 ****************************************************************/
8647
8648 WERROR _spoolss_ResetPrinter(struct pipes_struct *p,
8649                              struct spoolss_ResetPrinter *r)
8650 {
8651         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
8652         int             snum;
8653
8654         DEBUG(5,("_spoolss_ResetPrinter\n"));
8655
8656         /*
8657          * All we do is to check to see if the handle and queue is valid.
8658          * This call really doesn't mean anything to us because we only
8659          * support RAW printing.   --jerry
8660          */
8661
8662         if (!Printer) {
8663                 DEBUG(2,("_spoolss_ResetPrinter: Invalid handle (%s:%u:%u).\n",
8664                         OUR_HANDLE(r->in.handle)));
8665                 return WERR_BADFID;
8666         }
8667
8668         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8669                 return WERR_BADFID;
8670
8671
8672         /* blindly return success */
8673         return WERR_OK;
8674 }
8675
8676 /****************************************************************
8677  _spoolss_DeletePrinterData
8678 ****************************************************************/
8679
8680 WERROR _spoolss_DeletePrinterData(struct pipes_struct *p,
8681                                   struct spoolss_DeletePrinterData *r)
8682 {
8683         struct spoolss_DeletePrinterDataEx r2;
8684
8685         r2.in.handle            = r->in.handle;
8686         r2.in.key_name          = "PrinterDriverData";
8687         r2.in.value_name        = r->in.value_name;
8688
8689         return _spoolss_DeletePrinterDataEx(p, &r2);
8690 }
8691
8692 /****************************************************************
8693  _spoolss_AddForm
8694 ****************************************************************/
8695
8696 WERROR _spoolss_AddForm(struct pipes_struct *p,
8697                         struct spoolss_AddForm *r)
8698 {
8699         struct spoolss_AddFormInfo1 *form;
8700         int snum = -1;
8701         WERROR status = WERR_OK;
8702         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
8703         struct dcerpc_binding_handle *b;
8704         TALLOC_CTX *tmp_ctx = NULL;
8705
8706         DEBUG(5,("_spoolss_AddForm\n"));
8707
8708         if (!Printer) {
8709                 DEBUG(2,("_spoolss_AddForm: Invalid handle (%s:%u:%u).\n",
8710                         OUR_HANDLE(r->in.handle)));
8711                 return WERR_BADFID;
8712         }
8713
8714         /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
8715            and not a printer admin, then fail */
8716
8717         if ((p->session_info->unix_token->uid != sec_initial_uid()) &&
8718             !security_token_has_privilege(p->session_info->security_token,
8719                                           SEC_PRIV_PRINT_OPERATOR)) {
8720                 DEBUG(2,("_spoolss_Addform: denied by insufficient permissions.\n"));
8721                 return WERR_ACCESS_DENIED;
8722         }
8723
8724         if (r->in.info_ctr->level != 1) {
8725                 return WERR_INVALID_LEVEL;
8726         }
8727
8728         form = r->in.info_ctr->info.info1;
8729         if (!form) {
8730                 return WERR_INVALID_PARAM;
8731         }
8732
8733         switch (form->flags) {
8734         case SPOOLSS_FORM_USER:
8735         case SPOOLSS_FORM_BUILTIN:
8736         case SPOOLSS_FORM_PRINTER:
8737                 break;
8738         default:
8739                 return WERR_INVALID_PARAM;
8740         }
8741
8742         tmp_ctx = talloc_new(p->mem_ctx);
8743         if (!tmp_ctx) {
8744                 return WERR_NOMEM;
8745         }
8746
8747         status = winreg_printer_binding_handle(tmp_ctx,
8748                                                get_session_info_system(),
8749                                                p->msg_ctx,
8750                                                &b);
8751         if (!W_ERROR_IS_OK(status)) {
8752                 goto done;
8753         }
8754
8755         status = winreg_printer_addform1(tmp_ctx, b, form);
8756         if (!W_ERROR_IS_OK(status)) {
8757                 goto done;
8758         }
8759
8760         /*
8761          * ChangeID must always be set if this is a printer
8762          */
8763         if (Printer->printer_type == SPLHND_PRINTER) {
8764                 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8765                         status = WERR_BADFID;
8766                         goto done;
8767                 }
8768
8769                 status = winreg_printer_update_changeid(tmp_ctx, b,
8770                                                         lp_const_servicename(snum));
8771         }
8772
8773 done:
8774         talloc_free(tmp_ctx);
8775         return status;
8776 }
8777
8778 /****************************************************************
8779  _spoolss_DeleteForm
8780 ****************************************************************/
8781
8782 WERROR _spoolss_DeleteForm(struct pipes_struct *p,
8783                            struct spoolss_DeleteForm *r)
8784 {
8785         const char *form_name = r->in.form_name;
8786         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
8787         int snum = -1;
8788         WERROR status = WERR_OK;
8789         struct dcerpc_binding_handle *b;
8790         TALLOC_CTX *tmp_ctx = NULL;
8791
8792         DEBUG(5,("_spoolss_DeleteForm\n"));
8793
8794         if (!Printer) {
8795                 DEBUG(2,("_spoolss_DeleteForm: Invalid handle (%s:%u:%u).\n",
8796                         OUR_HANDLE(r->in.handle)));
8797                 return WERR_BADFID;
8798         }
8799
8800         if ((p->session_info->unix_token->uid != sec_initial_uid()) &&
8801             !security_token_has_privilege(p->session_info->security_token,
8802                                           SEC_PRIV_PRINT_OPERATOR)) {
8803                 DEBUG(2,("_spoolss_DeleteForm: denied by insufficient permissions.\n"));
8804                 return WERR_ACCESS_DENIED;
8805         }
8806
8807         tmp_ctx = talloc_new(p->mem_ctx);
8808         if (!tmp_ctx) {
8809                 return WERR_NOMEM;
8810         }
8811
8812         status = winreg_printer_binding_handle(tmp_ctx,
8813                                                get_session_info_system(),
8814                                                p->msg_ctx,
8815                                                &b);
8816         if (!W_ERROR_IS_OK(status)) {
8817                 goto done;
8818         }
8819
8820         status = winreg_printer_deleteform1(tmp_ctx, b, form_name);
8821         if (!W_ERROR_IS_OK(status)) {
8822                 goto done;
8823         }
8824
8825         /*
8826          * ChangeID must always be set if this is a printer
8827          */
8828         if (Printer->printer_type == SPLHND_PRINTER) {
8829                 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8830                         status = WERR_BADFID;
8831                         goto done;
8832                 }
8833
8834                 status = winreg_printer_update_changeid(tmp_ctx, b,
8835                                                         lp_const_servicename(snum));
8836         }
8837
8838 done:
8839         talloc_free(tmp_ctx);
8840         return status;
8841 }
8842
8843 /****************************************************************
8844  _spoolss_SetForm
8845 ****************************************************************/
8846
8847 WERROR _spoolss_SetForm(struct pipes_struct *p,
8848                         struct spoolss_SetForm *r)
8849 {
8850         struct spoolss_AddFormInfo1 *form;
8851         const char *form_name = r->in.form_name;
8852         int snum = -1;
8853         WERROR status = WERR_OK;
8854         struct dcerpc_binding_handle *b;
8855         TALLOC_CTX *tmp_ctx = NULL;
8856
8857         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
8858
8859         DEBUG(5,("_spoolss_SetForm\n"));
8860
8861         if (!Printer) {
8862                 DEBUG(2,("_spoolss_SetForm: Invalid handle (%s:%u:%u).\n",
8863                         OUR_HANDLE(r->in.handle)));
8864                 return WERR_BADFID;
8865         }
8866
8867         /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
8868            and not a printer admin, then fail */
8869
8870         if ((p->session_info->unix_token->uid != sec_initial_uid()) &&
8871              !security_token_has_privilege(p->session_info->security_token,
8872                                            SEC_PRIV_PRINT_OPERATOR)) {
8873                 DEBUG(2,("_spoolss_Setform: denied by insufficient permissions.\n"));
8874                 return WERR_ACCESS_DENIED;
8875         }
8876
8877         if (r->in.info_ctr->level != 1) {
8878                 return WERR_INVALID_LEVEL;
8879         }
8880
8881         form = r->in.info_ctr->info.info1;
8882         if (!form) {
8883                 return WERR_INVALID_PARAM;
8884         }
8885
8886         tmp_ctx = talloc_new(p->mem_ctx);
8887         if (!tmp_ctx) {
8888                 return WERR_NOMEM;
8889         }
8890
8891         status = winreg_printer_binding_handle(tmp_ctx,
8892                                                get_session_info_system(),
8893                                                p->msg_ctx,
8894                                                &b);
8895         if (!W_ERROR_IS_OK(status)) {
8896                 goto done;
8897         }
8898
8899         status = winreg_printer_setform1(tmp_ctx, b,
8900                                          form_name,
8901                                          form);
8902         if (!W_ERROR_IS_OK(status)) {
8903                 goto done;
8904         }
8905
8906         /*
8907          * ChangeID must always be set if this is a printer
8908          */
8909         if (Printer->printer_type == SPLHND_PRINTER) {
8910                 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8911                         status = WERR_BADFID;
8912                         goto done;
8913                 }
8914
8915                 status = winreg_printer_update_changeid(tmp_ctx, b,
8916                                                         lp_const_servicename(snum));
8917         }
8918
8919 done:
8920         talloc_free(tmp_ctx);
8921         return status;
8922 }
8923
8924 /****************************************************************************
8925  fill_print_processor1
8926 ****************************************************************************/
8927
8928 static WERROR fill_print_processor1(TALLOC_CTX *mem_ctx,
8929                                     struct spoolss_PrintProcessorInfo1 *r,
8930                                     const char *print_processor_name)
8931 {
8932         r->print_processor_name = talloc_strdup(mem_ctx, print_processor_name);
8933         W_ERROR_HAVE_NO_MEMORY(r->print_processor_name);
8934
8935         return WERR_OK;
8936 }
8937
8938 /****************************************************************************
8939  enumprintprocessors level 1.
8940 ****************************************************************************/
8941
8942 static WERROR enumprintprocessors_level_1(TALLOC_CTX *mem_ctx,
8943                                           union spoolss_PrintProcessorInfo **info_p,
8944                                           uint32_t *count)
8945 {
8946         union spoolss_PrintProcessorInfo *info;
8947         WERROR result;
8948
8949         info = talloc_array(mem_ctx, union spoolss_PrintProcessorInfo, 1);
8950         W_ERROR_HAVE_NO_MEMORY(info);
8951
8952         *count = 1;
8953
8954         result = fill_print_processor1(info, &info[0].info1, "winprint");
8955         if (!W_ERROR_IS_OK(result)) {
8956                 goto out;
8957         }
8958
8959  out:
8960         if (!W_ERROR_IS_OK(result)) {
8961                 TALLOC_FREE(info);
8962                 *count = 0;
8963                 return result;
8964         }
8965
8966         *info_p = info;
8967
8968         return WERR_OK;
8969 }
8970
8971 /****************************************************************
8972  _spoolss_EnumPrintProcessors
8973 ****************************************************************/
8974
8975 WERROR _spoolss_EnumPrintProcessors(struct pipes_struct *p,
8976                                     struct spoolss_EnumPrintProcessors *r)
8977 {
8978         WERROR result;
8979
8980         /* that's an [in out] buffer */
8981
8982         if (!r->in.buffer && (r->in.offered != 0)) {
8983                 return WERR_INVALID_PARAM;
8984         }
8985
8986         DEBUG(5,("_spoolss_EnumPrintProcessors\n"));
8987
8988         /*
8989          * Enumerate the print processors ...
8990          *
8991          * Just reply with "winprint", to keep NT happy
8992          * and I can use my nice printer checker.
8993          */
8994
8995         *r->out.count = 0;
8996         *r->out.needed = 0;
8997         *r->out.info = NULL;
8998
8999         if (!get_short_archi(r->in.environment)) {
9000                 return WERR_INVALID_ENVIRONMENT;
9001         }
9002
9003         switch (r->in.level) {
9004         case 1:
9005                 result = enumprintprocessors_level_1(p->mem_ctx, r->out.info,
9006                                                      r->out.count);
9007                 break;
9008         default:
9009                 return WERR_UNKNOWN_LEVEL;
9010         }
9011
9012         if (!W_ERROR_IS_OK(result)) {
9013                 return result;
9014         }
9015
9016         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
9017                                                      spoolss_EnumPrintProcessors,
9018                                                      *r->out.info, r->in.level,
9019                                                      *r->out.count);
9020         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
9021         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
9022
9023         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
9024 }
9025
9026 /****************************************************************************
9027  fill_printprocdatatype1
9028 ****************************************************************************/
9029
9030 static WERROR fill_printprocdatatype1(TALLOC_CTX *mem_ctx,
9031                                       struct spoolss_PrintProcDataTypesInfo1 *r,
9032                                       const char *name_array)
9033 {
9034         r->name_array = talloc_strdup(mem_ctx, name_array);
9035         W_ERROR_HAVE_NO_MEMORY(r->name_array);
9036
9037         return WERR_OK;
9038 }
9039
9040 /****************************************************************************
9041  enumprintprocdatatypes level 1.
9042 ****************************************************************************/
9043
9044 static WERROR enumprintprocdatatypes_level_1(TALLOC_CTX *mem_ctx,
9045                                              union spoolss_PrintProcDataTypesInfo **info_p,
9046                                              uint32_t *count)
9047 {
9048         WERROR result;
9049         union spoolss_PrintProcDataTypesInfo *info;
9050
9051         info = talloc_array(mem_ctx, union spoolss_PrintProcDataTypesInfo, 1);
9052         W_ERROR_HAVE_NO_MEMORY(info);
9053
9054         *count = 1;
9055
9056         result = fill_printprocdatatype1(info, &info[0].info1, "RAW");
9057         if (!W_ERROR_IS_OK(result)) {
9058                 goto out;
9059         }
9060
9061  out:
9062         if (!W_ERROR_IS_OK(result)) {
9063                 TALLOC_FREE(info);
9064                 *count = 0;
9065                 return result;
9066         }
9067
9068         *info_p = info;
9069
9070         return WERR_OK;
9071 }
9072
9073 /****************************************************************
9074  _spoolss_EnumPrintProcDataTypes
9075 ****************************************************************/
9076
9077 WERROR _spoolss_EnumPrintProcDataTypes(struct pipes_struct *p,
9078                                        struct spoolss_EnumPrintProcDataTypes *r)
9079 {
9080         WERROR result;
9081
9082         /* that's an [in out] buffer */
9083
9084         if (!r->in.buffer && (r->in.offered != 0)) {
9085                 return WERR_INVALID_PARAM;
9086         }
9087
9088         DEBUG(5,("_spoolss_EnumPrintProcDataTypes\n"));
9089
9090         *r->out.count = 0;
9091         *r->out.needed = 0;
9092         *r->out.info = NULL;
9093
9094         if (r->in.print_processor_name == NULL ||
9095             !strequal(r->in.print_processor_name, "winprint")) {
9096                 return WERR_UNKNOWN_PRINTPROCESSOR;
9097         }
9098
9099         switch (r->in.level) {
9100         case 1:
9101                 result = enumprintprocdatatypes_level_1(p->mem_ctx, r->out.info,
9102                                                         r->out.count);
9103                 break;
9104         default:
9105                 return WERR_UNKNOWN_LEVEL;
9106         }
9107
9108         if (!W_ERROR_IS_OK(result)) {
9109                 return result;
9110         }
9111
9112         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
9113                                                      spoolss_EnumPrintProcDataTypes,
9114                                                      *r->out.info, r->in.level,
9115                                                      *r->out.count);
9116         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
9117         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
9118
9119         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
9120 }
9121
9122 /****************************************************************************
9123  fill_monitor_1
9124 ****************************************************************************/
9125
9126 static WERROR fill_monitor_1(TALLOC_CTX *mem_ctx,
9127                              struct spoolss_MonitorInfo1 *r,
9128                              const char *monitor_name)
9129 {
9130         r->monitor_name                 = talloc_strdup(mem_ctx, monitor_name);
9131         W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
9132
9133         return WERR_OK;
9134 }
9135
9136 /****************************************************************************
9137  fill_monitor_2
9138 ****************************************************************************/
9139
9140 static WERROR fill_monitor_2(TALLOC_CTX *mem_ctx,
9141                              struct spoolss_MonitorInfo2 *r,
9142                              const char *monitor_name,
9143                              const char *environment,
9144                              const char *dll_name)
9145 {
9146         r->monitor_name                 = talloc_strdup(mem_ctx, monitor_name);
9147         W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
9148         r->environment                  = talloc_strdup(mem_ctx, environment);
9149         W_ERROR_HAVE_NO_MEMORY(r->environment);
9150         r->dll_name                     = talloc_strdup(mem_ctx, dll_name);
9151         W_ERROR_HAVE_NO_MEMORY(r->dll_name);
9152
9153         return WERR_OK;
9154 }
9155
9156 /****************************************************************************
9157  enumprintmonitors level 1.
9158 ****************************************************************************/
9159
9160 static WERROR enumprintmonitors_level_1(TALLOC_CTX *mem_ctx,
9161                                         union spoolss_MonitorInfo **info_p,
9162                                         uint32_t *count)
9163 {
9164         union spoolss_MonitorInfo *info;
9165         WERROR result = WERR_OK;
9166
9167         info = talloc_array(mem_ctx, union spoolss_MonitorInfo, 2);
9168         W_ERROR_HAVE_NO_MEMORY(info);
9169
9170         *count = 2;
9171
9172         result = fill_monitor_1(info, &info[0].info1,
9173                                 SPL_LOCAL_PORT);
9174         if (!W_ERROR_IS_OK(result)) {
9175                 goto out;
9176         }
9177
9178         result = fill_monitor_1(info, &info[1].info1,
9179                                 SPL_TCPIP_PORT);
9180         if (!W_ERROR_IS_OK(result)) {
9181                 goto out;
9182         }
9183
9184 out:
9185         if (!W_ERROR_IS_OK(result)) {
9186                 TALLOC_FREE(info);
9187                 *count = 0;
9188                 return result;
9189         }
9190
9191         *info_p = info;
9192
9193         return WERR_OK;
9194 }
9195
9196 /****************************************************************************
9197  enumprintmonitors level 2.
9198 ****************************************************************************/
9199
9200 static WERROR enumprintmonitors_level_2(TALLOC_CTX *mem_ctx,
9201                                         union spoolss_MonitorInfo **info_p,
9202                                         uint32_t *count)
9203 {
9204         union spoolss_MonitorInfo *info;
9205         WERROR result = WERR_OK;
9206
9207         info = talloc_array(mem_ctx, union spoolss_MonitorInfo, 2);
9208         W_ERROR_HAVE_NO_MEMORY(info);
9209
9210         *count = 2;
9211
9212         result = fill_monitor_2(info, &info[0].info2,
9213                                 SPL_LOCAL_PORT,
9214                                 "Windows NT X86", /* FIXME */
9215                                 "localmon.dll");
9216         if (!W_ERROR_IS_OK(result)) {
9217                 goto out;
9218         }
9219
9220         result = fill_monitor_2(info, &info[1].info2,
9221                                 SPL_TCPIP_PORT,
9222                                 "Windows NT X86", /* FIXME */
9223                                 "tcpmon.dll");
9224         if (!W_ERROR_IS_OK(result)) {
9225                 goto out;
9226         }
9227
9228 out:
9229         if (!W_ERROR_IS_OK(result)) {
9230                 TALLOC_FREE(info);
9231                 *count = 0;
9232                 return result;
9233         }
9234
9235         *info_p = info;
9236
9237         return WERR_OK;
9238 }
9239
9240 /****************************************************************
9241  _spoolss_EnumMonitors
9242 ****************************************************************/
9243
9244 WERROR _spoolss_EnumMonitors(struct pipes_struct *p,
9245                              struct spoolss_EnumMonitors *r)
9246 {
9247         WERROR result;
9248
9249         /* that's an [in out] buffer */
9250
9251         if (!r->in.buffer && (r->in.offered != 0)) {
9252                 return WERR_INVALID_PARAM;
9253         }
9254
9255         DEBUG(5,("_spoolss_EnumMonitors\n"));
9256
9257         /*
9258          * Enumerate the print monitors ...
9259          *
9260          * Just reply with "Local Port", to keep NT happy
9261          * and I can use my nice printer checker.
9262          */
9263
9264         *r->out.count = 0;
9265         *r->out.needed = 0;
9266         *r->out.info = NULL;
9267
9268         switch (r->in.level) {
9269         case 1:
9270                 result = enumprintmonitors_level_1(p->mem_ctx, r->out.info,
9271                                                    r->out.count);
9272                 break;
9273         case 2:
9274                 result = enumprintmonitors_level_2(p->mem_ctx, r->out.info,
9275                                                    r->out.count);
9276                 break;
9277         default:
9278                 return WERR_UNKNOWN_LEVEL;
9279         }
9280
9281         if (!W_ERROR_IS_OK(result)) {
9282                 return result;
9283         }
9284
9285         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
9286                                                      spoolss_EnumMonitors,
9287                                                      *r->out.info, r->in.level,
9288                                                      *r->out.count);
9289         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
9290         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
9291
9292         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
9293 }
9294
9295 /****************************************************************************
9296 ****************************************************************************/
9297
9298 static WERROR getjob_level_1(TALLOC_CTX *mem_ctx,
9299                              const print_queue_struct *queue,
9300                              int count, int snum,
9301                              struct spoolss_PrinterInfo2 *pinfo2,
9302                              uint32_t jobid,
9303                              struct spoolss_JobInfo1 *r)
9304 {
9305         int i = 0;
9306         bool found = false;
9307
9308         for (i=0; i<count; i++) {
9309                 if (queue[i].sysjob == (int)jobid) {
9310                         found = true;
9311                         break;
9312                 }
9313         }
9314
9315         if (found == false) {
9316                 /* NT treats not found as bad param... yet another bad choice */
9317                 return WERR_INVALID_PARAM;
9318         }
9319
9320         return fill_job_info1(mem_ctx,
9321                               r,
9322                               &queue[i],
9323                               i,
9324                               snum,
9325                               pinfo2);
9326 }
9327
9328 /****************************************************************************
9329 ****************************************************************************/
9330
9331 static WERROR getjob_level_2(TALLOC_CTX *mem_ctx,
9332                              const print_queue_struct *queue,
9333                              int count, int snum,
9334                              struct spoolss_PrinterInfo2 *pinfo2,
9335                              uint32_t jobid,
9336                              struct spoolss_JobInfo2 *r)
9337 {
9338         int i = 0;
9339         bool found = false;
9340         struct spoolss_DeviceMode *devmode;
9341         WERROR result;
9342
9343         for (i=0; i<count; i++) {
9344                 if (queue[i].sysjob == (int)jobid) {
9345                         found = true;
9346                         break;
9347                 }
9348         }
9349
9350         if (found == false) {
9351                 /* NT treats not found as bad param... yet another bad
9352                    choice */
9353                 return WERR_INVALID_PARAM;
9354         }
9355
9356         /*
9357          * if the print job does not have a DEVMODE associated with it,
9358          * just use the one for the printer. A NULL devicemode is not
9359          *  a failure condition
9360          */
9361
9362         devmode = print_job_devmode(mem_ctx, lp_const_servicename(snum), jobid);
9363         if (!devmode) {
9364                 result = spoolss_create_default_devmode(mem_ctx,
9365                                                 pinfo2->printername,
9366                                                 &devmode);
9367                 if (!W_ERROR_IS_OK(result)) {
9368                         DEBUG(3, ("Can't proceed w/o a devmode!"));
9369                         return result;
9370                 }
9371         }
9372
9373         return fill_job_info2(mem_ctx,
9374                               r,
9375                               &queue[i],
9376                               i,
9377                               snum,
9378                               pinfo2,
9379                               devmode);
9380 }
9381
9382 /****************************************************************
9383  _spoolss_GetJob
9384 ****************************************************************/
9385
9386 WERROR _spoolss_GetJob(struct pipes_struct *p,
9387                        struct spoolss_GetJob *r)
9388 {
9389         WERROR result = WERR_OK;
9390         struct spoolss_PrinterInfo2 *pinfo2 = NULL;
9391         int snum;
9392         int count;
9393         print_queue_struct      *queue = NULL;
9394         print_status_struct prt_status;
9395
9396         /* that's an [in out] buffer */
9397
9398         if (!r->in.buffer && (r->in.offered != 0)) {
9399                 return WERR_INVALID_PARAM;
9400         }
9401
9402         DEBUG(5,("_spoolss_GetJob\n"));
9403
9404         *r->out.needed = 0;
9405
9406         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9407                 return WERR_BADFID;
9408         }
9409
9410         result = winreg_get_printer_internal(p->mem_ctx,
9411                                     get_session_info_system(),
9412                                     p->msg_ctx,
9413                                     lp_const_servicename(snum),
9414                                     &pinfo2);
9415         if (!W_ERROR_IS_OK(result)) {
9416                 return result;
9417         }
9418
9419         count = print_queue_status(p->msg_ctx, snum, &queue, &prt_status);
9420
9421         DEBUGADD(4,("count:[%d], prt_status:[%d], [%s]\n",
9422                      count, prt_status.status, prt_status.message));
9423
9424         switch (r->in.level) {
9425         case 1:
9426                 result = getjob_level_1(p->mem_ctx,
9427                                         queue, count, snum, pinfo2,
9428                                         r->in.job_id, &r->out.info->info1);
9429                 break;
9430         case 2:
9431                 result = getjob_level_2(p->mem_ctx,
9432                                         queue, count, snum, pinfo2,
9433                                         r->in.job_id, &r->out.info->info2);
9434                 break;
9435         default:
9436                 result = WERR_UNKNOWN_LEVEL;
9437                 break;
9438         }
9439
9440         SAFE_FREE(queue);
9441         TALLOC_FREE(pinfo2);
9442
9443         if (!W_ERROR_IS_OK(result)) {
9444                 TALLOC_FREE(r->out.info);
9445                 return result;
9446         }
9447
9448         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_JobInfo, r->out.info,
9449                                                                                    r->in.level);
9450         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
9451
9452         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
9453 }
9454
9455 /****************************************************************
9456  _spoolss_GetPrinterDataEx
9457 ****************************************************************/
9458
9459 WERROR _spoolss_GetPrinterDataEx(struct pipes_struct *p,
9460                                  struct spoolss_GetPrinterDataEx *r)
9461 {
9462
9463         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
9464         const char *printer;
9465         int                     snum = 0;
9466         WERROR result = WERR_OK;
9467         DATA_BLOB blob;
9468         enum winreg_Type val_type = REG_NONE;
9469         uint8_t *val_data = NULL;
9470         uint32_t val_size = 0;
9471         struct dcerpc_binding_handle *b;
9472         TALLOC_CTX *tmp_ctx;
9473
9474         DEBUG(4,("_spoolss_GetPrinterDataEx\n"));
9475
9476         DEBUG(10, ("_spoolss_GetPrinterDataEx: key => [%s], value => [%s]\n",
9477                 r->in.key_name, r->in.value_name));
9478
9479         /* in case of problem, return some default values */
9480
9481         *r->out.needed  = 0;
9482         *r->out.type    = REG_NONE;
9483
9484         tmp_ctx = talloc_new(p->mem_ctx);
9485         if (!tmp_ctx) {
9486                 return WERR_NOMEM;
9487         }
9488
9489         if (!Printer) {
9490                 DEBUG(2,("_spoolss_GetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
9491                         OUR_HANDLE(r->in.handle)));
9492                 result = WERR_BADFID;
9493                 goto done;
9494         }
9495
9496         /* check to see if the keyname is valid */
9497         if (!strlen(r->in.key_name)) {
9498                 result = WERR_INVALID_PARAM;
9499                 goto done;
9500         }
9501
9502         /* Is the handle to a printer or to the server? */
9503
9504         if (Printer->printer_type == SPLHND_SERVER) {
9505
9506                 union spoolss_PrinterData data;
9507
9508                 result = getprinterdata_printer_server(tmp_ctx,
9509                                                        r->in.value_name,
9510                                                        r->out.type,
9511                                                        &data);
9512                 if (!W_ERROR_IS_OK(result)) {
9513                         goto done;
9514                 }
9515
9516                 result = push_spoolss_PrinterData(tmp_ctx, &blob,
9517                                                   *r->out.type, &data);
9518                 if (!W_ERROR_IS_OK(result)) {
9519                         goto done;
9520                 }
9521
9522                 *r->out.needed = blob.length;
9523
9524                 if (r->in.offered >= *r->out.needed) {
9525                         memcpy(r->out.data, blob.data, blob.length);
9526                 }
9527
9528                 result = WERR_OK;
9529                 goto done;
9530         }
9531
9532         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9533                 result = WERR_BADFID;
9534                 goto done;
9535         }
9536         printer = lp_const_servicename(snum);
9537
9538         result = winreg_printer_binding_handle(tmp_ctx,
9539                                                get_session_info_system(),
9540                                                p->msg_ctx,
9541                                                &b);
9542         if (!W_ERROR_IS_OK(result)) {
9543                 goto done;
9544         }
9545
9546         /* XP sends this and wants the ChangeID value from PRINTER_INFO_0 */
9547         if (strequal(r->in.key_name, SPOOL_PRINTERDATA_KEY) &&
9548             strequal(r->in.value_name, "ChangeId")) {
9549                 *r->out.type = REG_DWORD;
9550                 *r->out.needed = 4;
9551                 if (r->in.offered >= *r->out.needed) {
9552                         uint32_t changeid = 0;
9553
9554                         result = winreg_printer_get_changeid(tmp_ctx, b,
9555                                                              printer,
9556                                                              &changeid);
9557                         if (!W_ERROR_IS_OK(result)) {
9558                                 goto done;
9559                         }
9560
9561                         SIVAL(r->out.data, 0, changeid);
9562                         result = WERR_OK;
9563                 }
9564                 goto done;
9565         }
9566
9567         result = winreg_get_printer_dataex(tmp_ctx, b,
9568                                            printer,
9569                                            r->in.key_name,
9570                                            r->in.value_name,
9571                                            &val_type,
9572                                            &val_data,
9573                                            &val_size);
9574         if (!W_ERROR_IS_OK(result)) {
9575                 goto done;
9576         }
9577
9578         *r->out.needed = val_size;
9579         *r->out.type = val_type;
9580
9581         if (r->in.offered >= *r->out.needed) {
9582                 memcpy(r->out.data, val_data, val_size);
9583         }
9584
9585 done:
9586         /* NOTE: do not replace type when returning WERR_MORE_DATA */
9587
9588         if (W_ERROR_IS_OK(result)) {
9589                 result = SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
9590         }
9591
9592         talloc_free(tmp_ctx);
9593         return result;
9594 }
9595
9596 /****************************************************************
9597  _spoolss_SetPrinterDataEx
9598 ****************************************************************/
9599
9600 WERROR _spoolss_SetPrinterDataEx(struct pipes_struct *p,
9601                                  struct spoolss_SetPrinterDataEx *r)
9602 {
9603         struct spoolss_PrinterInfo2 *pinfo2 = NULL;
9604         int                     snum = 0;
9605         WERROR                  result = WERR_OK;
9606         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
9607         char                    *oid_string;
9608         struct dcerpc_binding_handle *b;
9609         TALLOC_CTX *tmp_ctx;
9610
9611         DEBUG(4,("_spoolss_SetPrinterDataEx\n"));
9612
9613         /* From MSDN documentation of SetPrinterDataEx: pass request to
9614            SetPrinterData if key is "PrinterDriverData" */
9615
9616         if (!Printer) {
9617                 DEBUG(2,("_spoolss_SetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
9618                         OUR_HANDLE(r->in.handle)));
9619                 return WERR_BADFID;
9620         }
9621
9622         if (Printer->printer_type == SPLHND_SERVER) {
9623                 DEBUG(10,("_spoolss_SetPrinterDataEx: "
9624                         "Not implemented for server handles yet\n"));
9625                 return WERR_INVALID_PARAM;
9626         }
9627
9628         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9629                 return WERR_BADFID;
9630         }
9631
9632         /*
9633          * Access check : NT returns "access denied" if you make a
9634          * SetPrinterData call without the necessary privildge.
9635          * we were originally returning OK if nothing changed
9636          * which made Win2k issue **a lot** of SetPrinterData
9637          * when connecting to a printer  --jerry
9638          */
9639
9640         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9641                 DEBUG(3, ("_spoolss_SetPrinterDataEx: "
9642                         "change denied by handle access permissions\n"));
9643                 return WERR_ACCESS_DENIED;
9644         }
9645
9646         tmp_ctx = talloc_new(p->mem_ctx);
9647         if (!tmp_ctx) {
9648                 return WERR_NOMEM;
9649         }
9650
9651         result = winreg_printer_binding_handle(tmp_ctx,
9652                                                get_session_info_system(),
9653                                                p->msg_ctx,
9654                                                &b);
9655         if (!W_ERROR_IS_OK(result)) {
9656                 goto done;
9657         }
9658
9659         result = winreg_get_printer(tmp_ctx, b,
9660                                     lp_servicename(talloc_tos(), snum),
9661                                     &pinfo2);
9662         if (!W_ERROR_IS_OK(result)) {
9663                 goto done;
9664         }
9665
9666         /* check for OID in valuename */
9667
9668         oid_string = strchr(r->in.value_name, ',');
9669         if (oid_string) {
9670                 *oid_string = '\0';
9671                 oid_string++;
9672         }
9673
9674         /* save the registry data */
9675
9676         result = winreg_set_printer_dataex(tmp_ctx, b,
9677                                            pinfo2->sharename,
9678                                            r->in.key_name,
9679                                            r->in.value_name,
9680                                            r->in.type,
9681                                            r->in.data,
9682                                            r->in.offered);
9683
9684         if (W_ERROR_IS_OK(result)) {
9685                 /* save the OID if one was specified */
9686                 if (oid_string) {
9687                         char *str = talloc_asprintf(tmp_ctx, "%s\\%s",
9688                                 r->in.key_name, SPOOL_OID_KEY);
9689                         if (!str) {
9690                                 result = WERR_NOMEM;
9691                                 goto done;
9692                         }
9693
9694                         /*
9695                          * I'm not checking the status here on purpose.  Don't know
9696                          * if this is right, but I'm returning the status from the
9697                          * previous set_printer_dataex() call.  I have no idea if
9698                          * this is right.    --jerry
9699                          */
9700                         winreg_set_printer_dataex(tmp_ctx, b,
9701                                                   pinfo2->sharename,
9702                                                   str,
9703                                                   r->in.value_name,
9704                                                   REG_SZ,
9705                                                   (uint8_t *) oid_string,
9706                                                   strlen(oid_string) + 1);
9707                 }
9708
9709                 result = winreg_printer_update_changeid(tmp_ctx, b,
9710                                                         lp_const_servicename(snum));
9711
9712         }
9713
9714 done:
9715         talloc_free(tmp_ctx);
9716         return result;
9717 }
9718
9719 /****************************************************************
9720  _spoolss_DeletePrinterDataEx
9721 ****************************************************************/
9722
9723 WERROR _spoolss_DeletePrinterDataEx(struct pipes_struct *p,
9724                                     struct spoolss_DeletePrinterDataEx *r)
9725 {
9726         const char *printer;
9727         int             snum=0;
9728         WERROR          status = WERR_OK;
9729         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
9730
9731         DEBUG(5,("_spoolss_DeletePrinterDataEx\n"));
9732
9733         if (!Printer) {
9734                 DEBUG(2,("_spoolss_DeletePrinterDataEx: "
9735                         "Invalid handle (%s:%u:%u).\n",
9736                         OUR_HANDLE(r->in.handle)));
9737                 return WERR_BADFID;
9738         }
9739
9740         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9741                 DEBUG(3, ("_spoolss_DeletePrinterDataEx: "
9742                         "printer properties change denied by handle\n"));
9743                 return WERR_ACCESS_DENIED;
9744         }
9745
9746         if (!r->in.value_name || !r->in.key_name) {
9747                 return WERR_NOMEM;
9748         }
9749
9750         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9751                 return WERR_BADFID;
9752         }
9753         printer = lp_const_servicename(snum);
9754
9755         status = winreg_delete_printer_dataex_internal(p->mem_ctx,
9756                                               get_session_info_system(),
9757                                               p->msg_ctx,
9758                                               printer,
9759                                               r->in.key_name,
9760                                               r->in.value_name);
9761         if (W_ERROR_IS_OK(status)) {
9762                 status = winreg_printer_update_changeid_internal(p->mem_ctx,
9763                                                         get_session_info_system(),
9764                                                         p->msg_ctx,
9765                                                         printer);
9766         }
9767
9768         return status;
9769 }
9770
9771 /****************************************************************
9772  _spoolss_EnumPrinterKey
9773 ****************************************************************/
9774
9775 WERROR _spoolss_EnumPrinterKey(struct pipes_struct *p,
9776                                struct spoolss_EnumPrinterKey *r)
9777 {
9778         uint32_t        num_keys;
9779         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
9780         int             snum = 0;
9781         WERROR          result = WERR_BADFILE;
9782         const char **array = NULL;
9783         DATA_BLOB blob;
9784
9785         DEBUG(4,("_spoolss_EnumPrinterKey\n"));
9786
9787         if (!Printer) {
9788                 DEBUG(2,("_spoolss_EnumPrinterKey: Invalid handle (%s:%u:%u).\n",
9789                         OUR_HANDLE(r->in.handle)));
9790                 return WERR_BADFID;
9791         }
9792
9793         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9794                 return WERR_BADFID;
9795         }
9796
9797         result = winreg_enum_printer_key_internal(p->mem_ctx,
9798                                          get_session_info_system(),
9799                                          p->msg_ctx,
9800                                          lp_const_servicename(snum),
9801                                          r->in.key_name,
9802                                          &num_keys,
9803                                          &array);
9804         if (!W_ERROR_IS_OK(result)) {
9805                 goto done;
9806         }
9807
9808         if (!push_reg_multi_sz(p->mem_ctx, &blob, array)) {
9809                 result = WERR_NOMEM;
9810                 goto done;
9811         }
9812
9813         *r->out._ndr_size = r->in.offered / 2;
9814         *r->out.needed = blob.length;
9815
9816         if (r->in.offered < *r->out.needed) {
9817                 result = WERR_MORE_DATA;
9818         } else {
9819                 result = WERR_OK;
9820                 r->out.key_buffer->string_array = array;
9821         }
9822
9823  done:
9824         if (!W_ERROR_IS_OK(result)) {
9825                 TALLOC_FREE(array);
9826                 if (!W_ERROR_EQUAL(result, WERR_MORE_DATA)) {
9827                         *r->out.needed = 0;
9828                 }
9829         }
9830
9831         return result;
9832 }
9833
9834 /****************************************************************
9835  _spoolss_DeletePrinterKey
9836 ****************************************************************/
9837
9838 WERROR _spoolss_DeletePrinterKey(struct pipes_struct *p,
9839                                  struct spoolss_DeletePrinterKey *r)
9840 {
9841         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
9842         int                     snum=0;
9843         WERROR                  status;
9844         const char *printer;
9845         struct dcerpc_binding_handle *b;
9846         TALLOC_CTX *tmp_ctx;
9847
9848         DEBUG(5,("_spoolss_DeletePrinterKey\n"));
9849
9850         if (!Printer) {
9851                 DEBUG(2,("_spoolss_DeletePrinterKey: Invalid handle (%s:%u:%u).\n",
9852                         OUR_HANDLE(r->in.handle)));
9853                 return WERR_BADFID;
9854         }
9855
9856         /* if keyname == NULL, return error */
9857         if ( !r->in.key_name )
9858                 return WERR_INVALID_PARAM;
9859
9860         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9861                 return WERR_BADFID;
9862         }
9863
9864         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9865                 DEBUG(3, ("_spoolss_DeletePrinterKey: "
9866                         "printer properties change denied by handle\n"));
9867                 return WERR_ACCESS_DENIED;
9868         }
9869
9870         printer = lp_const_servicename(snum);
9871
9872         tmp_ctx = talloc_new(p->mem_ctx);
9873         if (!tmp_ctx) {
9874                 return WERR_NOMEM;
9875         }
9876
9877         status = winreg_printer_binding_handle(tmp_ctx,
9878                                                get_session_info_system(),
9879                                                p->msg_ctx,
9880                                                &b);
9881         if (!W_ERROR_IS_OK(status)) {
9882                 goto done;
9883         }
9884
9885         /* delete the key and all subkeys */
9886         status = winreg_delete_printer_key(tmp_ctx, b,
9887                                            printer,
9888                                            r->in.key_name);
9889         if (W_ERROR_IS_OK(status)) {
9890                 status = winreg_printer_update_changeid(tmp_ctx, b,
9891                                                         printer);
9892         }
9893
9894 done:
9895         talloc_free(tmp_ctx);
9896         return status;
9897 }
9898
9899 /****************************************************************
9900  _spoolss_EnumPrinterDataEx
9901 ****************************************************************/
9902
9903 WERROR _spoolss_EnumPrinterDataEx(struct pipes_struct *p,
9904                                   struct spoolss_EnumPrinterDataEx *r)
9905 {
9906         uint32_t        count = 0;
9907         struct spoolss_PrinterEnumValues *info = NULL;
9908         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
9909         int             snum;
9910         WERROR          result;
9911
9912         DEBUG(4,("_spoolss_EnumPrinterDataEx\n"));
9913
9914         *r->out.count = 0;
9915         *r->out.needed = 0;
9916         *r->out.info = NULL;
9917
9918         if (!Printer) {
9919                 DEBUG(2,("_spoolss_EnumPrinterDataEx: Invalid handle (%s:%u:%u1<).\n",
9920                         OUR_HANDLE(r->in.handle)));
9921                 return WERR_BADFID;
9922         }
9923
9924         /*
9925          * first check for a keyname of NULL or "".  Win2k seems to send
9926          * this a lot and we should send back WERR_INVALID_PARAM
9927          * no need to spend time looking up the printer in this case.
9928          * --jerry
9929          */
9930
9931         if (!strlen(r->in.key_name)) {
9932                 result = WERR_INVALID_PARAM;
9933                 goto done;
9934         }
9935
9936         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9937                 return WERR_BADFID;
9938         }
9939
9940         /* now look for a match on the key name */
9941         result = winreg_enum_printer_dataex_internal(p->mem_ctx,
9942                                             get_session_info_system(),
9943                                             p->msg_ctx,
9944                                             lp_const_servicename(snum),
9945                                             r->in.key_name,
9946                                             &count,
9947                                             &info);
9948         if (!W_ERROR_IS_OK(result)) {
9949                 goto done;
9950         }
9951
9952 #if 0 /* FIXME - gd */
9953         /* housekeeping information in the reply */
9954
9955         /* Fix from Martin Zielinski <mz@seh.de> - ensure
9956          * the hand marshalled container size is a multiple
9957          * of 4 bytes for RPC alignment.
9958          */
9959
9960         if (needed % 4) {
9961                 needed += 4-(needed % 4);
9962         }
9963 #endif
9964         *r->out.count   = count;
9965         *r->out.info    = info;
9966
9967  done:
9968         if (!W_ERROR_IS_OK(result)) {
9969                 return result;
9970         }
9971
9972         *r->out.needed  = SPOOLSS_BUFFER_ARRAY(p->mem_ctx,
9973                                                spoolss_EnumPrinterDataEx,
9974                                                *r->out.info,
9975                                                *r->out.count);
9976         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
9977         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, *r->out.count);
9978
9979         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
9980 }
9981
9982 /****************************************************************************
9983 ****************************************************************************/
9984
9985 static WERROR getprintprocessordirectory_level_1(TALLOC_CTX *mem_ctx,
9986                                                  const char *servername,
9987                                                  const char *environment,
9988                                                  struct spoolss_PrintProcessorDirectoryInfo1 *r)
9989 {
9990         WERROR werr;
9991         char *path = NULL;
9992
9993         werr = compose_spoolss_server_path(mem_ctx,
9994                                            servername,
9995                                            environment,
9996                                            SPOOLSS_PRTPROCS_PATH,
9997                                            &path);
9998         if (!W_ERROR_IS_OK(werr)) {
9999                 return werr;
10000         }
10001
10002         DEBUG(4,("print processor directory: [%s]\n", path));
10003
10004         r->directory_name = path;
10005
10006         return WERR_OK;
10007 }
10008
10009 /****************************************************************
10010  _spoolss_GetPrintProcessorDirectory
10011 ****************************************************************/
10012
10013 WERROR _spoolss_GetPrintProcessorDirectory(struct pipes_struct *p,
10014                                            struct spoolss_GetPrintProcessorDirectory *r)
10015 {
10016         WERROR result;
10017         char *prnproc_share = NULL;
10018         bool prnproc_share_exists = false;
10019         int snum;
10020
10021         /* that's an [in out] buffer */
10022
10023         if (!r->in.buffer && (r->in.offered != 0)) {
10024                 return WERR_INVALID_PARAM;
10025         }
10026
10027         DEBUG(5,("_spoolss_GetPrintProcessorDirectory: level %d\n",
10028                 r->in.level));
10029
10030         *r->out.needed = 0;
10031
10032         /* r->in.level is ignored */
10033
10034         /* We always should reply with a local print processor directory so that
10035          * users are not forced to have a [prnproc$] share on the Samba spoolss
10036          * server, if users decide to do so, lets announce it though - Guenther */
10037
10038         snum = find_service(talloc_tos(), "prnproc$", &prnproc_share);
10039         if (!prnproc_share) {
10040                 return WERR_NOMEM;
10041         }
10042         if (snum != -1) {
10043                 prnproc_share_exists = true;
10044         }
10045
10046         result = getprintprocessordirectory_level_1(p->mem_ctx,
10047                                                     prnproc_share_exists ? r->in.server : NULL,
10048                                                     r->in.environment,
10049                                                     &r->out.info->info1);
10050         if (!W_ERROR_IS_OK(result)) {
10051                 TALLOC_FREE(r->out.info);
10052                 return result;
10053         }
10054
10055         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_PrintProcessorDirectoryInfo,
10056                                                                                    r->out.info, r->in.level);
10057         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
10058
10059         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
10060 }
10061
10062 /*******************************************************************
10063  ********************************************************************/
10064
10065 static bool push_monitorui_buf(TALLOC_CTX *mem_ctx, DATA_BLOB *buf,
10066                                const char *dllname)
10067 {
10068         enum ndr_err_code ndr_err;
10069         struct spoolss_MonitorUi ui;
10070
10071         ui.dll_name = dllname;
10072
10073         ndr_err = ndr_push_struct_blob(buf, mem_ctx, &ui,
10074                        (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorUi);
10075         if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
10076                 NDR_PRINT_DEBUG(spoolss_MonitorUi, &ui);
10077         }
10078         return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
10079 }
10080
10081 /*******************************************************************
10082  Streams the monitor UI DLL name in UNICODE
10083 *******************************************************************/
10084
10085 static WERROR xcvtcp_monitorui(TALLOC_CTX *mem_ctx,
10086                                struct security_token *token, DATA_BLOB *in,
10087                                DATA_BLOB *out, uint32_t *needed)
10088 {
10089         const char *dllname = "tcpmonui.dll";
10090
10091         *needed = (strlen(dllname)+1) * 2;
10092
10093         if (out->length < *needed) {
10094                 return WERR_INSUFFICIENT_BUFFER;
10095         }
10096
10097         if (!push_monitorui_buf(mem_ctx, out, dllname)) {
10098                 return WERR_NOMEM;
10099         }
10100
10101         return WERR_OK;
10102 }
10103
10104 /*******************************************************************
10105  ********************************************************************/
10106
10107 static bool pull_port_data_1(TALLOC_CTX *mem_ctx,
10108                              struct spoolss_PortData1 *port1,
10109                              const DATA_BLOB *buf)
10110 {
10111         enum ndr_err_code ndr_err;
10112         ndr_err = ndr_pull_struct_blob(buf, mem_ctx, port1,
10113                        (ndr_pull_flags_fn_t)ndr_pull_spoolss_PortData1);
10114         if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
10115                 NDR_PRINT_DEBUG(spoolss_PortData1, port1);
10116         }
10117         return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
10118 }
10119
10120 /*******************************************************************
10121  ********************************************************************/
10122
10123 static bool pull_port_data_2(TALLOC_CTX *mem_ctx,
10124                              struct spoolss_PortData2 *port2,
10125                              const DATA_BLOB *buf)
10126 {
10127         enum ndr_err_code ndr_err;
10128         ndr_err = ndr_pull_struct_blob(buf, mem_ctx, port2,
10129                        (ndr_pull_flags_fn_t)ndr_pull_spoolss_PortData2);
10130         if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
10131                 NDR_PRINT_DEBUG(spoolss_PortData2, port2);
10132         }
10133         return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
10134 }
10135
10136 /*******************************************************************
10137  Create a new TCP/IP port
10138 *******************************************************************/
10139
10140 static WERROR xcvtcp_addport(TALLOC_CTX *mem_ctx,
10141                              struct security_token *token, DATA_BLOB *in,
10142                              DATA_BLOB *out, uint32_t *needed)
10143 {
10144         struct spoolss_PortData1 port1;
10145         struct spoolss_PortData2 port2;
10146         char *device_uri = NULL;
10147         uint32_t version;
10148
10149         const char *portname;
10150         const char *hostaddress;
10151         const char *queue;
10152         uint32_t port_number;
10153         uint32_t protocol;
10154
10155         /* peek for spoolss_PortData version */
10156
10157         if (!in || (in->length < (128 + 4))) {
10158                 return WERR_GENERAL_FAILURE;
10159         }
10160
10161         version = IVAL(in->data, 128);
10162
10163         switch (version) {
10164                 case 1:
10165                         ZERO_STRUCT(port1);
10166
10167                         if (!pull_port_data_1(mem_ctx, &port1, in)) {
10168                                 return WERR_NOMEM;
10169                         }
10170
10171                         portname        = port1.portname;
10172                         hostaddress     = port1.hostaddress;
10173                         queue           = port1.queue;
10174                         protocol        = port1.protocol;
10175                         port_number     = port1.port_number;
10176
10177                         break;
10178                 case 2:
10179                         ZERO_STRUCT(port2);
10180
10181                         if (!pull_port_data_2(mem_ctx, &port2, in)) {
10182                                 return WERR_NOMEM;
10183                         }
10184
10185                         portname        = port2.portname;
10186                         hostaddress     = port2.hostaddress;
10187                         queue           = port2.queue;
10188                         protocol        = port2.protocol;
10189                         port_number     = port2.port_number;
10190
10191                         break;
10192                 default:
10193                         DEBUG(1,("xcvtcp_addport: "
10194                                 "unknown version of port_data: %d\n", version));
10195                         return WERR_UNKNOWN_PORT;
10196         }
10197
10198         /* create the device URI and call the add_port_hook() */
10199
10200         switch (protocol) {
10201         case PROTOCOL_RAWTCP_TYPE:
10202                 device_uri = talloc_asprintf(mem_ctx,
10203                                 "socket://%s:%d/", hostaddress,
10204                                 port_number);
10205                 break;
10206
10207         case PROTOCOL_LPR_TYPE:
10208                 device_uri = talloc_asprintf(mem_ctx,
10209                         "lpr://%s/%s", hostaddress, queue );
10210                 break;
10211
10212         default:
10213                 return WERR_UNKNOWN_PORT;
10214         }
10215
10216         if (!device_uri) {
10217                 return WERR_NOMEM;
10218         }
10219
10220         return add_port_hook(mem_ctx, token, portname, device_uri);
10221 }
10222
10223 /*******************************************************************
10224 *******************************************************************/
10225
10226 struct xcv_api_table xcvtcp_cmds[] = {
10227         { "MonitorUI",  xcvtcp_monitorui },
10228         { "AddPort",    xcvtcp_addport},
10229         { NULL,         NULL }
10230 };
10231
10232 static WERROR process_xcvtcp_command(TALLOC_CTX *mem_ctx,
10233                                      struct security_token *token, const char *command,
10234                                      DATA_BLOB *inbuf,
10235                                      DATA_BLOB *outbuf,
10236                                      uint32_t *needed )
10237 {
10238         int i;
10239
10240         DEBUG(10,("process_xcvtcp_command: Received command \"%s\"\n", command));
10241
10242         for ( i=0; xcvtcp_cmds[i].name; i++ ) {
10243                 if ( strcmp( command, xcvtcp_cmds[i].name ) == 0 )
10244                         return xcvtcp_cmds[i].fn(mem_ctx, token, inbuf, outbuf, needed);
10245         }
10246
10247         return WERR_BADFUNC;
10248 }
10249
10250 /*******************************************************************
10251 *******************************************************************/
10252 #if 0   /* don't support management using the "Local Port" monitor */
10253
10254 static WERROR xcvlocal_monitorui(TALLOC_CTX *mem_ctx,
10255                                  struct security_token *token, DATA_BLOB *in,
10256                                  DATA_BLOB *out, uint32_t *needed)
10257 {
10258         const char *dllname = "localui.dll";
10259
10260         *needed = (strlen(dllname)+1) * 2;
10261
10262         if (out->length < *needed) {
10263                 return WERR_INSUFFICIENT_BUFFER;
10264         }
10265
10266         if (!push_monitorui_buf(mem_ctx, out, dllname)) {
10267                 return WERR_NOMEM;
10268         }
10269
10270         return WERR_OK;
10271 }
10272
10273 /*******************************************************************
10274 *******************************************************************/
10275
10276 struct xcv_api_table xcvlocal_cmds[] = {
10277         { "MonitorUI",  xcvlocal_monitorui },
10278         { NULL,         NULL }
10279 };
10280 #else
10281 struct xcv_api_table xcvlocal_cmds[] = {
10282         { NULL,         NULL }
10283 };
10284 #endif
10285
10286
10287
10288 /*******************************************************************
10289 *******************************************************************/
10290
10291 static WERROR process_xcvlocal_command(TALLOC_CTX *mem_ctx,
10292                                        struct security_token *token, const char *command,
10293                                        DATA_BLOB *inbuf, DATA_BLOB *outbuf,
10294                                        uint32_t *needed)
10295 {
10296         int i;
10297
10298         DEBUG(10,("process_xcvlocal_command: Received command \"%s\"\n", command));
10299
10300         for ( i=0; xcvlocal_cmds[i].name; i++ ) {
10301                 if ( strcmp( command, xcvlocal_cmds[i].name ) == 0 )
10302                         return xcvlocal_cmds[i].fn(mem_ctx, token, inbuf, outbuf, needed);
10303         }
10304         return WERR_BADFUNC;
10305 }
10306
10307 /****************************************************************
10308  _spoolss_XcvData
10309 ****************************************************************/
10310
10311 WERROR _spoolss_XcvData(struct pipes_struct *p,
10312                         struct spoolss_XcvData *r)
10313 {
10314         struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
10315         DATA_BLOB out_data = data_blob_null;
10316         WERROR werror;
10317
10318         if (!Printer) {
10319                 DEBUG(2,("_spoolss_XcvData: Invalid handle (%s:%u:%u).\n",
10320                         OUR_HANDLE(r->in.handle)));
10321                 return WERR_BADFID;
10322         }
10323
10324         /* Has to be a handle to the TCP/IP port monitor */
10325
10326         if ( !(Printer->printer_type & (SPLHND_PORTMON_LOCAL|SPLHND_PORTMON_TCP)) ) {
10327                 DEBUG(2,("_spoolss_XcvData: Call only valid for Port Monitors\n"));
10328                 return WERR_BADFID;
10329         }
10330
10331         /* requires administrative access to the server */
10332
10333         if ( !(Printer->access_granted & SERVER_ACCESS_ADMINISTER) ) {
10334                 DEBUG(2,("_spoolss_XcvData: denied by handle permissions.\n"));
10335                 return WERR_ACCESS_DENIED;
10336         }
10337
10338         /* Allocate the outgoing buffer */
10339
10340         if (r->in.out_data_size) {
10341                 out_data = data_blob_talloc_zero(p->mem_ctx, r->in.out_data_size);
10342                 if (out_data.data == NULL) {
10343                         return WERR_NOMEM;
10344                 }
10345         }
10346
10347         switch ( Printer->printer_type ) {
10348         case SPLHND_PORTMON_TCP:
10349                 werror = process_xcvtcp_command(p->mem_ctx,
10350                                                 p->session_info->security_token,
10351                                                 r->in.function_name,
10352                                                 &r->in.in_data, &out_data,
10353                                                 r->out.needed);
10354                 break;
10355         case SPLHND_PORTMON_LOCAL:
10356                 werror = process_xcvlocal_command(p->mem_ctx,
10357                                                   p->session_info->security_token,
10358                                                   r->in.function_name,
10359                                                   &r->in.in_data, &out_data,
10360                                                   r->out.needed);
10361                 break;
10362         default:
10363                 werror = WERR_INVALID_PRINT_MONITOR;
10364         }
10365
10366         if (!W_ERROR_IS_OK(werror)) {
10367                 return werror;
10368         }
10369
10370         *r->out.status_code = 0;
10371
10372         if (r->out.out_data && out_data.data && r->in.out_data_size && out_data.length) {
10373                 memcpy(r->out.out_data, out_data.data,
10374                         MIN(r->in.out_data_size, out_data.length));
10375         }
10376
10377         return WERR_OK;
10378 }
10379
10380 /****************************************************************
10381  _spoolss_AddPrintProcessor
10382 ****************************************************************/
10383
10384 WERROR _spoolss_AddPrintProcessor(struct pipes_struct *p,
10385                                   struct spoolss_AddPrintProcessor *r)
10386 {
10387         /* for now, just indicate success and ignore the add.  We'll
10388            automatically set the winprint processor for printer
10389            entries later.  Used to debug the LexMark Optra S 1855 PCL
10390            driver --jerry */
10391
10392         return WERR_OK;
10393 }
10394
10395 /****************************************************************
10396  _spoolss_AddPort
10397 ****************************************************************/
10398
10399 WERROR _spoolss_AddPort(struct pipes_struct *p,
10400                         struct spoolss_AddPort *r)
10401 {
10402         /* do what w2k3 does */
10403
10404         return WERR_NOT_SUPPORTED;
10405 }
10406
10407 /****************************************************************
10408  _spoolss_GetPrinterDriver
10409 ****************************************************************/
10410
10411 WERROR _spoolss_GetPrinterDriver(struct pipes_struct *p,
10412                                  struct spoolss_GetPrinterDriver *r)
10413 {
10414         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10415         return WERR_NOT_SUPPORTED;
10416 }
10417
10418 /****************************************************************
10419  _spoolss_ReadPrinter
10420 ****************************************************************/
10421
10422 WERROR _spoolss_ReadPrinter(struct pipes_struct *p,
10423                             struct spoolss_ReadPrinter *r)
10424 {
10425         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10426         return WERR_NOT_SUPPORTED;
10427 }
10428
10429 /****************************************************************
10430  _spoolss_WaitForPrinterChange
10431 ****************************************************************/
10432
10433 WERROR _spoolss_WaitForPrinterChange(struct pipes_struct *p,
10434                                      struct spoolss_WaitForPrinterChange *r)
10435 {
10436         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10437         return WERR_NOT_SUPPORTED;
10438 }
10439
10440 /****************************************************************
10441  _spoolss_ConfigurePort
10442 ****************************************************************/
10443
10444 WERROR _spoolss_ConfigurePort(struct pipes_struct *p,
10445                               struct spoolss_ConfigurePort *r)
10446 {
10447         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10448         return WERR_NOT_SUPPORTED;
10449 }
10450
10451 /****************************************************************
10452  _spoolss_DeletePort
10453 ****************************************************************/
10454
10455 WERROR _spoolss_DeletePort(struct pipes_struct *p,
10456                            struct spoolss_DeletePort *r)
10457 {
10458         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10459         return WERR_NOT_SUPPORTED;
10460 }
10461
10462 /****************************************************************
10463  _spoolss_CreatePrinterIC
10464 ****************************************************************/
10465
10466 WERROR _spoolss_CreatePrinterIC(struct pipes_struct *p,
10467                                 struct spoolss_CreatePrinterIC *r)
10468 {
10469         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10470         return WERR_NOT_SUPPORTED;
10471 }
10472
10473 /****************************************************************
10474  _spoolss_PlayGDIScriptOnPrinterIC
10475 ****************************************************************/
10476
10477 WERROR _spoolss_PlayGDIScriptOnPrinterIC(struct pipes_struct *p,
10478                                          struct spoolss_PlayGDIScriptOnPrinterIC *r)
10479 {
10480         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10481         return WERR_NOT_SUPPORTED;
10482 }
10483
10484 /****************************************************************
10485  _spoolss_DeletePrinterIC
10486 ****************************************************************/
10487
10488 WERROR _spoolss_DeletePrinterIC(struct pipes_struct *p,
10489                                 struct spoolss_DeletePrinterIC *r)
10490 {
10491         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10492         return WERR_NOT_SUPPORTED;
10493 }
10494
10495 /****************************************************************
10496  _spoolss_AddPrinterConnection
10497 ****************************************************************/
10498
10499 WERROR _spoolss_AddPrinterConnection(struct pipes_struct *p,
10500                                      struct spoolss_AddPrinterConnection *r)
10501 {
10502         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10503         return WERR_NOT_SUPPORTED;
10504 }
10505
10506 /****************************************************************
10507  _spoolss_DeletePrinterConnection
10508 ****************************************************************/
10509
10510 WERROR _spoolss_DeletePrinterConnection(struct pipes_struct *p,
10511                                         struct spoolss_DeletePrinterConnection *r)
10512 {
10513         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10514         return WERR_NOT_SUPPORTED;
10515 }
10516
10517 /****************************************************************
10518  _spoolss_PrinterMessageBox
10519 ****************************************************************/
10520
10521 WERROR _spoolss_PrinterMessageBox(struct pipes_struct *p,
10522                                   struct spoolss_PrinterMessageBox *r)
10523 {
10524         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10525         return WERR_NOT_SUPPORTED;
10526 }
10527
10528 /****************************************************************
10529  _spoolss_AddMonitor
10530 ****************************************************************/
10531
10532 WERROR _spoolss_AddMonitor(struct pipes_struct *p,
10533                            struct spoolss_AddMonitor *r)
10534 {
10535         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10536         return WERR_NOT_SUPPORTED;
10537 }
10538
10539 /****************************************************************
10540  _spoolss_DeleteMonitor
10541 ****************************************************************/
10542
10543 WERROR _spoolss_DeleteMonitor(struct pipes_struct *p,
10544                               struct spoolss_DeleteMonitor *r)
10545 {
10546         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10547         return WERR_NOT_SUPPORTED;
10548 }
10549
10550 /****************************************************************
10551  _spoolss_DeletePrintProcessor
10552 ****************************************************************/
10553
10554 WERROR _spoolss_DeletePrintProcessor(struct pipes_struct *p,
10555                                      struct spoolss_DeletePrintProcessor *r)
10556 {
10557         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10558         return WERR_NOT_SUPPORTED;
10559 }
10560
10561 /****************************************************************
10562  _spoolss_AddPrintProvidor
10563 ****************************************************************/
10564
10565 WERROR _spoolss_AddPrintProvidor(struct pipes_struct *p,
10566                                  struct spoolss_AddPrintProvidor *r)
10567 {
10568         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10569         return WERR_NOT_SUPPORTED;
10570 }
10571
10572 /****************************************************************
10573  _spoolss_DeletePrintProvidor
10574 ****************************************************************/
10575
10576 WERROR _spoolss_DeletePrintProvidor(struct pipes_struct *p,
10577                                     struct spoolss_DeletePrintProvidor *r)
10578 {
10579         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10580         return WERR_NOT_SUPPORTED;
10581 }
10582
10583 /****************************************************************
10584  _spoolss_FindFirstPrinterChangeNotification
10585 ****************************************************************/
10586
10587 WERROR _spoolss_FindFirstPrinterChangeNotification(struct pipes_struct *p,
10588                                                    struct spoolss_FindFirstPrinterChangeNotification *r)
10589 {
10590         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10591         return WERR_NOT_SUPPORTED;
10592 }
10593
10594 /****************************************************************
10595  _spoolss_FindNextPrinterChangeNotification
10596 ****************************************************************/
10597
10598 WERROR _spoolss_FindNextPrinterChangeNotification(struct pipes_struct *p,
10599                                                   struct spoolss_FindNextPrinterChangeNotification *r)
10600 {
10601         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10602         return WERR_NOT_SUPPORTED;
10603 }
10604
10605 /****************************************************************
10606  _spoolss_RouterFindFirstPrinterChangeNotificationOld
10607 ****************************************************************/
10608
10609 WERROR _spoolss_RouterFindFirstPrinterChangeNotificationOld(struct pipes_struct *p,
10610                                                             struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
10611 {
10612         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10613         return WERR_NOT_SUPPORTED;
10614 }
10615
10616 /****************************************************************
10617  _spoolss_ReplyOpenPrinter
10618 ****************************************************************/
10619
10620 WERROR _spoolss_ReplyOpenPrinter(struct pipes_struct *p,
10621                                  struct spoolss_ReplyOpenPrinter *r)
10622 {
10623         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10624         return WERR_NOT_SUPPORTED;
10625 }
10626
10627 /****************************************************************
10628  _spoolss_RouterReplyPrinter
10629 ****************************************************************/
10630
10631 WERROR _spoolss_RouterReplyPrinter(struct pipes_struct *p,
10632                                    struct spoolss_RouterReplyPrinter *r)
10633 {
10634         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10635         return WERR_NOT_SUPPORTED;
10636 }
10637
10638 /****************************************************************
10639  _spoolss_ReplyClosePrinter
10640 ****************************************************************/
10641
10642 WERROR _spoolss_ReplyClosePrinter(struct pipes_struct *p,
10643                                   struct spoolss_ReplyClosePrinter *r)
10644 {
10645         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10646         return WERR_NOT_SUPPORTED;
10647 }
10648
10649 /****************************************************************
10650  _spoolss_AddPortEx
10651 ****************************************************************/
10652
10653 WERROR _spoolss_AddPortEx(struct pipes_struct *p,
10654                           struct spoolss_AddPortEx *r)
10655 {
10656         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10657         return WERR_NOT_SUPPORTED;
10658 }
10659
10660 /****************************************************************
10661  _spoolss_RouterFindFirstPrinterChangeNotification
10662 ****************************************************************/
10663
10664 WERROR _spoolss_RouterFindFirstPrinterChangeNotification(struct pipes_struct *p,
10665                                                          struct spoolss_RouterFindFirstPrinterChangeNotification *r)
10666 {
10667         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10668         return WERR_NOT_SUPPORTED;
10669 }
10670
10671 /****************************************************************
10672  _spoolss_SpoolerInit
10673 ****************************************************************/
10674
10675 WERROR _spoolss_SpoolerInit(struct pipes_struct *p,
10676                             struct spoolss_SpoolerInit *r)
10677 {
10678         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10679         return WERR_NOT_SUPPORTED;
10680 }
10681
10682 /****************************************************************
10683  _spoolss_ResetPrinterEx
10684 ****************************************************************/
10685
10686 WERROR _spoolss_ResetPrinterEx(struct pipes_struct *p,
10687                                struct spoolss_ResetPrinterEx *r)
10688 {
10689         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10690         return WERR_NOT_SUPPORTED;
10691 }
10692
10693 /****************************************************************
10694  _spoolss_RouterReplyPrinterEx
10695 ****************************************************************/
10696
10697 WERROR _spoolss_RouterReplyPrinterEx(struct pipes_struct *p,
10698                                      struct spoolss_RouterReplyPrinterEx *r)
10699 {
10700         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10701         return WERR_NOT_SUPPORTED;
10702 }
10703
10704 /****************************************************************
10705  _spoolss_44
10706 ****************************************************************/
10707
10708 WERROR _spoolss_44(struct pipes_struct *p,
10709                    struct spoolss_44 *r)
10710 {
10711         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10712         return WERR_NOT_SUPPORTED;
10713 }
10714
10715 /****************************************************************
10716  _spoolss_SetPort
10717 ****************************************************************/
10718
10719 WERROR _spoolss_SetPort(struct pipes_struct *p,
10720                         struct spoolss_SetPort *r)
10721 {
10722         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10723         return WERR_NOT_SUPPORTED;
10724 }
10725
10726 /****************************************************************
10727  _spoolss_4a
10728 ****************************************************************/
10729
10730 WERROR _spoolss_4a(struct pipes_struct *p,
10731                    struct spoolss_4a *r)
10732 {
10733         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10734         return WERR_NOT_SUPPORTED;
10735 }
10736
10737 /****************************************************************
10738  _spoolss_4b
10739 ****************************************************************/
10740
10741 WERROR _spoolss_4b(struct pipes_struct *p,
10742                    struct spoolss_4b *r)
10743 {
10744         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10745         return WERR_NOT_SUPPORTED;
10746 }
10747
10748 /****************************************************************
10749  _spoolss_4c
10750 ****************************************************************/
10751
10752 WERROR _spoolss_4c(struct pipes_struct *p,
10753                    struct spoolss_4c *r)
10754 {
10755         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10756         return WERR_NOT_SUPPORTED;
10757 }
10758
10759 /****************************************************************
10760  _spoolss_53
10761 ****************************************************************/
10762
10763 WERROR _spoolss_53(struct pipes_struct *p,
10764                    struct spoolss_53 *r)
10765 {
10766         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10767         return WERR_NOT_SUPPORTED;
10768 }
10769
10770 /****************************************************************
10771  _spoolss_AddPerMachineConnection
10772 ****************************************************************/
10773
10774 WERROR _spoolss_AddPerMachineConnection(struct pipes_struct *p,
10775                                         struct spoolss_AddPerMachineConnection *r)
10776 {
10777         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10778         return WERR_NOT_SUPPORTED;
10779 }
10780
10781 /****************************************************************
10782  _spoolss_DeletePerMachineConnection
10783 ****************************************************************/
10784
10785 WERROR _spoolss_DeletePerMachineConnection(struct pipes_struct *p,
10786                                            struct spoolss_DeletePerMachineConnection *r)
10787 {
10788         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10789         return WERR_NOT_SUPPORTED;
10790 }
10791
10792 /****************************************************************
10793  _spoolss_EnumPerMachineConnections
10794 ****************************************************************/
10795
10796 WERROR _spoolss_EnumPerMachineConnections(struct pipes_struct *p,
10797                                           struct spoolss_EnumPerMachineConnections *r)
10798 {
10799         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10800         return WERR_NOT_SUPPORTED;
10801 }
10802
10803 /****************************************************************
10804  _spoolss_5a
10805 ****************************************************************/
10806
10807 WERROR _spoolss_5a(struct pipes_struct *p,
10808                    struct spoolss_5a *r)
10809 {
10810         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10811         return WERR_NOT_SUPPORTED;
10812 }
10813
10814 /****************************************************************
10815  _spoolss_5b
10816 ****************************************************************/
10817
10818 WERROR _spoolss_5b(struct pipes_struct *p,
10819                    struct spoolss_5b *r)
10820 {
10821         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10822         return WERR_NOT_SUPPORTED;
10823 }
10824
10825 /****************************************************************
10826  _spoolss_5c
10827 ****************************************************************/
10828
10829 WERROR _spoolss_5c(struct pipes_struct *p,
10830                    struct spoolss_5c *r)
10831 {
10832         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10833         return WERR_NOT_SUPPORTED;
10834 }
10835
10836 /****************************************************************
10837  _spoolss_5d
10838 ****************************************************************/
10839
10840 WERROR _spoolss_5d(struct pipes_struct *p,
10841                    struct spoolss_5d *r)
10842 {
10843         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10844         return WERR_NOT_SUPPORTED;
10845 }
10846
10847 /****************************************************************
10848  _spoolss_5e
10849 ****************************************************************/
10850
10851 WERROR _spoolss_5e(struct pipes_struct *p,
10852                    struct spoolss_5e *r)
10853 {
10854         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10855         return WERR_NOT_SUPPORTED;
10856 }
10857
10858 /****************************************************************
10859  _spoolss_5f
10860 ****************************************************************/
10861
10862 WERROR _spoolss_5f(struct pipes_struct *p,
10863                    struct spoolss_5f *r)
10864 {
10865         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10866         return WERR_NOT_SUPPORTED;
10867 }
10868
10869 /****************************************************************
10870  _spoolss_60
10871 ****************************************************************/
10872
10873 WERROR _spoolss_60(struct pipes_struct *p,
10874                    struct spoolss_60 *r)
10875 {
10876         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10877         return WERR_NOT_SUPPORTED;
10878 }
10879
10880 /****************************************************************
10881  _spoolss_RpcSendRecvBidiData
10882 ****************************************************************/
10883
10884 WERROR _spoolss_RpcSendRecvBidiData(struct pipes_struct *p,
10885                                     struct spoolss_RpcSendRecvBidiData *r)
10886 {
10887         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10888         return WERR_NOT_SUPPORTED;
10889 }
10890
10891 /****************************************************************
10892  _spoolss_62
10893 ****************************************************************/
10894
10895 WERROR _spoolss_62(struct pipes_struct *p,
10896                    struct spoolss_62 *r)
10897 {
10898         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10899         return WERR_NOT_SUPPORTED;
10900 }
10901
10902 /****************************************************************
10903  _spoolss_63
10904 ****************************************************************/
10905
10906 WERROR _spoolss_63(struct pipes_struct *p,
10907                    struct spoolss_63 *r)
10908 {
10909         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10910         return WERR_NOT_SUPPORTED;
10911 }
10912
10913 /****************************************************************
10914  _spoolss_64
10915 ****************************************************************/
10916
10917 WERROR _spoolss_64(struct pipes_struct *p,
10918                    struct spoolss_64 *r)
10919 {
10920         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10921         return WERR_NOT_SUPPORTED;
10922 }
10923
10924 /****************************************************************
10925  _spoolss_65
10926 ****************************************************************/
10927
10928 WERROR _spoolss_65(struct pipes_struct *p,
10929                    struct spoolss_65 *r)
10930 {
10931         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10932         return WERR_NOT_SUPPORTED;
10933 }
10934
10935 /****************************************************************
10936  _spoolss_GetCorePrinterDrivers
10937 ****************************************************************/
10938
10939 WERROR _spoolss_GetCorePrinterDrivers(struct pipes_struct *p,
10940                                       struct spoolss_GetCorePrinterDrivers *r)
10941 {
10942         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10943         return WERR_NOT_SUPPORTED;
10944 }
10945
10946 /****************************************************************
10947  _spoolss_67
10948 ****************************************************************/
10949
10950 WERROR _spoolss_67(struct pipes_struct *p,
10951                    struct spoolss_67 *r)
10952 {
10953         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10954         return WERR_NOT_SUPPORTED;
10955 }
10956
10957 /****************************************************************
10958  _spoolss_GetPrinterDriverPackagePath
10959 ****************************************************************/
10960
10961 WERROR _spoolss_GetPrinterDriverPackagePath(struct pipes_struct *p,
10962                                             struct spoolss_GetPrinterDriverPackagePath *r)
10963 {
10964         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10965         return WERR_NOT_SUPPORTED;
10966 }
10967
10968 /****************************************************************
10969  _spoolss_69
10970 ****************************************************************/
10971
10972 WERROR _spoolss_69(struct pipes_struct *p,
10973                    struct spoolss_69 *r)
10974 {
10975         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10976         return WERR_NOT_SUPPORTED;
10977 }
10978
10979 /****************************************************************
10980  _spoolss_6a
10981 ****************************************************************/
10982
10983 WERROR _spoolss_6a(struct pipes_struct *p,
10984                    struct spoolss_6a *r)
10985 {
10986         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10987         return WERR_NOT_SUPPORTED;
10988 }
10989
10990 /****************************************************************
10991  _spoolss_6b
10992 ****************************************************************/
10993
10994 WERROR _spoolss_6b(struct pipes_struct *p,
10995                    struct spoolss_6b *r)
10996 {
10997         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10998         return WERR_NOT_SUPPORTED;
10999 }
11000
11001 /****************************************************************
11002  _spoolss_6c
11003 ****************************************************************/
11004
11005 WERROR _spoolss_6c(struct pipes_struct *p,
11006                    struct spoolss_6c *r)
11007 {
11008         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11009         return WERR_NOT_SUPPORTED;
11010 }
11011
11012 /****************************************************************
11013  _spoolss_6d
11014 ****************************************************************/
11015
11016 WERROR _spoolss_6d(struct pipes_struct *p,
11017                    struct spoolss_6d *r)
11018 {
11019         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11020         return WERR_NOT_SUPPORTED;
11021 }
11022
11023 /****************************************************************
11024  _spoolss_RpcGetJobNamedPropertyValue
11025 ****************************************************************/
11026
11027 WERROR _spoolss_RpcGetJobNamedPropertyValue(struct pipes_struct *p,
11028                                             struct spoolss_RpcGetJobNamedPropertyValue *r)
11029 {
11030         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11031         return WERR_NOT_SUPPORTED;
11032 }
11033
11034 /****************************************************************
11035  _spoolss_RpcSetJobNamedProperty
11036 ****************************************************************/
11037
11038 WERROR _spoolss_RpcSetJobNamedProperty(struct pipes_struct *p,
11039                                        struct spoolss_RpcSetJobNamedProperty *r)
11040 {
11041         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11042         return WERR_NOT_SUPPORTED;
11043 }
11044
11045 /****************************************************************
11046  _spoolss_RpcDeleteJobNamedProperty
11047 ****************************************************************/
11048
11049 WERROR _spoolss_RpcDeleteJobNamedProperty(struct pipes_struct *p,
11050                                           struct spoolss_RpcDeleteJobNamedProperty *r)
11051 {
11052         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11053         return WERR_NOT_SUPPORTED;
11054 }
11055
11056 /****************************************************************
11057  _spoolss_RpcEnumJobNamedProperties
11058 ****************************************************************/
11059
11060 WERROR _spoolss_RpcEnumJobNamedProperties(struct pipes_struct *p,
11061                                           struct spoolss_RpcEnumJobNamedProperties *r)
11062 {
11063         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11064         return WERR_NOT_SUPPORTED;
11065 }