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                                   struct messaging_context *msg_ctx,
3910                                   uint32_t flags,
3911                                   const char *servername,
3912                                   union spoolss_PrinterInfo **info,
3913                                   uint32_t *count)
3914 {
3915         DEBUG(4,("enum_all_printers_info_0\n"));
3916
3917         return enum_all_printers_info_level(mem_ctx, server_info, msg_ctx,
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                                        struct messaging_context *msg_ctx,
3928                                        uint32_t flags,
3929                                        union spoolss_PrinterInfo **info,
3930                                        uint32_t *count)
3931 {
3932         DEBUG(4,("enum_all_printers_info_1\n"));
3933
3934         return enum_all_printers_info_level(mem_ctx, server_info, msg_ctx,
3935                                             1, flags, info, count);
3936 }
3937
3938 /********************************************************************
3939  enum_all_printers_info_1_local.
3940 *********************************************************************/
3941
3942 static WERROR enum_all_printers_info_1_local(TALLOC_CTX *mem_ctx,
3943                                              struct auth_serversupplied_info *server_info,
3944                                              struct messaging_context *msg_ctx,
3945                                              union spoolss_PrinterInfo **info,
3946                                              uint32_t *count)
3947 {
3948         DEBUG(4,("enum_all_printers_info_1_local\n"));
3949
3950         return enum_all_printers_info_1(mem_ctx, server_info, msg_ctx,
3951                                         PRINTER_ENUM_ICON8, info, count);
3952 }
3953
3954 /********************************************************************
3955  enum_all_printers_info_1_name.
3956 *********************************************************************/
3957
3958 static WERROR enum_all_printers_info_1_name(TALLOC_CTX *mem_ctx,
3959                                             struct auth_serversupplied_info *server_info,
3960                                             struct messaging_context *msg_ctx,
3961                                             const char *name,
3962                                             union spoolss_PrinterInfo **info,
3963                                             uint32_t *count)
3964 {
3965         const char *s = name;
3966
3967         DEBUG(4,("enum_all_printers_info_1_name\n"));
3968
3969         if ((name[0] == '\\') && (name[1] == '\\')) {
3970                 s = name + 2;
3971         }
3972
3973         if (!is_myname_or_ipaddr(s)) {
3974                 return WERR_INVALID_NAME;
3975         }
3976
3977         return enum_all_printers_info_1(mem_ctx, server_info, msg_ctx,
3978                                         PRINTER_ENUM_ICON8, info, count);
3979 }
3980
3981 /********************************************************************
3982  enum_all_printers_info_1_network.
3983 *********************************************************************/
3984
3985 static WERROR enum_all_printers_info_1_network(TALLOC_CTX *mem_ctx,
3986                                                struct auth_serversupplied_info *server_info,
3987                                                struct messaging_context *msg_ctx,
3988                                                const char *name,
3989                                                union spoolss_PrinterInfo **info,
3990                                                uint32_t *count)
3991 {
3992         const char *s = name;
3993
3994         DEBUG(4,("enum_all_printers_info_1_network\n"));
3995
3996         /* If we respond to a enum_printers level 1 on our name with flags
3997            set to PRINTER_ENUM_REMOTE with a list of printers then these
3998            printers incorrectly appear in the APW browse list.
3999            Specifically the printers for the server appear at the workgroup
4000            level where all the other servers in the domain are
4001            listed. Windows responds to this call with a
4002            WERR_CAN_NOT_COMPLETE so we should do the same. */
4003
4004         if (name[0] == '\\' && name[1] == '\\') {
4005                  s = name + 2;
4006         }
4007
4008         if (is_myname_or_ipaddr(s)) {
4009                  return WERR_CAN_NOT_COMPLETE;
4010         }
4011
4012         return enum_all_printers_info_1(mem_ctx, server_info, msg_ctx,
4013                                         PRINTER_ENUM_NAME, info, count);
4014 }
4015
4016 /********************************************************************
4017  * api_spoolss_enumprinters
4018  *
4019  * called from api_spoolss_enumprinters (see this to understand)
4020  ********************************************************************/
4021
4022 static WERROR enum_all_printers_info_2(TALLOC_CTX *mem_ctx,
4023                                        struct auth_serversupplied_info *server_info,
4024                                        struct messaging_context *msg_ctx,
4025                                        union spoolss_PrinterInfo **info,
4026                                        uint32_t *count)
4027 {
4028         DEBUG(4,("enum_all_printers_info_2\n"));
4029
4030         return enum_all_printers_info_level(mem_ctx, server_info, msg_ctx,
4031                                             2, 0, info, count);
4032 }
4033
4034 /********************************************************************
4035  * handle enumeration of printers at level 1
4036  ********************************************************************/
4037
4038 static WERROR enumprinters_level1(TALLOC_CTX *mem_ctx,
4039                                   struct auth_serversupplied_info *server_info,
4040                                   struct messaging_context *msg_ctx,
4041                                   uint32_t flags,
4042                                   const char *name,
4043                                   union spoolss_PrinterInfo **info,
4044                                   uint32_t *count)
4045 {
4046         /* Not all the flags are equals */
4047
4048         if (flags & PRINTER_ENUM_LOCAL) {
4049                 return enum_all_printers_info_1_local(mem_ctx, server_info,
4050                                                       msg_ctx, info, count);
4051         }
4052
4053         if (flags & PRINTER_ENUM_NAME) {
4054                 return enum_all_printers_info_1_name(mem_ctx, server_info,
4055                                                      msg_ctx, name, info,
4056                                                      count);
4057         }
4058
4059         if (flags & PRINTER_ENUM_NETWORK) {
4060                 return enum_all_printers_info_1_network(mem_ctx, server_info,
4061                                                         msg_ctx, name, info,
4062                                                         count);
4063         }
4064
4065         return WERR_OK; /* NT4sp5 does that */
4066 }
4067
4068 /********************************************************************
4069  * handle enumeration of printers at level 2
4070  ********************************************************************/
4071
4072 static WERROR enumprinters_level2(TALLOC_CTX *mem_ctx,
4073                                   struct auth_serversupplied_info *server_info,
4074                                   uint32_t flags,
4075                                   const char *servername,
4076                                   union spoolss_PrinterInfo **info,
4077                                   uint32_t *count)
4078 {
4079         if (flags & PRINTER_ENUM_LOCAL) {
4080                 return enum_all_printers_info_2(mem_ctx, server_info,
4081                                                 smbd_messaging_context(),
4082                                                 info, count);
4083         }
4084
4085         if (flags & PRINTER_ENUM_NAME) {
4086                 if (!is_myname_or_ipaddr(canon_servername(servername))) {
4087                         return WERR_INVALID_NAME;
4088                 }
4089
4090                 return enum_all_printers_info_2(mem_ctx, server_info,
4091                                                 smbd_messaging_context(),
4092                                                 info, count);
4093         }
4094
4095         if (flags & PRINTER_ENUM_REMOTE) {
4096                 return WERR_UNKNOWN_LEVEL;
4097         }
4098
4099         return WERR_OK;
4100 }
4101
4102 /********************************************************************
4103  * handle enumeration of printers at level 4
4104  ********************************************************************/
4105
4106 static WERROR enumprinters_level4(TALLOC_CTX *mem_ctx,
4107                                   struct auth_serversupplied_info *server_info,
4108                                   uint32_t flags,
4109                                   const char *servername,
4110                                   union spoolss_PrinterInfo **info,
4111                                   uint32_t *count)
4112 {
4113         DEBUG(4,("enum_all_printers_info_4\n"));
4114
4115         return enum_all_printers_info_level(mem_ctx, server_info,
4116                                             smbd_messaging_context(),
4117                                             4, flags, info, count);
4118 }
4119
4120
4121 /********************************************************************
4122  * handle enumeration of printers at level 5
4123  ********************************************************************/
4124
4125 static WERROR enumprinters_level5(TALLOC_CTX *mem_ctx,
4126                                   struct auth_serversupplied_info *server_info,
4127                                   uint32_t flags,
4128                                   const char *servername,
4129                                   union spoolss_PrinterInfo **info,
4130                                   uint32_t *count)
4131 {
4132         DEBUG(4,("enum_all_printers_info_5\n"));
4133
4134         return enum_all_printers_info_level(mem_ctx, server_info,
4135                                             smbd_messaging_context(),
4136                                             5, flags, info, count);
4137 }
4138
4139 /****************************************************************
4140  _spoolss_EnumPrinters
4141 ****************************************************************/
4142
4143 WERROR _spoolss_EnumPrinters(struct pipes_struct *p,
4144                              struct spoolss_EnumPrinters *r)
4145 {
4146         const char *name = NULL;
4147         WERROR result;
4148
4149         /* that's an [in out] buffer */
4150
4151         if (!r->in.buffer && (r->in.offered != 0)) {
4152                 return WERR_INVALID_PARAM;
4153         }
4154
4155         DEBUG(4,("_spoolss_EnumPrinters\n"));
4156
4157         *r->out.needed = 0;
4158         *r->out.count = 0;
4159         *r->out.info = NULL;
4160
4161         /*
4162          * Level 1:
4163          *          flags==PRINTER_ENUM_NAME
4164          *           if name=="" then enumerates all printers
4165          *           if name!="" then enumerate the printer
4166          *          flags==PRINTER_ENUM_REMOTE
4167          *          name is NULL, enumerate printers
4168          * Level 2: name!="" enumerates printers, name can't be NULL
4169          * Level 3: doesn't exist
4170          * Level 4: does a local registry lookup
4171          * Level 5: same as Level 2
4172          */
4173
4174         if (r->in.server) {
4175                 name = talloc_strdup_upper(p->mem_ctx, r->in.server);
4176                 W_ERROR_HAVE_NO_MEMORY(name);
4177         }
4178
4179         switch (r->in.level) {
4180         case 0:
4181                 result = enumprinters_level0(p->mem_ctx, p->server_info,
4182                                              p->msg_ctx, r->in.flags, name,
4183                                              r->out.info, r->out.count);
4184                 break;
4185         case 1:
4186                 result = enumprinters_level1(p->mem_ctx, p->server_info,
4187                                              p->msg_ctx, r->in.flags, name,
4188                                              r->out.info, r->out.count);
4189                 break;
4190         case 2:
4191                 result = enumprinters_level2(p->mem_ctx, p->server_info,
4192                                              r->in.flags, name,
4193                                              r->out.info, r->out.count);
4194                 break;
4195         case 4:
4196                 result = enumprinters_level4(p->mem_ctx, p->server_info,
4197                                              r->in.flags, name,
4198                                              r->out.info, r->out.count);
4199                 break;
4200         case 5:
4201                 result = enumprinters_level5(p->mem_ctx, p->server_info,
4202                                              r->in.flags, name,
4203                                              r->out.info, r->out.count);
4204                 break;
4205         default:
4206                 return WERR_UNKNOWN_LEVEL;
4207         }
4208
4209         if (!W_ERROR_IS_OK(result)) {
4210                 return result;
4211         }
4212
4213         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
4214                                                      spoolss_EnumPrinters,
4215                                                      *r->out.info, r->in.level,
4216                                                      *r->out.count);
4217         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
4218         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
4219
4220         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
4221 }
4222
4223 /****************************************************************
4224  _spoolss_GetPrinter
4225 ****************************************************************/
4226
4227 WERROR _spoolss_GetPrinter(struct pipes_struct *p,
4228                            struct spoolss_GetPrinter *r)
4229 {
4230         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
4231         struct spoolss_PrinterInfo2 *info2 = NULL;
4232         WERROR result = WERR_OK;
4233         const char *servername = NULL;
4234         int snum;
4235
4236         /* that's an [in out] buffer */
4237
4238         if (!r->in.buffer && (r->in.offered != 0)) {
4239                 return WERR_INVALID_PARAM;
4240         }
4241
4242         *r->out.needed = 0;
4243
4244         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
4245                 return WERR_BADFID;
4246         }
4247
4248         if (Printer != NULL || Printer->servername != NULL) {
4249                 servername = Printer->servername;
4250         }
4251
4252         result = winreg_get_printer(p->mem_ctx,
4253                                     p->server_info,
4254                                     p->msg_ctx,
4255                                     servername,
4256                                     lp_const_servicename(snum),
4257                                     &info2);
4258         if (!W_ERROR_IS_OK(result)) {
4259                 return result;
4260         }
4261
4262         switch (r->in.level) {
4263         case 0:
4264                 result = construct_printer_info0(p->mem_ctx, p->server_info,
4265                                                  p->msg_ctx, info2,
4266                                                  &r->out.info->info0, snum);
4267                 break;
4268         case 1:
4269                 result = construct_printer_info1(p->mem_ctx, info2,
4270                                                  PRINTER_ENUM_ICON8,
4271                                                  &r->out.info->info1, snum);
4272                 break;
4273         case 2:
4274                 result = construct_printer_info2(p->mem_ctx, info2,
4275                                                  &r->out.info->info2, snum);
4276                 break;
4277         case 3:
4278                 result = construct_printer_info3(p->mem_ctx, info2,
4279                                                  &r->out.info->info3, snum);
4280                 break;
4281         case 4:
4282                 result = construct_printer_info4(p->mem_ctx, info2,
4283                                                  &r->out.info->info4, snum);
4284                 break;
4285         case 5:
4286                 result = construct_printer_info5(p->mem_ctx, info2,
4287                                                  &r->out.info->info5, snum);
4288                 break;
4289         case 6:
4290                 result = construct_printer_info6(p->mem_ctx, info2,
4291                                                  &r->out.info->info6, snum);
4292                 break;
4293         case 7:
4294                 result = construct_printer_info7(p->mem_ctx, Printer,
4295                                                  &r->out.info->info7, snum);
4296                 break;
4297         case 8:
4298                 result = construct_printer_info8(p->mem_ctx, info2,
4299                                                  &r->out.info->info8, snum);
4300                 break;
4301         default:
4302                 result = WERR_UNKNOWN_LEVEL;
4303                 break;
4304         }
4305
4306         if (!W_ERROR_IS_OK(result)) {
4307                 DEBUG(0, ("_spoolss_GetPrinter: failed to construct printer info level %d - %s\n",
4308                           r->in.level, win_errstr(result)));
4309                 TALLOC_FREE(r->out.info);
4310                 return result;
4311         }
4312
4313         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_PrinterInfo,
4314                                                r->out.info, r->in.level);
4315         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
4316
4317         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
4318 }
4319
4320 /********************************************************************
4321  ********************************************************************/
4322
4323 #define FILL_DRIVER_STRING(mem_ctx, in, out) \
4324         do { \
4325                 if (in && strlen(in)) { \
4326                         out = talloc_strdup(mem_ctx, in); \
4327                 } else { \
4328                         out = talloc_strdup(mem_ctx, ""); \
4329                 } \
4330                 W_ERROR_HAVE_NO_MEMORY(out); \
4331         } while (0);
4332
4333 #define FILL_DRIVER_UNC_STRING(mem_ctx, server, arch, ver, in, out) \
4334         do { \
4335                 if (in && strlen(in)) { \
4336                         out = talloc_asprintf(mem_ctx, "\\\\%s\\print$\\%s\\%d\\%s", server, get_short_archi(arch), ver, in); \
4337                 } else { \
4338                         out = talloc_strdup(mem_ctx, ""); \
4339                 } \
4340                 W_ERROR_HAVE_NO_MEMORY(out); \
4341         } while (0);
4342
4343 static WERROR string_array_from_driver_info(TALLOC_CTX *mem_ctx,
4344                                                   const char **string_array,
4345                                                   const char ***presult,
4346                                                   const char *cservername,
4347                                                   const char *arch,
4348                                                   int version)
4349 {
4350         int i, num_strings = 0;
4351         const char **array = NULL;
4352
4353         if (string_array == NULL) {
4354                 return WERR_INVALID_PARAMETER;;
4355         }
4356
4357         for (i=0; string_array[i] && string_array[i][0] != '\0'; i++) {
4358                 const char *str = NULL;
4359
4360                 if (cservername == NULL || arch == NULL) {
4361                         FILL_DRIVER_STRING(mem_ctx, string_array[i], str);
4362                 } else {
4363                         FILL_DRIVER_UNC_STRING(mem_ctx, cservername, arch, version, string_array[i], str);
4364                 }
4365
4366                 if (!add_string_to_array(mem_ctx, str, &array, &num_strings)) {
4367                         TALLOC_FREE(array);
4368                         return WERR_NOMEM;
4369                 }
4370         }
4371
4372         if (i > 0) {
4373                 ADD_TO_ARRAY(mem_ctx, const char *, NULL,
4374                              &array, &num_strings);
4375         }
4376
4377         if (presult) {
4378                 *presult = array;
4379         }
4380
4381         return WERR_OK;
4382 }
4383
4384 /********************************************************************
4385  * fill a spoolss_DriverInfo1 struct
4386  ********************************************************************/
4387
4388 static WERROR fill_printer_driver_info1(TALLOC_CTX *mem_ctx,
4389                                         struct spoolss_DriverInfo1 *r,
4390                                         const struct spoolss_DriverInfo8 *driver,
4391                                         const char *servername)
4392 {
4393         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
4394         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4395
4396         return WERR_OK;
4397 }
4398
4399 /********************************************************************
4400  * fill a spoolss_DriverInfo2 struct
4401  ********************************************************************/
4402
4403 static WERROR fill_printer_driver_info2(TALLOC_CTX *mem_ctx,
4404                                         struct spoolss_DriverInfo2 *r,
4405                                         const struct spoolss_DriverInfo8 *driver,
4406                                         const char *servername)
4407
4408 {
4409         const char *cservername = canon_servername(servername);
4410
4411         r->version              = driver->version;
4412
4413         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
4414         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4415         r->architecture         = talloc_strdup(mem_ctx, driver->architecture);
4416         W_ERROR_HAVE_NO_MEMORY(r->architecture);
4417
4418         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4419                                driver->architecture,
4420                                driver->version,
4421                                driver->driver_path,
4422                                r->driver_path);
4423
4424         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4425                                driver->architecture,
4426                                driver->version,
4427                                driver->data_file,
4428                                r->data_file);
4429
4430         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4431                                driver->architecture,
4432                                driver->version,
4433                                driver->config_file,
4434                                r->config_file);
4435
4436         return WERR_OK;
4437 }
4438
4439 /********************************************************************
4440  * fill a spoolss_DriverInfo3 struct
4441  ********************************************************************/
4442
4443 static WERROR fill_printer_driver_info3(TALLOC_CTX *mem_ctx,
4444                                         struct spoolss_DriverInfo3 *r,
4445                                         const struct spoolss_DriverInfo8 *driver,
4446                                         const char *servername)
4447 {
4448         const char *cservername = canon_servername(servername);
4449
4450         r->version              = driver->version;
4451
4452         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
4453         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4454         r->architecture         = talloc_strdup(mem_ctx, driver->architecture);
4455         W_ERROR_HAVE_NO_MEMORY(r->architecture);
4456
4457         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4458                                driver->architecture,
4459                                driver->version,
4460                                driver->driver_path,
4461                                r->driver_path);
4462
4463         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4464                                driver->architecture,
4465                                driver->version,
4466                                driver->data_file,
4467                                r->data_file);
4468
4469         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4470                                driver->architecture,
4471                                driver->version,
4472                                driver->config_file,
4473                                r->config_file);
4474
4475         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4476                                driver->architecture,
4477                                driver->version,
4478                                driver->help_file,
4479                                r->help_file);
4480
4481         FILL_DRIVER_STRING(mem_ctx,
4482                            driver->monitor_name,
4483                            r->monitor_name);
4484
4485         FILL_DRIVER_STRING(mem_ctx,
4486                            driver->default_datatype,
4487                            r->default_datatype);
4488
4489         return string_array_from_driver_info(mem_ctx,
4490                                              driver->dependent_files,
4491                                              &r->dependent_files,
4492                                              cservername,
4493                                              driver->architecture,
4494                                              driver->version);
4495 }
4496
4497 /********************************************************************
4498  * fill a spoolss_DriverInfo4 struct
4499  ********************************************************************/
4500
4501 static WERROR fill_printer_driver_info4(TALLOC_CTX *mem_ctx,
4502                                         struct spoolss_DriverInfo4 *r,
4503                                         const struct spoolss_DriverInfo8 *driver,
4504                                         const char *servername)
4505 {
4506         const char *cservername = canon_servername(servername);
4507         WERROR result;
4508
4509         r->version              = driver->version;
4510
4511         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
4512         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4513         r->architecture         = talloc_strdup(mem_ctx, driver->architecture);
4514         W_ERROR_HAVE_NO_MEMORY(r->architecture);
4515
4516         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4517                                driver->architecture,
4518                                driver->version,
4519                                driver->driver_path,
4520                                r->driver_path);
4521
4522         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4523                                driver->architecture,
4524                                driver->version,
4525                                driver->data_file,
4526                                r->data_file);
4527
4528         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4529                                driver->architecture,
4530                                driver->version,
4531                                driver->config_file,
4532                                r->config_file);
4533
4534         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4535                                driver->architecture,
4536                                driver->version,
4537                                driver->help_file,
4538                                r->help_file);
4539
4540         result = string_array_from_driver_info(mem_ctx,
4541                                                driver->dependent_files,
4542                                                &r->dependent_files,
4543                                                cservername,
4544                                                driver->architecture,
4545                                                driver->version);
4546         if (!W_ERROR_IS_OK(result)) {
4547                 return result;
4548         }
4549
4550         FILL_DRIVER_STRING(mem_ctx,
4551                            driver->monitor_name,
4552                            r->monitor_name);
4553
4554         FILL_DRIVER_STRING(mem_ctx,
4555                            driver->default_datatype,
4556                            r->default_datatype);
4557
4558
4559         result = string_array_from_driver_info(mem_ctx,
4560                                                driver->previous_names,
4561                                                &r->previous_names,
4562                                                NULL, NULL, 0);
4563
4564         return result;
4565 }
4566
4567 /********************************************************************
4568  * fill a spoolss_DriverInfo5 struct
4569  ********************************************************************/
4570
4571 static WERROR fill_printer_driver_info5(TALLOC_CTX *mem_ctx,
4572                                         struct spoolss_DriverInfo5 *r,
4573                                         const struct spoolss_DriverInfo8 *driver,
4574                                         const char *servername)
4575 {
4576         const char *cservername = canon_servername(servername);
4577
4578         r->version              = driver->version;
4579
4580         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
4581         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4582         r->architecture         = talloc_strdup(mem_ctx, driver->architecture);
4583         W_ERROR_HAVE_NO_MEMORY(r->architecture);
4584
4585         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4586                                driver->architecture,
4587                                driver->version,
4588                                driver->driver_path,
4589                                r->driver_path);
4590
4591         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4592                                driver->architecture,
4593                                driver->version,
4594                                driver->data_file,
4595                                r->data_file);
4596
4597         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4598                                driver->architecture,
4599                                driver->version,
4600                                driver->config_file,
4601                                r->config_file);
4602
4603         r->driver_attributes    = 0;
4604         r->config_version       = 0;
4605         r->driver_version       = 0;
4606
4607         return WERR_OK;
4608 }
4609 /********************************************************************
4610  * fill a spoolss_DriverInfo6 struct
4611  ********************************************************************/
4612
4613 static WERROR fill_printer_driver_info6(TALLOC_CTX *mem_ctx,
4614                                         struct spoolss_DriverInfo6 *r,
4615                                         const struct spoolss_DriverInfo8 *driver,
4616                                         const char *servername)
4617 {
4618         const char *cservername = canon_servername(servername);
4619         WERROR result;
4620
4621         r->version              = driver->version;
4622
4623         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
4624         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4625         r->architecture         = talloc_strdup(mem_ctx, driver->architecture);
4626         W_ERROR_HAVE_NO_MEMORY(r->architecture);
4627
4628         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4629                                driver->architecture,
4630                                driver->version,
4631                                driver->driver_path,
4632                                r->driver_path);
4633
4634         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4635                                driver->architecture,
4636                                driver->version,
4637                                driver->data_file,
4638                                r->data_file);
4639
4640         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4641                                driver->architecture,
4642                                driver->version,
4643                                driver->config_file,
4644                                r->config_file);
4645
4646         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4647                                driver->architecture,
4648                                driver->version,
4649                                driver->help_file,
4650                                r->help_file);
4651
4652         FILL_DRIVER_STRING(mem_ctx,
4653                            driver->monitor_name,
4654                            r->monitor_name);
4655
4656         FILL_DRIVER_STRING(mem_ctx,
4657                            driver->default_datatype,
4658                            r->default_datatype);
4659
4660         result = string_array_from_driver_info(mem_ctx,
4661                                                driver->dependent_files,
4662                                                &r->dependent_files,
4663                                                cservername,
4664                                                driver->architecture,
4665                                                driver->version);
4666         if (!W_ERROR_IS_OK(result)) {
4667                 return result;
4668         }
4669
4670         result = string_array_from_driver_info(mem_ctx,
4671                                                driver->previous_names,
4672                                                &r->previous_names,
4673                                                NULL, NULL, 0);
4674         if (!W_ERROR_IS_OK(result)) {
4675                 return result;
4676         }
4677
4678         r->driver_date          = driver->driver_date;
4679         r->driver_version       = driver->driver_version;
4680
4681         FILL_DRIVER_STRING(mem_ctx,
4682                            driver->manufacturer_name,
4683                            r->manufacturer_name);
4684         FILL_DRIVER_STRING(mem_ctx,
4685                            driver->manufacturer_url,
4686                            r->manufacturer_url);
4687         FILL_DRIVER_STRING(mem_ctx,
4688                            driver->hardware_id,
4689                            r->hardware_id);
4690         FILL_DRIVER_STRING(mem_ctx,
4691                            driver->provider,
4692                            r->provider);
4693
4694         return WERR_OK;
4695 }
4696
4697 /********************************************************************
4698  * fill a spoolss_DriverInfo8 struct
4699  ********************************************************************/
4700
4701 static WERROR fill_printer_driver_info8(TALLOC_CTX *mem_ctx,
4702                                         struct spoolss_DriverInfo8 *r,
4703                                         const struct spoolss_DriverInfo8 *driver,
4704                                         const char *servername)
4705 {
4706         const char *cservername = canon_servername(servername);
4707         WERROR result;
4708
4709         r->version              = driver->version;
4710
4711         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
4712         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4713         r->architecture         = talloc_strdup(mem_ctx, driver->architecture);
4714         W_ERROR_HAVE_NO_MEMORY(r->architecture);
4715
4716         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4717                                driver->architecture,
4718                                driver->version,
4719                                driver->driver_path,
4720                                r->driver_path);
4721
4722         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4723                                driver->architecture,
4724                                driver->version,
4725                                driver->data_file,
4726                                r->data_file);
4727
4728         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4729                                driver->architecture,
4730                                driver->version,
4731                                driver->config_file,
4732                                r->config_file);
4733
4734         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4735                                driver->architecture,
4736                                driver->version,
4737                                driver->help_file,
4738                                r->help_file);
4739
4740         FILL_DRIVER_STRING(mem_ctx,
4741                            driver->monitor_name,
4742                            r->monitor_name);
4743
4744         FILL_DRIVER_STRING(mem_ctx,
4745                            driver->default_datatype,
4746                            r->default_datatype);
4747
4748         result = string_array_from_driver_info(mem_ctx,
4749                                                driver->dependent_files,
4750                                                &r->dependent_files,
4751                                                cservername,
4752                                                driver->architecture,
4753                                                driver->version);
4754         if (!W_ERROR_IS_OK(result)) {
4755                 return result;
4756         }
4757
4758         result = string_array_from_driver_info(mem_ctx,
4759                                                driver->previous_names,
4760                                                &r->previous_names,
4761                                                NULL, NULL, 0);
4762         if (!W_ERROR_IS_OK(result)) {
4763                 return result;
4764         }
4765
4766         r->driver_date          = driver->driver_date;
4767         r->driver_version       = driver->driver_version;
4768
4769         FILL_DRIVER_STRING(mem_ctx,
4770                            driver->manufacturer_name,
4771                            r->manufacturer_name);
4772         FILL_DRIVER_STRING(mem_ctx,
4773                            driver->manufacturer_url,
4774                            r->manufacturer_url);
4775         FILL_DRIVER_STRING(mem_ctx,
4776                            driver->hardware_id,
4777                            r->hardware_id);
4778         FILL_DRIVER_STRING(mem_ctx,
4779                            driver->provider,
4780                            r->provider);
4781
4782         FILL_DRIVER_STRING(mem_ctx,
4783                            driver->print_processor,
4784                            r->print_processor);
4785         FILL_DRIVER_STRING(mem_ctx,
4786                            driver->vendor_setup,
4787                            r->vendor_setup);
4788
4789         result = string_array_from_driver_info(mem_ctx,
4790                                                driver->color_profiles,
4791                                                &r->color_profiles,
4792                                                NULL, NULL, 0);
4793         if (!W_ERROR_IS_OK(result)) {
4794                 return result;
4795         }
4796
4797         FILL_DRIVER_STRING(mem_ctx,
4798                            driver->inf_path,
4799                            r->inf_path);
4800
4801         r->printer_driver_attributes    = driver->printer_driver_attributes;
4802
4803         result = string_array_from_driver_info(mem_ctx,
4804                                                driver->core_driver_dependencies,
4805                                                &r->core_driver_dependencies,
4806                                                NULL, NULL, 0);
4807         if (!W_ERROR_IS_OK(result)) {
4808                 return result;
4809         }
4810
4811         r->min_inbox_driver_ver_date    = driver->min_inbox_driver_ver_date;
4812         r->min_inbox_driver_ver_version = driver->min_inbox_driver_ver_version;
4813
4814         return WERR_OK;
4815 }
4816
4817 #if 0 /* disabled until marshalling issues are resolved - gd */
4818 /********************************************************************
4819  ********************************************************************/
4820
4821 static WERROR fill_spoolss_DriverFileInfo(TALLOC_CTX *mem_ctx,
4822                                           struct spoolss_DriverFileInfo *r,
4823                                           const char *cservername,
4824                                           const char *file_name,
4825                                           enum spoolss_DriverFileType file_type,
4826                                           uint32_t file_version)
4827 {
4828         r->file_name    = talloc_asprintf(mem_ctx, "\\\\%s%s",
4829                                           cservername, file_name);
4830         W_ERROR_HAVE_NO_MEMORY(r->file_name);
4831         r->file_type    = file_type;
4832         r->file_version = file_version;
4833
4834         return WERR_OK;
4835 }
4836
4837 /********************************************************************
4838  ********************************************************************/
4839
4840 static WERROR spoolss_DriverFileInfo_from_driver(TALLOC_CTX *mem_ctx,
4841                                                  const struct spoolss_DriverInfo8 *driver,
4842                                                  const char *cservername,
4843                                                  struct spoolss_DriverFileInfo **info_p,
4844                                                  uint32_t *count_p)
4845 {
4846         struct spoolss_DriverFileInfo *info = NULL;
4847         uint32_t count = 0;
4848         WERROR result;
4849         uint32_t i;
4850
4851         *info_p = NULL;
4852         *count_p = 0;
4853
4854         if (strlen(driver->driver_path)) {
4855                 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4856                                             struct spoolss_DriverFileInfo,
4857                                             count + 1);
4858                 W_ERROR_HAVE_NO_MEMORY(info);
4859                 result = fill_spoolss_DriverFileInfo(info,
4860                                                      &info[count],
4861                                                      cservername,
4862                                                      driver->driver_path,
4863                                                      SPOOLSS_DRIVER_FILE_TYPE_RENDERING,
4864                                                      0);
4865                 W_ERROR_NOT_OK_RETURN(result);
4866                 count++;
4867         }
4868
4869         if (strlen(driver->config_file)) {
4870                 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4871                                             struct spoolss_DriverFileInfo,
4872                                             count + 1);
4873                 W_ERROR_HAVE_NO_MEMORY(info);
4874                 result = fill_spoolss_DriverFileInfo(info,
4875                                                      &info[count],
4876                                                      cservername,
4877                                                      driver->config_file,
4878                                                      SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION,
4879                                                      0);
4880                 W_ERROR_NOT_OK_RETURN(result);
4881                 count++;
4882         }
4883
4884         if (strlen(driver->data_file)) {
4885                 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4886                                             struct spoolss_DriverFileInfo,
4887                                             count + 1);
4888                 W_ERROR_HAVE_NO_MEMORY(info);
4889                 result = fill_spoolss_DriverFileInfo(info,
4890                                                      &info[count],
4891                                                      cservername,
4892                                                      driver->data_file,
4893                                                      SPOOLSS_DRIVER_FILE_TYPE_DATA,
4894                                                      0);
4895                 W_ERROR_NOT_OK_RETURN(result);
4896                 count++;
4897         }
4898
4899         if (strlen(driver->help_file)) {
4900                 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4901                                             struct spoolss_DriverFileInfo,
4902                                             count + 1);
4903                 W_ERROR_HAVE_NO_MEMORY(info);
4904                 result = fill_spoolss_DriverFileInfo(info,
4905                                                      &info[count],
4906                                                      cservername,
4907                                                      driver->help_file,
4908                                                      SPOOLSS_DRIVER_FILE_TYPE_HELP,
4909                                                      0);
4910                 W_ERROR_NOT_OK_RETURN(result);
4911                 count++;
4912         }
4913
4914         for (i=0; driver->dependent_files[i] && driver->dependent_files[i][0] != '\0'; i++) {
4915                 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4916                                             struct spoolss_DriverFileInfo,
4917                                             count + 1);
4918                 W_ERROR_HAVE_NO_MEMORY(info);
4919                 result = fill_spoolss_DriverFileInfo(info,
4920                                                      &info[count],
4921                                                      cservername,
4922                                                      driver->dependent_files[i],
4923                                                      SPOOLSS_DRIVER_FILE_TYPE_OTHER,
4924                                                      0);
4925                 W_ERROR_NOT_OK_RETURN(result);
4926                 count++;
4927         }
4928
4929         *info_p = info;
4930         *count_p = count;
4931
4932         return WERR_OK;
4933 }
4934
4935 /********************************************************************
4936  * fill a spoolss_DriverInfo101 struct
4937  ********************************************************************/
4938
4939 static WERROR fill_printer_driver_info101(TALLOC_CTX *mem_ctx,
4940                                           struct spoolss_DriverInfo101 *r,
4941                                           const struct spoolss_DriverInfo8 *driver,
4942                                           const char *servername)
4943 {
4944         const char *cservername = canon_servername(servername);
4945         WERROR result;
4946
4947         r->version              = driver->version;
4948
4949         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
4950         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4951         r->architecture         = talloc_strdup(mem_ctx, driver->architecture);
4952         W_ERROR_HAVE_NO_MEMORY(r->architecture);
4953
4954         result = spoolss_DriverFileInfo_from_driver(mem_ctx, driver,
4955                                                     cservername,
4956                                                     &r->file_info,
4957                                                     &r->file_count);
4958         if (!W_ERROR_IS_OK(result)) {
4959                 return result;
4960         }
4961
4962         FILL_DRIVER_STRING(mem_ctx,
4963                            driver->monitor_name,
4964                            r->monitor_name);
4965
4966         FILL_DRIVER_STRING(mem_ctx,
4967                            driver->default_datatype,
4968                            r->default_datatype);
4969
4970         result = string_array_from_driver_info(mem_ctx,
4971                                                driver->previous_names,
4972                                                &r->previous_names,
4973                                                NULL, NULL, 0);
4974         if (!W_ERROR_IS_OK(result)) {
4975                 return result;
4976         }
4977
4978         r->driver_date          = driver->driver_date;
4979         r->driver_version       = driver->driver_version;
4980
4981         FILL_DRIVER_STRING(mem_ctx,
4982                            driver->manufacturer_name,
4983                            r->manufacturer_name);
4984         FILL_DRIVER_STRING(mem_ctx,
4985                            driver->manufacturer_url,
4986                            r->manufacturer_url);
4987         FILL_DRIVER_STRING(mem_ctx,
4988                            driver->hardware_id,
4989                            r->hardware_id);
4990         FILL_DRIVER_STRING(mem_ctx,
4991                            driver->provider,
4992                            r->provider);
4993
4994         return WERR_OK;
4995 }
4996 #endif
4997 /********************************************************************
4998  ********************************************************************/
4999
5000 static WERROR construct_printer_driver_info_level(TALLOC_CTX *mem_ctx,
5001                                                   struct auth_serversupplied_info *server_info,
5002                                                   uint32_t level,
5003                                                   union spoolss_DriverInfo *r,
5004                                                   int snum,
5005                                                   const char *servername,
5006                                                   const char *architecture,
5007                                                   uint32_t version)
5008 {
5009         struct spoolss_PrinterInfo2 *pinfo2 = NULL;
5010         struct spoolss_DriverInfo8 *driver;
5011         WERROR result;
5012
5013         result = winreg_get_printer(mem_ctx,
5014                                     server_info,
5015                                     smbd_messaging_context(),
5016                                     servername,
5017                                     lp_const_servicename(snum),
5018                                     &pinfo2);
5019
5020         DEBUG(8,("construct_printer_driver_info_level: status: %s\n",
5021                 win_errstr(result)));
5022
5023         if (!W_ERROR_IS_OK(result)) {
5024                 return WERR_INVALID_PRINTER_NAME;
5025         }
5026
5027         result = winreg_get_driver(mem_ctx, server_info,
5028                                    smbd_messaging_context(),
5029                                    architecture,
5030                                    pinfo2->drivername, version, &driver);
5031
5032         DEBUG(8,("construct_printer_driver_info_level: status: %s\n",
5033                 win_errstr(result)));
5034
5035         if (!W_ERROR_IS_OK(result)) {
5036                 /*
5037                  * Is this a W2k client ?
5038                  */
5039
5040                 if (version < 3) {
5041                         talloc_free(pinfo2);
5042                         return WERR_UNKNOWN_PRINTER_DRIVER;
5043                 }
5044
5045                 /* Yes - try again with a WinNT driver. */
5046                 version = 2;
5047                 result = winreg_get_driver(mem_ctx, server_info,
5048                                            smbd_messaging_context(),
5049                                            architecture,
5050                                            pinfo2->drivername,
5051                                            version, &driver);
5052                 DEBUG(8,("construct_printer_driver_level: status: %s\n",
5053                         win_errstr(result)));
5054                 if (!W_ERROR_IS_OK(result)) {
5055                         talloc_free(pinfo2);
5056                         return WERR_UNKNOWN_PRINTER_DRIVER;
5057                 }
5058         }
5059
5060         switch (level) {
5061         case 1:
5062                 result = fill_printer_driver_info1(mem_ctx, &r->info1, driver, servername);
5063                 break;
5064         case 2:
5065                 result = fill_printer_driver_info2(mem_ctx, &r->info2, driver, servername);
5066                 break;
5067         case 3:
5068                 result = fill_printer_driver_info3(mem_ctx, &r->info3, driver, servername);
5069                 break;
5070         case 4:
5071                 result = fill_printer_driver_info4(mem_ctx, &r->info4, driver, servername);
5072                 break;
5073         case 5:
5074                 result = fill_printer_driver_info5(mem_ctx, &r->info5, driver, servername);
5075                 break;
5076         case 6:
5077                 result = fill_printer_driver_info6(mem_ctx, &r->info6, driver, servername);
5078                 break;
5079         case 8:
5080                 result = fill_printer_driver_info8(mem_ctx, &r->info8, driver, servername);
5081                 break;
5082 #if 0 /* disabled until marshalling issues are resolved - gd */
5083         case 101:
5084                 result = fill_printer_driver_info101(mem_ctx, &r->info101, driver, servername);
5085                 break;
5086 #endif
5087         default:
5088                 result = WERR_UNKNOWN_LEVEL;
5089                 break;
5090         }
5091
5092         talloc_free(pinfo2);
5093         talloc_free(driver);
5094
5095         return result;
5096 }
5097
5098 /****************************************************************
5099  _spoolss_GetPrinterDriver2
5100 ****************************************************************/
5101
5102 WERROR _spoolss_GetPrinterDriver2(struct pipes_struct *p,
5103                                   struct spoolss_GetPrinterDriver2 *r)
5104 {
5105         Printer_entry *printer;
5106         WERROR result;
5107
5108         int snum;
5109
5110         /* that's an [in out] buffer */
5111
5112         if (!r->in.buffer && (r->in.offered != 0)) {
5113                 return WERR_INVALID_PARAM;
5114         }
5115
5116         DEBUG(4,("_spoolss_GetPrinterDriver2\n"));
5117
5118         if (!(printer = find_printer_index_by_hnd(p, r->in.handle))) {
5119                 DEBUG(0,("_spoolss_GetPrinterDriver2: invalid printer handle!\n"));
5120                 return WERR_INVALID_PRINTER_NAME;
5121         }
5122
5123         *r->out.needed = 0;
5124         *r->out.server_major_version = 0;
5125         *r->out.server_minor_version = 0;
5126
5127         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5128                 return WERR_BADFID;
5129         }
5130
5131         result = construct_printer_driver_info_level(p->mem_ctx, p->server_info,
5132                                                      r->in.level, r->out.info,
5133                                                      snum, printer->servername,
5134                                                      r->in.architecture,
5135                                                      r->in.client_major_version);
5136         if (!W_ERROR_IS_OK(result)) {
5137                 TALLOC_FREE(r->out.info);
5138                 return result;
5139         }
5140
5141         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_DriverInfo,
5142                                                r->out.info, r->in.level);
5143         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
5144
5145         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
5146 }
5147
5148
5149 /****************************************************************
5150  _spoolss_StartPagePrinter
5151 ****************************************************************/
5152
5153 WERROR _spoolss_StartPagePrinter(struct pipes_struct *p,
5154                                  struct spoolss_StartPagePrinter *r)
5155 {
5156         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5157
5158         if (!Printer) {
5159                 DEBUG(3,("_spoolss_StartPagePrinter: "
5160                         "Error in startpageprinter printer handle\n"));
5161                 return WERR_BADFID;
5162         }
5163
5164         Printer->page_started = true;
5165         return WERR_OK;
5166 }
5167
5168 /****************************************************************
5169  _spoolss_EndPagePrinter
5170 ****************************************************************/
5171
5172 WERROR _spoolss_EndPagePrinter(struct pipes_struct *p,
5173                                struct spoolss_EndPagePrinter *r)
5174 {
5175         int snum;
5176
5177         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5178
5179         if (!Printer) {
5180                 DEBUG(2,("_spoolss_EndPagePrinter: Invalid handle (%s:%u:%u).\n",
5181                         OUR_HANDLE(r->in.handle)));
5182                 return WERR_BADFID;
5183         }
5184
5185         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5186                 return WERR_BADFID;
5187
5188         Printer->page_started = false;
5189         print_job_endpage(snum, Printer->jobid);
5190
5191         return WERR_OK;
5192 }
5193
5194 /****************************************************************
5195  _spoolss_StartDocPrinter
5196 ****************************************************************/
5197
5198 WERROR _spoolss_StartDocPrinter(struct pipes_struct *p,
5199                                 struct spoolss_StartDocPrinter *r)
5200 {
5201         struct spoolss_DocumentInfo1 *info_1;
5202         int snum;
5203         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5204         WERROR werr;
5205
5206         if (!Printer) {
5207                 DEBUG(2,("_spoolss_StartDocPrinter: "
5208                         "Invalid handle (%s:%u:%u)\n",
5209                         OUR_HANDLE(r->in.handle)));
5210                 return WERR_BADFID;
5211         }
5212
5213         if (Printer->jobid) {
5214                 DEBUG(2, ("_spoolss_StartDocPrinter: "
5215                           "StartDocPrinter called twice! "
5216                           "(existing jobid = %d)\n", Printer->jobid));
5217                 return WERR_INVALID_HANDLE;
5218         }
5219
5220         if (r->in.level != 1) {
5221                 return WERR_UNKNOWN_LEVEL;
5222         }
5223
5224         info_1 = r->in.info.info1;
5225
5226         /*
5227          * a nice thing with NT is it doesn't listen to what you tell it.
5228          * when asked to send _only_ RAW datas, it tries to send datas
5229          * in EMF format.
5230          *
5231          * So I add checks like in NT Server ...
5232          */
5233
5234         if (info_1->datatype) {
5235                 if (strcmp(info_1->datatype, "RAW") != 0) {
5236                         *r->out.job_id = 0;
5237                         return WERR_INVALID_DATATYPE;
5238                 }
5239         }
5240
5241         /* get the share number of the printer */
5242         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5243                 return WERR_BADFID;
5244         }
5245
5246         werr = print_job_start(p->server_info, snum,
5247                                 info_1->document_name, info_1->output_file,
5248                                 Printer->devmode, &Printer->jobid);
5249
5250         /* An error occured in print_job_start() so return an appropriate
5251            NT error code. */
5252
5253         if (!W_ERROR_IS_OK(werr)) {
5254                 return werr;
5255         }
5256
5257         Printer->document_started = true;
5258         *r->out.job_id = Printer->jobid;
5259
5260         return WERR_OK;
5261 }
5262
5263 /****************************************************************
5264  _spoolss_EndDocPrinter
5265 ****************************************************************/
5266
5267 WERROR _spoolss_EndDocPrinter(struct pipes_struct *p,
5268                               struct spoolss_EndDocPrinter *r)
5269 {
5270         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5271         NTSTATUS status;
5272         int snum;
5273
5274         if (!Printer) {
5275                 DEBUG(2,("_spoolss_EndDocPrinter: Invalid handle (%s:%u:%u)\n",
5276                         OUR_HANDLE(r->in.handle)));
5277                 return WERR_BADFID;
5278         }
5279
5280         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5281                 return WERR_BADFID;
5282         }
5283
5284         Printer->document_started = false;
5285         status = print_job_end(snum, Printer->jobid, NORMAL_CLOSE);
5286         if (!NT_STATUS_IS_OK(status)) {
5287                 DEBUG(2, ("_spoolss_EndDocPrinter: "
5288                           "print_job_end failed [%s]\n",
5289                           nt_errstr(status)));
5290         }
5291
5292         Printer->jobid = 0;
5293         return ntstatus_to_werror(status);
5294 }
5295
5296 /****************************************************************
5297  _spoolss_WritePrinter
5298 ****************************************************************/
5299
5300 WERROR _spoolss_WritePrinter(struct pipes_struct *p,
5301                              struct spoolss_WritePrinter *r)
5302 {
5303         ssize_t buffer_written;
5304         int snum;
5305         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5306
5307         if (!Printer) {
5308                 DEBUG(2,("_spoolss_WritePrinter: Invalid handle (%s:%u:%u)\n",
5309                         OUR_HANDLE(r->in.handle)));
5310                 *r->out.num_written = r->in._data_size;
5311                 return WERR_BADFID;
5312         }
5313
5314         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5315                 return WERR_BADFID;
5316
5317         /* print_job_write takes care of checking for PJOB_SMBD_SPOOLING */
5318         buffer_written = print_job_write(snum, Printer->jobid,
5319                                                    (const char *)r->in.data.data,
5320                                                    (SMB_OFF_T)-1,
5321                                                    (size_t)r->in._data_size);
5322         if (buffer_written == (ssize_t)-1) {
5323                 *r->out.num_written = 0;
5324                 if (errno == ENOSPC)
5325                         return WERR_NO_SPOOL_SPACE;
5326                 else
5327                         return WERR_ACCESS_DENIED;
5328         }
5329
5330         *r->out.num_written = r->in._data_size;
5331
5332         return WERR_OK;
5333 }
5334
5335 /********************************************************************
5336  * api_spoolss_getprinter
5337  * called from the spoolss dispatcher
5338  *
5339  ********************************************************************/
5340
5341 static WERROR control_printer(struct policy_handle *handle, uint32_t command,
5342                               struct pipes_struct *p)
5343 {
5344         int snum;
5345         WERROR errcode = WERR_BADFUNC;
5346         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5347
5348         if (!Printer) {
5349                 DEBUG(2,("control_printer: Invalid handle (%s:%u:%u)\n",
5350                         OUR_HANDLE(handle)));
5351                 return WERR_BADFID;
5352         }
5353
5354         if (!get_printer_snum(p, handle, &snum, NULL))
5355                 return WERR_BADFID;
5356
5357         switch (command) {
5358         case SPOOLSS_PRINTER_CONTROL_PAUSE:
5359                 errcode = print_queue_pause(p->server_info, snum);
5360                 break;
5361         case SPOOLSS_PRINTER_CONTROL_RESUME:
5362         case SPOOLSS_PRINTER_CONTROL_UNPAUSE:
5363                 errcode = print_queue_resume(p->server_info, snum);
5364                 break;
5365         case SPOOLSS_PRINTER_CONTROL_PURGE:
5366                 errcode = print_queue_purge(p->server_info, snum);
5367                 break;
5368         default:
5369                 return WERR_UNKNOWN_LEVEL;
5370         }
5371
5372         return errcode;
5373 }
5374
5375
5376 /****************************************************************
5377  _spoolss_AbortPrinter
5378  * From MSDN: "Deletes printer's spool file if printer is configured
5379  * for spooling"
5380 ****************************************************************/
5381
5382 WERROR _spoolss_AbortPrinter(struct pipes_struct *p,
5383                              struct spoolss_AbortPrinter *r)
5384 {
5385         Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
5386         int             snum;
5387         WERROR          errcode = WERR_OK;
5388
5389         if (!Printer) {
5390                 DEBUG(2,("_spoolss_AbortPrinter: Invalid handle (%s:%u:%u)\n",
5391                         OUR_HANDLE(r->in.handle)));
5392                 return WERR_BADFID;
5393         }
5394
5395         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5396                 return WERR_BADFID;
5397
5398         if (!Printer->document_started) {
5399                 return WERR_SPL_NO_STARTDOC;
5400         }
5401
5402         errcode = print_job_delete(p->server_info, snum, Printer->jobid);
5403
5404         return errcode;
5405 }
5406
5407 /********************************************************************
5408  * called by spoolss_api_setprinter
5409  * when updating a printer description
5410  ********************************************************************/
5411
5412 static WERROR update_printer_sec(struct policy_handle *handle,
5413                                  struct pipes_struct *p,
5414                                  struct sec_desc_buf *secdesc_ctr)
5415 {
5416         struct spoolss_security_descriptor *new_secdesc = NULL;
5417         struct spoolss_security_descriptor *old_secdesc = NULL;
5418         const char *printer;
5419         WERROR result;
5420         int snum;
5421
5422         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5423
5424         if (!Printer || !get_printer_snum(p, handle, &snum, NULL)) {
5425                 DEBUG(2,("update_printer_sec: Invalid handle (%s:%u:%u)\n",
5426                          OUR_HANDLE(handle)));
5427
5428                 result = WERR_BADFID;
5429                 goto done;
5430         }
5431
5432         if (secdesc_ctr == NULL) {
5433                 DEBUG(10,("update_printer_sec: secdesc_ctr is NULL !\n"));
5434                 result = WERR_INVALID_PARAM;
5435                 goto done;
5436         }
5437         printer = lp_const_servicename(snum);
5438
5439         /* Check the user has permissions to change the security
5440            descriptor.  By experimentation with two NT machines, the user
5441            requires Full Access to the printer to change security
5442            information. */
5443
5444         if ( Printer->access_granted != PRINTER_ACCESS_ADMINISTER ) {
5445                 DEBUG(4,("update_printer_sec: updated denied by printer permissions\n"));
5446                 result = WERR_ACCESS_DENIED;
5447                 goto done;
5448         }
5449
5450         /* NT seems to like setting the security descriptor even though
5451            nothing may have actually changed. */
5452         result = winreg_get_printer_secdesc(p->mem_ctx,
5453                                             p->server_info,
5454                                             p->msg_ctx,
5455                                             printer,
5456                                             &old_secdesc);
5457         if (!W_ERROR_IS_OK(result)) {
5458                 DEBUG(2,("update_printer_sec: winreg_get_printer_secdesc() failed\n"));
5459                 result = WERR_BADFID;
5460                 goto done;
5461         }
5462
5463         if (DEBUGLEVEL >= 10) {
5464                 struct security_acl *the_acl;
5465                 int i;
5466
5467                 the_acl = old_secdesc->dacl;
5468                 DEBUG(10, ("old_secdesc_ctr for %s has %d aces:\n",
5469                            printer, the_acl->num_aces));
5470
5471                 for (i = 0; i < the_acl->num_aces; i++) {
5472                         DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
5473                                            &the_acl->aces[i].trustee),
5474                                   the_acl->aces[i].access_mask));
5475                 }
5476
5477                 the_acl = secdesc_ctr->sd->dacl;
5478
5479                 if (the_acl) {
5480                         DEBUG(10, ("secdesc_ctr for %s has %d aces:\n",
5481                                    printer, the_acl->num_aces));
5482
5483                         for (i = 0; i < the_acl->num_aces; i++) {
5484                                 DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
5485                                                    &the_acl->aces[i].trustee),
5486                                            the_acl->aces[i].access_mask));
5487                         }
5488                 } else {
5489                         DEBUG(10, ("dacl for secdesc_ctr is NULL\n"));
5490                 }
5491         }
5492
5493         new_secdesc = sec_desc_merge(p->mem_ctx, secdesc_ctr->sd, old_secdesc);
5494         if (new_secdesc == NULL) {
5495                 result = WERR_NOMEM;
5496                 goto done;
5497         }
5498
5499         if (security_descriptor_equal(new_secdesc, old_secdesc)) {
5500                 result = WERR_OK;
5501                 goto done;
5502         }
5503
5504         result = winreg_set_printer_secdesc(p->mem_ctx,
5505                                             p->server_info,
5506                                             p->msg_ctx,
5507                                             printer,
5508                                             new_secdesc);
5509
5510  done:
5511         return result;
5512 }
5513
5514 /********************************************************************
5515  Canonicalize printer info from a client
5516  ********************************************************************/
5517
5518 static bool check_printer_ok(TALLOC_CTX *mem_ctx,
5519                              struct spoolss_SetPrinterInfo2 *info2,
5520                              int snum)
5521 {
5522         fstring printername;
5523         const char *p;
5524
5525         DEBUG(5,("check_printer_ok: servername=%s printername=%s sharename=%s "
5526                 "portname=%s drivername=%s comment=%s location=%s\n",
5527                 info2->servername, info2->printername, info2->sharename,
5528                 info2->portname, info2->drivername, info2->comment,
5529                 info2->location));
5530
5531         /* we force some elements to "correct" values */
5532         info2->servername = talloc_asprintf(mem_ctx, "\\\\%s", global_myname());
5533         if (info2->servername == NULL) {
5534                 return false;
5535         }
5536         info2->sharename = talloc_strdup(mem_ctx, lp_const_servicename(snum));
5537         if (info2->sharename == NULL) {
5538                 return false;
5539         }
5540
5541         /* check to see if we allow printername != sharename */
5542         if (lp_force_printername(snum)) {
5543                 info2->printername = talloc_asprintf(mem_ctx, "\\\\%s\\%s",
5544                                         global_myname(), info2->sharename);
5545         } else {
5546                 /* make sure printername is in \\server\printername format */
5547                 fstrcpy(printername, info2->printername);
5548                 p = printername;
5549                 if ( printername[0] == '\\' && printername[1] == '\\' ) {
5550                         if ( (p = strchr_m( &printername[2], '\\' )) != NULL )
5551                                 p++;
5552                 }
5553
5554                 info2->printername = talloc_asprintf(mem_ctx, "\\\\%s\\%s",
5555                                         global_myname(), p);
5556         }
5557         if (info2->printername == NULL) {
5558                 return false;
5559         }
5560
5561         info2->attributes |= PRINTER_ATTRIBUTE_SAMBA;
5562         info2->attributes &= ~PRINTER_ATTRIBUTE_NOT_SAMBA;
5563
5564         return true;
5565 }
5566
5567 /****************************************************************************
5568 ****************************************************************************/
5569
5570 static WERROR add_port_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, const char *portname, const char *uri)
5571 {
5572         char *cmd = lp_addport_cmd();
5573         char *command = NULL;
5574         int ret;
5575         SE_PRIV se_printop = SE_PRINT_OPERATOR;
5576         bool is_print_op = false;
5577
5578         if ( !*cmd ) {
5579                 return WERR_ACCESS_DENIED;
5580         }
5581
5582         command = talloc_asprintf(ctx,
5583                         "%s \"%s\" \"%s\"", cmd, portname, uri );
5584         if (!command) {
5585                 return WERR_NOMEM;
5586         }
5587
5588         if ( token )
5589                 is_print_op = user_has_privileges( token, &se_printop );
5590
5591         DEBUG(10,("Running [%s]\n", command));
5592
5593         /********* BEGIN SePrintOperatorPrivilege **********/
5594
5595         if ( is_print_op )
5596                 become_root();
5597
5598         ret = smbrun(command, NULL);
5599
5600         if ( is_print_op )
5601                 unbecome_root();
5602
5603         /********* END SePrintOperatorPrivilege **********/
5604
5605         DEBUGADD(10,("returned [%d]\n", ret));
5606
5607         TALLOC_FREE(command);
5608
5609         if ( ret != 0 ) {
5610                 return WERR_ACCESS_DENIED;
5611         }
5612
5613         return WERR_OK;
5614 }
5615
5616 /****************************************************************************
5617 ****************************************************************************/
5618
5619 static bool add_printer_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token,
5620                              struct spoolss_SetPrinterInfo2 *info2,
5621                              const char *remote_machine,
5622                              struct messaging_context *msg_ctx)
5623 {
5624         char *cmd = lp_addprinter_cmd();
5625         char **qlines;
5626         char *command = NULL;
5627         int numlines;
5628         int ret;
5629         int fd;
5630         SE_PRIV se_printop = SE_PRINT_OPERATOR;
5631         bool is_print_op = false;
5632
5633         if (!remote_machine) {
5634                 return false;
5635         }
5636
5637         command = talloc_asprintf(ctx,
5638                         "%s \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"",
5639                         cmd, info2->printername, info2->sharename,
5640                         info2->portname, info2->drivername,
5641                         info2->location, info2->comment, remote_machine);
5642         if (!command) {
5643                 return false;
5644         }
5645
5646         if ( token )
5647                 is_print_op = user_has_privileges( token, &se_printop );
5648
5649         DEBUG(10,("Running [%s]\n", command));
5650
5651         /********* BEGIN SePrintOperatorPrivilege **********/
5652
5653         if ( is_print_op )
5654                 become_root();
5655
5656         if ( (ret = smbrun(command, &fd)) == 0 ) {
5657                 /* Tell everyone we updated smb.conf. */
5658                 message_send_all(msg_ctx, MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
5659         }
5660
5661         if ( is_print_op )
5662                 unbecome_root();
5663
5664         /********* END SePrintOperatorPrivilege **********/
5665
5666         DEBUGADD(10,("returned [%d]\n", ret));
5667
5668         TALLOC_FREE(command);
5669
5670         if ( ret != 0 ) {
5671                 if (fd != -1)
5672                         close(fd);
5673                 return false;
5674         }
5675
5676         /* reload our services immediately */
5677         become_root();
5678         reload_services(false);
5679         unbecome_root();
5680
5681         numlines = 0;
5682         /* Get lines and convert them back to dos-codepage */
5683         qlines = fd_lines_load(fd, &numlines, 0, NULL);
5684         DEBUGADD(10,("Lines returned = [%d]\n", numlines));
5685         close(fd);
5686
5687         /* Set the portname to what the script says the portname should be. */
5688         /* but don't require anything to be return from the script exit a good error code */
5689
5690         if (numlines) {
5691                 /* Set the portname to what the script says the portname should be. */
5692                 info2->portname = talloc_strdup(ctx, qlines[0]);
5693                 DEBUGADD(6,("Line[0] = [%s]\n", qlines[0]));
5694         }
5695
5696         TALLOC_FREE(qlines);
5697         return true;
5698 }
5699
5700 static WERROR update_dsspooler(TALLOC_CTX *mem_ctx,
5701                                struct auth_serversupplied_info *server_info,
5702                                int snum,
5703                                struct spoolss_SetPrinterInfo2 *printer,
5704                                struct spoolss_PrinterInfo2 *old_printer)
5705 {
5706         bool force_update = (old_printer == NULL);
5707         const char *dnsdomname;
5708         const char *longname;
5709         const char *uncname;
5710         const char *spooling;
5711         DATA_BLOB buffer;
5712         WERROR result = WERR_OK;
5713
5714         if (force_update || !strequal(printer->drivername, old_printer->drivername)) {
5715                 push_reg_sz(mem_ctx, &buffer, printer->drivername);
5716                 winreg_set_printer_dataex(mem_ctx,
5717                                           server_info,
5718                                           smbd_messaging_context(),
5719                                           printer->sharename,
5720                                           SPOOL_DSSPOOLER_KEY,
5721                                           SPOOL_REG_DRIVERNAME,
5722                                           REG_SZ,
5723                                           buffer.data,
5724                                           buffer.length);
5725
5726                 if (!force_update) {
5727                         DEBUG(10,("update_printer: changing driver [%s]!  Sending event!\n",
5728                                 printer->drivername));
5729
5730                         notify_printer_driver(snum, printer->drivername);
5731                 }
5732         }
5733
5734         if (force_update || !strequal(printer->comment, old_printer->comment)) {
5735                 push_reg_sz(mem_ctx, &buffer, printer->comment);
5736                 winreg_set_printer_dataex(mem_ctx,
5737                                           server_info,
5738                                           smbd_messaging_context(),
5739                                           printer->sharename,
5740                                           SPOOL_DSSPOOLER_KEY,
5741                                           SPOOL_REG_DESCRIPTION,
5742                                           REG_SZ,
5743                                           buffer.data,
5744                                           buffer.length);
5745
5746                 if (!force_update) {
5747                         notify_printer_comment(snum, printer->comment);
5748                 }
5749         }
5750
5751         if (force_update || !strequal(printer->sharename, old_printer->sharename)) {
5752                 push_reg_sz(mem_ctx, &buffer, printer->sharename);
5753                 winreg_set_printer_dataex(mem_ctx,
5754                                           server_info,
5755                                           smbd_messaging_context(),
5756                                           printer->sharename,
5757                                           SPOOL_DSSPOOLER_KEY,
5758                                           SPOOL_REG_PRINTSHARENAME,
5759                                           REG_SZ,
5760                                           buffer.data,
5761                                           buffer.length);
5762
5763                 if (!force_update) {
5764                         notify_printer_sharename(snum, printer->sharename);
5765                 }
5766         }
5767
5768         if (force_update || !strequal(printer->printername, old_printer->printername)) {
5769                 const char *p;
5770
5771                 p = strrchr(printer->printername, '\\' );
5772                 if (p != NULL) {
5773                         p++;
5774                 } else {
5775                         p = printer->printername;
5776                 }
5777
5778                 push_reg_sz(mem_ctx, &buffer, p);
5779                 winreg_set_printer_dataex(mem_ctx,
5780                                           server_info,
5781                                           smbd_messaging_context(),
5782                                           printer->sharename,
5783                                           SPOOL_DSSPOOLER_KEY,
5784                                           SPOOL_REG_PRINTERNAME,
5785                                           REG_SZ,
5786                                           buffer.data,
5787                                           buffer.length);
5788
5789                 if (!force_update) {
5790                         notify_printer_printername(snum, p);
5791                 }
5792         }
5793
5794         if (force_update || !strequal(printer->portname, old_printer->portname)) {
5795                 push_reg_sz(mem_ctx, &buffer, printer->portname);
5796                 winreg_set_printer_dataex(mem_ctx,
5797                                           server_info,
5798                                           smbd_messaging_context(),
5799                                           printer->sharename,
5800                                           SPOOL_DSSPOOLER_KEY,
5801                                           SPOOL_REG_PORTNAME,
5802                                           REG_SZ,
5803                                           buffer.data,
5804                                           buffer.length);
5805
5806                 if (!force_update) {
5807                         notify_printer_port(snum, printer->portname);
5808                 }
5809         }
5810
5811         if (force_update || !strequal(printer->location, old_printer->location)) {
5812                 push_reg_sz(mem_ctx, &buffer, printer->location);
5813                 winreg_set_printer_dataex(mem_ctx,
5814                                           server_info,
5815                                           smbd_messaging_context(),
5816                                           printer->sharename,
5817                                           SPOOL_DSSPOOLER_KEY,
5818                                           SPOOL_REG_LOCATION,
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 || !strequal(printer->sepfile, old_printer->sepfile)) {
5829                 push_reg_sz(mem_ctx, &buffer, printer->sepfile);
5830                 winreg_set_printer_dataex(mem_ctx,
5831                                           server_info,
5832                                           smbd_messaging_context(),
5833                                           printer->sharename,
5834                                           SPOOL_DSSPOOLER_KEY,
5835                                           SPOOL_REG_PRINTSEPARATORFILE,
5836                                           REG_SZ,
5837                                           buffer.data,
5838                                           buffer.length);
5839
5840                 if (!force_update) {
5841                         notify_printer_location(snum, printer->location);
5842                 }
5843         }
5844
5845         if (force_update || printer->starttime != old_printer->starttime) {
5846                 buffer = data_blob_talloc(mem_ctx, NULL, 4);
5847                 SIVAL(buffer.data, 0, printer->starttime);
5848                 winreg_set_printer_dataex(mem_ctx,
5849                                           server_info,
5850                                           smbd_messaging_context(),
5851                                           printer->sharename,
5852                                           SPOOL_DSSPOOLER_KEY,
5853                                           SPOOL_REG_PRINTSTARTTIME,
5854                                           REG_DWORD,
5855                                           buffer.data,
5856                                           buffer.length);
5857         }
5858
5859         if (force_update || printer->untiltime != old_printer->untiltime) {
5860                 buffer = data_blob_talloc(mem_ctx, NULL, 4);
5861                 SIVAL(buffer.data, 0, printer->untiltime);
5862                 winreg_set_printer_dataex(mem_ctx,
5863                                           server_info,
5864                                           smbd_messaging_context(),
5865                                           printer->sharename,
5866                                           SPOOL_DSSPOOLER_KEY,
5867                                           SPOOL_REG_PRINTENDTIME,
5868                                           REG_DWORD,
5869                                           buffer.data,
5870                                           buffer.length);
5871         }
5872
5873         if (force_update || printer->priority != old_printer->priority) {
5874                 buffer = data_blob_talloc(mem_ctx, NULL, 4);
5875                 SIVAL(buffer.data, 0, printer->priority);
5876                 winreg_set_printer_dataex(mem_ctx,
5877                                           server_info,
5878                                           smbd_messaging_context(),
5879                                           printer->sharename,
5880                                           SPOOL_DSSPOOLER_KEY,
5881                                           SPOOL_REG_PRIORITY,
5882                                           REG_DWORD,
5883                                           buffer.data,
5884                                           buffer.length);
5885         }
5886
5887         if (force_update || printer->attributes != old_printer->attributes) {
5888                 buffer = data_blob_talloc(mem_ctx, NULL, 4);
5889                 SIVAL(buffer.data, 0, (printer->attributes &
5890                                        PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS));
5891                 winreg_set_printer_dataex(mem_ctx,
5892                                           server_info,
5893                                           smbd_messaging_context(),
5894                                           printer->sharename,
5895                                           SPOOL_DSSPOOLER_KEY,
5896                                           SPOOL_REG_PRINTKEEPPRINTEDJOBS,
5897                                           REG_DWORD,
5898                                           buffer.data,
5899                                           buffer.length);
5900
5901                 switch (printer->attributes & 0x3) {
5902                         case 0:
5903                                 spooling = SPOOL_REGVAL_PRINTWHILESPOOLING;
5904                                 break;
5905                         case 1:
5906                                 spooling = SPOOL_REGVAL_PRINTAFTERSPOOLED;
5907                                 break;
5908                         case 2:
5909                                 spooling = SPOOL_REGVAL_PRINTDIRECT;
5910                                 break;
5911                         default:
5912                                 spooling = "unknown";
5913                 }
5914                 push_reg_sz(mem_ctx, &buffer, spooling);
5915                 winreg_set_printer_dataex(mem_ctx,
5916                                           server_info,
5917                                           smbd_messaging_context(),
5918                                           printer->sharename,
5919                                           SPOOL_DSSPOOLER_KEY,
5920                                           SPOOL_REG_PRINTSPOOLING,
5921                                           REG_SZ,
5922                                           buffer.data,
5923                                           buffer.length);
5924         }
5925
5926         push_reg_sz(mem_ctx, &buffer, global_myname());
5927         winreg_set_printer_dataex(mem_ctx,
5928                                   server_info,
5929                                   smbd_messaging_context(),
5930                                   printer->sharename,
5931                                   SPOOL_DSSPOOLER_KEY,
5932                                   SPOOL_REG_SHORTSERVERNAME,
5933                                   REG_SZ,
5934                                   buffer.data,
5935                                   buffer.length);
5936
5937         dnsdomname = get_mydnsfullname();
5938         if (dnsdomname != NULL && dnsdomname[0] != '\0') {
5939                 longname = talloc_strdup(mem_ctx, dnsdomname);
5940         } else {
5941                 longname = talloc_strdup(mem_ctx, global_myname());
5942         }
5943         if (longname == NULL) {
5944                 result = WERR_NOMEM;
5945                 goto done;
5946         }
5947
5948         push_reg_sz(mem_ctx, &buffer, longname);
5949         winreg_set_printer_dataex(mem_ctx,
5950                                   server_info,
5951                                   smbd_messaging_context(),
5952                                   printer->sharename,
5953                                   SPOOL_DSSPOOLER_KEY,
5954                                   SPOOL_REG_SERVERNAME,
5955                                   REG_SZ,
5956                                   buffer.data,
5957                                   buffer.length);
5958
5959         uncname = talloc_asprintf(mem_ctx, "\\\\%s\\%s",
5960                                   global_myname(), printer->sharename);
5961         push_reg_sz(mem_ctx, &buffer, uncname);
5962         winreg_set_printer_dataex(mem_ctx,
5963                                   server_info,
5964                                   smbd_messaging_context(),
5965                                   printer->sharename,
5966                                   SPOOL_DSSPOOLER_KEY,
5967                                   SPOOL_REG_UNCNAME,
5968                                   REG_SZ,
5969                                   buffer.data,
5970                                   buffer.length);
5971
5972 done:
5973         return result;
5974 }
5975
5976 /********************************************************************
5977  * Called by spoolss_api_setprinter
5978  * when updating a printer description.
5979  ********************************************************************/
5980
5981 static WERROR update_printer(struct pipes_struct *p,
5982                              struct policy_handle *handle,
5983                              struct spoolss_SetPrinterInfoCtr *info_ctr,
5984                              struct spoolss_DeviceMode *devmode)
5985 {
5986         uint32_t printer_mask = SPOOLSS_PRINTER_INFO_ALL;
5987         struct spoolss_SetPrinterInfo2 *printer = info_ctr->info.info2;
5988         struct spoolss_PrinterInfo2 *old_printer;
5989         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5990         const char *servername = NULL;
5991         int snum;
5992         WERROR result = WERR_OK;
5993         TALLOC_CTX *tmp_ctx;
5994
5995         DEBUG(8,("update_printer\n"));
5996
5997         tmp_ctx = talloc_new(p->mem_ctx);
5998         if (tmp_ctx == NULL) {
5999                 return WERR_NOMEM;
6000         }
6001
6002         if (!Printer) {
6003                 result = WERR_BADFID;
6004                 goto done;
6005         }
6006
6007         if (!get_printer_snum(p, handle, &snum, NULL)) {
6008                 result = WERR_BADFID;
6009                 goto done;
6010         }
6011
6012         if (Printer != NULL || Printer->servername != NULL) {
6013                 servername = Printer->servername;
6014         }
6015
6016         result = winreg_get_printer(tmp_ctx,
6017                                     p->server_info,
6018                                     p->msg_ctx,
6019                                     servername,
6020                                     lp_const_servicename(snum),
6021                                     &old_printer);
6022         if (!W_ERROR_IS_OK(result)) {
6023                 result = WERR_BADFID;
6024                 goto done;
6025         }
6026
6027         /* Do sanity check on the requested changes for Samba */
6028         if (!check_printer_ok(tmp_ctx, printer, snum)) {
6029                 result = WERR_INVALID_PARAM;
6030                 goto done;
6031         }
6032
6033         /* FIXME!!! If the driver has changed we really should verify that
6034            it is installed before doing much else   --jerry */
6035
6036         /* Check calling user has permission to update printer description */
6037         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
6038                 DEBUG(3, ("update_printer: printer property change denied by handle\n"));
6039                 result = WERR_ACCESS_DENIED;
6040                 goto done;
6041         }
6042
6043         /* Call addprinter hook */
6044         /* Check changes to see if this is really needed */
6045
6046         if (*lp_addprinter_cmd() &&
6047                         (!strequal(printer->drivername, old_printer->drivername) ||
6048                          !strequal(printer->comment, old_printer->comment) ||
6049                          !strequal(printer->portname, old_printer->portname) ||
6050                          !strequal(printer->location, old_printer->location)) )
6051         {
6052                 /* add_printer_hook() will call reload_services() */
6053                 if (!add_printer_hook(tmp_ctx, p->server_info->ptok,
6054                                       printer, p->client_address,
6055                                       p->msg_ctx)) {
6056                         result = WERR_ACCESS_DENIED;
6057                         goto done;
6058                 }
6059         }
6060
6061         update_dsspooler(tmp_ctx,
6062                          p->server_info,
6063                          snum,
6064                          printer,
6065                          old_printer);
6066
6067         printer_mask &= ~SPOOLSS_PRINTER_INFO_SECDESC;
6068
6069         if (devmode == NULL) {
6070                 printer_mask &= ~SPOOLSS_PRINTER_INFO_DEVMODE;
6071         }
6072         result = winreg_update_printer(tmp_ctx,
6073                                        p->server_info,
6074                                        p->msg_ctx,
6075                                        printer->sharename,
6076                                        printer_mask,
6077                                        printer,
6078                                        devmode,
6079                                        NULL);
6080
6081 done:
6082         talloc_free(tmp_ctx);
6083
6084         return result;
6085 }
6086
6087 /****************************************************************************
6088 ****************************************************************************/
6089 static WERROR publish_or_unpublish_printer(struct pipes_struct *p,
6090                                            struct policy_handle *handle,
6091                                            struct spoolss_SetPrinterInfo7 *info7)
6092 {
6093 #ifdef HAVE_ADS
6094         struct spoolss_PrinterInfo2 *pinfo2 = NULL;
6095         WERROR result;
6096         int snum;
6097         Printer_entry *Printer;
6098
6099         if ( lp_security() != SEC_ADS ) {
6100                 return WERR_UNKNOWN_LEVEL;
6101         }
6102
6103         Printer = find_printer_index_by_hnd(p, handle);
6104
6105         DEBUG(5,("publish_or_unpublish_printer, action = %d\n",info7->action));
6106
6107         if (!Printer)
6108                 return WERR_BADFID;
6109
6110         if (!get_printer_snum(p, handle, &snum, NULL))
6111                 return WERR_BADFID;
6112
6113         result = winreg_get_printer(p->mem_ctx, p->server_info, p->msg_ctx,
6114                                     Printer->servername,
6115                                     lp_servicename(snum), &pinfo2);
6116         if (!W_ERROR_IS_OK(result)) {
6117                 return WERR_BADFID;
6118         }
6119
6120         nt_printer_publish(pinfo2, p->server_info, pinfo2, info7->action);
6121
6122         TALLOC_FREE(pinfo2);
6123         return WERR_OK;
6124 #else
6125         return WERR_UNKNOWN_LEVEL;
6126 #endif
6127 }
6128
6129 /********************************************************************
6130  ********************************************************************/
6131
6132 static WERROR update_printer_devmode(struct pipes_struct *p,
6133                                      struct policy_handle *handle,
6134                                      struct spoolss_DeviceMode *devmode)
6135 {
6136         int snum;
6137         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
6138         uint32_t info2_mask = SPOOLSS_PRINTER_INFO_DEVMODE;
6139
6140         DEBUG(8,("update_printer_devmode\n"));
6141
6142         if (!Printer) {
6143                 return WERR_BADFID;
6144         }
6145
6146         if (!get_printer_snum(p, handle, &snum, NULL)) {
6147                 return WERR_BADFID;
6148         }
6149
6150         /* Check calling user has permission to update printer description */
6151         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
6152                 DEBUG(3, ("update_printer: printer property change denied by handle\n"));
6153                 return WERR_ACCESS_DENIED;
6154         }
6155
6156         return winreg_update_printer(p->mem_ctx,
6157                                      p->server_info,
6158                                      p->msg_ctx,
6159                                      lp_const_servicename(snum),
6160                                      info2_mask,
6161                                      NULL,
6162                                      devmode,
6163                                      NULL);
6164 }
6165
6166
6167 /****************************************************************
6168  _spoolss_SetPrinter
6169 ****************************************************************/
6170
6171 WERROR _spoolss_SetPrinter(struct pipes_struct *p,
6172                            struct spoolss_SetPrinter *r)
6173 {
6174         WERROR result;
6175
6176         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
6177
6178         if (!Printer) {
6179                 DEBUG(2,("_spoolss_SetPrinter: Invalid handle (%s:%u:%u)\n",
6180                         OUR_HANDLE(r->in.handle)));
6181                 return WERR_BADFID;
6182         }
6183
6184         /* check the level */
6185         switch (r->in.info_ctr->level) {
6186                 case 0:
6187                         return control_printer(r->in.handle, r->in.command, p);
6188                 case 2:
6189                         result = update_printer(p, r->in.handle,
6190                                                 r->in.info_ctr,
6191                                                 r->in.devmode_ctr->devmode);
6192                         if (!W_ERROR_IS_OK(result))
6193                                 return result;
6194                         if (r->in.secdesc_ctr->sd)
6195                                 result = update_printer_sec(r->in.handle, p,
6196                                                             r->in.secdesc_ctr);
6197                         return result;
6198                 case 3:
6199                         return update_printer_sec(r->in.handle, p,
6200                                                   r->in.secdesc_ctr);
6201                 case 7:
6202                         return publish_or_unpublish_printer(p, r->in.handle,
6203                                                             r->in.info_ctr->info.info7);
6204                 case 8:
6205                         return update_printer_devmode(p, r->in.handle,
6206                                                       r->in.devmode_ctr->devmode);
6207                 default:
6208                         return WERR_UNKNOWN_LEVEL;
6209         }
6210 }
6211
6212 /****************************************************************
6213  _spoolss_FindClosePrinterNotify
6214 ****************************************************************/
6215
6216 WERROR _spoolss_FindClosePrinterNotify(struct pipes_struct *p,
6217                                        struct spoolss_FindClosePrinterNotify *r)
6218 {
6219         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
6220
6221         if (!Printer) {
6222                 DEBUG(2,("_spoolss_FindClosePrinterNotify: "
6223                         "Invalid handle (%s:%u:%u)\n", OUR_HANDLE(r->in.handle)));
6224                 return WERR_BADFID;
6225         }
6226
6227         if (Printer->notify.client_connected == true) {
6228                 int snum = -1;
6229
6230                 if ( Printer->printer_type == SPLHND_SERVER)
6231                         snum = -1;
6232                 else if ( (Printer->printer_type == SPLHND_PRINTER) &&
6233                                 !get_printer_snum(p, r->in.handle, &snum, NULL) )
6234                         return WERR_BADFID;
6235
6236                 srv_spoolss_replycloseprinter(
6237                         snum, &Printer->notify.client_hnd, p->msg_ctx);
6238         }
6239
6240         Printer->notify.flags=0;
6241         Printer->notify.options=0;
6242         Printer->notify.localmachine[0]='\0';
6243         Printer->notify.printerlocal=0;
6244         TALLOC_FREE(Printer->notify.option);
6245         Printer->notify.client_connected = false;
6246
6247         return WERR_OK;
6248 }
6249
6250 /****************************************************************
6251  _spoolss_AddJob
6252 ****************************************************************/
6253
6254 WERROR _spoolss_AddJob(struct pipes_struct *p,
6255                        struct spoolss_AddJob *r)
6256 {
6257         if (!r->in.buffer && (r->in.offered != 0)) {
6258                 return WERR_INVALID_PARAM;
6259         }
6260
6261         /* this is what a NT server returns for AddJob. AddJob must fail on
6262          * non-local printers */
6263
6264         if (r->in.level != 1) {
6265                 return WERR_UNKNOWN_LEVEL;
6266         }
6267
6268         return WERR_INVALID_PARAM;
6269 }
6270
6271 /****************************************************************************
6272 fill_job_info1
6273 ****************************************************************************/
6274
6275 static WERROR fill_job_info1(TALLOC_CTX *mem_ctx,
6276                              struct spoolss_JobInfo1 *r,
6277                              const print_queue_struct *queue,
6278                              int position, int snum,
6279                              struct spoolss_PrinterInfo2 *pinfo2)
6280 {
6281         struct tm *t;
6282
6283         t = gmtime(&queue->time);
6284
6285         r->job_id               = queue->job;
6286
6287         r->printer_name         = talloc_strdup(mem_ctx, lp_servicename(snum));
6288         W_ERROR_HAVE_NO_MEMORY(r->printer_name);
6289         r->server_name          = talloc_strdup(mem_ctx, pinfo2->servername);
6290         W_ERROR_HAVE_NO_MEMORY(r->server_name);
6291         r->user_name            = talloc_strdup(mem_ctx, queue->fs_user);
6292         W_ERROR_HAVE_NO_MEMORY(r->user_name);
6293         r->document_name        = talloc_strdup(mem_ctx, queue->fs_file);
6294         W_ERROR_HAVE_NO_MEMORY(r->document_name);
6295         r->data_type            = talloc_strdup(mem_ctx, "RAW");
6296         W_ERROR_HAVE_NO_MEMORY(r->data_type);
6297         r->text_status          = talloc_strdup(mem_ctx, "");
6298         W_ERROR_HAVE_NO_MEMORY(r->text_status);
6299
6300         r->status               = nt_printj_status(queue->status);
6301         r->priority             = queue->priority;
6302         r->position             = position;
6303         r->total_pages          = queue->page_count;
6304         r->pages_printed        = 0; /* ??? */
6305
6306         init_systemtime(&r->submitted, t);
6307
6308         return WERR_OK;
6309 }
6310
6311 /****************************************************************************
6312 fill_job_info2
6313 ****************************************************************************/
6314
6315 static WERROR fill_job_info2(TALLOC_CTX *mem_ctx,
6316                              struct spoolss_JobInfo2 *r,
6317                              const print_queue_struct *queue,
6318                              int position, int snum,
6319                              struct spoolss_PrinterInfo2 *pinfo2,
6320                              struct spoolss_DeviceMode *devmode)
6321 {
6322         struct tm *t;
6323
6324         t = gmtime(&queue->time);
6325
6326         r->job_id               = queue->job;
6327
6328         r->printer_name         = talloc_strdup(mem_ctx, lp_servicename(snum));
6329         W_ERROR_HAVE_NO_MEMORY(r->printer_name);
6330         r->server_name          = talloc_strdup(mem_ctx, pinfo2->servername);
6331         W_ERROR_HAVE_NO_MEMORY(r->server_name);
6332         r->user_name            = talloc_strdup(mem_ctx, queue->fs_user);
6333         W_ERROR_HAVE_NO_MEMORY(r->user_name);
6334         r->document_name        = talloc_strdup(mem_ctx, queue->fs_file);
6335         W_ERROR_HAVE_NO_MEMORY(r->document_name);
6336         r->notify_name          = talloc_strdup(mem_ctx, queue->fs_user);
6337         W_ERROR_HAVE_NO_MEMORY(r->notify_name);
6338         r->data_type            = talloc_strdup(mem_ctx, "RAW");
6339         W_ERROR_HAVE_NO_MEMORY(r->data_type);
6340         r->print_processor      = talloc_strdup(mem_ctx, "winprint");
6341         W_ERROR_HAVE_NO_MEMORY(r->print_processor);
6342         r->parameters           = talloc_strdup(mem_ctx, "");
6343         W_ERROR_HAVE_NO_MEMORY(r->parameters);
6344         r->driver_name          = talloc_strdup(mem_ctx, pinfo2->drivername);
6345         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
6346
6347         r->devmode              = devmode;
6348
6349         r->text_status          = talloc_strdup(mem_ctx, "");
6350         W_ERROR_HAVE_NO_MEMORY(r->text_status);
6351
6352         r->secdesc              = NULL;
6353
6354         r->status               = nt_printj_status(queue->status);
6355         r->priority             = queue->priority;
6356         r->position             = position;
6357         r->start_time           = 0;
6358         r->until_time           = 0;
6359         r->total_pages          = queue->page_count;
6360         r->size                 = queue->size;
6361         init_systemtime(&r->submitted, t);
6362         r->time                 = 0;
6363         r->pages_printed        = 0; /* ??? */
6364
6365         return WERR_OK;
6366 }
6367
6368 /****************************************************************************
6369 fill_job_info3
6370 ****************************************************************************/
6371
6372 static WERROR fill_job_info3(TALLOC_CTX *mem_ctx,
6373                              struct spoolss_JobInfo3 *r,
6374                              const print_queue_struct *queue,
6375                              const print_queue_struct *next_queue,
6376                              int position, int snum,
6377                              struct spoolss_PrinterInfo2 *pinfo2)
6378 {
6379         r->job_id               = queue->job;
6380         r->next_job_id          = 0;
6381         if (next_queue) {
6382                 r->next_job_id  = next_queue->job;
6383         }
6384         r->reserved             = 0;
6385
6386         return WERR_OK;
6387 }
6388
6389 /****************************************************************************
6390  Enumjobs at level 1.
6391 ****************************************************************************/
6392
6393 static WERROR enumjobs_level1(TALLOC_CTX *mem_ctx,
6394                               const print_queue_struct *queue,
6395                               uint32_t num_queues, int snum,
6396                               struct spoolss_PrinterInfo2 *pinfo2,
6397                               union spoolss_JobInfo **info_p,
6398                               uint32_t *count)
6399 {
6400         union spoolss_JobInfo *info;
6401         int i;
6402         WERROR result = WERR_OK;
6403
6404         info = TALLOC_ARRAY(mem_ctx, union spoolss_JobInfo, num_queues);
6405         W_ERROR_HAVE_NO_MEMORY(info);
6406
6407         *count = num_queues;
6408
6409         for (i=0; i<*count; i++) {
6410                 result = fill_job_info1(info,
6411                                         &info[i].info1,
6412                                         &queue[i],
6413                                         i,
6414                                         snum,
6415                                         pinfo2);
6416                 if (!W_ERROR_IS_OK(result)) {
6417                         goto out;
6418                 }
6419         }
6420
6421  out:
6422         if (!W_ERROR_IS_OK(result)) {
6423                 TALLOC_FREE(info);
6424                 *count = 0;
6425                 return result;
6426         }
6427
6428         *info_p = info;
6429
6430         return WERR_OK;
6431 }
6432
6433 /****************************************************************************
6434  Enumjobs at level 2.
6435 ****************************************************************************/
6436
6437 static WERROR enumjobs_level2(TALLOC_CTX *mem_ctx,
6438                               const print_queue_struct *queue,
6439                               uint32_t num_queues, int snum,
6440                               struct spoolss_PrinterInfo2 *pinfo2,
6441                               union spoolss_JobInfo **info_p,
6442                               uint32_t *count)
6443 {
6444         union spoolss_JobInfo *info;
6445         int i;
6446         WERROR result = WERR_OK;
6447
6448         info = TALLOC_ARRAY(mem_ctx, union spoolss_JobInfo, num_queues);
6449         W_ERROR_HAVE_NO_MEMORY(info);
6450
6451         *count = num_queues;
6452
6453         for (i=0; i<*count; i++) {
6454                 struct spoolss_DeviceMode *devmode;
6455
6456                 result = spoolss_create_default_devmode(info,
6457                                                         pinfo2->printername,
6458                                                         &devmode);
6459                 if (!W_ERROR_IS_OK(result)) {
6460                         DEBUG(3, ("Can't proceed w/o a devmode!"));
6461                         goto out;
6462                 }
6463
6464                 result = fill_job_info2(info,
6465                                         &info[i].info2,
6466                                         &queue[i],
6467                                         i,
6468                                         snum,
6469                                         pinfo2,
6470                                         devmode);
6471                 if (!W_ERROR_IS_OK(result)) {
6472                         goto out;
6473                 }
6474         }
6475
6476  out:
6477         if (!W_ERROR_IS_OK(result)) {
6478                 TALLOC_FREE(info);
6479                 *count = 0;
6480                 return result;
6481         }
6482
6483         *info_p = info;
6484
6485         return WERR_OK;
6486 }
6487
6488 /****************************************************************************
6489  Enumjobs at level 3.
6490 ****************************************************************************/
6491
6492 static WERROR enumjobs_level3(TALLOC_CTX *mem_ctx,
6493                               const print_queue_struct *queue,
6494                               uint32_t num_queues, int snum,
6495                               struct spoolss_PrinterInfo2 *pinfo2,
6496                               union spoolss_JobInfo **info_p,
6497                               uint32_t *count)
6498 {
6499         union spoolss_JobInfo *info;
6500         int i;
6501         WERROR result = WERR_OK;
6502
6503         info = TALLOC_ARRAY(mem_ctx, union spoolss_JobInfo, num_queues);
6504         W_ERROR_HAVE_NO_MEMORY(info);
6505
6506         *count = num_queues;
6507
6508         for (i=0; i<*count; i++) {
6509                 const print_queue_struct *next_queue = NULL;
6510
6511                 if (i+1 < *count) {
6512                         next_queue = &queue[i+1];
6513                 }
6514
6515                 result = fill_job_info3(info,
6516                                         &info[i].info3,
6517                                         &queue[i],
6518                                         next_queue,
6519                                         i,
6520                                         snum,
6521                                         pinfo2);
6522                 if (!W_ERROR_IS_OK(result)) {
6523                         goto out;
6524                 }
6525         }
6526
6527  out:
6528         if (!W_ERROR_IS_OK(result)) {
6529                 TALLOC_FREE(info);
6530                 *count = 0;
6531                 return result;
6532         }
6533
6534         *info_p = info;
6535
6536         return WERR_OK;
6537 }
6538
6539 /****************************************************************
6540  _spoolss_EnumJobs
6541 ****************************************************************/
6542
6543 WERROR _spoolss_EnumJobs(struct pipes_struct *p,
6544                          struct spoolss_EnumJobs *r)
6545 {
6546         WERROR result;
6547         struct spoolss_PrinterInfo2 *pinfo2 = NULL;
6548         int snum;
6549         print_status_struct prt_status;
6550         print_queue_struct *queue = NULL;
6551         uint32_t count;
6552
6553         /* that's an [in out] buffer */
6554
6555         if (!r->in.buffer && (r->in.offered != 0)) {
6556                 return WERR_INVALID_PARAM;
6557         }
6558
6559         DEBUG(4,("_spoolss_EnumJobs\n"));
6560
6561         *r->out.needed = 0;
6562         *r->out.count = 0;
6563         *r->out.info = NULL;
6564
6565         /* lookup the printer snum and tdb entry */
6566
6567         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
6568                 return WERR_BADFID;
6569         }
6570
6571         result = winreg_get_printer(p->mem_ctx, p->server_info, p->msg_ctx,
6572                                     NULL, lp_servicename(snum), &pinfo2);
6573         if (!W_ERROR_IS_OK(result)) {
6574                 return result;
6575         }
6576
6577         count = print_queue_status(snum, &queue, &prt_status);
6578         DEBUGADD(4,("count:[%d], status:[%d], [%s]\n",
6579                 count, prt_status.status, prt_status.message));
6580
6581         if (count == 0) {
6582                 SAFE_FREE(queue);
6583                 TALLOC_FREE(pinfo2);
6584                 return WERR_OK;
6585         }
6586
6587         switch (r->in.level) {
6588         case 1:
6589                 result = enumjobs_level1(p->mem_ctx, queue, count, snum,
6590                                          pinfo2, r->out.info, r->out.count);
6591                 break;
6592         case 2:
6593                 result = enumjobs_level2(p->mem_ctx, queue, count, snum,
6594                                          pinfo2, r->out.info, r->out.count);
6595                 break;
6596         case 3:
6597                 result = enumjobs_level3(p->mem_ctx, queue, count, snum,
6598                                          pinfo2, r->out.info, r->out.count);
6599                 break;
6600         default:
6601                 result = WERR_UNKNOWN_LEVEL;
6602                 break;
6603         }
6604
6605         SAFE_FREE(queue);
6606         TALLOC_FREE(pinfo2);
6607
6608         if (!W_ERROR_IS_OK(result)) {
6609                 return result;
6610         }
6611
6612         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
6613                                                      spoolss_EnumJobs,
6614                                                      *r->out.info, r->in.level,
6615                                                      *r->out.count);
6616         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
6617         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
6618
6619         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
6620 }
6621
6622 /****************************************************************
6623  _spoolss_ScheduleJob
6624 ****************************************************************/
6625
6626 WERROR _spoolss_ScheduleJob(struct pipes_struct *p,
6627                             struct spoolss_ScheduleJob *r)
6628 {
6629         return WERR_OK;
6630 }
6631
6632 /****************************************************************
6633 ****************************************************************/
6634
6635 static WERROR spoolss_setjob_1(TALLOC_CTX *mem_ctx,
6636                                const char *printer_name,
6637                                uint32_t job_id,
6638                                struct spoolss_SetJobInfo1 *r)
6639 {
6640         char *old_doc_name;
6641
6642         if (!print_job_get_name(mem_ctx, printer_name, job_id, &old_doc_name)) {
6643                 return WERR_BADFID;
6644         }
6645
6646         if (strequal(old_doc_name, r->document_name)) {
6647                 return WERR_OK;
6648         }
6649
6650         if (!print_job_set_name(printer_name, job_id, r->document_name)) {
6651                 return WERR_BADFID;
6652         }
6653
6654         return WERR_OK;
6655 }
6656
6657 /****************************************************************
6658  _spoolss_SetJob
6659 ****************************************************************/
6660
6661 WERROR _spoolss_SetJob(struct pipes_struct *p,
6662                        struct spoolss_SetJob *r)
6663 {
6664         int snum;
6665         WERROR errcode = WERR_BADFUNC;
6666
6667         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
6668                 return WERR_BADFID;
6669         }
6670
6671         if (!print_job_exists(lp_const_servicename(snum), r->in.job_id)) {
6672                 return WERR_INVALID_PRINTER_NAME;
6673         }
6674
6675         switch (r->in.command) {
6676         case SPOOLSS_JOB_CONTROL_CANCEL:
6677         case SPOOLSS_JOB_CONTROL_DELETE:
6678                 errcode = print_job_delete(p->server_info,
6679                                            snum, r->in.job_id);
6680                 if (W_ERROR_EQUAL(errcode, WERR_PRINTER_HAS_JOBS_QUEUED)) {
6681                         errcode = WERR_OK;
6682                 }
6683                 break;
6684         case SPOOLSS_JOB_CONTROL_PAUSE:
6685                 if (print_job_pause(p->server_info, snum, r->in.job_id, &errcode)) {
6686                         errcode = WERR_OK;
6687                 }
6688                 break;
6689         case SPOOLSS_JOB_CONTROL_RESTART:
6690         case SPOOLSS_JOB_CONTROL_RESUME:
6691                 if (print_job_resume(p->server_info, snum, r->in.job_id, &errcode)) {
6692                         errcode = WERR_OK;
6693                 }
6694                 break;
6695         case 0:
6696                 errcode = WERR_OK;
6697                 break;
6698         default:
6699                 return WERR_UNKNOWN_LEVEL;
6700         }
6701
6702         if (!W_ERROR_IS_OK(errcode)) {
6703                 return errcode;
6704         }
6705
6706         if (r->in.ctr == NULL) {
6707                 return errcode;
6708         }
6709
6710         switch (r->in.ctr->level) {
6711         case 1:
6712                 errcode = spoolss_setjob_1(p->mem_ctx, lp_const_servicename(snum),
6713                                            r->in.job_id,
6714                                            r->in.ctr->info.info1);
6715                 break;
6716         case 2:
6717         case 3:
6718         case 4:
6719         default:
6720                 return WERR_UNKNOWN_LEVEL;
6721         }
6722
6723         return errcode;
6724 }
6725
6726 /****************************************************************************
6727  Enumerates all printer drivers by level and architecture.
6728 ****************************************************************************/
6729
6730 static WERROR enumprinterdrivers_level_by_architecture(TALLOC_CTX *mem_ctx,
6731                                                        struct auth_serversupplied_info *server_info,
6732                                                        const char *servername,
6733                                                        const char *architecture,
6734                                                        uint32_t level,
6735                                                        union spoolss_DriverInfo **info_p,
6736                                                        uint32_t *count_p)
6737 {
6738         int i;
6739         uint32_t version;
6740         struct spoolss_DriverInfo8 *driver;
6741         union spoolss_DriverInfo *info = NULL;
6742         uint32_t count = 0;
6743         WERROR result = WERR_OK;
6744         uint32_t num_drivers;
6745         const char **drivers;
6746
6747         *count_p = 0;
6748         *info_p = NULL;
6749
6750         for (version=0; version<DRIVER_MAX_VERSION; version++) {
6751                 result = winreg_get_driver_list(mem_ctx, server_info,
6752                                                 smbd_messaging_context(),
6753                                                 architecture, version,
6754                                                 &num_drivers, &drivers);
6755                 if (!W_ERROR_IS_OK(result)) {
6756                         goto out;
6757                 }
6758                 DEBUG(4, ("we have:[%d] drivers in environment"
6759                           " [%s] and version [%d]\n",
6760                           num_drivers, architecture, version));
6761
6762                 if (num_drivers != 0) {
6763                         info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
6764                                                     union spoolss_DriverInfo,
6765                                                     count + num_drivers);
6766                         if (!info) {
6767                                 DEBUG(0,("enumprinterdrivers_level_by_architecture: "
6768                                         "failed to enlarge driver info buffer!\n"));
6769                                 result = WERR_NOMEM;
6770                                 goto out;
6771                         }
6772                 }
6773
6774                 for (i = 0; i < num_drivers; i++) {
6775                         DEBUG(5, ("\tdriver: [%s]\n", drivers[i]));
6776
6777                         result = winreg_get_driver(mem_ctx, server_info,
6778                                                    smbd_messaging_context(),
6779                                                    architecture, drivers[i],
6780                                                    version, &driver);
6781                         if (!W_ERROR_IS_OK(result)) {
6782                                 goto out;
6783                         }
6784
6785                         switch (level) {
6786                         case 1:
6787                                 result = fill_printer_driver_info1(info, &info[count+i].info1,
6788                                                                    driver, servername);
6789                                 break;
6790                         case 2:
6791                                 result = fill_printer_driver_info2(info, &info[count+i].info2,
6792                                                                    driver, servername);
6793                                 break;
6794                         case 3:
6795                                 result = fill_printer_driver_info3(info, &info[count+i].info3,
6796                                                                    driver, servername);
6797                                 break;
6798                         case 4:
6799                                 result = fill_printer_driver_info4(info, &info[count+i].info4,
6800                                                                    driver, servername);
6801                                 break;
6802                         case 5:
6803                                 result = fill_printer_driver_info5(info, &info[count+i].info5,
6804                                                                    driver, servername);
6805                                 break;
6806                         case 6:
6807                                 result = fill_printer_driver_info6(info, &info[count+i].info6,
6808                                                                    driver, servername);
6809                                 break;
6810                         case 8:
6811                                 result = fill_printer_driver_info8(info, &info[count+i].info8,
6812                                                                    driver, servername);
6813                                 break;
6814                         default:
6815                                 result = WERR_UNKNOWN_LEVEL;
6816                                 break;
6817                         }
6818
6819                         TALLOC_FREE(driver);
6820
6821                         if (!W_ERROR_IS_OK(result)) {
6822                                 goto out;
6823                         }
6824                 }
6825
6826                 count += num_drivers;
6827                 TALLOC_FREE(drivers);
6828         }
6829
6830  out:
6831         TALLOC_FREE(drivers);
6832
6833         if (!W_ERROR_IS_OK(result)) {
6834                 TALLOC_FREE(info);
6835                 return result;
6836         }
6837
6838         *info_p = info;
6839         *count_p = count;
6840
6841         return WERR_OK;
6842 }
6843
6844 /****************************************************************************
6845  Enumerates all printer drivers by level.
6846 ****************************************************************************/
6847
6848 static WERROR enumprinterdrivers_level(TALLOC_CTX *mem_ctx,
6849                                        struct auth_serversupplied_info *server_info,
6850                                        const char *servername,
6851                                        const char *architecture,
6852                                        uint32_t level,
6853                                        union spoolss_DriverInfo **info_p,
6854                                        uint32_t *count_p)
6855 {
6856         uint32_t a,i;
6857         WERROR result = WERR_OK;
6858
6859         if (strequal(architecture, SPOOLSS_ARCHITECTURE_ALL)) {
6860
6861                 for (a=0; archi_table[a].long_archi != NULL; a++) {
6862
6863                         union spoolss_DriverInfo *info = NULL;
6864                         uint32_t count = 0;
6865
6866                         result = enumprinterdrivers_level_by_architecture(mem_ctx,
6867                                                                           server_info,
6868                                                                           servername,
6869                                                                           archi_table[a].long_archi,
6870                                                                           level,
6871                                                                           &info,
6872                                                                           &count);
6873                         if (!W_ERROR_IS_OK(result)) {
6874                                 continue;
6875                         }
6876
6877                         for (i=0; i < count; i++) {
6878                                 ADD_TO_ARRAY(mem_ctx, union spoolss_DriverInfo,
6879                                              info[i], info_p, count_p);
6880                         }
6881                 }
6882
6883                 return result;
6884         }
6885
6886         return enumprinterdrivers_level_by_architecture(mem_ctx,
6887                                                         server_info,
6888                                                         servername,
6889                                                         architecture,
6890                                                         level,
6891                                                         info_p,
6892                                                         count_p);
6893 }
6894
6895 /****************************************************************
6896  _spoolss_EnumPrinterDrivers
6897 ****************************************************************/
6898
6899 WERROR _spoolss_EnumPrinterDrivers(struct pipes_struct *p,
6900                                    struct spoolss_EnumPrinterDrivers *r)
6901 {
6902         const char *cservername;
6903         WERROR result;
6904
6905         /* that's an [in out] buffer */
6906
6907         if (!r->in.buffer && (r->in.offered != 0)) {
6908                 return WERR_INVALID_PARAM;
6909         }
6910
6911         DEBUG(4,("_spoolss_EnumPrinterDrivers\n"));
6912
6913         *r->out.needed = 0;
6914         *r->out.count = 0;
6915         *r->out.info = NULL;
6916
6917         cservername = canon_servername(r->in.server);
6918
6919         if (!is_myname_or_ipaddr(cservername)) {
6920                 return WERR_UNKNOWN_PRINTER_DRIVER;
6921         }
6922
6923         result = enumprinterdrivers_level(p->mem_ctx,
6924                                           p->server_info,
6925                                           cservername,
6926                                           r->in.environment,
6927                                           r->in.level,
6928                                           r->out.info,
6929                                           r->out.count);
6930         if (!W_ERROR_IS_OK(result)) {
6931                 return result;
6932         }
6933
6934         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
6935                                                      spoolss_EnumPrinterDrivers,
6936                                                      *r->out.info, r->in.level,
6937                                                      *r->out.count);
6938         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
6939         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
6940
6941         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
6942 }
6943
6944 /****************************************************************
6945  _spoolss_EnumForms
6946 ****************************************************************/
6947
6948 WERROR _spoolss_EnumForms(struct pipes_struct *p,
6949                           struct spoolss_EnumForms *r)
6950 {
6951         WERROR result;
6952
6953         *r->out.count = 0;
6954         *r->out.needed = 0;
6955         *r->out.info = NULL;
6956
6957         /* that's an [in out] buffer */
6958
6959         if (!r->in.buffer && (r->in.offered != 0) ) {
6960                 return WERR_INVALID_PARAM;
6961         }
6962
6963         DEBUG(4,("_spoolss_EnumForms\n"));
6964         DEBUGADD(5,("Offered buffer size [%d]\n", r->in.offered));
6965         DEBUGADD(5,("Info level [%d]\n",          r->in.level));
6966
6967         switch (r->in.level) {
6968         case 1:
6969                 result = winreg_printer_enumforms1(p->mem_ctx,
6970                                                    p->server_info,
6971                                                    p->msg_ctx,
6972                                                    r->out.count,
6973                                                    r->out.info);
6974                 break;
6975         default:
6976                 result = WERR_UNKNOWN_LEVEL;
6977                 break;
6978         }
6979
6980         if (!W_ERROR_IS_OK(result)) {
6981                 return result;
6982         }
6983
6984         if (*r->out.count == 0) {
6985                 return WERR_NO_MORE_ITEMS;
6986         }
6987
6988         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
6989                                                      spoolss_EnumForms,
6990                                                      *r->out.info, r->in.level,
6991                                                      *r->out.count);
6992         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
6993         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
6994
6995         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
6996 }
6997
6998 /****************************************************************
6999  _spoolss_GetForm
7000 ****************************************************************/
7001
7002 WERROR _spoolss_GetForm(struct pipes_struct *p,
7003                         struct spoolss_GetForm *r)
7004 {
7005         WERROR result;
7006
7007         /* that's an [in out] buffer */
7008
7009         if (!r->in.buffer && (r->in.offered != 0)) {
7010                 return WERR_INVALID_PARAM;
7011         }
7012
7013         DEBUG(4,("_spoolss_GetForm\n"));
7014         DEBUGADD(5,("Offered buffer size [%d]\n", r->in.offered));
7015         DEBUGADD(5,("Info level [%d]\n",          r->in.level));
7016
7017         switch (r->in.level) {
7018         case 1:
7019                 result = winreg_printer_getform1(p->mem_ctx,
7020                                                  p->server_info,
7021                                                  p->msg_ctx,
7022                                                  r->in.form_name,
7023                                                  &r->out.info->info1);
7024                 break;
7025         default:
7026                 result = WERR_UNKNOWN_LEVEL;
7027                 break;
7028         }
7029
7030         if (!W_ERROR_IS_OK(result)) {
7031                 TALLOC_FREE(r->out.info);
7032                 return result;
7033         }
7034
7035         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_FormInfo,
7036                                                r->out.info, r->in.level);
7037         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
7038
7039         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7040 }
7041
7042 /****************************************************************************
7043 ****************************************************************************/
7044
7045 static WERROR fill_port_1(TALLOC_CTX *mem_ctx,
7046                           struct spoolss_PortInfo1 *r,
7047                           const char *name)
7048 {
7049         r->port_name = talloc_strdup(mem_ctx, name);
7050         W_ERROR_HAVE_NO_MEMORY(r->port_name);
7051
7052         return WERR_OK;
7053 }
7054
7055 /****************************************************************************
7056  TODO: This probably needs distinguish between TCP/IP and Local ports
7057  somehow.
7058 ****************************************************************************/
7059
7060 static WERROR fill_port_2(TALLOC_CTX *mem_ctx,
7061                           struct spoolss_PortInfo2 *r,
7062                           const char *name)
7063 {
7064         r->port_name = talloc_strdup(mem_ctx, name);
7065         W_ERROR_HAVE_NO_MEMORY(r->port_name);
7066
7067         r->monitor_name = talloc_strdup(mem_ctx, "Local Monitor");
7068         W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
7069
7070         r->description = talloc_strdup(mem_ctx, SPL_LOCAL_PORT);
7071         W_ERROR_HAVE_NO_MEMORY(r->description);
7072
7073         r->port_type = SPOOLSS_PORT_TYPE_WRITE;
7074         r->reserved = 0;
7075
7076         return WERR_OK;
7077 }
7078
7079
7080 /****************************************************************************
7081  wrapper around the enumer ports command
7082 ****************************************************************************/
7083
7084 static WERROR enumports_hook(TALLOC_CTX *ctx, int *count, char ***lines)
7085 {
7086         char *cmd = lp_enumports_cmd();
7087         char **qlines = NULL;
7088         char *command = NULL;
7089         int numlines;
7090         int ret;
7091         int fd;
7092
7093         *count = 0;
7094         *lines = NULL;
7095
7096         /* if no hook then just fill in the default port */
7097
7098         if ( !*cmd ) {
7099                 if (!(qlines = TALLOC_ARRAY( NULL, char*, 2 ))) {
7100                         return WERR_NOMEM;
7101                 }
7102                 if (!(qlines[0] = talloc_strdup(qlines, SAMBA_PRINTER_PORT_NAME ))) {
7103                         TALLOC_FREE(qlines);
7104                         return WERR_NOMEM;
7105                 }
7106                 qlines[1] = NULL;
7107                 numlines = 1;
7108         }
7109         else {
7110                 /* we have a valid enumport command */
7111
7112                 command = talloc_asprintf(ctx, "%s \"%d\"", cmd, 1);
7113                 if (!command) {
7114                         return WERR_NOMEM;
7115                 }
7116
7117                 DEBUG(10,("Running [%s]\n", command));
7118                 ret = smbrun(command, &fd);
7119                 DEBUG(10,("Returned [%d]\n", ret));
7120                 TALLOC_FREE(command);
7121                 if (ret != 0) {
7122                         if (fd != -1) {
7123                                 close(fd);
7124                         }
7125                         return WERR_ACCESS_DENIED;
7126                 }
7127
7128                 numlines = 0;
7129                 qlines = fd_lines_load(fd, &numlines, 0, NULL);
7130                 DEBUGADD(10,("Lines returned = [%d]\n", numlines));
7131                 close(fd);
7132         }
7133
7134         *count = numlines;
7135         *lines = qlines;
7136
7137         return WERR_OK;
7138 }
7139
7140 /****************************************************************************
7141  enumports level 1.
7142 ****************************************************************************/
7143
7144 static WERROR enumports_level_1(TALLOC_CTX *mem_ctx,
7145                                 union spoolss_PortInfo **info_p,
7146                                 uint32_t *count)
7147 {
7148         union spoolss_PortInfo *info = NULL;
7149         int i=0;
7150         WERROR result = WERR_OK;
7151         char **qlines = NULL;
7152         int numlines = 0;
7153
7154         result = enumports_hook(talloc_tos(), &numlines, &qlines );
7155         if (!W_ERROR_IS_OK(result)) {
7156                 goto out;
7157         }
7158
7159         if (numlines) {
7160                 info = TALLOC_ARRAY(mem_ctx, union spoolss_PortInfo, numlines);
7161                 if (!info) {
7162                         DEBUG(10,("Returning WERR_NOMEM\n"));
7163                         result = WERR_NOMEM;
7164                         goto out;
7165                 }
7166
7167                 for (i=0; i<numlines; i++) {
7168                         DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
7169                         result = fill_port_1(info, &info[i].info1, qlines[i]);
7170                         if (!W_ERROR_IS_OK(result)) {
7171                                 goto out;
7172                         }
7173                 }
7174         }
7175         TALLOC_FREE(qlines);
7176
7177 out:
7178         if (!W_ERROR_IS_OK(result)) {
7179                 TALLOC_FREE(info);
7180                 TALLOC_FREE(qlines);
7181                 *count = 0;
7182                 *info_p = NULL;
7183                 return result;
7184         }
7185
7186         *info_p = info;
7187         *count = numlines;
7188
7189         return WERR_OK;
7190 }
7191
7192 /****************************************************************************
7193  enumports level 2.
7194 ****************************************************************************/
7195
7196 static WERROR enumports_level_2(TALLOC_CTX *mem_ctx,
7197                                 union spoolss_PortInfo **info_p,
7198                                 uint32_t *count)
7199 {
7200         union spoolss_PortInfo *info = NULL;
7201         int i=0;
7202         WERROR result = WERR_OK;
7203         char **qlines = NULL;
7204         int numlines = 0;
7205
7206         result = enumports_hook(talloc_tos(), &numlines, &qlines );
7207         if (!W_ERROR_IS_OK(result)) {
7208                 goto out;
7209         }
7210
7211         if (numlines) {
7212                 info = TALLOC_ARRAY(mem_ctx, union spoolss_PortInfo, numlines);
7213                 if (!info) {
7214                         DEBUG(10,("Returning WERR_NOMEM\n"));
7215                         result = WERR_NOMEM;
7216                         goto out;
7217                 }
7218
7219                 for (i=0; i<numlines; i++) {
7220                         DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
7221                         result = fill_port_2(info, &info[i].info2, qlines[i]);
7222                         if (!W_ERROR_IS_OK(result)) {
7223                                 goto out;
7224                         }
7225                 }
7226         }
7227         TALLOC_FREE(qlines);
7228
7229 out:
7230         if (!W_ERROR_IS_OK(result)) {
7231                 TALLOC_FREE(info);
7232                 TALLOC_FREE(qlines);
7233                 *count = 0;
7234                 *info_p = NULL;
7235                 return result;
7236         }
7237
7238         *info_p = info;
7239         *count = numlines;
7240
7241         return WERR_OK;
7242 }
7243
7244 /****************************************************************
7245  _spoolss_EnumPorts
7246 ****************************************************************/
7247
7248 WERROR _spoolss_EnumPorts(struct pipes_struct *p,
7249                           struct spoolss_EnumPorts *r)
7250 {
7251         WERROR result;
7252
7253         /* that's an [in out] buffer */
7254
7255         if (!r->in.buffer && (r->in.offered != 0)) {
7256                 return WERR_INVALID_PARAM;
7257         }
7258
7259         DEBUG(4,("_spoolss_EnumPorts\n"));
7260
7261         *r->out.count = 0;
7262         *r->out.needed = 0;
7263         *r->out.info = NULL;
7264
7265         switch (r->in.level) {
7266         case 1:
7267                 result = enumports_level_1(p->mem_ctx, r->out.info,
7268                                            r->out.count);
7269                 break;
7270         case 2:
7271                 result = enumports_level_2(p->mem_ctx, r->out.info,
7272                                            r->out.count);
7273                 break;
7274         default:
7275                 return WERR_UNKNOWN_LEVEL;
7276         }
7277
7278         if (!W_ERROR_IS_OK(result)) {
7279                 return result;
7280         }
7281
7282         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
7283                                                      spoolss_EnumPorts,
7284                                                      *r->out.info, r->in.level,
7285                                                      *r->out.count);
7286         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
7287         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
7288
7289         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7290 }
7291
7292 /****************************************************************************
7293 ****************************************************************************/
7294
7295 static WERROR spoolss_addprinterex_level_2(struct pipes_struct *p,
7296                                            const char *server,
7297                                            struct spoolss_SetPrinterInfoCtr *info_ctr,
7298                                            struct spoolss_DeviceMode *devmode,
7299                                            struct security_descriptor *secdesc,
7300                                            struct spoolss_UserLevelCtr *user_ctr,
7301                                            struct policy_handle *handle)
7302 {
7303         struct spoolss_SetPrinterInfo2 *info2 = info_ctr->info.info2;
7304         uint32_t info2_mask = SPOOLSS_PRINTER_INFO_ALL;
7305         int     snum;
7306         WERROR err = WERR_OK;
7307
7308         /* samba does not have a concept of local, non-shared printers yet, so
7309          * make sure we always setup sharename - gd */
7310         if ((info2->sharename == NULL || info2->sharename[0] == '\0') &&
7311             (info2->printername != NULL && info2->printername[0] != '\0')) {
7312                 DEBUG(5, ("spoolss_addprinterex_level_2: "
7313                         "no sharename has been set, setting printername %s as sharename\n",
7314                         info2->printername));
7315                 info2->sharename = info2->printername;
7316         }
7317
7318         /* check to see if the printer already exists */
7319         if ((snum = print_queue_snum(info2->sharename)) != -1) {
7320                 DEBUG(5, ("spoolss_addprinterex_level_2: Attempted to add a printer named [%s] when one already existed!\n",
7321                         info2->sharename));
7322                 return WERR_PRINTER_ALREADY_EXISTS;
7323         }
7324
7325         if (!lp_force_printername(GLOBAL_SECTION_SNUM)) {
7326                 if ((snum = print_queue_snum(info2->printername)) != -1) {
7327                         DEBUG(5, ("spoolss_addprinterex_level_2: Attempted to add a printer named [%s] when one already existed!\n",
7328                                 info2->printername));
7329                         return WERR_PRINTER_ALREADY_EXISTS;
7330                 }
7331         }
7332
7333         /* validate printer info struct */
7334         if (!info2->printername || strlen(info2->printername) == 0) {
7335                 return WERR_INVALID_PRINTER_NAME;
7336         }
7337         if (!info2->portname || strlen(info2->portname) == 0) {
7338                 return WERR_UNKNOWN_PORT;
7339         }
7340         if (!info2->drivername || strlen(info2->drivername) == 0) {
7341                 return WERR_UNKNOWN_PRINTER_DRIVER;
7342         }
7343         if (!info2->printprocessor || strlen(info2->printprocessor) == 0) {
7344                 return WERR_UNKNOWN_PRINTPROCESSOR;
7345         }
7346
7347         /* FIXME!!!  smbd should check to see if the driver is installed before
7348            trying to add a printer like this  --jerry */
7349
7350         if (*lp_addprinter_cmd() ) {
7351                 if ( !add_printer_hook(p->mem_ctx, p->server_info->ptok,
7352                                        info2, p->client_address,
7353                                        p->msg_ctx) ) {
7354                         return WERR_ACCESS_DENIED;
7355                 }
7356         } else {
7357                 DEBUG(0,("spoolss_addprinterex_level_2: add printer for printer %s called and no"
7358                         "smb.conf parameter \"addprinter command\" is defined. This"
7359                         "parameter must exist for this call to succeed\n",
7360                         info2->sharename ));
7361         }
7362
7363         if ((snum = print_queue_snum(info2->sharename)) == -1) {
7364                 return WERR_ACCESS_DENIED;
7365         }
7366
7367         /* you must be a printer admin to add a new printer */
7368         if (!print_access_check(p->server_info, snum, PRINTER_ACCESS_ADMINISTER)) {
7369                 return WERR_ACCESS_DENIED;
7370         }
7371
7372         /*
7373          * Do sanity check on the requested changes for Samba.
7374          */
7375
7376         if (!check_printer_ok(p->mem_ctx, info2, snum)) {
7377                 return WERR_INVALID_PARAM;
7378         }
7379
7380         if (devmode == NULL) {
7381                 info2_mask = ~SPOOLSS_PRINTER_INFO_DEVMODE;
7382         }
7383
7384         update_dsspooler(p->mem_ctx,
7385                          p->server_info,
7386                          0,
7387                          info2,
7388                          NULL);
7389
7390         err = winreg_update_printer(p->mem_ctx,
7391                                     p->server_info,
7392                                     p->msg_ctx,
7393                                     info2->sharename,
7394                                     info2_mask,
7395                                     info2,
7396                                     devmode,
7397                                     secdesc);
7398         if (!W_ERROR_IS_OK(err)) {
7399                 return err;
7400         }
7401
7402         if (!open_printer_hnd(p, handle, info2->printername, PRINTER_ACCESS_ADMINISTER)) {
7403                 /* Handle open failed - remove addition. */
7404                 ZERO_STRUCTP(handle);
7405                 return WERR_ACCESS_DENIED;
7406         }
7407
7408         return WERR_OK;
7409 }
7410
7411 /****************************************************************
7412  _spoolss_AddPrinterEx
7413 ****************************************************************/
7414
7415 WERROR _spoolss_AddPrinterEx(struct pipes_struct *p,
7416                              struct spoolss_AddPrinterEx *r)
7417 {
7418         switch (r->in.info_ctr->level) {
7419         case 1:
7420                 /* we don't handle yet */
7421                 /* but I know what to do ... */
7422                 return WERR_UNKNOWN_LEVEL;
7423         case 2:
7424                 return spoolss_addprinterex_level_2(p, r->in.server,
7425                                                     r->in.info_ctr,
7426                                                     r->in.devmode_ctr->devmode,
7427                                                     r->in.secdesc_ctr->sd,
7428                                                     r->in.userlevel_ctr,
7429                                                     r->out.handle);
7430         default:
7431                 return WERR_UNKNOWN_LEVEL;
7432         }
7433 }
7434
7435 /****************************************************************
7436  _spoolss_AddPrinter
7437 ****************************************************************/
7438
7439 WERROR _spoolss_AddPrinter(struct pipes_struct *p,
7440                            struct spoolss_AddPrinter *r)
7441 {
7442         struct spoolss_AddPrinterEx a;
7443         struct spoolss_UserLevelCtr userlevel_ctr;
7444
7445         ZERO_STRUCT(userlevel_ctr);
7446
7447         userlevel_ctr.level = 1;
7448
7449         a.in.server             = r->in.server;
7450         a.in.info_ctr           = r->in.info_ctr;
7451         a.in.devmode_ctr        = r->in.devmode_ctr;
7452         a.in.secdesc_ctr        = r->in.secdesc_ctr;
7453         a.in.userlevel_ctr      = &userlevel_ctr;
7454         a.out.handle            = r->out.handle;
7455
7456         return _spoolss_AddPrinterEx(p, &a);
7457 }
7458
7459 /****************************************************************
7460  _spoolss_AddPrinterDriverEx
7461 ****************************************************************/
7462
7463 WERROR _spoolss_AddPrinterDriverEx(struct pipes_struct *p,
7464                                    struct spoolss_AddPrinterDriverEx *r)
7465 {
7466         WERROR err = WERR_OK;
7467         const char *driver_name = NULL;
7468         uint32_t version;
7469         const char *fn;
7470
7471         switch (p->opnum) {
7472                 case NDR_SPOOLSS_ADDPRINTERDRIVER:
7473                         fn = "_spoolss_AddPrinterDriver";
7474                         break;
7475                 case NDR_SPOOLSS_ADDPRINTERDRIVEREX:
7476                         fn = "_spoolss_AddPrinterDriverEx";
7477                         break;
7478                 default:
7479                         return WERR_INVALID_PARAM;
7480         }
7481
7482         /*
7483          * we only support the semantics of AddPrinterDriver()
7484          * i.e. only copy files that are newer than existing ones
7485          */
7486
7487         if (r->in.flags == 0) {
7488                 return WERR_INVALID_PARAM;
7489         }
7490
7491         if (r->in.flags != APD_COPY_NEW_FILES) {
7492                 return WERR_ACCESS_DENIED;
7493         }
7494
7495         /* FIXME */
7496         if (r->in.info_ctr->level != 3 && r->in.info_ctr->level != 6) {
7497                 /* Clever hack from Martin Zielinski <mz@seh.de>
7498                  * to allow downgrade from level 8 (Vista).
7499                  */
7500                 DEBUG(0,("%s: level %d not yet implemented\n", fn,
7501                         r->in.info_ctr->level));
7502                 return WERR_UNKNOWN_LEVEL;
7503         }
7504
7505         DEBUG(5,("Cleaning driver's information\n"));
7506         err = clean_up_driver_struct(p->mem_ctx, p, r->in.info_ctr);
7507         if (!W_ERROR_IS_OK(err))
7508                 goto done;
7509
7510         DEBUG(5,("Moving driver to final destination\n"));
7511         if( !W_ERROR_IS_OK(err = move_driver_to_download_area(p, r->in.info_ctr,
7512                                                               &err)) ) {
7513                 goto done;
7514         }
7515
7516         err = winreg_add_driver(p->mem_ctx, p->server_info, p->msg_ctx,
7517                                 r->in.info_ctr, &driver_name, &version);
7518         if (!W_ERROR_IS_OK(err)) {
7519                 goto done;
7520         }
7521
7522         /*
7523          * I think this is where he DrvUpgradePrinter() hook would be
7524          * be called in a driver's interface DLL on a Windows NT 4.0/2k
7525          * server.  Right now, we just need to send ourselves a message
7526          * to update each printer bound to this driver.   --jerry
7527          */
7528
7529         if (!srv_spoolss_drv_upgrade_printer(driver_name, p->msg_ctx)) {
7530                 DEBUG(0,("%s: Failed to send message about upgrading driver [%s]!\n",
7531                         fn, driver_name));
7532         }
7533
7534 done:
7535         return err;
7536 }
7537
7538 /****************************************************************
7539  _spoolss_AddPrinterDriver
7540 ****************************************************************/
7541
7542 WERROR _spoolss_AddPrinterDriver(struct pipes_struct *p,
7543                                  struct spoolss_AddPrinterDriver *r)
7544 {
7545         struct spoolss_AddPrinterDriverEx a;
7546
7547         switch (r->in.info_ctr->level) {
7548         case 2:
7549         case 3:
7550         case 4:
7551         case 5:
7552                 break;
7553         default:
7554                 return WERR_UNKNOWN_LEVEL;
7555         }
7556
7557         a.in.servername         = r->in.servername;
7558         a.in.info_ctr           = r->in.info_ctr;
7559         a.in.flags              = APD_COPY_NEW_FILES;
7560
7561         return _spoolss_AddPrinterDriverEx(p, &a);
7562 }
7563
7564 /****************************************************************************
7565 ****************************************************************************/
7566
7567 struct _spoolss_paths {
7568         int type;
7569         const char *share;
7570         const char *dir;
7571 };
7572
7573 enum { SPOOLSS_DRIVER_PATH, SPOOLSS_PRTPROCS_PATH };
7574
7575 static const struct _spoolss_paths spoolss_paths[]= {
7576         { SPOOLSS_DRIVER_PATH,          "print$",       "DRIVERS" },
7577         { SPOOLSS_PRTPROCS_PATH,        "prnproc$",     "PRTPROCS" }
7578 };
7579
7580 static WERROR compose_spoolss_server_path(TALLOC_CTX *mem_ctx,
7581                                           const char *servername,
7582                                           const char *environment,
7583                                           int component,
7584                                           char **path)
7585 {
7586         const char *pservername = NULL;
7587         const char *long_archi = SPOOLSS_ARCHITECTURE_NT_X86;
7588         const char *short_archi;
7589
7590         *path = NULL;
7591
7592         /* environment may be empty */
7593         if (environment && strlen(environment)) {
7594                 long_archi = environment;
7595         }
7596
7597         /* servername may be empty */
7598         if (servername && strlen(servername)) {
7599                 pservername = canon_servername(servername);
7600
7601                 if (!is_myname_or_ipaddr(pservername)) {
7602                         return WERR_INVALID_PARAM;
7603                 }
7604         }
7605
7606         if (!(short_archi = get_short_archi(long_archi))) {
7607                 return WERR_INVALID_ENVIRONMENT;
7608         }
7609
7610         switch (component) {
7611         case SPOOLSS_PRTPROCS_PATH:
7612         case SPOOLSS_DRIVER_PATH:
7613                 if (pservername) {
7614                         *path = talloc_asprintf(mem_ctx,
7615                                         "\\\\%s\\%s\\%s",
7616                                         pservername,
7617                                         spoolss_paths[component].share,
7618                                         short_archi);
7619                 } else {
7620                         *path = talloc_asprintf(mem_ctx, "%s\\%s\\%s",
7621                                         SPOOLSS_DEFAULT_SERVER_PATH,
7622                                         spoolss_paths[component].dir,
7623                                         short_archi);
7624                 }
7625                 break;
7626         default:
7627                 return WERR_INVALID_PARAM;
7628         }
7629
7630         if (!*path) {
7631                 return WERR_NOMEM;
7632         }
7633
7634         return WERR_OK;
7635 }
7636
7637 /****************************************************************************
7638 ****************************************************************************/
7639
7640 static WERROR getprinterdriverdir_level_1(TALLOC_CTX *mem_ctx,
7641                                           const char *servername,
7642                                           const char *environment,
7643                                           struct spoolss_DriverDirectoryInfo1 *r)
7644 {
7645         WERROR werr;
7646         char *path = NULL;
7647
7648         werr = compose_spoolss_server_path(mem_ctx,
7649                                            servername,
7650                                            environment,
7651                                            SPOOLSS_DRIVER_PATH,
7652                                            &path);
7653         if (!W_ERROR_IS_OK(werr)) {
7654                 return werr;
7655         }
7656
7657         DEBUG(4,("printer driver directory: [%s]\n", path));
7658
7659         r->directory_name = path;
7660
7661         return WERR_OK;
7662 }
7663
7664 /****************************************************************
7665  _spoolss_GetPrinterDriverDirectory
7666 ****************************************************************/
7667
7668 WERROR _spoolss_GetPrinterDriverDirectory(struct pipes_struct *p,
7669                                           struct spoolss_GetPrinterDriverDirectory *r)
7670 {
7671         WERROR werror;
7672
7673         /* that's an [in out] buffer */
7674
7675         if (!r->in.buffer && (r->in.offered != 0)) {
7676                 return WERR_INVALID_PARAM;
7677         }
7678
7679         DEBUG(5,("_spoolss_GetPrinterDriverDirectory: level %d\n",
7680                 r->in.level));
7681
7682         *r->out.needed = 0;
7683
7684         /* r->in.level is ignored */
7685
7686         werror = getprinterdriverdir_level_1(p->mem_ctx,
7687                                              r->in.server,
7688                                              r->in.environment,
7689                                              &r->out.info->info1);
7690         if (!W_ERROR_IS_OK(werror)) {
7691                 TALLOC_FREE(r->out.info);
7692                 return werror;
7693         }
7694
7695         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_DriverDirectoryInfo,
7696                                                r->out.info, r->in.level);
7697         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
7698
7699         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7700 }
7701
7702 /****************************************************************
7703  _spoolss_EnumPrinterData
7704 ****************************************************************/
7705
7706 WERROR _spoolss_EnumPrinterData(struct pipes_struct *p,
7707                                 struct spoolss_EnumPrinterData *r)
7708 {
7709         WERROR result;
7710         struct spoolss_EnumPrinterDataEx r2;
7711         uint32_t count;
7712         struct spoolss_PrinterEnumValues *info, *val = NULL;
7713         uint32_t needed;
7714
7715         r2.in.handle    = r->in.handle;
7716         r2.in.key_name  = "PrinterDriverData";
7717         r2.in.offered   = 0;
7718         r2.out.count    = &count;
7719         r2.out.info     = &info;
7720         r2.out.needed   = &needed;
7721
7722         result = _spoolss_EnumPrinterDataEx(p, &r2);
7723         if (W_ERROR_EQUAL(result, WERR_MORE_DATA)) {
7724                 r2.in.offered = needed;
7725                 result = _spoolss_EnumPrinterDataEx(p, &r2);
7726         }
7727         if (!W_ERROR_IS_OK(result)) {
7728                 return result;
7729         }
7730
7731         /*
7732          * The NT machine wants to know the biggest size of value and data
7733          *
7734          * cf: MSDN EnumPrinterData remark section
7735          */
7736
7737         if (!r->in.value_offered && !r->in.data_offered) {
7738                 uint32_t biggest_valuesize = 0;
7739                 uint32_t biggest_datasize = 0;
7740                 int i, name_length;
7741
7742                 DEBUGADD(6,("Activating NT mega-hack to find sizes\n"));
7743
7744                 for (i=0; i<count; i++) {
7745
7746                         name_length = strlen(info[i].value_name);
7747                         if (strlen(info[i].value_name) > biggest_valuesize) {
7748                                 biggest_valuesize = name_length;
7749                         }
7750
7751                         if (info[i].data_length > biggest_datasize) {
7752                                 biggest_datasize = info[i].data_length;
7753                         }
7754
7755                         DEBUG(6,("current values: [%d], [%d]\n", biggest_valuesize,
7756                                 biggest_datasize));
7757                 }
7758
7759                 /* the value is an UNICODE string but real_value_size is the length
7760                    in bytes including the trailing 0 */
7761
7762                 *r->out.value_needed = 2 * (1 + biggest_valuesize);
7763                 *r->out.data_needed  = biggest_datasize;
7764
7765                 DEBUG(6,("final values: [%d], [%d]\n",
7766                         *r->out.value_needed, *r->out.data_needed));
7767
7768                 return WERR_OK;
7769         }
7770
7771         if (r->in.enum_index < count) {
7772                 val = &info[r->in.enum_index];
7773         }
7774
7775         if (val == NULL) {
7776                 /* out_value should default to "" or else NT4 has
7777                    problems unmarshalling the response */
7778
7779                 if (r->in.value_offered) {
7780                         *r->out.value_needed = 1;
7781                         r->out.value_name = talloc_strdup(r, "");
7782                         if (!r->out.value_name) {
7783                                 return WERR_NOMEM;
7784                         }
7785                 } else {
7786                         r->out.value_name = NULL;
7787                         *r->out.value_needed = 0;
7788                 }
7789
7790                 /* the data is counted in bytes */
7791
7792                 *r->out.data_needed = r->in.data_offered;
7793
7794                 result = WERR_NO_MORE_ITEMS;
7795         } else {
7796                 /*
7797                  * the value is:
7798                  * - counted in bytes in the request
7799                  * - counted in UNICODE chars in the max reply
7800                  * - counted in bytes in the real size
7801                  *
7802                  * take a pause *before* coding not *during* coding
7803                  */
7804
7805                 /* name */
7806                 if (r->in.value_offered) {
7807                         r->out.value_name = talloc_strdup(r, val->value_name);
7808                         if (!r->out.value_name) {
7809                                 return WERR_NOMEM;
7810                         }
7811                         *r->out.value_needed = val->value_name_len;
7812                 } else {
7813                         r->out.value_name = NULL;
7814                         *r->out.value_needed = 0;
7815                 }
7816
7817                 /* type */
7818
7819                 *r->out.type = val->type;
7820
7821                 /* data - counted in bytes */
7822
7823                 /*
7824                  * See the section "Dynamically Typed Query Parameters"
7825                  * in MS-RPRN.
7826                  */
7827
7828                 if (r->out.data && val->data && val->data->data &&
7829                                 val->data_length && r->in.data_offered) {
7830                         memcpy(r->out.data, val->data->data,
7831                                 MIN(val->data_length,r->in.data_offered));
7832                 }
7833
7834                 *r->out.data_needed = val->data_length;
7835
7836                 result = WERR_OK;
7837         }
7838
7839         return result;
7840 }
7841
7842 /****************************************************************
7843  _spoolss_SetPrinterData
7844 ****************************************************************/
7845
7846 WERROR _spoolss_SetPrinterData(struct pipes_struct *p,
7847                                struct spoolss_SetPrinterData *r)
7848 {
7849         struct spoolss_SetPrinterDataEx r2;
7850
7851         r2.in.handle            = r->in.handle;
7852         r2.in.key_name          = "PrinterDriverData";
7853         r2.in.value_name        = r->in.value_name;
7854         r2.in.type              = r->in.type;
7855         r2.in.data              = r->in.data;
7856         r2.in.offered           = r->in.offered;
7857
7858         return _spoolss_SetPrinterDataEx(p, &r2);
7859 }
7860
7861 /****************************************************************
7862  _spoolss_ResetPrinter
7863 ****************************************************************/
7864
7865 WERROR _spoolss_ResetPrinter(struct pipes_struct *p,
7866                              struct spoolss_ResetPrinter *r)
7867 {
7868         Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
7869         int             snum;
7870
7871         DEBUG(5,("_spoolss_ResetPrinter\n"));
7872
7873         /*
7874          * All we do is to check to see if the handle and queue is valid.
7875          * This call really doesn't mean anything to us because we only
7876          * support RAW printing.   --jerry
7877          */
7878
7879         if (!Printer) {
7880                 DEBUG(2,("_spoolss_ResetPrinter: Invalid handle (%s:%u:%u).\n",
7881                         OUR_HANDLE(r->in.handle)));
7882                 return WERR_BADFID;
7883         }
7884
7885         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
7886                 return WERR_BADFID;
7887
7888
7889         /* blindly return success */
7890         return WERR_OK;
7891 }
7892
7893 /****************************************************************
7894  _spoolss_DeletePrinterData
7895 ****************************************************************/
7896
7897 WERROR _spoolss_DeletePrinterData(struct pipes_struct *p,
7898                                   struct spoolss_DeletePrinterData *r)
7899 {
7900         struct spoolss_DeletePrinterDataEx r2;
7901
7902         r2.in.handle            = r->in.handle;
7903         r2.in.key_name          = "PrinterDriverData";
7904         r2.in.value_name        = r->in.value_name;
7905
7906         return _spoolss_DeletePrinterDataEx(p, &r2);
7907 }
7908
7909 /****************************************************************
7910  _spoolss_AddForm
7911 ****************************************************************/
7912
7913 WERROR _spoolss_AddForm(struct pipes_struct *p,
7914                         struct spoolss_AddForm *r)
7915 {
7916         struct spoolss_AddFormInfo1 *form = r->in.info.info1;
7917         int snum = -1;
7918         WERROR status = WERR_OK;
7919         SE_PRIV se_printop = SE_PRINT_OPERATOR;
7920
7921         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
7922
7923         DEBUG(5,("_spoolss_AddForm\n"));
7924
7925         if (!Printer) {
7926                 DEBUG(2,("_spoolss_AddForm: Invalid handle (%s:%u:%u).\n",
7927                         OUR_HANDLE(r->in.handle)));
7928                 return WERR_BADFID;
7929         }
7930
7931         /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
7932            and not a printer admin, then fail */
7933
7934         if ((p->server_info->utok.uid != sec_initial_uid()) &&
7935              !user_has_privileges(p->server_info->ptok, &se_printop) &&
7936              !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
7937                                           p->server_info->info3->base.domain.string,
7938                                           NULL,
7939                                           p->server_info->ptok,
7940                                           lp_printer_admin(snum))) {
7941                 DEBUG(2,("_spoolss_Addform: denied by insufficient permissions.\n"));
7942                 return WERR_ACCESS_DENIED;
7943         }
7944
7945         switch (form->flags) {
7946         case SPOOLSS_FORM_USER:
7947         case SPOOLSS_FORM_BUILTIN:
7948         case SPOOLSS_FORM_PRINTER:
7949                 break;
7950         default:
7951                 return WERR_INVALID_PARAM;
7952         }
7953
7954         status = winreg_printer_addform1(p->mem_ctx, p->server_info,
7955                                          p->msg_ctx, form);
7956         if (!W_ERROR_IS_OK(status)) {
7957                 return status;
7958         }
7959
7960         /*
7961          * ChangeID must always be set if this is a printer
7962          */
7963         if (Printer->printer_type == SPLHND_PRINTER) {
7964                 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
7965                         return WERR_BADFID;
7966                 }
7967
7968                 status = winreg_printer_update_changeid(p->mem_ctx,
7969                                                         p->server_info,
7970                                                         p->msg_ctx,
7971                                                         lp_const_servicename(snum));
7972                 if (!W_ERROR_IS_OK(status)) {
7973                         return status;
7974                 }
7975         }
7976
7977         return status;
7978 }
7979
7980 /****************************************************************
7981  _spoolss_DeleteForm
7982 ****************************************************************/
7983
7984 WERROR _spoolss_DeleteForm(struct pipes_struct *p,
7985                            struct spoolss_DeleteForm *r)
7986 {
7987         const char *form_name = r->in.form_name;
7988         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
7989         int snum = -1;
7990         WERROR status = WERR_OK;
7991         SE_PRIV se_printop = SE_PRINT_OPERATOR;
7992
7993         DEBUG(5,("_spoolss_DeleteForm\n"));
7994
7995         if (!Printer) {
7996                 DEBUG(2,("_spoolss_DeleteForm: Invalid handle (%s:%u:%u).\n",
7997                         OUR_HANDLE(r->in.handle)));
7998                 return WERR_BADFID;
7999         }
8000
8001         if ((p->server_info->utok.uid != sec_initial_uid()) &&
8002              !user_has_privileges(p->server_info->ptok, &se_printop) &&
8003              !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
8004                                           p->server_info->info3->base.domain.string,
8005                                           NULL,
8006                                           p->server_info->ptok,
8007                                           lp_printer_admin(snum))) {
8008                 DEBUG(2,("_spoolss_DeleteForm: denied by insufficient permissions.\n"));
8009                 return WERR_ACCESS_DENIED;
8010         }
8011
8012         status = winreg_printer_deleteform1(p->mem_ctx,
8013                                             p->server_info,
8014                                             p->msg_ctx,
8015                                             form_name);
8016         if (!W_ERROR_IS_OK(status)) {
8017                 return status;
8018         }
8019
8020         /*
8021          * ChangeID must always be set if this is a printer
8022          */
8023         if (Printer->printer_type == SPLHND_PRINTER) {
8024                 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8025                         return WERR_BADFID;
8026                 }
8027
8028                 status = winreg_printer_update_changeid(p->mem_ctx,
8029                                                         p->server_info,
8030                                                         p->msg_ctx,
8031                                                         lp_const_servicename(snum));
8032                 if (!W_ERROR_IS_OK(status)) {
8033                         return status;
8034                 }
8035         }
8036
8037         return status;
8038 }
8039
8040 /****************************************************************
8041  _spoolss_SetForm
8042 ****************************************************************/
8043
8044 WERROR _spoolss_SetForm(struct pipes_struct *p,
8045                         struct spoolss_SetForm *r)
8046 {
8047         struct spoolss_AddFormInfo1 *form = r->in.info.info1;
8048         const char *form_name = r->in.form_name;
8049         int snum = -1;
8050         WERROR status = WERR_OK;
8051         SE_PRIV se_printop = SE_PRINT_OPERATOR;
8052
8053         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8054
8055         DEBUG(5,("_spoolss_SetForm\n"));
8056
8057         if (!Printer) {
8058                 DEBUG(2,("_spoolss_SetForm: Invalid handle (%s:%u:%u).\n",
8059                         OUR_HANDLE(r->in.handle)));
8060                 return WERR_BADFID;
8061         }
8062
8063         /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
8064            and not a printer admin, then fail */
8065
8066         if ((p->server_info->utok.uid != sec_initial_uid()) &&
8067              !user_has_privileges(p->server_info->ptok, &se_printop) &&
8068              !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
8069                                           p->server_info->info3->base.domain.string,
8070                                           NULL,
8071                                           p->server_info->ptok,
8072                                           lp_printer_admin(snum))) {
8073                 DEBUG(2,("_spoolss_Setform: denied by insufficient permissions.\n"));
8074                 return WERR_ACCESS_DENIED;
8075         }
8076
8077         status = winreg_printer_setform1(p->mem_ctx,
8078                                          p->server_info,
8079                                          p->msg_ctx,
8080                                          form_name,
8081                                          form);
8082         if (!W_ERROR_IS_OK(status)) {
8083                 return status;
8084         }
8085
8086         /*
8087          * ChangeID must always be set if this is a printer
8088          */
8089         if (Printer->printer_type == SPLHND_PRINTER) {
8090                 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8091                         return WERR_BADFID;
8092                 }
8093
8094                 status = winreg_printer_update_changeid(p->mem_ctx,
8095                                                         p->server_info,
8096                                                         p->msg_ctx,
8097                                                         lp_const_servicename(snum));
8098                 if (!W_ERROR_IS_OK(status)) {
8099                         return status;
8100                 }
8101         }
8102
8103         return status;
8104 }
8105
8106 /****************************************************************************
8107  fill_print_processor1
8108 ****************************************************************************/
8109
8110 static WERROR fill_print_processor1(TALLOC_CTX *mem_ctx,
8111                                     struct spoolss_PrintProcessorInfo1 *r,
8112                                     const char *print_processor_name)
8113 {
8114         r->print_processor_name = talloc_strdup(mem_ctx, print_processor_name);
8115         W_ERROR_HAVE_NO_MEMORY(r->print_processor_name);
8116
8117         return WERR_OK;
8118 }
8119
8120 /****************************************************************************
8121  enumprintprocessors level 1.
8122 ****************************************************************************/
8123
8124 static WERROR enumprintprocessors_level_1(TALLOC_CTX *mem_ctx,
8125                                           union spoolss_PrintProcessorInfo **info_p,
8126                                           uint32_t *count)
8127 {
8128         union spoolss_PrintProcessorInfo *info;
8129         WERROR result;
8130
8131         info = TALLOC_ARRAY(mem_ctx, union spoolss_PrintProcessorInfo, 1);
8132         W_ERROR_HAVE_NO_MEMORY(info);
8133
8134         *count = 1;
8135
8136         result = fill_print_processor1(info, &info[0].info1, "winprint");
8137         if (!W_ERROR_IS_OK(result)) {
8138                 goto out;
8139         }
8140
8141  out:
8142         if (!W_ERROR_IS_OK(result)) {
8143                 TALLOC_FREE(info);
8144                 *count = 0;
8145                 return result;
8146         }
8147
8148         *info_p = info;
8149
8150         return WERR_OK;
8151 }
8152
8153 /****************************************************************
8154  _spoolss_EnumPrintProcessors
8155 ****************************************************************/
8156
8157 WERROR _spoolss_EnumPrintProcessors(struct pipes_struct *p,
8158                                     struct spoolss_EnumPrintProcessors *r)
8159 {
8160         WERROR result;
8161
8162         /* that's an [in out] buffer */
8163
8164         if (!r->in.buffer && (r->in.offered != 0)) {
8165                 return WERR_INVALID_PARAM;
8166         }
8167
8168         DEBUG(5,("_spoolss_EnumPrintProcessors\n"));
8169
8170         /*
8171          * Enumerate the print processors ...
8172          *
8173          * Just reply with "winprint", to keep NT happy
8174          * and I can use my nice printer checker.
8175          */
8176
8177         *r->out.count = 0;
8178         *r->out.needed = 0;
8179         *r->out.info = NULL;
8180
8181         switch (r->in.level) {
8182         case 1:
8183                 result = enumprintprocessors_level_1(p->mem_ctx, r->out.info,
8184                                                      r->out.count);
8185                 break;
8186         default:
8187                 return WERR_UNKNOWN_LEVEL;
8188         }
8189
8190         if (!W_ERROR_IS_OK(result)) {
8191                 return result;
8192         }
8193
8194         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8195                                                      spoolss_EnumPrintProcessors,
8196                                                      *r->out.info, r->in.level,
8197                                                      *r->out.count);
8198         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8199         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8200
8201         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8202 }
8203
8204 /****************************************************************************
8205  fill_printprocdatatype1
8206 ****************************************************************************/
8207
8208 static WERROR fill_printprocdatatype1(TALLOC_CTX *mem_ctx,
8209                                       struct spoolss_PrintProcDataTypesInfo1 *r,
8210                                       const char *name_array)
8211 {
8212         r->name_array = talloc_strdup(mem_ctx, name_array);
8213         W_ERROR_HAVE_NO_MEMORY(r->name_array);
8214
8215         return WERR_OK;
8216 }
8217
8218 /****************************************************************************
8219  enumprintprocdatatypes level 1.
8220 ****************************************************************************/
8221
8222 static WERROR enumprintprocdatatypes_level_1(TALLOC_CTX *mem_ctx,
8223                                              union spoolss_PrintProcDataTypesInfo **info_p,
8224                                              uint32_t *count)
8225 {
8226         WERROR result;
8227         union spoolss_PrintProcDataTypesInfo *info;
8228
8229         info = TALLOC_ARRAY(mem_ctx, union spoolss_PrintProcDataTypesInfo, 1);
8230         W_ERROR_HAVE_NO_MEMORY(info);
8231
8232         *count = 1;
8233
8234         result = fill_printprocdatatype1(info, &info[0].info1, "RAW");
8235         if (!W_ERROR_IS_OK(result)) {
8236                 goto out;
8237         }
8238
8239  out:
8240         if (!W_ERROR_IS_OK(result)) {
8241                 TALLOC_FREE(info);
8242                 *count = 0;
8243                 return result;
8244         }
8245
8246         *info_p = info;
8247
8248         return WERR_OK;
8249 }
8250
8251 /****************************************************************
8252  _spoolss_EnumPrintProcDataTypes
8253 ****************************************************************/
8254
8255 WERROR _spoolss_EnumPrintProcDataTypes(struct pipes_struct *p,
8256                                        struct spoolss_EnumPrintProcDataTypes *r)
8257 {
8258         WERROR result;
8259
8260         /* that's an [in out] buffer */
8261
8262         if (!r->in.buffer && (r->in.offered != 0)) {
8263                 return WERR_INVALID_PARAM;
8264         }
8265
8266         DEBUG(5,("_spoolss_EnumPrintProcDataTypes\n"));
8267
8268         *r->out.count = 0;
8269         *r->out.needed = 0;
8270         *r->out.info = NULL;
8271
8272         switch (r->in.level) {
8273         case 1:
8274                 result = enumprintprocdatatypes_level_1(p->mem_ctx, r->out.info,
8275                                                         r->out.count);
8276                 break;
8277         default:
8278                 return WERR_UNKNOWN_LEVEL;
8279         }
8280
8281         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8282                                                      spoolss_EnumPrintProcDataTypes,
8283                                                      *r->out.info, r->in.level,
8284                                                      *r->out.count);
8285         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8286         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8287
8288         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8289 }
8290
8291 /****************************************************************************
8292  fill_monitor_1
8293 ****************************************************************************/
8294
8295 static WERROR fill_monitor_1(TALLOC_CTX *mem_ctx,
8296                              struct spoolss_MonitorInfo1 *r,
8297                              const char *monitor_name)
8298 {
8299         r->monitor_name                 = talloc_strdup(mem_ctx, monitor_name);
8300         W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
8301
8302         return WERR_OK;
8303 }
8304
8305 /****************************************************************************
8306  fill_monitor_2
8307 ****************************************************************************/
8308
8309 static WERROR fill_monitor_2(TALLOC_CTX *mem_ctx,
8310                              struct spoolss_MonitorInfo2 *r,
8311                              const char *monitor_name,
8312                              const char *environment,
8313                              const char *dll_name)
8314 {
8315         r->monitor_name                 = talloc_strdup(mem_ctx, monitor_name);
8316         W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
8317         r->environment                  = talloc_strdup(mem_ctx, environment);
8318         W_ERROR_HAVE_NO_MEMORY(r->environment);
8319         r->dll_name                     = talloc_strdup(mem_ctx, dll_name);
8320         W_ERROR_HAVE_NO_MEMORY(r->dll_name);
8321
8322         return WERR_OK;
8323 }
8324
8325 /****************************************************************************
8326  enumprintmonitors level 1.
8327 ****************************************************************************/
8328
8329 static WERROR enumprintmonitors_level_1(TALLOC_CTX *mem_ctx,
8330                                         union spoolss_MonitorInfo **info_p,
8331                                         uint32_t *count)
8332 {
8333         union spoolss_MonitorInfo *info;
8334         WERROR result = WERR_OK;
8335
8336         info = TALLOC_ARRAY(mem_ctx, union spoolss_MonitorInfo, 2);
8337         W_ERROR_HAVE_NO_MEMORY(info);
8338
8339         *count = 2;
8340
8341         result = fill_monitor_1(info, &info[0].info1,
8342                                 SPL_LOCAL_PORT);
8343         if (!W_ERROR_IS_OK(result)) {
8344                 goto out;
8345         }
8346
8347         result = fill_monitor_1(info, &info[1].info1,
8348                                 SPL_TCPIP_PORT);
8349         if (!W_ERROR_IS_OK(result)) {
8350                 goto out;
8351         }
8352
8353 out:
8354         if (!W_ERROR_IS_OK(result)) {
8355                 TALLOC_FREE(info);
8356                 *count = 0;
8357                 return result;
8358         }
8359
8360         *info_p = info;
8361
8362         return WERR_OK;
8363 }
8364
8365 /****************************************************************************
8366  enumprintmonitors level 2.
8367 ****************************************************************************/
8368
8369 static WERROR enumprintmonitors_level_2(TALLOC_CTX *mem_ctx,
8370                                         union spoolss_MonitorInfo **info_p,
8371                                         uint32_t *count)
8372 {
8373         union spoolss_MonitorInfo *info;
8374         WERROR result = WERR_OK;
8375
8376         info = TALLOC_ARRAY(mem_ctx, union spoolss_MonitorInfo, 2);
8377         W_ERROR_HAVE_NO_MEMORY(info);
8378
8379         *count = 2;
8380
8381         result = fill_monitor_2(info, &info[0].info2,
8382                                 SPL_LOCAL_PORT,
8383                                 "Windows NT X86", /* FIXME */
8384                                 "localmon.dll");
8385         if (!W_ERROR_IS_OK(result)) {
8386                 goto out;
8387         }
8388
8389         result = fill_monitor_2(info, &info[1].info2,
8390                                 SPL_TCPIP_PORT,
8391                                 "Windows NT X86", /* FIXME */
8392                                 "tcpmon.dll");
8393         if (!W_ERROR_IS_OK(result)) {
8394                 goto out;
8395         }
8396
8397 out:
8398         if (!W_ERROR_IS_OK(result)) {
8399                 TALLOC_FREE(info);
8400                 *count = 0;
8401                 return result;
8402         }
8403
8404         *info_p = info;
8405
8406         return WERR_OK;
8407 }
8408
8409 /****************************************************************
8410  _spoolss_EnumMonitors
8411 ****************************************************************/
8412
8413 WERROR _spoolss_EnumMonitors(struct pipes_struct *p,
8414                              struct spoolss_EnumMonitors *r)
8415 {
8416         WERROR result;
8417
8418         /* that's an [in out] buffer */
8419
8420         if (!r->in.buffer && (r->in.offered != 0)) {
8421                 return WERR_INVALID_PARAM;
8422         }
8423
8424         DEBUG(5,("_spoolss_EnumMonitors\n"));
8425
8426         /*
8427          * Enumerate the print monitors ...
8428          *
8429          * Just reply with "Local Port", to keep NT happy
8430          * and I can use my nice printer checker.
8431          */
8432
8433         *r->out.count = 0;
8434         *r->out.needed = 0;
8435         *r->out.info = NULL;
8436
8437         switch (r->in.level) {
8438         case 1:
8439                 result = enumprintmonitors_level_1(p->mem_ctx, r->out.info,
8440                                                    r->out.count);
8441                 break;
8442         case 2:
8443                 result = enumprintmonitors_level_2(p->mem_ctx, r->out.info,
8444                                                    r->out.count);
8445                 break;
8446         default:
8447                 return WERR_UNKNOWN_LEVEL;
8448         }
8449
8450         if (!W_ERROR_IS_OK(result)) {
8451                 return result;
8452         }
8453
8454         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8455                                                      spoolss_EnumMonitors,
8456                                                      *r->out.info, r->in.level,
8457                                                      *r->out.count);
8458         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8459         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8460
8461         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8462 }
8463
8464 /****************************************************************************
8465 ****************************************************************************/
8466
8467 static WERROR getjob_level_1(TALLOC_CTX *mem_ctx,
8468                              const print_queue_struct *queue,
8469                              int count, int snum,
8470                              struct spoolss_PrinterInfo2 *pinfo2,
8471                              uint32_t jobid,
8472                              struct spoolss_JobInfo1 *r)
8473 {
8474         int i = 0;
8475         bool found = false;
8476
8477         for (i=0; i<count; i++) {
8478                 if (queue[i].job == (int)jobid) {
8479                         found = true;
8480                         break;
8481                 }
8482         }
8483
8484         if (found == false) {
8485                 /* NT treats not found as bad param... yet another bad choice */
8486                 return WERR_INVALID_PARAM;
8487         }
8488
8489         return fill_job_info1(mem_ctx,
8490                               r,
8491                               &queue[i],
8492                               i,
8493                               snum,
8494                               pinfo2);
8495 }
8496
8497 /****************************************************************************
8498 ****************************************************************************/
8499
8500 static WERROR getjob_level_2(TALLOC_CTX *mem_ctx,
8501                              const print_queue_struct *queue,
8502                              int count, int snum,
8503                              struct spoolss_PrinterInfo2 *pinfo2,
8504                              uint32_t jobid,
8505                              struct spoolss_JobInfo2 *r)
8506 {
8507         int i = 0;
8508         bool found = false;
8509         struct spoolss_DeviceMode *devmode;
8510         WERROR result;
8511
8512         for (i=0; i<count; i++) {
8513                 if (queue[i].job == (int)jobid) {
8514                         found = true;
8515                         break;
8516                 }
8517         }
8518
8519         if (found == false) {
8520                 /* NT treats not found as bad param... yet another bad
8521                    choice */
8522                 return WERR_INVALID_PARAM;
8523         }
8524
8525         /*
8526          * if the print job does not have a DEVMODE associated with it,
8527          * just use the one for the printer. A NULL devicemode is not
8528          *  a failure condition
8529          */
8530
8531         devmode = print_job_devmode(lp_const_servicename(snum), jobid);
8532         if (!devmode) {
8533                 result = spoolss_create_default_devmode(mem_ctx,
8534                                                 pinfo2->printername,
8535                                                 &devmode);
8536                 if (!W_ERROR_IS_OK(result)) {
8537                         DEBUG(3, ("Can't proceed w/o a devmode!"));
8538                         return result;
8539                 }
8540         }
8541
8542         return fill_job_info2(mem_ctx,
8543                               r,
8544                               &queue[i],
8545                               i,
8546                               snum,
8547                               pinfo2,
8548                               devmode);
8549 }
8550
8551 /****************************************************************
8552  _spoolss_GetJob
8553 ****************************************************************/
8554
8555 WERROR _spoolss_GetJob(struct pipes_struct *p,
8556                        struct spoolss_GetJob *r)
8557 {
8558         WERROR result = WERR_OK;
8559         struct spoolss_PrinterInfo2 *pinfo2 = NULL;
8560         int snum;
8561         int count;
8562         print_queue_struct      *queue = NULL;
8563         print_status_struct prt_status;
8564
8565         /* that's an [in out] buffer */
8566
8567         if (!r->in.buffer && (r->in.offered != 0)) {
8568                 return WERR_INVALID_PARAM;
8569         }
8570
8571         DEBUG(5,("_spoolss_GetJob\n"));
8572
8573         *r->out.needed = 0;
8574
8575         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8576                 return WERR_BADFID;
8577         }
8578
8579         result = winreg_get_printer(p->mem_ctx, p->server_info, p->msg_ctx,
8580                                     NULL, lp_servicename(snum), &pinfo2);
8581         if (!W_ERROR_IS_OK(result)) {
8582                 return result;
8583         }
8584
8585         count = print_queue_status(snum, &queue, &prt_status);
8586
8587         DEBUGADD(4,("count:[%d], prt_status:[%d], [%s]\n",
8588                      count, prt_status.status, prt_status.message));
8589
8590         switch (r->in.level) {
8591         case 1:
8592                 result = getjob_level_1(p->mem_ctx,
8593                                         queue, count, snum, pinfo2,
8594                                         r->in.job_id, &r->out.info->info1);
8595                 break;
8596         case 2:
8597                 result = getjob_level_2(p->mem_ctx,
8598                                         queue, count, snum, pinfo2,
8599                                         r->in.job_id, &r->out.info->info2);
8600                 break;
8601         default:
8602                 result = WERR_UNKNOWN_LEVEL;
8603                 break;
8604         }
8605
8606         SAFE_FREE(queue);
8607         TALLOC_FREE(pinfo2);
8608
8609         if (!W_ERROR_IS_OK(result)) {
8610                 TALLOC_FREE(r->out.info);
8611                 return result;
8612         }
8613
8614         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_JobInfo, r->out.info,
8615                                                                                    r->in.level);
8616         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
8617
8618         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8619 }
8620
8621 /****************************************************************
8622  _spoolss_GetPrinterDataEx
8623 ****************************************************************/
8624
8625 WERROR _spoolss_GetPrinterDataEx(struct pipes_struct *p,
8626                                  struct spoolss_GetPrinterDataEx *r)
8627 {
8628
8629         Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
8630         const char *printer;
8631         int                     snum = 0;
8632         WERROR result = WERR_OK;
8633         DATA_BLOB blob;
8634         enum winreg_Type val_type;
8635         uint8_t *val_data;
8636         uint32_t val_size;
8637
8638
8639         DEBUG(4,("_spoolss_GetPrinterDataEx\n"));
8640
8641         DEBUG(10, ("_spoolss_GetPrinterDataEx: key => [%s], value => [%s]\n",
8642                 r->in.key_name, r->in.value_name));
8643
8644         /* in case of problem, return some default values */
8645
8646         *r->out.needed  = 0;
8647         *r->out.type    = REG_NONE;
8648
8649         if (!Printer) {
8650                 DEBUG(2,("_spoolss_GetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
8651                         OUR_HANDLE(r->in.handle)));
8652                 result = WERR_BADFID;
8653                 goto done;
8654         }
8655
8656         /* Is the handle to a printer or to the server? */
8657
8658         if (Printer->printer_type == SPLHND_SERVER) {
8659
8660                 union spoolss_PrinterData data;
8661
8662                 result = getprinterdata_printer_server(p->mem_ctx,
8663                                                        r->in.value_name,
8664                                                        r->out.type,
8665                                                        &data);
8666                 if (!W_ERROR_IS_OK(result)) {
8667                         return result;
8668                 }
8669
8670                 result = push_spoolss_PrinterData(p->mem_ctx, &blob,
8671                                                   *r->out.type, &data);
8672                 if (!W_ERROR_IS_OK(result)) {
8673                         return result;
8674                 }
8675
8676                 *r->out.needed = blob.length;
8677
8678                 if (r->in.offered >= *r->out.needed) {
8679                         memcpy(r->out.data, blob.data, blob.length);
8680                 }
8681
8682                 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
8683         }
8684
8685         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8686                 return WERR_BADFID;
8687         }
8688         printer = lp_const_servicename(snum);
8689
8690         /* check to see if the keyname is valid */
8691         if (!strlen(r->in.key_name)) {
8692                 return WERR_INVALID_PARAM;
8693         }
8694
8695         /* XP sends this and wants the ChangeID value from PRINTER_INFO_0 */
8696         if (strequal(r->in.key_name, SPOOL_PRINTERDATA_KEY) &&
8697             strequal(r->in.value_name, "ChangeId")) {
8698                 *r->out.type = REG_DWORD;
8699                 *r->out.needed = 4;
8700                 if (r->in.offered >= *r->out.needed) {
8701                         uint32_t changeid = 0;
8702
8703                         result = winreg_printer_get_changeid(p->mem_ctx,
8704                                                              p->server_info,
8705                                                              p->msg_ctx,
8706                                                              printer,
8707                                                              &changeid);
8708                         if (!W_ERROR_IS_OK(result)) {
8709                                 return result;
8710                         }
8711
8712                         SIVAL(r->out.data, 0, changeid);
8713                         result = WERR_OK;
8714                 }
8715                 goto done;
8716         }
8717
8718         result = winreg_get_printer_dataex(p->mem_ctx,
8719                                            p->server_info,
8720                                            p->msg_ctx,
8721                                            printer,
8722                                            r->in.key_name,
8723                                            r->in.value_name,
8724                                            &val_type,
8725                                            &val_data,
8726                                            &val_size);
8727         if (!W_ERROR_IS_OK(result)) {
8728                 return result;
8729         }
8730
8731         *r->out.needed = val_size;
8732         *r->out.type = val_type;
8733
8734         if (r->in.offered >= *r->out.needed) {
8735                 memcpy(r->out.data, val_data, val_size);
8736         }
8737
8738  done:
8739         *r->out.type    = SPOOLSS_BUFFER_OK(*r->out.type, REG_NONE);
8740         r->out.data     = SPOOLSS_BUFFER_OK(r->out.data, r->out.data);
8741
8742         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
8743 }
8744
8745 /****************************************************************
8746  _spoolss_SetPrinterDataEx
8747 ****************************************************************/
8748
8749 WERROR _spoolss_SetPrinterDataEx(struct pipes_struct *p,
8750                                  struct spoolss_SetPrinterDataEx *r)
8751 {
8752         struct spoolss_PrinterInfo2 *pinfo2 = NULL;
8753         int                     snum = 0;
8754         WERROR                  result = WERR_OK;
8755         Printer_entry           *Printer = find_printer_index_by_hnd(p, r->in.handle);
8756         char                    *oid_string;
8757
8758         DEBUG(4,("_spoolss_SetPrinterDataEx\n"));
8759
8760         /* From MSDN documentation of SetPrinterDataEx: pass request to
8761            SetPrinterData if key is "PrinterDriverData" */
8762
8763         if (!Printer) {
8764                 DEBUG(2,("_spoolss_SetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
8765                         OUR_HANDLE(r->in.handle)));
8766                 return WERR_BADFID;
8767         }
8768
8769         if (Printer->printer_type == SPLHND_SERVER) {
8770                 DEBUG(10,("_spoolss_SetPrinterDataEx: "
8771                         "Not implemented for server handles yet\n"));
8772                 return WERR_INVALID_PARAM;
8773         }
8774
8775         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8776                 return WERR_BADFID;
8777         }
8778
8779         /*
8780          * Access check : NT returns "access denied" if you make a
8781          * SetPrinterData call without the necessary privildge.
8782          * we were originally returning OK if nothing changed
8783          * which made Win2k issue **a lot** of SetPrinterData
8784          * when connecting to a printer  --jerry
8785          */
8786
8787         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
8788                 DEBUG(3, ("_spoolss_SetPrinterDataEx: "
8789                         "change denied by handle access permissions\n"));
8790                 return WERR_ACCESS_DENIED;
8791         }
8792
8793         result = winreg_get_printer(Printer, p->server_info, p->msg_ctx,
8794                                     Printer->servername,
8795                                     lp_servicename(snum),
8796                                     &pinfo2);
8797         if (!W_ERROR_IS_OK(result)) {
8798                 return result;
8799         }
8800
8801         /* check for OID in valuename */
8802
8803         oid_string = strchr(r->in.value_name, ',');
8804         if (oid_string) {
8805                 *oid_string = '\0';
8806                 oid_string++;
8807         }
8808
8809         /* save the registry data */
8810
8811         result = winreg_set_printer_dataex(p->mem_ctx,
8812                                            p->server_info,
8813                                            p->msg_ctx,
8814                                            pinfo2->sharename,
8815                                            r->in.key_name,
8816                                            r->in.value_name,
8817                                            r->in.type,
8818                                            r->in.data,
8819                                            r->in.offered);
8820
8821         if (W_ERROR_IS_OK(result)) {
8822                 /* save the OID if one was specified */
8823                 if (oid_string) {
8824                         char *str = talloc_asprintf(p->mem_ctx, "%s\\%s",
8825                                 r->in.key_name, SPOOL_OID_KEY);
8826                         if (!str) {
8827                                 result = WERR_NOMEM;
8828                                 goto done;
8829                         }
8830
8831                         /*
8832                          * I'm not checking the status here on purpose.  Don't know
8833                          * if this is right, but I'm returning the status from the
8834                          * previous set_printer_dataex() call.  I have no idea if
8835                          * this is right.    --jerry
8836                          */
8837                         winreg_set_printer_dataex(p->mem_ctx,
8838                                                   p->server_info,
8839                                                   p->msg_ctx,
8840                                                   pinfo2->sharename,
8841                                                   str,
8842                                                   r->in.value_name,
8843                                                   REG_SZ,
8844                                                   (uint8_t *) oid_string,
8845                                                   strlen(oid_string) + 1);
8846                 }
8847
8848                 result = winreg_printer_update_changeid(p->mem_ctx,
8849                                                         p->server_info,
8850                                                         p->msg_ctx,
8851                                                         lp_const_servicename(snum));
8852
8853         }
8854
8855 done:
8856         talloc_free(pinfo2);
8857         return result;
8858 }
8859
8860 /****************************************************************
8861  _spoolss_DeletePrinterDataEx
8862 ****************************************************************/
8863
8864 WERROR _spoolss_DeletePrinterDataEx(struct pipes_struct *p,
8865                                     struct spoolss_DeletePrinterDataEx *r)
8866 {
8867         const char *printer;
8868         int             snum=0;
8869         WERROR          status = WERR_OK;
8870         Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
8871
8872         DEBUG(5,("_spoolss_DeletePrinterDataEx\n"));
8873
8874         if (!Printer) {
8875                 DEBUG(2,("_spoolss_DeletePrinterDataEx: "
8876                         "Invalid handle (%s:%u:%u).\n",
8877                         OUR_HANDLE(r->in.handle)));
8878                 return WERR_BADFID;
8879         }
8880
8881         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
8882                 DEBUG(3, ("_spoolss_DeletePrinterDataEx: "
8883                         "printer properties change denied by handle\n"));
8884                 return WERR_ACCESS_DENIED;
8885         }
8886
8887         if (!r->in.value_name || !r->in.key_name) {
8888                 return WERR_NOMEM;
8889         }
8890
8891         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8892                 return WERR_BADFID;
8893         }
8894         printer = lp_const_servicename(snum);
8895
8896         status = winreg_delete_printer_dataex(p->mem_ctx,
8897                                               p->server_info,
8898                                               p->msg_ctx,
8899                                               printer,
8900                                               r->in.key_name,
8901                                               r->in.value_name);
8902         if (W_ERROR_IS_OK(status)) {
8903                 status = winreg_printer_update_changeid(p->mem_ctx,
8904                                                         p->server_info,
8905                                                         p->msg_ctx,
8906                                                         printer);
8907         }
8908
8909         return status;
8910 }
8911
8912 /****************************************************************
8913  _spoolss_EnumPrinterKey
8914 ****************************************************************/
8915
8916 WERROR _spoolss_EnumPrinterKey(struct pipes_struct *p,
8917                                struct spoolss_EnumPrinterKey *r)
8918 {
8919         uint32_t        num_keys;
8920         Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
8921         int             snum = 0;
8922         WERROR          result = WERR_BADFILE;
8923         const char **array = NULL;
8924         DATA_BLOB blob;
8925
8926         DEBUG(4,("_spoolss_EnumPrinterKey\n"));
8927
8928         if (!Printer) {
8929                 DEBUG(2,("_spoolss_EnumPrinterKey: Invalid handle (%s:%u:%u).\n",
8930                         OUR_HANDLE(r->in.handle)));
8931                 return WERR_BADFID;
8932         }
8933
8934         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8935                 return WERR_BADFID;
8936         }
8937
8938         result = winreg_enum_printer_key(p->mem_ctx,
8939                                          p->server_info,
8940                                          p->msg_ctx,
8941                                          lp_const_servicename(snum),
8942                                          r->in.key_name,
8943                                          &num_keys,
8944                                          &array);
8945         if (!W_ERROR_IS_OK(result)) {
8946                 goto done;
8947         }
8948
8949         if (!push_reg_multi_sz(p->mem_ctx, &blob, array)) {
8950                 result = WERR_NOMEM;
8951                 goto done;
8952         }
8953
8954         *r->out._ndr_size = r->in.offered / 2;
8955         *r->out.needed = blob.length;
8956
8957         if (r->in.offered < *r->out.needed) {
8958                 result = WERR_MORE_DATA;
8959         } else {
8960                 result = WERR_OK;
8961                 r->out.key_buffer->string_array = array;
8962         }
8963
8964  done:
8965         if (!W_ERROR_IS_OK(result)) {
8966                 TALLOC_FREE(array);
8967                 if (!W_ERROR_EQUAL(result, WERR_MORE_DATA)) {
8968                         *r->out.needed = 0;
8969                 }
8970         }
8971
8972         return result;
8973 }
8974
8975 /****************************************************************
8976  _spoolss_DeletePrinterKey
8977 ****************************************************************/
8978
8979 WERROR _spoolss_DeletePrinterKey(struct pipes_struct *p,
8980                                  struct spoolss_DeletePrinterKey *r)
8981 {
8982         Printer_entry           *Printer = find_printer_index_by_hnd(p, r->in.handle);
8983         int                     snum=0;
8984         WERROR                  status;
8985         const char *printer;
8986
8987         DEBUG(5,("_spoolss_DeletePrinterKey\n"));
8988
8989         if (!Printer) {
8990                 DEBUG(2,("_spoolss_DeletePrinterKey: Invalid handle (%s:%u:%u).\n",
8991                         OUR_HANDLE(r->in.handle)));
8992                 return WERR_BADFID;
8993         }
8994
8995         /* if keyname == NULL, return error */
8996         if ( !r->in.key_name )
8997                 return WERR_INVALID_PARAM;
8998
8999         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9000                 return WERR_BADFID;
9001         }
9002
9003         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9004                 DEBUG(3, ("_spoolss_DeletePrinterKey: "
9005                         "printer properties change denied by handle\n"));
9006                 return WERR_ACCESS_DENIED;
9007         }
9008
9009         printer = lp_const_servicename(snum);
9010
9011         /* delete the key and all subkeys */
9012         status = winreg_delete_printer_key(p->mem_ctx,
9013                                            p->server_info,
9014                                            p->msg_ctx,
9015                                            printer,
9016                                            r->in.key_name);
9017         if (W_ERROR_IS_OK(status)) {
9018                 status = winreg_printer_update_changeid(p->mem_ctx,
9019                                                         p->server_info,
9020                                                         p->msg_ctx,
9021                                                         printer);
9022         }
9023
9024         return status;
9025 }
9026
9027 /****************************************************************
9028  _spoolss_EnumPrinterDataEx
9029 ****************************************************************/
9030
9031 WERROR _spoolss_EnumPrinterDataEx(struct pipes_struct *p,
9032                                   struct spoolss_EnumPrinterDataEx *r)
9033 {
9034         uint32_t        count = 0;
9035         struct spoolss_PrinterEnumValues *info = NULL;
9036         Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
9037         int             snum;
9038         WERROR          result;
9039
9040         DEBUG(4,("_spoolss_EnumPrinterDataEx\n"));
9041
9042         *r->out.count = 0;
9043         *r->out.needed = 0;
9044         *r->out.info = NULL;
9045
9046         if (!Printer) {
9047                 DEBUG(2,("_spoolss_EnumPrinterDataEx: Invalid handle (%s:%u:%u1<).\n",
9048                         OUR_HANDLE(r->in.handle)));
9049                 return WERR_BADFID;
9050         }
9051
9052         /*
9053          * first check for a keyname of NULL or "".  Win2k seems to send
9054          * this a lot and we should send back WERR_INVALID_PARAM
9055          * no need to spend time looking up the printer in this case.
9056          * --jerry
9057          */
9058
9059         if (!strlen(r->in.key_name)) {
9060                 result = WERR_INVALID_PARAM;
9061                 goto done;
9062         }
9063
9064         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9065                 return WERR_BADFID;
9066         }
9067
9068         /* now look for a match on the key name */
9069         result = winreg_enum_printer_dataex(p->mem_ctx,
9070                                             p->server_info,
9071                                             p->msg_ctx,
9072                                             lp_const_servicename(snum),
9073                                             r->in.key_name,
9074                                             &count,
9075                                             &info);
9076         if (!W_ERROR_IS_OK(result)) {
9077                 goto done;
9078         }
9079
9080 #if 0 /* FIXME - gd */
9081         /* housekeeping information in the reply */
9082
9083         /* Fix from Martin Zielinski <mz@seh.de> - ensure
9084          * the hand marshalled container size is a multiple
9085          * of 4 bytes for RPC alignment.
9086          */
9087
9088         if (needed % 4) {
9089                 needed += 4-(needed % 4);
9090         }
9091 #endif
9092         *r->out.count   = count;
9093         *r->out.info    = info;
9094
9095  done:
9096         if (!W_ERROR_IS_OK(result)) {
9097                 return result;
9098         }
9099
9100         *r->out.needed  = SPOOLSS_BUFFER_ARRAY(p->mem_ctx,
9101                                                spoolss_EnumPrinterDataEx,
9102                                                *r->out.info,
9103                                                *r->out.count);
9104         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
9105         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, *r->out.count);
9106
9107         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
9108 }
9109
9110 /****************************************************************************
9111 ****************************************************************************/
9112
9113 static WERROR getprintprocessordirectory_level_1(TALLOC_CTX *mem_ctx,
9114                                                  const char *servername,
9115                                                  const char *environment,
9116                                                  struct spoolss_PrintProcessorDirectoryInfo1 *r)
9117 {
9118         WERROR werr;
9119         char *path = NULL;
9120
9121         werr = compose_spoolss_server_path(mem_ctx,
9122                                            servername,
9123                                            environment,
9124                                            SPOOLSS_PRTPROCS_PATH,
9125                                            &path);
9126         if (!W_ERROR_IS_OK(werr)) {
9127                 return werr;
9128         }
9129
9130         DEBUG(4,("print processor directory: [%s]\n", path));
9131
9132         r->directory_name = path;
9133
9134         return WERR_OK;
9135 }
9136
9137 /****************************************************************
9138  _spoolss_GetPrintProcessorDirectory
9139 ****************************************************************/
9140
9141 WERROR _spoolss_GetPrintProcessorDirectory(struct pipes_struct *p,
9142                                            struct spoolss_GetPrintProcessorDirectory *r)
9143 {
9144         WERROR result;
9145
9146         /* that's an [in out] buffer */
9147
9148         if (!r->in.buffer && (r->in.offered != 0)) {
9149                 return WERR_INVALID_PARAM;
9150         }
9151
9152         DEBUG(5,("_spoolss_GetPrintProcessorDirectory: level %d\n",
9153                 r->in.level));
9154
9155         *r->out.needed = 0;
9156
9157         /* r->in.level is ignored */
9158
9159         /* We always should reply with a local print processor directory so that
9160          * users are not forced to have a [prnproc$] share on the Samba spoolss
9161          * server - Guenther */
9162
9163         result = getprintprocessordirectory_level_1(p->mem_ctx,
9164                                                     NULL, /* r->in.server */
9165                                                     r->in.environment,
9166                                                     &r->out.info->info1);
9167         if (!W_ERROR_IS_OK(result)) {
9168                 TALLOC_FREE(r->out.info);
9169                 return result;
9170         }
9171
9172         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_PrintProcessorDirectoryInfo,
9173                                                                                    r->out.info, r->in.level);
9174         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
9175
9176         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
9177 }
9178
9179 /*******************************************************************
9180  ********************************************************************/
9181
9182 static bool push_monitorui_buf(TALLOC_CTX *mem_ctx, DATA_BLOB *buf,
9183                                const char *dllname)
9184 {
9185         enum ndr_err_code ndr_err;
9186         struct spoolss_MonitorUi ui;
9187
9188         ui.dll_name = dllname;
9189
9190         ndr_err = ndr_push_struct_blob(buf, mem_ctx, &ui,
9191                        (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorUi);
9192         if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9193                 NDR_PRINT_DEBUG(spoolss_MonitorUi, &ui);
9194         }
9195         return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9196 }
9197
9198 /*******************************************************************
9199  Streams the monitor UI DLL name in UNICODE
9200 *******************************************************************/
9201
9202 static WERROR xcvtcp_monitorui(TALLOC_CTX *mem_ctx,
9203                                NT_USER_TOKEN *token, DATA_BLOB *in,
9204                                DATA_BLOB *out, uint32_t *needed)
9205 {
9206         const char *dllname = "tcpmonui.dll";
9207
9208         *needed = (strlen(dllname)+1) * 2;
9209
9210         if (out->length < *needed) {
9211                 return WERR_INSUFFICIENT_BUFFER;
9212         }
9213
9214         if (!push_monitorui_buf(mem_ctx, out, dllname)) {
9215                 return WERR_NOMEM;
9216         }
9217
9218         return WERR_OK;
9219 }
9220
9221 /*******************************************************************
9222  ********************************************************************/
9223
9224 static bool pull_port_data_1(TALLOC_CTX *mem_ctx,
9225                              struct spoolss_PortData1 *port1,
9226                              const DATA_BLOB *buf)
9227 {
9228         enum ndr_err_code ndr_err;
9229         ndr_err = ndr_pull_struct_blob(buf, mem_ctx, port1,
9230                        (ndr_pull_flags_fn_t)ndr_pull_spoolss_PortData1);
9231         if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9232                 NDR_PRINT_DEBUG(spoolss_PortData1, port1);
9233         }
9234         return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9235 }
9236
9237 /*******************************************************************
9238  ********************************************************************/
9239
9240 static bool pull_port_data_2(TALLOC_CTX *mem_ctx,
9241                              struct spoolss_PortData2 *port2,
9242                              const DATA_BLOB *buf)
9243 {
9244         enum ndr_err_code ndr_err;
9245         ndr_err = ndr_pull_struct_blob(buf, mem_ctx, port2,
9246                        (ndr_pull_flags_fn_t)ndr_pull_spoolss_PortData2);
9247         if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9248                 NDR_PRINT_DEBUG(spoolss_PortData2, port2);
9249         }
9250         return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9251 }
9252
9253 /*******************************************************************
9254  Create a new TCP/IP port
9255 *******************************************************************/
9256
9257 static WERROR xcvtcp_addport(TALLOC_CTX *mem_ctx,
9258                              NT_USER_TOKEN *token, DATA_BLOB *in,
9259                              DATA_BLOB *out, uint32_t *needed)
9260 {
9261         struct spoolss_PortData1 port1;
9262         struct spoolss_PortData2 port2;
9263         char *device_uri = NULL;
9264         uint32_t version;
9265
9266         const char *portname;
9267         const char *hostaddress;
9268         const char *queue;
9269         uint32_t port_number;
9270         uint32_t protocol;
9271
9272         /* peek for spoolss_PortData version */
9273
9274         if (!in || (in->length < (128 + 4))) {
9275                 return WERR_GENERAL_FAILURE;
9276         }
9277
9278         version = IVAL(in->data, 128);
9279
9280         switch (version) {
9281                 case 1:
9282                         ZERO_STRUCT(port1);
9283
9284                         if (!pull_port_data_1(mem_ctx, &port1, in)) {
9285                                 return WERR_NOMEM;
9286                         }
9287
9288                         portname        = port1.portname;
9289                         hostaddress     = port1.hostaddress;
9290                         queue           = port1.queue;
9291                         protocol        = port1.protocol;
9292                         port_number     = port1.port_number;
9293
9294                         break;
9295                 case 2:
9296                         ZERO_STRUCT(port2);
9297
9298                         if (!pull_port_data_2(mem_ctx, &port2, in)) {
9299                                 return WERR_NOMEM;
9300                         }
9301
9302                         portname        = port2.portname;
9303                         hostaddress     = port2.hostaddress;
9304                         queue           = port2.queue;
9305                         protocol        = port2.protocol;
9306                         port_number     = port2.port_number;
9307
9308                         break;
9309                 default:
9310                         DEBUG(1,("xcvtcp_addport: "
9311                                 "unknown version of port_data: %d\n", version));
9312                         return WERR_UNKNOWN_PORT;
9313         }
9314
9315         /* create the device URI and call the add_port_hook() */
9316
9317         switch (protocol) {
9318         case PROTOCOL_RAWTCP_TYPE:
9319                 device_uri = talloc_asprintf(mem_ctx,
9320                                 "socket://%s:%d/", hostaddress,
9321                                 port_number);
9322                 break;
9323
9324         case PROTOCOL_LPR_TYPE:
9325                 device_uri = talloc_asprintf(mem_ctx,
9326                         "lpr://%s/%s", hostaddress, queue );
9327                 break;
9328
9329         default:
9330                 return WERR_UNKNOWN_PORT;
9331         }
9332
9333         if (!device_uri) {
9334                 return WERR_NOMEM;
9335         }
9336
9337         return add_port_hook(mem_ctx, token, portname, device_uri);
9338 }
9339
9340 /*******************************************************************
9341 *******************************************************************/
9342
9343 struct xcv_api_table xcvtcp_cmds[] = {
9344         { "MonitorUI",  xcvtcp_monitorui },
9345         { "AddPort",    xcvtcp_addport},
9346         { NULL,         NULL }
9347 };
9348
9349 static WERROR process_xcvtcp_command(TALLOC_CTX *mem_ctx,
9350                                      NT_USER_TOKEN *token, const char *command,
9351                                      DATA_BLOB *inbuf,
9352                                      DATA_BLOB *outbuf,
9353                                      uint32_t *needed )
9354 {
9355         int i;
9356
9357         DEBUG(10,("process_xcvtcp_command: Received command \"%s\"\n", command));
9358
9359         for ( i=0; xcvtcp_cmds[i].name; i++ ) {
9360                 if ( strcmp( command, xcvtcp_cmds[i].name ) == 0 )
9361                         return xcvtcp_cmds[i].fn(mem_ctx, token, inbuf, outbuf, needed);
9362         }
9363
9364         return WERR_BADFUNC;
9365 }
9366
9367 /*******************************************************************
9368 *******************************************************************/
9369 #if 0   /* don't support management using the "Local Port" monitor */
9370
9371 static WERROR xcvlocal_monitorui(TALLOC_CTX *mem_ctx,
9372                                  NT_USER_TOKEN *token, DATA_BLOB *in,
9373                                  DATA_BLOB *out, uint32_t *needed)
9374 {
9375         const char *dllname = "localui.dll";
9376
9377         *needed = (strlen(dllname)+1) * 2;
9378
9379         if (out->length < *needed) {
9380                 return WERR_INSUFFICIENT_BUFFER;
9381         }
9382
9383         if (!push_monitorui_buf(mem_ctx, out, dllname)) {
9384                 return WERR_NOMEM;
9385         }
9386
9387         return WERR_OK;
9388 }
9389
9390 /*******************************************************************
9391 *******************************************************************/
9392
9393 struct xcv_api_table xcvlocal_cmds[] = {
9394         { "MonitorUI",  xcvlocal_monitorui },
9395         { NULL,         NULL }
9396 };
9397 #else
9398 struct xcv_api_table xcvlocal_cmds[] = {
9399         { NULL,         NULL }
9400 };
9401 #endif
9402
9403
9404
9405 /*******************************************************************
9406 *******************************************************************/
9407
9408 static WERROR process_xcvlocal_command(TALLOC_CTX *mem_ctx,
9409                                        NT_USER_TOKEN *token, const char *command,
9410                                        DATA_BLOB *inbuf, DATA_BLOB *outbuf,
9411                                        uint32_t *needed)
9412 {
9413         int i;
9414
9415         DEBUG(10,("process_xcvlocal_command: Received command \"%s\"\n", command));
9416
9417         for ( i=0; xcvlocal_cmds[i].name; i++ ) {
9418                 if ( strcmp( command, xcvlocal_cmds[i].name ) == 0 )
9419                         return xcvlocal_cmds[i].fn(mem_ctx, token, inbuf, outbuf, needed);
9420         }
9421         return WERR_BADFUNC;
9422 }
9423
9424 /****************************************************************
9425  _spoolss_XcvData
9426 ****************************************************************/
9427
9428 WERROR _spoolss_XcvData(struct pipes_struct *p,
9429                         struct spoolss_XcvData *r)
9430 {
9431         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9432         DATA_BLOB out_data = data_blob_null;
9433         WERROR werror;
9434
9435         if (!Printer) {
9436                 DEBUG(2,("_spoolss_XcvData: Invalid handle (%s:%u:%u).\n",
9437                         OUR_HANDLE(r->in.handle)));
9438                 return WERR_BADFID;
9439         }
9440
9441         /* Has to be a handle to the TCP/IP port monitor */
9442
9443         if ( !(Printer->printer_type & (SPLHND_PORTMON_LOCAL|SPLHND_PORTMON_TCP)) ) {
9444                 DEBUG(2,("_spoolss_XcvData: Call only valid for Port Monitors\n"));
9445                 return WERR_BADFID;
9446         }
9447
9448         /* requires administrative access to the server */
9449
9450         if ( !(Printer->access_granted & SERVER_ACCESS_ADMINISTER) ) {
9451                 DEBUG(2,("_spoolss_XcvData: denied by handle permissions.\n"));
9452                 return WERR_ACCESS_DENIED;
9453         }
9454
9455         /* Allocate the outgoing buffer */
9456
9457         if (r->in.out_data_size) {
9458                 out_data = data_blob_talloc_zero(p->mem_ctx, r->in.out_data_size);
9459                 if (out_data.data == NULL) {
9460                         return WERR_NOMEM;
9461                 }
9462         }
9463
9464         switch ( Printer->printer_type ) {
9465         case SPLHND_PORTMON_TCP:
9466                 werror = process_xcvtcp_command(p->mem_ctx,
9467                                                 p->server_info->ptok,
9468                                                 r->in.function_name,
9469                                                 &r->in.in_data, &out_data,
9470                                                 r->out.needed);
9471                 break;
9472         case SPLHND_PORTMON_LOCAL:
9473                 werror = process_xcvlocal_command(p->mem_ctx,
9474                                                   p->server_info->ptok,
9475                                                   r->in.function_name,
9476                                                   &r->in.in_data, &out_data,
9477                                                   r->out.needed);
9478                 break;
9479         default:
9480                 werror = WERR_INVALID_PRINT_MONITOR;
9481         }
9482
9483         if (!W_ERROR_IS_OK(werror)) {
9484                 return werror;
9485         }
9486
9487         *r->out.status_code = 0;
9488
9489         if (r->out.out_data && out_data.data && r->in.out_data_size && out_data.length) {
9490                 memcpy(r->out.out_data, out_data.data,
9491                         MIN(r->in.out_data_size, out_data.length));
9492         }
9493
9494         return WERR_OK;
9495 }
9496
9497 /****************************************************************
9498  _spoolss_AddPrintProcessor
9499 ****************************************************************/
9500
9501 WERROR _spoolss_AddPrintProcessor(struct pipes_struct *p,
9502                                   struct spoolss_AddPrintProcessor *r)
9503 {
9504         /* for now, just indicate success and ignore the add.  We'll
9505            automatically set the winprint processor for printer
9506            entries later.  Used to debug the LexMark Optra S 1855 PCL
9507            driver --jerry */
9508
9509         return WERR_OK;
9510 }
9511
9512 /****************************************************************
9513  _spoolss_AddPort
9514 ****************************************************************/
9515
9516 WERROR _spoolss_AddPort(struct pipes_struct *p,
9517                         struct spoolss_AddPort *r)
9518 {
9519         /* do what w2k3 does */
9520
9521         return WERR_NOT_SUPPORTED;
9522 }
9523
9524 /****************************************************************
9525  _spoolss_GetPrinterDriver
9526 ****************************************************************/
9527
9528 WERROR _spoolss_GetPrinterDriver(struct pipes_struct *p,
9529                                  struct spoolss_GetPrinterDriver *r)
9530 {
9531         p->rng_fault_state = true;
9532         return WERR_NOT_SUPPORTED;
9533 }
9534
9535 /****************************************************************
9536  _spoolss_ReadPrinter
9537 ****************************************************************/
9538
9539 WERROR _spoolss_ReadPrinter(struct pipes_struct *p,
9540                             struct spoolss_ReadPrinter *r)
9541 {
9542         p->rng_fault_state = true;
9543         return WERR_NOT_SUPPORTED;
9544 }
9545
9546 /****************************************************************
9547  _spoolss_WaitForPrinterChange
9548 ****************************************************************/
9549
9550 WERROR _spoolss_WaitForPrinterChange(struct pipes_struct *p,
9551                                      struct spoolss_WaitForPrinterChange *r)
9552 {
9553         p->rng_fault_state = true;
9554         return WERR_NOT_SUPPORTED;
9555 }
9556
9557 /****************************************************************
9558  _spoolss_ConfigurePort
9559 ****************************************************************/
9560
9561 WERROR _spoolss_ConfigurePort(struct pipes_struct *p,
9562                               struct spoolss_ConfigurePort *r)
9563 {
9564         p->rng_fault_state = true;
9565         return WERR_NOT_SUPPORTED;
9566 }
9567
9568 /****************************************************************
9569  _spoolss_DeletePort
9570 ****************************************************************/
9571
9572 WERROR _spoolss_DeletePort(struct pipes_struct *p,
9573                            struct spoolss_DeletePort *r)
9574 {
9575         p->rng_fault_state = true;
9576         return WERR_NOT_SUPPORTED;
9577 }
9578
9579 /****************************************************************
9580  _spoolss_CreatePrinterIC
9581 ****************************************************************/
9582
9583 WERROR _spoolss_CreatePrinterIC(struct pipes_struct *p,
9584                                 struct spoolss_CreatePrinterIC *r)
9585 {
9586         p->rng_fault_state = true;
9587         return WERR_NOT_SUPPORTED;
9588 }
9589
9590 /****************************************************************
9591  _spoolss_PlayGDIScriptOnPrinterIC
9592 ****************************************************************/
9593
9594 WERROR _spoolss_PlayGDIScriptOnPrinterIC(struct pipes_struct *p,
9595                                          struct spoolss_PlayGDIScriptOnPrinterIC *r)
9596 {
9597         p->rng_fault_state = true;
9598         return WERR_NOT_SUPPORTED;
9599 }
9600
9601 /****************************************************************
9602  _spoolss_DeletePrinterIC
9603 ****************************************************************/
9604
9605 WERROR _spoolss_DeletePrinterIC(struct pipes_struct *p,
9606                                 struct spoolss_DeletePrinterIC *r)
9607 {
9608         p->rng_fault_state = true;
9609         return WERR_NOT_SUPPORTED;
9610 }
9611
9612 /****************************************************************
9613  _spoolss_AddPrinterConnection
9614 ****************************************************************/
9615
9616 WERROR _spoolss_AddPrinterConnection(struct pipes_struct *p,
9617                                      struct spoolss_AddPrinterConnection *r)
9618 {
9619         p->rng_fault_state = true;
9620         return WERR_NOT_SUPPORTED;
9621 }
9622
9623 /****************************************************************
9624  _spoolss_DeletePrinterConnection
9625 ****************************************************************/
9626
9627 WERROR _spoolss_DeletePrinterConnection(struct pipes_struct *p,
9628                                         struct spoolss_DeletePrinterConnection *r)
9629 {
9630         p->rng_fault_state = true;
9631         return WERR_NOT_SUPPORTED;
9632 }
9633
9634 /****************************************************************
9635  _spoolss_PrinterMessageBox
9636 ****************************************************************/
9637
9638 WERROR _spoolss_PrinterMessageBox(struct pipes_struct *p,
9639                                   struct spoolss_PrinterMessageBox *r)
9640 {
9641         p->rng_fault_state = true;
9642         return WERR_NOT_SUPPORTED;
9643 }
9644
9645 /****************************************************************
9646  _spoolss_AddMonitor
9647 ****************************************************************/
9648
9649 WERROR _spoolss_AddMonitor(struct pipes_struct *p,
9650                            struct spoolss_AddMonitor *r)
9651 {
9652         p->rng_fault_state = true;
9653         return WERR_NOT_SUPPORTED;
9654 }
9655
9656 /****************************************************************
9657  _spoolss_DeleteMonitor
9658 ****************************************************************/
9659
9660 WERROR _spoolss_DeleteMonitor(struct pipes_struct *p,
9661                               struct spoolss_DeleteMonitor *r)
9662 {
9663         p->rng_fault_state = true;
9664         return WERR_NOT_SUPPORTED;
9665 }
9666
9667 /****************************************************************
9668  _spoolss_DeletePrintProcessor
9669 ****************************************************************/
9670
9671 WERROR _spoolss_DeletePrintProcessor(struct pipes_struct *p,
9672                                      struct spoolss_DeletePrintProcessor *r)
9673 {
9674         p->rng_fault_state = true;
9675         return WERR_NOT_SUPPORTED;
9676 }
9677
9678 /****************************************************************
9679  _spoolss_AddPrintProvidor
9680 ****************************************************************/
9681
9682 WERROR _spoolss_AddPrintProvidor(struct pipes_struct *p,
9683                                  struct spoolss_AddPrintProvidor *r)
9684 {
9685         p->rng_fault_state = true;
9686         return WERR_NOT_SUPPORTED;
9687 }
9688
9689 /****************************************************************
9690  _spoolss_DeletePrintProvidor
9691 ****************************************************************/
9692
9693 WERROR _spoolss_DeletePrintProvidor(struct pipes_struct *p,
9694                                     struct spoolss_DeletePrintProvidor *r)
9695 {
9696         p->rng_fault_state = true;
9697         return WERR_NOT_SUPPORTED;
9698 }
9699
9700 /****************************************************************
9701  _spoolss_FindFirstPrinterChangeNotification
9702 ****************************************************************/
9703
9704 WERROR _spoolss_FindFirstPrinterChangeNotification(struct pipes_struct *p,
9705                                                    struct spoolss_FindFirstPrinterChangeNotification *r)
9706 {
9707         p->rng_fault_state = true;
9708         return WERR_NOT_SUPPORTED;
9709 }
9710
9711 /****************************************************************
9712  _spoolss_FindNextPrinterChangeNotification
9713 ****************************************************************/
9714
9715 WERROR _spoolss_FindNextPrinterChangeNotification(struct pipes_struct *p,
9716                                                   struct spoolss_FindNextPrinterChangeNotification *r)
9717 {
9718         p->rng_fault_state = true;
9719         return WERR_NOT_SUPPORTED;
9720 }
9721
9722 /****************************************************************
9723  _spoolss_RouterFindFirstPrinterChangeNotificationOld
9724 ****************************************************************/
9725
9726 WERROR _spoolss_RouterFindFirstPrinterChangeNotificationOld(struct pipes_struct *p,
9727                                                             struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
9728 {
9729         p->rng_fault_state = true;
9730         return WERR_NOT_SUPPORTED;
9731 }
9732
9733 /****************************************************************
9734  _spoolss_ReplyOpenPrinter
9735 ****************************************************************/
9736
9737 WERROR _spoolss_ReplyOpenPrinter(struct pipes_struct *p,
9738                                  struct spoolss_ReplyOpenPrinter *r)
9739 {
9740         p->rng_fault_state = true;
9741         return WERR_NOT_SUPPORTED;
9742 }
9743
9744 /****************************************************************
9745  _spoolss_RouterReplyPrinter
9746 ****************************************************************/
9747
9748 WERROR _spoolss_RouterReplyPrinter(struct pipes_struct *p,
9749                                    struct spoolss_RouterReplyPrinter *r)
9750 {
9751         p->rng_fault_state = true;
9752         return WERR_NOT_SUPPORTED;
9753 }
9754
9755 /****************************************************************
9756  _spoolss_ReplyClosePrinter
9757 ****************************************************************/
9758
9759 WERROR _spoolss_ReplyClosePrinter(struct pipes_struct *p,
9760                                   struct spoolss_ReplyClosePrinter *r)
9761 {
9762         p->rng_fault_state = true;
9763         return WERR_NOT_SUPPORTED;
9764 }
9765
9766 /****************************************************************
9767  _spoolss_AddPortEx
9768 ****************************************************************/
9769
9770 WERROR _spoolss_AddPortEx(struct pipes_struct *p,
9771                           struct spoolss_AddPortEx *r)
9772 {
9773         p->rng_fault_state = true;
9774         return WERR_NOT_SUPPORTED;
9775 }
9776
9777 /****************************************************************
9778  _spoolss_RouterFindFirstPrinterChangeNotification
9779 ****************************************************************/
9780
9781 WERROR _spoolss_RouterFindFirstPrinterChangeNotification(struct pipes_struct *p,
9782                                                          struct spoolss_RouterFindFirstPrinterChangeNotification *r)
9783 {
9784         p->rng_fault_state = true;
9785         return WERR_NOT_SUPPORTED;
9786 }
9787
9788 /****************************************************************
9789  _spoolss_SpoolerInit
9790 ****************************************************************/
9791
9792 WERROR _spoolss_SpoolerInit(struct pipes_struct *p,
9793                             struct spoolss_SpoolerInit *r)
9794 {
9795         p->rng_fault_state = true;
9796         return WERR_NOT_SUPPORTED;
9797 }
9798
9799 /****************************************************************
9800  _spoolss_ResetPrinterEx
9801 ****************************************************************/
9802
9803 WERROR _spoolss_ResetPrinterEx(struct pipes_struct *p,
9804                                struct spoolss_ResetPrinterEx *r)
9805 {
9806         p->rng_fault_state = true;
9807         return WERR_NOT_SUPPORTED;
9808 }
9809
9810 /****************************************************************
9811  _spoolss_RouterReplyPrinterEx
9812 ****************************************************************/
9813
9814 WERROR _spoolss_RouterReplyPrinterEx(struct pipes_struct *p,
9815                                      struct spoolss_RouterReplyPrinterEx *r)
9816 {
9817         p->rng_fault_state = true;
9818         return WERR_NOT_SUPPORTED;
9819 }
9820
9821 /****************************************************************
9822  _spoolss_44
9823 ****************************************************************/
9824
9825 WERROR _spoolss_44(struct pipes_struct *p,
9826                    struct spoolss_44 *r)
9827 {
9828         p->rng_fault_state = true;
9829         return WERR_NOT_SUPPORTED;
9830 }
9831
9832 /****************************************************************
9833  _spoolss_47
9834 ****************************************************************/
9835
9836 WERROR _spoolss_47(struct pipes_struct *p,
9837                    struct spoolss_47 *r)
9838 {
9839         p->rng_fault_state = true;
9840         return WERR_NOT_SUPPORTED;
9841 }
9842
9843 /****************************************************************
9844  _spoolss_4a
9845 ****************************************************************/
9846
9847 WERROR _spoolss_4a(struct pipes_struct *p,
9848                    struct spoolss_4a *r)
9849 {
9850         p->rng_fault_state = true;
9851         return WERR_NOT_SUPPORTED;
9852 }
9853
9854 /****************************************************************
9855  _spoolss_4b
9856 ****************************************************************/
9857
9858 WERROR _spoolss_4b(struct pipes_struct *p,
9859                    struct spoolss_4b *r)
9860 {
9861         p->rng_fault_state = true;
9862         return WERR_NOT_SUPPORTED;
9863 }
9864
9865 /****************************************************************
9866  _spoolss_4c
9867 ****************************************************************/
9868
9869 WERROR _spoolss_4c(struct pipes_struct *p,
9870                    struct spoolss_4c *r)
9871 {
9872         p->rng_fault_state = true;
9873         return WERR_NOT_SUPPORTED;
9874 }
9875
9876 /****************************************************************
9877  _spoolss_53
9878 ****************************************************************/
9879
9880 WERROR _spoolss_53(struct pipes_struct *p,
9881                    struct spoolss_53 *r)
9882 {
9883         p->rng_fault_state = true;
9884         return WERR_NOT_SUPPORTED;
9885 }
9886
9887 /****************************************************************
9888  _spoolss_55
9889 ****************************************************************/
9890
9891 WERROR _spoolss_55(struct pipes_struct *p,
9892                    struct spoolss_55 *r)
9893 {
9894         p->rng_fault_state = true;
9895         return WERR_NOT_SUPPORTED;
9896 }
9897
9898 /****************************************************************
9899  _spoolss_56
9900 ****************************************************************/
9901
9902 WERROR _spoolss_56(struct pipes_struct *p,
9903                    struct spoolss_56 *r)
9904 {
9905         p->rng_fault_state = true;
9906         return WERR_NOT_SUPPORTED;
9907 }
9908
9909 /****************************************************************
9910  _spoolss_57
9911 ****************************************************************/
9912
9913 WERROR _spoolss_57(struct pipes_struct *p,
9914                    struct spoolss_57 *r)
9915 {
9916         p->rng_fault_state = true;
9917         return WERR_NOT_SUPPORTED;
9918 }
9919
9920 /****************************************************************
9921  _spoolss_5a
9922 ****************************************************************/
9923
9924 WERROR _spoolss_5a(struct pipes_struct *p,
9925                    struct spoolss_5a *r)
9926 {
9927         p->rng_fault_state = true;
9928         return WERR_NOT_SUPPORTED;
9929 }
9930
9931 /****************************************************************
9932  _spoolss_5b
9933 ****************************************************************/
9934
9935 WERROR _spoolss_5b(struct pipes_struct *p,
9936                    struct spoolss_5b *r)
9937 {
9938         p->rng_fault_state = true;
9939         return WERR_NOT_SUPPORTED;
9940 }
9941
9942 /****************************************************************
9943  _spoolss_5c
9944 ****************************************************************/
9945
9946 WERROR _spoolss_5c(struct pipes_struct *p,
9947                    struct spoolss_5c *r)
9948 {
9949         p->rng_fault_state = true;
9950         return WERR_NOT_SUPPORTED;
9951 }
9952
9953 /****************************************************************
9954  _spoolss_5d
9955 ****************************************************************/
9956
9957 WERROR _spoolss_5d(struct pipes_struct *p,
9958                    struct spoolss_5d *r)
9959 {
9960         p->rng_fault_state = true;
9961         return WERR_NOT_SUPPORTED;
9962 }
9963
9964 /****************************************************************
9965  _spoolss_5e
9966 ****************************************************************/
9967
9968 WERROR _spoolss_5e(struct pipes_struct *p,
9969                    struct spoolss_5e *r)
9970 {
9971         p->rng_fault_state = true;
9972         return WERR_NOT_SUPPORTED;
9973 }
9974
9975 /****************************************************************
9976  _spoolss_5f
9977 ****************************************************************/
9978
9979 WERROR _spoolss_5f(struct pipes_struct *p,
9980                    struct spoolss_5f *r)
9981 {
9982         p->rng_fault_state = true;
9983         return WERR_NOT_SUPPORTED;
9984 }
9985
9986 /****************************************************************
9987  _spoolss_60
9988 ****************************************************************/
9989
9990 WERROR _spoolss_60(struct pipes_struct *p,
9991                    struct spoolss_60 *r)
9992 {
9993         p->rng_fault_state = true;
9994         return WERR_NOT_SUPPORTED;
9995 }
9996
9997 /****************************************************************
9998  _spoolss_61
9999 ****************************************************************/
10000
10001 WERROR _spoolss_61(struct pipes_struct *p,
10002                    struct spoolss_61 *r)
10003 {
10004         p->rng_fault_state = true;
10005         return WERR_NOT_SUPPORTED;
10006 }
10007
10008 /****************************************************************
10009  _spoolss_62
10010 ****************************************************************/
10011
10012 WERROR _spoolss_62(struct pipes_struct *p,
10013                    struct spoolss_62 *r)
10014 {
10015         p->rng_fault_state = true;
10016         return WERR_NOT_SUPPORTED;
10017 }
10018
10019 /****************************************************************
10020  _spoolss_63
10021 ****************************************************************/
10022
10023 WERROR _spoolss_63(struct pipes_struct *p,
10024                    struct spoolss_63 *r)
10025 {
10026         p->rng_fault_state = true;
10027         return WERR_NOT_SUPPORTED;
10028 }
10029
10030 /****************************************************************
10031  _spoolss_64
10032 ****************************************************************/
10033
10034 WERROR _spoolss_64(struct pipes_struct *p,
10035                    struct spoolss_64 *r)
10036 {
10037         p->rng_fault_state = true;
10038         return WERR_NOT_SUPPORTED;
10039 }
10040
10041 /****************************************************************
10042  _spoolss_65
10043 ****************************************************************/
10044
10045 WERROR _spoolss_65(struct pipes_struct *p,
10046                    struct spoolss_65 *r)
10047 {
10048         p->rng_fault_state = true;
10049         return WERR_NOT_SUPPORTED;
10050 }
10051
10052 /****************************************************************
10053  _spoolss_GetCorePrinterDrivers
10054 ****************************************************************/
10055
10056 WERROR _spoolss_GetCorePrinterDrivers(struct pipes_struct *p,
10057                                       struct spoolss_GetCorePrinterDrivers *r)
10058 {
10059         p->rng_fault_state = true;
10060         return WERR_NOT_SUPPORTED;
10061 }
10062
10063 /****************************************************************
10064  _spoolss_67
10065 ****************************************************************/
10066
10067 WERROR _spoolss_67(struct pipes_struct *p,
10068                    struct spoolss_67 *r)
10069 {
10070         p->rng_fault_state = true;
10071         return WERR_NOT_SUPPORTED;
10072 }
10073
10074 /****************************************************************
10075  _spoolss_GetPrinterDriverPackagePath
10076 ****************************************************************/
10077
10078 WERROR _spoolss_GetPrinterDriverPackagePath(struct pipes_struct *p,
10079                                             struct spoolss_GetPrinterDriverPackagePath *r)
10080 {
10081         p->rng_fault_state = true;
10082         return WERR_NOT_SUPPORTED;
10083 }
10084
10085 /****************************************************************
10086  _spoolss_69
10087 ****************************************************************/
10088
10089 WERROR _spoolss_69(struct pipes_struct *p,
10090                    struct spoolss_69 *r)
10091 {
10092         p->rng_fault_state = true;
10093         return WERR_NOT_SUPPORTED;
10094 }
10095
10096 /****************************************************************
10097  _spoolss_6a
10098 ****************************************************************/
10099
10100 WERROR _spoolss_6a(struct pipes_struct *p,
10101                    struct spoolss_6a *r)
10102 {
10103         p->rng_fault_state = true;
10104         return WERR_NOT_SUPPORTED;
10105 }
10106
10107 /****************************************************************
10108  _spoolss_6b
10109 ****************************************************************/
10110
10111 WERROR _spoolss_6b(struct pipes_struct *p,
10112                    struct spoolss_6b *r)
10113 {
10114         p->rng_fault_state = true;
10115         return WERR_NOT_SUPPORTED;
10116 }
10117
10118 /****************************************************************
10119  _spoolss_6c
10120 ****************************************************************/
10121
10122 WERROR _spoolss_6c(struct pipes_struct *p,
10123                    struct spoolss_6c *r)
10124 {
10125         p->rng_fault_state = true;
10126         return WERR_NOT_SUPPORTED;
10127 }
10128
10129 /****************************************************************
10130  _spoolss_6d
10131 ****************************************************************/
10132
10133 WERROR _spoolss_6d(struct pipes_struct *p,
10134                    struct spoolss_6d *r)
10135 {
10136         p->rng_fault_state = true;
10137         return WERR_NOT_SUPPORTED;
10138 }