source3/rpc_server/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 "nt_printing.h"
  32 #include "srv_spoolss_util.h"
  33 #include "../librpc/gen_ndr/srv_spoolss.h"
  34 #include "../librpc/gen_ndr/cli_spoolss.h"
  35 #include "rpc_client/init_spoolss.h"
  36 #include "librpc/gen_ndr/messaging.h"
  37 #include "librpc/gen_ndr/ndr_security.h"
  38 #include "registry.h"
  39 #include "registry/reg_objects.h"
  40 #include "include/printing.h"
  41 #include "secrets.h"
  42 #include "../librpc/gen_ndr/netlogon.h"
  43
  44 /* macros stolen from s4 spoolss server */
  45 #define SPOOLSS_BUFFER_UNION(fn,info,level) \
  46         ((info)?ndr_size_##fn(info, level, 0):0)
  47
  48 #define SPOOLSS_BUFFER_UNION_ARRAY(mem_ctx,fn,info,level,count) \
  49         ((info)?ndr_size_##fn##_info(mem_ctx, level, count, info):0)
  50
  51 #define SPOOLSS_BUFFER_ARRAY(mem_ctx,fn,info,count) \
  52         ((info)?ndr_size_##fn##_info(mem_ctx, count, info):0)
  53
  54 #define SPOOLSS_BUFFER_OK(val_true,val_false) ((r->in.offered >= *r->out.needed)?val_true:val_false)
  55
  56 #undef DBGC_CLASS
  57 #define DBGC_CLASS DBGC_RPC_SRV
  58
  59 static Printer_entry *printers_list;
  60
  61 typedef struct _counter_printer_0 {
  62         struct _counter_printer_0 *next;
  63         struct _counter_printer_0 *prev;
  64
  65         int snum;
  66         uint32_t counter;
  67 } counter_printer_0;
  68
  69 static counter_printer_0 *counter_list;
  70
  71 static struct rpc_pipe_client *notify_cli_pipe; /* print notify back-channel pipe handle*/
  72 static uint32_t smb_connections = 0;
  73
  74
  75 /* Map generic permissions to printer object specific permissions */
  76
  77 const struct standard_mapping printer_std_mapping = {
  78         PRINTER_READ,
  79         PRINTER_WRITE,
  80         PRINTER_EXECUTE,
  81         PRINTER_ALL_ACCESS
  82 };
  83
  84 /* Map generic permissions to print server object specific permissions */
  85
  86 const struct standard_mapping printserver_std_mapping = {
  87         SERVER_READ,
  88         SERVER_WRITE,
  89         SERVER_EXECUTE,
  90         SERVER_ALL_ACCESS
  91 };
  92
  93 /* API table for Xcv Monitor functions */
  94
  95 struct xcv_api_table {
  96         const char *name;
  97         WERROR(*fn) (TALLOC_CTX *mem_ctx, NT_USER_TOKEN *token, DATA_BLOB *in, DATA_BLOB *out, uint32_t *needed);
  98 };
  99
 100 /********************************************************************
 101  * Canonicalize servername.
 102  ********************************************************************/
 103
 104 static const char *canon_servername(const char *servername)
 105 {
 106         const char *pservername = servername;
 107         while (*pservername == '\\') {
 108                 pservername++;
 109         }
 110         return pservername;
 111 }
 112
 113 /* translate between internal status numbers and NT status numbers */
 114 static int nt_printj_status(int v)
 115 {
 116         switch (v) {
 117         case LPQ_QUEUED:
 118                 return 0;
 119         case LPQ_PAUSED:
 120                 return JOB_STATUS_PAUSED;
 121         case LPQ_SPOOLING:
 122                 return JOB_STATUS_SPOOLING;
 123         case LPQ_PRINTING:
 124                 return JOB_STATUS_PRINTING;
 125         case LPQ_ERROR:
 126                 return JOB_STATUS_ERROR;
 127         case LPQ_DELETING:
 128                 return JOB_STATUS_DELETING;
 129         case LPQ_OFFLINE:
 130                 return JOB_STATUS_OFFLINE;
 131         case LPQ_PAPEROUT:
 132                 return JOB_STATUS_PAPEROUT;
 133         case LPQ_PRINTED:
 134                 return JOB_STATUS_PRINTED;
 135         case LPQ_DELETED:
 136                 return JOB_STATUS_DELETED;
 137         case LPQ_BLOCKED:
 138                 return JOB_STATUS_BLOCKED_DEVQ;
 139         case LPQ_USER_INTERVENTION:
 140                 return JOB_STATUS_USER_INTERVENTION;
 141         }
 142         return 0;
 143 }
 144
 145 static int nt_printq_status(int v)
 146 {
 147         switch (v) {
 148         case LPQ_PAUSED:
 149                 return PRINTER_STATUS_PAUSED;
 150         case LPQ_QUEUED:
 151         case LPQ_SPOOLING:
 152         case LPQ_PRINTING:
 153                 return 0;
 154         }
 155         return 0;
 156 }
 157
 158 /***************************************************************************
 159  Disconnect from the client
 160 ****************************************************************************/
 161
 162 static void srv_spoolss_replycloseprinter(
 163         int snum, struct policy_handle *handle,
 164         struct messaging_context *msg_ctx)
 165 {
 166         WERROR result;
 167         NTSTATUS status;
 168
 169         /*
 170          * Tell the specific printing tdb we no longer want messages for this printer
 171          * by deregistering our PID.
 172          */
 173
 174         if (!print_notify_deregister_pid(snum))
 175                 DEBUG(0,("print_notify_register_pid: Failed to register our pid for printer %s\n", lp_const_servicename(snum) ));
 176
 177         /* weird if the test succeeds !!! */
 178         if (smb_connections==0) {
 179                 DEBUG(0,("srv_spoolss_replycloseprinter:Trying to close non-existant notify backchannel !\n"));
 180                 return;
 181         }
 182
 183         status = rpccli_spoolss_ReplyClosePrinter(notify_cli_pipe, talloc_tos(),
 184                                                   handle,
 185                                                   &result);
 186         if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result))
 187                 DEBUG(0,("srv_spoolss_replycloseprinter: reply_close_printer failed [%s].\n",
 188                         win_errstr(result)));
 189
 190         /* if it's the last connection, deconnect the IPC$ share */
 191         if (smb_connections==1) {
 192
 193                 cli_shutdown( rpc_pipe_np_smb_conn(notify_cli_pipe) );
 194                 /*
 195                  * The above call shuts down the pipe also.
 196                  */
 197                 notify_cli_pipe = NULL;
 198
 199                 if (msg_ctx != NULL) {
 200                         messaging_deregister(msg_ctx, MSG_PRINTER_NOTIFY2,
 201                                              NULL);
 202
 203                         /*
 204                          * Tell the serverid.tdb we're no longer
 205                          * interested in printer notify messages.
 206                          */
 207
 208                         serverid_register_msg_flags(
 209                                 messaging_server_id(msg_ctx),
 210                                 false, FLAG_MSG_PRINT_NOTIFY);
 211                 }
 212         }
 213
 214         smb_connections--;
 215 }
 216
 217 /****************************************************************************
 218  Functions to free a printer entry datastruct.
 219 ****************************************************************************/
 220
 221 static int printer_entry_destructor(Printer_entry *Printer)
 222 {
 223         if (Printer->notify.client_connected == true) {
 224                 int snum = -1;
 225
 226                 if ( Printer->printer_type == SPLHND_SERVER) {
 227                         snum = -1;
 228                         srv_spoolss_replycloseprinter(
 229                                 snum, &Printer->notify.client_hnd,
 230                                 Printer->notify.msg_ctx);
 231                 } else if (Printer->printer_type == SPLHND_PRINTER) {
 232                         snum = print_queue_snum(Printer->sharename);
 233                         if (snum != -1)
 234                                 srv_spoolss_replycloseprinter(
 235                                         snum, &Printer->notify.client_hnd,
 236                                         Printer->notify.msg_ctx);
 237                 }
 238         }
 239
 240         Printer->notify.flags=0;
 241         Printer->notify.options=0;
 242         Printer->notify.localmachine[0]='\0';
 243         Printer->notify.printerlocal=0;
 244         TALLOC_FREE(Printer->notify.option);
 245         Printer->notify.client_connected = false;
 246
 247         TALLOC_FREE(Printer->devmode);
 248
 249         /* Remove from the internal list. */
 250         DLIST_REMOVE(printers_list, Printer);
 251         return 0;
 252 }
 253
 254 /****************************************************************************
 255   find printer index by handle
 256 ****************************************************************************/
 257
 258 static Printer_entry *find_printer_index_by_hnd(struct pipes_struct *p,
 259                                                 struct policy_handle *hnd)
 260 {
 261         Printer_entry *find_printer = NULL;
 262
 263         if(!find_policy_by_hnd(p,hnd,(void **)(void *)&find_printer)) {
 264                 DEBUG(2,("find_printer_index_by_hnd: Printer handle not found: "));
 265                 return NULL;
 266         }
 267
 268         return find_printer;
 269 }
 270
 271 /****************************************************************************
 272  Close printer index by handle.
 273 ****************************************************************************/
 274
 275 static bool close_printer_handle(struct pipes_struct *p, struct policy_handle *hnd)
 276 {
 277         Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
 278
 279         if (!Printer) {
 280                 DEBUG(2,("close_printer_handle: Invalid handle (%s:%u:%u)\n",
 281                         OUR_HANDLE(hnd)));
 282                 return false;
 283         }
 284
 285         close_policy_hnd(p, hnd);
 286
 287         return true;
 288 }
 289
 290 /****************************************************************************
 291  Delete a printer given a handle.
 292 ****************************************************************************/
 293
 294 static WERROR delete_printer_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token,
 295                                   const char *sharename,
 296                                   struct messaging_context *msg_ctx)
 297 {
 298         char *cmd = lp_deleteprinter_cmd();
 299         char *command = NULL;
 300         int ret;
 301         SE_PRIV se_printop = SE_PRINT_OPERATOR;
 302         bool is_print_op = false;
 303
 304         /* can't fail if we don't try */
 305
 306         if ( !*cmd )
 307                 return WERR_OK;
 308
 309         command = talloc_asprintf(ctx,
 310                         "%s \"%s\"",
 311                         cmd, sharename);
 312         if (!command) {
 313                 return WERR_NOMEM;
 314         }
 315         if ( token )
 316                 is_print_op = user_has_privileges( token, &se_printop );
 317
 318         DEBUG(10,("Running [%s]\n", command));
 319
 320         /********** BEGIN SePrintOperatorPrivlege BLOCK **********/
 321
 322         if ( is_print_op )
 323                 become_root();
 324
 325         if ( (ret = smbrun(command, NULL)) == 0 ) {
 326                 /* Tell everyone we updated smb.conf. */
 327                 message_send_all(msg_ctx, MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
 328         }
 329
 330         if ( is_print_op )
 331                 unbecome_root();
 332
 333         /********** END SePrintOperatorPrivlege BLOCK **********/
 334
 335         DEBUGADD(10,("returned [%d]\n", ret));
 336
 337         TALLOC_FREE(command);
 338
 339         if (ret != 0)
 340                 return WERR_BADFID; /* What to return here? */
 341
 342         /* go ahead and re-read the services immediately */
 343         become_root();
 344         reload_services(false);
 345         unbecome_root();
 346
 347         if ( lp_servicenumber( sharename )  > 0 )
 348                 return WERR_ACCESS_DENIED;
 349
 350         return WERR_OK;
 351 }
 352
 353 /****************************************************************************
 354  Delete a printer given a handle.
 355 ****************************************************************************/
 356
 357 static WERROR delete_printer_handle(struct pipes_struct *p, struct policy_handle *hnd)
 358 {
 359         Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
 360         WERROR result;
 361
 362         if (!Printer) {
 363                 DEBUG(2,("delete_printer_handle: Invalid handle (%s:%u:%u)\n",
 364                         OUR_HANDLE(hnd)));
 365                 return WERR_BADFID;
 366         }
 367
 368         /*
 369          * It turns out that Windows allows delete printer on a handle
 370          * opened by an admin user, then used on a pipe handle created
 371          * by an anonymous user..... but they're working on security.... riiight !
 372          * JRA.
 373          */
 374
 375         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
 376                 DEBUG(3, ("delete_printer_handle: denied by handle\n"));
 377                 return WERR_ACCESS_DENIED;
 378         }
 379
 380         /* this does not need a become root since the access check has been
 381            done on the handle already */
 382
 383         result = winreg_delete_printer_key(p->mem_ctx, p->server_info,
 384                                            p->msg_ctx, Printer->sharename, "");
 385         if (!W_ERROR_IS_OK(result)) {
 386                 DEBUG(3,("Error deleting printer %s\n", Printer->sharename));
 387                 return WERR_BADFID;
 388         }
 389
 390         return delete_printer_hook(p->mem_ctx, p->server_info->ptok,
 391                                    Printer->sharename, p->msg_ctx);
 392 }
 393
 394 /****************************************************************************
 395  Return the snum of a printer corresponding to an handle.
 396 ****************************************************************************/
 397
 398 static bool get_printer_snum(struct pipes_struct *p, struct policy_handle *hnd,
 399                              int *number, struct share_params **params)
 400 {
 401         Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
 402
 403         if (!Printer) {
 404                 DEBUG(2,("get_printer_snum: Invalid handle (%s:%u:%u)\n",
 405                         OUR_HANDLE(hnd)));
 406                 return false;
 407         }
 408
 409         switch (Printer->printer_type) {
 410                 case SPLHND_PRINTER:
 411                         DEBUG(4,("short name:%s\n", Printer->sharename));
 412                         *number = print_queue_snum(Printer->sharename);
 413                         return (*number != -1);
 414                 case SPLHND_SERVER:
 415                         return false;
 416                 default:
 417                         return false;
 418         }
 419 }
 420
 421 /****************************************************************************
 422  Set printer handle type.
 423  Check if it's \\server or \\server\printer
 424 ****************************************************************************/
 425
 426 static bool set_printer_hnd_printertype(Printer_entry *Printer, const char *handlename)
 427 {
 428         DEBUG(3,("Setting printer type=%s\n", handlename));
 429
 430         if ( strlen(handlename) < 3 ) {
 431                 DEBUGADD(4,("A print server must have at least 1 char ! %s\n", handlename));
 432                 return false;
 433         }
 434
 435         /* it's a print server */
 436         if (*handlename=='\\' && *(handlename+1)=='\\' && !strchr_m(handlename+2, '\\')) {
 437                 DEBUGADD(4,("Printer is a print server\n"));
 438                 Printer->printer_type = SPLHND_SERVER;
 439         }
 440         /* it's a printer (set_printer_hnd_name() will handle port monitors */
 441         else {
 442                 DEBUGADD(4,("Printer is a printer\n"));
 443                 Printer->printer_type = SPLHND_PRINTER;
 444         }
 445
 446         return true;
 447 }
 448
 449 /****************************************************************************
 450  Set printer handle name..  Accept names like \\server, \\server\printer,
 451  \\server\SHARE, & "\\server\,XcvMonitor Standard TCP/IP Port"    See
 452  the MSDN docs regarding OpenPrinter() for details on the XcvData() and
 453  XcvDataPort() interface.
 454 ****************************************************************************/
 455
 456 static bool set_printer_hnd_name(TALLOC_CTX *mem_ctx,
 457                                  struct auth_serversupplied_info *server_info,
 458                                  struct messaging_context *msg_ctx,
 459                                  Printer_entry *Printer,
 460                                  const char *handlename)
 461 {
 462         int snum;
 463         int n_services=lp_numservices();
 464         char *aprinter;
 465         const char *printername;
 466         const char *servername = NULL;
 467         fstring sname;
 468         bool found = false;
 469         struct spoolss_PrinterInfo2 *info2 = NULL;
 470         WERROR result;
 471
 472         DEBUG(4,("Setting printer name=%s (len=%lu)\n", handlename,
 473                 (unsigned long)strlen(handlename)));
 474
 475         aprinter = CONST_DISCARD(char *, handlename);
 476         if ( *handlename == '\\' ) {
 477                 servername = canon_servername(handlename);
 478                 if ( (aprinter = strchr_m( servername, '\\' )) != NULL ) {
 479                         *aprinter = '\0';
 480                         aprinter++;
 481                 }
 482                 if (!is_myname_or_ipaddr(servername)) {
 483                         return false;
 484                 }
 485
 486                 fstrcpy(Printer->servername, servername);
 487         }
 488
 489         if (Printer->printer_type == SPLHND_SERVER) {
 490                 return true;
 491         }
 492
 493         if (Printer->printer_type != SPLHND_PRINTER) {
 494                 return false;
 495         }
 496
 497         DEBUGADD(5, ("searching for [%s]\n", aprinter));
 498
 499         /* check for the Port Monitor Interface */
 500         if ( strequal( aprinter, SPL_XCV_MONITOR_TCPMON ) ) {
 501                 Printer->printer_type = SPLHND_PORTMON_TCP;
 502                 fstrcpy(sname, SPL_XCV_MONITOR_TCPMON);
 503                 found = true;
 504         }
 505         else if ( strequal( aprinter, SPL_XCV_MONITOR_LOCALMON ) ) {
 506                 Printer->printer_type = SPLHND_PORTMON_LOCAL;
 507                 fstrcpy(sname, SPL_XCV_MONITOR_LOCALMON);
 508                 found = true;
 509         }
 510
 511         /* Search all sharenames first as this is easier than pulling
 512            the printer_info_2 off of disk. Don't use find_service() since
 513            that calls out to map_username() */
 514
 515         /* do another loop to look for printernames */
 516         for (snum = 0; !found && snum < n_services; snum++) {
 517                 const char *printer = lp_const_servicename(snum);
 518
 519                 /* no point going on if this is not a printer */
 520                 if (!(lp_snum_ok(snum) && lp_print_ok(snum))) {
 521                         continue;
 522                 }
 523
 524                 /* ignore [printers] share */
 525                 if (strequal(printer, "printers")) {
 526                         continue;
 527                 }
 528
 529                 fstrcpy(sname, printer);
 530                 if (strequal(aprinter, printer)) {
 531                         found = true;
 532                         break;
 533                 }
 534
 535                 /* no point looking up the printer object if
 536                    we aren't allowing printername != sharename */
 537                 if (lp_force_printername(snum)) {
 538                         continue;
 539                 }
 540
 541                 result = winreg_get_printer(mem_ctx,
 542                                             server_info,
 543                                             msg_ctx,
 544                                             servername,
 545                                             sname,
 546                                             &info2);
 547                 if ( !W_ERROR_IS_OK(result) ) {
 548                         DEBUG(2,("set_printer_hnd_name: failed to lookup printer [%s] -- result [%s]\n",
 549                                  sname, win_errstr(result)));
 550                         continue;
 551                 }
 552
 553                 printername = strrchr(info2->printername, '\\');
 554                 if (printername == NULL) {
 555                         printername = info2->printername;
 556                 } else {
 557                         printername++;
 558                 }
 559
 560                 if (strequal(printername, aprinter)) {
 561                         found = true;
 562                         break;
 563                 }
 564
 565                 DEBUGADD(10, ("printername: %s\n", printername));
 566
 567                 TALLOC_FREE(info2);
 568         }
 569
 570         if ( !found ) {
 571                 DEBUGADD(4,("Printer not found\n"));
 572                 return false;
 573         }
 574
 575         DEBUGADD(4,("set_printer_hnd_name: Printer found: %s -> %s\n", aprinter, sname));
 576
 577         fstrcpy(Printer->sharename, sname);
 578
 579         return true;
 580 }
 581
 582 /****************************************************************************
 583  Find first available printer slot. creates a printer handle for you.
 584  ****************************************************************************/
 585
 586 static bool open_printer_hnd(struct pipes_struct *p, struct policy_handle *hnd,
 587                              const char *name, uint32_t access_granted)
 588 {
 589         Printer_entry *new_printer;
 590
 591         DEBUG(10,("open_printer_hnd: name [%s]\n", name));
 592
 593         new_printer = TALLOC_ZERO_P(NULL, Printer_entry);
 594         if (new_printer == NULL) {
 595                 return false;
 596         }
 597         talloc_set_destructor(new_printer, printer_entry_destructor);
 598
 599         if (!create_policy_hnd(p, hnd, new_printer)) {
 600                 TALLOC_FREE(new_printer);
 601                 return false;
 602         }
 603
 604         /* Add to the internal list. */
 605         DLIST_ADD(printers_list, new_printer);
 606
 607         new_printer->notify.option=NULL;
 608
 609         if (!set_printer_hnd_printertype(new_printer, name)) {
 610                 close_printer_handle(p, hnd);
 611                 return false;
 612         }
 613
 614         if (!set_printer_hnd_name(p->mem_ctx, p->server_info, p->msg_ctx,
 615                                   new_printer, name)) {
 616                 close_printer_handle(p, hnd);
 617                 return false;
 618         }
 619
 620         new_printer->access_granted = access_granted;
 621
 622         DEBUG(5, ("%d printer handles active\n",
 623                   (int)num_pipe_handles(p)));
 624
 625         return true;
 626 }
 627
 628 /***************************************************************************
 629  check to see if the client motify handle is monitoring the notification
 630  given by (notify_type, notify_field).
 631  **************************************************************************/
 632
 633 static bool is_monitoring_event_flags(uint32_t flags, uint16_t notify_type,
 634                                       uint16_t notify_field)
 635 {
 636         return true;
 637 }
 638
 639 static bool is_monitoring_event(Printer_entry *p, uint16_t notify_type,
 640                                 uint16_t notify_field)
 641 {
 642         struct spoolss_NotifyOption *option = p->notify.option;
 643         uint32_t i, j;
 644
 645         /*
 646          * Flags should always be zero when the change notify
 647          * is registered by the client's spooler.  A user Win32 app
 648          * might use the flags though instead of the NOTIFY_OPTION_INFO
 649          * --jerry
 650          */
 651
 652         if (!option) {
 653                 return false;
 654         }
 655
 656         if (p->notify.flags)
 657                 return is_monitoring_event_flags(
 658                         p->notify.flags, notify_type, notify_field);
 659
 660         for (i = 0; i < option->count; i++) {
 661
 662                 /* Check match for notify_type */
 663
 664                 if (option->types[i].type != notify_type)
 665                         continue;
 666
 667                 /* Check match for field */
 668
 669                 for (j = 0; j < option->types[i].count; j++) {
 670                         if (option->types[i].fields[j].field == notify_field) {
 671                                 return true;
 672                         }
 673                 }
 674         }
 675
 676         DEBUG(10, ("Open handle for \\\\%s\\%s is not monitoring 0x%02x/0x%02x\n",
 677                    p->servername, p->sharename, notify_type, notify_field));
 678
 679         return false;
 680 }
 681
 682 #define SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(_data, _integer) \
 683         _data->data.integer[0] = _integer; \
 684         _data->data.integer[1] = 0;
 685
 686
 687 #define SETUP_SPOOLSS_NOTIFY_DATA_STRING(_data, _p) \
 688         _data->data.string.string = talloc_strdup(mem_ctx, _p); \
 689         if (!_data->data.string.string) {\
 690                 _data->data.string.size = 0; \
 691         } \
 692         _data->data.string.size = strlen_m_term(_p) * 2;
 693
 694 #define SETUP_SPOOLSS_NOTIFY_DATA_DEVMODE(_data, _devmode) \
 695         _data->data.devmode.devmode = _devmode;
 696
 697 #define SETUP_SPOOLSS_NOTIFY_DATA_SECDESC(_data, _sd) \
 698         _data->data.sd.sd = dup_sec_desc(mem_ctx, _sd); \
 699         if (!_data->data.sd.sd) { \
 700                 _data->data.sd.sd_size = 0; \
 701         } \
 702         _data->data.sd.sd_size = \
 703                 ndr_size_security_descriptor(_data->data.sd.sd, 0);
 704
 705 static void init_systemtime_buffer(TALLOC_CTX *mem_ctx,
 706                                    struct tm *t,
 707                                    const char **pp,
 708                                    uint32_t *plen)
 709 {
 710         struct spoolss_Time st;
 711         uint32_t len = 16;
 712         char *p;
 713
 714         if (!init_systemtime(&st, t)) {
 715                 return;
 716         }
 717
 718         p = talloc_array(mem_ctx, char, len);
 719         if (!p) {
 720                 return;
 721         }
 722
 723         /*
 724          * Systemtime must be linearized as a set of UINT16's.
 725          * Fix from Benjamin (Bj) Kuit bj@it.uts.edu.au
 726          */
 727
 728         SSVAL(p, 0, st.year);
 729         SSVAL(p, 2, st.month);
 730         SSVAL(p, 4, st.day_of_week);
 731         SSVAL(p, 6, st.day);
 732         SSVAL(p, 8, st.hour);
 733         SSVAL(p, 10, st.minute);
 734         SSVAL(p, 12, st.second);
 735         SSVAL(p, 14, st.millisecond);
 736
 737         *pp = p;
 738         *plen = len;
 739 }
 740
 741 /* Convert a notification message to a struct spoolss_Notify */
 742
 743 static void notify_one_value(struct spoolss_notify_msg *msg,
 744                              struct spoolss_Notify *data,
 745                              TALLOC_CTX *mem_ctx)
 746 {
 747         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, msg->notify.value[0]);
 748 }
 749
 750 static void notify_string(struct spoolss_notify_msg *msg,
 751                           struct spoolss_Notify *data,
 752                           TALLOC_CTX *mem_ctx)
 753 {
 754         /* The length of the message includes the trailing \0 */
 755
 756         data->data.string.size = msg->len * 2;
 757         data->data.string.string = talloc_strdup(mem_ctx, msg->notify.data);
 758         if (!data->data.string.string) {
 759                 data->data.string.size = 0;
 760                 return;
 761         }
 762 }
 763
 764 static void notify_system_time(struct spoolss_notify_msg *msg,
 765                                struct spoolss_Notify *data,
 766                                TALLOC_CTX *mem_ctx)
 767 {
 768         data->data.string.string = NULL;
 769         data->data.string.size = 0;
 770
 771         if (msg->len != sizeof(time_t)) {
 772                 DEBUG(5, ("notify_system_time: received wrong sized message (%d)\n",
 773                           msg->len));
 774                 return;
 775         }
 776
 777         init_systemtime_buffer(mem_ctx, gmtime((time_t *)msg->notify.data),
 778                                &data->data.string.string,
 779                                &data->data.string.size);
 780 }
 781
 782 struct notify2_message_table {
 783         const char *name;
 784         void (*fn)(struct spoolss_notify_msg *msg,
 785                    struct spoolss_Notify *data, TALLOC_CTX *mem_ctx);
 786 };
 787
 788 static struct notify2_message_table printer_notify_table[] = {
 789         /* 0x00 */ { "PRINTER_NOTIFY_FIELD_SERVER_NAME", notify_string },
 790         /* 0x01 */ { "PRINTER_NOTIFY_FIELD_PRINTER_NAME", notify_string },
 791         /* 0x02 */ { "PRINTER_NOTIFY_FIELD_SHARE_NAME", notify_string },
 792         /* 0x03 */ { "PRINTER_NOTIFY_FIELD_PORT_NAME", notify_string },
 793         /* 0x04 */ { "PRINTER_NOTIFY_FIELD_DRIVER_NAME", notify_string },
 794         /* 0x05 */ { "PRINTER_NOTIFY_FIELD_COMMENT", notify_string },
 795         /* 0x06 */ { "PRINTER_NOTIFY_FIELD_LOCATION", notify_string },
 796         /* 0x07 */ { "PRINTER_NOTIFY_FIELD_DEVMODE", NULL },
 797         /* 0x08 */ { "PRINTER_NOTIFY_FIELD_SEPFILE", notify_string },
 798         /* 0x09 */ { "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR", notify_string },
 799         /* 0x0a */ { "PRINTER_NOTIFY_FIELD_PARAMETERS", NULL },
 800         /* 0x0b */ { "PRINTER_NOTIFY_FIELD_DATATYPE", notify_string },
 801         /* 0x0c */ { "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NULL },
 802         /* 0x0d */ { "PRINTER_NOTIFY_FIELD_ATTRIBUTES", notify_one_value },
 803         /* 0x0e */ { "PRINTER_NOTIFY_FIELD_PRIORITY", notify_one_value },
 804         /* 0x0f */ { "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY", NULL },
 805         /* 0x10 */ { "PRINTER_NOTIFY_FIELD_START_TIME", NULL },
 806         /* 0x11 */ { "PRINTER_NOTIFY_FIELD_UNTIL_TIME", NULL },
 807         /* 0x12 */ { "PRINTER_NOTIFY_FIELD_STATUS", notify_one_value },
 808 };
 809
 810 static struct notify2_message_table job_notify_table[] = {
 811         /* 0x00 */ { "JOB_NOTIFY_FIELD_PRINTER_NAME", NULL },
 812         /* 0x01 */ { "JOB_NOTIFY_FIELD_MACHINE_NAME", NULL },
 813         /* 0x02 */ { "JOB_NOTIFY_FIELD_PORT_NAME", NULL },
 814         /* 0x03 */ { "JOB_NOTIFY_FIELD_USER_NAME", notify_string },
 815         /* 0x04 */ { "JOB_NOTIFY_FIELD_NOTIFY_NAME", NULL },
 816         /* 0x05 */ { "JOB_NOTIFY_FIELD_DATATYPE", NULL },
 817         /* 0x06 */ { "JOB_NOTIFY_FIELD_PRINT_PROCESSOR", NULL },
 818         /* 0x07 */ { "JOB_NOTIFY_FIELD_PARAMETERS", NULL },
 819         /* 0x08 */ { "JOB_NOTIFY_FIELD_DRIVER_NAME", NULL },
 820         /* 0x09 */ { "JOB_NOTIFY_FIELD_DEVMODE", NULL },
 821         /* 0x0a */ { "JOB_NOTIFY_FIELD_STATUS", notify_one_value },
 822         /* 0x0b */ { "JOB_NOTIFY_FIELD_STATUS_STRING", NULL },
 823         /* 0x0c */ { "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NULL },
 824         /* 0x0d */ { "JOB_NOTIFY_FIELD_DOCUMENT", notify_string },
 825         /* 0x0e */ { "JOB_NOTIFY_FIELD_PRIORITY", NULL },
 826         /* 0x0f */ { "JOB_NOTIFY_FIELD_POSITION", NULL },
 827         /* 0x10 */ { "JOB_NOTIFY_FIELD_SUBMITTED", notify_system_time },
 828         /* 0x11 */ { "JOB_NOTIFY_FIELD_START_TIME", NULL },
 829         /* 0x12 */ { "JOB_NOTIFY_FIELD_UNTIL_TIME", NULL },
 830         /* 0x13 */ { "JOB_NOTIFY_FIELD_TIME", NULL },
 831         /* 0x14 */ { "JOB_NOTIFY_FIELD_TOTAL_PAGES", notify_one_value },
 832         /* 0x15 */ { "JOB_NOTIFY_FIELD_PAGES_PRINTED", NULL },
 833         /* 0x16 */ { "JOB_NOTIFY_FIELD_TOTAL_BYTES", notify_one_value },
 834         /* 0x17 */ { "JOB_NOTIFY_FIELD_BYTES_PRINTED", NULL },
 835 };
 836
 837
 838 /***********************************************************************
 839  Allocate talloc context for container object
 840  **********************************************************************/
 841
 842 static void notify_msg_ctr_init( SPOOLSS_NOTIFY_MSG_CTR *ctr )
 843 {
 844         if ( !ctr )
 845                 return;
 846
 847         ctr->ctx = talloc_init("notify_msg_ctr_init %p", ctr);
 848
 849         return;
 850 }
 851
 852 /***********************************************************************
 853  release all allocated memory and zero out structure
 854  **********************************************************************/
 855
 856 static void notify_msg_ctr_destroy( SPOOLSS_NOTIFY_MSG_CTR *ctr )
 857 {
 858         if ( !ctr )
 859                 return;
 860
 861         if ( ctr->ctx )
 862                 talloc_destroy(ctr->ctx);
 863
 864         ZERO_STRUCTP(ctr);
 865
 866         return;
 867 }
 868
 869 /***********************************************************************
 870  **********************************************************************/
 871
 872 static TALLOC_CTX* notify_ctr_getctx( SPOOLSS_NOTIFY_MSG_CTR *ctr )
 873 {
 874         if ( !ctr )
 875                 return NULL;
 876
 877         return ctr->ctx;
 878 }
 879
 880 /***********************************************************************
 881  **********************************************************************/
 882
 883 static SPOOLSS_NOTIFY_MSG_GROUP* notify_ctr_getgroup( SPOOLSS_NOTIFY_MSG_CTR *ctr, uint32_t idx )
 884 {
 885         if ( !ctr || !ctr->msg_groups )
 886                 return NULL;
 887
 888         if ( idx >= ctr->num_groups )
 889                 return NULL;
 890
 891         return &ctr->msg_groups[idx];
 892
 893 }
 894
 895 /***********************************************************************
 896  How many groups of change messages do we have ?
 897  **********************************************************************/
 898
 899 static int notify_msg_ctr_numgroups( SPOOLSS_NOTIFY_MSG_CTR *ctr )
 900 {
 901         if ( !ctr )
 902                 return 0;
 903
 904         return ctr->num_groups;
 905 }
 906
 907 /***********************************************************************
 908  Add a SPOOLSS_NOTIFY_MSG_CTR to the correct group
 909  **********************************************************************/
 910
 911 static int notify_msg_ctr_addmsg( SPOOLSS_NOTIFY_MSG_CTR *ctr, SPOOLSS_NOTIFY_MSG *msg )
 912 {
 913         SPOOLSS_NOTIFY_MSG_GROUP        *groups = NULL;
 914         SPOOLSS_NOTIFY_MSG_GROUP        *msg_grp = NULL;
 915         SPOOLSS_NOTIFY_MSG              *msg_list = NULL;
 916         int                             i, new_slot;
 917
 918         if ( !ctr || !msg )
 919                 return 0;
 920
 921         /* loop over all groups looking for a matching printer name */
 922
 923         for ( i=0; i<ctr->num_groups; i++ ) {
 924                 if ( strcmp(ctr->msg_groups[i].printername, msg->printer) == 0 )
 925                         break;
 926         }
 927
 928         /* add a new group? */
 929
 930         if ( i == ctr->num_groups ) {
 931                 ctr->num_groups++;
 932
 933                 if ( !(groups = TALLOC_REALLOC_ARRAY( ctr->ctx, ctr->msg_groups, SPOOLSS_NOTIFY_MSG_GROUP, ctr->num_groups)) ) {
 934                         DEBUG(0,("notify_msg_ctr_addmsg: talloc_realloc() failed!\n"));
 935                         return 0;
 936                 }
 937                 ctr->msg_groups = groups;
 938
 939                 /* clear the new entry and set the printer name */
 940
 941                 ZERO_STRUCT( ctr->msg_groups[ctr->num_groups-1] );
 942                 fstrcpy( ctr->msg_groups[ctr->num_groups-1].printername, msg->printer );
 943         }
 944
 945         /* add the change messages; 'i' is the correct index now regardless */
 946
 947         msg_grp = &ctr->msg_groups[i];
 948
 949         msg_grp->num_msgs++;
 950
 951         if ( !(msg_list = TALLOC_REALLOC_ARRAY( ctr->ctx, msg_grp->msgs, SPOOLSS_NOTIFY_MSG, msg_grp->num_msgs )) ) {
 952                 DEBUG(0,("notify_msg_ctr_addmsg: talloc_realloc() failed for new message [%d]!\n", msg_grp->num_msgs));
 953                 return 0;
 954         }
 955         msg_grp->msgs = msg_list;
 956
 957         new_slot = msg_grp->num_msgs-1;
 958         memcpy( &msg_grp->msgs[new_slot], msg, sizeof(SPOOLSS_NOTIFY_MSG) );
 959
 960         /* need to allocate own copy of data */
 961
 962         if ( msg->len != 0 )
 963                 msg_grp->msgs[new_slot].notify.data = (char *)
 964                         TALLOC_MEMDUP( ctr->ctx, msg->notify.data, msg->len );
 965
 966         return ctr->num_groups;
 967 }
 968
 969 static void construct_info_data(struct spoolss_Notify *info_data,
 970                                 enum spoolss_NotifyType type,
 971                                 uint16_t field, int id);
 972
 973 /***********************************************************************
 974  Send a change notication message on all handles which have a call
 975  back registered
 976  **********************************************************************/
 977
 978 static void send_notify2_changes( SPOOLSS_NOTIFY_MSG_CTR *ctr, uint32_t idx )
 979 {
 980         Printer_entry            *p;
 981         TALLOC_CTX               *mem_ctx = notify_ctr_getctx( ctr );
 982         SPOOLSS_NOTIFY_MSG_GROUP *msg_group = notify_ctr_getgroup( ctr, idx );
 983         SPOOLSS_NOTIFY_MSG       *messages;
 984         int                      sending_msg_count;
 985
 986         if ( !msg_group ) {
 987                 DEBUG(5,("send_notify2_changes() called with no msg group!\n"));
 988                 return;
 989         }
 990
 991         messages = msg_group->msgs;
 992
 993         if ( !messages ) {
 994                 DEBUG(5,("send_notify2_changes() called with no messages!\n"));
 995                 return;
 996         }
 997
 998         DEBUG(8,("send_notify2_changes: Enter...[%s]\n", msg_group->printername));
 999
1000         /* loop over all printers */
1001
1002         for (p = printers_list; p; p = p->next) {
1003                 struct spoolss_Notify *notifies;
1004                 uint32_t count = 0;
1005                 uint32_t id;
1006                 int     i;
1007
1008                 /* Is there notification on this handle? */
1009
1010                 if ( !p->notify.client_connected )
1011                         continue;
1012
1013                 DEBUG(10,("Client connected! [\\\\%s\\%s]\n", p->servername, p->sharename));
1014
1015                 /* For this printer?  Print servers always receive
1016                    notifications. */
1017
1018                 if ( ( p->printer_type == SPLHND_PRINTER )  &&
1019                     ( !strequal(msg_group->printername, p->sharename) ) )
1020                         continue;
1021
1022                 DEBUG(10,("Our printer\n"));
1023
1024                 /* allocate the max entries possible */
1025
1026                 notifies = TALLOC_ZERO_ARRAY(mem_ctx, struct spoolss_Notify, msg_group->num_msgs);
1027                 if (!notifies) {
1028                         return;
1029                 }
1030
1031                 /* build the array of change notifications */
1032
1033                 sending_msg_count = 0;
1034
1035                 for ( i=0; i<msg_group->num_msgs; i++ ) {
1036                         SPOOLSS_NOTIFY_MSG      *msg = &messages[i];
1037
1038                         /* Are we monitoring this event? */
1039
1040                         if (!is_monitoring_event(p, msg->type, msg->field))
1041                                 continue;
1042
1043                         sending_msg_count++;
1044
1045
1046                         DEBUG(10,("process_notify2_message: Sending message type [0x%x] field [0x%2x] for printer [%s]\n",
1047                                 msg->type, msg->field, p->sharename));
1048
1049                         /*
1050                          * if the is a printer notification handle and not a job notification
1051                          * type, then set the id to 0.  Other wise just use what was specified
1052                          * in the message.
1053                          *
1054                          * When registering change notification on a print server handle
1055                          * we always need to send back the id (snum) matching the printer
1056                          * for which the change took place.  For change notify registered
1057                          * on a printer handle, this does not matter and the id should be 0.
1058                          *
1059                          * --jerry
1060                          */
1061
1062                         if ( ( p->printer_type == SPLHND_PRINTER ) && ( msg->type == PRINTER_NOTIFY_TYPE ) )
1063                                 id = 0;
1064                         else
1065                                 id = msg->id;
1066
1067
1068                         /* Convert unix jobid to smb jobid */
1069
1070                         if (msg->flags & SPOOLSS_NOTIFY_MSG_UNIX_JOBID) {
1071                                 id = sysjob_to_jobid(msg->id);
1072
1073                                 if (id == -1) {
1074                                         DEBUG(3, ("no such unix jobid %d\n", msg->id));
1075                                         goto done;
1076                                 }
1077                         }
1078
1079                         construct_info_data( &notifies[count], msg->type, msg->field, id );
1080
1081                         switch(msg->type) {
1082                         case PRINTER_NOTIFY_TYPE:
1083                                 if ( printer_notify_table[msg->field].fn )
1084                                         printer_notify_table[msg->field].fn(msg, &notifies[count], mem_ctx);
1085                                 break;
1086
1087                         case JOB_NOTIFY_TYPE:
1088                                 if ( job_notify_table[msg->field].fn )
1089                                         job_notify_table[msg->field].fn(msg, &notifies[count], mem_ctx);
1090                                 break;
1091
1092                         default:
1093                                 DEBUG(5, ("Unknown notification type %d\n", msg->type));
1094                                 goto done;
1095                         }
1096
1097                         count++;
1098                 }
1099
1100                 if ( sending_msg_count ) {
1101                         NTSTATUS status;
1102                         WERROR werr;
1103                         union spoolss_ReplyPrinterInfo info;
1104                         struct spoolss_NotifyInfo info0;
1105                         uint32_t reply_result;
1106
1107                         info0.version   = 0x2;
1108                         info0.flags     = count ? 0x00020000 /* ??? */ : PRINTER_NOTIFY_INFO_DISCARDED;
1109                         info0.count     = count;
1110                         info0.notifies  = notifies;
1111
1112                         info.info0 = &info0;
1113
1114                         status = rpccli_spoolss_RouterReplyPrinterEx(notify_cli_pipe, mem_ctx,
1115                                                                      &p->notify.client_hnd,
1116                                                                      p->notify.change, /* color */
1117                                                                      p->notify.flags,
1118                                                                      &reply_result,
1119                                                                      0, /* reply_type, must be 0 */
1120                                                                      info,
1121                                                                      &werr);
1122                         if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(werr)) {
1123                                 DEBUG(1,("RouterReplyPrinterEx to client: %s failed: %s\n",
1124                                         notify_cli_pipe->srv_name_slash,
1125                                         win_errstr(werr)));
1126                         }
1127                         switch (reply_result) {
1128                                 case 0:
1129                                         break;
1130                                 case PRINTER_NOTIFY_INFO_DISCARDED:
1131                                 case PRINTER_NOTIFY_INFO_DISCARDNOTED:
1132                                 case PRINTER_NOTIFY_INFO_COLOR_MISMATCH:
1133                                         break;
1134                                 default:
1135                                         break;
1136                         }
1137                 }
1138         }
1139
1140 done:
1141         DEBUG(8,("send_notify2_changes: Exit...\n"));
1142         return;
1143 }
1144
1145 /***********************************************************************
1146  **********************************************************************/
1147
1148 static bool notify2_unpack_msg( SPOOLSS_NOTIFY_MSG *msg, struct timeval *tv, void *buf, size_t len )
1149 {
1150
1151         uint32_t tv_sec, tv_usec;
1152         size_t offset = 0;
1153
1154         /* Unpack message */
1155
1156         offset += tdb_unpack((uint8_t *)buf + offset, len - offset, "f",
1157                              msg->printer);
1158
1159         offset += tdb_unpack((uint8_t *)buf + offset, len - offset, "ddddddd",
1160                                 &tv_sec, &tv_usec,
1161                                 &msg->type, &msg->field, &msg->id, &msg->len, &msg->flags);
1162
1163         if (msg->len == 0)
1164                 tdb_unpack((uint8_t *)buf + offset, len - offset, "dd",
1165                            &msg->notify.value[0], &msg->notify.value[1]);
1166         else
1167                 tdb_unpack((uint8_t *)buf + offset, len - offset, "B",
1168                            &msg->len, &msg->notify.data);
1169
1170         DEBUG(3, ("notify2_unpack_msg: got NOTIFY2 message for printer %s, jobid %u type %d, field 0x%02x, flags 0x%04x\n",
1171                   msg->printer, (unsigned int)msg->id, msg->type, msg->field, msg->flags));
1172
1173         tv->tv_sec = tv_sec;
1174         tv->tv_usec = tv_usec;
1175
1176         if (msg->len == 0)
1177                 DEBUG(3, ("notify2_unpack_msg: value1 = %d, value2 = %d\n", msg->notify.value[0],
1178                           msg->notify.value[1]));
1179         else
1180                 dump_data(3, (uint8_t *)msg->notify.data, msg->len);
1181
1182         return true;
1183 }
1184
1185 /********************************************************************
1186  Receive a notify2 message list
1187  ********************************************************************/
1188
1189 static void receive_notify2_message_list(struct messaging_context *msg,
1190                                          void *private_data,
1191                                          uint32_t msg_type,
1192                                          struct server_id server_id,
1193                                          DATA_BLOB *data)
1194 {
1195         size_t                  msg_count, i;
1196         char                    *buf = (char *)data->data;
1197         char                    *msg_ptr;
1198         size_t                  msg_len;
1199         SPOOLSS_NOTIFY_MSG      notify;
1200         SPOOLSS_NOTIFY_MSG_CTR  messages;
1201         int                     num_groups;
1202
1203         if (data->length < 4) {
1204                 DEBUG(0,("receive_notify2_message_list: bad message format (len < 4)!\n"));
1205                 return;
1206         }
1207
1208         msg_count = IVAL(buf, 0);
1209         msg_ptr = buf + 4;
1210
1211         DEBUG(5, ("receive_notify2_message_list: got %lu messages in list\n", (unsigned long)msg_count));
1212
1213         if (msg_count == 0) {
1214                 DEBUG(0,("receive_notify2_message_list: bad message format (msg_count == 0) !\n"));
1215                 return;
1216         }
1217
1218         /* initialize the container */
1219
1220         ZERO_STRUCT( messages );
1221         notify_msg_ctr_init( &messages );
1222
1223         /*
1224          * build message groups for each printer identified
1225          * in a change_notify msg.  Remember that a PCN message
1226          * includes the handle returned for the srv_spoolss_replyopenprinter()
1227          * call.  Therefore messages are grouped according to printer handle.
1228          */
1229
1230         for ( i=0; i<msg_count; i++ ) {
1231                 struct timeval msg_tv;
1232
1233                 if (msg_ptr + 4 - buf > data->length) {
1234                         DEBUG(0,("receive_notify2_message_list: bad message format (len > buf_size) !\n"));
1235                         return;
1236                 }
1237
1238                 msg_len = IVAL(msg_ptr,0);
1239                 msg_ptr += 4;
1240
1241                 if (msg_ptr + msg_len - buf > data->length) {
1242                         DEBUG(0,("receive_notify2_message_list: bad message format (bad len) !\n"));
1243                         return;
1244                 }
1245
1246                 /* unpack messages */
1247
1248                 ZERO_STRUCT( notify );
1249                 notify2_unpack_msg( &notify, &msg_tv, msg_ptr, msg_len );
1250                 msg_ptr += msg_len;
1251
1252                 /* add to correct list in container */
1253
1254                 notify_msg_ctr_addmsg( &messages, &notify );
1255
1256                 /* free memory that might have been allocated by notify2_unpack_msg() */
1257
1258                 if ( notify.len != 0 )
1259                         SAFE_FREE( notify.notify.data );
1260         }
1261
1262         /* process each group of messages */
1263
1264         num_groups = notify_msg_ctr_numgroups( &messages );
1265         for ( i=0; i<num_groups; i++ )
1266                 send_notify2_changes( &messages, i );
1267
1268
1269         /* cleanup */
1270
1271         DEBUG(10,("receive_notify2_message_list: processed %u messages\n",
1272                 (uint32_t)msg_count ));
1273
1274         notify_msg_ctr_destroy( &messages );
1275
1276         return;
1277 }
1278
1279 /********************************************************************
1280  Send a message to ourself about new driver being installed
1281  so we can upgrade the information for each printer bound to this
1282  driver
1283  ********************************************************************/
1284
1285 static bool srv_spoolss_drv_upgrade_printer(const char *drivername,
1286                                             struct messaging_context *msg_ctx)
1287 {
1288         int len = strlen(drivername);
1289
1290         if (!len)
1291                 return false;
1292
1293         DEBUG(10,("srv_spoolss_drv_upgrade_printer: Sending message about driver upgrade [%s]\n",
1294                 drivername));
1295
1296         messaging_send_buf(msg_ctx, messaging_server_id(msg_ctx),
1297                            MSG_PRINTER_DRVUPGRADE,
1298                            (uint8_t *)drivername, len+1);
1299
1300         return true;
1301 }
1302
1303 /**********************************************************************
1304  callback to receive a MSG_PRINTER_DRVUPGRADE message and interate
1305  over all printers, upgrading ones as necessary
1306  **********************************************************************/
1307
1308 void do_drv_upgrade_printer(struct messaging_context *msg,
1309                             void *private_data,
1310                             uint32_t msg_type,
1311                             struct server_id server_id,
1312                             DATA_BLOB *data)
1313 {
1314         TALLOC_CTX *tmp_ctx;
1315         struct auth_serversupplied_info *server_info = NULL;
1316         struct spoolss_PrinterInfo2 *pinfo2;
1317         NTSTATUS status;
1318         WERROR result;
1319         const char *drivername;
1320         int snum;
1321         int n_services = lp_numservices();
1322         size_t len;
1323
1324         tmp_ctx = talloc_new(NULL);
1325         if (!tmp_ctx) return;
1326
1327         status = make_server_info_system(tmp_ctx, &server_info);
1328         if (!NT_STATUS_IS_OK(status)) {
1329                 DEBUG(0, ("do_drv_upgrade_printer: "
1330                           "Could not create system server_info\n"));
1331                 goto done;
1332         }
1333
1334         len = MIN(data->length,sizeof(drivername)-1);
1335         drivername = talloc_strndup(tmp_ctx, (const char *)data->data, len);
1336         if (!drivername) {
1337                 DEBUG(0, ("do_drv_upgrade_printer: Out of memoery ?!\n"));
1338                 goto done;
1339         }
1340
1341         DEBUG(10, ("do_drv_upgrade_printer: "
1342                    "Got message for new driver [%s]\n", drivername));
1343
1344         /* Iterate the printer list */
1345
1346         for (snum = 0; snum < n_services; snum++) {
1347                 if (!lp_snum_ok(snum) || !lp_print_ok(snum)) {
1348                         continue;
1349                 }
1350
1351                 result = winreg_get_printer(tmp_ctx, server_info, msg,
1352                                             NULL,
1353                                             lp_const_servicename(snum),
1354                                             &pinfo2);
1355
1356                 if (!W_ERROR_IS_OK(result)) {
1357                         continue;
1358                 }
1359
1360                 if (!pinfo2->drivername) {
1361                         continue;
1362                 }
1363
1364                 if (strcmp(drivername, pinfo2->drivername) != 0) {
1365                         continue;
1366                 }
1367
1368                 DEBUG(6,("Updating printer [%s]\n", pinfo2->printername));
1369
1370                 /* all we care about currently is the change_id */
1371                 result = winreg_printer_update_changeid(tmp_ctx,
1372                                                         server_info,
1373                                                         msg,
1374                                                         pinfo2->printername);
1375
1376                 if (!W_ERROR_IS_OK(result)) {
1377                         DEBUG(3, ("do_drv_upgrade_printer: "
1378                                   "Failed to update changeid [%s]\n",
1379                                   win_errstr(result)));
1380                 }
1381         }
1382
1383         /* all done */
1384 done:
1385         talloc_free(tmp_ctx);
1386 }
1387
1388 /********************************************************************
1389  Update the cache for all printq's with a registered client
1390  connection
1391  ********************************************************************/
1392
1393 void update_monitored_printq_cache( void )
1394 {
1395         Printer_entry *printer = printers_list;
1396         int snum;
1397
1398         /* loop through all printers and update the cache where
1399            client_connected == true */
1400         while ( printer )
1401         {
1402                 if ( (printer->printer_type == SPLHND_PRINTER)
1403                         && printer->notify.client_connected )
1404                 {
1405                         snum = print_queue_snum(printer->sharename);
1406                         print_queue_status( snum, NULL, NULL );
1407                 }
1408
1409                 printer = printer->next;
1410         }
1411
1412         return;
1413 }
1414
1415 /****************************************************************
1416  _spoolss_OpenPrinter
1417 ****************************************************************/
1418
1419 WERROR _spoolss_OpenPrinter(struct pipes_struct *p,
1420                             struct spoolss_OpenPrinter *r)
1421 {
1422         struct spoolss_OpenPrinterEx e;
1423         WERROR werr;
1424
1425         ZERO_STRUCT(e.in.userlevel);
1426
1427         e.in.printername        = r->in.printername;
1428         e.in.datatype           = r->in.datatype;
1429         e.in.devmode_ctr        = r->in.devmode_ctr;
1430         e.in.access_mask        = r->in.access_mask;
1431         e.in.level              = 0;
1432
1433         e.out.handle            = r->out.handle;
1434
1435         werr = _spoolss_OpenPrinterEx(p, &e);
1436
1437         if (W_ERROR_EQUAL(werr, WERR_INVALID_PARAM)) {
1438                 /* OpenPrinterEx returns this for a bad
1439                  * printer name. We must return WERR_INVALID_PRINTER_NAME
1440                  * instead.
1441                  */
1442                 werr = WERR_INVALID_PRINTER_NAME;
1443         }
1444
1445         return werr;
1446 }
1447
1448 static WERROR copy_devicemode(TALLOC_CTX *mem_ctx,
1449                               struct spoolss_DeviceMode *orig,
1450                               struct spoolss_DeviceMode **dest)
1451 {
1452         struct spoolss_DeviceMode *dm;
1453
1454         dm = talloc(mem_ctx, struct spoolss_DeviceMode);
1455         if (!dm) {
1456                 return WERR_NOMEM;
1457         }
1458
1459         /* copy all values, then duplicate strings and structs */
1460         *dm = *orig;
1461
1462         dm->devicename = talloc_strdup(dm, orig->devicename);
1463         if (!dm->devicename) {
1464                 return WERR_NOMEM;
1465         }
1466         dm->formname = talloc_strdup(dm, orig->formname);
1467         if (!dm->formname) {
1468                 return WERR_NOMEM;
1469         }
1470         if (orig->driverextra_data.data) {
1471                 dm->driverextra_data.data =
1472                         (uint8_t *) talloc_memdup(dm, orig->driverextra_data.data,
1473                                         orig->driverextra_data.length);
1474                 if (!dm->driverextra_data.data) {
1475                         return WERR_NOMEM;
1476                 }
1477         }
1478
1479         *dest = dm;
1480         return WERR_OK;
1481 }
1482
1483 /****************************************************************
1484  _spoolss_OpenPrinterEx
1485 ****************************************************************/
1486
1487 WERROR _spoolss_OpenPrinterEx(struct pipes_struct *p,
1488                               struct spoolss_OpenPrinterEx *r)
1489 {
1490         int snum;
1491         Printer_entry *Printer=NULL;
1492
1493         if (!r->in.printername) {
1494                 return WERR_INVALID_PARAM;
1495         }
1496
1497         /* some sanity check because you can open a printer or a print server */
1498         /* aka: \\server\printer or \\server */
1499
1500         DEBUGADD(3,("checking name: %s\n", r->in.printername));
1501
1502         if (!open_printer_hnd(p, r->out.handle, r->in.printername, 0)) {
1503                 DEBUG(0,("_spoolss_OpenPrinterEx: Cannot open a printer handle "
1504                         " for printer %s\n", r->in.printername));
1505                 ZERO_STRUCTP(r->out.handle);
1506                 return WERR_INVALID_PARAM;
1507         }
1508
1509         Printer = find_printer_index_by_hnd(p, r->out.handle);
1510         if ( !Printer ) {
1511                 DEBUG(0,("_spoolss_OpenPrinterEx: logic error.  Can't find printer "
1512                         "handle we created for printer %s\n", r->in.printername));
1513                 close_printer_handle(p, r->out.handle);
1514                 ZERO_STRUCTP(r->out.handle);
1515                 return WERR_INVALID_PARAM;
1516         }
1517
1518         /*
1519          * First case: the user is opening the print server:
1520          *
1521          * Disallow MS AddPrinterWizard if parameter disables it. A Win2k
1522          * client 1st tries an OpenPrinterEx with access==0, MUST be allowed.
1523          *
1524          * Then both Win2k and WinNT clients try an OpenPrinterEx with
1525          * SERVER_ALL_ACCESS, which we allow only if the user is root (uid=0)
1526          * or if the user is listed in the smb.conf printer admin parameter.
1527          *
1528          * Then they try OpenPrinterEx with SERVER_READ which we allow. This lets the
1529          * client view printer folder, but does not show the MSAPW.
1530          *
1531          * Note: this test needs code to check access rights here too. Jeremy
1532          * could you look at this?
1533          *
1534          * Second case: the user is opening a printer:
1535          * NT doesn't let us connect to a printer if the connecting user
1536          * doesn't have print permission.
1537          *
1538          * Third case: user is opening a Port Monitor
1539          * access checks same as opening a handle to the print server.
1540          */
1541
1542         switch (Printer->printer_type )
1543         {
1544         case SPLHND_SERVER:
1545         case SPLHND_PORTMON_TCP:
1546         case SPLHND_PORTMON_LOCAL:
1547                 /* Printserver handles use global struct... */
1548
1549                 snum = -1;
1550
1551                 /* Map standard access rights to object specific access rights */
1552
1553                 se_map_standard(&r->in.access_mask,
1554                                 &printserver_std_mapping);
1555
1556                 /* Deny any object specific bits that don't apply to print
1557                    servers (i.e printer and job specific bits) */
1558
1559                 r->in.access_mask &= SEC_MASK_SPECIFIC;
1560
1561                 if (r->in.access_mask &
1562                     ~(SERVER_ACCESS_ADMINISTER | SERVER_ACCESS_ENUMERATE)) {
1563                         DEBUG(3, ("access DENIED for non-printserver bits\n"));
1564                         close_printer_handle(p, r->out.handle);
1565                         ZERO_STRUCTP(r->out.handle);
1566                         return WERR_ACCESS_DENIED;
1567                 }
1568
1569                 /* Allow admin access */
1570
1571                 if ( r->in.access_mask & SERVER_ACCESS_ADMINISTER )
1572                 {
1573                         SE_PRIV se_printop = SE_PRINT_OPERATOR;
1574
1575                         if (!lp_ms_add_printer_wizard()) {
1576                                 close_printer_handle(p, r->out.handle);
1577                                 ZERO_STRUCTP(r->out.handle);
1578                                 return WERR_ACCESS_DENIED;
1579                         }
1580
1581                         /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
1582                            and not a printer admin, then fail */
1583
1584                         if ((p->server_info->utok.uid != sec_initial_uid()) &&
1585                             !user_has_privileges(p->server_info->ptok,
1586                                                  &se_printop ) &&
1587                             !token_contains_name_in_list(
1588                                     uidtoname(p->server_info->utok.uid),
1589                                     p->server_info->info3->base.domain.string,
1590                                     NULL,
1591                                     p->server_info->ptok,
1592                                     lp_printer_admin(snum))) {
1593                                 close_printer_handle(p, r->out.handle);
1594                                 ZERO_STRUCTP(r->out.handle);
1595                                 return WERR_ACCESS_DENIED;
1596                         }
1597
1598                         r->in.access_mask = SERVER_ACCESS_ADMINISTER;
1599                 }
1600                 else
1601                 {
1602                         r->in.access_mask = SERVER_ACCESS_ENUMERATE;
1603                 }
1604
1605                 DEBUG(4,("Setting print server access = %s\n", (r->in.access_mask == SERVER_ACCESS_ADMINISTER)
1606                         ? "SERVER_ACCESS_ADMINISTER" : "SERVER_ACCESS_ENUMERATE" ));
1607
1608                 /* We fall through to return WERR_OK */
1609                 break;
1610
1611         case SPLHND_PRINTER:
1612                 /* NT doesn't let us connect to a printer if the connecting user
1613                    doesn't have print permission.  */
1614
1615                 if (!get_printer_snum(p, r->out.handle, &snum, NULL)) {
1616                         close_printer_handle(p, r->out.handle);
1617                         ZERO_STRUCTP(r->out.handle);
1618                         return WERR_BADFID;
1619                 }
1620
1621                 if (r->in.access_mask == SEC_FLAG_MAXIMUM_ALLOWED) {
1622                         r->in.access_mask = PRINTER_ACCESS_ADMINISTER;
1623                 }
1624
1625                 se_map_standard(&r->in.access_mask, &printer_std_mapping);
1626
1627                 /* map an empty access mask to the minimum access mask */
1628                 if (r->in.access_mask == 0x0)
1629                         r->in.access_mask = PRINTER_ACCESS_USE;
1630
1631                 /*
1632                  * If we are not serving the printer driver for this printer,
1633                  * map PRINTER_ACCESS_ADMINISTER to PRINTER_ACCESS_USE.  This
1634                  * will keep NT clients happy  --jerry
1635                  */
1636
1637                 if (lp_use_client_driver(snum)
1638                         && (r->in.access_mask & PRINTER_ACCESS_ADMINISTER))
1639                 {
1640                         r->in.access_mask = PRINTER_ACCESS_USE;
1641                 }
1642
1643                 /* check smb.conf parameters and the the sec_desc */
1644
1645                 if ( !check_access(get_client_fd(), lp_hostsallow(snum), lp_hostsdeny(snum)) ) {
1646                         DEBUG(3, ("access DENIED (hosts allow/deny) for printer open\n"));
1647                         ZERO_STRUCTP(r->out.handle);
1648                         return WERR_ACCESS_DENIED;
1649                 }
1650
1651                 if (!user_ok_token(uidtoname(p->server_info->utok.uid), NULL,
1652                                    p->server_info->ptok, snum) ||
1653                     !print_access_check(p->server_info, snum,
1654                                         r->in.access_mask)) {
1655                         DEBUG(3, ("access DENIED for printer open\n"));
1656                         close_printer_handle(p, r->out.handle);
1657                         ZERO_STRUCTP(r->out.handle);
1658                         return WERR_ACCESS_DENIED;
1659                 }
1660
1661                 if ((r->in.access_mask & SEC_MASK_SPECIFIC)& ~(PRINTER_ACCESS_ADMINISTER|PRINTER_ACCESS_USE)) {
1662                         DEBUG(3, ("access DENIED for printer open - unknown bits\n"));
1663                         close_printer_handle(p, r->out.handle);
1664                         ZERO_STRUCTP(r->out.handle);
1665                         return WERR_ACCESS_DENIED;
1666                 }
1667
1668                 if (r->in.access_mask & PRINTER_ACCESS_ADMINISTER)
1669                         r->in.access_mask = PRINTER_ACCESS_ADMINISTER;
1670                 else
1671                         r->in.access_mask = PRINTER_ACCESS_USE;
1672
1673                 DEBUG(4,("Setting printer access = %s\n", (r->in.access_mask == PRINTER_ACCESS_ADMINISTER)
1674                         ? "PRINTER_ACCESS_ADMINISTER" : "PRINTER_ACCESS_USE" ));
1675
1676                 winreg_create_printer(p->mem_ctx,
1677                                       p->server_info,
1678                                       p->msg_ctx,
1679                                       Printer->servername,
1680                                       lp_const_servicename(snum));
1681
1682                 break;
1683
1684         default:
1685                 /* sanity check to prevent programmer error */
1686                 ZERO_STRUCTP(r->out.handle);
1687                 return WERR_BADFID;
1688         }
1689
1690         Printer->access_granted = r->in.access_mask;
1691
1692         /*
1693          * If the client sent a devmode in the OpenPrinter() call, then
1694          * save it here in case we get a job submission on this handle
1695          */
1696
1697          if ((Printer->printer_type != SPLHND_SERVER) &&
1698              r->in.devmode_ctr.devmode) {
1699                 copy_devicemode(NULL, r->in.devmode_ctr.devmode,
1700                                 &Printer->devmode);
1701          }
1702
1703 #if 0   /* JERRY -- I'm doubtful this is really effective */
1704         /* HACK ALERT!!! Sleep for 1/3 of a second to try trigger a LAN/WAN
1705            optimization in Windows 2000 clients  --jerry */
1706
1707         if ( (r->in.access_mask == PRINTER_ACCESS_ADMINISTER)
1708                 && (RA_WIN2K == get_remote_arch()) )
1709         {
1710                 DEBUG(10,("_spoolss_OpenPrinterEx: Enabling LAN/WAN hack for Win2k clients.\n"));
1711                 sys_usleep( 500000 );
1712         }
1713 #endif
1714
1715         return WERR_OK;
1716 }
1717
1718 /****************************************************************
1719  _spoolss_ClosePrinter
1720 ****************************************************************/
1721
1722 WERROR _spoolss_ClosePrinter(struct pipes_struct *p,
1723                              struct spoolss_ClosePrinter *r)
1724 {
1725         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
1726
1727         if (Printer && Printer->document_started) {
1728                 struct spoolss_EndDocPrinter e;
1729
1730                 e.in.handle = r->in.handle;
1731
1732                 _spoolss_EndDocPrinter(p, &e);
1733         }
1734
1735         if (!close_printer_handle(p, r->in.handle))
1736                 return WERR_BADFID;
1737
1738         /* clear the returned printer handle.  Observed behavior
1739            from Win2k server.  Don't think this really matters.
1740            Previous code just copied the value of the closed
1741            handle.    --jerry */
1742
1743         ZERO_STRUCTP(r->out.handle);
1744
1745         return WERR_OK;
1746 }
1747
1748 /****************************************************************
1749  _spoolss_DeletePrinter
1750 ****************************************************************/
1751
1752 WERROR _spoolss_DeletePrinter(struct pipes_struct *p,
1753                               struct spoolss_DeletePrinter *r)
1754 {
1755         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
1756         WERROR result;
1757         int snum;
1758
1759         if (Printer && Printer->document_started) {
1760                 struct spoolss_EndDocPrinter e;
1761
1762                 e.in.handle = r->in.handle;
1763
1764                 _spoolss_EndDocPrinter(p, &e);
1765         }
1766
1767         if (get_printer_snum(p, r->in.handle, &snum, NULL)) {
1768                 winreg_delete_printer_key(p->mem_ctx,
1769                                           p->server_info,
1770                                           p->msg_ctx,
1771                                           lp_const_servicename(snum),
1772                                           "");
1773         }
1774
1775         result = delete_printer_handle(p, r->in.handle);
1776
1777         return result;
1778 }
1779
1780 /*******************************************************************
1781  * static function to lookup the version id corresponding to an
1782  * long architecture string
1783  ******************************************************************/
1784
1785 static const struct print_architecture_table_node archi_table[]= {
1786
1787         {"Windows 4.0",          SPL_ARCH_WIN40,        0 },
1788         {"Windows NT x86",       SPL_ARCH_W32X86,       2 },
1789         {"Windows NT R4000",     SPL_ARCH_W32MIPS,      2 },
1790         {"Windows NT Alpha_AXP", SPL_ARCH_W32ALPHA,     2 },
1791         {"Windows NT PowerPC",   SPL_ARCH_W32PPC,       2 },
1792         {"Windows IA64",         SPL_ARCH_IA64,         3 },
1793         {"Windows x64",          SPL_ARCH_X64,          3 },
1794         {NULL,                   "",            -1 }
1795 };
1796
1797 static int get_version_id(const char *arch)
1798 {
1799         int i;
1800
1801         for (i=0; archi_table[i].long_archi != NULL; i++)
1802         {
1803                 if (strcmp(arch, archi_table[i].long_archi) == 0)
1804                         return (archi_table[i].version);
1805         }
1806
1807         return -1;
1808 }
1809
1810 /****************************************************************
1811  _spoolss_DeletePrinterDriver
1812 ****************************************************************/
1813
1814 WERROR _spoolss_DeletePrinterDriver(struct pipes_struct *p,
1815                                     struct spoolss_DeletePrinterDriver *r)
1816 {
1817
1818         struct spoolss_DriverInfo8 *info = NULL;
1819         struct spoolss_DriverInfo8 *info_win2k = NULL;
1820         int                             version;
1821         WERROR                          status;
1822         SE_PRIV                         se_printop = SE_PRINT_OPERATOR;
1823
1824         /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
1825            and not a printer admin, then fail */
1826
1827         if ( (p->server_info->utok.uid != sec_initial_uid())
1828                 && !user_has_privileges(p->server_info->ptok, &se_printop )
1829                 && !token_contains_name_in_list(
1830                         uidtoname(p->server_info->utok.uid),
1831                         p->server_info->info3->base.domain.string,
1832                         NULL,
1833                         p->server_info->ptok,
1834                         lp_printer_admin(-1)) )
1835         {
1836                 return WERR_ACCESS_DENIED;
1837         }
1838
1839         /* check that we have a valid driver name first */
1840
1841         if ((version = get_version_id(r->in.architecture)) == -1)
1842                 return WERR_INVALID_ENVIRONMENT;
1843
1844         status = winreg_get_driver(p->mem_ctx, p->server_info, p->msg_ctx,
1845                                    r->in.architecture, r->in.driver,
1846                                    version, &info);
1847         if (!W_ERROR_IS_OK(status)) {
1848                 /* try for Win2k driver if "Windows NT x86" */
1849
1850                 if ( version == 2 ) {
1851                         version = 3;
1852
1853                         status = winreg_get_driver(p->mem_ctx, p->server_info,
1854                                                    p->msg_ctx,
1855                                                    r->in.architecture,
1856                                                    r->in.driver,
1857                                                    version, &info);
1858                         if (!W_ERROR_IS_OK(status)) {
1859                                 status = WERR_UNKNOWN_PRINTER_DRIVER;
1860                                 goto done;
1861                         }
1862                 }
1863                 /* otherwise it was a failure */
1864                 else {
1865                         status = WERR_UNKNOWN_PRINTER_DRIVER;
1866                         goto done;
1867                 }
1868
1869         }
1870
1871         if (printer_driver_in_use(p->mem_ctx, p->server_info, info)) {
1872                 status = WERR_PRINTER_DRIVER_IN_USE;
1873                 goto done;
1874         }
1875
1876         if (version == 2) {
1877                 status = winreg_get_driver(p->mem_ctx, p->server_info,
1878                                            p->msg_ctx,
1879                                            r->in.architecture,
1880                                            r->in.driver, 3, &info_win2k);
1881                 if (W_ERROR_IS_OK(status)) {
1882                         /* if we get to here, we now have 2 driver info structures to remove */
1883                         /* remove the Win2k driver first*/
1884
1885                         status = winreg_del_driver(p->mem_ctx,
1886                                                    p->server_info,
1887                                                    p->msg_ctx,
1888                                                    info_win2k, 3);
1889                         talloc_free(info_win2k);
1890
1891                         /* this should not have failed---if it did, report to client */
1892                         if (!W_ERROR_IS_OK(status)) {
1893                                 goto done;
1894                         }
1895                 }
1896         }
1897
1898         status = winreg_del_driver(p->mem_ctx, p->server_info, p->msg_ctx,
1899                                    info, version);
1900
1901 done:
1902         talloc_free(info);
1903
1904         return status;
1905 }
1906
1907 /****************************************************************
1908  _spoolss_DeletePrinterDriverEx
1909 ****************************************************************/
1910
1911 WERROR _spoolss_DeletePrinterDriverEx(struct pipes_struct *p,
1912                                       struct spoolss_DeletePrinterDriverEx *r)
1913 {
1914         struct spoolss_DriverInfo8      *info = NULL;
1915         struct spoolss_DriverInfo8      *info_win2k = NULL;
1916         int                             version;
1917         bool                            delete_files;
1918         WERROR                          status;
1919         SE_PRIV                         se_printop = SE_PRINT_OPERATOR;
1920
1921         /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
1922            and not a printer admin, then fail */
1923
1924         if ( (p->server_info->utok.uid != sec_initial_uid())
1925                 && !user_has_privileges(p->server_info->ptok, &se_printop )
1926                 && !token_contains_name_in_list(
1927                         uidtoname(p->server_info->utok.uid),
1928                         p->server_info->info3->base.domain.string,
1929                         NULL,
1930                         p->server_info->ptok, lp_printer_admin(-1)) )
1931         {
1932                 return WERR_ACCESS_DENIED;
1933         }
1934
1935         /* check that we have a valid driver name first */
1936         if ((version = get_version_id(r->in.architecture)) == -1) {
1937                 /* this is what NT returns */
1938                 return WERR_INVALID_ENVIRONMENT;
1939         }
1940
1941         if (r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION)
1942                 version = r->in.version;
1943
1944         status = winreg_get_driver(p->mem_ctx, p->server_info,
1945                                    p->msg_ctx, r->in.architecture,
1946                                    r->in.driver, version, &info);
1947         if (!W_ERROR_IS_OK(status)) {
1948                 status = WERR_UNKNOWN_PRINTER_DRIVER;
1949
1950                 /*
1951                  * if the client asked for a specific version,
1952                  * or this is something other than Windows NT x86,
1953                  * then we've failed
1954                  */
1955
1956                 if ( (r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION) || (version !=2) )
1957                         goto done;
1958
1959                 /* try for Win2k driver if "Windows NT x86" */
1960
1961                 version = 3;
1962                 status = winreg_get_driver(info, p->server_info, p->msg_ctx,
1963                                            r->in.architecture,
1964                                            r->in.driver,
1965                                            version, &info);
1966                 if (!W_ERROR_IS_OK(status)) {
1967                         status = WERR_UNKNOWN_PRINTER_DRIVER;
1968                         goto done;
1969                 }
1970         }
1971
1972         if (printer_driver_in_use(info, p->server_info, info)) {
1973                 status = WERR_PRINTER_DRIVER_IN_USE;
1974                 goto done;
1975         }
1976
1977         /*
1978          * we have a couple of cases to consider.
1979          * (1) Are any files in use?  If so and DPD_DELTE_ALL_FILE is set,
1980          *     then the delete should fail if **any** files overlap with
1981          *     other drivers
1982          * (2) If DPD_DELTE_UNUSED_FILES is sert, then delete all
1983          *     non-overlapping files
1984          * (3) If neither DPD_DELTE_ALL_FILE nor DPD_DELTE_ALL_FILES
1985          *     is set, the do not delete any files
1986          * Refer to MSDN docs on DeletePrinterDriverEx() for details.
1987          */
1988
1989         delete_files = r->in.delete_flags & (DPD_DELETE_ALL_FILES|DPD_DELETE_UNUSED_FILES);
1990
1991         /* fail if any files are in use and DPD_DELETE_ALL_FILES is set */
1992
1993         if (delete_files &&
1994             (r->in.delete_flags & DPD_DELETE_ALL_FILES) &&
1995             printer_driver_files_in_use(info, p->server_info, info)) {
1996                 /* no idea of the correct error here */
1997                 status = WERR_ACCESS_DENIED;
1998                 goto done;
1999         }
2000
2001
2002         /* also check for W32X86/3 if necessary; maybe we already have? */
2003
2004         if ( (version == 2) && ((r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION) != DPD_DELETE_SPECIFIC_VERSION)  ) {
2005                 status = winreg_get_driver(info, p->server_info, p->msg_ctx,
2006                                            r->in.architecture,
2007                                            r->in.driver, 3, &info_win2k);
2008                 if (W_ERROR_IS_OK(status)) {
2009
2010                         if (delete_files &&
2011                             (r->in.delete_flags & DPD_DELETE_ALL_FILES) &&
2012                             printer_driver_files_in_use(info, p->server_info,
2013                                                         info_win2k)) {
2014                                 /* no idea of the correct error here */
2015                                 talloc_free(info_win2k);
2016                                 status = WERR_ACCESS_DENIED;
2017                                 goto done;
2018                         }
2019
2020                         /* if we get to here, we now have 2 driver info structures to remove */
2021                         /* remove the Win2k driver first*/
2022
2023                         status = winreg_del_driver(info, p->server_info,
2024                                                    p->msg_ctx, info_win2k, 3);
2025
2026                         /* this should not have failed---if it did, report to client */
2027
2028                         if (!W_ERROR_IS_OK(status)) {
2029                                 goto done;
2030                         }
2031
2032                         /*
2033                          * now delete any associated files if delete_files is
2034                          * true. Even if this part failes, we return succes
2035                          * because the driver doesn not exist any more
2036                          */
2037                         if (delete_files) {
2038                                 delete_driver_files(p->server_info,
2039                                                     info_win2k);
2040                         }
2041                 }
2042         }
2043
2044         status = winreg_del_driver(info, p->server_info, p->msg_ctx, info,
2045                                    version);
2046         if (!W_ERROR_IS_OK(status)) {
2047                 goto done;
2048         }
2049
2050         /*
2051          * now delete any associated files if delete_files is
2052          * true. Even if this part failes, we return succes
2053          * because the driver doesn not exist any more
2054          */
2055         if (delete_files) {
2056                 delete_driver_files(p->server_info, info);
2057         }
2058
2059 done:
2060         talloc_free(info);
2061         return status;
2062 }
2063
2064
2065 /********************************************************************
2066  GetPrinterData on a printer server Handle.
2067 ********************************************************************/
2068
2069 static WERROR getprinterdata_printer_server(TALLOC_CTX *mem_ctx,
2070                                             const char *value,
2071                                             enum winreg_Type *type,
2072                                             union spoolss_PrinterData *data)
2073 {
2074         DEBUG(8,("getprinterdata_printer_server:%s\n", value));
2075
2076         if (!StrCaseCmp(value, "W3SvcInstalled")) {
2077                 *type = REG_DWORD;
2078                 data->value = 0x00;
2079                 return WERR_OK;
2080         }
2081
2082         if (!StrCaseCmp(value, "BeepEnabled")) {
2083                 *type = REG_DWORD;
2084                 data->value = 0x00;
2085                 return WERR_OK;
2086         }
2087
2088         if (!StrCaseCmp(value, "EventLog")) {
2089                 *type = REG_DWORD;
2090                 /* formally was 0x1b */
2091                 data->value = 0x00;
2092                 return WERR_OK;
2093         }
2094
2095         if (!StrCaseCmp(value, "NetPopup")) {
2096                 *type = REG_DWORD;
2097                 data->value = 0x00;
2098                 return WERR_OK;
2099         }
2100
2101         if (!StrCaseCmp(value, "MajorVersion")) {
2102                 *type = REG_DWORD;
2103
2104                 /* Windows NT 4.0 seems to not allow uploading of drivers
2105                    to a server that reports 0x3 as the MajorVersion.
2106                    need to investigate more how Win2k gets around this .
2107                    -- jerry */
2108
2109                 if (RA_WINNT == get_remote_arch()) {
2110                         data->value = 0x02;
2111                 } else {
2112                         data->value = 0x03;
2113                 }
2114
2115                 return WERR_OK;
2116         }
2117
2118         if (!StrCaseCmp(value, "MinorVersion")) {
2119                 *type = REG_DWORD;
2120                 data->value = 0x00;
2121                 return WERR_OK;
2122         }
2123
2124         /* REG_BINARY
2125          *  uint32_t size        = 0x114
2126          *  uint32_t major       = 5
2127          *  uint32_t minor       = [0|1]
2128          *  uint32_t build       = [2195|2600]
2129          *  extra unicode string = e.g. "Service Pack 3"
2130          */
2131         if (!StrCaseCmp(value, "OSVersion")) {
2132                 DATA_BLOB blob;
2133                 enum ndr_err_code ndr_err;
2134                 struct spoolss_OSVersion os;
2135
2136                 os.major                = 5;    /* Windows 2000 == 5.0 */
2137                 os.minor                = 0;
2138                 os.build                = 2195; /* build */
2139                 os.extra_string         = "";   /* leave extra string empty */
2140
2141                 ndr_err = ndr_push_struct_blob(&blob, mem_ctx, &os,
2142                         (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion);
2143                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2144                         return WERR_GENERAL_FAILURE;
2145                 }
2146
2147                 *type = REG_BINARY;
2148                 data->binary = blob;
2149
2150                 return WERR_OK;
2151         }
2152
2153
2154         if (!StrCaseCmp(value, "DefaultSpoolDirectory")) {
2155                 *type = REG_SZ;
2156
2157                 data->string = talloc_strdup(mem_ctx, "C:\\PRINTERS");
2158                 W_ERROR_HAVE_NO_MEMORY(data->string);
2159
2160                 return WERR_OK;
2161         }
2162
2163         if (!StrCaseCmp(value, "Architecture")) {
2164                 *type = REG_SZ;
2165                 data->string = talloc_strdup(mem_ctx,
2166                         lp_parm_const_string(GLOBAL_SECTION_SNUM, "spoolss", "architecture", SPOOLSS_ARCHITECTURE_NT_X86));
2167                 W_ERROR_HAVE_NO_MEMORY(data->string);
2168
2169                 return WERR_OK;
2170         }
2171
2172         if (!StrCaseCmp(value, "DsPresent")) {
2173                 *type = REG_DWORD;
2174
2175                 /* only show the publish check box if we are a
2176                    member of a AD domain */
2177
2178                 if (lp_security() == SEC_ADS) {
2179                         data->value = 0x01;
2180                 } else {
2181                         data->value = 0x00;
2182                 }
2183                 return WERR_OK;
2184         }
2185
2186         if (!StrCaseCmp(value, "DNSMachineName")) {
2187                 const char *hostname = get_mydnsfullname();
2188
2189                 if (!hostname) {
2190                         return WERR_BADFILE;
2191                 }
2192
2193                 *type = REG_SZ;
2194                 data->string = talloc_strdup(mem_ctx, hostname);
2195                 W_ERROR_HAVE_NO_MEMORY(data->string);
2196
2197                 return WERR_OK;
2198         }
2199
2200         *type = REG_NONE;
2201
2202         return WERR_INVALID_PARAM;
2203 }
2204
2205 /****************************************************************
2206  _spoolss_GetPrinterData
2207 ****************************************************************/
2208
2209 WERROR _spoolss_GetPrinterData(struct pipes_struct *p,
2210                                struct spoolss_GetPrinterData *r)
2211 {
2212         struct spoolss_GetPrinterDataEx r2;
2213
2214         r2.in.handle            = r->in.handle;
2215         r2.in.key_name          = "PrinterDriverData";
2216         r2.in.value_name        = r->in.value_name;
2217         r2.in.offered           = r->in.offered;
2218         r2.out.type             = r->out.type;
2219         r2.out.data             = r->out.data;
2220         r2.out.needed           = r->out.needed;
2221
2222         return _spoolss_GetPrinterDataEx(p, &r2);
2223 }
2224
2225 /*********************************************************
2226  Connect to the client machine.
2227 **********************************************************/
2228
2229 static bool spoolss_connect_to_client(struct rpc_pipe_client **pp_pipe,
2230                         struct sockaddr_storage *client_ss, const char *remote_machine)
2231 {
2232         NTSTATUS ret;
2233         struct cli_state *the_cli;
2234         struct sockaddr_storage rm_addr;
2235         char addr[INET6_ADDRSTRLEN];
2236
2237         if ( is_zero_addr((struct sockaddr *)client_ss) ) {
2238                 DEBUG(2,("spoolss_connect_to_client: resolving %s\n",
2239                         remote_machine));
2240                 if ( !resolve_name( remote_machine, &rm_addr, 0x20, false) ) {
2241                         DEBUG(2,("spoolss_connect_to_client: Can't resolve address for %s\n", remote_machine));
2242                         return false;
2243                 }
2244                 print_sockaddr(addr, sizeof(addr), &rm_addr);
2245         } else {
2246                 rm_addr = *client_ss;
2247                 print_sockaddr(addr, sizeof(addr), &rm_addr);
2248                 DEBUG(5,("spoolss_connect_to_client: Using address %s (no name resolution necessary)\n",
2249                         addr));
2250         }
2251
2252         if (ismyaddr((struct sockaddr *)(void *)&rm_addr)) {
2253                 DEBUG(0,("spoolss_connect_to_client: Machine %s is one of our addresses. Cannot add to ourselves.\n",
2254                         addr));
2255                 return false;
2256         }
2257
2258         /* setup the connection */
2259         ret = cli_full_connection( &the_cli, global_myname(), remote_machine,
2260                 &rm_addr, 0, "IPC$", "IPC",
2261                 "", /* username */
2262                 "", /* domain */
2263                 "", /* password */
2264                 0, lp_client_signing(), NULL );
2265
2266         if ( !NT_STATUS_IS_OK( ret ) ) {
2267                 DEBUG(2,("spoolss_connect_to_client: connection to [%s] failed!\n",
2268                         remote_machine ));
2269                 return false;
2270         }
2271
2272         if ( the_cli->protocol != PROTOCOL_NT1 ) {
2273                 DEBUG(0,("spoolss_connect_to_client: machine %s didn't negotiate NT protocol.\n", remote_machine));
2274                 cli_shutdown(the_cli);
2275                 return false;
2276         }
2277
2278         /*
2279          * Ok - we have an anonymous connection to the IPC$ share.
2280          * Now start the NT Domain stuff :-).
2281          */
2282
2283         ret = cli_rpc_pipe_open_noauth(the_cli, &ndr_table_spoolss.syntax_id, pp_pipe);
2284         if (!NT_STATUS_IS_OK(ret)) {
2285                 DEBUG(2,("spoolss_connect_to_client: unable to open the spoolss pipe on machine %s. Error was : %s.\n",
2286                         remote_machine, nt_errstr(ret)));
2287                 cli_shutdown(the_cli);
2288                 return false;
2289         }
2290
2291         return true;
2292 }
2293
2294 /***************************************************************************
2295  Connect to the client.
2296 ****************************************************************************/
2297
2298 static bool srv_spoolss_replyopenprinter(int snum, const char *printer,
2299                                         uint32_t localprinter, uint32_t type,
2300                                         struct policy_handle *handle,
2301                                         struct sockaddr_storage *client_ss,
2302                                         struct messaging_context *msg_ctx)
2303 {
2304         WERROR result;
2305         NTSTATUS status;
2306
2307         /*
2308          * If it's the first connection, contact the client
2309          * and connect to the IPC$ share anonymously
2310          */
2311         if (smb_connections==0) {
2312                 fstring unix_printer;
2313
2314                 fstrcpy(unix_printer, printer+2); /* the +2 is to strip the leading 2 backslashs */
2315
2316                 if ( !spoolss_connect_to_client( &notify_cli_pipe, client_ss, unix_printer ))
2317                         return false;
2318
2319                 messaging_register(msg_ctx, NULL, MSG_PRINTER_NOTIFY2,
2320                                    receive_notify2_message_list);
2321                 /* Tell the connections db we're now interested in printer
2322                  * notify messages. */
2323                 serverid_register_msg_flags(messaging_server_id(msg_ctx),
2324                                             true, FLAG_MSG_PRINT_NOTIFY);
2325         }
2326
2327         /*
2328          * Tell the specific printing tdb we want messages for this printer
2329          * by registering our PID.
2330          */
2331
2332         if (!print_notify_register_pid(snum))
2333                 DEBUG(0,("print_notify_register_pid: Failed to register our pid for printer %s\n", printer ));
2334
2335         smb_connections++;
2336
2337         status = rpccli_spoolss_ReplyOpenPrinter(notify_cli_pipe, talloc_tos(),
2338                                                  printer,
2339                                                  localprinter,
2340                                                  type,
2341                                                  0,
2342                                                  NULL,
2343                                                  handle,
2344                                                  &result);
2345         if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result))
2346                 DEBUG(5,("srv_spoolss_reply_open_printer: Client RPC returned [%s]\n",
2347                         win_errstr(result)));
2348
2349         return (W_ERROR_IS_OK(result));
2350 }
2351
2352 /****************************************************************
2353  ****************************************************************/
2354
2355 static struct spoolss_NotifyOption *dup_spoolss_NotifyOption(TALLOC_CTX *mem_ctx,
2356                                                              const struct spoolss_NotifyOption *r)
2357 {
2358         struct spoolss_NotifyOption *option;
2359         uint32_t i,k;
2360
2361         if (!r) {
2362                 return NULL;
2363         }
2364
2365         option = talloc_zero(mem_ctx, struct spoolss_NotifyOption);
2366         if (!option) {
2367                 return NULL;
2368         }
2369
2370         *option = *r;
2371
2372         if (!option->count) {
2373                 return option;
2374         }
2375
2376         option->types = talloc_zero_array(option,
2377                 struct spoolss_NotifyOptionType, option->count);
2378         if (!option->types) {
2379                 talloc_free(option);
2380                 return NULL;
2381         }
2382
2383         for (i=0; i < option->count; i++) {
2384                 option->types[i] = r->types[i];
2385
2386                 if (option->types[i].count) {
2387                         option->types[i].fields = talloc_zero_array(option,
2388                                 union spoolss_Field, option->types[i].count);
2389                         if (!option->types[i].fields) {
2390                                 talloc_free(option);
2391                                 return NULL;
2392                         }
2393                         for (k=0; k<option->types[i].count; k++) {
2394                                 option->types[i].fields[k] =
2395                                         r->types[i].fields[k];
2396                         }
2397                 }
2398         }
2399
2400         return option;
2401 }
2402
2403 /****************************************************************
2404  * _spoolss_RemoteFindFirstPrinterChangeNotifyEx
2405  *
2406  * before replying OK: status=0 a rpc call is made to the workstation
2407  * asking ReplyOpenPrinter
2408  *
2409  * in fact ReplyOpenPrinter is the changenotify equivalent on the spoolss pipe
2410  * called from api_spoolss_rffpcnex
2411 ****************************************************************/
2412
2413 WERROR _spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct pipes_struct *p,
2414                                                      struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
2415 {
2416         int snum = -1;
2417         struct spoolss_NotifyOption *option = r->in.notify_options;
2418         struct sockaddr_storage client_ss;
2419
2420         /* store the notify value in the printer struct */
2421
2422         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
2423
2424         if (!Printer) {
2425                 DEBUG(2,("_spoolss_RemoteFindFirstPrinterChangeNotifyEx: "
2426                         "Invalid handle (%s:%u:%u).\n",
2427                         OUR_HANDLE(r->in.handle)));
2428                 return WERR_BADFID;
2429         }
2430
2431         Printer->notify.flags           = r->in.flags;
2432         Printer->notify.options         = r->in.options;
2433         Printer->notify.printerlocal    = r->in.printer_local;
2434         Printer->notify.msg_ctx         = p->msg_ctx;
2435
2436         TALLOC_FREE(Printer->notify.option);
2437         Printer->notify.option = dup_spoolss_NotifyOption(Printer, option);
2438
2439         fstrcpy(Printer->notify.localmachine, r->in.local_machine);
2440
2441         /* Connect to the client machine and send a ReplyOpenPrinter */
2442
2443         if ( Printer->printer_type == SPLHND_SERVER)
2444                 snum = -1;
2445         else if ( (Printer->printer_type == SPLHND_PRINTER) &&
2446                         !get_printer_snum(p, r->in.handle, &snum, NULL) )
2447                 return WERR_BADFID;
2448
2449         DEBUG(10,("_spoolss_RemoteFindFirstPrinterChangeNotifyEx: "
2450                 "client_address is %s\n", p->client_address));
2451
2452         if (!interpret_string_addr(&client_ss, p->client_address,
2453                                    AI_NUMERICHOST)) {
2454                 return WERR_SERVER_UNAVAILABLE;
2455         }
2456
2457         if(!srv_spoolss_replyopenprinter(snum, Printer->notify.localmachine,
2458                                         Printer->notify.printerlocal, 1,
2459                                         &Printer->notify.client_hnd,
2460                                         &client_ss, p->msg_ctx))
2461                 return WERR_SERVER_UNAVAILABLE;
2462
2463         Printer->notify.client_connected = true;
2464
2465         return WERR_OK;
2466 }
2467
2468 /*******************************************************************
2469  * fill a notify_info_data with the servername
2470  ********************************************************************/
2471
2472 static void spoolss_notify_server_name(int snum,
2473                                        struct spoolss_Notify *data,
2474                                        print_queue_struct *queue,
2475                                        struct spoolss_PrinterInfo2 *pinfo2,
2476                                        TALLOC_CTX *mem_ctx)
2477 {
2478         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->servername);
2479 }
2480
2481 /*******************************************************************
2482  * fill a notify_info_data with the printername (not including the servername).
2483  ********************************************************************/
2484
2485 static void spoolss_notify_printer_name(int snum,
2486                                         struct spoolss_Notify *data,
2487                                         print_queue_struct *queue,
2488                                         struct spoolss_PrinterInfo2 *pinfo2,
2489                                         TALLOC_CTX *mem_ctx)
2490 {
2491         /* the notify name should not contain the \\server\ part */
2492         const char *p = strrchr(pinfo2->printername, '\\');
2493
2494         if (!p) {
2495                 p = pinfo2->printername;
2496         } else {
2497                 p++;
2498         }
2499
2500         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, p);
2501 }
2502
2503 /*******************************************************************
2504  * fill a notify_info_data with the servicename
2505  ********************************************************************/
2506
2507 static void spoolss_notify_share_name(int snum,
2508                                       struct spoolss_Notify *data,
2509                                       print_queue_struct *queue,
2510                                       struct spoolss_PrinterInfo2 *pinfo2,
2511                                       TALLOC_CTX *mem_ctx)
2512 {
2513         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, lp_servicename(snum));
2514 }
2515
2516 /*******************************************************************
2517  * fill a notify_info_data with the port name
2518  ********************************************************************/
2519
2520 static void spoolss_notify_port_name(int snum,
2521                                      struct spoolss_Notify *data,
2522                                      print_queue_struct *queue,
2523                                      struct spoolss_PrinterInfo2 *pinfo2,
2524                                      TALLOC_CTX *mem_ctx)
2525 {
2526         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->portname);
2527 }
2528
2529 /*******************************************************************
2530  * fill a notify_info_data with the printername
2531  * but it doesn't exist, have to see what to do
2532  ********************************************************************/
2533
2534 static void spoolss_notify_driver_name(int snum,
2535                                        struct spoolss_Notify *data,
2536                                        print_queue_struct *queue,
2537                                        struct spoolss_PrinterInfo2 *pinfo2,
2538                                        TALLOC_CTX *mem_ctx)
2539 {
2540         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->drivername);
2541 }
2542
2543 /*******************************************************************
2544  * fill a notify_info_data with the comment
2545  ********************************************************************/
2546
2547 static void spoolss_notify_comment(int snum,
2548                                    struct spoolss_Notify *data,
2549                                    print_queue_struct *queue,
2550                                    struct spoolss_PrinterInfo2 *pinfo2,
2551                                    TALLOC_CTX *mem_ctx)
2552 {
2553         const char *p;
2554
2555         if (*pinfo2->comment == '\0') {
2556                 p = lp_comment(snum);
2557         } else {
2558                 p = pinfo2->comment;
2559         }
2560
2561         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, p);
2562 }
2563
2564 /*******************************************************************
2565  * fill a notify_info_data with the comment
2566  * location = "Room 1, floor 2, building 3"
2567  ********************************************************************/
2568
2569 static void spoolss_notify_location(int snum,
2570                                     struct spoolss_Notify *data,
2571                                     print_queue_struct *queue,
2572                                     struct spoolss_PrinterInfo2 *pinfo2,
2573                                     TALLOC_CTX *mem_ctx)
2574 {
2575         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->location);
2576 }
2577
2578 /*******************************************************************
2579  * fill a notify_info_data with the device mode
2580  * jfm:xxxx don't to it for know but that's a real problem !!!
2581  ********************************************************************/
2582
2583 static void spoolss_notify_devmode(int snum,
2584                                    struct spoolss_Notify *data,
2585                                    print_queue_struct *queue,
2586                                    struct spoolss_PrinterInfo2 *pinfo2,
2587                                    TALLOC_CTX *mem_ctx)
2588 {
2589         /* for a dummy implementation we have to zero the fields */
2590         SETUP_SPOOLSS_NOTIFY_DATA_DEVMODE(data, NULL);
2591 }
2592
2593 /*******************************************************************
2594  * fill a notify_info_data with the separator file name
2595  ********************************************************************/
2596
2597 static void spoolss_notify_sepfile(int snum,
2598                                    struct spoolss_Notify *data,
2599                                    print_queue_struct *queue,
2600                                    struct spoolss_PrinterInfo2 *pinfo2,
2601                                    TALLOC_CTX *mem_ctx)
2602 {
2603         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->sepfile);
2604 }
2605
2606 /*******************************************************************
2607  * fill a notify_info_data with the print processor
2608  * jfm:xxxx return always winprint to indicate we don't do anything to it
2609  ********************************************************************/
2610
2611 static void spoolss_notify_print_processor(int snum,
2612                                            struct spoolss_Notify *data,
2613                                            print_queue_struct *queue,
2614                                            struct spoolss_PrinterInfo2 *pinfo2,
2615                                            TALLOC_CTX *mem_ctx)
2616 {
2617         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->printprocessor);
2618 }
2619
2620 /*******************************************************************
2621  * fill a notify_info_data with the print processor options
2622  * jfm:xxxx send an empty string
2623  ********************************************************************/
2624
2625 static void spoolss_notify_parameters(int snum,
2626                                       struct spoolss_Notify *data,
2627                                       print_queue_struct *queue,
2628                                       struct spoolss_PrinterInfo2 *pinfo2,
2629                                       TALLOC_CTX *mem_ctx)
2630 {
2631         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->parameters);
2632 }
2633
2634 /*******************************************************************
2635  * fill a notify_info_data with the data type
2636  * jfm:xxxx always send RAW as data type
2637  ********************************************************************/
2638
2639 static void spoolss_notify_datatype(int snum,
2640                                     struct spoolss_Notify *data,
2641                                     print_queue_struct *queue,
2642                                     struct spoolss_PrinterInfo2 *pinfo2,
2643                                     TALLOC_CTX *mem_ctx)
2644 {
2645         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->datatype);
2646 }
2647
2648 /*******************************************************************
2649  * fill a notify_info_data with the security descriptor
2650  * jfm:xxxx send an null pointer to say no security desc
2651  * have to implement security before !
2652  ********************************************************************/
2653
2654 static void spoolss_notify_security_desc(int snum,
2655                                          struct spoolss_Notify *data,
2656                                          print_queue_struct *queue,
2657                                          struct spoolss_PrinterInfo2 *pinfo2,
2658                                          TALLOC_CTX *mem_ctx)
2659 {
2660         SETUP_SPOOLSS_NOTIFY_DATA_SECDESC(data, pinfo2->secdesc);
2661 }
2662
2663 /*******************************************************************
2664  * fill a notify_info_data with the attributes
2665  * jfm:xxxx a samba printer is always shared
2666  ********************************************************************/
2667
2668 static void spoolss_notify_attributes(int snum,
2669                                       struct spoolss_Notify *data,
2670                                       print_queue_struct *queue,
2671                                       struct spoolss_PrinterInfo2 *pinfo2,
2672                                       TALLOC_CTX *mem_ctx)
2673 {
2674         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->attributes);
2675 }
2676
2677 /*******************************************************************
2678  * fill a notify_info_data with the priority
2679  ********************************************************************/
2680
2681 static void spoolss_notify_priority(int snum,
2682                                     struct spoolss_Notify *data,
2683                                     print_queue_struct *queue,
2684                                     struct spoolss_PrinterInfo2 *pinfo2,
2685                                     TALLOC_CTX *mem_ctx)
2686 {
2687         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->priority);
2688 }
2689
2690 /*******************************************************************
2691  * fill a notify_info_data with the default priority
2692  ********************************************************************/
2693
2694 static void spoolss_notify_default_priority(int snum,
2695                                             struct spoolss_Notify *data,
2696                                             print_queue_struct *queue,
2697                                             struct spoolss_PrinterInfo2 *pinfo2,
2698                                             TALLOC_CTX *mem_ctx)
2699 {
2700         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->defaultpriority);
2701 }
2702
2703 /*******************************************************************
2704  * fill a notify_info_data with the start time
2705  ********************************************************************/
2706
2707 static void spoolss_notify_start_time(int snum,
2708                                       struct spoolss_Notify *data,
2709                                       print_queue_struct *queue,
2710                                       struct spoolss_PrinterInfo2 *pinfo2,
2711                                       TALLOC_CTX *mem_ctx)
2712 {
2713         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->starttime);
2714 }
2715
2716 /*******************************************************************
2717  * fill a notify_info_data with the until time
2718  ********************************************************************/
2719
2720 static void spoolss_notify_until_time(int snum,
2721                                       struct spoolss_Notify *data,
2722                                       print_queue_struct *queue,
2723                                       struct spoolss_PrinterInfo2 *pinfo2,
2724                                       TALLOC_CTX *mem_ctx)
2725 {
2726         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->untiltime);
2727 }
2728
2729 /*******************************************************************
2730  * fill a notify_info_data with the status
2731  ********************************************************************/
2732
2733 static void spoolss_notify_status(int snum,
2734                                   struct spoolss_Notify *data,
2735                                   print_queue_struct *queue,
2736                                   struct spoolss_PrinterInfo2 *pinfo2,
2737                                   TALLOC_CTX *mem_ctx)
2738 {
2739         print_status_struct status;
2740
2741         print_queue_length(snum, &status);
2742         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, status.status);
2743 }
2744
2745 /*******************************************************************
2746  * fill a notify_info_data with the number of jobs queued
2747  ********************************************************************/
2748
2749 static void spoolss_notify_cjobs(int snum,
2750                                  struct spoolss_Notify *data,
2751                                  print_queue_struct *queue,
2752                                  struct spoolss_PrinterInfo2 *pinfo2,
2753                                  TALLOC_CTX *mem_ctx)
2754 {
2755         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, print_queue_length(snum, NULL));
2756 }
2757
2758 /*******************************************************************
2759  * fill a notify_info_data with the average ppm
2760  ********************************************************************/
2761
2762 static void spoolss_notify_average_ppm(int snum,
2763                                        struct spoolss_Notify *data,
2764                                        print_queue_struct *queue,
2765                                        struct spoolss_PrinterInfo2 *pinfo2,
2766                                        TALLOC_CTX *mem_ctx)
2767 {
2768         /* always respond 8 pages per minutes */
2769         /* a little hard ! */
2770         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->averageppm);
2771 }
2772
2773 /*******************************************************************
2774  * fill a notify_info_data with username
2775  ********************************************************************/
2776
2777 static void spoolss_notify_username(int snum,
2778                                     struct spoolss_Notify *data,
2779                                     print_queue_struct *queue,
2780                                     struct spoolss_PrinterInfo2 *pinfo2,
2781                                     TALLOC_CTX *mem_ctx)
2782 {
2783         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, queue->fs_user);
2784 }
2785
2786 /*******************************************************************
2787  * fill a notify_info_data with job status
2788  ********************************************************************/
2789
2790 static void spoolss_notify_job_status(int snum,
2791                                       struct spoolss_Notify *data,
2792                                       print_queue_struct *queue,
2793                                       struct spoolss_PrinterInfo2 *pinfo2,
2794                                       TALLOC_CTX *mem_ctx)
2795 {
2796         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, nt_printj_status(queue->status));
2797 }
2798
2799 /*******************************************************************
2800  * fill a notify_info_data with job name
2801  ********************************************************************/
2802
2803 static void spoolss_notify_job_name(int snum,
2804                                     struct spoolss_Notify *data,
2805                                     print_queue_struct *queue,
2806                                     struct spoolss_PrinterInfo2 *pinfo2,
2807                                     TALLOC_CTX *mem_ctx)
2808 {
2809         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, queue->fs_file);
2810 }
2811
2812 /*******************************************************************
2813  * fill a notify_info_data with job status
2814  ********************************************************************/
2815
2816 static void spoolss_notify_job_status_string(int snum,
2817                                              struct spoolss_Notify *data,
2818                                              print_queue_struct *queue,
2819                                              struct spoolss_PrinterInfo2 *pinfo2,
2820                                              TALLOC_CTX *mem_ctx)
2821 {
2822         /*
2823          * Now we're returning job status codes we just return a "" here. JRA.
2824          */
2825
2826         const char *p = "";
2827
2828 #if 0 /* NO LONGER NEEDED - JRA. 02/22/2001 */
2829         p = "unknown";
2830
2831         switch (queue->status) {
2832         case LPQ_QUEUED:
2833                 p = "Queued";
2834                 break;
2835         case LPQ_PAUSED:
2836                 p = "";    /* NT provides the paused string */
2837                 break;
2838         case LPQ_SPOOLING:
2839                 p = "Spooling";
2840                 break;
2841         case LPQ_PRINTING:
2842                 p = "Printing";
2843                 break;
2844         }
2845 #endif /* NO LONGER NEEDED. */
2846
2847         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, p);
2848 }
2849
2850 /*******************************************************************
2851  * fill a notify_info_data with job time
2852  ********************************************************************/
2853
2854 static void spoolss_notify_job_time(int snum,
2855                                     struct spoolss_Notify *data,
2856                                     print_queue_struct *queue,
2857                                     struct spoolss_PrinterInfo2 *pinfo2,
2858                                     TALLOC_CTX *mem_ctx)
2859 {
2860         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, 0);
2861 }
2862
2863 /*******************************************************************
2864  * fill a notify_info_data with job size
2865  ********************************************************************/
2866
2867 static void spoolss_notify_job_size(int snum,
2868                                     struct spoolss_Notify *data,
2869                                     print_queue_struct *queue,
2870                                     struct spoolss_PrinterInfo2 *pinfo2,
2871                                     TALLOC_CTX *mem_ctx)
2872 {
2873         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->size);
2874 }
2875
2876 /*******************************************************************
2877  * fill a notify_info_data with page info
2878  ********************************************************************/
2879 static void spoolss_notify_total_pages(int snum,
2880                                 struct spoolss_Notify *data,
2881                                 print_queue_struct *queue,
2882                                 struct spoolss_PrinterInfo2 *pinfo2,
2883                                 TALLOC_CTX *mem_ctx)
2884 {
2885         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->page_count);
2886 }
2887
2888 /*******************************************************************
2889  * fill a notify_info_data with pages printed info.
2890  ********************************************************************/
2891 static void spoolss_notify_pages_printed(int snum,
2892                                 struct spoolss_Notify *data,
2893                                 print_queue_struct *queue,
2894                                 struct spoolss_PrinterInfo2 *pinfo2,
2895                                 TALLOC_CTX *mem_ctx)
2896 {
2897         /* Add code when back-end tracks this */
2898         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, 0);
2899 }
2900
2901 /*******************************************************************
2902  Fill a notify_info_data with job position.
2903  ********************************************************************/
2904
2905 static void spoolss_notify_job_position(int snum,
2906                                         struct spoolss_Notify *data,
2907                                         print_queue_struct *queue,
2908                                         struct spoolss_PrinterInfo2 *pinfo2,
2909                                         TALLOC_CTX *mem_ctx)
2910 {
2911         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->job);
2912 }
2913
2914 /*******************************************************************
2915  Fill a notify_info_data with submitted time.
2916  ********************************************************************/
2917
2918 static void spoolss_notify_submitted_time(int snum,
2919                                           struct spoolss_Notify *data,
2920                                           print_queue_struct *queue,
2921                                           struct spoolss_PrinterInfo2 *pinfo2,
2922                                           TALLOC_CTX *mem_ctx)
2923 {
2924         data->data.string.string = NULL;
2925         data->data.string.size = 0;
2926
2927         init_systemtime_buffer(mem_ctx, gmtime(&queue->time),
2928                                &data->data.string.string,
2929                                &data->data.string.size);
2930
2931 }
2932
2933 struct s_notify_info_data_table
2934 {
2935         enum spoolss_NotifyType type;
2936         uint16_t field;
2937         const char *name;
2938         enum spoolss_NotifyTable variable_type;
2939         void (*fn) (int snum, struct spoolss_Notify *data,
2940                     print_queue_struct *queue,
2941                     struct spoolss_PrinterInfo2 *pinfo2,
2942                     TALLOC_CTX *mem_ctx);
2943 };
2944
2945 /* A table describing the various print notification constants and
2946    whether the notification data is a pointer to a variable sized
2947    buffer, a one value uint32_t or a two value uint32_t. */
2948
2949 static const struct s_notify_info_data_table notify_info_data_table[] =
2950 {
2951 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SERVER_NAME,         "PRINTER_NOTIFY_FIELD_SERVER_NAME",         NOTIFY_TABLE_STRING,   spoolss_notify_server_name },
2952 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRINTER_NAME,        "PRINTER_NOTIFY_FIELD_PRINTER_NAME",        NOTIFY_TABLE_STRING,   spoolss_notify_printer_name },
2953 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SHARE_NAME,          "PRINTER_NOTIFY_FIELD_SHARE_NAME",          NOTIFY_TABLE_STRING,   spoolss_notify_share_name },
2954 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PORT_NAME,           "PRINTER_NOTIFY_FIELD_PORT_NAME",           NOTIFY_TABLE_STRING,   spoolss_notify_port_name },
2955 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DRIVER_NAME,         "PRINTER_NOTIFY_FIELD_DRIVER_NAME",         NOTIFY_TABLE_STRING,   spoolss_notify_driver_name },
2956 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_COMMENT,             "PRINTER_NOTIFY_FIELD_COMMENT",             NOTIFY_TABLE_STRING,   spoolss_notify_comment },
2957 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_LOCATION,            "PRINTER_NOTIFY_FIELD_LOCATION",            NOTIFY_TABLE_STRING,   spoolss_notify_location },
2958 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DEVMODE,             "PRINTER_NOTIFY_FIELD_DEVMODE",             NOTIFY_TABLE_DEVMODE,  spoolss_notify_devmode },
2959 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SEPFILE,             "PRINTER_NOTIFY_FIELD_SEPFILE",             NOTIFY_TABLE_STRING,   spoolss_notify_sepfile },
2960 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR,     "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR",     NOTIFY_TABLE_STRING,   spoolss_notify_print_processor },
2961 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PARAMETERS,          "PRINTER_NOTIFY_FIELD_PARAMETERS",          NOTIFY_TABLE_STRING,   spoolss_notify_parameters },
2962 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DATATYPE,            "PRINTER_NOTIFY_FIELD_DATATYPE",            NOTIFY_TABLE_STRING,   spoolss_notify_datatype },
2963 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR, "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NOTIFY_TABLE_SECURITYDESCRIPTOR,   spoolss_notify_security_desc },
2964 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_ATTRIBUTES,          "PRINTER_NOTIFY_FIELD_ATTRIBUTES",          NOTIFY_TABLE_DWORD,    spoolss_notify_attributes },
2965 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRIORITY,            "PRINTER_NOTIFY_FIELD_PRIORITY",            NOTIFY_TABLE_DWORD,    spoolss_notify_priority },
2966 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY,    "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY",    NOTIFY_TABLE_DWORD,    spoolss_notify_default_priority },
2967 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_START_TIME,          "PRINTER_NOTIFY_FIELD_START_TIME",          NOTIFY_TABLE_DWORD,    spoolss_notify_start_time },
2968 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_UNTIL_TIME,          "PRINTER_NOTIFY_FIELD_UNTIL_TIME",          NOTIFY_TABLE_DWORD,    spoolss_notify_until_time },
2969 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_STATUS,              "PRINTER_NOTIFY_FIELD_STATUS",              NOTIFY_TABLE_DWORD,    spoolss_notify_status },
2970 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_STATUS_STRING,       "PRINTER_NOTIFY_FIELD_STATUS_STRING",       NOTIFY_TABLE_STRING,   NULL },
2971 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_CJOBS,               "PRINTER_NOTIFY_FIELD_CJOBS",               NOTIFY_TABLE_DWORD,    spoolss_notify_cjobs },
2972 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_AVERAGE_PPM,         "PRINTER_NOTIFY_FIELD_AVERAGE_PPM",         NOTIFY_TABLE_DWORD,    spoolss_notify_average_ppm },
2973 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_TOTAL_PAGES,         "PRINTER_NOTIFY_FIELD_TOTAL_PAGES",         NOTIFY_TABLE_DWORD,    NULL },
2974 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PAGES_PRINTED,       "PRINTER_NOTIFY_FIELD_PAGES_PRINTED",       NOTIFY_TABLE_DWORD,    NULL },
2975 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_TOTAL_BYTES,         "PRINTER_NOTIFY_FIELD_TOTAL_BYTES",         NOTIFY_TABLE_DWORD,    NULL },
2976 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_BYTES_PRINTED,       "PRINTER_NOTIFY_FIELD_BYTES_PRINTED",       NOTIFY_TABLE_DWORD,    NULL },
2977 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_PRINTER_NAME,            "JOB_NOTIFY_FIELD_PRINTER_NAME",            NOTIFY_TABLE_STRING,   spoolss_notify_printer_name },
2978 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_MACHINE_NAME,            "JOB_NOTIFY_FIELD_MACHINE_NAME",            NOTIFY_TABLE_STRING,   spoolss_notify_server_name },
2979 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_PORT_NAME,               "JOB_NOTIFY_FIELD_PORT_NAME",               NOTIFY_TABLE_STRING,   spoolss_notify_port_name },
2980 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_USER_NAME,               "JOB_NOTIFY_FIELD_USER_NAME",               NOTIFY_TABLE_STRING,   spoolss_notify_username },
2981 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_NOTIFY_NAME,             "JOB_NOTIFY_FIELD_NOTIFY_NAME",             NOTIFY_TABLE_STRING,   spoolss_notify_username },
2982 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_DATATYPE,                "JOB_NOTIFY_FIELD_DATATYPE",                NOTIFY_TABLE_STRING,   spoolss_notify_datatype },
2983 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_PRINT_PROCESSOR,         "JOB_NOTIFY_FIELD_PRINT_PROCESSOR",         NOTIFY_TABLE_STRING,   spoolss_notify_print_processor },
2984 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_PARAMETERS,              "JOB_NOTIFY_FIELD_PARAMETERS",              NOTIFY_TABLE_STRING,   spoolss_notify_parameters },
2985 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_DRIVER_NAME,             "JOB_NOTIFY_FIELD_DRIVER_NAME",             NOTIFY_TABLE_STRING,   spoolss_notify_driver_name },
2986 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_DEVMODE,                 "JOB_NOTIFY_FIELD_DEVMODE",                 NOTIFY_TABLE_DEVMODE,  spoolss_notify_devmode },
2987 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_STATUS,                  "JOB_NOTIFY_FIELD_STATUS",                  NOTIFY_TABLE_DWORD,    spoolss_notify_job_status },
2988 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_STATUS_STRING,           "JOB_NOTIFY_FIELD_STATUS_STRING",           NOTIFY_TABLE_STRING,   spoolss_notify_job_status_string },
2989 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR,     "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR",     NOTIFY_TABLE_SECURITYDESCRIPTOR,   NULL },
2990 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_DOCUMENT,                "JOB_NOTIFY_FIELD_DOCUMENT",                NOTIFY_TABLE_STRING,   spoolss_notify_job_name },
2991 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_PRIORITY,                "JOB_NOTIFY_FIELD_PRIORITY",                NOTIFY_TABLE_DWORD,    spoolss_notify_priority },
2992 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_POSITION,                "JOB_NOTIFY_FIELD_POSITION",                NOTIFY_TABLE_DWORD,    spoolss_notify_job_position },
2993 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_SUBMITTED,               "JOB_NOTIFY_FIELD_SUBMITTED",               NOTIFY_TABLE_TIME,     spoolss_notify_submitted_time },
2994 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_START_TIME,              "JOB_NOTIFY_FIELD_START_TIME",              NOTIFY_TABLE_DWORD,    spoolss_notify_start_time },
2995 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_UNTIL_TIME,              "JOB_NOTIFY_FIELD_UNTIL_TIME",              NOTIFY_TABLE_DWORD,    spoolss_notify_until_time },
2996 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_TIME,                    "JOB_NOTIFY_FIELD_TIME",                    NOTIFY_TABLE_DWORD,    spoolss_notify_job_time },
2997 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_TOTAL_PAGES,             "JOB_NOTIFY_FIELD_TOTAL_PAGES",             NOTIFY_TABLE_DWORD,    spoolss_notify_total_pages },
2998 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_PAGES_PRINTED,           "JOB_NOTIFY_FIELD_PAGES_PRINTED",           NOTIFY_TABLE_DWORD,    spoolss_notify_pages_printed },
2999 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_TOTAL_BYTES,             "JOB_NOTIFY_FIELD_TOTAL_BYTES",             NOTIFY_TABLE_DWORD,    spoolss_notify_job_size },
3000 };
3001
3002 /*******************************************************************
3003  Return the variable_type of info_data structure.
3004 ********************************************************************/
3005
3006 static uint32_t variable_type_of_notify_info_data(enum spoolss_NotifyType type,
3007                                                   uint16_t field)
3008 {
3009         int i=0;
3010
3011         for (i = 0; i < ARRAY_SIZE(notify_info_data_table); i++) {
3012                 if ( (notify_info_data_table[i].type == type) &&
3013                      (notify_info_data_table[i].field == field) ) {
3014                         return notify_info_data_table[i].variable_type;
3015                 }
3016         }
3017
3018         DEBUG(5, ("invalid notify data type %d/%d\n", type, field));
3019
3020         return 0;
3021 }
3022
3023 /****************************************************************************
3024 ****************************************************************************/
3025
3026 static bool search_notify(enum spoolss_NotifyType type,
3027                           uint16_t field,
3028                           int *value)
3029 {
3030         int i;
3031
3032         for (i = 0; i < ARRAY_SIZE(notify_info_data_table); i++) {
3033                 if (notify_info_data_table[i].type == type &&
3034                     notify_info_data_table[i].field == field &&
3035                     notify_info_data_table[i].fn != NULL) {
3036                         *value = i;
3037                         return true;
3038                 }
3039         }
3040
3041         return false;
3042 }
3043
3044 /****************************************************************************
3045 ****************************************************************************/
3046
3047 static void construct_info_data(struct spoolss_Notify *info_data,
3048                                 enum spoolss_NotifyType type,
3049                                 uint16_t field, int id)
3050 {
3051         info_data->type                 = type;
3052         info_data->field.field          = field;
3053         info_data->variable_type        = variable_type_of_notify_info_data(type, field);
3054         info_data->job_id               = id;
3055 }
3056
3057 /*******************************************************************
3058  *
3059  * fill a notify_info struct with info asked
3060  *
3061  ********************************************************************/
3062
3063 static bool construct_notify_printer_info(Printer_entry *print_hnd,
3064                                           struct spoolss_NotifyInfo *info,
3065                                           struct spoolss_PrinterInfo2 *pinfo2,
3066                                           int snum,
3067                                           const struct spoolss_NotifyOptionType *option_type,
3068                                           uint32_t id,
3069                                           TALLOC_CTX *mem_ctx)
3070 {
3071         int field_num,j;
3072         enum spoolss_NotifyType type;
3073         uint16_t field;
3074
3075         struct spoolss_Notify *current_data;
3076         print_queue_struct *queue=NULL;
3077
3078         type = option_type->type;
3079
3080         DEBUG(4,("construct_notify_printer_info: Notify type: [%s], number of notify info: [%d] on printer: [%s]\n",
3081                 (type == PRINTER_NOTIFY_TYPE ? "PRINTER_NOTIFY_TYPE" : "JOB_NOTIFY_TYPE"),
3082                 option_type->count, lp_servicename(snum)));
3083
3084         for(field_num=0; field_num < option_type->count; field_num++) {
3085                 field = option_type->fields[field_num].field;
3086
3087                 DEBUG(4,("construct_notify_printer_info: notify [%d]: type [%x], field [%x]\n", field_num, type, field));
3088
3089                 if (!search_notify(type, field, &j) )
3090                         continue;
3091
3092                 info->notifies = TALLOC_REALLOC_ARRAY(info, info->notifies,
3093                                                       struct spoolss_Notify,
3094                                                       info->count + 1);
3095                 if (info->notifies == NULL) {
3096                         DEBUG(2,("construct_notify_printer_info: failed to enlarge buffer info->data!\n"));
3097                         return false;
3098                 }
3099
3100                 current_data = &info->notifies[info->count];
3101
3102                 construct_info_data(current_data, type, field, id);
3103
3104                 DEBUG(10, ("construct_notify_printer_info: "
3105                            "calling [%s]  snum=%d  printername=[%s])\n",
3106                            notify_info_data_table[j].name, snum,
3107                            pinfo2->printername));
3108
3109                 notify_info_data_table[j].fn(snum, current_data, queue,
3110                                              pinfo2, mem_ctx);
3111
3112                 info->count++;
3113         }
3114
3115         return true;
3116 }
3117
3118 /*******************************************************************
3119  *
3120  * fill a notify_info struct with info asked
3121  *
3122  ********************************************************************/
3123
3124 static bool construct_notify_jobs_info(print_queue_struct *queue,
3125                                        struct spoolss_NotifyInfo *info,
3126                                        struct spoolss_PrinterInfo2 *pinfo2,
3127                                        int snum,
3128                                        const struct spoolss_NotifyOptionType *option_type,
3129                                        uint32_t id,
3130                                        TALLOC_CTX *mem_ctx)
3131 {
3132         int field_num,j;
3133         enum spoolss_NotifyType type;
3134         uint16_t field;
3135         struct spoolss_Notify *current_data;
3136
3137         DEBUG(4,("construct_notify_jobs_info\n"));
3138
3139         type = option_type->type;
3140
3141         DEBUGADD(4,("Notify type: [%s], number of notify info: [%d]\n",
3142                 (type == PRINTER_NOTIFY_TYPE ? "PRINTER_NOTIFY_TYPE" : "JOB_NOTIFY_TYPE"),
3143                 option_type->count));
3144
3145         for(field_num=0; field_num<option_type->count; field_num++) {
3146                 field = option_type->fields[field_num].field;
3147
3148                 if (!search_notify(type, field, &j) )
3149                         continue;
3150
3151                 info->notifies = TALLOC_REALLOC_ARRAY(info, info->notifies,
3152                                                       struct spoolss_Notify,
3153                                                       info->count + 1);
3154                 if (info->notifies == NULL) {
3155                         DEBUG(2,("construct_notify_jobs_info: failed to enlarg buffer info->data!\n"));
3156                         return false;
3157                 }
3158
3159                 current_data=&(info->notifies[info->count]);
3160
3161                 construct_info_data(current_data, type, field, id);
3162                 notify_info_data_table[j].fn(snum, current_data, queue,
3163                                              pinfo2, mem_ctx);
3164                 info->count++;
3165         }
3166
3167         return true;
3168 }
3169
3170 /*
3171  * JFM: The enumeration is not that simple, it's even non obvious.
3172  *
3173  * let's take an example: I want to monitor the PRINTER SERVER for
3174  * the printer's name and the number of jobs currently queued.
3175  * So in the NOTIFY_OPTION, I have one NOTIFY_OPTION_TYPE structure.
3176  * Its type is PRINTER_NOTIFY_TYPE and it has 2 fields NAME and CJOBS.
3177  *
3178  * I have 3 printers on the back of my server.
3179  *
3180  * Now the response is a NOTIFY_INFO structure, with 6 NOTIFY_INFO_DATA
3181  * structures.
3182  *   Number     Data                    Id
3183  *      1       printer 1 name          1
3184  *      2       printer 1 cjob          1
3185  *      3       printer 2 name          2
3186  *      4       printer 2 cjob          2
3187  *      5       printer 3 name          3
3188  *      6       printer 3 name          3
3189  *
3190  * that's the print server case, the printer case is even worse.
3191  */
3192
3193 /*******************************************************************
3194  *
3195  * enumerate all printers on the printserver
3196  * fill a notify_info struct with info asked
3197  *
3198  ********************************************************************/
3199
3200 static WERROR printserver_notify_info(struct pipes_struct *p,
3201                                       struct policy_handle *hnd,
3202                                       struct spoolss_NotifyInfo *info,
3203                                       TALLOC_CTX *mem_ctx)
3204 {
3205         int snum;
3206         Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
3207         int n_services=lp_numservices();
3208         int i;
3209         struct spoolss_NotifyOption *option;
3210         struct spoolss_NotifyOptionType option_type;
3211         struct spoolss_PrinterInfo2 *pinfo2 = NULL;
3212         WERROR result;
3213
3214         DEBUG(4,("printserver_notify_info\n"));
3215
3216         if (!Printer)
3217                 return WERR_BADFID;
3218
3219         option = Printer->notify.option;
3220
3221         info->version   = 2;
3222         info->notifies  = NULL;
3223         info->count     = 0;
3224
3225         /* a bug in xp sp2 rc2 causes it to send a fnpcn request without
3226            sending a ffpcn() request first */
3227
3228         if ( !option )
3229                 return WERR_BADFID;
3230
3231         for (i=0; i<option->count; i++) {
3232                 option_type = option->types[i];
3233
3234                 if (option_type.type != PRINTER_NOTIFY_TYPE)
3235                         continue;
3236
3237                 for (snum = 0; snum < n_services; snum++) {
3238                         if (!lp_browseable(snum) ||
3239                             !lp_snum_ok(snum) ||
3240                             !lp_print_ok(snum)) {
3241                                 continue; /* skip */
3242                         }
3243
3244                         /* Maybe we should use the SYSTEM server_info here... */
3245                         result = winreg_get_printer(mem_ctx, p->server_info,
3246                                                     p->msg_ctx,
3247                                                     Printer->servername,
3248                                                     lp_servicename(snum),
3249                                                     &pinfo2);
3250                         if (!W_ERROR_IS_OK(result)) {
3251                                 DEBUG(4, ("printserver_notify_info: "
3252                                           "Failed to get printer [%s]\n",
3253                                           lp_servicename(snum)));
3254                                 continue;
3255                         }
3256
3257
3258                         construct_notify_printer_info(Printer, info,
3259                                                       pinfo2, snum,
3260                                                       &option_type, snum,
3261                                                       mem_ctx);
3262
3263                         TALLOC_FREE(pinfo2);
3264                 }
3265         }
3266
3267 #if 0
3268         /*
3269          * Debugging information, don't delete.
3270          */
3271
3272         DEBUG(1,("dumping the NOTIFY_INFO\n"));
3273         DEBUGADD(1,("info->version:[%d], info->flags:[%d], info->count:[%d]\n", info->version, info->flags, info->count));
3274         DEBUGADD(1,("num\ttype\tfield\tres\tid\tsize\tenc_type\n"));
3275
3276         for (i=0; i<info->count; i++) {
3277                 DEBUGADD(1,("[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\n",
3278                 i, info->data[i].type, info->data[i].field, info->data[i].reserved,
3279                 info->data[i].id, info->data[i].size, info->data[i].enc_type));
3280         }
3281 #endif
3282
3283         return WERR_OK;
3284 }
3285
3286 /*******************************************************************
3287  *
3288  * fill a notify_info struct with info asked
3289  *
3290  ********************************************************************/
3291
3292 static WERROR printer_notify_info(struct pipes_struct *p,
3293                                   struct policy_handle *hnd,
3294                                   struct spoolss_NotifyInfo *info,
3295                                   TALLOC_CTX *mem_ctx)
3296 {
3297         int snum;
3298         Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
3299         int i;
3300         uint32_t id;
3301         struct spoolss_NotifyOption *option;
3302         struct spoolss_NotifyOptionType option_type;
3303         int count,j;
3304         print_queue_struct *queue=NULL;
3305         print_status_struct status;
3306         struct spoolss_PrinterInfo2 *pinfo2 = NULL;
3307         WERROR result;
3308
3309         DEBUG(4,("printer_notify_info\n"));
3310
3311         if (!Printer)
3312                 return WERR_BADFID;
3313
3314         option = Printer->notify.option;
3315         id = 0x0;
3316
3317         info->version   = 2;
3318         info->notifies  = NULL;
3319         info->count     = 0;
3320
3321         /* a bug in xp sp2 rc2 causes it to send a fnpcn request without
3322            sending a ffpcn() request first */
3323
3324         if ( !option )
3325                 return WERR_BADFID;
3326
3327         get_printer_snum(p, hnd, &snum, NULL);
3328
3329         /* Maybe we should use the SYSTEM server_info here... */
3330         result = winreg_get_printer(mem_ctx, p->server_info, p->msg_ctx,
3331                                     Printer->servername,
3332                                     lp_servicename(snum), &pinfo2);
3333         if (!W_ERROR_IS_OK(result)) {
3334                 return WERR_BADFID;
3335         }
3336
3337         for (i=0; i<option->count; i++) {
3338                 option_type = option->types[i];
3339
3340                 switch (option_type.type) {
3341                 case PRINTER_NOTIFY_TYPE:
3342                         if (construct_notify_printer_info(Printer, info,
3343                                                           pinfo2, snum,
3344                                                           &option_type, id,
3345                                                           mem_ctx)) {
3346                                 id--;
3347                         }
3348                         break;
3349
3350                 case JOB_NOTIFY_TYPE:
3351
3352                         count = print_queue_status(snum, &queue, &status);
3353
3354                         for (j=0; j<count; j++) {
3355                                 construct_notify_jobs_info(&queue[j], info,
3356                                                            pinfo2, snum,
3357                                                            &option_type,
3358                                                            queue[j].job,
3359                                                            mem_ctx);
3360                         }
3361
3362                         SAFE_FREE(queue);
3363                         break;
3364                 }
3365         }
3366
3367         /*
3368          * Debugging information, don't delete.
3369          */
3370         /*
3371         DEBUG(1,("dumping the NOTIFY_INFO\n"));
3372         DEBUGADD(1,("info->version:[%d], info->flags:[%d], info->count:[%d]\n", info->version, info->flags, info->count));
3373         DEBUGADD(1,("num\ttype\tfield\tres\tid\tsize\tenc_type\n"));
3374
3375         for (i=0; i<info->count; i++) {
3376                 DEBUGADD(1,("[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\n",
3377                 i, info->data[i].type, info->data[i].field, info->data[i].reserved,
3378                 info->data[i].id, info->data[i].size, info->data[i].enc_type));
3379         }
3380         */
3381
3382         talloc_free(pinfo2);
3383         return WERR_OK;
3384 }
3385
3386 /****************************************************************
3387  _spoolss_RouterRefreshPrinterChangeNotify
3388 ****************************************************************/
3389
3390 WERROR _spoolss_RouterRefreshPrinterChangeNotify(struct pipes_struct *p,
3391                                                  struct spoolss_RouterRefreshPrinterChangeNotify *r)
3392 {
3393         struct spoolss_NotifyInfo *info;
3394
3395         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
3396         WERROR result = WERR_BADFID;
3397
3398         /* we always have a spoolss_NotifyInfo struct */
3399         info = talloc_zero(p->mem_ctx, struct spoolss_NotifyInfo);
3400         if (!info) {
3401                 result = WERR_NOMEM;
3402                 goto done;
3403         }
3404
3405         *r->out.info = info;
3406
3407         if (!Printer) {
3408                 DEBUG(2,("_spoolss_RouterRefreshPrinterChangeNotify: "
3409                         "Invalid handle (%s:%u:%u).\n",
3410                         OUR_HANDLE(r->in.handle)));
3411                 goto done;
3412         }
3413
3414         DEBUG(4,("Printer type %x\n",Printer->printer_type));
3415
3416         /*
3417          *      We are now using the change value, and
3418          *      I should check for PRINTER_NOTIFY_OPTIONS_REFRESH but as
3419          *      I don't have a global notification system, I'm sending back all the
3420          *      informations even when _NOTHING_ has changed.
3421          */
3422
3423         /* We need to keep track of the change value to send back in
3424            RRPCN replies otherwise our updates are ignored. */
3425
3426         Printer->notify.fnpcn = true;
3427
3428         if (Printer->notify.client_connected) {
3429                 DEBUG(10,("_spoolss_RouterRefreshPrinterChangeNotify: "
3430                         "Saving change value in request [%x]\n",
3431                         r->in.change_low));
3432                 Printer->notify.change = r->in.change_low;
3433         }
3434
3435         /* just ignore the spoolss_NotifyOption */
3436
3437         switch (Printer->printer_type) {
3438                 case SPLHND_SERVER:
3439                         result = printserver_notify_info(p, r->in.handle,
3440                                                          info, p->mem_ctx);
3441                         break;
3442
3443                 case SPLHND_PRINTER:
3444                         result = printer_notify_info(p, r->in.handle,
3445                                                      info, p->mem_ctx);
3446                         break;
3447         }
3448
3449         Printer->notify.fnpcn = false;
3450
3451 done:
3452         return result;
3453 }
3454
3455 /********************************************************************
3456  * construct_printer_info_0
3457  * fill a printer_info_0 struct
3458  ********************************************************************/
3459
3460 static WERROR construct_printer_info0(TALLOC_CTX *mem_ctx,
3461                                       struct auth_serversupplied_info *server_info,
3462                                       struct messaging_context *msg_ctx,
3463                                       struct spoolss_PrinterInfo2 *info2,
3464                                       struct spoolss_PrinterInfo0 *r,
3465                                       int snum)
3466 {
3467         int count;
3468         counter_printer_0 *session_counter;
3469         struct timeval setuptime;
3470         print_status_struct status;
3471
3472         r->printername          = talloc_strdup(mem_ctx, info2->printername);
3473         W_ERROR_HAVE_NO_MEMORY(r->printername);
3474
3475         r->servername           = talloc_strdup(mem_ctx, info2->servername);
3476         W_ERROR_HAVE_NO_MEMORY(r->servername);
3477
3478         count = print_queue_length(snum, &status);
3479
3480         /* check if we already have a counter for this printer */
3481         for (session_counter = counter_list; session_counter; session_counter = session_counter->next) {
3482                 if (session_counter->snum == snum)
3483                         break;
3484         }
3485
3486         /* it's the first time, add it to the list */
3487         if (session_counter == NULL) {
3488                 session_counter = SMB_MALLOC_P(counter_printer_0);
3489                 W_ERROR_HAVE_NO_MEMORY(session_counter);
3490                 ZERO_STRUCTP(session_counter);
3491                 session_counter->snum           = snum;
3492                 session_counter->counter        = 0;
3493                 DLIST_ADD(counter_list, session_counter);
3494         }
3495
3496         /* increment it */
3497         session_counter->counter++;
3498
3499         r->cjobs                        = count;
3500         r->total_jobs                   = 0;
3501         r->total_bytes                  = 0;
3502
3503         get_startup_time(&setuptime);
3504         init_systemtime(&r->time, gmtime(&setuptime.tv_sec));
3505
3506         /* JFM:
3507          * the global_counter should be stored in a TDB as it's common to all the clients
3508          * and should be zeroed on samba startup
3509          */
3510         r->global_counter               = session_counter->counter;
3511         r->total_pages                  = 0;
3512         /* in 2.2 we reported ourselves as 0x0004 and 0x0565 */
3513         SSVAL(&r->version, 0, 0x0005); /* NT 5 */
3514         SSVAL(&r->version, 2, 0x0893); /* build 2195 */
3515         r->free_build                   = SPOOLSS_RELEASE_BUILD;
3516         r->spooling                     = 0;
3517         r->max_spooling                 = 0;
3518         r->session_counter              = session_counter->counter;
3519         r->num_error_out_of_paper       = 0x0;
3520         r->num_error_not_ready          = 0x0;          /* number of print failure */
3521         r->job_error                    = 0x0;
3522         r->number_of_processors         = 0x1;
3523         r->processor_type               = PROCESSOR_INTEL_PENTIUM; /* 586 Pentium ? */
3524         r->high_part_total_bytes        = 0x0;
3525
3526         /* ChangeID in milliseconds*/
3527         winreg_printer_get_changeid(mem_ctx, server_info, msg_ctx,
3528                                     info2->sharename, &r->change_id);
3529
3530         r->last_error                   = WERR_OK;
3531         r->status                       = nt_printq_status(status.status);
3532         r->enumerate_network_printers   = 0x0;
3533         r->c_setprinter                 = 0x0;
3534         r->processor_architecture       = 0x0;
3535         r->processor_level              = 0x6;          /* 6  ???*/
3536         r->ref_ic                       = 0;
3537         r->reserved2                    = 0;
3538         r->reserved3                    = 0;
3539
3540         return WERR_OK;
3541 }
3542
3543
3544 /********************************************************************
3545  * construct_printer_info1
3546  * fill a spoolss_PrinterInfo1 struct
3547 ********************************************************************/
3548
3549 static WERROR construct_printer_info1(TALLOC_CTX *mem_ctx,
3550                                       const struct spoolss_PrinterInfo2 *info2,
3551                                       uint32_t flags,
3552                                       struct spoolss_PrinterInfo1 *r,
3553                                       int snum)
3554 {
3555         r->flags                = flags;
3556
3557         r->description          = talloc_asprintf(mem_ctx, "%s,%s,%s",
3558                                                   info2->printername,
3559                                                   info2->drivername,
3560                                                   info2->location);
3561         W_ERROR_HAVE_NO_MEMORY(r->description);
3562
3563         if (info2->comment == NULL || info2->comment[0] == '\0') {
3564                 r->comment      = talloc_strdup(mem_ctx, lp_comment(snum));
3565         } else {
3566                 r->comment      = talloc_strdup(mem_ctx, info2->comment); /* saved comment */
3567         }
3568         W_ERROR_HAVE_NO_MEMORY(r->comment);
3569
3570         r->name                 = talloc_strdup(mem_ctx, info2->printername);
3571         W_ERROR_HAVE_NO_MEMORY(r->name);
3572
3573         return WERR_OK;
3574 }
3575
3576 /********************************************************************
3577  * construct_printer_info2
3578  * fill a spoolss_PrinterInfo2 struct
3579 ********************************************************************/
3580
3581 static WERROR construct_printer_info2(TALLOC_CTX *mem_ctx,
3582                                       const struct spoolss_PrinterInfo2 *info2,
3583                                       struct spoolss_PrinterInfo2 *r,
3584                                       int snum)
3585 {
3586         int count;
3587         print_status_struct status;
3588
3589         count = print_queue_length(snum, &status);
3590
3591         r->servername           = talloc_strdup(mem_ctx, info2->servername);
3592         W_ERROR_HAVE_NO_MEMORY(r->servername);
3593         r->printername          = talloc_strdup(mem_ctx, info2->printername);
3594         W_ERROR_HAVE_NO_MEMORY(r->printername);
3595         r->sharename            = talloc_strdup(mem_ctx, lp_servicename(snum));
3596         W_ERROR_HAVE_NO_MEMORY(r->sharename);
3597         r->portname             = talloc_strdup(mem_ctx, info2->portname);
3598         W_ERROR_HAVE_NO_MEMORY(r->portname);
3599         r->drivername           = talloc_strdup(mem_ctx, info2->drivername);
3600         W_ERROR_HAVE_NO_MEMORY(r->drivername);
3601
3602         if (info2->comment[0] == '\0') {
3603                 r->comment      = talloc_strdup(mem_ctx, lp_comment(snum));
3604         } else {
3605                 r->comment      = talloc_strdup(mem_ctx, info2->comment);
3606         }
3607         W_ERROR_HAVE_NO_MEMORY(r->comment);
3608
3609         r->location             = talloc_strdup(mem_ctx, info2->location);
3610         W_ERROR_HAVE_NO_MEMORY(r->location);
3611         r->sepfile              = talloc_strdup(mem_ctx, info2->sepfile);
3612         W_ERROR_HAVE_NO_MEMORY(r->sepfile);
3613         r->printprocessor       = talloc_strdup(mem_ctx, info2->printprocessor);
3614         W_ERROR_HAVE_NO_MEMORY(r->printprocessor);
3615         r->datatype             = talloc_strdup(mem_ctx, info2->datatype);
3616         W_ERROR_HAVE_NO_MEMORY(r->datatype);
3617         r->parameters           = talloc_strdup(mem_ctx, info2->parameters);
3618         W_ERROR_HAVE_NO_MEMORY(r->parameters);
3619
3620         r->attributes           = info2->attributes;
3621
3622         r->priority             = info2->priority;
3623         r->defaultpriority      = info2->defaultpriority;
3624         r->starttime            = info2->starttime;
3625         r->untiltime            = info2->untiltime;
3626         r->status               = nt_printq_status(status.status);
3627         r->cjobs                = count;
3628         r->averageppm           = info2->averageppm;
3629
3630         copy_devicemode(mem_ctx, info2->devmode, &r->devmode);
3631         if (!r->devmode) {
3632                 DEBUG(8,("Returning NULL Devicemode!\n"));
3633         }
3634
3635         r->secdesc = NULL;
3636
3637         if (info2->secdesc != NULL) {
3638                 /* don't use talloc_steal() here unless you do a deep steal of all
3639                    the SEC_DESC members */
3640
3641                 r->secdesc      = dup_sec_desc(mem_ctx, info2->secdesc);
3642         }
3643
3644         return WERR_OK;
3645 }
3646
3647 /********************************************************************
3648  * construct_printer_info3
3649  * fill a spoolss_PrinterInfo3 struct
3650  ********************************************************************/
3651
3652 static WERROR construct_printer_info3(TALLOC_CTX *mem_ctx,
3653                                       const struct spoolss_PrinterInfo2 *info2,
3654                                       struct spoolss_PrinterInfo3 *r,
3655                                       int snum)
3656 {
3657         /* These are the components of the SD we are returning. */
3658
3659         if (info2->secdesc != NULL) {
3660                 /* don't use talloc_steal() here unless you do a deep steal of all
3661                    the SEC_DESC members */
3662
3663                 r->secdesc = dup_sec_desc(mem_ctx, info2->secdesc);
3664                 W_ERROR_HAVE_NO_MEMORY(r->secdesc);
3665         }
3666
3667         return WERR_OK;
3668 }
3669
3670 /********************************************************************
3671  * construct_printer_info4
3672  * fill a spoolss_PrinterInfo4 struct
3673  ********************************************************************/
3674
3675 static WERROR construct_printer_info4(TALLOC_CTX *mem_ctx,
3676                                       const struct spoolss_PrinterInfo2 *info2,
3677                                       struct spoolss_PrinterInfo4 *r,
3678                                       int snum)
3679 {
3680         r->printername  = talloc_strdup(mem_ctx, info2->printername);
3681         W_ERROR_HAVE_NO_MEMORY(r->printername);
3682         r->servername   = talloc_strdup(mem_ctx, info2->servername);
3683         W_ERROR_HAVE_NO_MEMORY(r->servername);
3684
3685         r->attributes   = info2->attributes;
3686
3687         return WERR_OK;
3688 }
3689
3690 /********************************************************************
3691  * construct_printer_info5
3692  * fill a spoolss_PrinterInfo5 struct
3693  ********************************************************************/
3694
3695 static WERROR construct_printer_info5(TALLOC_CTX *mem_ctx,
3696                                       const struct spoolss_PrinterInfo2 *info2,
3697                                       struct spoolss_PrinterInfo5 *r,
3698                                       int snum)
3699 {
3700         r->printername  = talloc_strdup(mem_ctx, info2->printername);
3701         W_ERROR_HAVE_NO_MEMORY(r->printername);
3702         r->portname     = talloc_strdup(mem_ctx, info2->portname);
3703         W_ERROR_HAVE_NO_MEMORY(r->portname);
3704
3705         r->attributes   = info2->attributes;
3706
3707         /* these two are not used by NT+ according to MSDN */
3708         r->device_not_selected_timeout          = 0x0;  /* have seen 0x3a98 */
3709         r->transmission_retry_timeout           = 0x0;  /* have seen 0xafc8 */
3710
3711         return WERR_OK;
3712 }
3713
3714 /********************************************************************
3715  * construct_printer_info_6
3716  * fill a spoolss_PrinterInfo6 struct
3717  ********************************************************************/
3718
3719 static WERROR construct_printer_info6(TALLOC_CTX *mem_ctx,
3720                                       const struct spoolss_PrinterInfo2 *info2,
3721                                       struct spoolss_PrinterInfo6 *r,
3722                                       int snum)
3723 {
3724         int count;
3725         print_status_struct status;
3726
3727         count = print_queue_length(snum, &status);
3728
3729         r->status = nt_printq_status(status.status);
3730
3731         return WERR_OK;
3732 }
3733
3734 /********************************************************************
3735  * construct_printer_info7
3736  * fill a spoolss_PrinterInfo7 struct
3737  ********************************************************************/
3738
3739 static WERROR construct_printer_info7(TALLOC_CTX *mem_ctx,
3740                                       Printer_entry *print_hnd,
3741                                       struct spoolss_PrinterInfo7 *r,
3742                                       int snum)
3743 {
3744         struct auth_serversupplied_info *server_info;
3745         struct GUID guid;
3746         NTSTATUS status;
3747
3748         status = make_server_info_system(mem_ctx, &server_info);
3749         if (!NT_STATUS_IS_OK(status)) {
3750                 DEBUG(0, ("construct_printer_info7: "
3751                           "Could not create system server_info\n"));
3752                 return WERR_NOMEM;
3753         }
3754
3755         if (is_printer_published(mem_ctx, server_info, print_hnd->servername,
3756                                  lp_servicename(snum), &guid, NULL)) {
3757                 r->guid = talloc_strdup_upper(mem_ctx, GUID_string2(mem_ctx, &guid));
3758                 r->action = DSPRINT_PUBLISH;
3759         } else {
3760                 r->guid = talloc_strdup(mem_ctx, "");
3761                 r->action = DSPRINT_UNPUBLISH;
3762         }
3763         W_ERROR_HAVE_NO_MEMORY(r->guid);
3764
3765         TALLOC_FREE(server_info);
3766         return WERR_OK;
3767 }
3768
3769 /********************************************************************
3770  * construct_printer_info8
3771  * fill a spoolss_PrinterInfo8 struct
3772  ********************************************************************/
3773
3774 static WERROR construct_printer_info8(TALLOC_CTX *mem_ctx,
3775                                       const struct spoolss_PrinterInfo2 *info2,
3776                                       struct spoolss_DeviceModeInfo *r,
3777                                       int snum)
3778 {
3779         copy_devicemode(mem_ctx, info2->devmode, &r->devmode);
3780         if (!r->devmode) {
3781                 DEBUG(8,("Returning NULL Devicemode!\n"));
3782         }
3783
3784         return WERR_OK;
3785 }
3786
3787
3788 /********************************************************************
3789 ********************************************************************/
3790
3791 static bool snum_is_shared_printer(int snum)
3792 {
3793         return (lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum));
3794 }
3795
3796 /********************************************************************
3797  Spoolss_enumprinters.
3798 ********************************************************************/
3799
3800 static WERROR enum_all_printers_info_level(TALLOC_CTX *mem_ctx,
3801                                            struct auth_serversupplied_info *server_info,
3802                                            struct messaging_context *msg_ctx,
3803                                            uint32_t level,
3804                                            uint32_t flags,
3805                                            union spoolss_PrinterInfo **info_p,
3806                                            uint32_t *count_p)
3807 {
3808         int snum;
3809         int n_services = lp_numservices();
3810         union spoolss_PrinterInfo *info = NULL;
3811         uint32_t count = 0;
3812         WERROR result = WERR_OK;
3813
3814         *count_p = 0;
3815         *info_p = NULL;
3816
3817         for (snum = 0; snum < n_services; snum++) {
3818
3819                 const char *printer;
3820                 struct spoolss_PrinterInfo2 *info2;
3821
3822                 if (!snum_is_shared_printer(snum)) {
3823                         continue;
3824                 }
3825
3826                 printer = lp_const_servicename(snum);
3827
3828                 DEBUG(4,("Found a printer in smb.conf: %s[%x]\n",
3829                         printer, snum));
3830
3831                 result = winreg_create_printer(mem_ctx,
3832                                                server_info,
3833                                                msg_ctx,
3834                                                NULL,
3835                                                printer);
3836                 if (!W_ERROR_IS_OK(result)) {
3837                         goto out;
3838                 }
3839
3840                 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
3841                                             union spoolss_PrinterInfo,
3842                                             count + 1);
3843                 if (!info) {
3844                         result = WERR_NOMEM;
3845                         goto out;
3846                 }
3847
3848                 result = winreg_get_printer(mem_ctx, server_info, msg_ctx,
3849                                             NULL, printer, &info2);
3850                 if (!W_ERROR_IS_OK(result)) {
3851                         goto out;
3852                 }
3853
3854                 switch (level) {
3855                 case 0:
3856                         result = construct_printer_info0(info, server_info,
3857                                                          msg_ctx, info2,
3858                                                          &info[count].info0, snum);
3859                         break;
3860                 case 1:
3861                         result = construct_printer_info1(info, info2, flags,
3862                                                          &info[count].info1, snum);
3863                         break;
3864                 case 2:
3865                         result = construct_printer_info2(info, info2,
3866                                                          &info[count].info2, snum);
3867                         break;
3868                 case 4:
3869                         result = construct_printer_info4(info, info2,
3870                                                          &info[count].info4, snum);
3871                         break;
3872                 case 5:
3873                         result = construct_printer_info5(info, info2,
3874                                                          &info[count].info5, snum);
3875                         break;
3876
3877                 default:
3878                         result = WERR_UNKNOWN_LEVEL;
3879                         goto out;
3880                 }
3881
3882                 if (!W_ERROR_IS_OK(result)) {
3883                         goto out;
3884                 }
3885
3886                 count++;
3887         }
3888
3889         *count_p = count;
3890         *info_p = info;
3891
3892  out:
3893         if (!W_ERROR_IS_OK(result)) {
3894                 TALLOC_FREE(info);
3895                 return result;
3896         }
3897
3898         *info_p = info;
3899
3900         return WERR_OK;
3901 }
3902
3903 /********************************************************************
3904  * handle enumeration of printers at level 0
3905  ********************************************************************/
3906
3907 static WERROR enumprinters_level0(TALLOC_CTX *mem_ctx,
3908                                   struct auth_serversupplied_info *server_info,
3909                                   uint32_t flags,
3910                                   const char *servername,
3911                                   union spoolss_PrinterInfo **info,
3912                                   uint32_t *count)
3913 {
3914         DEBUG(4,("enum_all_printers_info_0\n"));
3915
3916         return enum_all_printers_info_level(mem_ctx, server_info,
3917                                             smbd_messaging_context(),
3918                                             0, flags, info, count);
3919 }
3920
3921
3922 /********************************************************************
3923 ********************************************************************/
3924
3925 static WERROR enum_all_printers_info_1(TALLOC_CTX *mem_ctx,
3926                                        struct auth_serversupplied_info *server_info,
3927                                        uint32_t flags,
3928                                        union spoolss_PrinterInfo **info,
3929                                        uint32_t *count)
3930 {
3931         DEBUG(4,("enum_all_printers_info_1\n"));
3932
3933         return enum_all_printers_info_level(mem_ctx, server_info,
3934                                             smbd_messaging_context(), 1, flags, info, count);
3935 }
3936
3937 /********************************************************************
3938  enum_all_printers_info_1_local.
3939 *********************************************************************/
3940
3941 static WERROR enum_all_printers_info_1_local(TALLOC_CTX *mem_ctx,
3942                                              struct auth_serversupplied_info *server_info,
3943                                              union spoolss_PrinterInfo **info,
3944                                              uint32_t *count)
3945 {
3946         DEBUG(4,("enum_all_printers_info_1_local\n"));
3947
3948         return enum_all_printers_info_1(mem_ctx, server_info, PRINTER_ENUM_ICON8, info, count);
3949 }
3950
3951 /********************************************************************
3952  enum_all_printers_info_1_name.
3953 *********************************************************************/
3954
3955 static WERROR enum_all_printers_info_1_name(TALLOC_CTX *mem_ctx,
3956                                             struct auth_serversupplied_info *server_info,
3957                                             const char *name,
3958                                             union spoolss_PrinterInfo **info,
3959                                             uint32_t *count)
3960 {
3961         const char *s = name;
3962
3963         DEBUG(4,("enum_all_printers_info_1_name\n"));
3964
3965         if ((name[0] == '\\') && (name[1] == '\\')) {
3966                 s = name + 2;
3967         }
3968
3969         if (!is_myname_or_ipaddr(s)) {
3970                 return WERR_INVALID_NAME;
3971         }
3972
3973         return enum_all_printers_info_1(mem_ctx, server_info, PRINTER_ENUM_ICON8, info, count);
3974 }
3975
3976 /********************************************************************
3977  enum_all_printers_info_1_network.
3978 *********************************************************************/
3979
3980 static WERROR enum_all_printers_info_1_network(TALLOC_CTX *mem_ctx,
3981                                                struct auth_serversupplied_info *server_info,
3982                                                const char *name,
3983                                                union spoolss_PrinterInfo **info,
3984                                                uint32_t *count)
3985 {
3986         const char *s = name;
3987
3988         DEBUG(4,("enum_all_printers_info_1_network\n"));
3989
3990         /* If we respond to a enum_printers level 1 on our name with flags
3991            set to PRINTER_ENUM_REMOTE with a list of printers then these
3992            printers incorrectly appear in the APW browse list.
3993            Specifically the printers for the server appear at the workgroup
3994            level where all the other servers in the domain are
3995            listed. Windows responds to this call with a
3996            WERR_CAN_NOT_COMPLETE so we should do the same. */
3997
3998         if (name[0] == '\\' && name[1] == '\\') {
3999                  s = name + 2;
4000         }
4001
4002         if (is_myname_or_ipaddr(s)) {
4003                  return WERR_CAN_NOT_COMPLETE;
4004         }
4005
4006         return enum_all_printers_info_1(mem_ctx, server_info, PRINTER_ENUM_NAME, info, count);
4007 }
4008
4009 /********************************************************************
4010  * api_spoolss_enumprinters
4011  *
4012  * called from api_spoolss_enumprinters (see this to understand)
4013  ********************************************************************/
4014
4015 static WERROR enum_all_printers_info_2(TALLOC_CTX *mem_ctx,
4016                                        struct auth_serversupplied_info *server_info,
4017                                        union spoolss_PrinterInfo **info,
4018                                        uint32_t *count)
4019 {
4020         DEBUG(4,("enum_all_printers_info_2\n"));
4021
4022         return enum_all_printers_info_level(mem_ctx, server_info,
4023                                             smbd_messaging_context(),
4024                                             2, 0, info, count);
4025 }
4026
4027 /********************************************************************
4028  * handle enumeration of printers at level 1
4029  ********************************************************************/
4030
4031 static WERROR enumprinters_level1(TALLOC_CTX *mem_ctx,
4032                                   struct auth_serversupplied_info *server_info,
4033                                   uint32_t flags,
4034                                   const char *name,
4035                                   union spoolss_PrinterInfo **info,
4036                                   uint32_t *count)
4037 {
4038         /* Not all the flags are equals */
4039
4040         if (flags & PRINTER_ENUM_LOCAL) {
4041                 return enum_all_printers_info_1_local(mem_ctx, server_info, info, count);
4042         }
4043
4044         if (flags & PRINTER_ENUM_NAME) {
4045                 return enum_all_printers_info_1_name(mem_ctx, server_info, name, info, count);
4046         }
4047
4048         if (flags & PRINTER_ENUM_NETWORK) {
4049                 return enum_all_printers_info_1_network(mem_ctx, server_info, name, info, count);
4050         }
4051
4052         return WERR_OK; /* NT4sp5 does that */
4053 }
4054
4055 /********************************************************************
4056  * handle enumeration of printers at level 2
4057  ********************************************************************/
4058
4059 static WERROR enumprinters_level2(TALLOC_CTX *mem_ctx,
4060                                   struct auth_serversupplied_info *server_info,
4061                                   uint32_t flags,
4062                                   const char *servername,
4063                                   union spoolss_PrinterInfo **info,
4064                                   uint32_t *count)
4065 {
4066         if (flags & PRINTER_ENUM_LOCAL) {
4067                 return enum_all_printers_info_2(mem_ctx, server_info, info, count);
4068         }
4069
4070         if (flags & PRINTER_ENUM_NAME) {
4071                 if (!is_myname_or_ipaddr(canon_servername(servername))) {
4072                         return WERR_INVALID_NAME;
4073                 }
4074
4075                 return enum_all_printers_info_2(mem_ctx, server_info, info, count);
4076         }
4077
4078         if (flags & PRINTER_ENUM_REMOTE) {
4079                 return WERR_UNKNOWN_LEVEL;
4080         }
4081
4082         return WERR_OK;
4083 }
4084
4085 /********************************************************************
4086  * handle enumeration of printers at level 4
4087  ********************************************************************/
4088
4089 static WERROR enumprinters_level4(TALLOC_CTX *mem_ctx,
4090                                   struct auth_serversupplied_info *server_info,
4091                                   uint32_t flags,
4092                                   const char *servername,
4093                                   union spoolss_PrinterInfo **info,
4094                                   uint32_t *count)
4095 {
4096         DEBUG(4,("enum_all_printers_info_4\n"));
4097
4098         return enum_all_printers_info_level(mem_ctx, server_info,
4099                                             smbd_messaging_context(),
4100                                             4, flags, info, count);
4101 }
4102
4103
4104 /********************************************************************
4105  * handle enumeration of printers at level 5
4106  ********************************************************************/
4107
4108 static WERROR enumprinters_level5(TALLOC_CTX *mem_ctx,
4109                                   struct auth_serversupplied_info *server_info,
4110                                   uint32_t flags,
4111                                   const char *servername,
4112                                   union spoolss_PrinterInfo **info,
4113                                   uint32_t *count)
4114 {
4115         DEBUG(4,("enum_all_printers_info_5\n"));
4116
4117         return enum_all_printers_info_level(mem_ctx, server_info,
4118                                             smbd_messaging_context(),
4119                                             5, flags, info, count);
4120 }
4121
4122 /****************************************************************
4123  _spoolss_EnumPrinters
4124 ****************************************************************/
4125
4126 WERROR _spoolss_EnumPrinters(struct pipes_struct *p,
4127                              struct spoolss_EnumPrinters *r)
4128 {
4129         const char *name = NULL;
4130         WERROR result;
4131
4132         /* that's an [in out] buffer */
4133
4134         if (!r->in.buffer && (r->in.offered != 0)) {
4135                 return WERR_INVALID_PARAM;
4136         }
4137
4138         DEBUG(4,("_spoolss_EnumPrinters\n"));
4139
4140         *r->out.needed = 0;
4141         *r->out.count = 0;
4142         *r->out.info = NULL;
4143
4144         /*
4145          * Level 1:
4146          *          flags==PRINTER_ENUM_NAME
4147          *           if name=="" then enumerates all printers
4148          *           if name!="" then enumerate the printer
4149          *          flags==PRINTER_ENUM_REMOTE
4150          *          name is NULL, enumerate printers
4151          * Level 2: name!="" enumerates printers, name can't be NULL
4152          * Level 3: doesn't exist
4153          * Level 4: does a local registry lookup
4154          * Level 5: same as Level 2
4155          */
4156
4157         if (r->in.server) {
4158                 name = talloc_strdup_upper(p->mem_ctx, r->in.server);
4159                 W_ERROR_HAVE_NO_MEMORY(name);
4160         }
4161
4162         switch (r->in.level) {
4163         case 0:
4164                 result = enumprinters_level0(p->mem_ctx, p->server_info,
4165                                              r->in.flags, name,
4166                                              r->out.info, r->out.count);
4167                 break;
4168         case 1:
4169                 result = enumprinters_level1(p->mem_ctx, p->server_info,
4170                                              r->in.flags, name,
4171                                              r->out.info, r->out.count);
4172                 break;
4173         case 2:
4174                 result = enumprinters_level2(p->mem_ctx, p->server_info,
4175                                              r->in.flags, name,
4176                                              r->out.info, r->out.count);
4177                 break;
4178         case 4:
4179                 result = enumprinters_level4(p->mem_ctx, p->server_info,
4180                                              r->in.flags, name,
4181                                              r->out.info, r->out.count);
4182                 break;
4183         case 5:
4184                 result = enumprinters_level5(p->mem_ctx, p->server_info,
4185                                              r->in.flags, name,
4186                                              r->out.info, r->out.count);
4187                 break;
4188         default:
4189                 return WERR_UNKNOWN_LEVEL;
4190         }
4191
4192         if (!W_ERROR_IS_OK(result)) {
4193                 return result;
4194         }
4195
4196         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
4197                                                      spoolss_EnumPrinters,
4198                                                      *r->out.info, r->in.level,
4199                                                      *r->out.count);
4200         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
4201         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
4202
4203         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
4204 }
4205
4206 /****************************************************************
4207  _spoolss_GetPrinter
4208 ****************************************************************/
4209
4210 WERROR _spoolss_GetPrinter(struct pipes_struct *p,
4211                            struct spoolss_GetPrinter *r)
4212 {
4213         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
4214         struct spoolss_PrinterInfo2 *info2 = NULL;
4215         WERROR result = WERR_OK;
4216         const char *servername = NULL;
4217         int snum;
4218
4219         /* that's an [in out] buffer */
4220
4221         if (!r->in.buffer && (r->in.offered != 0)) {
4222                 return WERR_INVALID_PARAM;
4223         }
4224
4225         *r->out.needed = 0;
4226
4227         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
4228                 return WERR_BADFID;
4229         }
4230
4231         if (Printer != NULL || Printer->servername != NULL) {
4232                 servername = Printer->servername;
4233         }
4234
4235         result = winreg_get_printer(p->mem_ctx,
4236                                     p->server_info,
4237                                     p->msg_ctx,
4238                                     servername,
4239                                     lp_const_servicename(snum),
4240                                     &info2);
4241         if (!W_ERROR_IS_OK(result)) {
4242                 return result;
4243         }
4244
4245         switch (r->in.level) {
4246         case 0:
4247                 result = construct_printer_info0(p->mem_ctx, p->server_info,
4248                                                  p->msg_ctx, info2,
4249                                                  &r->out.info->info0, snum);
4250                 break;
4251         case 1:
4252                 result = construct_printer_info1(p->mem_ctx, info2,
4253                                                  PRINTER_ENUM_ICON8,
4254                                                  &r->out.info->info1, snum);
4255                 break;
4256         case 2:
4257                 result = construct_printer_info2(p->mem_ctx, info2,
4258                                                  &r->out.info->info2, snum);
4259                 break;
4260         case 3:
4261                 result = construct_printer_info3(p->mem_ctx, info2,
4262                                                  &r->out.info->info3, snum);
4263                 break;
4264         case 4:
4265                 result = construct_printer_info4(p->mem_ctx, info2,
4266                                                  &r->out.info->info4, snum);
4267                 break;
4268         case 5:
4269                 result = construct_printer_info5(p->mem_ctx, info2,
4270                                                  &r->out.info->info5, snum);
4271                 break;
4272         case 6:
4273                 result = construct_printer_info6(p->mem_ctx, info2,
4274                                                  &r->out.info->info6, snum);
4275                 break;
4276         case 7:
4277                 result = construct_printer_info7(p->mem_ctx, Printer,
4278                                                  &r->out.info->info7, snum);
4279                 break;
4280         case 8:
4281                 result = construct_printer_info8(p->mem_ctx, info2,
4282                                                  &r->out.info->info8, snum);
4283                 break;
4284         default:
4285                 result = WERR_UNKNOWN_LEVEL;
4286                 break;
4287         }
4288
4289         if (!W_ERROR_IS_OK(result)) {
4290                 DEBUG(0, ("_spoolss_GetPrinter: failed to construct printer info level %d - %s\n",
4291                           r->in.level, win_errstr(result)));
4292                 TALLOC_FREE(r->out.info);
4293                 return result;
4294         }
4295
4296         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_PrinterInfo,
4297                                                r->out.info, r->in.level);
4298         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
4299
4300         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
4301 }
4302
4303 /********************************************************************
4304  ********************************************************************/
4305
4306 #define FILL_DRIVER_STRING(mem_ctx, in, out) \
4307         do { \
4308                 if (in && strlen(in)) { \
4309                         out = talloc_strdup(mem_ctx, in); \
4310                 } else { \
4311                         out = talloc_strdup(mem_ctx, ""); \
4312                 } \
4313                 W_ERROR_HAVE_NO_MEMORY(out); \
4314         } while (0);
4315
4316 #define FILL_DRIVER_UNC_STRING(mem_ctx, server, arch, ver, in, out) \
4317         do { \
4318                 if (in && strlen(in)) { \
4319                         out = talloc_asprintf(mem_ctx, "\\\\%s\\print$\\%s\\%d\\%s", server, get_short_archi(arch), ver, in); \
4320                 } else { \
4321                         out = talloc_strdup(mem_ctx, ""); \
4322                 } \
4323                 W_ERROR_HAVE_NO_MEMORY(out); \
4324         } while (0);
4325
4326 static WERROR string_array_from_driver_info(TALLOC_CTX *mem_ctx,
4327                                                   const char **string_array,
4328                                                   const char ***presult,
4329                                                   const char *cservername,
4330                                                   const char *arch,
4331                                                   int version)
4332 {
4333         int i, num_strings = 0;
4334         const char **array = NULL;
4335
4336         if (string_array == NULL) {
4337                 return WERR_INVALID_PARAMETER;;
4338         }
4339
4340         for (i=0; string_array[i] && string_array[i][0] != '\0'; i++) {
4341                 const char *str = NULL;
4342
4343                 if (cservername == NULL || arch == NULL) {
4344                         FILL_DRIVER_STRING(mem_ctx, string_array[i], str);
4345                 } else {
4346                         FILL_DRIVER_UNC_STRING(mem_ctx, cservername, arch, version, string_array[i], str);
4347                 }
4348
4349                 if (!add_string_to_array(mem_ctx, str, &array, &num_strings)) {
4350                         TALLOC_FREE(array);
4351                         return WERR_NOMEM;
4352                 }
4353         }
4354
4355         if (i > 0) {
4356                 ADD_TO_ARRAY(mem_ctx, const char *, NULL,
4357                              &array, &num_strings);
4358         }
4359
4360         if (presult) {
4361                 *presult = array;
4362         }
4363
4364         return WERR_OK;
4365 }
4366
4367 /********************************************************************
4368  * fill a spoolss_DriverInfo1 struct
4369  ********************************************************************/
4370
4371 static WERROR fill_printer_driver_info1(TALLOC_CTX *mem_ctx,
4372                                         struct spoolss_DriverInfo1 *r,
4373                                         const struct spoolss_DriverInfo8 *driver,
4374                                         const char *servername)
4375 {
4376         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
4377         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4378
4379         return WERR_OK;
4380 }
4381
4382 /********************************************************************
4383  * fill a spoolss_DriverInfo2 struct
4384  ********************************************************************/
4385
4386 static WERROR fill_printer_driver_info2(TALLOC_CTX *mem_ctx,
4387                                         struct spoolss_DriverInfo2 *r,
4388                                         const struct spoolss_DriverInfo8 *driver,
4389                                         const char *servername)
4390
4391 {
4392         const char *cservername = canon_servername(servername);
4393
4394         r->version              = driver->version;
4395
4396         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
4397         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4398         r->architecture         = talloc_strdup(mem_ctx, driver->architecture);
4399         W_ERROR_HAVE_NO_MEMORY(r->architecture);
4400
4401         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4402                                driver->architecture,
4403                                driver->version,
4404                                driver->driver_path,
4405                                r->driver_path);
4406
4407         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4408                                driver->architecture,
4409                                driver->version,
4410                                driver->data_file,
4411                                r->data_file);
4412
4413         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4414                                driver->architecture,
4415                                driver->version,
4416                                driver->config_file,
4417                                r->config_file);
4418
4419         return WERR_OK;
4420 }
4421
4422 /********************************************************************
4423  * fill a spoolss_DriverInfo3 struct
4424  ********************************************************************/
4425
4426 static WERROR fill_printer_driver_info3(TALLOC_CTX *mem_ctx,
4427                                         struct spoolss_DriverInfo3 *r,
4428                                         const struct spoolss_DriverInfo8 *driver,
4429                                         const char *servername)
4430 {
4431         const char *cservername = canon_servername(servername);
4432
4433         r->version              = driver->version;
4434
4435         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
4436         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4437         r->architecture         = talloc_strdup(mem_ctx, driver->architecture);
4438         W_ERROR_HAVE_NO_MEMORY(r->architecture);
4439
4440         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4441                                driver->architecture,
4442                                driver->version,
4443                                driver->driver_path,
4444                                r->driver_path);
4445
4446         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4447                                driver->architecture,
4448                                driver->version,
4449                                driver->data_file,
4450                                r->data_file);
4451
4452         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4453                                driver->architecture,
4454                                driver->version,
4455                                driver->config_file,
4456                                r->config_file);
4457
4458         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4459                                driver->architecture,
4460                                driver->version,
4461                                driver->help_file,
4462                                r->help_file);
4463
4464         FILL_DRIVER_STRING(mem_ctx,
4465                            driver->monitor_name,
4466                            r->monitor_name);
4467
4468         FILL_DRIVER_STRING(mem_ctx,
4469                            driver->default_datatype,
4470                            r->default_datatype);
4471
4472         return string_array_from_driver_info(mem_ctx,
4473                                              driver->dependent_files,
4474                                              &r->dependent_files,
4475                                              cservername,
4476                                              driver->architecture,
4477                                              driver->version);
4478 }
4479
4480 /********************************************************************
4481  * fill a spoolss_DriverInfo4 struct
4482  ********************************************************************/
4483
4484 static WERROR fill_printer_driver_info4(TALLOC_CTX *mem_ctx,
4485                                         struct spoolss_DriverInfo4 *r,
4486                                         const struct spoolss_DriverInfo8 *driver,
4487                                         const char *servername)
4488 {
4489         const char *cservername = canon_servername(servername);
4490         WERROR result;
4491
4492         r->version              = driver->version;
4493
4494         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
4495         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4496         r->architecture         = talloc_strdup(mem_ctx, driver->architecture);
4497         W_ERROR_HAVE_NO_MEMORY(r->architecture);
4498
4499         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4500                                driver->architecture,
4501                                driver->version,
4502                                driver->driver_path,
4503                                r->driver_path);
4504
4505         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4506                                driver->architecture,
4507                                driver->version,
4508                                driver->data_file,
4509                                r->data_file);
4510
4511         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4512                                driver->architecture,
4513                                driver->version,
4514                                driver->config_file,
4515                                r->config_file);
4516
4517         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4518                                driver->architecture,
4519                                driver->version,
4520                                driver->help_file,
4521                                r->help_file);
4522
4523         result = string_array_from_driver_info(mem_ctx,
4524                                                driver->dependent_files,
4525                                                &r->dependent_files,
4526                                                cservername,
4527                                                driver->architecture,
4528                                                driver->version);
4529         if (!W_ERROR_IS_OK(result)) {
4530                 return result;
4531         }
4532
4533         FILL_DRIVER_STRING(mem_ctx,
4534                            driver->monitor_name,
4535                            r->monitor_name);
4536
4537         FILL_DRIVER_STRING(mem_ctx,
4538                            driver->default_datatype,
4539                            r->default_datatype);
4540
4541
4542         result = string_array_from_driver_info(mem_ctx,
4543                                                driver->previous_names,
4544                                                &r->previous_names,
4545                                                NULL, NULL, 0);
4546
4547         return result;
4548 }
4549
4550 /********************************************************************
4551  * fill a spoolss_DriverInfo5 struct
4552  ********************************************************************/
4553
4554 static WERROR fill_printer_driver_info5(TALLOC_CTX *mem_ctx,
4555                                         struct spoolss_DriverInfo5 *r,
4556                                         const struct spoolss_DriverInfo8 *driver,
4557                                         const char *servername)
4558 {
4559         const char *cservername = canon_servername(servername);
4560
4561         r->version              = driver->version;
4562
4563         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
4564         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4565         r->architecture         = talloc_strdup(mem_ctx, driver->architecture);
4566         W_ERROR_HAVE_NO_MEMORY(r->architecture);
4567
4568         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4569                                driver->architecture,
4570                                driver->version,
4571                                driver->driver_path,
4572                                r->driver_path);
4573
4574         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4575                                driver->architecture,
4576                                driver->version,
4577                                driver->data_file,
4578                                r->data_file);
4579
4580         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4581                                driver->architecture,
4582                                driver->version,
4583                                driver->config_file,
4584                                r->config_file);
4585
4586         r->driver_attributes    = 0;
4587         r->config_version       = 0;
4588         r->driver_version       = 0;
4589
4590         return WERR_OK;
4591 }
4592 /********************************************************************
4593  * fill a spoolss_DriverInfo6 struct
4594  ********************************************************************/
4595
4596 static WERROR fill_printer_driver_info6(TALLOC_CTX *mem_ctx,
4597                                         struct spoolss_DriverInfo6 *r,
4598                                         const struct spoolss_DriverInfo8 *driver,
4599                                         const char *servername)
4600 {
4601         const char *cservername = canon_servername(servername);
4602         WERROR result;
4603
4604         r->version              = driver->version;
4605
4606         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
4607         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4608         r->architecture         = talloc_strdup(mem_ctx, driver->architecture);
4609         W_ERROR_HAVE_NO_MEMORY(r->architecture);
4610
4611         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4612                                driver->architecture,
4613                                driver->version,
4614                                driver->driver_path,
4615                                r->driver_path);
4616
4617         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4618                                driver->architecture,
4619                                driver->version,
4620                                driver->data_file,
4621                                r->data_file);
4622
4623         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4624                                driver->architecture,
4625                                driver->version,
4626                                driver->config_file,
4627                                r->config_file);
4628
4629         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4630                                driver->architecture,
4631                                driver->version,
4632                                driver->help_file,
4633                                r->help_file);
4634
4635         FILL_DRIVER_STRING(mem_ctx,
4636                            driver->monitor_name,
4637                            r->monitor_name);
4638
4639         FILL_DRIVER_STRING(mem_ctx,
4640                            driver->default_datatype,
4641                            r->default_datatype);
4642
4643         result = string_array_from_driver_info(mem_ctx,
4644                                                driver->dependent_files,
4645                                                &r->dependent_files,
4646                                                cservername,
4647                                                driver->architecture,
4648                                                driver->version);
4649         if (!W_ERROR_IS_OK(result)) {
4650                 return result;
4651         }
4652
4653         result = string_array_from_driver_info(mem_ctx,
4654                                                driver->previous_names,
4655                                                &r->previous_names,
4656                                                NULL, NULL, 0);
4657         if (!W_ERROR_IS_OK(result)) {
4658                 return result;
4659         }
4660
4661         r->driver_date          = driver->driver_date;
4662         r->driver_version       = driver->driver_version;
4663
4664         FILL_DRIVER_STRING(mem_ctx,
4665                            driver->manufacturer_name,
4666                            r->manufacturer_name);
4667         FILL_DRIVER_STRING(mem_ctx,
4668                            driver->manufacturer_url,
4669                            r->manufacturer_url);
4670         FILL_DRIVER_STRING(mem_ctx,
4671                            driver->hardware_id,
4672                            r->hardware_id);
4673         FILL_DRIVER_STRING(mem_ctx,
4674                            driver->provider,
4675                            r->provider);
4676
4677         return WERR_OK;
4678 }
4679
4680 /********************************************************************
4681  * fill a spoolss_DriverInfo8 struct
4682  ********************************************************************/
4683
4684 static WERROR fill_printer_driver_info8(TALLOC_CTX *mem_ctx,
4685                                         struct spoolss_DriverInfo8 *r,
4686                                         const struct spoolss_DriverInfo8 *driver,
4687                                         const char *servername)
4688 {
4689         const char *cservername = canon_servername(servername);
4690         WERROR result;
4691
4692         r->version              = driver->version;
4693
4694         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
4695         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4696         r->architecture         = talloc_strdup(mem_ctx, driver->architecture);
4697         W_ERROR_HAVE_NO_MEMORY(r->architecture);
4698
4699         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4700                                driver->architecture,
4701                                driver->version,
4702                                driver->driver_path,
4703                                r->driver_path);
4704
4705         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4706                                driver->architecture,
4707                                driver->version,
4708                                driver->data_file,
4709                                r->data_file);
4710
4711         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4712                                driver->architecture,
4713                                driver->version,
4714                                driver->config_file,
4715                                r->config_file);
4716
4717         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4718                                driver->architecture,
4719                                driver->version,
4720                                driver->help_file,
4721                                r->help_file);
4722
4723         FILL_DRIVER_STRING(mem_ctx,
4724                            driver->monitor_name,
4725                            r->monitor_name);
4726
4727         FILL_DRIVER_STRING(mem_ctx,
4728                            driver->default_datatype,
4729                            r->default_datatype);
4730
4731         result = string_array_from_driver_info(mem_ctx,
4732                                                driver->dependent_files,
4733                                                &r->dependent_files,
4734                                                cservername,
4735                                                driver->architecture,
4736                                                driver->version);
4737         if (!W_ERROR_IS_OK(result)) {
4738                 return result;
4739         }
4740
4741         result = string_array_from_driver_info(mem_ctx,
4742                                                driver->previous_names,
4743                                                &r->previous_names,
4744                                                NULL, NULL, 0);
4745         if (!W_ERROR_IS_OK(result)) {
4746                 return result;
4747         }
4748
4749         r->driver_date          = driver->driver_date;
4750         r->driver_version       = driver->driver_version;
4751
4752         FILL_DRIVER_STRING(mem_ctx,
4753                            driver->manufacturer_name,
4754                            r->manufacturer_name);
4755         FILL_DRIVER_STRING(mem_ctx,
4756                            driver->manufacturer_url,
4757                            r->manufacturer_url);
4758         FILL_DRIVER_STRING(mem_ctx,
4759                            driver->hardware_id,
4760                            r->hardware_id);
4761         FILL_DRIVER_STRING(mem_ctx,
4762                            driver->provider,
4763                            r->provider);
4764
4765         FILL_DRIVER_STRING(mem_ctx,
4766                            driver->print_processor,
4767                            r->print_processor);
4768         FILL_DRIVER_STRING(mem_ctx,
4769                            driver->vendor_setup,
4770                            r->vendor_setup);
4771
4772         result = string_array_from_driver_info(mem_ctx,
4773                                                driver->color_profiles,
4774                                                &r->color_profiles,
4775                                                NULL, NULL, 0);
4776         if (!W_ERROR_IS_OK(result)) {
4777                 return result;
4778         }
4779
4780         FILL_DRIVER_STRING(mem_ctx,
4781                            driver->inf_path,
4782                            r->inf_path);
4783
4784         r->printer_driver_attributes    = driver->printer_driver_attributes;
4785
4786         result = string_array_from_driver_info(mem_ctx,
4787                                                driver->core_driver_dependencies,
4788                                                &r->core_driver_dependencies,
4789                                                NULL, NULL, 0);
4790         if (!W_ERROR_IS_OK(result)) {
4791                 return result;
4792         }
4793
4794         r->min_inbox_driver_ver_date    = driver->min_inbox_driver_ver_date;
4795         r->min_inbox_driver_ver_version = driver->min_inbox_driver_ver_version;
4796
4797         return WERR_OK;
4798 }
4799
4800 #if 0 /* disabled until marshalling issues are resolved - gd */
4801 /********************************************************************
4802  ********************************************************************/
4803
4804 static WERROR fill_spoolss_DriverFileInfo(TALLOC_CTX *mem_ctx,
4805                                           struct spoolss_DriverFileInfo *r,
4806                                           const char *cservername,
4807                                           const char *file_name,
4808                                           enum spoolss_DriverFileType file_type,
4809                                           uint32_t file_version)
4810 {
4811         r->file_name    = talloc_asprintf(mem_ctx, "\\\\%s%s",
4812                                           cservername, file_name);
4813         W_ERROR_HAVE_NO_MEMORY(r->file_name);
4814         r->file_type    = file_type;
4815         r->file_version = file_version;
4816
4817         return WERR_OK;
4818 }
4819
4820 /********************************************************************
4821  ********************************************************************/
4822
4823 static WERROR spoolss_DriverFileInfo_from_driver(TALLOC_CTX *mem_ctx,
4824                                                  const struct spoolss_DriverInfo8 *driver,
4825                                                  const char *cservername,
4826                                                  struct spoolss_DriverFileInfo **info_p,
4827                                                  uint32_t *count_p)
4828 {
4829         struct spoolss_DriverFileInfo *info = NULL;
4830         uint32_t count = 0;
4831         WERROR result;
4832         uint32_t i;
4833
4834         *info_p = NULL;
4835         *count_p = 0;
4836
4837         if (strlen(driver->driver_path)) {
4838                 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4839                                             struct spoolss_DriverFileInfo,
4840                                             count + 1);
4841                 W_ERROR_HAVE_NO_MEMORY(info);
4842                 result = fill_spoolss_DriverFileInfo(info,
4843                                                      &info[count],
4844                                                      cservername,
4845                                                      driver->driver_path,
4846                                                      SPOOLSS_DRIVER_FILE_TYPE_RENDERING,
4847                                                      0);
4848                 W_ERROR_NOT_OK_RETURN(result);
4849                 count++;
4850         }
4851
4852         if (strlen(driver->config_file)) {
4853                 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4854                                             struct spoolss_DriverFileInfo,
4855                                             count + 1);
4856                 W_ERROR_HAVE_NO_MEMORY(info);
4857                 result = fill_spoolss_DriverFileInfo(info,
4858                                                      &info[count],
4859                                                      cservername,
4860                                                      driver->config_file,
4861                                                      SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION,
4862                                                      0);
4863                 W_ERROR_NOT_OK_RETURN(result);
4864                 count++;
4865         }
4866
4867         if (strlen(driver->data_file)) {
4868                 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4869                                             struct spoolss_DriverFileInfo,
4870                                             count + 1);
4871                 W_ERROR_HAVE_NO_MEMORY(info);
4872                 result = fill_spoolss_DriverFileInfo(info,
4873                                                      &info[count],
4874                                                      cservername,
4875                                                      driver->data_file,
4876                                                      SPOOLSS_DRIVER_FILE_TYPE_DATA,
4877                                                      0);
4878                 W_ERROR_NOT_OK_RETURN(result);
4879                 count++;
4880         }
4881
4882         if (strlen(driver->help_file)) {
4883                 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4884                                             struct spoolss_DriverFileInfo,
4885                                             count + 1);
4886                 W_ERROR_HAVE_NO_MEMORY(info);
4887                 result = fill_spoolss_DriverFileInfo(info,
4888                                                      &info[count],
4889                                                      cservername,
4890                                                      driver->help_file,
4891                                                      SPOOLSS_DRIVER_FILE_TYPE_HELP,
4892                                                      0);
4893                 W_ERROR_NOT_OK_RETURN(result);
4894                 count++;
4895         }
4896
4897         for (i=0; driver->dependent_files[i] && driver->dependent_files[i][0] != '\0'; i++) {
4898                 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4899                                             struct spoolss_DriverFileInfo,
4900                                             count + 1);
4901                 W_ERROR_HAVE_NO_MEMORY(info);
4902                 result = fill_spoolss_DriverFileInfo(info,
4903                                                      &info[count],
4904                                                      cservername,
4905                                                      driver->dependent_files[i],
4906                                                      SPOOLSS_DRIVER_FILE_TYPE_OTHER,
4907                                                      0);
4908                 W_ERROR_NOT_OK_RETURN(result);
4909                 count++;
4910         }
4911
4912         *info_p = info;
4913         *count_p = count;
4914
4915         return WERR_OK;
4916 }
4917
4918 /********************************************************************
4919  * fill a spoolss_DriverInfo101 struct
4920  ********************************************************************/
4921
4922 static WERROR fill_printer_driver_info101(TALLOC_CTX *mem_ctx,
4923                                           struct spoolss_DriverInfo101 *r,
4924                                           const struct spoolss_DriverInfo8 *driver,
4925                                           const char *servername)
4926 {
4927         const char *cservername = canon_servername(servername);
4928         WERROR result;
4929
4930         r->version              = driver->version;
4931
4932         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
4933         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4934         r->architecture         = talloc_strdup(mem_ctx, driver->architecture);
4935         W_ERROR_HAVE_NO_MEMORY(r->architecture);
4936
4937         result = spoolss_DriverFileInfo_from_driver(mem_ctx, driver,
4938                                                     cservername,
4939                                                     &r->file_info,
4940                                                     &r->file_count);
4941         if (!W_ERROR_IS_OK(result)) {
4942                 return result;
4943         }
4944
4945         FILL_DRIVER_STRING(mem_ctx,
4946                            driver->monitor_name,
4947                            r->monitor_name);
4948
4949         FILL_DRIVER_STRING(mem_ctx,
4950                            driver->default_datatype,
4951                            r->default_datatype);
4952
4953         result = string_array_from_driver_info(mem_ctx,
4954                                                driver->previous_names,
4955                                                &r->previous_names,
4956                                                NULL, NULL, 0);
4957         if (!W_ERROR_IS_OK(result)) {
4958                 return result;
4959         }
4960
4961         r->driver_date          = driver->driver_date;
4962         r->driver_version       = driver->driver_version;
4963
4964         FILL_DRIVER_STRING(mem_ctx,
4965                            driver->manufacturer_name,
4966                            r->manufacturer_name);
4967         FILL_DRIVER_STRING(mem_ctx,
4968                            driver->manufacturer_url,
4969                            r->manufacturer_url);
4970         FILL_DRIVER_STRING(mem_ctx,
4971                            driver->hardware_id,
4972                            r->hardware_id);
4973         FILL_DRIVER_STRING(mem_ctx,
4974                            driver->provider,
4975                            r->provider);
4976
4977         return WERR_OK;
4978 }
4979 #endif
4980 /********************************************************************
4981  ********************************************************************/
4982
4983 static WERROR construct_printer_driver_info_level(TALLOC_CTX *mem_ctx,
4984                                                   struct auth_serversupplied_info *server_info,
4985                                                   uint32_t level,
4986                                                   union spoolss_DriverInfo *r,
4987                                                   int snum,
4988                                                   const char *servername,
4989                                                   const char *architecture,
4990                                                   uint32_t version)
4991 {
4992         struct spoolss_PrinterInfo2 *pinfo2 = NULL;
4993         struct spoolss_DriverInfo8 *driver;
4994         WERROR result;
4995
4996         result = winreg_get_printer(mem_ctx,
4997                                     server_info,
4998                                     smbd_messaging_context(),
4999                                     servername,
5000                                     lp_const_servicename(snum),
5001                                     &pinfo2);
5002
5003         DEBUG(8,("construct_printer_driver_info_level: status: %s\n",
5004                 win_errstr(result)));
5005
5006         if (!W_ERROR_IS_OK(result)) {
5007                 return WERR_INVALID_PRINTER_NAME;
5008         }
5009
5010         result = winreg_get_driver(mem_ctx, server_info,
5011                                    smbd_messaging_context(),
5012                                    architecture,
5013                                    pinfo2->drivername, version, &driver);
5014
5015         DEBUG(8,("construct_printer_driver_info_level: status: %s\n",
5016                 win_errstr(result)));
5017
5018         if (!W_ERROR_IS_OK(result)) {
5019                 /*
5020                  * Is this a W2k client ?
5021                  */
5022
5023                 if (version < 3) {
5024                         talloc_free(pinfo2);
5025                         return WERR_UNKNOWN_PRINTER_DRIVER;
5026                 }
5027
5028                 /* Yes - try again with a WinNT driver. */
5029                 version = 2;
5030                 result = winreg_get_driver(mem_ctx, server_info,
5031                                            smbd_messaging_context(),
5032                                            architecture,
5033                                            pinfo2->drivername,
5034                                            version, &driver);
5035                 DEBUG(8,("construct_printer_driver_level: status: %s\n",
5036                         win_errstr(result)));
5037                 if (!W_ERROR_IS_OK(result)) {
5038                         talloc_free(pinfo2);
5039                         return WERR_UNKNOWN_PRINTER_DRIVER;
5040                 }
5041         }
5042
5043         switch (level) {
5044         case 1:
5045                 result = fill_printer_driver_info1(mem_ctx, &r->info1, driver, servername);
5046                 break;
5047         case 2:
5048                 result = fill_printer_driver_info2(mem_ctx, &r->info2, driver, servername);
5049                 break;
5050         case 3:
5051                 result = fill_printer_driver_info3(mem_ctx, &r->info3, driver, servername);
5052                 break;
5053         case 4:
5054                 result = fill_printer_driver_info4(mem_ctx, &r->info4, driver, servername);
5055                 break;
5056         case 5:
5057                 result = fill_printer_driver_info5(mem_ctx, &r->info5, driver, servername);
5058                 break;
5059         case 6:
5060                 result = fill_printer_driver_info6(mem_ctx, &r->info6, driver, servername);
5061                 break;
5062         case 8:
5063                 result = fill_printer_driver_info8(mem_ctx, &r->info8, driver, servername);
5064                 break;
5065 #if 0 /* disabled until marshalling issues are resolved - gd */
5066         case 101:
5067                 result = fill_printer_driver_info101(mem_ctx, &r->info101, driver, servername);
5068                 break;
5069 #endif
5070         default:
5071                 result = WERR_UNKNOWN_LEVEL;
5072                 break;
5073         }
5074
5075         talloc_free(pinfo2);
5076         talloc_free(driver);
5077
5078         return result;
5079 }
5080
5081 /****************************************************************
5082  _spoolss_GetPrinterDriver2
5083 ****************************************************************/
5084
5085 WERROR _spoolss_GetPrinterDriver2(struct pipes_struct *p,
5086                                   struct spoolss_GetPrinterDriver2 *r)
5087 {
5088         Printer_entry *printer;
5089         WERROR result;
5090
5091         int snum;
5092
5093         /* that's an [in out] buffer */
5094
5095         if (!r->in.buffer && (r->in.offered != 0)) {
5096                 return WERR_INVALID_PARAM;
5097         }
5098
5099         DEBUG(4,("_spoolss_GetPrinterDriver2\n"));
5100
5101         if (!(printer = find_printer_index_by_hnd(p, r->in.handle))) {
5102                 DEBUG(0,("_spoolss_GetPrinterDriver2: invalid printer handle!\n"));
5103                 return WERR_INVALID_PRINTER_NAME;
5104         }
5105
5106         *r->out.needed = 0;
5107         *r->out.server_major_version = 0;
5108         *r->out.server_minor_version = 0;
5109
5110         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5111                 return WERR_BADFID;
5112         }
5113
5114         result = construct_printer_driver_info_level(p->mem_ctx, p->server_info,
5115                                                      r->in.level, r->out.info,
5116                                                      snum, printer->servername,
5117                                                      r->in.architecture,
5118                                                      r->in.client_major_version);
5119         if (!W_ERROR_IS_OK(result)) {
5120                 TALLOC_FREE(r->out.info);
5121                 return result;
5122         }
5123
5124         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_DriverInfo,
5125                                                r->out.info, r->in.level);
5126         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
5127
5128         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
5129 }
5130
5131
5132 /****************************************************************
5133  _spoolss_StartPagePrinter
5134 ****************************************************************/
5135
5136 WERROR _spoolss_StartPagePrinter(struct pipes_struct *p,
5137                                  struct spoolss_StartPagePrinter *r)
5138 {
5139         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5140
5141         if (!Printer) {
5142                 DEBUG(3,("_spoolss_StartPagePrinter: "
5143                         "Error in startpageprinter printer handle\n"));
5144                 return WERR_BADFID;
5145         }
5146
5147         Printer->page_started = true;
5148         return WERR_OK;
5149 }
5150
5151 /****************************************************************
5152  _spoolss_EndPagePrinter
5153 ****************************************************************/
5154
5155 WERROR _spoolss_EndPagePrinter(struct pipes_struct *p,
5156                                struct spoolss_EndPagePrinter *r)
5157 {
5158         int snum;
5159
5160         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5161
5162         if (!Printer) {
5163                 DEBUG(2,("_spoolss_EndPagePrinter: Invalid handle (%s:%u:%u).\n",
5164                         OUR_HANDLE(r->in.handle)));
5165                 return WERR_BADFID;
5166         }
5167
5168         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5169                 return WERR_BADFID;
5170
5171         Printer->page_started = false;
5172         print_job_endpage(snum, Printer->jobid);
5173
5174         return WERR_OK;
5175 }
5176
5177 /****************************************************************
5178  _spoolss_StartDocPrinter
5179 ****************************************************************/
5180
5181 WERROR _spoolss_StartDocPrinter(struct pipes_struct *p,
5182                                 struct spoolss_StartDocPrinter *r)
5183 {
5184         struct spoolss_DocumentInfo1 *info_1;
5185         int snum;
5186         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5187         WERROR werr;
5188
5189         if (!Printer) {
5190                 DEBUG(2,("_spoolss_StartDocPrinter: "
5191                         "Invalid handle (%s:%u:%u)\n",
5192                         OUR_HANDLE(r->in.handle)));
5193                 return WERR_BADFID;
5194         }
5195
5196         if (Printer->jobid) {
5197                 DEBUG(2, ("_spoolss_StartDocPrinter: "
5198                           "StartDocPrinter called twice! "
5199                           "(existing jobid = %d)\n", Printer->jobid));
5200                 return WERR_INVALID_HANDLE;
5201         }
5202
5203         if (r->in.level != 1) {
5204                 return WERR_UNKNOWN_LEVEL;
5205         }
5206
5207         info_1 = r->in.info.info1;
5208
5209         /*
5210          * a nice thing with NT is it doesn't listen to what you tell it.
5211          * when asked to send _only_ RAW datas, it tries to send datas
5212          * in EMF format.
5213          *
5214          * So I add checks like in NT Server ...
5215          */
5216
5217         if (info_1->datatype) {
5218                 if (strcmp(info_1->datatype, "RAW") != 0) {
5219                         *r->out.job_id = 0;
5220                         return WERR_INVALID_DATATYPE;
5221                 }
5222         }
5223
5224         /* get the share number of the printer */
5225         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5226                 return WERR_BADFID;
5227         }
5228
5229         werr = print_job_start(p->server_info, snum,
5230                                 info_1->document_name, info_1->output_file,
5231                                 Printer->devmode, &Printer->jobid);
5232
5233         /* An error occured in print_job_start() so return an appropriate
5234            NT error code. */
5235
5236         if (!W_ERROR_IS_OK(werr)) {
5237                 return werr;
5238         }
5239
5240         Printer->document_started = true;
5241         *r->out.job_id = Printer->jobid;
5242
5243         return WERR_OK;
5244 }
5245
5246 /****************************************************************
5247  _spoolss_EndDocPrinter
5248 ****************************************************************/
5249
5250 WERROR _spoolss_EndDocPrinter(struct pipes_struct *p,
5251                               struct spoolss_EndDocPrinter *r)
5252 {
5253         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5254         NTSTATUS status;
5255         int snum;
5256
5257         if (!Printer) {
5258                 DEBUG(2,("_spoolss_EndDocPrinter: Invalid handle (%s:%u:%u)\n",
5259                         OUR_HANDLE(r->in.handle)));
5260                 return WERR_BADFID;
5261         }
5262
5263         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5264                 return WERR_BADFID;
5265         }
5266
5267         Printer->document_started = false;
5268         status = print_job_end(snum, Printer->jobid, NORMAL_CLOSE);
5269         if (!NT_STATUS_IS_OK(status)) {
5270                 DEBUG(2, ("_spoolss_EndDocPrinter: "
5271                           "print_job_end failed [%s]\n",
5272                           nt_errstr(status)));
5273         }
5274
5275         Printer->jobid = 0;
5276         return ntstatus_to_werror(status);
5277 }
5278
5279 /****************************************************************
5280  _spoolss_WritePrinter
5281 ****************************************************************/
5282
5283 WERROR _spoolss_WritePrinter(struct pipes_struct *p,
5284                              struct spoolss_WritePrinter *r)
5285 {
5286         ssize_t buffer_written;
5287         int snum;
5288         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5289
5290         if (!Printer) {
5291                 DEBUG(2,("_spoolss_WritePrinter: Invalid handle (%s:%u:%u)\n",
5292                         OUR_HANDLE(r->in.handle)));
5293                 *r->out.num_written = r->in._data_size;
5294                 return WERR_BADFID;
5295         }
5296
5297         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5298                 return WERR_BADFID;
5299
5300         /* print_job_write takes care of checking for PJOB_SMBD_SPOOLING */
5301         buffer_written = print_job_write(snum, Printer->jobid,
5302                                                    (const char *)r->in.data.data,
5303                                                    (SMB_OFF_T)-1,
5304                                                    (size_t)r->in._data_size);
5305         if (buffer_written == (ssize_t)-1) {
5306                 *r->out.num_written = 0;
5307                 if (errno == ENOSPC)
5308                         return WERR_NO_SPOOL_SPACE;
5309                 else
5310                         return WERR_ACCESS_DENIED;
5311         }
5312
5313         *r->out.num_written = r->in._data_size;
5314
5315         return WERR_OK;
5316 }
5317
5318 /********************************************************************
5319  * api_spoolss_getprinter
5320  * called from the spoolss dispatcher
5321  *
5322  ********************************************************************/
5323
5324 static WERROR control_printer(struct policy_handle *handle, uint32_t command,
5325                               struct pipes_struct *p)
5326 {
5327         int snum;
5328         WERROR errcode = WERR_BADFUNC;
5329         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5330
5331         if (!Printer) {
5332                 DEBUG(2,("control_printer: Invalid handle (%s:%u:%u)\n",
5333                         OUR_HANDLE(handle)));
5334                 return WERR_BADFID;
5335         }
5336
5337         if (!get_printer_snum(p, handle, &snum, NULL))
5338                 return WERR_BADFID;
5339
5340         switch (command) {
5341         case SPOOLSS_PRINTER_CONTROL_PAUSE:
5342                 errcode = print_queue_pause(p->server_info, snum);
5343                 break;
5344         case SPOOLSS_PRINTER_CONTROL_RESUME:
5345         case SPOOLSS_PRINTER_CONTROL_UNPAUSE:
5346                 errcode = print_queue_resume(p->server_info, snum);
5347                 break;
5348         case SPOOLSS_PRINTER_CONTROL_PURGE:
5349                 errcode = print_queue_purge(p->server_info, snum);
5350                 break;
5351         default:
5352                 return WERR_UNKNOWN_LEVEL;
5353         }
5354
5355         return errcode;
5356 }
5357
5358
5359 /****************************************************************
5360  _spoolss_AbortPrinter
5361  * From MSDN: "Deletes printer's spool file if printer is configured
5362  * for spooling"
5363 ****************************************************************/
5364
5365 WERROR _spoolss_AbortPrinter(struct pipes_struct *p,
5366                              struct spoolss_AbortPrinter *r)
5367 {
5368         Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
5369         int             snum;
5370         WERROR          errcode = WERR_OK;
5371
5372         if (!Printer) {
5373                 DEBUG(2,("_spoolss_AbortPrinter: Invalid handle (%s:%u:%u)\n",
5374                         OUR_HANDLE(r->in.handle)));
5375                 return WERR_BADFID;
5376         }
5377
5378         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5379                 return WERR_BADFID;
5380
5381         if (!Printer->document_started) {
5382                 return WERR_SPL_NO_STARTDOC;
5383         }
5384
5385         errcode = print_job_delete(p->server_info, snum, Printer->jobid);
5386
5387         return errcode;
5388 }
5389
5390 /********************************************************************
5391  * called by spoolss_api_setprinter
5392  * when updating a printer description
5393  ********************************************************************/
5394
5395 static WERROR update_printer_sec(struct policy_handle *handle,
5396                                  struct pipes_struct *p,
5397                                  struct sec_desc_buf *secdesc_ctr)
5398 {
5399         struct spoolss_security_descriptor *new_secdesc = NULL;
5400         struct spoolss_security_descriptor *old_secdesc = NULL;
5401         const char *printer;
5402         WERROR result;
5403         int snum;
5404
5405         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5406
5407         if (!Printer || !get_printer_snum(p, handle, &snum, NULL)) {
5408                 DEBUG(2,("update_printer_sec: Invalid handle (%s:%u:%u)\n",
5409                          OUR_HANDLE(handle)));
5410
5411                 result = WERR_BADFID;
5412                 goto done;
5413         }
5414
5415         if (secdesc_ctr == NULL) {
5416                 DEBUG(10,("update_printer_sec: secdesc_ctr is NULL !\n"));
5417                 result = WERR_INVALID_PARAM;
5418                 goto done;
5419         }
5420         printer = lp_const_servicename(snum);
5421
5422         /* Check the user has permissions to change the security
5423            descriptor.  By experimentation with two NT machines, the user
5424            requires Full Access to the printer to change security
5425            information. */
5426
5427         if ( Printer->access_granted != PRINTER_ACCESS_ADMINISTER ) {
5428                 DEBUG(4,("update_printer_sec: updated denied by printer permissions\n"));
5429                 result = WERR_ACCESS_DENIED;
5430                 goto done;
5431         }
5432
5433         /* NT seems to like setting the security descriptor even though
5434            nothing may have actually changed. */
5435         result = winreg_get_printer_secdesc(p->mem_ctx,
5436                                             p->server_info,
5437                                             p->msg_ctx,
5438                                             printer,
5439                                             &old_secdesc);
5440         if (!W_ERROR_IS_OK(result)) {
5441                 DEBUG(2,("update_printer_sec: winreg_get_printer_secdesc() failed\n"));
5442                 result = WERR_BADFID;
5443                 goto done;
5444         }
5445
5446         if (DEBUGLEVEL >= 10) {
5447                 struct security_acl *the_acl;
5448                 int i;
5449
5450                 the_acl = old_secdesc->dacl;
5451                 DEBUG(10, ("old_secdesc_ctr for %s has %d aces:\n",
5452                            printer, the_acl->num_aces));
5453
5454                 for (i = 0; i < the_acl->num_aces; i++) {
5455                         DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
5456                                            &the_acl->aces[i].trustee),
5457                                   the_acl->aces[i].access_mask));
5458                 }
5459
5460                 the_acl = secdesc_ctr->sd->dacl;
5461
5462                 if (the_acl) {
5463                         DEBUG(10, ("secdesc_ctr for %s has %d aces:\n",
5464                                    printer, the_acl->num_aces));
5465
5466                         for (i = 0; i < the_acl->num_aces; i++) {
5467                                 DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
5468                                                    &the_acl->aces[i].trustee),
5469                                            the_acl->aces[i].access_mask));
5470                         }
5471                 } else {
5472                         DEBUG(10, ("dacl for secdesc_ctr is NULL\n"));
5473                 }
5474         }
5475
5476         new_secdesc = sec_desc_merge(p->mem_ctx, secdesc_ctr->sd, old_secdesc);
5477         if (new_secdesc == NULL) {
5478                 result = WERR_NOMEM;
5479                 goto done;
5480         }
5481
5482         if (security_descriptor_equal(new_secdesc, old_secdesc)) {
5483                 result = WERR_OK;
5484                 goto done;
5485         }
5486
5487         result = winreg_set_printer_secdesc(p->mem_ctx,
5488                                             p->server_info,
5489                                             p->msg_ctx,
5490                                             printer,
5491                                             new_secdesc);
5492
5493  done:
5494         return result;
5495 }
5496
5497 /********************************************************************
5498  Canonicalize printer info from a client
5499  ********************************************************************/
5500
5501 static bool check_printer_ok(TALLOC_CTX *mem_ctx,
5502                              struct spoolss_SetPrinterInfo2 *info2,
5503                              int snum)
5504 {
5505         fstring printername;
5506         const char *p;
5507
5508         DEBUG(5,("check_printer_ok: servername=%s printername=%s sharename=%s "
5509                 "portname=%s drivername=%s comment=%s location=%s\n",
5510                 info2->servername, info2->printername, info2->sharename,
5511                 info2->portname, info2->drivername, info2->comment,
5512                 info2->location));
5513
5514         /* we force some elements to "correct" values */
5515         info2->servername = talloc_asprintf(mem_ctx, "\\\\%s", global_myname());
5516         if (info2->servername == NULL) {
5517                 return false;
5518         }
5519         info2->sharename = talloc_strdup(mem_ctx, lp_const_servicename(snum));
5520         if (info2->sharename == NULL) {
5521                 return false;
5522         }
5523
5524         /* check to see if we allow printername != sharename */
5525         if (lp_force_printername(snum)) {
5526                 info2->printername = talloc_asprintf(mem_ctx, "\\\\%s\\%s",
5527                                         global_myname(), info2->sharename);
5528         } else {
5529                 /* make sure printername is in \\server\printername format */
5530                 fstrcpy(printername, info2->printername);
5531                 p = printername;
5532                 if ( printername[0] == '\\' && printername[1] == '\\' ) {
5533                         if ( (p = strchr_m( &printername[2], '\\' )) != NULL )
5534                                 p++;
5535                 }
5536
5537                 info2->printername = talloc_asprintf(mem_ctx, "\\\\%s\\%s",
5538                                         global_myname(), p);
5539         }
5540         if (info2->printername == NULL) {
5541                 return false;
5542         }
5543
5544         info2->attributes |= PRINTER_ATTRIBUTE_SAMBA;
5545         info2->attributes &= ~PRINTER_ATTRIBUTE_NOT_SAMBA;
5546
5547         return true;
5548 }
5549
5550 /****************************************************************************
5551 ****************************************************************************/
5552
5553 static WERROR add_port_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, const char *portname, const char *uri)
5554 {
5555         char *cmd = lp_addport_cmd();
5556         char *command = NULL;
5557         int ret;
5558         SE_PRIV se_printop = SE_PRINT_OPERATOR;
5559         bool is_print_op = false;
5560
5561         if ( !*cmd ) {
5562                 return WERR_ACCESS_DENIED;
5563         }
5564
5565         command = talloc_asprintf(ctx,
5566                         "%s \"%s\" \"%s\"", cmd, portname, uri );
5567         if (!command) {
5568                 return WERR_NOMEM;
5569         }
5570
5571         if ( token )
5572                 is_print_op = user_has_privileges( token, &se_printop );
5573
5574         DEBUG(10,("Running [%s]\n", command));
5575
5576         /********* BEGIN SePrintOperatorPrivilege **********/
5577
5578         if ( is_print_op )
5579                 become_root();
5580
5581         ret = smbrun(command, NULL);
5582
5583         if ( is_print_op )
5584                 unbecome_root();
5585
5586         /********* END SePrintOperatorPrivilege **********/
5587
5588         DEBUGADD(10,("returned [%d]\n", ret));
5589
5590         TALLOC_FREE(command);
5591
5592         if ( ret != 0 ) {
5593                 return WERR_ACCESS_DENIED;
5594         }
5595
5596         return WERR_OK;
5597 }
5598
5599 /****************************************************************************
5600 ****************************************************************************/
5601
5602 static bool add_printer_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token,
5603                              struct spoolss_SetPrinterInfo2 *info2,
5604                              const char *remote_machine,
5605                              struct messaging_context *msg_ctx)
5606 {
5607         char *cmd = lp_addprinter_cmd();
5608         char **qlines;
5609         char *command = NULL;
5610         int numlines;
5611         int ret;
5612         int fd;
5613         SE_PRIV se_printop = SE_PRINT_OPERATOR;
5614         bool is_print_op = false;
5615
5616         if (!remote_machine) {
5617                 return false;
5618         }
5619
5620         command = talloc_asprintf(ctx,
5621                         "%s \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"",
5622                         cmd, info2->printername, info2->sharename,
5623                         info2->portname, info2->drivername,
5624                         info2->location, info2->comment, remote_machine);
5625         if (!command) {
5626                 return false;
5627         }
5628
5629         if ( token )
5630                 is_print_op = user_has_privileges( token, &se_printop );
5631
5632         DEBUG(10,("Running [%s]\n", command));
5633
5634         /********* BEGIN SePrintOperatorPrivilege **********/
5635
5636         if ( is_print_op )
5637                 become_root();
5638
5639         if ( (ret = smbrun(command, &fd)) == 0 ) {
5640                 /* Tell everyone we updated smb.conf. */
5641                 message_send_all(msg_ctx, MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
5642         }
5643
5644         if ( is_print_op )
5645                 unbecome_root();
5646
5647         /********* END SePrintOperatorPrivilege **********/
5648
5649         DEBUGADD(10,("returned [%d]\n", ret));
5650
5651         TALLOC_FREE(command);
5652
5653         if ( ret != 0 ) {
5654                 if (fd != -1)
5655                         close(fd);
5656                 return false;
5657         }
5658
5659         /* reload our services immediately */
5660         become_root();
5661         reload_services(false);
5662         unbecome_root();
5663
5664         numlines = 0;
5665         /* Get lines and convert them back to dos-codepage */
5666         qlines = fd_lines_load(fd, &numlines, 0, NULL);
5667         DEBUGADD(10,("Lines returned = [%d]\n", numlines));
5668         close(fd);
5669
5670         /* Set the portname to what the script says the portname should be. */
5671         /* but don't require anything to be return from the script exit a good error code */
5672
5673         if (numlines) {
5674                 /* Set the portname to what the script says the portname should be. */
5675                 info2->portname = talloc_strdup(ctx, qlines[0]);
5676                 DEBUGADD(6,("Line[0] = [%s]\n", qlines[0]));
5677         }
5678
5679         TALLOC_FREE(qlines);
5680         return true;
5681 }
5682
5683 static WERROR update_dsspooler(TALLOC_CTX *mem_ctx,
5684                                struct auth_serversupplied_info *server_info,
5685                                int snum,
5686                                struct spoolss_SetPrinterInfo2 *printer,
5687                                struct spoolss_PrinterInfo2 *old_printer)
5688 {
5689         bool force_update = (old_printer == NULL);
5690         const char *dnsdomname;
5691         const char *longname;
5692         const char *uncname;
5693         const char *spooling;
5694         DATA_BLOB buffer;
5695         WERROR result = WERR_OK;
5696
5697         if (force_update || !strequal(printer->drivername, old_printer->drivername)) {
5698                 push_reg_sz(mem_ctx, &buffer, printer->drivername);
5699                 winreg_set_printer_dataex(mem_ctx,
5700                                           server_info,
5701                                           smbd_messaging_context(),
5702                                           printer->sharename,
5703                                           SPOOL_DSSPOOLER_KEY,
5704                                           SPOOL_REG_DRIVERNAME,
5705                                           REG_SZ,
5706                                           buffer.data,
5707                                           buffer.length);
5708
5709                 if (!force_update) {
5710                         DEBUG(10,("update_printer: changing driver [%s]!  Sending event!\n",
5711                                 printer->drivername));
5712
5713                         notify_printer_driver(snum, printer->drivername);
5714                 }
5715         }
5716
5717         if (force_update || !strequal(printer->comment, old_printer->comment)) {
5718                 push_reg_sz(mem_ctx, &buffer, printer->comment);
5719                 winreg_set_printer_dataex(mem_ctx,
5720                                           server_info,
5721                                           smbd_messaging_context(),
5722                                           printer->sharename,
5723                                           SPOOL_DSSPOOLER_KEY,
5724                                           SPOOL_REG_DESCRIPTION,
5725                                           REG_SZ,
5726                                           buffer.data,
5727                                           buffer.length);
5728
5729                 if (!force_update) {
5730                         notify_printer_comment(snum, printer->comment);
5731                 }
5732         }
5733
5734         if (force_update || !strequal(printer->sharename, old_printer->sharename)) {
5735                 push_reg_sz(mem_ctx, &buffer, printer->sharename);
5736                 winreg_set_printer_dataex(mem_ctx,
5737                                           server_info,
5738                                           smbd_messaging_context(),
5739                                           printer->sharename,
5740                                           SPOOL_DSSPOOLER_KEY,
5741                                           SPOOL_REG_PRINTSHARENAME,
5742                                           REG_SZ,
5743                                           buffer.data,
5744                                           buffer.length);
5745
5746                 if (!force_update) {
5747                         notify_printer_sharename(snum, printer->sharename);
5748                 }
5749         }
5750
5751         if (force_update || !strequal(printer->printername, old_printer->printername)) {
5752                 const char *p;
5753
5754                 p = strrchr(printer->printername, '\\' );
5755                 if (p != NULL) {
5756                         p++;
5757                 } else {
5758                         p = printer->printername;
5759                 }
5760
5761                 push_reg_sz(mem_ctx, &buffer, p);
5762                 winreg_set_printer_dataex(mem_ctx,
5763                                           server_info,
5764                                           smbd_messaging_context(),
5765                                           printer->sharename,
5766                                           SPOOL_DSSPOOLER_KEY,
5767                                           SPOOL_REG_PRINTERNAME,
5768                                           REG_SZ,
5769                                           buffer.data,
5770                                           buffer.length);
5771
5772                 if (!force_update) {
5773                         notify_printer_printername(snum, p);
5774                 }
5775         }
5776
5777         if (force_update || !strequal(printer->portname, old_printer->portname)) {
5778                 push_reg_sz(mem_ctx, &buffer, printer->portname);
5779                 winreg_set_printer_dataex(mem_ctx,
5780                                           server_info,
5781                                           smbd_messaging_context(),
5782                                           printer->sharename,
5783                                           SPOOL_DSSPOOLER_KEY,
5784                                           SPOOL_REG_PORTNAME,
5785                                           REG_SZ,
5786                                           buffer.data,
5787                                           buffer.length);
5788
5789                 if (!force_update) {
5790                         notify_printer_port(snum, printer->portname);
5791                 }
5792         }
5793
5794         if (force_update || !strequal(printer->location, old_printer->location)) {
5795                 push_reg_sz(mem_ctx, &buffer, printer->location);
5796                 winreg_set_printer_dataex(mem_ctx,
5797                                           server_info,
5798                                           smbd_messaging_context(),
5799                                           printer->sharename,
5800                                           SPOOL_DSSPOOLER_KEY,
5801                                           SPOOL_REG_LOCATION,
5802                                           REG_SZ,
5803                                           buffer.data,
5804                                           buffer.length);
5805
5806                 if (!force_update) {
5807                         notify_printer_location(snum, printer->location);
5808                 }
5809         }
5810
5811         if (force_update || !strequal(printer->sepfile, old_printer->sepfile)) {
5812                 push_reg_sz(mem_ctx, &buffer, printer->sepfile);
5813                 winreg_set_printer_dataex(mem_ctx,
5814                                           server_info,
5815                                           smbd_messaging_context(),
5816                                           printer->sharename,
5817                                           SPOOL_DSSPOOLER_KEY,
5818                                           SPOOL_REG_PRINTSEPARATORFILE,
5819                                           REG_SZ,
5820                                           buffer.data,
5821                                           buffer.length);
5822
5823                 if (!force_update) {
5824                         notify_printer_location(snum, printer->location);
5825                 }
5826         }
5827
5828         if (force_update || printer->starttime != old_printer->starttime) {
5829                 buffer = data_blob_talloc(mem_ctx, NULL, 4);
5830                 SIVAL(buffer.data, 0, printer->starttime);
5831                 winreg_set_printer_dataex(mem_ctx,
5832                                           server_info,
5833                                           smbd_messaging_context(),
5834                                           printer->sharename,
5835                                           SPOOL_DSSPOOLER_KEY,
5836                                           SPOOL_REG_PRINTSTARTTIME,
5837                                           REG_DWORD,
5838                                           buffer.data,
5839                                           buffer.length);
5840         }
5841
5842         if (force_update || printer->untiltime != old_printer->untiltime) {
5843                 buffer = data_blob_talloc(mem_ctx, NULL, 4);
5844                 SIVAL(buffer.data, 0, printer->untiltime);
5845                 winreg_set_printer_dataex(mem_ctx,
5846                                           server_info,
5847                                           smbd_messaging_context(),
5848                                           printer->sharename,
5849                                           SPOOL_DSSPOOLER_KEY,
5850                                           SPOOL_REG_PRINTENDTIME,
5851                                           REG_DWORD,
5852                                           buffer.data,
5853                                           buffer.length);
5854         }
5855
5856         if (force_update || printer->priority != old_printer->priority) {
5857                 buffer = data_blob_talloc(mem_ctx, NULL, 4);
5858                 SIVAL(buffer.data, 0, printer->priority);
5859                 winreg_set_printer_dataex(mem_ctx,
5860                                           server_info,
5861                                           smbd_messaging_context(),
5862                                           printer->sharename,
5863                                           SPOOL_DSSPOOLER_KEY,
5864                                           SPOOL_REG_PRIORITY,
5865                                           REG_DWORD,
5866                                           buffer.data,
5867                                           buffer.length);
5868         }
5869
5870         if (force_update || printer->attributes != old_printer->attributes) {
5871                 buffer = data_blob_talloc(mem_ctx, NULL, 4);
5872                 SIVAL(buffer.data, 0, (printer->attributes &
5873                                        PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS));
5874                 winreg_set_printer_dataex(mem_ctx,
5875                                           server_info,
5876                                           smbd_messaging_context(),
5877                                           printer->sharename,
5878                                           SPOOL_DSSPOOLER_KEY,
5879                                           SPOOL_REG_PRINTKEEPPRINTEDJOBS,
5880                                           REG_DWORD,
5881                                           buffer.data,
5882                                           buffer.length);
5883
5884                 switch (printer->attributes & 0x3) {
5885                         case 0:
5886                                 spooling = SPOOL_REGVAL_PRINTWHILESPOOLING;
5887                                 break;
5888                         case 1:
5889                                 spooling = SPOOL_REGVAL_PRINTAFTERSPOOLED;
5890                                 break;
5891                         case 2:
5892                                 spooling = SPOOL_REGVAL_PRINTDIRECT;
5893                                 break;
5894                         default:
5895                                 spooling = "unknown";
5896                 }
5897                 push_reg_sz(mem_ctx, &buffer, spooling);
5898                 winreg_set_printer_dataex(mem_ctx,
5899                                           server_info,
5900                                           smbd_messaging_context(),
5901                                           printer->sharename,
5902                                           SPOOL_DSSPOOLER_KEY,
5903                                           SPOOL_REG_PRINTSPOOLING,
5904                                           REG_SZ,
5905                                           buffer.data,
5906                                           buffer.length);
5907         }
5908
5909         push_reg_sz(mem_ctx, &buffer, global_myname());
5910         winreg_set_printer_dataex(mem_ctx,
5911                                   server_info,
5912                                   smbd_messaging_context(),
5913                                   printer->sharename,
5914                                   SPOOL_DSSPOOLER_KEY,
5915                                   SPOOL_REG_SHORTSERVERNAME,
5916                                   REG_SZ,
5917                                   buffer.data,
5918                                   buffer.length);
5919
5920         dnsdomname = get_mydnsfullname();
5921         if (dnsdomname != NULL && dnsdomname[0] != '\0') {
5922                 longname = talloc_strdup(mem_ctx, dnsdomname);
5923         } else {
5924                 longname = talloc_strdup(mem_ctx, global_myname());
5925         }
5926         if (longname == NULL) {
5927                 result = WERR_NOMEM;
5928                 goto done;
5929         }
5930
5931         push_reg_sz(mem_ctx, &buffer, longname);
5932         winreg_set_printer_dataex(mem_ctx,
5933                                   server_info,
5934                                   smbd_messaging_context(),
5935                                   printer->sharename,
5936                                   SPOOL_DSSPOOLER_KEY,
5937                                   SPOOL_REG_SERVERNAME,
5938                                   REG_SZ,
5939                                   buffer.data,
5940                                   buffer.length);
5941
5942         uncname = talloc_asprintf(mem_ctx, "\\\\%s\\%s",
5943                                   global_myname(), printer->sharename);
5944         push_reg_sz(mem_ctx, &buffer, uncname);
5945         winreg_set_printer_dataex(mem_ctx,
5946                                   server_info,
5947                                   smbd_messaging_context(),
5948                                   printer->sharename,
5949                                   SPOOL_DSSPOOLER_KEY,
5950                                   SPOOL_REG_UNCNAME,
5951                                   REG_SZ,
5952                                   buffer.data,
5953                                   buffer.length);
5954
5955 done:
5956         return result;
5957 }
5958
5959 /********************************************************************
5960  * Called by spoolss_api_setprinter
5961  * when updating a printer description.
5962  ********************************************************************/
5963
5964 static WERROR update_printer(struct pipes_struct *p,
5965                              struct policy_handle *handle,
5966                              struct spoolss_SetPrinterInfoCtr *info_ctr,
5967                              struct spoolss_DeviceMode *devmode)
5968 {
5969         uint32_t printer_mask = SPOOLSS_PRINTER_INFO_ALL;
5970         struct spoolss_SetPrinterInfo2 *printer = info_ctr->info.info2;
5971         struct spoolss_PrinterInfo2 *old_printer;
5972         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5973         const char *servername = NULL;
5974         int snum;
5975         WERROR result = WERR_OK;
5976         TALLOC_CTX *tmp_ctx;
5977
5978         DEBUG(8,("update_printer\n"));
5979
5980         tmp_ctx = talloc_new(p->mem_ctx);
5981         if (tmp_ctx == NULL) {
5982                 return WERR_NOMEM;
5983         }
5984
5985         if (!Printer) {
5986                 result = WERR_BADFID;
5987                 goto done;
5988         }
5989
5990         if (!get_printer_snum(p, handle, &snum, NULL)) {
5991                 result = WERR_BADFID;
5992                 goto done;
5993         }
5994
5995         if (Printer != NULL || Printer->servername != NULL) {
5996                 servername = Printer->servername;
5997         }
5998
5999         result = winreg_get_printer(tmp_ctx,
6000                                     p->server_info,
6001                                     p->msg_ctx,
6002                                     servername,
6003                                     lp_const_servicename(snum),
6004                                     &old_printer);
6005         if (!W_ERROR_IS_OK(result)) {
6006                 result = WERR_BADFID;
6007                 goto done;
6008         }
6009
6010         /* Do sanity check on the requested changes for Samba */
6011         if (!check_printer_ok(tmp_ctx, printer, snum)) {
6012                 result = WERR_INVALID_PARAM;
6013                 goto done;
6014         }
6015
6016         /* FIXME!!! If the driver has changed we really should verify that
6017            it is installed before doing much else   --jerry */
6018
6019         /* Check calling user has permission to update printer description */
6020         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
6021                 DEBUG(3, ("update_printer: printer property change denied by handle\n"));
6022                 result = WERR_ACCESS_DENIED;
6023                 goto done;
6024         }
6025
6026         /* Call addprinter hook */
6027         /* Check changes to see if this is really needed */
6028
6029         if (*lp_addprinter_cmd() &&
6030                         (!strequal(printer->drivername, old_printer->drivername) ||
6031                          !strequal(printer->comment, old_printer->comment) ||
6032                          !strequal(printer->portname, old_printer->portname) ||
6033                          !strequal(printer->location, old_printer->location)) )
6034         {
6035                 /* add_printer_hook() will call reload_services() */
6036                 if (!add_printer_hook(tmp_ctx, p->server_info->ptok,
6037                                       printer, p->client_address,
6038                                       p->msg_ctx)) {
6039                         result = WERR_ACCESS_DENIED;
6040                         goto done;
6041                 }
6042         }
6043
6044         update_dsspooler(tmp_ctx,
6045                          p->server_info,
6046                          snum,
6047                          printer,
6048                          old_printer);
6049
6050         printer_mask &= ~SPOOLSS_PRINTER_INFO_SECDESC;
6051
6052         if (devmode == NULL) {
6053                 printer_mask &= ~SPOOLSS_PRINTER_INFO_DEVMODE;
6054         }
6055         result = winreg_update_printer(tmp_ctx,
6056                                        p->server_info,
6057                                        p->msg_ctx,
6058                                        printer->sharename,
6059                                        printer_mask,
6060                                        printer,
6061                                        devmode,
6062                                        NULL);
6063
6064 done:
6065         talloc_free(tmp_ctx);
6066
6067         return result;
6068 }
6069
6070 /****************************************************************************
6071 ****************************************************************************/
6072 static WERROR publish_or_unpublish_printer(struct pipes_struct *p,
6073                                            struct policy_handle *handle,
6074                                            struct spoolss_SetPrinterInfo7 *info7)
6075 {
6076 #ifdef HAVE_ADS
6077         struct spoolss_PrinterInfo2 *pinfo2 = NULL;
6078         WERROR result;
6079         int snum;
6080         Printer_entry *Printer;
6081
6082         if ( lp_security() != SEC_ADS ) {
6083                 return WERR_UNKNOWN_LEVEL;
6084         }
6085
6086         Printer = find_printer_index_by_hnd(p, handle);
6087
6088         DEBUG(5,("publish_or_unpublish_printer, action = %d\n",info7->action));
6089
6090         if (!Printer)
6091                 return WERR_BADFID;
6092
6093         if (!get_printer_snum(p, handle, &snum, NULL))
6094                 return WERR_BADFID;
6095
6096         result = winreg_get_printer(p->mem_ctx, p->server_info, p->msg_ctx,
6097                                     Printer->servername,
6098                                     lp_servicename(snum), &pinfo2);
6099         if (!W_ERROR_IS_OK(result)) {
6100                 return WERR_BADFID;
6101         }
6102
6103         nt_printer_publish(pinfo2, p->server_info, pinfo2, info7->action);
6104
6105         TALLOC_FREE(pinfo2);
6106         return WERR_OK;
6107 #else
6108         return WERR_UNKNOWN_LEVEL;
6109 #endif
6110 }
6111
6112 /********************************************************************
6113  ********************************************************************/
6114
6115 static WERROR update_printer_devmode(struct pipes_struct *p,
6116                                      struct policy_handle *handle,
6117                                      struct spoolss_DeviceMode *devmode)
6118 {
6119         int snum;
6120         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
6121         uint32_t info2_mask = SPOOLSS_PRINTER_INFO_DEVMODE;
6122
6123         DEBUG(8,("update_printer_devmode\n"));
6124
6125         if (!Printer) {
6126                 return WERR_BADFID;
6127         }
6128
6129         if (!get_printer_snum(p, handle, &snum, NULL)) {
6130                 return WERR_BADFID;
6131         }
6132
6133         /* Check calling user has permission to update printer description */
6134         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
6135                 DEBUG(3, ("update_printer: printer property change denied by handle\n"));
6136                 return WERR_ACCESS_DENIED;
6137         }
6138
6139         return winreg_update_printer(p->mem_ctx,
6140                                      p->server_info,
6141                                      p->msg_ctx,
6142                                      lp_const_servicename(snum),
6143                                      info2_mask,
6144                                      NULL,
6145                                      devmode,
6146                                      NULL);
6147 }
6148
6149
6150 /****************************************************************
6151  _spoolss_SetPrinter
6152 ****************************************************************/
6153
6154 WERROR _spoolss_SetPrinter(struct pipes_struct *p,
6155                            struct spoolss_SetPrinter *r)
6156 {
6157         WERROR result;
6158
6159         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
6160
6161         if (!Printer) {
6162                 DEBUG(2,("_spoolss_SetPrinter: Invalid handle (%s:%u:%u)\n",
6163                         OUR_HANDLE(r->in.handle)));
6164                 return WERR_BADFID;
6165         }
6166
6167         /* check the level */
6168         switch (r->in.info_ctr->level) {
6169                 case 0:
6170                         return control_printer(r->in.handle, r->in.command, p);
6171                 case 2:
6172                         result = update_printer(p, r->in.handle,
6173                                                 r->in.info_ctr,
6174                                                 r->in.devmode_ctr->devmode);
6175                         if (!W_ERROR_IS_OK(result))
6176                                 return result;
6177                         if (r->in.secdesc_ctr->sd)
6178                                 result = update_printer_sec(r->in.handle, p,
6179                                                             r->in.secdesc_ctr);
6180                         return result;
6181                 case 3:
6182                         return update_printer_sec(r->in.handle, p,
6183                                                   r->in.secdesc_ctr);
6184                 case 7:
6185                         return publish_or_unpublish_printer(p, r->in.handle,
6186                                                             r->in.info_ctr->info.info7);
6187                 case 8:
6188                         return update_printer_devmode(p, r->in.handle,
6189                                                       r->in.devmode_ctr->devmode);
6190                 default:
6191                         return WERR_UNKNOWN_LEVEL;
6192         }
6193 }
6194
6195 /****************************************************************
6196  _spoolss_FindClosePrinterNotify
6197 ****************************************************************/
6198
6199 WERROR _spoolss_FindClosePrinterNotify(struct pipes_struct *p,
6200                                        struct spoolss_FindClosePrinterNotify *r)
6201 {
6202         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
6203
6204         if (!Printer) {
6205                 DEBUG(2,("_spoolss_FindClosePrinterNotify: "
6206                         "Invalid handle (%s:%u:%u)\n", OUR_HANDLE(r->in.handle)));
6207                 return WERR_BADFID;
6208         }
6209
6210         if (Printer->notify.client_connected == true) {
6211                 int snum = -1;
6212
6213                 if ( Printer->printer_type == SPLHND_SERVER)
6214                         snum = -1;
6215                 else if ( (Printer->printer_type == SPLHND_PRINTER) &&
6216                                 !get_printer_snum(p, r->in.handle, &snum, NULL) )
6217                         return WERR_BADFID;
6218
6219                 srv_spoolss_replycloseprinter(
6220                         snum, &Printer->notify.client_hnd, p->msg_ctx);
6221         }
6222
6223         Printer->notify.flags=0;
6224         Printer->notify.options=0;
6225         Printer->notify.localmachine[0]='\0';
6226         Printer->notify.printerlocal=0;
6227         TALLOC_FREE(Printer->notify.option);
6228         Printer->notify.client_connected = false;
6229
6230         return WERR_OK;
6231 }
6232
6233 /****************************************************************
6234  _spoolss_AddJob
6235 ****************************************************************/
6236
6237 WERROR _spoolss_AddJob(struct pipes_struct *p,
6238                        struct spoolss_AddJob *r)
6239 {
6240         if (!r->in.buffer && (r->in.offered != 0)) {
6241                 return WERR_INVALID_PARAM;
6242         }
6243
6244         /* this is what a NT server returns for AddJob. AddJob must fail on
6245          * non-local printers */
6246
6247         if (r->in.level != 1) {
6248                 return WERR_UNKNOWN_LEVEL;
6249         }
6250
6251         return WERR_INVALID_PARAM;
6252 }
6253
6254 /****************************************************************************
6255 fill_job_info1
6256 ****************************************************************************/
6257
6258 static WERROR fill_job_info1(TALLOC_CTX *mem_ctx,
6259                              struct spoolss_JobInfo1 *r,
6260                              const print_queue_struct *queue,
6261                              int position, int snum,
6262                              struct spoolss_PrinterInfo2 *pinfo2)
6263 {
6264         struct tm *t;
6265
6266         t = gmtime(&queue->time);
6267
6268         r->job_id               = queue->job;
6269
6270         r->printer_name         = talloc_strdup(mem_ctx, lp_servicename(snum));
6271         W_ERROR_HAVE_NO_MEMORY(r->printer_name);
6272         r->server_name          = talloc_strdup(mem_ctx, pinfo2->servername);
6273         W_ERROR_HAVE_NO_MEMORY(r->server_name);
6274         r->user_name            = talloc_strdup(mem_ctx, queue->fs_user);
6275         W_ERROR_HAVE_NO_MEMORY(r->user_name);
6276         r->document_name        = talloc_strdup(mem_ctx, queue->fs_file);
6277         W_ERROR_HAVE_NO_MEMORY(r->document_name);
6278         r->data_type            = talloc_strdup(mem_ctx, "RAW");
6279         W_ERROR_HAVE_NO_MEMORY(r->data_type);
6280         r->text_status          = talloc_strdup(mem_ctx, "");
6281         W_ERROR_HAVE_NO_MEMORY(r->text_status);
6282
6283         r->status               = nt_printj_status(queue->status);
6284         r->priority             = queue->priority;
6285         r->position             = position;
6286         r->total_pages          = queue->page_count;
6287         r->pages_printed        = 0; /* ??? */
6288
6289         init_systemtime(&r->submitted, t);
6290
6291         return WERR_OK;
6292 }
6293
6294 /****************************************************************************
6295 fill_job_info2
6296 ****************************************************************************/
6297
6298 static WERROR fill_job_info2(TALLOC_CTX *mem_ctx,
6299                              struct spoolss_JobInfo2 *r,
6300                              const print_queue_struct *queue,
6301                              int position, int snum,
6302                              struct spoolss_PrinterInfo2 *pinfo2,
6303                              struct spoolss_DeviceMode *devmode)
6304 {
6305         struct tm *t;
6306
6307         t = gmtime(&queue->time);
6308
6309         r->job_id               = queue->job;
6310
6311         r->printer_name         = talloc_strdup(mem_ctx, lp_servicename(snum));
6312         W_ERROR_HAVE_NO_MEMORY(r->printer_name);
6313         r->server_name          = talloc_strdup(mem_ctx, pinfo2->servername);
6314         W_ERROR_HAVE_NO_MEMORY(r->server_name);
6315         r->user_name            = talloc_strdup(mem_ctx, queue->fs_user);
6316         W_ERROR_HAVE_NO_MEMORY(r->user_name);
6317         r->document_name        = talloc_strdup(mem_ctx, queue->fs_file);
6318         W_ERROR_HAVE_NO_MEMORY(r->document_name);
6319         r->notify_name          = talloc_strdup(mem_ctx, queue->fs_user);
6320         W_ERROR_HAVE_NO_MEMORY(r->notify_name);
6321         r->data_type            = talloc_strdup(mem_ctx, "RAW");
6322         W_ERROR_HAVE_NO_MEMORY(r->data_type);
6323         r->print_processor      = talloc_strdup(mem_ctx, "winprint");
6324         W_ERROR_HAVE_NO_MEMORY(r->print_processor);
6325         r->parameters           = talloc_strdup(mem_ctx, "");
6326         W_ERROR_HAVE_NO_MEMORY(r->parameters);
6327         r->driver_name          = talloc_strdup(mem_ctx, pinfo2->drivername);
6328         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
6329
6330         r->devmode              = devmode;
6331
6332         r->text_status          = talloc_strdup(mem_ctx, "");
6333         W_ERROR_HAVE_NO_MEMORY(r->text_status);
6334
6335         r->secdesc              = NULL;
6336
6337         r->status               = nt_printj_status(queue->status);
6338         r->priority             = queue->priority;
6339         r->position             = position;
6340         r->start_time           = 0;
6341         r->until_time           = 0;
6342         r->total_pages          = queue->page_count;
6343         r->size                 = queue->size;
6344         init_systemtime(&r->submitted, t);
6345         r->time                 = 0;
6346         r->pages_printed        = 0; /* ??? */
6347
6348         return WERR_OK;
6349 }
6350
6351 /****************************************************************************
6352 fill_job_info3
6353 ****************************************************************************/
6354
6355 static WERROR fill_job_info3(TALLOC_CTX *mem_ctx,
6356                              struct spoolss_JobInfo3 *r,
6357                              const print_queue_struct *queue,
6358                              const print_queue_struct *next_queue,
6359                              int position, int snum,
6360                              struct spoolss_PrinterInfo2 *pinfo2)
6361 {
6362         r->job_id               = queue->job;
6363         r->next_job_id          = 0;
6364         if (next_queue) {
6365                 r->next_job_id  = next_queue->job;
6366         }
6367         r->reserved             = 0;
6368
6369         return WERR_OK;
6370 }
6371
6372 /****************************************************************************
6373  Enumjobs at level 1.
6374 ****************************************************************************/
6375
6376 static WERROR enumjobs_level1(TALLOC_CTX *mem_ctx,
6377                               const print_queue_struct *queue,
6378                               uint32_t num_queues, int snum,
6379                               struct spoolss_PrinterInfo2 *pinfo2,
6380                               union spoolss_JobInfo **info_p,
6381                               uint32_t *count)
6382 {
6383         union spoolss_JobInfo *info;
6384         int i;
6385         WERROR result = WERR_OK;
6386
6387         info = TALLOC_ARRAY(mem_ctx, union spoolss_JobInfo, num_queues);
6388         W_ERROR_HAVE_NO_MEMORY(info);
6389
6390         *count = num_queues;
6391
6392         for (i=0; i<*count; i++) {
6393                 result = fill_job_info1(info,
6394                                         &info[i].info1,
6395                                         &queue[i],
6396                                         i,
6397                                         snum,
6398                                         pinfo2);
6399                 if (!W_ERROR_IS_OK(result)) {
6400                         goto out;
6401                 }
6402         }
6403
6404  out:
6405         if (!W_ERROR_IS_OK(result)) {
6406                 TALLOC_FREE(info);
6407                 *count = 0;
6408                 return result;
6409         }
6410
6411         *info_p = info;
6412
6413         return WERR_OK;
6414 }
6415
6416 /****************************************************************************
6417  Enumjobs at level 2.
6418 ****************************************************************************/
6419
6420 static WERROR enumjobs_level2(TALLOC_CTX *mem_ctx,
6421                               const print_queue_struct *queue,
6422                               uint32_t num_queues, int snum,
6423                               struct spoolss_PrinterInfo2 *pinfo2,
6424                               union spoolss_JobInfo **info_p,
6425                               uint32_t *count)
6426 {
6427         union spoolss_JobInfo *info;
6428         int i;
6429         WERROR result = WERR_OK;
6430
6431         info = TALLOC_ARRAY(mem_ctx, union spoolss_JobInfo, num_queues);
6432         W_ERROR_HAVE_NO_MEMORY(info);
6433
6434         *count = num_queues;
6435
6436         for (i=0; i<*count; i++) {
6437                 struct spoolss_DeviceMode *devmode;
6438
6439                 result = spoolss_create_default_devmode(info,
6440                                                         pinfo2->printername,
6441                                                         &devmode);
6442                 if (!W_ERROR_IS_OK(result)) {
6443                         DEBUG(3, ("Can't proceed w/o a devmode!"));
6444                         goto out;
6445                 }
6446
6447                 result = fill_job_info2(info,
6448                                         &info[i].info2,
6449                                         &queue[i],
6450                                         i,
6451                                         snum,
6452                                         pinfo2,
6453                                         devmode);
6454                 if (!W_ERROR_IS_OK(result)) {
6455                         goto out;
6456                 }
6457         }
6458
6459  out:
6460         if (!W_ERROR_IS_OK(result)) {
6461                 TALLOC_FREE(info);
6462                 *count = 0;
6463                 return result;
6464         }
6465
6466         *info_p = info;
6467
6468         return WERR_OK;
6469 }
6470
6471 /****************************************************************************
6472  Enumjobs at level 3.
6473 ****************************************************************************/
6474
6475 static WERROR enumjobs_level3(TALLOC_CTX *mem_ctx,
6476                               const print_queue_struct *queue,
6477                               uint32_t num_queues, int snum,
6478                               struct spoolss_PrinterInfo2 *pinfo2,
6479                               union spoolss_JobInfo **info_p,
6480                               uint32_t *count)
6481 {
6482         union spoolss_JobInfo *info;
6483         int i;
6484         WERROR result = WERR_OK;
6485
6486         info = TALLOC_ARRAY(mem_ctx, union spoolss_JobInfo, num_queues);
6487         W_ERROR_HAVE_NO_MEMORY(info);
6488
6489         *count = num_queues;
6490
6491         for (i=0; i<*count; i++) {
6492                 const print_queue_struct *next_queue = NULL;
6493
6494                 if (i+1 < *count) {
6495                         next_queue = &queue[i+1];
6496                 }
6497
6498                 result = fill_job_info3(info,
6499                                         &info[i].info3,
6500                                         &queue[i],
6501                                         next_queue,
6502                                         i,
6503                                         snum,
6504                                         pinfo2);
6505                 if (!W_ERROR_IS_OK(result)) {
6506                         goto out;
6507                 }
6508         }
6509
6510  out:
6511         if (!W_ERROR_IS_OK(result)) {
6512                 TALLOC_FREE(info);
6513                 *count = 0;
6514                 return result;
6515         }
6516
6517         *info_p = info;
6518
6519         return WERR_OK;
6520 }
6521
6522 /****************************************************************
6523  _spoolss_EnumJobs
6524 ****************************************************************/
6525
6526 WERROR _spoolss_EnumJobs(struct pipes_struct *p,
6527                          struct spoolss_EnumJobs *r)
6528 {
6529         WERROR result;
6530         struct spoolss_PrinterInfo2 *pinfo2 = NULL;
6531         int snum;
6532         print_status_struct prt_status;
6533         print_queue_struct *queue = NULL;
6534         uint32_t count;
6535
6536         /* that's an [in out] buffer */
6537
6538         if (!r->in.buffer && (r->in.offered != 0)) {
6539                 return WERR_INVALID_PARAM;
6540         }
6541
6542         DEBUG(4,("_spoolss_EnumJobs\n"));
6543
6544         *r->out.needed = 0;
6545         *r->out.count = 0;
6546         *r->out.info = NULL;
6547
6548         /* lookup the printer snum and tdb entry */
6549
6550         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
6551                 return WERR_BADFID;
6552         }
6553
6554         result = winreg_get_printer(p->mem_ctx, p->server_info, p->msg_ctx,
6555                                     NULL, lp_servicename(snum), &pinfo2);
6556         if (!W_ERROR_IS_OK(result)) {
6557                 return result;
6558         }
6559
6560         count = print_queue_status(snum, &queue, &prt_status);
6561         DEBUGADD(4,("count:[%d], status:[%d], [%s]\n",
6562                 count, prt_status.status, prt_status.message));
6563
6564         if (count == 0) {
6565                 SAFE_FREE(queue);
6566                 TALLOC_FREE(pinfo2);
6567                 return WERR_OK;
6568         }
6569
6570         switch (r->in.level) {
6571         case 1:
6572                 result = enumjobs_level1(p->mem_ctx, queue, count, snum,
6573                                          pinfo2, r->out.info, r->out.count);
6574                 break;
6575         case 2:
6576                 result = enumjobs_level2(p->mem_ctx, queue, count, snum,
6577                                          pinfo2, r->out.info, r->out.count);
6578                 break;
6579         case 3:
6580                 result = enumjobs_level3(p->mem_ctx, queue, count, snum,
6581                                          pinfo2, r->out.info, r->out.count);
6582                 break;
6583         default:
6584                 result = WERR_UNKNOWN_LEVEL;
6585                 break;
6586         }
6587
6588         SAFE_FREE(queue);
6589         TALLOC_FREE(pinfo2);
6590
6591         if (!W_ERROR_IS_OK(result)) {
6592                 return result;
6593         }
6594
6595         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
6596                                                      spoolss_EnumJobs,
6597                                                      *r->out.info, r->in.level,
6598                                                      *r->out.count);
6599         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
6600         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
6601
6602         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
6603 }
6604
6605 /****************************************************************
6606  _spoolss_ScheduleJob
6607 ****************************************************************/
6608
6609 WERROR _spoolss_ScheduleJob(struct pipes_struct *p,
6610                             struct spoolss_ScheduleJob *r)
6611 {
6612         return WERR_OK;
6613 }
6614
6615 /****************************************************************
6616 ****************************************************************/
6617
6618 static WERROR spoolss_setjob_1(TALLOC_CTX *mem_ctx,
6619                                const char *printer_name,
6620                                uint32_t job_id,
6621                                struct spoolss_SetJobInfo1 *r)
6622 {
6623         char *old_doc_name;
6624
6625         if (!print_job_get_name(mem_ctx, printer_name, job_id, &old_doc_name)) {
6626                 return WERR_BADFID;
6627         }
6628
6629         if (strequal(old_doc_name, r->document_name)) {
6630                 return WERR_OK;
6631         }
6632
6633         if (!print_job_set_name(printer_name, job_id, r->document_name)) {
6634                 return WERR_BADFID;
6635         }
6636
6637         return WERR_OK;
6638 }
6639
6640 /****************************************************************
6641  _spoolss_SetJob
6642 ****************************************************************/
6643
6644 WERROR _spoolss_SetJob(struct pipes_struct *p,
6645                        struct spoolss_SetJob *r)
6646 {
6647         int snum;
6648         WERROR errcode = WERR_BADFUNC;
6649
6650         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
6651                 return WERR_BADFID;
6652         }
6653
6654         if (!print_job_exists(lp_const_servicename(snum), r->in.job_id)) {
6655                 return WERR_INVALID_PRINTER_NAME;
6656         }
6657
6658         switch (r->in.command) {
6659         case SPOOLSS_JOB_CONTROL_CANCEL:
6660         case SPOOLSS_JOB_CONTROL_DELETE:
6661                 errcode = print_job_delete(p->server_info,
6662                                            snum, r->in.job_id);
6663                 if (W_ERROR_EQUAL(errcode, WERR_PRINTER_HAS_JOBS_QUEUED)) {
6664                         errcode = WERR_OK;
6665                 }
6666                 break;
6667         case SPOOLSS_JOB_CONTROL_PAUSE:
6668                 if (print_job_pause(p->server_info, snum, r->in.job_id, &errcode)) {
6669                         errcode = WERR_OK;
6670                 }
6671                 break;
6672         case SPOOLSS_JOB_CONTROL_RESTART:
6673         case SPOOLSS_JOB_CONTROL_RESUME:
6674                 if (print_job_resume(p->server_info, snum, r->in.job_id, &errcode)) {
6675                         errcode = WERR_OK;
6676                 }
6677                 break;
6678         case 0:
6679                 errcode = WERR_OK;
6680                 break;
6681         default:
6682                 return WERR_UNKNOWN_LEVEL;
6683         }
6684
6685         if (!W_ERROR_IS_OK(errcode)) {
6686                 return errcode;
6687         }
6688
6689         if (r->in.ctr == NULL) {
6690                 return errcode;
6691         }
6692
6693         switch (r->in.ctr->level) {
6694         case 1:
6695                 errcode = spoolss_setjob_1(p->mem_ctx, lp_const_servicename(snum),
6696                                            r->in.job_id,
6697                                            r->in.ctr->info.info1);
6698                 break;
6699         case 2:
6700         case 3:
6701         case 4:
6702         default:
6703                 return WERR_UNKNOWN_LEVEL;
6704         }
6705
6706         return errcode;
6707 }
6708
6709 /****************************************************************************
6710  Enumerates all printer drivers by level and architecture.
6711 ****************************************************************************/
6712
6713 static WERROR enumprinterdrivers_level_by_architecture(TALLOC_CTX *mem_ctx,
6714                                                        struct auth_serversupplied_info *server_info,
6715                                                        const char *servername,
6716                                                        const char *architecture,
6717                                                        uint32_t level,
6718                                                        union spoolss_DriverInfo **info_p,
6719                                                        uint32_t *count_p)
6720 {
6721         int i;
6722         uint32_t version;
6723         struct spoolss_DriverInfo8 *driver;
6724         union spoolss_DriverInfo *info = NULL;
6725         uint32_t count = 0;
6726         WERROR result = WERR_OK;
6727         uint32_t num_drivers;
6728         const char **drivers;
6729
6730         *count_p = 0;
6731         *info_p = NULL;
6732
6733         for (version=0; version<DRIVER_MAX_VERSION; version++) {
6734                 result = winreg_get_driver_list(mem_ctx, server_info,
6735                                                 smbd_messaging_context(),
6736                                                 architecture, version,
6737                                                 &num_drivers, &drivers);
6738                 if (!W_ERROR_IS_OK(result)) {
6739                         goto out;
6740                 }
6741                 DEBUG(4, ("we have:[%d] drivers in environment"
6742                           " [%s] and version [%d]\n",
6743                           num_drivers, architecture, version));
6744
6745                 if (num_drivers != 0) {
6746                         info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
6747                                                     union spoolss_DriverInfo,
6748                                                     count + num_drivers);
6749                         if (!info) {
6750                                 DEBUG(0,("enumprinterdrivers_level_by_architecture: "
6751                                         "failed to enlarge driver info buffer!\n"));
6752                                 result = WERR_NOMEM;
6753                                 goto out;
6754                         }
6755                 }
6756
6757                 for (i = 0; i < num_drivers; i++) {
6758                         DEBUG(5, ("\tdriver: [%s]\n", drivers[i]));
6759
6760                         result = winreg_get_driver(mem_ctx, server_info,
6761                                                    smbd_messaging_context(),
6762                                                    architecture, drivers[i],
6763                                                    version, &driver);
6764                         if (!W_ERROR_IS_OK(result)) {
6765                                 goto out;
6766                         }
6767
6768                         switch (level) {
6769                         case 1:
6770                                 result = fill_printer_driver_info1(info, &info[count+i].info1,
6771                                                                    driver, servername);
6772                                 break;
6773                         case 2:
6774                                 result = fill_printer_driver_info2(info, &info[count+i].info2,
6775                                                                    driver, servername);
6776                                 break;
6777                         case 3:
6778                                 result = fill_printer_driver_info3(info, &info[count+i].info3,
6779                                                                    driver, servername);
6780                                 break;
6781                         case 4:
6782                                 result = fill_printer_driver_info4(info, &info[count+i].info4,
6783                                                                    driver, servername);
6784                                 break;
6785                         case 5:
6786                                 result = fill_printer_driver_info5(info, &info[count+i].info5,
6787                                                                    driver, servername);
6788                                 break;
6789                         case 6:
6790                                 result = fill_printer_driver_info6(info, &info[count+i].info6,
6791                                                                    driver, servername);
6792                                 break;
6793                         case 8:
6794                                 result = fill_printer_driver_info8(info, &info[count+i].info8,
6795                                                                    driver, servername);
6796                                 break;
6797                         default:
6798                                 result = WERR_UNKNOWN_LEVEL;
6799                                 break;
6800                         }
6801
6802                         TALLOC_FREE(driver);
6803
6804                         if (!W_ERROR_IS_OK(result)) {
6805                                 goto out;
6806                         }
6807                 }
6808
6809                 count += num_drivers;
6810                 TALLOC_FREE(drivers);
6811         }
6812
6813  out:
6814         TALLOC_FREE(drivers);
6815
6816         if (!W_ERROR_IS_OK(result)) {
6817                 TALLOC_FREE(info);
6818                 return result;
6819         }
6820
6821         *info_p = info;
6822         *count_p = count;
6823
6824         return WERR_OK;
6825 }
6826
6827 /****************************************************************************
6828  Enumerates all printer drivers by level.
6829 ****************************************************************************/
6830
6831 static WERROR enumprinterdrivers_level(TALLOC_CTX *mem_ctx,
6832                                        struct auth_serversupplied_info *server_info,
6833                                        const char *servername,
6834                                        const char *architecture,
6835                                        uint32_t level,
6836                                        union spoolss_DriverInfo **info_p,
6837                                        uint32_t *count_p)
6838 {
6839         uint32_t a,i;
6840         WERROR result = WERR_OK;
6841
6842         if (strequal(architecture, SPOOLSS_ARCHITECTURE_ALL)) {
6843
6844                 for (a=0; archi_table[a].long_archi != NULL; a++) {
6845
6846                         union spoolss_DriverInfo *info = NULL;
6847                         uint32_t count = 0;
6848
6849                         result = enumprinterdrivers_level_by_architecture(mem_ctx,
6850                                                                           server_info,
6851                                                                           servername,
6852                                                                           archi_table[a].long_archi,
6853                                                                           level,
6854                                                                           &info,
6855                                                                           &count);
6856                         if (!W_ERROR_IS_OK(result)) {
6857                                 continue;
6858                         }
6859
6860                         for (i=0; i < count; i++) {
6861                                 ADD_TO_ARRAY(mem_ctx, union spoolss_DriverInfo,
6862                                              info[i], info_p, count_p);
6863                         }
6864                 }
6865
6866                 return result;
6867         }
6868
6869         return enumprinterdrivers_level_by_architecture(mem_ctx,
6870                                                         server_info,
6871                                                         servername,
6872                                                         architecture,
6873                                                         level,
6874                                                         info_p,
6875                                                         count_p);
6876 }
6877
6878 /****************************************************************
6879  _spoolss_EnumPrinterDrivers
6880 ****************************************************************/
6881
6882 WERROR _spoolss_EnumPrinterDrivers(struct pipes_struct *p,
6883                                    struct spoolss_EnumPrinterDrivers *r)
6884 {
6885         const char *cservername;
6886         WERROR result;
6887
6888         /* that's an [in out] buffer */
6889
6890         if (!r->in.buffer && (r->in.offered != 0)) {
6891                 return WERR_INVALID_PARAM;
6892         }
6893
6894         DEBUG(4,("_spoolss_EnumPrinterDrivers\n"));
6895
6896         *r->out.needed = 0;
6897         *r->out.count = 0;
6898         *r->out.info = NULL;
6899
6900         cservername = canon_servername(r->in.server);
6901
6902         if (!is_myname_or_ipaddr(cservername)) {
6903                 return WERR_UNKNOWN_PRINTER_DRIVER;
6904         }
6905
6906         result = enumprinterdrivers_level(p->mem_ctx,
6907                                           p->server_info,
6908                                           cservername,
6909                                           r->in.environment,
6910                                           r->in.level,
6911                                           r->out.info,
6912                                           r->out.count);
6913         if (!W_ERROR_IS_OK(result)) {
6914                 return result;
6915         }
6916
6917         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
6918                                                      spoolss_EnumPrinterDrivers,
6919                                                      *r->out.info, r->in.level,
6920                                                      *r->out.count);
6921         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
6922         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
6923
6924         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
6925 }
6926
6927 /****************************************************************
6928  _spoolss_EnumForms
6929 ****************************************************************/
6930
6931 WERROR _spoolss_EnumForms(struct pipes_struct *p,
6932                           struct spoolss_EnumForms *r)
6933 {
6934         WERROR result;
6935
6936         *r->out.count = 0;
6937         *r->out.needed = 0;
6938         *r->out.info = NULL;
6939
6940         /* that's an [in out] buffer */
6941
6942         if (!r->in.buffer && (r->in.offered != 0) ) {
6943                 return WERR_INVALID_PARAM;
6944         }
6945
6946         DEBUG(4,("_spoolss_EnumForms\n"));
6947         DEBUGADD(5,("Offered buffer size [%d]\n", r->in.offered));
6948         DEBUGADD(5,("Info level [%d]\n",          r->in.level));
6949
6950         switch (r->in.level) {
6951         case 1:
6952                 result = winreg_printer_enumforms1(p->mem_ctx,
6953                                                    p->server_info,
6954                                                    p->msg_ctx,
6955                                                    r->out.count,
6956                                                    r->out.info);
6957                 break;
6958         default:
6959                 result = WERR_UNKNOWN_LEVEL;
6960                 break;
6961         }
6962
6963         if (!W_ERROR_IS_OK(result)) {
6964                 return result;
6965         }
6966
6967         if (*r->out.count == 0) {
6968                 return WERR_NO_MORE_ITEMS;
6969         }
6970
6971         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
6972                                                      spoolss_EnumForms,
6973                                                      *r->out.info, r->in.level,
6974                                                      *r->out.count);
6975         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
6976         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
6977
6978         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
6979 }
6980
6981 /****************************************************************
6982  _spoolss_GetForm
6983 ****************************************************************/
6984
6985 WERROR _spoolss_GetForm(struct pipes_struct *p,
6986                         struct spoolss_GetForm *r)
6987 {
6988         WERROR result;
6989
6990         /* that's an [in out] buffer */
6991
6992         if (!r->in.buffer && (r->in.offered != 0)) {
6993                 return WERR_INVALID_PARAM;
6994         }
6995
6996         DEBUG(4,("_spoolss_GetForm\n"));
6997         DEBUGADD(5,("Offered buffer size [%d]\n", r->in.offered));
6998         DEBUGADD(5,("Info level [%d]\n",          r->in.level));
6999
7000         switch (r->in.level) {
7001         case 1:
7002                 result = winreg_printer_getform1(p->mem_ctx,
7003                                                  p->server_info,
7004                                                  p->msg_ctx,
7005                                                  r->in.form_name,
7006                                                  &r->out.info->info1);
7007                 break;
7008         default:
7009                 result = WERR_UNKNOWN_LEVEL;
7010                 break;
7011         }
7012
7013         if (!W_ERROR_IS_OK(result)) {
7014                 TALLOC_FREE(r->out.info);
7015                 return result;
7016         }
7017
7018         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_FormInfo,
7019                                                r->out.info, r->in.level);
7020         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
7021
7022         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7023 }
7024
7025 /****************************************************************************
7026 ****************************************************************************/
7027
7028 static WERROR fill_port_1(TALLOC_CTX *mem_ctx,
7029                           struct spoolss_PortInfo1 *r,
7030                           const char *name)
7031 {
7032         r->port_name = talloc_strdup(mem_ctx, name);
7033         W_ERROR_HAVE_NO_MEMORY(r->port_name);
7034
7035         return WERR_OK;
7036 }
7037
7038 /****************************************************************************
7039  TODO: This probably needs distinguish between TCP/IP and Local ports
7040  somehow.
7041 ****************************************************************************/
7042
7043 static WERROR fill_port_2(TALLOC_CTX *mem_ctx,
7044                           struct spoolss_PortInfo2 *r,
7045                           const char *name)
7046 {
7047         r->port_name = talloc_strdup(mem_ctx, name);
7048         W_ERROR_HAVE_NO_MEMORY(r->port_name);
7049
7050         r->monitor_name = talloc_strdup(mem_ctx, "Local Monitor");
7051         W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
7052
7053         r->description = talloc_strdup(mem_ctx, SPL_LOCAL_PORT);
7054         W_ERROR_HAVE_NO_MEMORY(r->description);
7055
7056         r->port_type = SPOOLSS_PORT_TYPE_WRITE;
7057         r->reserved = 0;
7058
7059         return WERR_OK;
7060 }
7061
7062
7063 /****************************************************************************
7064  wrapper around the enumer ports command
7065 ****************************************************************************/
7066
7067 static WERROR enumports_hook(TALLOC_CTX *ctx, int *count, char ***lines)
7068 {
7069         char *cmd = lp_enumports_cmd();
7070         char **qlines = NULL;
7071         char *command = NULL;
7072         int numlines;
7073         int ret;
7074         int fd;
7075
7076         *count = 0;
7077         *lines = NULL;
7078
7079         /* if no hook then just fill in the default port */
7080
7081         if ( !*cmd ) {
7082                 if (!(qlines = TALLOC_ARRAY( NULL, char*, 2 ))) {
7083                         return WERR_NOMEM;
7084                 }
7085                 if (!(qlines[0] = talloc_strdup(qlines, SAMBA_PRINTER_PORT_NAME ))) {
7086                         TALLOC_FREE(qlines);
7087                         return WERR_NOMEM;
7088                 }
7089                 qlines[1] = NULL;
7090                 numlines = 1;
7091         }
7092         else {
7093                 /* we have a valid enumport command */
7094
7095                 command = talloc_asprintf(ctx, "%s \"%d\"", cmd, 1);
7096                 if (!command) {
7097                         return WERR_NOMEM;
7098                 }
7099
7100                 DEBUG(10,("Running [%s]\n", command));
7101                 ret = smbrun(command, &fd);
7102                 DEBUG(10,("Returned [%d]\n", ret));
7103                 TALLOC_FREE(command);
7104                 if (ret != 0) {
7105                         if (fd != -1) {
7106                                 close(fd);
7107                         }
7108                         return WERR_ACCESS_DENIED;
7109                 }
7110
7111                 numlines = 0;
7112                 qlines = fd_lines_load(fd, &numlines, 0, NULL);
7113                 DEBUGADD(10,("Lines returned = [%d]\n", numlines));
7114                 close(fd);
7115         }
7116
7117         *count = numlines;
7118         *lines = qlines;
7119
7120         return WERR_OK;
7121 }
7122
7123 /****************************************************************************
7124  enumports level 1.
7125 ****************************************************************************/
7126
7127 static WERROR enumports_level_1(TALLOC_CTX *mem_ctx,
7128                                 union spoolss_PortInfo **info_p,
7129                                 uint32_t *count)
7130 {
7131         union spoolss_PortInfo *info = NULL;
7132         int i=0;
7133         WERROR result = WERR_OK;
7134         char **qlines = NULL;
7135         int numlines = 0;
7136
7137         result = enumports_hook(talloc_tos(), &numlines, &qlines );
7138         if (!W_ERROR_IS_OK(result)) {
7139                 goto out;
7140         }
7141
7142         if (numlines) {
7143                 info = TALLOC_ARRAY(mem_ctx, union spoolss_PortInfo, numlines);
7144                 if (!info) {
7145                         DEBUG(10,("Returning WERR_NOMEM\n"));
7146                         result = WERR_NOMEM;
7147                         goto out;
7148                 }
7149
7150                 for (i=0; i<numlines; i++) {
7151                         DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
7152                         result = fill_port_1(info, &info[i].info1, qlines[i]);
7153                         if (!W_ERROR_IS_OK(result)) {
7154                                 goto out;
7155                         }
7156                 }
7157         }
7158         TALLOC_FREE(qlines);
7159
7160 out:
7161         if (!W_ERROR_IS_OK(result)) {
7162                 TALLOC_FREE(info);
7163                 TALLOC_FREE(qlines);
7164                 *count = 0;
7165                 *info_p = NULL;
7166                 return result;
7167         }
7168
7169         *info_p = info;
7170         *count = numlines;
7171
7172         return WERR_OK;
7173 }
7174
7175 /****************************************************************************
7176  enumports level 2.
7177 ****************************************************************************/
7178
7179 static WERROR enumports_level_2(TALLOC_CTX *mem_ctx,
7180                                 union spoolss_PortInfo **info_p,
7181                                 uint32_t *count)
7182 {
7183         union spoolss_PortInfo *info = NULL;
7184         int i=0;
7185         WERROR result = WERR_OK;
7186         char **qlines = NULL;
7187         int numlines = 0;
7188
7189         result = enumports_hook(talloc_tos(), &numlines, &qlines );
7190         if (!W_ERROR_IS_OK(result)) {
7191                 goto out;
7192         }
7193
7194         if (numlines) {
7195                 info = TALLOC_ARRAY(mem_ctx, union spoolss_PortInfo, numlines);
7196                 if (!info) {
7197                         DEBUG(10,("Returning WERR_NOMEM\n"));
7198                         result = WERR_NOMEM;
7199                         goto out;
7200                 }
7201
7202                 for (i=0; i<numlines; i++) {
7203                         DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
7204                         result = fill_port_2(info, &info[i].info2, qlines[i]);
7205                         if (!W_ERROR_IS_OK(result)) {
7206                                 goto out;
7207                         }
7208                 }
7209         }
7210         TALLOC_FREE(qlines);
7211
7212 out:
7213         if (!W_ERROR_IS_OK(result)) {
7214                 TALLOC_FREE(info);
7215                 TALLOC_FREE(qlines);
7216                 *count = 0;
7217                 *info_p = NULL;
7218                 return result;
7219         }
7220
7221         *info_p = info;
7222         *count = numlines;
7223
7224         return WERR_OK;
7225 }
7226
7227 /****************************************************************
7228  _spoolss_EnumPorts
7229 ****************************************************************/
7230
7231 WERROR _spoolss_EnumPorts(struct pipes_struct *p,
7232                           struct spoolss_EnumPorts *r)
7233 {
7234         WERROR result;
7235
7236         /* that's an [in out] buffer */
7237
7238         if (!r->in.buffer && (r->in.offered != 0)) {
7239                 return WERR_INVALID_PARAM;
7240         }
7241
7242         DEBUG(4,("_spoolss_EnumPorts\n"));
7243
7244         *r->out.count = 0;
7245         *r->out.needed = 0;
7246         *r->out.info = NULL;
7247
7248         switch (r->in.level) {
7249         case 1:
7250                 result = enumports_level_1(p->mem_ctx, r->out.info,
7251                                            r->out.count);
7252                 break;
7253         case 2:
7254                 result = enumports_level_2(p->mem_ctx, r->out.info,
7255                                            r->out.count);
7256                 break;
7257         default:
7258                 return WERR_UNKNOWN_LEVEL;
7259         }
7260
7261         if (!W_ERROR_IS_OK(result)) {
7262                 return result;
7263         }
7264
7265         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
7266                                                      spoolss_EnumPorts,
7267                                                      *r->out.info, r->in.level,
7268                                                      *r->out.count);
7269         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
7270         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
7271
7272         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7273 }
7274
7275 /****************************************************************************
7276 ****************************************************************************/
7277
7278 static WERROR spoolss_addprinterex_level_2(struct pipes_struct *p,
7279                                            const char *server,
7280                                            struct spoolss_SetPrinterInfoCtr *info_ctr,
7281                                            struct spoolss_DeviceMode *devmode,
7282                                            struct security_descriptor *secdesc,
7283                                            struct spoolss_UserLevelCtr *user_ctr,
7284                                            struct policy_handle *handle)
7285 {
7286         struct spoolss_SetPrinterInfo2 *info2 = info_ctr->info.info2;
7287         uint32_t info2_mask = SPOOLSS_PRINTER_INFO_ALL;
7288         int     snum;
7289         WERROR err = WERR_OK;
7290
7291         /* samba does not have a concept of local, non-shared printers yet, so
7292          * make sure we always setup sharename - gd */
7293         if ((info2->sharename == NULL || info2->sharename[0] == '\0') &&
7294             (info2->printername != NULL && info2->printername[0] != '\0')) {
7295                 DEBUG(5, ("spoolss_addprinterex_level_2: "
7296                         "no sharename has been set, setting printername %s as sharename\n",
7297                         info2->printername));
7298                 info2->sharename = info2->printername;
7299         }
7300
7301         /* check to see if the printer already exists */
7302         if ((snum = print_queue_snum(info2->sharename)) != -1) {
7303                 DEBUG(5, ("spoolss_addprinterex_level_2: Attempted to add a printer named [%s] when one already existed!\n",
7304                         info2->sharename));
7305                 return WERR_PRINTER_ALREADY_EXISTS;
7306         }
7307
7308         if (!lp_force_printername(GLOBAL_SECTION_SNUM)) {
7309                 if ((snum = print_queue_snum(info2->printername)) != -1) {
7310                         DEBUG(5, ("spoolss_addprinterex_level_2: Attempted to add a printer named [%s] when one already existed!\n",
7311                                 info2->printername));
7312                         return WERR_PRINTER_ALREADY_EXISTS;
7313                 }
7314         }
7315
7316         /* validate printer info struct */
7317         if (!info2->printername || strlen(info2->printername) == 0) {
7318                 return WERR_INVALID_PRINTER_NAME;
7319         }
7320         if (!info2->portname || strlen(info2->portname) == 0) {
7321                 return WERR_UNKNOWN_PORT;
7322         }
7323         if (!info2->drivername || strlen(info2->drivername) == 0) {
7324                 return WERR_UNKNOWN_PRINTER_DRIVER;
7325         }
7326         if (!info2->printprocessor || strlen(info2->printprocessor) == 0) {
7327                 return WERR_UNKNOWN_PRINTPROCESSOR;
7328         }
7329
7330         /* FIXME!!!  smbd should check to see if the driver is installed before
7331            trying to add a printer like this  --jerry */
7332
7333         if (*lp_addprinter_cmd() ) {
7334                 if ( !add_printer_hook(p->mem_ctx, p->server_info->ptok,
7335                                        info2, p->client_address,
7336                                        p->msg_ctx) ) {
7337                         return WERR_ACCESS_DENIED;
7338                 }
7339         } else {
7340                 DEBUG(0,("spoolss_addprinterex_level_2: add printer for printer %s called and no"
7341                         "smb.conf parameter \"addprinter command\" is defined. This"
7342                         "parameter must exist for this call to succeed\n",
7343                         info2->sharename ));
7344         }
7345
7346         if ((snum = print_queue_snum(info2->sharename)) == -1) {
7347                 return WERR_ACCESS_DENIED;
7348         }
7349
7350         /* you must be a printer admin to add a new printer */
7351         if (!print_access_check(p->server_info, snum, PRINTER_ACCESS_ADMINISTER)) {
7352                 return WERR_ACCESS_DENIED;
7353         }
7354
7355         /*
7356          * Do sanity check on the requested changes for Samba.
7357          */
7358
7359         if (!check_printer_ok(p->mem_ctx, info2, snum)) {
7360                 return WERR_INVALID_PARAM;
7361         }
7362
7363         if (devmode == NULL) {
7364                 info2_mask = ~SPOOLSS_PRINTER_INFO_DEVMODE;
7365         }
7366
7367         update_dsspooler(p->mem_ctx,
7368                          p->server_info,
7369                          0,
7370                          info2,
7371                          NULL);
7372
7373         err = winreg_update_printer(p->mem_ctx,
7374                                     p->server_info,
7375                                     p->msg_ctx,
7376                                     info2->sharename,
7377                                     info2_mask,
7378                                     info2,
7379                                     devmode,
7380                                     secdesc);
7381         if (!W_ERROR_IS_OK(err)) {
7382                 return err;
7383         }
7384
7385         if (!open_printer_hnd(p, handle, info2->printername, PRINTER_ACCESS_ADMINISTER)) {
7386                 /* Handle open failed - remove addition. */
7387                 ZERO_STRUCTP(handle);
7388                 return WERR_ACCESS_DENIED;
7389         }
7390
7391         return WERR_OK;
7392 }
7393
7394 /****************************************************************
7395  _spoolss_AddPrinterEx
7396 ****************************************************************/
7397
7398 WERROR _spoolss_AddPrinterEx(struct pipes_struct *p,
7399                              struct spoolss_AddPrinterEx *r)
7400 {
7401         switch (r->in.info_ctr->level) {
7402         case 1:
7403                 /* we don't handle yet */
7404                 /* but I know what to do ... */
7405                 return WERR_UNKNOWN_LEVEL;
7406         case 2:
7407                 return spoolss_addprinterex_level_2(p, r->in.server,
7408                                                     r->in.info_ctr,
7409                                                     r->in.devmode_ctr->devmode,
7410                                                     r->in.secdesc_ctr->sd,
7411                                                     r->in.userlevel_ctr,
7412                                                     r->out.handle);
7413         default:
7414                 return WERR_UNKNOWN_LEVEL;
7415         }
7416 }
7417
7418 /****************************************************************
7419  _spoolss_AddPrinter
7420 ****************************************************************/
7421
7422 WERROR _spoolss_AddPrinter(struct pipes_struct *p,
7423                            struct spoolss_AddPrinter *r)
7424 {
7425         struct spoolss_AddPrinterEx a;
7426         struct spoolss_UserLevelCtr userlevel_ctr;
7427
7428         ZERO_STRUCT(userlevel_ctr);
7429
7430         userlevel_ctr.level = 1;
7431
7432         a.in.server             = r->in.server;
7433         a.in.info_ctr           = r->in.info_ctr;
7434         a.in.devmode_ctr        = r->in.devmode_ctr;
7435         a.in.secdesc_ctr        = r->in.secdesc_ctr;
7436         a.in.userlevel_ctr      = &userlevel_ctr;
7437         a.out.handle            = r->out.handle;
7438
7439         return _spoolss_AddPrinterEx(p, &a);
7440 }
7441
7442 /****************************************************************
7443  _spoolss_AddPrinterDriverEx
7444 ****************************************************************/
7445
7446 WERROR _spoolss_AddPrinterDriverEx(struct pipes_struct *p,
7447                                    struct spoolss_AddPrinterDriverEx *r)
7448 {
7449         WERROR err = WERR_OK;
7450         const char *driver_name = NULL;
7451         uint32_t version;
7452         const char *fn;
7453
7454         switch (p->opnum) {
7455                 case NDR_SPOOLSS_ADDPRINTERDRIVER:
7456                         fn = "_spoolss_AddPrinterDriver";
7457                         break;
7458                 case NDR_SPOOLSS_ADDPRINTERDRIVEREX:
7459                         fn = "_spoolss_AddPrinterDriverEx";
7460                         break;
7461                 default:
7462                         return WERR_INVALID_PARAM;
7463         }
7464
7465         /*
7466          * we only support the semantics of AddPrinterDriver()
7467          * i.e. only copy files that are newer than existing ones
7468          */
7469
7470         if (r->in.flags == 0) {
7471                 return WERR_INVALID_PARAM;
7472         }
7473
7474         if (r->in.flags != APD_COPY_NEW_FILES) {
7475                 return WERR_ACCESS_DENIED;
7476         }
7477
7478         /* FIXME */
7479         if (r->in.info_ctr->level != 3 && r->in.info_ctr->level != 6) {
7480                 /* Clever hack from Martin Zielinski <mz@seh.de>
7481                  * to allow downgrade from level 8 (Vista).
7482                  */
7483                 DEBUG(0,("%s: level %d not yet implemented\n", fn,
7484                         r->in.info_ctr->level));
7485                 return WERR_UNKNOWN_LEVEL;
7486         }
7487
7488         DEBUG(5,("Cleaning driver's information\n"));
7489         err = clean_up_driver_struct(p->mem_ctx, p, r->in.info_ctr);
7490         if (!W_ERROR_IS_OK(err))
7491                 goto done;
7492
7493         DEBUG(5,("Moving driver to final destination\n"));
7494         if( !W_ERROR_IS_OK(err = move_driver_to_download_area(p, r->in.info_ctr,
7495                                                               &err)) ) {
7496                 goto done;
7497         }
7498
7499         err = winreg_add_driver(p->mem_ctx, p->server_info, p->msg_ctx,
7500                                 r->in.info_ctr, &driver_name, &version);
7501         if (!W_ERROR_IS_OK(err)) {
7502                 goto done;
7503         }
7504
7505         /*
7506          * I think this is where he DrvUpgradePrinter() hook would be
7507          * be called in a driver's interface DLL on a Windows NT 4.0/2k
7508          * server.  Right now, we just need to send ourselves a message
7509          * to update each printer bound to this driver.   --jerry
7510          */
7511
7512         if (!srv_spoolss_drv_upgrade_printer(driver_name, p->msg_ctx)) {
7513                 DEBUG(0,("%s: Failed to send message about upgrading driver [%s]!\n",
7514                         fn, driver_name));
7515         }
7516
7517 done:
7518         return err;
7519 }
7520
7521 /****************************************************************
7522  _spoolss_AddPrinterDriver
7523 ****************************************************************/
7524
7525 WERROR _spoolss_AddPrinterDriver(struct pipes_struct *p,
7526                                  struct spoolss_AddPrinterDriver *r)
7527 {
7528         struct spoolss_AddPrinterDriverEx a;
7529
7530         switch (r->in.info_ctr->level) {
7531         case 2:
7532         case 3:
7533         case 4:
7534         case 5:
7535                 break;
7536         default:
7537                 return WERR_UNKNOWN_LEVEL;
7538         }
7539
7540         a.in.servername         = r->in.servername;
7541         a.in.info_ctr           = r->in.info_ctr;
7542         a.in.flags              = APD_COPY_NEW_FILES;
7543
7544         return _spoolss_AddPrinterDriverEx(p, &a);
7545 }
7546
7547 /****************************************************************************
7548 ****************************************************************************/
7549
7550 struct _spoolss_paths {
7551         int type;
7552         const char *share;
7553         const char *dir;
7554 };
7555
7556 enum { SPOOLSS_DRIVER_PATH, SPOOLSS_PRTPROCS_PATH };
7557
7558 static const struct _spoolss_paths spoolss_paths[]= {
7559         { SPOOLSS_DRIVER_PATH,          "print$",       "DRIVERS" },
7560         { SPOOLSS_PRTPROCS_PATH,        "prnproc$",     "PRTPROCS" }
7561 };
7562
7563 static WERROR compose_spoolss_server_path(TALLOC_CTX *mem_ctx,
7564                                           const char *servername,
7565                                           const char *environment,
7566                                           int component,
7567                                           char **path)
7568 {
7569         const char *pservername = NULL;
7570         const char *long_archi = SPOOLSS_ARCHITECTURE_NT_X86;
7571         const char *short_archi;
7572
7573         *path = NULL;
7574
7575         /* environment may be empty */
7576         if (environment && strlen(environment)) {
7577                 long_archi = environment;
7578         }
7579
7580         /* servername may be empty */
7581         if (servername && strlen(servername)) {
7582                 pservername = canon_servername(servername);
7583
7584                 if (!is_myname_or_ipaddr(pservername)) {
7585                         return WERR_INVALID_PARAM;
7586                 }
7587         }
7588
7589         if (!(short_archi = get_short_archi(long_archi))) {
7590                 return WERR_INVALID_ENVIRONMENT;
7591         }
7592
7593         switch (component) {
7594         case SPOOLSS_PRTPROCS_PATH:
7595         case SPOOLSS_DRIVER_PATH:
7596                 if (pservername) {
7597                         *path = talloc_asprintf(mem_ctx,
7598                                         "\\\\%s\\%s\\%s",
7599                                         pservername,
7600                                         spoolss_paths[component].share,
7601                                         short_archi);
7602                 } else {
7603                         *path = talloc_asprintf(mem_ctx, "%s\\%s\\%s",
7604                                         SPOOLSS_DEFAULT_SERVER_PATH,
7605                                         spoolss_paths[component].dir,
7606                                         short_archi);
7607                 }
7608                 break;
7609         default:
7610                 return WERR_INVALID_PARAM;
7611         }
7612
7613         if (!*path) {
7614                 return WERR_NOMEM;
7615         }
7616
7617         return WERR_OK;
7618 }
7619
7620 /****************************************************************************
7621 ****************************************************************************/
7622
7623 static WERROR getprinterdriverdir_level_1(TALLOC_CTX *mem_ctx,
7624                                           const char *servername,
7625                                           const char *environment,
7626                                           struct spoolss_DriverDirectoryInfo1 *r)
7627 {
7628         WERROR werr;
7629         char *path = NULL;
7630
7631         werr = compose_spoolss_server_path(mem_ctx,
7632                                            servername,
7633                                            environment,
7634                                            SPOOLSS_DRIVER_PATH,
7635                                            &path);
7636         if (!W_ERROR_IS_OK(werr)) {
7637                 return werr;
7638         }
7639
7640         DEBUG(4,("printer driver directory: [%s]\n", path));
7641
7642         r->directory_name = path;
7643
7644         return WERR_OK;
7645 }
7646
7647 /****************************************************************
7648  _spoolss_GetPrinterDriverDirectory
7649 ****************************************************************/
7650
7651 WERROR _spoolss_GetPrinterDriverDirectory(struct pipes_struct *p,
7652                                           struct spoolss_GetPrinterDriverDirectory *r)
7653 {
7654         WERROR werror;
7655
7656         /* that's an [in out] buffer */
7657
7658         if (!r->in.buffer && (r->in.offered != 0)) {
7659                 return WERR_INVALID_PARAM;
7660         }
7661
7662         DEBUG(5,("_spoolss_GetPrinterDriverDirectory: level %d\n",
7663                 r->in.level));
7664
7665         *r->out.needed = 0;
7666
7667         /* r->in.level is ignored */
7668
7669         werror = getprinterdriverdir_level_1(p->mem_ctx,
7670                                              r->in.server,
7671                                              r->in.environment,
7672                                              &r->out.info->info1);
7673         if (!W_ERROR_IS_OK(werror)) {
7674                 TALLOC_FREE(r->out.info);
7675                 return werror;
7676         }
7677
7678         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_DriverDirectoryInfo,
7679                                                r->out.info, r->in.level);
7680         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
7681
7682         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7683 }
7684
7685 /****************************************************************
7686  _spoolss_EnumPrinterData
7687 ****************************************************************/
7688
7689 WERROR _spoolss_EnumPrinterData(struct pipes_struct *p,
7690                                 struct spoolss_EnumPrinterData *r)
7691 {
7692         WERROR result;
7693         struct spoolss_EnumPrinterDataEx r2;
7694         uint32_t count;
7695         struct spoolss_PrinterEnumValues *info, *val = NULL;
7696         uint32_t needed;
7697
7698         r2.in.handle    = r->in.handle;
7699         r2.in.key_name  = "PrinterDriverData";
7700         r2.in.offered   = 0;
7701         r2.out.count    = &count;
7702         r2.out.info     = &info;
7703         r2.out.needed   = &needed;
7704
7705         result = _spoolss_EnumPrinterDataEx(p, &r2);
7706         if (W_ERROR_EQUAL(result, WERR_MORE_DATA)) {
7707                 r2.in.offered = needed;
7708                 result = _spoolss_EnumPrinterDataEx(p, &r2);
7709         }
7710         if (!W_ERROR_IS_OK(result)) {
7711                 return result;
7712         }
7713
7714         /*
7715          * The NT machine wants to know the biggest size of value and data
7716          *
7717          * cf: MSDN EnumPrinterData remark section
7718          */
7719
7720         if (!r->in.value_offered && !r->in.data_offered) {
7721                 uint32_t biggest_valuesize = 0;
7722                 uint32_t biggest_datasize = 0;
7723                 int i, name_length;
7724
7725                 DEBUGADD(6,("Activating NT mega-hack to find sizes\n"));
7726
7727                 for (i=0; i<count; i++) {
7728
7729                         name_length = strlen(info[i].value_name);
7730                         if (strlen(info[i].value_name) > biggest_valuesize) {
7731                                 biggest_valuesize = name_length;
7732                         }
7733
7734                         if (info[i].data_length > biggest_datasize) {
7735                                 biggest_datasize = info[i].data_length;
7736                         }
7737
7738                         DEBUG(6,("current values: [%d], [%d]\n", biggest_valuesize,
7739                                 biggest_datasize));
7740                 }
7741
7742                 /* the value is an UNICODE string but real_value_size is the length
7743                    in bytes including the trailing 0 */
7744
7745                 *r->out.value_needed = 2 * (1 + biggest_valuesize);
7746                 *r->out.data_needed  = biggest_datasize;
7747
7748                 DEBUG(6,("final values: [%d], [%d]\n",
7749                         *r->out.value_needed, *r->out.data_needed));
7750
7751                 return WERR_OK;
7752         }
7753
7754         if (r->in.enum_index < count) {
7755                 val = &info[r->in.enum_index];
7756         }
7757
7758         if (val == NULL) {
7759                 /* out_value should default to "" or else NT4 has
7760                    problems unmarshalling the response */
7761
7762                 if (r->in.value_offered) {
7763                         *r->out.value_needed = 1;
7764                         r->out.value_name = talloc_strdup(r, "");
7765                         if (!r->out.value_name) {
7766                                 return WERR_NOMEM;
7767                         }
7768                 } else {
7769                         r->out.value_name = NULL;
7770                         *r->out.value_needed = 0;
7771                 }
7772
7773                 /* the data is counted in bytes */
7774
7775                 *r->out.data_needed = r->in.data_offered;
7776
7777                 result = WERR_NO_MORE_ITEMS;
7778         } else {
7779                 /*
7780                  * the value is:
7781                  * - counted in bytes in the request
7782                  * - counted in UNICODE chars in the max reply
7783                  * - counted in bytes in the real size
7784                  *
7785                  * take a pause *before* coding not *during* coding
7786                  */
7787
7788                 /* name */
7789                 if (r->in.value_offered) {
7790                         r->out.value_name = talloc_strdup(r, val->value_name);
7791                         if (!r->out.value_name) {
7792                                 return WERR_NOMEM;
7793                         }
7794                         *r->out.value_needed = val->value_name_len;
7795                 } else {
7796                         r->out.value_name = NULL;
7797                         *r->out.value_needed = 0;
7798                 }
7799
7800                 /* type */
7801
7802                 *r->out.type = val->type;
7803
7804                 /* data - counted in bytes */
7805
7806                 /*
7807                  * See the section "Dynamically Typed Query Parameters"
7808                  * in MS-RPRN.
7809                  */
7810
7811                 if (r->out.data && val->data && val->data->data &&
7812                                 val->data_length && r->in.data_offered) {
7813                         memcpy(r->out.data, val->data->data,
7814                                 MIN(val->data_length,r->in.data_offered));
7815                 }
7816
7817                 *r->out.data_needed = val->data_length;
7818
7819                 result = WERR_OK;
7820         }
7821
7822         return result;
7823 }
7824
7825 /****************************************************************
7826  _spoolss_SetPrinterData
7827 ****************************************************************/
7828
7829 WERROR _spoolss_SetPrinterData(struct pipes_struct *p,
7830                                struct spoolss_SetPrinterData *r)
7831 {
7832         struct spoolss_SetPrinterDataEx r2;
7833
7834         r2.in.handle            = r->in.handle;
7835         r2.in.key_name          = "PrinterDriverData";
7836         r2.in.value_name        = r->in.value_name;
7837         r2.in.type              = r->in.type;
7838         r2.in.data              = r->in.data;
7839         r2.in.offered           = r->in.offered;
7840
7841         return _spoolss_SetPrinterDataEx(p, &r2);
7842 }
7843
7844 /****************************************************************
7845  _spoolss_ResetPrinter
7846 ****************************************************************/
7847
7848 WERROR _spoolss_ResetPrinter(struct pipes_struct *p,
7849                              struct spoolss_ResetPrinter *r)
7850 {
7851         Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
7852         int             snum;
7853
7854         DEBUG(5,("_spoolss_ResetPrinter\n"));
7855
7856         /*
7857          * All we do is to check to see if the handle and queue is valid.
7858          * This call really doesn't mean anything to us because we only
7859          * support RAW printing.   --jerry
7860          */
7861
7862         if (!Printer) {
7863                 DEBUG(2,("_spoolss_ResetPrinter: Invalid handle (%s:%u:%u).\n",
7864                         OUR_HANDLE(r->in.handle)));
7865                 return WERR_BADFID;
7866         }
7867
7868         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
7869                 return WERR_BADFID;
7870
7871
7872         /* blindly return success */
7873         return WERR_OK;
7874 }
7875
7876 /****************************************************************
7877  _spoolss_DeletePrinterData
7878 ****************************************************************/
7879
7880 WERROR _spoolss_DeletePrinterData(struct pipes_struct *p,
7881                                   struct spoolss_DeletePrinterData *r)
7882 {
7883         struct spoolss_DeletePrinterDataEx r2;
7884
7885         r2.in.handle            = r->in.handle;
7886         r2.in.key_name          = "PrinterDriverData";
7887         r2.in.value_name        = r->in.value_name;
7888
7889         return _spoolss_DeletePrinterDataEx(p, &r2);
7890 }
7891
7892 /****************************************************************
7893  _spoolss_AddForm
7894 ****************************************************************/
7895
7896 WERROR _spoolss_AddForm(struct pipes_struct *p,
7897                         struct spoolss_AddForm *r)
7898 {
7899         struct spoolss_AddFormInfo1 *form = r->in.info.info1;
7900         int snum = -1;
7901         WERROR status = WERR_OK;
7902         SE_PRIV se_printop = SE_PRINT_OPERATOR;
7903
7904         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
7905
7906         DEBUG(5,("_spoolss_AddForm\n"));
7907
7908         if (!Printer) {
7909                 DEBUG(2,("_spoolss_AddForm: Invalid handle (%s:%u:%u).\n",
7910                         OUR_HANDLE(r->in.handle)));
7911                 return WERR_BADFID;
7912         }
7913
7914         /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
7915            and not a printer admin, then fail */
7916
7917         if ((p->server_info->utok.uid != sec_initial_uid()) &&
7918              !user_has_privileges(p->server_info->ptok, &se_printop) &&
7919              !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
7920                                           p->server_info->info3->base.domain.string,
7921                                           NULL,
7922                                           p->server_info->ptok,
7923                                           lp_printer_admin(snum))) {
7924                 DEBUG(2,("_spoolss_Addform: denied by insufficient permissions.\n"));
7925                 return WERR_ACCESS_DENIED;
7926         }
7927
7928         switch (form->flags) {
7929         case SPOOLSS_FORM_USER:
7930         case SPOOLSS_FORM_BUILTIN:
7931         case SPOOLSS_FORM_PRINTER:
7932                 break;
7933         default:
7934                 return WERR_INVALID_PARAM;
7935         }
7936
7937         status = winreg_printer_addform1(p->mem_ctx, p->server_info,
7938                                          p->msg_ctx, form);
7939         if (!W_ERROR_IS_OK(status)) {
7940                 return status;
7941         }
7942
7943         /*
7944          * ChangeID must always be set if this is a printer
7945          */
7946         if (Printer->printer_type == SPLHND_PRINTER) {
7947                 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
7948                         return WERR_BADFID;
7949                 }
7950
7951                 status = winreg_printer_update_changeid(p->mem_ctx,
7952                                                         p->server_info,
7953                                                         p->msg_ctx,
7954                                                         lp_const_servicename(snum));
7955                 if (!W_ERROR_IS_OK(status)) {
7956                         return status;
7957                 }
7958         }
7959
7960         return status;
7961 }
7962
7963 /****************************************************************
7964  _spoolss_DeleteForm
7965 ****************************************************************/
7966
7967 WERROR _spoolss_DeleteForm(struct pipes_struct *p,
7968                            struct spoolss_DeleteForm *r)
7969 {
7970         const char *form_name = r->in.form_name;
7971         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
7972         int snum = -1;
7973         WERROR status = WERR_OK;
7974         SE_PRIV se_printop = SE_PRINT_OPERATOR;
7975
7976         DEBUG(5,("_spoolss_DeleteForm\n"));
7977
7978         if (!Printer) {
7979                 DEBUG(2,("_spoolss_DeleteForm: Invalid handle (%s:%u:%u).\n",
7980                         OUR_HANDLE(r->in.handle)));
7981                 return WERR_BADFID;
7982         }
7983
7984         if ((p->server_info->utok.uid != sec_initial_uid()) &&
7985              !user_has_privileges(p->server_info->ptok, &se_printop) &&
7986              !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
7987                                           p->server_info->info3->base.domain.string,
7988                                           NULL,
7989                                           p->server_info->ptok,
7990                                           lp_printer_admin(snum))) {
7991                 DEBUG(2,("_spoolss_DeleteForm: denied by insufficient permissions.\n"));
7992                 return WERR_ACCESS_DENIED;
7993         }
7994
7995         status = winreg_printer_deleteform1(p->mem_ctx,
7996                                             p->server_info,
7997                                             p->msg_ctx,
7998                                             form_name);
7999         if (!W_ERROR_IS_OK(status)) {
8000                 return status;
8001         }
8002
8003         /*
8004          * ChangeID must always be set if this is a printer
8005          */
8006         if (Printer->printer_type == SPLHND_PRINTER) {
8007                 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8008                         return WERR_BADFID;
8009                 }
8010
8011                 status = winreg_printer_update_changeid(p->mem_ctx,
8012                                                         p->server_info,
8013                                                         p->msg_ctx,
8014                                                         lp_const_servicename(snum));
8015                 if (!W_ERROR_IS_OK(status)) {
8016                         return status;
8017                 }
8018         }
8019
8020         return status;
8021 }
8022
8023 /****************************************************************
8024  _spoolss_SetForm
8025 ****************************************************************/
8026
8027 WERROR _spoolss_SetForm(struct pipes_struct *p,
8028                         struct spoolss_SetForm *r)
8029 {
8030         struct spoolss_AddFormInfo1 *form = r->in.info.info1;
8031         const char *form_name = r->in.form_name;
8032         int snum = -1;
8033         WERROR status = WERR_OK;
8034         SE_PRIV se_printop = SE_PRINT_OPERATOR;
8035
8036         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8037
8038         DEBUG(5,("_spoolss_SetForm\n"));
8039
8040         if (!Printer) {
8041                 DEBUG(2,("_spoolss_SetForm: Invalid handle (%s:%u:%u).\n",
8042                         OUR_HANDLE(r->in.handle)));
8043                 return WERR_BADFID;
8044         }
8045
8046         /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
8047            and not a printer admin, then fail */
8048
8049         if ((p->server_info->utok.uid != sec_initial_uid()) &&
8050              !user_has_privileges(p->server_info->ptok, &se_printop) &&
8051              !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
8052                                           p->server_info->info3->base.domain.string,
8053                                           NULL,
8054                                           p->server_info->ptok,
8055                                           lp_printer_admin(snum))) {
8056                 DEBUG(2,("_spoolss_Setform: denied by insufficient permissions.\n"));
8057                 return WERR_ACCESS_DENIED;
8058         }
8059
8060         status = winreg_printer_setform1(p->mem_ctx,
8061                                          p->server_info,
8062                                          p->msg_ctx,
8063                                          form_name,
8064                                          form);
8065         if (!W_ERROR_IS_OK(status)) {
8066                 return status;
8067         }
8068
8069         /*
8070          * ChangeID must always be set if this is a printer
8071          */
8072         if (Printer->printer_type == SPLHND_PRINTER) {
8073                 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8074                         return WERR_BADFID;
8075                 }
8076
8077                 status = winreg_printer_update_changeid(p->mem_ctx,
8078                                                         p->server_info,
8079                                                         p->msg_ctx,
8080                                                         lp_const_servicename(snum));
8081                 if (!W_ERROR_IS_OK(status)) {
8082                         return status;
8083                 }
8084         }
8085
8086         return status;
8087 }
8088
8089 /****************************************************************************
8090  fill_print_processor1
8091 ****************************************************************************/
8092
8093 static WERROR fill_print_processor1(TALLOC_CTX *mem_ctx,
8094                                     struct spoolss_PrintProcessorInfo1 *r,
8095                                     const char *print_processor_name)
8096 {
8097         r->print_processor_name = talloc_strdup(mem_ctx, print_processor_name);
8098         W_ERROR_HAVE_NO_MEMORY(r->print_processor_name);
8099
8100         return WERR_OK;
8101 }
8102
8103 /****************************************************************************
8104  enumprintprocessors level 1.
8105 ****************************************************************************/
8106
8107 static WERROR enumprintprocessors_level_1(TALLOC_CTX *mem_ctx,
8108                                           union spoolss_PrintProcessorInfo **info_p,
8109                                           uint32_t *count)
8110 {
8111         union spoolss_PrintProcessorInfo *info;
8112         WERROR result;
8113
8114         info = TALLOC_ARRAY(mem_ctx, union spoolss_PrintProcessorInfo, 1);
8115         W_ERROR_HAVE_NO_MEMORY(info);
8116
8117         *count = 1;
8118
8119         result = fill_print_processor1(info, &info[0].info1, "winprint");
8120         if (!W_ERROR_IS_OK(result)) {
8121                 goto out;
8122         }
8123
8124  out:
8125         if (!W_ERROR_IS_OK(result)) {
8126                 TALLOC_FREE(info);
8127                 *count = 0;
8128                 return result;
8129         }
8130
8131         *info_p = info;
8132
8133         return WERR_OK;
8134 }
8135
8136 /****************************************************************
8137  _spoolss_EnumPrintProcessors
8138 ****************************************************************/
8139
8140 WERROR _spoolss_EnumPrintProcessors(struct pipes_struct *p,
8141                                     struct spoolss_EnumPrintProcessors *r)
8142 {
8143         WERROR result;
8144
8145         /* that's an [in out] buffer */
8146
8147         if (!r->in.buffer && (r->in.offered != 0)) {
8148                 return WERR_INVALID_PARAM;
8149         }
8150
8151         DEBUG(5,("_spoolss_EnumPrintProcessors\n"));
8152
8153         /*
8154          * Enumerate the print processors ...
8155          *
8156          * Just reply with "winprint", to keep NT happy
8157          * and I can use my nice printer checker.
8158          */
8159
8160         *r->out.count = 0;
8161         *r->out.needed = 0;
8162         *r->out.info = NULL;
8163
8164         switch (r->in.level) {
8165         case 1:
8166                 result = enumprintprocessors_level_1(p->mem_ctx, r->out.info,
8167                                                      r->out.count);
8168                 break;
8169         default:
8170                 return WERR_UNKNOWN_LEVEL;
8171         }
8172
8173         if (!W_ERROR_IS_OK(result)) {
8174                 return result;
8175         }
8176
8177         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8178                                                      spoolss_EnumPrintProcessors,
8179                                                      *r->out.info, r->in.level,
8180                                                      *r->out.count);
8181         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8182         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8183
8184         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8185 }
8186
8187 /****************************************************************************
8188  fill_printprocdatatype1
8189 ****************************************************************************/
8190
8191 static WERROR fill_printprocdatatype1(TALLOC_CTX *mem_ctx,
8192                                       struct spoolss_PrintProcDataTypesInfo1 *r,
8193                                       const char *name_array)
8194 {
8195         r->name_array = talloc_strdup(mem_ctx, name_array);
8196         W_ERROR_HAVE_NO_MEMORY(r->name_array);
8197
8198         return WERR_OK;
8199 }
8200
8201 /****************************************************************************
8202  enumprintprocdatatypes level 1.
8203 ****************************************************************************/
8204
8205 static WERROR enumprintprocdatatypes_level_1(TALLOC_CTX *mem_ctx,
8206                                              union spoolss_PrintProcDataTypesInfo **info_p,
8207                                              uint32_t *count)
8208 {
8209         WERROR result;
8210         union spoolss_PrintProcDataTypesInfo *info;
8211
8212         info = TALLOC_ARRAY(mem_ctx, union spoolss_PrintProcDataTypesInfo, 1);
8213         W_ERROR_HAVE_NO_MEMORY(info);
8214
8215         *count = 1;
8216
8217         result = fill_printprocdatatype1(info, &info[0].info1, "RAW");
8218         if (!W_ERROR_IS_OK(result)) {
8219                 goto out;
8220         }
8221
8222  out:
8223         if (!W_ERROR_IS_OK(result)) {
8224                 TALLOC_FREE(info);
8225                 *count = 0;
8226                 return result;
8227         }
8228
8229         *info_p = info;
8230
8231         return WERR_OK;
8232 }
8233
8234 /****************************************************************
8235  _spoolss_EnumPrintProcDataTypes
8236 ****************************************************************/
8237
8238 WERROR _spoolss_EnumPrintProcDataTypes(struct pipes_struct *p,
8239                                        struct spoolss_EnumPrintProcDataTypes *r)
8240 {
8241         WERROR result;
8242
8243         /* that's an [in out] buffer */
8244
8245         if (!r->in.buffer && (r->in.offered != 0)) {
8246                 return WERR_INVALID_PARAM;
8247         }
8248
8249         DEBUG(5,("_spoolss_EnumPrintProcDataTypes\n"));
8250
8251         *r->out.count = 0;
8252         *r->out.needed = 0;
8253         *r->out.info = NULL;
8254
8255         switch (r->in.level) {
8256         case 1:
8257                 result = enumprintprocdatatypes_level_1(p->mem_ctx, r->out.info,
8258                                                         r->out.count);
8259                 break;
8260         default:
8261                 return WERR_UNKNOWN_LEVEL;
8262         }
8263
8264         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8265                                                      spoolss_EnumPrintProcDataTypes,
8266                                                      *r->out.info, r->in.level,
8267                                                      *r->out.count);
8268         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8269         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8270
8271         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8272 }
8273
8274 /****************************************************************************
8275  fill_monitor_1
8276 ****************************************************************************/
8277
8278 static WERROR fill_monitor_1(TALLOC_CTX *mem_ctx,
8279                              struct spoolss_MonitorInfo1 *r,
8280                              const char *monitor_name)
8281 {
8282         r->monitor_name                 = talloc_strdup(mem_ctx, monitor_name);
8283         W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
8284
8285         return WERR_OK;
8286 }
8287
8288 /****************************************************************************
8289  fill_monitor_2
8290 ****************************************************************************/
8291
8292 static WERROR fill_monitor_2(TALLOC_CTX *mem_ctx,
8293                              struct spoolss_MonitorInfo2 *r,
8294                              const char *monitor_name,
8295                              const char *environment,
8296                              const char *dll_name)
8297 {
8298         r->monitor_name                 = talloc_strdup(mem_ctx, monitor_name);
8299         W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
8300         r->environment                  = talloc_strdup(mem_ctx, environment);
8301         W_ERROR_HAVE_NO_MEMORY(r->environment);
8302         r->dll_name                     = talloc_strdup(mem_ctx, dll_name);
8303         W_ERROR_HAVE_NO_MEMORY(r->dll_name);
8304
8305         return WERR_OK;
8306 }
8307
8308 /****************************************************************************
8309  enumprintmonitors level 1.
8310 ****************************************************************************/
8311
8312 static WERROR enumprintmonitors_level_1(TALLOC_CTX *mem_ctx,
8313                                         union spoolss_MonitorInfo **info_p,
8314                                         uint32_t *count)
8315 {
8316         union spoolss_MonitorInfo *info;
8317         WERROR result = WERR_OK;
8318
8319         info = TALLOC_ARRAY(mem_ctx, union spoolss_MonitorInfo, 2);
8320         W_ERROR_HAVE_NO_MEMORY(info);
8321
8322         *count = 2;
8323
8324         result = fill_monitor_1(info, &info[0].info1,
8325                                 SPL_LOCAL_PORT);
8326         if (!W_ERROR_IS_OK(result)) {
8327                 goto out;
8328         }
8329
8330         result = fill_monitor_1(info, &info[1].info1,
8331                                 SPL_TCPIP_PORT);
8332         if (!W_ERROR_IS_OK(result)) {
8333                 goto out;
8334         }
8335
8336 out:
8337         if (!W_ERROR_IS_OK(result)) {
8338                 TALLOC_FREE(info);
8339                 *count = 0;
8340                 return result;
8341         }
8342
8343         *info_p = info;
8344
8345         return WERR_OK;
8346 }
8347
8348 /****************************************************************************
8349  enumprintmonitors level 2.
8350 ****************************************************************************/
8351
8352 static WERROR enumprintmonitors_level_2(TALLOC_CTX *mem_ctx,
8353                                         union spoolss_MonitorInfo **info_p,
8354                                         uint32_t *count)
8355 {
8356         union spoolss_MonitorInfo *info;
8357         WERROR result = WERR_OK;
8358
8359         info = TALLOC_ARRAY(mem_ctx, union spoolss_MonitorInfo, 2);
8360         W_ERROR_HAVE_NO_MEMORY(info);
8361
8362         *count = 2;
8363
8364         result = fill_monitor_2(info, &info[0].info2,
8365                                 SPL_LOCAL_PORT,
8366                                 "Windows NT X86", /* FIXME */
8367                                 "localmon.dll");
8368         if (!W_ERROR_IS_OK(result)) {
8369                 goto out;
8370         }
8371
8372         result = fill_monitor_2(info, &info[1].info2,
8373                                 SPL_TCPIP_PORT,
8374                                 "Windows NT X86", /* FIXME */
8375                                 "tcpmon.dll");
8376         if (!W_ERROR_IS_OK(result)) {
8377                 goto out;
8378         }
8379
8380 out:
8381         if (!W_ERROR_IS_OK(result)) {
8382                 TALLOC_FREE(info);
8383                 *count = 0;
8384                 return result;
8385         }
8386
8387         *info_p = info;
8388
8389         return WERR_OK;
8390 }
8391
8392 /****************************************************************
8393  _spoolss_EnumMonitors
8394 ****************************************************************/
8395
8396 WERROR _spoolss_EnumMonitors(struct pipes_struct *p,
8397                              struct spoolss_EnumMonitors *r)
8398 {
8399         WERROR result;
8400
8401         /* that's an [in out] buffer */
8402
8403         if (!r->in.buffer && (r->in.offered != 0)) {
8404                 return WERR_INVALID_PARAM;
8405         }
8406
8407         DEBUG(5,("_spoolss_EnumMonitors\n"));
8408
8409         /*
8410          * Enumerate the print monitors ...
8411          *
8412          * Just reply with "Local Port", to keep NT happy
8413          * and I can use my nice printer checker.
8414          */
8415
8416         *r->out.count = 0;
8417         *r->out.needed = 0;
8418         *r->out.info = NULL;
8419
8420         switch (r->in.level) {
8421         case 1:
8422                 result = enumprintmonitors_level_1(p->mem_ctx, r->out.info,
8423                                                    r->out.count);
8424                 break;
8425         case 2:
8426                 result = enumprintmonitors_level_2(p->mem_ctx, r->out.info,
8427                                                    r->out.count);
8428                 break;
8429         default:
8430                 return WERR_UNKNOWN_LEVEL;
8431         }
8432
8433         if (!W_ERROR_IS_OK(result)) {
8434                 return result;
8435         }
8436
8437         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8438                                                      spoolss_EnumMonitors,
8439                                                      *r->out.info, r->in.level,
8440                                                      *r->out.count);
8441         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8442         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8443
8444         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8445 }
8446
8447 /****************************************************************************
8448 ****************************************************************************/
8449
8450 static WERROR getjob_level_1(TALLOC_CTX *mem_ctx,
8451                              const print_queue_struct *queue,
8452                              int count, int snum,
8453                              struct spoolss_PrinterInfo2 *pinfo2,
8454                              uint32_t jobid,
8455                              struct spoolss_JobInfo1 *r)
8456 {
8457         int i = 0;
8458         bool found = false;
8459
8460         for (i=0; i<count; i++) {
8461                 if (queue[i].job == (int)jobid) {
8462                         found = true;
8463                         break;
8464                 }
8465         }
8466
8467         if (found == false) {
8468                 /* NT treats not found as bad param... yet another bad choice */
8469                 return WERR_INVALID_PARAM;
8470         }
8471
8472         return fill_job_info1(mem_ctx,
8473                               r,
8474                               &queue[i],
8475                               i,
8476                               snum,
8477                               pinfo2);
8478 }
8479
8480 /****************************************************************************
8481 ****************************************************************************/
8482
8483 static WERROR getjob_level_2(TALLOC_CTX *mem_ctx,
8484                              const print_queue_struct *queue,
8485                              int count, int snum,
8486                              struct spoolss_PrinterInfo2 *pinfo2,
8487                              uint32_t jobid,
8488                              struct spoolss_JobInfo2 *r)
8489 {
8490         int i = 0;
8491         bool found = false;
8492         struct spoolss_DeviceMode *devmode;
8493         WERROR result;
8494
8495         for (i=0; i<count; i++) {
8496                 if (queue[i].job == (int)jobid) {
8497                         found = true;
8498                         break;
8499                 }
8500         }
8501
8502         if (found == false) {
8503                 /* NT treats not found as bad param... yet another bad
8504                    choice */
8505                 return WERR_INVALID_PARAM;
8506         }
8507
8508         /*
8509          * if the print job does not have a DEVMODE associated with it,
8510          * just use the one for the printer. A NULL devicemode is not
8511          *  a failure condition
8512          */
8513
8514         devmode = print_job_devmode(lp_const_servicename(snum), jobid);
8515         if (!devmode) {
8516                 result = spoolss_create_default_devmode(mem_ctx,
8517                                                 pinfo2->printername,
8518                                                 &devmode);
8519                 if (!W_ERROR_IS_OK(result)) {
8520                         DEBUG(3, ("Can't proceed w/o a devmode!"));
8521                         return result;
8522                 }
8523         }
8524
8525         return fill_job_info2(mem_ctx,
8526                               r,
8527                               &queue[i],
8528                               i,
8529                               snum,
8530                               pinfo2,
8531                               devmode);
8532 }
8533
8534 /****************************************************************
8535  _spoolss_GetJob
8536 ****************************************************************/
8537
8538 WERROR _spoolss_GetJob(struct pipes_struct *p,
8539                        struct spoolss_GetJob *r)
8540 {
8541         WERROR result = WERR_OK;
8542         struct spoolss_PrinterInfo2 *pinfo2 = NULL;
8543         int snum;
8544         int count;
8545         print_queue_struct      *queue = NULL;
8546         print_status_struct prt_status;
8547
8548         /* that's an [in out] buffer */
8549
8550         if (!r->in.buffer && (r->in.offered != 0)) {
8551                 return WERR_INVALID_PARAM;
8552         }
8553
8554         DEBUG(5,("_spoolss_GetJob\n"));
8555
8556         *r->out.needed = 0;
8557
8558         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8559                 return WERR_BADFID;
8560         }
8561
8562         result = winreg_get_printer(p->mem_ctx, p->server_info, p->msg_ctx,
8563                                     NULL, lp_servicename(snum), &pinfo2);
8564         if (!W_ERROR_IS_OK(result)) {
8565                 return result;
8566         }
8567
8568         count = print_queue_status(snum, &queue, &prt_status);
8569
8570         DEBUGADD(4,("count:[%d], prt_status:[%d], [%s]\n",
8571                      count, prt_status.status, prt_status.message));
8572
8573         switch (r->in.level) {
8574         case 1:
8575                 result = getjob_level_1(p->mem_ctx,
8576                                         queue, count, snum, pinfo2,
8577                                         r->in.job_id, &r->out.info->info1);
8578                 break;
8579         case 2:
8580                 result = getjob_level_2(p->mem_ctx,
8581                                         queue, count, snum, pinfo2,
8582                                         r->in.job_id, &r->out.info->info2);
8583                 break;
8584         default:
8585                 result = WERR_UNKNOWN_LEVEL;
8586                 break;
8587         }
8588
8589         SAFE_FREE(queue);
8590         TALLOC_FREE(pinfo2);
8591
8592         if (!W_ERROR_IS_OK(result)) {
8593                 TALLOC_FREE(r->out.info);
8594                 return result;
8595         }
8596
8597         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_JobInfo, r->out.info,
8598                                                                                    r->in.level);
8599         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
8600
8601         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8602 }
8603
8604 /****************************************************************
8605  _spoolss_GetPrinterDataEx
8606 ****************************************************************/
8607
8608 WERROR _spoolss_GetPrinterDataEx(struct pipes_struct *p,
8609                                  struct spoolss_GetPrinterDataEx *r)
8610 {
8611
8612         Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
8613         const char *printer;
8614         int                     snum = 0;
8615         WERROR result = WERR_OK;
8616         DATA_BLOB blob;
8617         enum winreg_Type val_type;
8618         uint8_t *val_data;
8619         uint32_t val_size;
8620
8621
8622         DEBUG(4,("_spoolss_GetPrinterDataEx\n"));
8623
8624         DEBUG(10, ("_spoolss_GetPrinterDataEx: key => [%s], value => [%s]\n",
8625                 r->in.key_name, r->in.value_name));
8626
8627         /* in case of problem, return some default values */
8628
8629         *r->out.needed  = 0;
8630         *r->out.type    = REG_NONE;
8631
8632         if (!Printer) {
8633                 DEBUG(2,("_spoolss_GetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
8634                         OUR_HANDLE(r->in.handle)));
8635                 result = WERR_BADFID;
8636                 goto done;
8637         }
8638
8639         /* Is the handle to a printer or to the server? */
8640
8641         if (Printer->printer_type == SPLHND_SERVER) {
8642
8643                 union spoolss_PrinterData data;
8644
8645                 result = getprinterdata_printer_server(p->mem_ctx,
8646                                                        r->in.value_name,
8647                                                        r->out.type,
8648                                                        &data);
8649                 if (!W_ERROR_IS_OK(result)) {
8650                         return result;
8651                 }
8652
8653                 result = push_spoolss_PrinterData(p->mem_ctx, &blob,
8654                                                   *r->out.type, &data);
8655                 if (!W_ERROR_IS_OK(result)) {
8656                         return result;
8657                 }
8658
8659                 *r->out.needed = blob.length;
8660
8661                 if (r->in.offered >= *r->out.needed) {
8662                         memcpy(r->out.data, blob.data, blob.length);
8663                 }
8664
8665                 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
8666         }
8667
8668         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8669                 return WERR_BADFID;
8670         }
8671         printer = lp_const_servicename(snum);
8672
8673         /* check to see if the keyname is valid */
8674         if (!strlen(r->in.key_name)) {
8675                 return WERR_INVALID_PARAM;
8676         }
8677
8678         /* XP sends this and wants the ChangeID value from PRINTER_INFO_0 */
8679         if (strequal(r->in.key_name, SPOOL_PRINTERDATA_KEY) &&
8680             strequal(r->in.value_name, "ChangeId")) {
8681                 *r->out.type = REG_DWORD;
8682                 *r->out.needed = 4;
8683                 if (r->in.offered >= *r->out.needed) {
8684                         uint32_t changeid = 0;
8685
8686                         result = winreg_printer_get_changeid(p->mem_ctx,
8687                                                              p->server_info,
8688                                                              p->msg_ctx,
8689                                                              printer,
8690                                                              &changeid);
8691                         if (!W_ERROR_IS_OK(result)) {
8692                                 return result;
8693                         }
8694
8695                         SIVAL(r->out.data, 0, changeid);
8696                         result = WERR_OK;
8697                 }
8698                 goto done;
8699         }
8700
8701         result = winreg_get_printer_dataex(p->mem_ctx,
8702                                            p->server_info,
8703                                            p->msg_ctx,
8704                                            printer,
8705                                            r->in.key_name,
8706                                            r->in.value_name,
8707                                            &val_type,
8708                                            &val_data,
8709                                            &val_size);
8710         if (!W_ERROR_IS_OK(result)) {
8711                 return result;
8712         }
8713
8714         *r->out.needed = val_size;
8715         *r->out.type = val_type;
8716
8717         if (r->in.offered >= *r->out.needed) {
8718                 memcpy(r->out.data, val_data, val_size);
8719         }
8720
8721  done:
8722         *r->out.type    = SPOOLSS_BUFFER_OK(*r->out.type, REG_NONE);
8723         r->out.data     = SPOOLSS_BUFFER_OK(r->out.data, r->out.data);
8724
8725         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
8726 }
8727
8728 /****************************************************************
8729  _spoolss_SetPrinterDataEx
8730 ****************************************************************/
8731
8732 WERROR _spoolss_SetPrinterDataEx(struct pipes_struct *p,
8733                                  struct spoolss_SetPrinterDataEx *r)
8734 {
8735         struct spoolss_PrinterInfo2 *pinfo2 = NULL;
8736         int                     snum = 0;
8737         WERROR                  result = WERR_OK;
8738         Printer_entry           *Printer = find_printer_index_by_hnd(p, r->in.handle);
8739         char                    *oid_string;
8740
8741         DEBUG(4,("_spoolss_SetPrinterDataEx\n"));
8742
8743         /* From MSDN documentation of SetPrinterDataEx: pass request to
8744            SetPrinterData if key is "PrinterDriverData" */
8745
8746         if (!Printer) {
8747                 DEBUG(2,("_spoolss_SetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
8748                         OUR_HANDLE(r->in.handle)));
8749                 return WERR_BADFID;
8750         }
8751
8752         if (Printer->printer_type == SPLHND_SERVER) {
8753                 DEBUG(10,("_spoolss_SetPrinterDataEx: "
8754                         "Not implemented for server handles yet\n"));
8755                 return WERR_INVALID_PARAM;
8756         }
8757
8758         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8759                 return WERR_BADFID;
8760         }
8761
8762         /*
8763          * Access check : NT returns "access denied" if you make a
8764          * SetPrinterData call without the necessary privildge.
8765          * we were originally returning OK if nothing changed
8766          * which made Win2k issue **a lot** of SetPrinterData
8767          * when connecting to a printer  --jerry
8768          */
8769
8770         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
8771                 DEBUG(3, ("_spoolss_SetPrinterDataEx: "
8772                         "change denied by handle access permissions\n"));
8773                 return WERR_ACCESS_DENIED;
8774         }
8775
8776         result = winreg_get_printer(Printer, p->server_info, p->msg_ctx,
8777                                     Printer->servername,
8778                                     lp_servicename(snum),
8779                                     &pinfo2);
8780         if (!W_ERROR_IS_OK(result)) {
8781                 return result;
8782         }
8783
8784         /* check for OID in valuename */
8785
8786         oid_string = strchr(r->in.value_name, ',');
8787         if (oid_string) {
8788                 *oid_string = '\0';
8789                 oid_string++;
8790         }
8791
8792         /* save the registry data */
8793
8794         result = winreg_set_printer_dataex(p->mem_ctx,
8795                                            p->server_info,
8796                                            p->msg_ctx,
8797                                            pinfo2->sharename,
8798                                            r->in.key_name,
8799                                            r->in.value_name,
8800                                            r->in.type,
8801                                            r->in.data,
8802                                            r->in.offered);
8803
8804         if (W_ERROR_IS_OK(result)) {
8805                 /* save the OID if one was specified */
8806                 if (oid_string) {
8807                         char *str = talloc_asprintf(p->mem_ctx, "%s\\%s",
8808                                 r->in.key_name, SPOOL_OID_KEY);
8809                         if (!str) {
8810                                 result = WERR_NOMEM;
8811                                 goto done;
8812                         }
8813
8814                         /*
8815                          * I'm not checking the status here on purpose.  Don't know
8816                          * if this is right, but I'm returning the status from the
8817                          * previous set_printer_dataex() call.  I have no idea if
8818                          * this is right.    --jerry
8819                          */
8820                         winreg_set_printer_dataex(p->mem_ctx,
8821                                                   p->server_info,
8822                                                   p->msg_ctx,
8823                                                   pinfo2->sharename,
8824                                                   str,
8825                                                   r->in.value_name,
8826                                                   REG_SZ,
8827                                                   (uint8_t *) oid_string,
8828                                                   strlen(oid_string) + 1);
8829                 }
8830
8831                 result = winreg_printer_update_changeid(p->mem_ctx,
8832                                                         p->server_info,
8833                                                         p->msg_ctx,
8834                                                         lp_const_servicename(snum));
8835
8836         }
8837
8838 done:
8839         talloc_free(pinfo2);
8840         return result;
8841 }
8842
8843 /****************************************************************
8844  _spoolss_DeletePrinterDataEx
8845 ****************************************************************/
8846
8847 WERROR _spoolss_DeletePrinterDataEx(struct pipes_struct *p,
8848                                     struct spoolss_DeletePrinterDataEx *r)
8849 {
8850         const char *printer;
8851         int             snum=0;
8852         WERROR          status = WERR_OK;
8853         Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
8854
8855         DEBUG(5,("_spoolss_DeletePrinterDataEx\n"));
8856
8857         if (!Printer) {
8858                 DEBUG(2,("_spoolss_DeletePrinterDataEx: "
8859                         "Invalid handle (%s:%u:%u).\n",
8860                         OUR_HANDLE(r->in.handle)));
8861                 return WERR_BADFID;
8862         }
8863
8864         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
8865                 DEBUG(3, ("_spoolss_DeletePrinterDataEx: "
8866                         "printer properties change denied by handle\n"));
8867                 return WERR_ACCESS_DENIED;
8868         }
8869
8870         if (!r->in.value_name || !r->in.key_name) {
8871                 return WERR_NOMEM;
8872         }
8873
8874         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8875                 return WERR_BADFID;
8876         }
8877         printer = lp_const_servicename(snum);
8878
8879         status = winreg_delete_printer_dataex(p->mem_ctx,
8880                                               p->server_info,
8881                                               p->msg_ctx,
8882                                               printer,
8883                                               r->in.key_name,
8884                                               r->in.value_name);
8885         if (W_ERROR_IS_OK(status)) {
8886                 status = winreg_printer_update_changeid(p->mem_ctx,
8887                                                         p->server_info,
8888                                                         p->msg_ctx,
8889                                                         printer);
8890         }
8891
8892         return status;
8893 }
8894
8895 /****************************************************************
8896  _spoolss_EnumPrinterKey
8897 ****************************************************************/
8898
8899 WERROR _spoolss_EnumPrinterKey(struct pipes_struct *p,
8900                                struct spoolss_EnumPrinterKey *r)
8901 {
8902         uint32_t        num_keys;
8903         Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
8904         int             snum = 0;
8905         WERROR          result = WERR_BADFILE;
8906         const char **array = NULL;
8907         DATA_BLOB blob;
8908
8909         DEBUG(4,("_spoolss_EnumPrinterKey\n"));
8910
8911         if (!Printer) {
8912                 DEBUG(2,("_spoolss_EnumPrinterKey: Invalid handle (%s:%u:%u).\n",
8913                         OUR_HANDLE(r->in.handle)));
8914                 return WERR_BADFID;
8915         }
8916
8917         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8918                 return WERR_BADFID;
8919         }
8920
8921         result = winreg_enum_printer_key(p->mem_ctx,
8922                                          p->server_info,
8923                                          p->msg_ctx,
8924                                          lp_const_servicename(snum),
8925                                          r->in.key_name,
8926                                          &num_keys,
8927                                          &array);
8928         if (!W_ERROR_IS_OK(result)) {
8929                 goto done;
8930         }
8931
8932         if (!push_reg_multi_sz(p->mem_ctx, &blob, array)) {
8933                 result = WERR_NOMEM;
8934                 goto done;
8935         }
8936
8937         *r->out._ndr_size = r->in.offered / 2;
8938         *r->out.needed = blob.length;
8939
8940         if (r->in.offered < *r->out.needed) {
8941                 result = WERR_MORE_DATA;
8942         } else {
8943                 result = WERR_OK;
8944                 r->out.key_buffer->string_array = array;
8945         }
8946
8947  done:
8948         if (!W_ERROR_IS_OK(result)) {
8949                 TALLOC_FREE(array);
8950                 if (!W_ERROR_EQUAL(result, WERR_MORE_DATA)) {
8951                         *r->out.needed = 0;
8952                 }
8953         }
8954
8955         return result;
8956 }
8957
8958 /****************************************************************
8959  _spoolss_DeletePrinterKey
8960 ****************************************************************/
8961
8962 WERROR _spoolss_DeletePrinterKey(struct pipes_struct *p,
8963                                  struct spoolss_DeletePrinterKey *r)
8964 {
8965         Printer_entry           *Printer = find_printer_index_by_hnd(p, r->in.handle);
8966         int                     snum=0;
8967         WERROR                  status;
8968         const char *printer;
8969
8970         DEBUG(5,("_spoolss_DeletePrinterKey\n"));
8971
8972         if (!Printer) {
8973                 DEBUG(2,("_spoolss_DeletePrinterKey: Invalid handle (%s:%u:%u).\n",
8974                         OUR_HANDLE(r->in.handle)));
8975                 return WERR_BADFID;
8976         }
8977
8978         /* if keyname == NULL, return error */
8979         if ( !r->in.key_name )
8980                 return WERR_INVALID_PARAM;
8981
8982         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8983                 return WERR_BADFID;
8984         }
8985
8986         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
8987                 DEBUG(3, ("_spoolss_DeletePrinterKey: "
8988                         "printer properties change denied by handle\n"));
8989                 return WERR_ACCESS_DENIED;
8990         }
8991
8992         printer = lp_const_servicename(snum);
8993
8994         /* delete the key and all subkeys */
8995         status = winreg_delete_printer_key(p->mem_ctx,
8996                                            p->server_info,
8997                                            p->msg_ctx,
8998                                            printer,
8999                                            r->in.key_name);
9000         if (W_ERROR_IS_OK(status)) {
9001                 status = winreg_printer_update_changeid(p->mem_ctx,
9002                                                         p->server_info,
9003                                                         p->msg_ctx,
9004                                                         printer);
9005         }
9006
9007         return status;
9008 }
9009
9010 /****************************************************************
9011  _spoolss_EnumPrinterDataEx
9012 ****************************************************************/
9013
9014 WERROR _spoolss_EnumPrinterDataEx(struct pipes_struct *p,
9015                                   struct spoolss_EnumPrinterDataEx *r)
9016 {
9017         uint32_t        count = 0;
9018         struct spoolss_PrinterEnumValues *info = NULL;
9019         Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
9020         int             snum;
9021         WERROR          result;
9022
9023         DEBUG(4,("_spoolss_EnumPrinterDataEx\n"));
9024
9025         *r->out.count = 0;
9026         *r->out.needed = 0;
9027         *r->out.info = NULL;
9028
9029         if (!Printer) {
9030                 DEBUG(2,("_spoolss_EnumPrinterDataEx: Invalid handle (%s:%u:%u1<).\n",
9031                         OUR_HANDLE(r->in.handle)));
9032                 return WERR_BADFID;
9033         }
9034
9035         /*
9036          * first check for a keyname of NULL or "".  Win2k seems to send
9037          * this a lot and we should send back WERR_INVALID_PARAM
9038          * no need to spend time looking up the printer in this case.
9039          * --jerry
9040          */
9041
9042         if (!strlen(r->in.key_name)) {
9043                 result = WERR_INVALID_PARAM;
9044                 goto done;
9045         }
9046
9047         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9048                 return WERR_BADFID;
9049         }
9050
9051         /* now look for a match on the key name */
9052         result = winreg_enum_printer_dataex(p->mem_ctx,
9053                                             p->server_info,
9054                                             p->msg_ctx,
9055                                             lp_const_servicename(snum),
9056                                             r->in.key_name,
9057                                             &count,
9058                                             &info);
9059         if (!W_ERROR_IS_OK(result)) {
9060                 goto done;
9061         }
9062
9063 #if 0 /* FIXME - gd */
9064         /* housekeeping information in the reply */
9065
9066         /* Fix from Martin Zielinski <mz@seh.de> - ensure
9067          * the hand marshalled container size is a multiple
9068          * of 4 bytes for RPC alignment.
9069          */
9070
9071         if (needed % 4) {
9072                 needed += 4-(needed % 4);
9073         }
9074 #endif
9075         *r->out.count   = count;
9076         *r->out.info    = info;
9077
9078  done:
9079         if (!W_ERROR_IS_OK(result)) {
9080                 return result;
9081         }
9082
9083         *r->out.needed  = SPOOLSS_BUFFER_ARRAY(p->mem_ctx,
9084                                                spoolss_EnumPrinterDataEx,
9085                                                *r->out.info,
9086                                                *r->out.count);
9087         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
9088         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, *r->out.count);
9089
9090         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
9091 }
9092
9093 /****************************************************************************
9094 ****************************************************************************/
9095
9096 static WERROR getprintprocessordirectory_level_1(TALLOC_CTX *mem_ctx,
9097                                                  const char *servername,
9098                                                  const char *environment,
9099                                                  struct spoolss_PrintProcessorDirectoryInfo1 *r)
9100 {
9101         WERROR werr;
9102         char *path = NULL;
9103
9104         werr = compose_spoolss_server_path(mem_ctx,
9105                                            servername,
9106                                            environment,
9107                                            SPOOLSS_PRTPROCS_PATH,
9108                                            &path);
9109         if (!W_ERROR_IS_OK(werr)) {
9110                 return werr;
9111         }
9112
9113         DEBUG(4,("print processor directory: [%s]\n", path));
9114
9115         r->directory_name = path;
9116
9117         return WERR_OK;
9118 }
9119
9120 /****************************************************************
9121  _spoolss_GetPrintProcessorDirectory
9122 ****************************************************************/
9123
9124 WERROR _spoolss_GetPrintProcessorDirectory(struct pipes_struct *p,
9125                                            struct spoolss_GetPrintProcessorDirectory *r)
9126 {
9127         WERROR result;
9128
9129         /* that's an [in out] buffer */
9130
9131         if (!r->in.buffer && (r->in.offered != 0)) {
9132                 return WERR_INVALID_PARAM;
9133         }
9134
9135         DEBUG(5,("_spoolss_GetPrintProcessorDirectory: level %d\n",
9136                 r->in.level));
9137
9138         *r->out.needed = 0;
9139
9140         /* r->in.level is ignored */
9141
9142         /* We always should reply with a local print processor directory so that
9143          * users are not forced to have a [prnproc$] share on the Samba spoolss
9144          * server - Guenther */
9145
9146         result = getprintprocessordirectory_level_1(p->mem_ctx,
9147                                                     NULL, /* r->in.server */
9148                                                     r->in.environment,
9149                                                     &r->out.info->info1);
9150         if (!W_ERROR_IS_OK(result)) {
9151                 TALLOC_FREE(r->out.info);
9152                 return result;
9153         }
9154
9155         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_PrintProcessorDirectoryInfo,
9156                                                                                    r->out.info, r->in.level);
9157         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
9158
9159         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
9160 }
9161
9162 /*******************************************************************
9163  ********************************************************************/
9164
9165 static bool push_monitorui_buf(TALLOC_CTX *mem_ctx, DATA_BLOB *buf,
9166                                const char *dllname)
9167 {
9168         enum ndr_err_code ndr_err;
9169         struct spoolss_MonitorUi ui;
9170
9171         ui.dll_name = dllname;
9172
9173         ndr_err = ndr_push_struct_blob(buf, mem_ctx, &ui,
9174                        (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorUi);
9175         if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9176                 NDR_PRINT_DEBUG(spoolss_MonitorUi, &ui);
9177         }
9178         return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9179 }
9180
9181 /*******************************************************************
9182  Streams the monitor UI DLL name in UNICODE
9183 *******************************************************************/
9184
9185 static WERROR xcvtcp_monitorui(TALLOC_CTX *mem_ctx,
9186                                NT_USER_TOKEN *token, DATA_BLOB *in,
9187                                DATA_BLOB *out, uint32_t *needed)
9188 {
9189         const char *dllname = "tcpmonui.dll";
9190
9191         *needed = (strlen(dllname)+1) * 2;
9192
9193         if (out->length < *needed) {
9194                 return WERR_INSUFFICIENT_BUFFER;
9195         }
9196
9197         if (!push_monitorui_buf(mem_ctx, out, dllname)) {
9198                 return WERR_NOMEM;
9199         }
9200
9201         return WERR_OK;
9202 }
9203
9204 /*******************************************************************
9205  ********************************************************************/
9206
9207 static bool pull_port_data_1(TALLOC_CTX *mem_ctx,
9208                              struct spoolss_PortData1 *port1,
9209                              const DATA_BLOB *buf)
9210 {
9211         enum ndr_err_code ndr_err;
9212         ndr_err = ndr_pull_struct_blob(buf, mem_ctx, port1,
9213                        (ndr_pull_flags_fn_t)ndr_pull_spoolss_PortData1);
9214         if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9215                 NDR_PRINT_DEBUG(spoolss_PortData1, port1);
9216         }
9217         return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9218 }
9219
9220 /*******************************************************************
9221  ********************************************************************/
9222
9223 static bool pull_port_data_2(TALLOC_CTX *mem_ctx,
9224                              struct spoolss_PortData2 *port2,
9225                              const DATA_BLOB *buf)
9226 {
9227         enum ndr_err_code ndr_err;
9228         ndr_err = ndr_pull_struct_blob(buf, mem_ctx, port2,
9229                        (ndr_pull_flags_fn_t)ndr_pull_spoolss_PortData2);
9230         if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9231                 NDR_PRINT_DEBUG(spoolss_PortData2, port2);
9232         }
9233         return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9234 }
9235
9236 /*******************************************************************
9237  Create a new TCP/IP port
9238 *******************************************************************/
9239
9240 static WERROR xcvtcp_addport(TALLOC_CTX *mem_ctx,
9241                              NT_USER_TOKEN *token, DATA_BLOB *in,
9242                              DATA_BLOB *out, uint32_t *needed)
9243 {
9244         struct spoolss_PortData1 port1;
9245         struct spoolss_PortData2 port2;
9246         char *device_uri = NULL;
9247         uint32_t version;
9248
9249         const char *portname;
9250         const char *hostaddress;
9251         const char *queue;
9252         uint32_t port_number;
9253         uint32_t protocol;
9254
9255         /* peek for spoolss_PortData version */
9256
9257         if (!in || (in->length < (128 + 4))) {
9258                 return WERR_GENERAL_FAILURE;
9259         }
9260
9261         version = IVAL(in->data, 128);
9262
9263         switch (version) {
9264                 case 1:
9265                         ZERO_STRUCT(port1);
9266
9267                         if (!pull_port_data_1(mem_ctx, &port1, in)) {
9268                                 return WERR_NOMEM;
9269                         }
9270
9271                         portname        = port1.portname;
9272                         hostaddress     = port1.hostaddress;
9273                         queue           = port1.queue;
9274                         protocol        = port1.protocol;
9275                         port_number     = port1.port_number;
9276
9277                         break;
9278                 case 2:
9279                         ZERO_STRUCT(port2);
9280
9281                         if (!pull_port_data_2(mem_ctx, &port2, in)) {
9282                                 return WERR_NOMEM;
9283                         }
9284
9285                         portname        = port2.portname;
9286                         hostaddress     = port2.hostaddress;
9287                         queue           = port2.queue;
9288                         protocol        = port2.protocol;
9289                         port_number     = port2.port_number;
9290
9291                         break;
9292                 default:
9293                         DEBUG(1,("xcvtcp_addport: "
9294                                 "unknown version of port_data: %d\n", version));
9295                         return WERR_UNKNOWN_PORT;
9296         }
9297
9298         /* create the device URI and call the add_port_hook() */
9299
9300         switch (protocol) {
9301         case PROTOCOL_RAWTCP_TYPE:
9302                 device_uri = talloc_asprintf(mem_ctx,
9303                                 "socket://%s:%d/", hostaddress,
9304                                 port_number);
9305                 break;
9306
9307         case PROTOCOL_LPR_TYPE:
9308                 device_uri = talloc_asprintf(mem_ctx,
9309                         "lpr://%s/%s", hostaddress, queue );
9310                 break;
9311
9312         default:
9313                 return WERR_UNKNOWN_PORT;
9314         }
9315
9316         if (!device_uri) {
9317                 return WERR_NOMEM;
9318         }
9319
9320         return add_port_hook(mem_ctx, token, portname, device_uri);
9321 }
9322
9323 /*******************************************************************
9324 *******************************************************************/
9325
9326 struct xcv_api_table xcvtcp_cmds[] = {
9327         { "MonitorUI",  xcvtcp_monitorui },
9328         { "AddPort",    xcvtcp_addport},
9329         { NULL,         NULL }
9330 };
9331
9332 static WERROR process_xcvtcp_command(TALLOC_CTX *mem_ctx,
9333                                      NT_USER_TOKEN *token, const char *command,
9334                                      DATA_BLOB *inbuf,
9335                                      DATA_BLOB *outbuf,
9336                                      uint32_t *needed )
9337 {
9338         int i;
9339
9340         DEBUG(10,("process_xcvtcp_command: Received command \"%s\"\n", command));
9341
9342         for ( i=0; xcvtcp_cmds[i].name; i++ ) {
9343                 if ( strcmp( command, xcvtcp_cmds[i].name ) == 0 )
9344                         return xcvtcp_cmds[i].fn(mem_ctx, token, inbuf, outbuf, needed);
9345         }
9346
9347         return WERR_BADFUNC;
9348 }
9349
9350 /*******************************************************************
9351 *******************************************************************/
9352 #if 0   /* don't support management using the "Local Port" monitor */
9353
9354 static WERROR xcvlocal_monitorui(TALLOC_CTX *mem_ctx,
9355                                  NT_USER_TOKEN *token, DATA_BLOB *in,
9356                                  DATA_BLOB *out, uint32_t *needed)
9357 {
9358         const char *dllname = "localui.dll";
9359
9360         *needed = (strlen(dllname)+1) * 2;
9361
9362         if (out->length < *needed) {
9363                 return WERR_INSUFFICIENT_BUFFER;
9364         }
9365
9366         if (!push_monitorui_buf(mem_ctx, out, dllname)) {
9367                 return WERR_NOMEM;
9368         }
9369
9370         return WERR_OK;
9371 }
9372
9373 /*******************************************************************
9374 *******************************************************************/
9375
9376 struct xcv_api_table xcvlocal_cmds[] = {
9377         { "MonitorUI",  xcvlocal_monitorui },
9378         { NULL,         NULL }
9379 };
9380 #else
9381 struct xcv_api_table xcvlocal_cmds[] = {
9382         { NULL,         NULL }
9383 };
9384 #endif
9385
9386
9387
9388 /*******************************************************************
9389 *******************************************************************/
9390
9391 static WERROR process_xcvlocal_command(TALLOC_CTX *mem_ctx,
9392                                        NT_USER_TOKEN *token, const char *command,
9393                                        DATA_BLOB *inbuf, DATA_BLOB *outbuf,
9394                                        uint32_t *needed)
9395 {
9396         int i;
9397
9398         DEBUG(10,("process_xcvlocal_command: Received command \"%s\"\n", command));
9399
9400         for ( i=0; xcvlocal_cmds[i].name; i++ ) {
9401                 if ( strcmp( command, xcvlocal_cmds[i].name ) == 0 )
9402                         return xcvlocal_cmds[i].fn(mem_ctx, token, inbuf, outbuf, needed);
9403         }
9404         return WERR_BADFUNC;
9405 }
9406
9407 /****************************************************************
9408  _spoolss_XcvData
9409 ****************************************************************/
9410
9411 WERROR _spoolss_XcvData(struct pipes_struct *p,
9412                         struct spoolss_XcvData *r)
9413 {
9414         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9415         DATA_BLOB out_data = data_blob_null;
9416         WERROR werror;
9417
9418         if (!Printer) {
9419                 DEBUG(2,("_spoolss_XcvData: Invalid handle (%s:%u:%u).\n",
9420                         OUR_HANDLE(r->in.handle)));
9421                 return WERR_BADFID;
9422         }
9423
9424         /* Has to be a handle to the TCP/IP port monitor */
9425
9426         if ( !(Printer->printer_type & (SPLHND_PORTMON_LOCAL|SPLHND_PORTMON_TCP)) ) {
9427                 DEBUG(2,("_spoolss_XcvData: Call only valid for Port Monitors\n"));
9428                 return WERR_BADFID;
9429         }
9430
9431         /* requires administrative access to the server */
9432
9433         if ( !(Printer->access_granted & SERVER_ACCESS_ADMINISTER) ) {
9434                 DEBUG(2,("_spoolss_XcvData: denied by handle permissions.\n"));
9435                 return WERR_ACCESS_DENIED;
9436         }
9437
9438         /* Allocate the outgoing buffer */
9439
9440         if (r->in.out_data_size) {
9441                 out_data = data_blob_talloc_zero(p->mem_ctx, r->in.out_data_size);
9442                 if (out_data.data == NULL) {
9443                         return WERR_NOMEM;
9444                 }
9445         }
9446
9447         switch ( Printer->printer_type ) {
9448         case SPLHND_PORTMON_TCP:
9449                 werror = process_xcvtcp_command(p->mem_ctx,
9450                                                 p->server_info->ptok,
9451                                                 r->in.function_name,
9452                                                 &r->in.in_data, &out_data,
9453                                                 r->out.needed);
9454                 break;
9455         case SPLHND_PORTMON_LOCAL:
9456                 werror = process_xcvlocal_command(p->mem_ctx,
9457                                                   p->server_info->ptok,
9458                                                   r->in.function_name,
9459                                                   &r->in.in_data, &out_data,
9460                                                   r->out.needed);
9461                 break;
9462         default:
9463                 werror = WERR_INVALID_PRINT_MONITOR;
9464         }
9465
9466         if (!W_ERROR_IS_OK(werror)) {
9467                 return werror;
9468         }
9469
9470         *r->out.status_code = 0;
9471
9472         if (r->out.out_data && out_data.data && r->in.out_data_size && out_data.length) {
9473                 memcpy(r->out.out_data, out_data.data,
9474                         MIN(r->in.out_data_size, out_data.length));
9475         }
9476
9477         return WERR_OK;
9478 }
9479
9480 /****************************************************************
9481  _spoolss_AddPrintProcessor
9482 ****************************************************************/
9483
9484 WERROR _spoolss_AddPrintProcessor(struct pipes_struct *p,
9485                                   struct spoolss_AddPrintProcessor *r)
9486 {
9487         /* for now, just indicate success and ignore the add.  We'll
9488            automatically set the winprint processor for printer
9489            entries later.  Used to debug the LexMark Optra S 1855 PCL
9490            driver --jerry */
9491
9492         return WERR_OK;
9493 }
9494
9495 /****************************************************************
9496  _spoolss_AddPort
9497 ****************************************************************/
9498
9499 WERROR _spoolss_AddPort(struct pipes_struct *p,
9500                         struct spoolss_AddPort *r)
9501 {
9502         /* do what w2k3 does */
9503
9504         return WERR_NOT_SUPPORTED;
9505 }
9506
9507 /****************************************************************
9508  _spoolss_GetPrinterDriver
9509 ****************************************************************/
9510
9511 WERROR _spoolss_GetPrinterDriver(struct pipes_struct *p,
9512                                  struct spoolss_GetPrinterDriver *r)
9513 {
9514         p->rng_fault_state = true;
9515         return WERR_NOT_SUPPORTED;
9516 }
9517
9518 /****************************************************************
9519  _spoolss_ReadPrinter
9520 ****************************************************************/
9521
9522 WERROR _spoolss_ReadPrinter(struct pipes_struct *p,
9523                             struct spoolss_ReadPrinter *r)
9524 {
9525         p->rng_fault_state = true;
9526         return WERR_NOT_SUPPORTED;
9527 }
9528
9529 /****************************************************************
9530  _spoolss_WaitForPrinterChange
9531 ****************************************************************/
9532
9533 WERROR _spoolss_WaitForPrinterChange(struct pipes_struct *p,
9534                                      struct spoolss_WaitForPrinterChange *r)
9535 {
9536         p->rng_fault_state = true;
9537         return WERR_NOT_SUPPORTED;
9538 }
9539
9540 /****************************************************************
9541  _spoolss_ConfigurePort
9542 ****************************************************************/
9543
9544 WERROR _spoolss_ConfigurePort(struct pipes_struct *p,
9545                               struct spoolss_ConfigurePort *r)
9546 {
9547         p->rng_fault_state = true;
9548         return WERR_NOT_SUPPORTED;
9549 }
9550
9551 /****************************************************************
9552  _spoolss_DeletePort
9553 ****************************************************************/
9554
9555 WERROR _spoolss_DeletePort(struct pipes_struct *p,
9556                            struct spoolss_DeletePort *r)
9557 {
9558         p->rng_fault_state = true;
9559         return WERR_NOT_SUPPORTED;
9560 }
9561
9562 /****************************************************************
9563  _spoolss_CreatePrinterIC
9564 ****************************************************************/
9565
9566 WERROR _spoolss_CreatePrinterIC(struct pipes_struct *p,
9567                                 struct spoolss_CreatePrinterIC *r)
9568 {
9569         p->rng_fault_state = true;
9570         return WERR_NOT_SUPPORTED;
9571 }
9572
9573 /****************************************************************
9574  _spoolss_PlayGDIScriptOnPrinterIC
9575 ****************************************************************/
9576
9577 WERROR _spoolss_PlayGDIScriptOnPrinterIC(struct pipes_struct *p,
9578                                          struct spoolss_PlayGDIScriptOnPrinterIC *r)
9579 {
9580         p->rng_fault_state = true;
9581         return WERR_NOT_SUPPORTED;
9582 }
9583
9584 /****************************************************************
9585  _spoolss_DeletePrinterIC
9586 ****************************************************************/
9587
9588 WERROR _spoolss_DeletePrinterIC(struct pipes_struct *p,
9589                                 struct spoolss_DeletePrinterIC *r)
9590 {
9591         p->rng_fault_state = true;
9592         return WERR_NOT_SUPPORTED;
9593 }
9594
9595 /****************************************************************
9596  _spoolss_AddPrinterConnection
9597 ****************************************************************/
9598
9599 WERROR _spoolss_AddPrinterConnection(struct pipes_struct *p,
9600                                      struct spoolss_AddPrinterConnection *r)
9601 {
9602         p->rng_fault_state = true;
9603         return WERR_NOT_SUPPORTED;
9604 }
9605
9606 /****************************************************************
9607  _spoolss_DeletePrinterConnection
9608 ****************************************************************/
9609
9610 WERROR _spoolss_DeletePrinterConnection(struct pipes_struct *p,
9611                                         struct spoolss_DeletePrinterConnection *r)
9612 {
9613         p->rng_fault_state = true;
9614         return WERR_NOT_SUPPORTED;
9615 }
9616
9617 /****************************************************************
9618  _spoolss_PrinterMessageBox
9619 ****************************************************************/
9620
9621 WERROR _spoolss_PrinterMessageBox(struct pipes_struct *p,
9622                                   struct spoolss_PrinterMessageBox *r)
9623 {
9624         p->rng_fault_state = true;
9625         return WERR_NOT_SUPPORTED;
9626 }
9627
9628 /****************************************************************
9629  _spoolss_AddMonitor
9630 ****************************************************************/
9631
9632 WERROR _spoolss_AddMonitor(struct pipes_struct *p,
9633                            struct spoolss_AddMonitor *r)
9634 {
9635         p->rng_fault_state = true;
9636         return WERR_NOT_SUPPORTED;
9637 }
9638
9639 /****************************************************************
9640  _spoolss_DeleteMonitor
9641 ****************************************************************/
9642
9643 WERROR _spoolss_DeleteMonitor(struct pipes_struct *p,
9644                               struct spoolss_DeleteMonitor *r)
9645 {
9646         p->rng_fault_state = true;
9647         return WERR_NOT_SUPPORTED;
9648 }
9649
9650 /****************************************************************
9651  _spoolss_DeletePrintProcessor
9652 ****************************************************************/
9653
9654 WERROR _spoolss_DeletePrintProcessor(struct pipes_struct *p,
9655                                      struct spoolss_DeletePrintProcessor *r)
9656 {
9657         p->rng_fault_state = true;
9658         return WERR_NOT_SUPPORTED;
9659 }
9660
9661 /****************************************************************
9662  _spoolss_AddPrintProvidor
9663 ****************************************************************/
9664
9665 WERROR _spoolss_AddPrintProvidor(struct pipes_struct *p,
9666                                  struct spoolss_AddPrintProvidor *r)
9667 {
9668         p->rng_fault_state = true;
9669         return WERR_NOT_SUPPORTED;
9670 }
9671
9672 /****************************************************************
9673  _spoolss_DeletePrintProvidor
9674 ****************************************************************/
9675
9676 WERROR _spoolss_DeletePrintProvidor(struct pipes_struct *p,
9677                                     struct spoolss_DeletePrintProvidor *r)
9678 {
9679         p->rng_fault_state = true;
9680         return WERR_NOT_SUPPORTED;
9681 }
9682
9683 /****************************************************************
9684  _spoolss_FindFirstPrinterChangeNotification
9685 ****************************************************************/
9686
9687 WERROR _spoolss_FindFirstPrinterChangeNotification(struct pipes_struct *p,
9688                                                    struct spoolss_FindFirstPrinterChangeNotification *r)
9689 {
9690         p->rng_fault_state = true;
9691         return WERR_NOT_SUPPORTED;
9692 }
9693
9694 /****************************************************************
9695  _spoolss_FindNextPrinterChangeNotification
9696 ****************************************************************/
9697
9698 WERROR _spoolss_FindNextPrinterChangeNotification(struct pipes_struct *p,
9699                                                   struct spoolss_FindNextPrinterChangeNotification *r)
9700 {
9701         p->rng_fault_state = true;
9702         return WERR_NOT_SUPPORTED;
9703 }
9704
9705 /****************************************************************
9706  _spoolss_RouterFindFirstPrinterChangeNotificationOld
9707 ****************************************************************/
9708
9709 WERROR _spoolss_RouterFindFirstPrinterChangeNotificationOld(struct pipes_struct *p,
9710                                                             struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
9711 {
9712         p->rng_fault_state = true;
9713         return WERR_NOT_SUPPORTED;
9714 }
9715
9716 /****************************************************************
9717  _spoolss_ReplyOpenPrinter
9718 ****************************************************************/
9719
9720 WERROR _spoolss_ReplyOpenPrinter(struct pipes_struct *p,
9721                                  struct spoolss_ReplyOpenPrinter *r)
9722 {
9723         p->rng_fault_state = true;
9724         return WERR_NOT_SUPPORTED;
9725 }
9726
9727 /****************************************************************
9728  _spoolss_RouterReplyPrinter
9729 ****************************************************************/
9730
9731 WERROR _spoolss_RouterReplyPrinter(struct pipes_struct *p,
9732                                    struct spoolss_RouterReplyPrinter *r)
9733 {
9734         p->rng_fault_state = true;
9735         return WERR_NOT_SUPPORTED;
9736 }
9737
9738 /****************************************************************
9739  _spoolss_ReplyClosePrinter
9740 ****************************************************************/
9741
9742 WERROR _spoolss_ReplyClosePrinter(struct pipes_struct *p,
9743                                   struct spoolss_ReplyClosePrinter *r)
9744 {
9745         p->rng_fault_state = true;
9746         return WERR_NOT_SUPPORTED;
9747 }
9748
9749 /****************************************************************
9750  _spoolss_AddPortEx
9751 ****************************************************************/
9752
9753 WERROR _spoolss_AddPortEx(struct pipes_struct *p,
9754                           struct spoolss_AddPortEx *r)
9755 {
9756         p->rng_fault_state = true;
9757         return WERR_NOT_SUPPORTED;
9758 }
9759
9760 /****************************************************************
9761  _spoolss_RouterFindFirstPrinterChangeNotification
9762 ****************************************************************/
9763
9764 WERROR _spoolss_RouterFindFirstPrinterChangeNotification(struct pipes_struct *p,
9765                                                          struct spoolss_RouterFindFirstPrinterChangeNotification *r)
9766 {
9767         p->rng_fault_state = true;
9768         return WERR_NOT_SUPPORTED;
9769 }
9770
9771 /****************************************************************
9772  _spoolss_SpoolerInit
9773 ****************************************************************/
9774
9775 WERROR _spoolss_SpoolerInit(struct pipes_struct *p,
9776                             struct spoolss_SpoolerInit *r)
9777 {
9778         p->rng_fault_state = true;
9779         return WERR_NOT_SUPPORTED;
9780 }
9781
9782 /****************************************************************
9783  _spoolss_ResetPrinterEx
9784 ****************************************************************/
9785
9786 WERROR _spoolss_ResetPrinterEx(struct pipes_struct *p,
9787                                struct spoolss_ResetPrinterEx *r)
9788 {
9789         p->rng_fault_state = true;
9790         return WERR_NOT_SUPPORTED;
9791 }
9792
9793 /****************************************************************
9794  _spoolss_RouterReplyPrinterEx
9795 ****************************************************************/
9796
9797 WERROR _spoolss_RouterReplyPrinterEx(struct pipes_struct *p,
9798                                      struct spoolss_RouterReplyPrinterEx *r)
9799 {
9800         p->rng_fault_state = true;
9801         return WERR_NOT_SUPPORTED;
9802 }
9803
9804 /****************************************************************
9805  _spoolss_44
9806 ****************************************************************/
9807
9808 WERROR _spoolss_44(struct pipes_struct *p,
9809                    struct spoolss_44 *r)
9810 {
9811         p->rng_fault_state = true;
9812         return WERR_NOT_SUPPORTED;
9813 }
9814
9815 /****************************************************************
9816  _spoolss_47
9817 ****************************************************************/
9818
9819 WERROR _spoolss_47(struct pipes_struct *p,
9820                    struct spoolss_47 *r)
9821 {
9822         p->rng_fault_state = true;
9823         return WERR_NOT_SUPPORTED;
9824 }
9825
9826 /****************************************************************
9827  _spoolss_4a
9828 ****************************************************************/
9829
9830 WERROR _spoolss_4a(struct pipes_struct *p,
9831                    struct spoolss_4a *r)
9832 {
9833         p->rng_fault_state = true;
9834         return WERR_NOT_SUPPORTED;
9835 }
9836
9837 /****************************************************************
9838  _spoolss_4b
9839 ****************************************************************/
9840
9841 WERROR _spoolss_4b(struct pipes_struct *p,
9842                    struct spoolss_4b *r)
9843 {
9844         p->rng_fault_state = true;
9845         return WERR_NOT_SUPPORTED;
9846 }
9847
9848 /****************************************************************
9849  _spoolss_4c
9850 ****************************************************************/
9851
9852 WERROR _spoolss_4c(struct pipes_struct *p,
9853                    struct spoolss_4c *r)
9854 {
9855         p->rng_fault_state = true;
9856         return WERR_NOT_SUPPORTED;
9857 }
9858
9859 /****************************************************************
9860  _spoolss_53
9861 ****************************************************************/
9862
9863 WERROR _spoolss_53(struct pipes_struct *p,
9864                    struct spoolss_53 *r)
9865 {
9866         p->rng_fault_state = true;
9867         return WERR_NOT_SUPPORTED;
9868 }
9869
9870 /****************************************************************
9871  _spoolss_55
9872 ****************************************************************/
9873
9874 WERROR _spoolss_55(struct pipes_struct *p,
9875                    struct spoolss_55 *r)
9876 {
9877         p->rng_fault_state = true;
9878         return WERR_NOT_SUPPORTED;
9879 }
9880
9881 /****************************************************************
9882  _spoolss_56
9883 ****************************************************************/
9884
9885 WERROR _spoolss_56(struct pipes_struct *p,
9886                    struct spoolss_56 *r)
9887 {
9888         p->rng_fault_state = true;
9889         return WERR_NOT_SUPPORTED;
9890 }
9891
9892 /****************************************************************
9893  _spoolss_57
9894 ****************************************************************/
9895
9896 WERROR _spoolss_57(struct pipes_struct *p,
9897                    struct spoolss_57 *r)
9898 {
9899         p->rng_fault_state = true;
9900         return WERR_NOT_SUPPORTED;
9901 }
9902
9903 /****************************************************************
9904  _spoolss_5a
9905 ****************************************************************/
9906
9907 WERROR _spoolss_5a(struct pipes_struct *p,
9908                    struct spoolss_5a *r)
9909 {
9910         p->rng_fault_state = true;
9911         return WERR_NOT_SUPPORTED;
9912 }
9913
9914 /****************************************************************
9915  _spoolss_5b
9916 ****************************************************************/
9917
9918 WERROR _spoolss_5b(struct pipes_struct *p,
9919                    struct spoolss_5b *r)
9920 {
9921         p->rng_fault_state = true;
9922         return WERR_NOT_SUPPORTED;
9923 }
9924
9925 /****************************************************************
9926  _spoolss_5c
9927 ****************************************************************/
9928
9929 WERROR _spoolss_5c(struct pipes_struct *p,
9930                    struct spoolss_5c *r)
9931 {
9932         p->rng_fault_state = true;
9933         return WERR_NOT_SUPPORTED;
9934 }
9935
9936 /****************************************************************
9937  _spoolss_5d
9938 ****************************************************************/
9939
9940 WERROR _spoolss_5d(struct pipes_struct *p,
9941                    struct spoolss_5d *r)
9942 {
9943         p->rng_fault_state = true;
9944         return WERR_NOT_SUPPORTED;
9945 }
9946
9947 /****************************************************************
9948  _spoolss_5e
9949 ****************************************************************/
9950
9951 WERROR _spoolss_5e(struct pipes_struct *p,
9952                    struct spoolss_5e *r)
9953 {
9954         p->rng_fault_state = true;
9955         return WERR_NOT_SUPPORTED;
9956 }
9957
9958 /****************************************************************
9959  _spoolss_5f
9960 ****************************************************************/
9961
9962 WERROR _spoolss_5f(struct pipes_struct *p,
9963                    struct spoolss_5f *r)
9964 {
9965         p->rng_fault_state = true;
9966         return WERR_NOT_SUPPORTED;
9967 }
9968
9969 /****************************************************************
9970  _spoolss_60
9971 ****************************************************************/
9972
9973 WERROR _spoolss_60(struct pipes_struct *p,
9974                    struct spoolss_60 *r)
9975 {
9976         p->rng_fault_state = true;
9977         return WERR_NOT_SUPPORTED;
9978 }
9979
9980 /****************************************************************
9981  _spoolss_61
9982 ****************************************************************/
9983
9984 WERROR _spoolss_61(struct pipes_struct *p,
9985                    struct spoolss_61 *r)
9986 {
9987         p->rng_fault_state = true;
9988         return WERR_NOT_SUPPORTED;
9989 }
9990
9991 /****************************************************************
9992  _spoolss_62
9993 ****************************************************************/
9994
9995 WERROR _spoolss_62(struct pipes_struct *p,
9996                    struct spoolss_62 *r)
9997 {
9998         p->rng_fault_state = true;
9999         return WERR_NOT_SUPPORTED;
10000 }
10001
10002 /****************************************************************
10003  _spoolss_63
10004 ****************************************************************/
10005
10006 WERROR _spoolss_63(struct pipes_struct *p,
10007                    struct spoolss_63 *r)
10008 {
10009         p->rng_fault_state = true;
10010         return WERR_NOT_SUPPORTED;
10011 }
10012
10013 /****************************************************************
10014  _spoolss_64
10015 ****************************************************************/
10016
10017 WERROR _spoolss_64(struct pipes_struct *p,
10018                    struct spoolss_64 *r)
10019 {
10020         p->rng_fault_state = true;
10021         return WERR_NOT_SUPPORTED;
10022 }
10023
10024 /****************************************************************
10025  _spoolss_65
10026 ****************************************************************/
10027
10028 WERROR _spoolss_65(struct pipes_struct *p,
10029                    struct spoolss_65 *r)
10030 {
10031         p->rng_fault_state = true;
10032         return WERR_NOT_SUPPORTED;
10033 }
10034
10035 /****************************************************************
10036  _spoolss_GetCorePrinterDrivers
10037 ****************************************************************/
10038
10039 WERROR _spoolss_GetCorePrinterDrivers(struct pipes_struct *p,
10040                                       struct spoolss_GetCorePrinterDrivers *r)
10041 {
10042         p->rng_fault_state = true;
10043         return WERR_NOT_SUPPORTED;
10044 }
10045
10046 /****************************************************************
10047  _spoolss_67
10048 ****************************************************************/
10049
10050 WERROR _spoolss_67(struct pipes_struct *p,
10051                    struct spoolss_67 *r)
10052 {
10053         p->rng_fault_state = true;
10054         return WERR_NOT_SUPPORTED;
10055 }
10056
10057 /****************************************************************
10058  _spoolss_GetPrinterDriverPackagePath
10059 ****************************************************************/
10060
10061 WERROR _spoolss_GetPrinterDriverPackagePath(struct pipes_struct *p,
10062                                             struct spoolss_GetPrinterDriverPackagePath *r)
10063 {
10064         p->rng_fault_state = true;
10065         return WERR_NOT_SUPPORTED;
10066 }
10067
10068 /****************************************************************
10069  _spoolss_69
10070 ****************************************************************/
10071
10072 WERROR _spoolss_69(struct pipes_struct *p,
10073                    struct spoolss_69 *r)
10074 {
10075         p->rng_fault_state = true;
10076         return WERR_NOT_SUPPORTED;
10077 }
10078
10079 /****************************************************************
10080  _spoolss_6a
10081 ****************************************************************/
10082
10083 WERROR _spoolss_6a(struct pipes_struct *p,
10084                    struct spoolss_6a *r)
10085 {
10086         p->rng_fault_state = true;
10087         return WERR_NOT_SUPPORTED;
10088 }
10089
10090 /****************************************************************
10091  _spoolss_6b
10092 ****************************************************************/
10093
10094 WERROR _spoolss_6b(struct pipes_struct *p,
10095                    struct spoolss_6b *r)
10096 {
10097         p->rng_fault_state = true;
10098         return WERR_NOT_SUPPORTED;
10099 }
10100
10101 /****************************************************************
10102  _spoolss_6c
10103 ****************************************************************/
10104
10105 WERROR _spoolss_6c(struct pipes_struct *p,
10106                    struct spoolss_6c *r)
10107 {
10108         p->rng_fault_state = true;
10109         return WERR_NOT_SUPPORTED;
10110 }
10111
10112 /****************************************************************
10113  _spoolss_6d
10114 ****************************************************************/
10115
10116 WERROR _spoolss_6d(struct pipes_struct *p,
10117                    struct spoolss_6d *r)
10118 {
10119         p->rng_fault_state = true;
10120         return WERR_NOT_SUPPORTED;
10121 }