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