source3/rpc_server/srv_spoolss_nt.c

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