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