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