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.
  11  *
  12  *  This program is free software; you can redistribute it and/or modify
  13  *  it under the terms of the GNU General Public License as published by
  14  *  the Free Software Foundation; either version 3 of the License, or
  15  *  (at your option) any later version.
  16  *
  17  *  This program is distributed in the hope that it will be useful,
  18  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  *  GNU General Public License for more details.
  21  *
  22  *  You should have received a copy of the GNU General Public License
  23  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
  24  */
  25
  26 /* Since the SPOOLSS rpc routines are basically DOS 16-bit calls wrapped
  27    up, all the errors returned are DOS errors, not NT status codes. */
  28
  29 #include "includes.h"
  30
  31 /* macros stolen from s4 spoolss server */
  32 #define SPOOLSS_BUFFER_UNION(fn,ic,info,level) \
  33         ((info)?ndr_size_##fn(info, level, ic, 0):0)
  34
  35 #define SPOOLSS_BUFFER_UNION_ARRAY(mem_ctx,fn,ic,info,level,count) \
  36         ((info)?ndr_size_##fn##_info(mem_ctx, ic, level, count, info):0)
  37
  38 #define SPOOLSS_BUFFER_ARRAY(mem_ctx,fn,ic,info,count) \
  39         ((info)?ndr_size_##fn##_info(mem_ctx, ic, count, info):0)
  40
  41 #define SPOOLSS_BUFFER_OK(val_true,val_false) ((r->in.offered >= *r->out.needed)?val_true:val_false)
  42
  43
  44 extern userdom_struct current_user_info;
  45
  46 #undef DBGC_CLASS
  47 #define DBGC_CLASS DBGC_RPC_SRV
  48
  49 #ifndef MAX_OPEN_PRINTER_EXS
  50 #define MAX_OPEN_PRINTER_EXS 50
  51 #endif
  52
  53 #define MAGIC_DISPLAY_FREQUENCY 0xfade2bad
  54 #define PHANTOM_DEVMODE_KEY "_p_f_a_n_t_0_m_"
  55
  56 static Printer_entry *printers_list;
  57
  58 typedef struct _counter_printer_0 {
  59         struct _counter_printer_0 *next;
  60         struct _counter_printer_0 *prev;
  61
  62         int snum;
  63         uint32_t counter;
  64 } counter_printer_0;
  65
  66 static counter_printer_0 *counter_list;
  67
  68 static struct rpc_pipe_client *notify_cli_pipe; /* print notify back-channel pipe handle*/
  69 static uint32_t smb_connections = 0;
  70
  71
  72 /* in printing/nt_printing.c */
  73
  74 extern struct standard_mapping printer_std_mapping, printserver_std_mapping;
  75
  76 /* API table for Xcv Monitor functions */
  77
  78 struct xcv_api_table {
  79         const char *name;
  80         WERROR(*fn) (TALLOC_CTX *mem_ctx, NT_USER_TOKEN *token, DATA_BLOB *in, DATA_BLOB *out, uint32_t *needed);
  81 };
  82
  83 /********************************************************************
  84  * Canonicalize servername.
  85  ********************************************************************/
  86
  87 static const char *canon_servername(const char *servername)
  88 {
  89         const char *pservername = servername;
  90         while (*pservername == '\\') {
  91                 pservername++;
  92         }
  93         return pservername;
  94 }
  95
  96 /* translate between internal status numbers and NT status numbers */
  97 static int nt_printj_status(int v)
  98 {
  99         switch (v) {
 100         case LPQ_QUEUED:
 101                 return 0;
 102         case LPQ_PAUSED:
 103                 return JOB_STATUS_PAUSED;
 104         case LPQ_SPOOLING:
 105                 return JOB_STATUS_SPOOLING;
 106         case LPQ_PRINTING:
 107                 return JOB_STATUS_PRINTING;
 108         case LPQ_ERROR:
 109                 return JOB_STATUS_ERROR;
 110         case LPQ_DELETING:
 111                 return JOB_STATUS_DELETING;
 112         case LPQ_OFFLINE:
 113                 return JOB_STATUS_OFFLINE;
 114         case LPQ_PAPEROUT:
 115                 return JOB_STATUS_PAPEROUT;
 116         case LPQ_PRINTED:
 117                 return JOB_STATUS_PRINTED;
 118         case LPQ_DELETED:
 119                 return JOB_STATUS_DELETED;
 120         case LPQ_BLOCKED:
 121                 return JOB_STATUS_BLOCKED_DEVQ;
 122         case LPQ_USER_INTERVENTION:
 123                 return JOB_STATUS_USER_INTERVENTION;
 124         }
 125         return 0;
 126 }
 127
 128 static int nt_printq_status(int v)
 129 {
 130         switch (v) {
 131         case LPQ_PAUSED:
 132                 return PRINTER_STATUS_PAUSED;
 133         case LPQ_QUEUED:
 134         case LPQ_SPOOLING:
 135         case LPQ_PRINTING:
 136                 return 0;
 137         }
 138         return 0;
 139 }
 140
 141 /***************************************************************************
 142  Disconnect from the client
 143 ****************************************************************************/
 144
 145 static void srv_spoolss_replycloseprinter(int snum, struct policy_handle *handle)
 146 {
 147         WERROR result;
 148         NTSTATUS status;
 149
 150         /*
 151          * Tell the specific printing tdb we no longer want messages for this printer
 152          * by deregistering our PID.
 153          */
 154
 155         if (!print_notify_deregister_pid(snum))
 156                 DEBUG(0,("print_notify_register_pid: Failed to register our pid for printer %s\n", lp_const_servicename(snum) ));
 157
 158         /* weird if the test succeds !!! */
 159         if (smb_connections==0) {
 160                 DEBUG(0,("srv_spoolss_replycloseprinter:Trying to close non-existant notify backchannel !\n"));
 161                 return;
 162         }
 163
 164         status = rpccli_spoolss_ReplyClosePrinter(notify_cli_pipe, talloc_tos(),
 165                                                   handle,
 166                                                   &result);
 167         if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result))
 168                 DEBUG(0,("srv_spoolss_replycloseprinter: reply_close_printer failed [%s].\n",
 169                         win_errstr(result)));
 170
 171         /* if it's the last connection, deconnect the IPC$ share */
 172         if (smb_connections==1) {
 173
 174                 cli_shutdown( rpc_pipe_np_smb_conn(notify_cli_pipe) );
 175                 notify_cli_pipe = NULL; /* The above call shuts downn the pipe also. */
 176
 177                 messaging_deregister(smbd_messaging_context(),
 178                                      MSG_PRINTER_NOTIFY2, NULL);
 179
 180                 /* Tell the connections db we're no longer interested in
 181                  * printer notify messages. */
 182
 183                 register_message_flags(false, FLAG_MSG_PRINT_NOTIFY);
 184         }
 185
 186         smb_connections--;
 187 }
 188
 189 /****************************************************************************
 190  Functions to free a printer entry datastruct.
 191 ****************************************************************************/
 192
 193 static int printer_entry_destructor(Printer_entry *Printer)
 194 {
 195         if (Printer->notify.client_connected == true) {
 196                 int snum = -1;
 197
 198                 if ( Printer->printer_type == SPLHND_SERVER) {
 199                         snum = -1;
 200                         srv_spoolss_replycloseprinter(snum, &Printer->notify.client_hnd);
 201                 } else if (Printer->printer_type == SPLHND_PRINTER) {
 202                         snum = print_queue_snum(Printer->sharename);
 203                         if (snum != -1)
 204                                 srv_spoolss_replycloseprinter(snum,
 205                                                 &Printer->notify.client_hnd);
 206                 }
 207         }
 208
 209         Printer->notify.flags=0;
 210         Printer->notify.options=0;
 211         Printer->notify.localmachine[0]='\0';
 212         Printer->notify.printerlocal=0;
 213         TALLOC_FREE(Printer->notify.option);
 214         Printer->notify.client_connected = false;
 215
 216         free_nt_devicemode( &Printer->nt_devmode );
 217         free_a_printer( &Printer->printer_info, 2 );
 218
 219         /* Remove from the internal list. */
 220         DLIST_REMOVE(printers_list, Printer);
 221         return 0;
 222 }
 223
 224 /****************************************************************************
 225   find printer index by handle
 226 ****************************************************************************/
 227
 228 static Printer_entry *find_printer_index_by_hnd(pipes_struct *p,
 229                                                 struct policy_handle *hnd)
 230 {
 231         Printer_entry *find_printer = NULL;
 232
 233         if(!find_policy_by_hnd(p,hnd,(void **)(void *)&find_printer)) {
 234                 DEBUG(2,("find_printer_index_by_hnd: Printer handle not found: "));
 235                 return NULL;
 236         }
 237
 238         return find_printer;
 239 }
 240
 241 /****************************************************************************
 242  Close printer index by handle.
 243 ****************************************************************************/
 244
 245 static bool close_printer_handle(pipes_struct *p, struct policy_handle *hnd)
 246 {
 247         Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
 248
 249         if (!Printer) {
 250                 DEBUG(2,("close_printer_handle: Invalid handle (%s:%u:%u)\n",
 251                         OUR_HANDLE(hnd)));
 252                 return false;
 253         }
 254
 255         close_policy_hnd(p, hnd);
 256
 257         return true;
 258 }
 259
 260 /****************************************************************************
 261  Delete a printer given a handle.
 262 ****************************************************************************/
 263
 264 WERROR delete_printer_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, const char *sharename )
 265 {
 266         char *cmd = lp_deleteprinter_cmd();
 267         char *command = NULL;
 268         int ret;
 269         SE_PRIV se_printop = SE_PRINT_OPERATOR;
 270         bool is_print_op = false;
 271
 272         /* can't fail if we don't try */
 273
 274         if ( !*cmd )
 275                 return WERR_OK;
 276
 277         command = talloc_asprintf(ctx,
 278                         "%s \"%s\"",
 279                         cmd, sharename);
 280         if (!command) {
 281                 return WERR_NOMEM;
 282         }
 283         if ( token )
 284                 is_print_op = user_has_privileges( token, &se_printop );
 285
 286         DEBUG(10,("Running [%s]\n", command));
 287
 288         /********** BEGIN SePrintOperatorPrivlege BLOCK **********/
 289
 290         if ( is_print_op )
 291                 become_root();
 292
 293         if ( (ret = smbrun(command, NULL)) == 0 ) {
 294                 /* Tell everyone we updated smb.conf. */
 295                 message_send_all(smbd_messaging_context(),
 296                                  MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
 297         }
 298
 299         if ( is_print_op )
 300                 unbecome_root();
 301
 302         /********** END SePrintOperatorPrivlege BLOCK **********/
 303
 304         DEBUGADD(10,("returned [%d]\n", ret));
 305
 306         TALLOC_FREE(command);
 307
 308         if (ret != 0)
 309                 return WERR_BADFID; /* What to return here? */
 310
 311         /* go ahead and re-read the services immediately */
 312         become_root();
 313         reload_services(false);
 314         unbecome_root();
 315
 316         if ( lp_servicenumber( sharename )  < 0 )
 317                 return WERR_ACCESS_DENIED;
 318
 319         return WERR_OK;
 320 }
 321
 322 /****************************************************************************
 323  Delete a printer given a handle.
 324 ****************************************************************************/
 325
 326 static WERROR delete_printer_handle(pipes_struct *p, struct policy_handle *hnd)
 327 {
 328         Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
 329
 330         if (!Printer) {
 331                 DEBUG(2,("delete_printer_handle: Invalid handle (%s:%u:%u)\n",
 332                         OUR_HANDLE(hnd)));
 333                 return WERR_BADFID;
 334         }
 335
 336         /*
 337          * It turns out that Windows allows delete printer on a handle
 338          * opened by an admin user, then used on a pipe handle created
 339          * by an anonymous user..... but they're working on security.... riiight !
 340          * JRA.
 341          */
 342
 343         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
 344                 DEBUG(3, ("delete_printer_handle: denied by handle\n"));
 345                 return WERR_ACCESS_DENIED;
 346         }
 347
 348         /* this does not need a become root since the access check has been
 349            done on the handle already */
 350
 351         if (del_a_printer( Printer->sharename ) != 0) {
 352                 DEBUG(3,("Error deleting printer %s\n", Printer->sharename));
 353                 return WERR_BADFID;
 354         }
 355
 356         return delete_printer_hook(p->mem_ctx, p->server_info->ptok,
 357                                    Printer->sharename );
 358 }
 359
 360 /****************************************************************************
 361  Return the snum of a printer corresponding to an handle.
 362 ****************************************************************************/
 363
 364 static bool get_printer_snum(pipes_struct *p, struct policy_handle *hnd,
 365                              int *number, struct share_params **params)
 366 {
 367         Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
 368
 369         if (!Printer) {
 370                 DEBUG(2,("get_printer_snum: Invalid handle (%s:%u:%u)\n",
 371                         OUR_HANDLE(hnd)));
 372                 return false;
 373         }
 374
 375         switch (Printer->printer_type) {
 376                 case SPLHND_PRINTER:
 377                         DEBUG(4,("short name:%s\n", Printer->sharename));
 378                         *number = print_queue_snum(Printer->sharename);
 379                         return (*number != -1);
 380                 case SPLHND_SERVER:
 381                         return false;
 382                 default:
 383                         return false;
 384         }
 385 }
 386
 387 /****************************************************************************
 388  Set printer handle type.
 389  Check if it's \\server or \\server\printer
 390 ****************************************************************************/
 391
 392 static bool set_printer_hnd_printertype(Printer_entry *Printer, const char *handlename)
 393 {
 394         DEBUG(3,("Setting printer type=%s\n", handlename));
 395
 396         if ( strlen(handlename) < 3 ) {
 397                 DEBUGADD(4,("A print server must have at least 1 char ! %s\n", handlename));
 398                 return false;
 399         }
 400
 401         /* it's a print server */
 402         if (*handlename=='\\' && *(handlename+1)=='\\' && !strchr_m(handlename+2, '\\')) {
 403                 DEBUGADD(4,("Printer is a print server\n"));
 404                 Printer->printer_type = SPLHND_SERVER;
 405         }
 406         /* it's a printer (set_printer_hnd_name() will handle port monitors */
 407         else {
 408                 DEBUGADD(4,("Printer is a printer\n"));
 409                 Printer->printer_type = SPLHND_PRINTER;
 410         }
 411
 412         return true;
 413 }
 414
 415 /****************************************************************************
 416  Set printer handle name..  Accept names like \\server, \\server\printer,
 417  \\server\SHARE, & "\\server\,XcvMonitor Standard TCP/IP Port"    See
 418  the MSDN docs regarding OpenPrinter() for details on the XcvData() and
 419  XcvDataPort() interface.
 420 ****************************************************************************/
 421
 422 static bool set_printer_hnd_name(Printer_entry *Printer, const char *handlename)
 423 {
 424         int snum;
 425         int n_services=lp_numservices();
 426         char *aprinter, *printername;
 427         const char *servername;
 428         fstring sname;
 429         bool found = false;
 430         NT_PRINTER_INFO_LEVEL *printer = NULL;
 431         WERROR result;
 432
 433         DEBUG(4,("Setting printer name=%s (len=%lu)\n", handlename,
 434                 (unsigned long)strlen(handlename)));
 435
 436         aprinter = CONST_DISCARD(char *, handlename);
 437         if ( *handlename == '\\' ) {
 438                 servername = canon_servername(handlename);
 439                 if ( (aprinter = strchr_m( servername, '\\' )) != NULL ) {
 440                         *aprinter = '\0';
 441                         aprinter++;
 442                 }
 443         } else {
 444                 servername = global_myname();
 445         }
 446
 447         /* save the servername to fill in replies on this handle */
 448
 449         if ( !is_myname_or_ipaddr( servername ) )
 450                 return false;
 451
 452         fstrcpy( Printer->servername, servername );
 453
 454         if ( Printer->printer_type == SPLHND_SERVER )
 455                 return true;
 456
 457         if ( Printer->printer_type != SPLHND_PRINTER )
 458                 return false;
 459
 460         DEBUGADD(5, ("searching for [%s]\n", aprinter ));
 461
 462         /* check for the Port Monitor Interface */
 463
 464         if ( strequal( aprinter, SPL_XCV_MONITOR_TCPMON ) ) {
 465                 Printer->printer_type = SPLHND_PORTMON_TCP;
 466                 fstrcpy(sname, SPL_XCV_MONITOR_TCPMON);
 467                 found = true;
 468         }
 469         else if ( strequal( aprinter, SPL_XCV_MONITOR_LOCALMON ) ) {
 470                 Printer->printer_type = SPLHND_PORTMON_LOCAL;
 471                 fstrcpy(sname, SPL_XCV_MONITOR_LOCALMON);
 472                 found = true;
 473         }
 474
 475         /* Search all sharenames first as this is easier than pulling
 476            the printer_info_2 off of disk. Don't use find_service() since
 477            that calls out to map_username() */
 478
 479         /* do another loop to look for printernames */
 480
 481         for (snum=0; !found && snum<n_services; snum++) {
 482
 483                 /* no point going on if this is not a printer */
 484
 485                 if ( !(lp_snum_ok(snum) && lp_print_ok(snum)) )
 486                         continue;
 487
 488                 fstrcpy(sname, lp_servicename(snum));
 489                 if ( strequal( aprinter, sname ) ) {
 490                         found = true;
 491                         break;
 492                 }
 493
 494                 /* no point looking up the printer object if
 495                    we aren't allowing printername != sharename */
 496
 497                 if ( lp_force_printername(snum) )
 498                         continue;
 499
 500                 fstrcpy(sname, lp_servicename(snum));
 501
 502                 printer = NULL;
 503
 504                 /* This call doesn't fill in the location or comment from
 505                  * a CUPS server for efficiency with large numbers of printers.
 506                  * JRA.
 507                  */
 508
 509                 result = get_a_printer_search( NULL, &printer, 2, sname );
 510                 if ( !W_ERROR_IS_OK(result) ) {
 511                         DEBUG(0,("set_printer_hnd_name: failed to lookup printer [%s] -- result [%s]\n",
 512                                 sname, win_errstr(result)));
 513                         continue;
 514                 }
 515
 516                 /* printername is always returned as \\server\printername */
 517                 if ( !(printername = strchr_m(&printer->info_2->printername[2], '\\')) ) {
 518                         DEBUG(0,("set_printer_hnd_name: info2->printername in wrong format! [%s]\n",
 519                                 printer->info_2->printername));
 520                         free_a_printer( &printer, 2);
 521                         continue;
 522                 }
 523
 524                 printername++;
 525
 526                 if ( strequal(printername, aprinter) ) {
 527                         free_a_printer( &printer, 2);
 528                         found = true;
 529                         break;
 530                 }
 531
 532                 DEBUGADD(10, ("printername: %s\n", printername));
 533
 534                 free_a_printer( &printer, 2);
 535         }
 536
 537         free_a_printer( &printer, 2);
 538
 539         if ( !found ) {
 540                 DEBUGADD(4,("Printer not found\n"));
 541                 return false;
 542         }
 543
 544         DEBUGADD(4,("set_printer_hnd_name: Printer found: %s -> %s\n", aprinter, sname));
 545
 546         fstrcpy(Printer->sharename, sname);
 547
 548         return true;
 549 }
 550
 551 /****************************************************************************
 552  Find first available printer slot. creates a printer handle for you.
 553  ****************************************************************************/
 554
 555 static bool open_printer_hnd(pipes_struct *p, struct policy_handle *hnd,
 556                              const char *name, uint32_t access_granted)
 557 {
 558         Printer_entry *new_printer;
 559
 560         DEBUG(10,("open_printer_hnd: name [%s]\n", name));
 561
 562         new_printer = TALLOC_ZERO_P(NULL, Printer_entry);
 563         if (new_printer == NULL) {
 564                 return false;
 565         }
 566         talloc_set_destructor(new_printer, printer_entry_destructor);
 567
 568         if (!create_policy_hnd(p, hnd, new_printer)) {
 569                 TALLOC_FREE(new_printer);
 570                 return false;
 571         }
 572
 573         /* Add to the internal list. */
 574         DLIST_ADD(printers_list, new_printer);
 575
 576         new_printer->notify.option=NULL;
 577
 578         if (!set_printer_hnd_printertype(new_printer, name)) {
 579                 close_printer_handle(p, hnd);
 580                 return false;
 581         }
 582
 583         if (!set_printer_hnd_name(new_printer, name)) {
 584                 close_printer_handle(p, hnd);
 585                 return false;
 586         }
 587
 588         new_printer->access_granted = access_granted;
 589
 590         DEBUG(5, ("%d printer handles active\n", (int)p->pipe_handles->count ));
 591
 592         return true;
 593 }
 594
 595 /***************************************************************************
 596  check to see if the client motify handle is monitoring the notification
 597  given by (notify_type, notify_field).
 598  **************************************************************************/
 599
 600 static bool is_monitoring_event_flags(uint32_t flags, uint16_t notify_type,
 601                                       uint16_t notify_field)
 602 {
 603         return true;
 604 }
 605
 606 static bool is_monitoring_event(Printer_entry *p, uint16_t notify_type,
 607                                 uint16_t notify_field)
 608 {
 609         struct spoolss_NotifyOption *option = p->notify.option;
 610         uint32_t i, j;
 611
 612         /*
 613          * Flags should always be zero when the change notify
 614          * is registered by the client's spooler.  A user Win32 app
 615          * might use the flags though instead of the NOTIFY_OPTION_INFO
 616          * --jerry
 617          */
 618
 619         if (!option) {
 620                 return false;
 621         }
 622
 623         if (p->notify.flags)
 624                 return is_monitoring_event_flags(
 625                         p->notify.flags, notify_type, notify_field);
 626
 627         for (i = 0; i < option->count; i++) {
 628
 629                 /* Check match for notify_type */
 630
 631                 if (option->types[i].type != notify_type)
 632                         continue;
 633
 634                 /* Check match for field */
 635
 636                 for (j = 0; j < option->types[i].count; j++) {
 637                         if (option->types[i].fields[j].field == notify_field) {
 638                                 return true;
 639                         }
 640                 }
 641         }
 642
 643         DEBUG(10, ("Open handle for \\\\%s\\%s is not monitoring 0x%02x/0x%02x\n",
 644                    p->servername, p->sharename, notify_type, notify_field));
 645
 646         return false;
 647 }
 648
 649 #define SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(_data, _integer) \
 650         _data->data.integer[0] = _integer; \
 651         _data->data.integer[1] = 0;
 652
 653
 654 #define SETUP_SPOOLSS_NOTIFY_DATA_STRING(_data, _p) \
 655         _data->data.string.string = talloc_strdup(mem_ctx, _p); \
 656         if (!_data->data.string.string) {\
 657                 _data->data.string.size = 0; \
 658         } \
 659         _data->data.string.size = strlen_m_term(_p) * 2;
 660
 661 #define SETUP_SPOOLSS_NOTIFY_DATA_DEVMODE(_data, _devmode) \
 662         _data->data.devmode.devmode = _devmode;
 663
 664 #define SETUP_SPOOLSS_NOTIFY_DATA_SECDESC(_data, _size, _sd) \
 665         _data->data.sd.sd = dup_sec_desc(mem_ctx, _sd); \
 666         if (!_data->data.sd.sd) { \
 667                 _data->data.sd.sd_size = 0; \
 668         } \
 669         _data->data.sd.sd_size = _size;
 670
 671 static void init_systemtime_buffer(TALLOC_CTX *mem_ctx,
 672                                    struct tm *t,
 673                                    const char **pp,
 674                                    uint32_t *plen)
 675 {
 676         struct spoolss_Time st;
 677         uint32_t len = 16;
 678         char *p;
 679
 680         if (!init_systemtime(&st, t)) {
 681                 return;
 682         }
 683
 684         p = talloc_array(mem_ctx, char, len);
 685         if (!p) {
 686                 return;
 687         }
 688
 689         /*
 690          * Systemtime must be linearized as a set of UINT16's.
 691          * Fix from Benjamin (Bj) Kuit bj@it.uts.edu.au
 692          */
 693
 694         SSVAL(p, 0, st.year);
 695         SSVAL(p, 2, st.month);
 696         SSVAL(p, 4, st.day_of_week);
 697         SSVAL(p, 6, st.day);
 698         SSVAL(p, 8, st.hour);
 699         SSVAL(p, 10, st.minute);
 700         SSVAL(p, 12, st.second);
 701         SSVAL(p, 14, st.millisecond);
 702
 703         *pp = p;
 704         *plen = len;
 705 }
 706
 707 /* Convert a notification message to a struct spoolss_Notify */
 708
 709 static void notify_one_value(struct spoolss_notify_msg *msg,
 710                              struct spoolss_Notify *data,
 711                              TALLOC_CTX *mem_ctx)
 712 {
 713         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, msg->notify.value[0]);
 714 }
 715
 716 static void notify_string(struct spoolss_notify_msg *msg,
 717                           struct spoolss_Notify *data,
 718                           TALLOC_CTX *mem_ctx)
 719 {
 720         /* The length of the message includes the trailing \0 */
 721
 722         data->data.string.size = msg->len * 2;
 723         data->data.string.string = talloc_strdup(mem_ctx, msg->notify.data);
 724         if (!data->data.string.string) {
 725                 data->data.string.size = 0;
 726                 return;
 727         }
 728 }
 729
 730 static void notify_system_time(struct spoolss_notify_msg *msg,
 731                                struct spoolss_Notify *data,
 732                                TALLOC_CTX *mem_ctx)
 733 {
 734         data->data.string.string = NULL;
 735         data->data.string.size = 0;
 736
 737         if (msg->len != sizeof(time_t)) {
 738                 DEBUG(5, ("notify_system_time: received wrong sized message (%d)\n",
 739                           msg->len));
 740                 return;
 741         }
 742
 743         init_systemtime_buffer(mem_ctx, gmtime((time_t *)msg->notify.data),
 744                                &data->data.string.string,
 745                                &data->data.string.size);
 746 }
 747
 748 struct notify2_message_table {
 749         const char *name;
 750         void (*fn)(struct spoolss_notify_msg *msg,
 751                    struct spoolss_Notify *data, TALLOC_CTX *mem_ctx);
 752 };
 753
 754 static struct notify2_message_table printer_notify_table[] = {
 755         /* 0x00 */ { "PRINTER_NOTIFY_FIELD_SERVER_NAME", notify_string },
 756         /* 0x01 */ { "PRINTER_NOTIFY_FIELD_PRINTER_NAME", notify_string },
 757         /* 0x02 */ { "PRINTER_NOTIFY_FIELD_SHARE_NAME", notify_string },
 758         /* 0x03 */ { "PRINTER_NOTIFY_FIELD_PORT_NAME", notify_string },
 759         /* 0x04 */ { "PRINTER_NOTIFY_FIELD_DRIVER_NAME", notify_string },
 760         /* 0x05 */ { "PRINTER_NOTIFY_FIELD_COMMENT", notify_string },
 761         /* 0x06 */ { "PRINTER_NOTIFY_FIELD_LOCATION", notify_string },
 762         /* 0x07 */ { "PRINTER_NOTIFY_FIELD_DEVMODE", NULL },
 763         /* 0x08 */ { "PRINTER_NOTIFY_FIELD_SEPFILE", notify_string },
 764         /* 0x09 */ { "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR", notify_string },
 765         /* 0x0a */ { "PRINTER_NOTIFY_FIELD_PARAMETERS", NULL },
 766         /* 0x0b */ { "PRINTER_NOTIFY_FIELD_DATATYPE", notify_string },
 767         /* 0x0c */ { "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NULL },
 768         /* 0x0d */ { "PRINTER_NOTIFY_FIELD_ATTRIBUTES", notify_one_value },
 769         /* 0x0e */ { "PRINTER_NOTIFY_FIELD_PRIORITY", notify_one_value },
 770         /* 0x0f */ { "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY", NULL },
 771         /* 0x10 */ { "PRINTER_NOTIFY_FIELD_START_TIME", NULL },
 772         /* 0x11 */ { "PRINTER_NOTIFY_FIELD_UNTIL_TIME", NULL },
 773         /* 0x12 */ { "PRINTER_NOTIFY_FIELD_STATUS", notify_one_value },
 774 };
 775
 776 static struct notify2_message_table job_notify_table[] = {
 777         /* 0x00 */ { "JOB_NOTIFY_FIELD_PRINTER_NAME", NULL },
 778         /* 0x01 */ { "JOB_NOTIFY_FIELD_MACHINE_NAME", NULL },
 779         /* 0x02 */ { "JOB_NOTIFY_FIELD_PORT_NAME", NULL },
 780         /* 0x03 */ { "JOB_NOTIFY_FIELD_USER_NAME", notify_string },
 781         /* 0x04 */ { "JOB_NOTIFY_FIELD_NOTIFY_NAME", NULL },
 782         /* 0x05 */ { "JOB_NOTIFY_FIELD_DATATYPE", NULL },
 783         /* 0x06 */ { "JOB_NOTIFY_FIELD_PRINT_PROCESSOR", NULL },
 784         /* 0x07 */ { "JOB_NOTIFY_FIELD_PARAMETERS", NULL },
 785         /* 0x08 */ { "JOB_NOTIFY_FIELD_DRIVER_NAME", NULL },
 786         /* 0x09 */ { "JOB_NOTIFY_FIELD_DEVMODE", NULL },
 787         /* 0x0a */ { "JOB_NOTIFY_FIELD_STATUS", notify_one_value },
 788         /* 0x0b */ { "JOB_NOTIFY_FIELD_STATUS_STRING", NULL },
 789         /* 0x0c */ { "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NULL },
 790         /* 0x0d */ { "JOB_NOTIFY_FIELD_DOCUMENT", notify_string },
 791         /* 0x0e */ { "JOB_NOTIFY_FIELD_PRIORITY", NULL },
 792         /* 0x0f */ { "JOB_NOTIFY_FIELD_POSITION", NULL },
 793         /* 0x10 */ { "JOB_NOTIFY_FIELD_SUBMITTED", notify_system_time },
 794         /* 0x11 */ { "JOB_NOTIFY_FIELD_START_TIME", NULL },
 795         /* 0x12 */ { "JOB_NOTIFY_FIELD_UNTIL_TIME", NULL },
 796         /* 0x13 */ { "JOB_NOTIFY_FIELD_TIME", NULL },
 797         /* 0x14 */ { "JOB_NOTIFY_FIELD_TOTAL_PAGES", notify_one_value },
 798         /* 0x15 */ { "JOB_NOTIFY_FIELD_PAGES_PRINTED", NULL },
 799         /* 0x16 */ { "JOB_NOTIFY_FIELD_TOTAL_BYTES", notify_one_value },
 800         /* 0x17 */ { "JOB_NOTIFY_FIELD_BYTES_PRINTED", NULL },
 801 };
 802
 803
 804 /***********************************************************************
 805  Allocate talloc context for container object
 806  **********************************************************************/
 807
 808 static void notify_msg_ctr_init( SPOOLSS_NOTIFY_MSG_CTR *ctr )
 809 {
 810         if ( !ctr )
 811                 return;
 812
 813         ctr->ctx = talloc_init("notify_msg_ctr_init %p", ctr);
 814
 815         return;
 816 }
 817
 818 /***********************************************************************
 819  release all allocated memory and zero out structure
 820  **********************************************************************/
 821
 822 static void notify_msg_ctr_destroy( SPOOLSS_NOTIFY_MSG_CTR *ctr )
 823 {
 824         if ( !ctr )
 825                 return;
 826
 827         if ( ctr->ctx )
 828                 talloc_destroy(ctr->ctx);
 829
 830         ZERO_STRUCTP(ctr);
 831
 832         return;
 833 }
 834
 835 /***********************************************************************
 836  **********************************************************************/
 837
 838 static TALLOC_CTX* notify_ctr_getctx( SPOOLSS_NOTIFY_MSG_CTR *ctr )
 839 {
 840         if ( !ctr )
 841                 return NULL;
 842
 843         return ctr->ctx;
 844 }
 845
 846 /***********************************************************************
 847  **********************************************************************/
 848
 849 static SPOOLSS_NOTIFY_MSG_GROUP* notify_ctr_getgroup( SPOOLSS_NOTIFY_MSG_CTR *ctr, uint32_t idx )
 850 {
 851         if ( !ctr || !ctr->msg_groups )
 852                 return NULL;
 853
 854         if ( idx >= ctr->num_groups )
 855                 return NULL;
 856
 857         return &ctr->msg_groups[idx];
 858
 859 }
 860
 861 /***********************************************************************
 862  How many groups of change messages do we have ?
 863  **********************************************************************/
 864
 865 static int notify_msg_ctr_numgroups( SPOOLSS_NOTIFY_MSG_CTR *ctr )
 866 {
 867         if ( !ctr )
 868                 return 0;
 869
 870         return ctr->num_groups;
 871 }
 872
 873 /***********************************************************************
 874  Add a SPOOLSS_NOTIFY_MSG_CTR to the correct group
 875  **********************************************************************/
 876
 877 static int notify_msg_ctr_addmsg( SPOOLSS_NOTIFY_MSG_CTR *ctr, SPOOLSS_NOTIFY_MSG *msg )
 878 {
 879         SPOOLSS_NOTIFY_MSG_GROUP        *groups = NULL;
 880         SPOOLSS_NOTIFY_MSG_GROUP        *msg_grp = NULL;
 881         SPOOLSS_NOTIFY_MSG              *msg_list = NULL;
 882         int                             i, new_slot;
 883
 884         if ( !ctr || !msg )
 885                 return 0;
 886
 887         /* loop over all groups looking for a matching printer name */
 888
 889         for ( i=0; i<ctr->num_groups; i++ ) {
 890                 if ( strcmp(ctr->msg_groups[i].printername, msg->printer) == 0 )
 891                         break;
 892         }
 893
 894         /* add a new group? */
 895
 896         if ( i == ctr->num_groups ) {
 897                 ctr->num_groups++;
 898
 899                 if ( !(groups = TALLOC_REALLOC_ARRAY( ctr->ctx, ctr->msg_groups, SPOOLSS_NOTIFY_MSG_GROUP, ctr->num_groups)) ) {
 900                         DEBUG(0,("notify_msg_ctr_addmsg: talloc_realloc() failed!\n"));
 901                         return 0;
 902                 }
 903                 ctr->msg_groups = groups;
 904
 905                 /* clear the new entry and set the printer name */
 906
 907                 ZERO_STRUCT( ctr->msg_groups[ctr->num_groups-1] );
 908                 fstrcpy( ctr->msg_groups[ctr->num_groups-1].printername, msg->printer );
 909         }
 910
 911         /* add the change messages; 'i' is the correct index now regardless */
 912
 913         msg_grp = &ctr->msg_groups[i];
 914
 915         msg_grp->num_msgs++;
 916
 917         if ( !(msg_list = TALLOC_REALLOC_ARRAY( ctr->ctx, msg_grp->msgs, SPOOLSS_NOTIFY_MSG, msg_grp->num_msgs )) ) {
 918                 DEBUG(0,("notify_msg_ctr_addmsg: talloc_realloc() failed for new message [%d]!\n", msg_grp->num_msgs));
 919                 return 0;
 920         }
 921         msg_grp->msgs = msg_list;
 922
 923         new_slot = msg_grp->num_msgs-1;
 924         memcpy( &msg_grp->msgs[new_slot], msg, sizeof(SPOOLSS_NOTIFY_MSG) );
 925
 926         /* need to allocate own copy of data */
 927
 928         if ( msg->len != 0 )
 929                 msg_grp->msgs[new_slot].notify.data = (char *)
 930                         TALLOC_MEMDUP( ctr->ctx, msg->notify.data, msg->len );
 931
 932         return ctr->num_groups;
 933 }
 934
 935 /***********************************************************************
 936  Send a change notication message on all handles which have a call
 937  back registered
 938  **********************************************************************/
 939
 940 static void send_notify2_changes( SPOOLSS_NOTIFY_MSG_CTR *ctr, uint32_t idx )
 941 {
 942         Printer_entry            *p;
 943         TALLOC_CTX               *mem_ctx = notify_ctr_getctx( ctr );
 944         SPOOLSS_NOTIFY_MSG_GROUP *msg_group = notify_ctr_getgroup( ctr, idx );
 945         SPOOLSS_NOTIFY_MSG       *messages;
 946         int                      sending_msg_count;
 947
 948         if ( !msg_group ) {
 949                 DEBUG(5,("send_notify2_changes() called with no msg group!\n"));
 950                 return;
 951         }
 952
 953         messages = msg_group->msgs;
 954
 955         if ( !messages ) {
 956                 DEBUG(5,("send_notify2_changes() called with no messages!\n"));
 957                 return;
 958         }
 959
 960         DEBUG(8,("send_notify2_changes: Enter...[%s]\n", msg_group->printername));
 961
 962         /* loop over all printers */
 963
 964         for (p = printers_list; p; p = p->next) {
 965                 struct spoolss_Notify *notifies;
 966                 uint32_t count = 0;
 967                 uint32_t id;
 968                 int     i;
 969
 970                 /* Is there notification on this handle? */
 971
 972                 if ( !p->notify.client_connected )
 973                         continue;
 974
 975                 DEBUG(10,("Client connected! [\\\\%s\\%s]\n", p->servername, p->sharename));
 976
 977                 /* For this printer?  Print servers always receive
 978                    notifications. */
 979
 980                 if ( ( p->printer_type == SPLHND_PRINTER )  &&
 981                     ( !strequal(msg_group->printername, p->sharename) ) )
 982                         continue;
 983
 984                 DEBUG(10,("Our printer\n"));
 985
 986                 /* allocate the max entries possible */
 987
 988                 notifies = TALLOC_ZERO_ARRAY(mem_ctx, struct spoolss_Notify, msg_group->num_msgs);
 989                 if (!notifies) {
 990                         return;
 991                 }
 992
 993                 /* build the array of change notifications */
 994
 995                 sending_msg_count = 0;
 996
 997                 for ( i=0; i<msg_group->num_msgs; i++ ) {
 998                         SPOOLSS_NOTIFY_MSG      *msg = &messages[i];
 999
1000                         /* Are we monitoring this event? */
1001
1002                         if (!is_monitoring_event(p, msg->type, msg->field))
1003                                 continue;
1004
1005                         sending_msg_count++;
1006
1007
1008                         DEBUG(10,("process_notify2_message: Sending message type [0x%x] field [0x%2x] for printer [%s]\n",
1009                                 msg->type, msg->field, p->sharename));
1010
1011                         /*
1012                          * if the is a printer notification handle and not a job notification
1013                          * type, then set the id to 0.  Other wise just use what was specified
1014                          * in the message.
1015                          *
1016                          * When registering change notification on a print server handle
1017                          * we always need to send back the id (snum) matching the printer
1018                          * for which the change took place.  For change notify registered
1019                          * on a printer handle, this does not matter and the id should be 0.
1020                          *
1021                          * --jerry
1022                          */
1023
1024                         if ( ( p->printer_type == SPLHND_PRINTER ) && ( msg->type == PRINTER_NOTIFY_TYPE ) )
1025                                 id = 0;
1026                         else
1027                                 id = msg->id;
1028
1029
1030                         /* Convert unix jobid to smb jobid */
1031
1032                         if (msg->flags & SPOOLSS_NOTIFY_MSG_UNIX_JOBID) {
1033                                 id = sysjob_to_jobid(msg->id);
1034
1035                                 if (id == -1) {
1036                                         DEBUG(3, ("no such unix jobid %d\n", msg->id));
1037                                         goto done;
1038                                 }
1039                         }
1040
1041                         construct_info_data( &notifies[count], msg->type, msg->field, id );
1042
1043                         switch(msg->type) {
1044                         case PRINTER_NOTIFY_TYPE:
1045                                 if ( printer_notify_table[msg->field].fn )
1046                                         printer_notify_table[msg->field].fn(msg, &notifies[count], mem_ctx);
1047                                 break;
1048
1049                         case JOB_NOTIFY_TYPE:
1050                                 if ( job_notify_table[msg->field].fn )
1051                                         job_notify_table[msg->field].fn(msg, &notifies[count], mem_ctx);
1052                                 break;
1053
1054                         default:
1055                                 DEBUG(5, ("Unknown notification type %d\n", msg->type));
1056                                 goto done;
1057                         }
1058
1059                         count++;
1060                 }
1061
1062                 if ( sending_msg_count ) {
1063                         NTSTATUS status;
1064                         WERROR werr;
1065                         union spoolss_ReplyPrinterInfo info;
1066                         struct spoolss_NotifyInfo info0;
1067                         uint32_t reply_result;
1068
1069                         info0.version   = 0x2;
1070                         info0.flags     = count ? 0x00020000 /* ??? */ : PRINTER_NOTIFY_INFO_DISCARDED;
1071                         info0.count     = count;
1072                         info0.notifies  = notifies;
1073
1074                         info.info0 = &info0;
1075
1076                         status = rpccli_spoolss_RouterReplyPrinterEx(notify_cli_pipe, mem_ctx,
1077                                                                      &p->notify.client_hnd,
1078                                                                      p->notify.change, /* color */
1079                                                                      p->notify.flags,
1080                                                                      &reply_result,
1081                                                                      0, /* reply_type, must be 0 */
1082                                                                      info,
1083                                                                      &werr);
1084                         if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(werr)) {
1085                                 DEBUG(1,("RouterReplyPrinterEx to client: %s failed: %s\n",
1086                                         notify_cli_pipe->srv_name_slash,
1087                                         win_errstr(werr)));
1088                         }
1089                         switch (reply_result) {
1090                                 case 0:
1091                                         break;
1092                                 case PRINTER_NOTIFY_INFO_DISCARDED:
1093                                 case PRINTER_NOTIFY_INFO_DISCARDNOTED:
1094                                 case PRINTER_NOTIFY_INFO_COLOR_MISMATCH:
1095                                         break;
1096                                 default:
1097                                         break;
1098                         }
1099                 }
1100         }
1101
1102 done:
1103         DEBUG(8,("send_notify2_changes: Exit...\n"));
1104         return;
1105 }
1106
1107 /***********************************************************************
1108  **********************************************************************/
1109
1110 static bool notify2_unpack_msg( SPOOLSS_NOTIFY_MSG *msg, struct timeval *tv, void *buf, size_t len )
1111 {
1112
1113         uint32_t tv_sec, tv_usec;
1114         size_t offset = 0;
1115
1116         /* Unpack message */
1117
1118         offset += tdb_unpack((uint8_t *)buf + offset, len - offset, "f",
1119                              msg->printer);
1120
1121         offset += tdb_unpack((uint8_t *)buf + offset, len - offset, "ddddddd",
1122                                 &tv_sec, &tv_usec,
1123                                 &msg->type, &msg->field, &msg->id, &msg->len, &msg->flags);
1124
1125         if (msg->len == 0)
1126                 tdb_unpack((uint8_t *)buf + offset, len - offset, "dd",
1127                            &msg->notify.value[0], &msg->notify.value[1]);
1128         else
1129                 tdb_unpack((uint8_t *)buf + offset, len - offset, "B",
1130                            &msg->len, &msg->notify.data);
1131
1132         DEBUG(3, ("notify2_unpack_msg: got NOTIFY2 message for printer %s, jobid %u type %d, field 0x%02x, flags 0x%04x\n",
1133                   msg->printer, (unsigned int)msg->id, msg->type, msg->field, msg->flags));
1134
1135         tv->tv_sec = tv_sec;
1136         tv->tv_usec = tv_usec;
1137
1138         if (msg->len == 0)
1139                 DEBUG(3, ("notify2_unpack_msg: value1 = %d, value2 = %d\n", msg->notify.value[0],
1140                           msg->notify.value[1]));
1141         else
1142                 dump_data(3, (uint8_t *)msg->notify.data, msg->len);
1143
1144         return true;
1145 }
1146
1147 /********************************************************************
1148  Receive a notify2 message list
1149  ********************************************************************/
1150
1151 static void receive_notify2_message_list(struct messaging_context *msg,
1152                                          void *private_data,
1153                                          uint32_t msg_type,
1154                                          struct server_id server_id,
1155                                          DATA_BLOB *data)
1156 {
1157         size_t                  msg_count, i;
1158         char                    *buf = (char *)data->data;
1159         char                    *msg_ptr;
1160         size_t                  msg_len;
1161         SPOOLSS_NOTIFY_MSG      notify;
1162         SPOOLSS_NOTIFY_MSG_CTR  messages;
1163         int                     num_groups;
1164
1165         if (data->length < 4) {
1166                 DEBUG(0,("receive_notify2_message_list: bad message format (len < 4)!\n"));
1167                 return;
1168         }
1169
1170         msg_count = IVAL(buf, 0);
1171         msg_ptr = buf + 4;
1172
1173         DEBUG(5, ("receive_notify2_message_list: got %lu messages in list\n", (unsigned long)msg_count));
1174
1175         if (msg_count == 0) {
1176                 DEBUG(0,("receive_notify2_message_list: bad message format (msg_count == 0) !\n"));
1177                 return;
1178         }
1179
1180         /* initialize the container */
1181
1182         ZERO_STRUCT( messages );
1183         notify_msg_ctr_init( &messages );
1184
1185         /*
1186          * build message groups for each printer identified
1187          * in a change_notify msg.  Remember that a PCN message
1188          * includes the handle returned for the srv_spoolss_replyopenprinter()
1189          * call.  Therefore messages are grouped according to printer handle.
1190          */
1191
1192         for ( i=0; i<msg_count; i++ ) {
1193                 struct timeval msg_tv;
1194
1195                 if (msg_ptr + 4 - buf > data->length) {
1196                         DEBUG(0,("receive_notify2_message_list: bad message format (len > buf_size) !\n"));
1197                         return;
1198                 }
1199
1200                 msg_len = IVAL(msg_ptr,0);
1201                 msg_ptr += 4;
1202
1203                 if (msg_ptr + msg_len - buf > data->length) {
1204                         DEBUG(0,("receive_notify2_message_list: bad message format (bad len) !\n"));
1205                         return;
1206                 }
1207
1208                 /* unpack messages */
1209
1210                 ZERO_STRUCT( notify );
1211                 notify2_unpack_msg( &notify, &msg_tv, msg_ptr, msg_len );
1212                 msg_ptr += msg_len;
1213
1214                 /* add to correct list in container */
1215
1216                 notify_msg_ctr_addmsg( &messages, &notify );
1217
1218                 /* free memory that might have been allocated by notify2_unpack_msg() */
1219
1220                 if ( notify.len != 0 )
1221                         SAFE_FREE( notify.notify.data );
1222         }
1223
1224         /* process each group of messages */
1225
1226         num_groups = notify_msg_ctr_numgroups( &messages );
1227         for ( i=0; i<num_groups; i++ )
1228                 send_notify2_changes( &messages, i );
1229
1230
1231         /* cleanup */
1232
1233         DEBUG(10,("receive_notify2_message_list: processed %u messages\n",
1234                 (uint32_t)msg_count ));
1235
1236         notify_msg_ctr_destroy( &messages );
1237
1238         return;
1239 }
1240
1241 /********************************************************************
1242  Send a message to ourself about new driver being installed
1243  so we can upgrade the information for each printer bound to this
1244  driver
1245  ********************************************************************/
1246
1247 static bool srv_spoolss_drv_upgrade_printer(const char *drivername)
1248 {
1249         int len = strlen(drivername);
1250
1251         if (!len)
1252                 return false;
1253
1254         DEBUG(10,("srv_spoolss_drv_upgrade_printer: Sending message about driver upgrade [%s]\n",
1255                 drivername));
1256
1257         messaging_send_buf(smbd_messaging_context(), procid_self(),
1258                            MSG_PRINTER_DRVUPGRADE,
1259                            (uint8_t *)drivername, len+1);
1260
1261         return true;
1262 }
1263
1264 /**********************************************************************
1265  callback to receive a MSG_PRINTER_DRVUPGRADE message and interate
1266  over all printers, upgrading ones as necessary
1267  **********************************************************************/
1268
1269 void do_drv_upgrade_printer(struct messaging_context *msg,
1270                             void *private_data,
1271                             uint32_t msg_type,
1272                             struct server_id server_id,
1273                             DATA_BLOB *data)
1274 {
1275         fstring drivername;
1276         int snum;
1277         int n_services = lp_numservices();
1278         size_t len;
1279
1280         len = MIN(data->length,sizeof(drivername)-1);
1281         strncpy(drivername, (const char *)data->data, len);
1282
1283         DEBUG(10,("do_drv_upgrade_printer: Got message for new driver [%s]\n", drivername ));
1284
1285         /* Iterate the printer list */
1286
1287         for (snum=0; snum<n_services; snum++)
1288         {
1289                 if (lp_snum_ok(snum) && lp_print_ok(snum) )
1290                 {
1291                         WERROR result;
1292                         NT_PRINTER_INFO_LEVEL *printer = NULL;
1293
1294                         result = get_a_printer(NULL, &printer, 2, lp_const_servicename(snum));
1295                         if (!W_ERROR_IS_OK(result))
1296                                 continue;
1297
1298                         if (printer && printer->info_2 && !strcmp(drivername, printer->info_2->drivername))
1299                         {
1300                                 DEBUG(6,("Updating printer [%s]\n", printer->info_2->printername));
1301
1302                                 /* all we care about currently is the change_id */
1303
1304                                 result = mod_a_printer(printer, 2);
1305                                 if (!W_ERROR_IS_OK(result)) {
1306                                         DEBUG(3,("do_drv_upgrade_printer: mod_a_printer() failed with status [%s]\n",
1307                                                 win_errstr(result)));
1308                                 }
1309                         }
1310
1311                         free_a_printer(&printer, 2);
1312                 }
1313         }
1314
1315         /* all done */
1316 }
1317
1318 /********************************************************************
1319  Update the cache for all printq's with a registered client
1320  connection
1321  ********************************************************************/
1322
1323 void update_monitored_printq_cache( void )
1324 {
1325         Printer_entry *printer = printers_list;
1326         int snum;
1327
1328         /* loop through all printers and update the cache where
1329            client_connected == true */
1330         while ( printer )
1331         {
1332                 if ( (printer->printer_type == SPLHND_PRINTER)
1333                         && printer->notify.client_connected )
1334                 {
1335                         snum = print_queue_snum(printer->sharename);
1336                         print_queue_status( snum, NULL, NULL );
1337                 }
1338
1339                 printer = printer->next;
1340         }
1341
1342         return;
1343 }
1344 /********************************************************************
1345  Send a message to ourself about new driver being installed
1346  so we can upgrade the information for each printer bound to this
1347  driver
1348  ********************************************************************/
1349
1350 static bool srv_spoolss_reset_printerdata(char* drivername)
1351 {
1352         int len = strlen(drivername);
1353
1354         if (!len)
1355                 return false;
1356
1357         DEBUG(10,("srv_spoolss_reset_printerdata: Sending message about resetting printerdata [%s]\n",
1358                 drivername));
1359
1360         messaging_send_buf(smbd_messaging_context(), procid_self(),
1361                            MSG_PRINTERDATA_INIT_RESET,
1362                            (uint8_t *)drivername, len+1);
1363
1364         return true;
1365 }
1366
1367 /**********************************************************************
1368  callback to receive a MSG_PRINTERDATA_INIT_RESET message and interate
1369  over all printers, resetting printer data as neessary
1370  **********************************************************************/
1371
1372 void reset_all_printerdata(struct messaging_context *msg,
1373                            void *private_data,
1374                            uint32_t msg_type,
1375                            struct server_id server_id,
1376                            DATA_BLOB *data)
1377 {
1378         fstring drivername;
1379         int snum;
1380         int n_services = lp_numservices();
1381         size_t len;
1382
1383         len = MIN( data->length, sizeof(drivername)-1 );
1384         strncpy( drivername, (const char *)data->data, len );
1385
1386         DEBUG(10,("reset_all_printerdata: Got message for new driver [%s]\n", drivername ));
1387
1388         /* Iterate the printer list */
1389
1390         for ( snum=0; snum<n_services; snum++ )
1391         {
1392                 if ( lp_snum_ok(snum) && lp_print_ok(snum) )
1393                 {
1394                         WERROR result;
1395                         NT_PRINTER_INFO_LEVEL *printer = NULL;
1396
1397                         result = get_a_printer( NULL, &printer, 2, lp_const_servicename(snum) );
1398                         if ( !W_ERROR_IS_OK(result) )
1399                                 continue;
1400
1401                         /*
1402                          * if the printer is bound to the driver,
1403                          * then reset to the new driver initdata
1404                          */
1405
1406                         if ( printer && printer->info_2 && !strcmp(drivername, printer->info_2->drivername) )
1407                         {
1408                                 DEBUG(6,("reset_all_printerdata: Updating printer [%s]\n", printer->info_2->printername));
1409
1410                                 if ( !set_driver_init(printer, 2) ) {
1411                                         DEBUG(5,("reset_all_printerdata: Error resetting printer data for printer [%s], driver [%s]!\n",
1412                                                 printer->info_2->printername, printer->info_2->drivername));
1413                                 }
1414
1415                                 result = mod_a_printer( printer, 2 );
1416                                 if ( !W_ERROR_IS_OK(result) ) {
1417                                         DEBUG(3,("reset_all_printerdata: mod_a_printer() failed!  (%s)\n",
1418                                                 get_dos_error_msg(result)));
1419                                 }
1420                         }
1421
1422                         free_a_printer( &printer, 2 );
1423                 }
1424         }
1425
1426         /* all done */
1427
1428         return;
1429 }
1430
1431 /****************************************************************
1432  _spoolss_OpenPrinter
1433 ****************************************************************/
1434
1435 WERROR _spoolss_OpenPrinter(pipes_struct *p,
1436                             struct spoolss_OpenPrinter *r)
1437 {
1438         struct spoolss_OpenPrinterEx e;
1439         WERROR werr;
1440
1441         ZERO_STRUCT(e.in.userlevel);
1442
1443         e.in.printername        = r->in.printername;
1444         e.in.datatype           = r->in.datatype;
1445         e.in.devmode_ctr        = r->in.devmode_ctr;
1446         e.in.access_mask        = r->in.access_mask;
1447         e.in.level              = 0;
1448
1449         e.out.handle            = r->out.handle;
1450
1451         werr = _spoolss_OpenPrinterEx(p, &e);
1452
1453         if (W_ERROR_EQUAL(werr, WERR_INVALID_PARAM)) {
1454                 /* OpenPrinterEx returns this for a bad
1455                  * printer name. We must return WERR_INVALID_PRINTER_NAME
1456                  * instead.
1457                  */
1458                 werr = WERR_INVALID_PRINTER_NAME;
1459         }
1460
1461         return werr;
1462 }
1463
1464 /********************************************************************
1465  ********************************************************************/
1466
1467 bool convert_devicemode(const char *printername,
1468                         const struct spoolss_DeviceMode *devmode,
1469                         NT_DEVICEMODE **pp_nt_devmode)
1470 {
1471         NT_DEVICEMODE *nt_devmode = *pp_nt_devmode;
1472
1473         /*
1474          * Ensure nt_devmode is a valid pointer
1475          * as we will be overwriting it.
1476          */
1477
1478         if (nt_devmode == NULL) {
1479                 DEBUG(5, ("convert_devicemode: allocating a generic devmode\n"));
1480                 if ((nt_devmode = construct_nt_devicemode(printername)) == NULL)
1481                         return false;
1482         }
1483
1484         rpcstr_push(nt_devmode->devicename, devmode->devicename, 31, 0);
1485         rpcstr_push(nt_devmode->formname, devmode->formname, 31, 0);
1486
1487         nt_devmode->specversion         = devmode->specversion;
1488         nt_devmode->driverversion       = devmode->driverversion;
1489         nt_devmode->size                = devmode->size;
1490         nt_devmode->fields              = devmode->fields;
1491         nt_devmode->orientation         = devmode->orientation;
1492         nt_devmode->papersize           = devmode->papersize;
1493         nt_devmode->paperlength         = devmode->paperlength;
1494         nt_devmode->paperwidth          = devmode->paperwidth;
1495         nt_devmode->scale               = devmode->scale;
1496         nt_devmode->copies              = devmode->copies;
1497         nt_devmode->defaultsource       = devmode->defaultsource;
1498         nt_devmode->printquality        = devmode->printquality;
1499         nt_devmode->color               = devmode->color;
1500         nt_devmode->duplex              = devmode->duplex;
1501         nt_devmode->yresolution         = devmode->yresolution;
1502         nt_devmode->ttoption            = devmode->ttoption;
1503         nt_devmode->collate             = devmode->collate;
1504
1505         nt_devmode->logpixels           = devmode->logpixels;
1506         nt_devmode->bitsperpel          = devmode->bitsperpel;
1507         nt_devmode->pelswidth           = devmode->pelswidth;
1508         nt_devmode->pelsheight          = devmode->pelsheight;
1509         nt_devmode->displayflags        = devmode->displayflags;
1510         nt_devmode->displayfrequency    = devmode->displayfrequency;
1511         nt_devmode->icmmethod           = devmode->icmmethod;
1512         nt_devmode->icmintent           = devmode->icmintent;
1513         nt_devmode->mediatype           = devmode->mediatype;
1514         nt_devmode->dithertype          = devmode->dithertype;
1515         nt_devmode->reserved1           = devmode->reserved1;
1516         nt_devmode->reserved2           = devmode->reserved2;
1517         nt_devmode->panningwidth        = devmode->panningwidth;
1518         nt_devmode->panningheight       = devmode->panningheight;
1519
1520         /*
1521          * Only change private and driverextra if the incoming devmode
1522          * has a new one. JRA.
1523          */
1524
1525         if ((devmode->__driverextra_length != 0) && (devmode->driverextra_data.data != NULL)) {
1526                 SAFE_FREE(nt_devmode->nt_dev_private);
1527                 nt_devmode->driverextra = devmode->__driverextra_length;
1528                 if((nt_devmode->nt_dev_private = SMB_MALLOC_ARRAY(uint8_t, nt_devmode->driverextra)) == NULL)
1529                         return false;
1530                 memcpy(nt_devmode->nt_dev_private, devmode->driverextra_data.data, nt_devmode->driverextra);
1531         }
1532
1533         *pp_nt_devmode = nt_devmode;
1534
1535         return true;
1536 }
1537
1538 /****************************************************************
1539  _spoolss_OpenPrinterEx
1540 ****************************************************************/
1541
1542 WERROR _spoolss_OpenPrinterEx(pipes_struct *p,
1543                               struct spoolss_OpenPrinterEx *r)
1544 {
1545         int snum;
1546         Printer_entry *Printer=NULL;
1547
1548         if (!r->in.printername) {
1549                 return WERR_INVALID_PARAM;
1550         }
1551
1552         /* some sanity check because you can open a printer or a print server */
1553         /* aka: \\server\printer or \\server */
1554
1555         DEBUGADD(3,("checking name: %s\n", r->in.printername));
1556
1557         if (!open_printer_hnd(p, r->out.handle, r->in.printername, 0)) {
1558                 ZERO_STRUCTP(r->out.handle);
1559                 return WERR_INVALID_PARAM;
1560         }
1561
1562         Printer = find_printer_index_by_hnd(p, r->out.handle);
1563         if ( !Printer ) {
1564                 DEBUG(0,("_spoolss_OpenPrinterEx: logic error.  Can't find printer "
1565                         "handle we created for printer %s\n", r->in.printername));
1566                 close_printer_handle(p, r->out.handle);
1567                 ZERO_STRUCTP(r->out.handle);
1568                 return WERR_INVALID_PARAM;
1569         }
1570
1571         /*
1572          * First case: the user is opening the print server:
1573          *
1574          * Disallow MS AddPrinterWizard if parameter disables it. A Win2k
1575          * client 1st tries an OpenPrinterEx with access==0, MUST be allowed.
1576          *
1577          * Then both Win2k and WinNT clients try an OpenPrinterEx with
1578          * SERVER_ALL_ACCESS, which we allow only if the user is root (uid=0)
1579          * or if the user is listed in the smb.conf printer admin parameter.
1580          *
1581          * Then they try OpenPrinterEx with SERVER_READ which we allow. This lets the
1582          * client view printer folder, but does not show the MSAPW.
1583          *
1584          * Note: this test needs code to check access rights here too. Jeremy
1585          * could you look at this?
1586          *
1587          * Second case: the user is opening a printer:
1588          * NT doesn't let us connect to a printer if the connecting user
1589          * doesn't have print permission.
1590          *
1591          * Third case: user is opening a Port Monitor
1592          * access checks same as opening a handle to the print server.
1593          */
1594
1595         switch (Printer->printer_type )
1596         {
1597         case SPLHND_SERVER:
1598         case SPLHND_PORTMON_TCP:
1599         case SPLHND_PORTMON_LOCAL:
1600                 /* Printserver handles use global struct... */
1601
1602                 snum = -1;
1603
1604                 /* Map standard access rights to object specific access rights */
1605
1606                 se_map_standard(&r->in.access_mask,
1607                                 &printserver_std_mapping);
1608
1609                 /* Deny any object specific bits that don't apply to print
1610                    servers (i.e printer and job specific bits) */
1611
1612                 r->in.access_mask &= SPECIFIC_RIGHTS_MASK;
1613
1614                 if (r->in.access_mask &
1615                     ~(SERVER_ACCESS_ADMINISTER | SERVER_ACCESS_ENUMERATE)) {
1616                         DEBUG(3, ("access DENIED for non-printserver bits\n"));
1617                         close_printer_handle(p, r->out.handle);
1618                         ZERO_STRUCTP(r->out.handle);
1619                         return WERR_ACCESS_DENIED;
1620                 }
1621
1622                 /* Allow admin access */
1623
1624                 if ( r->in.access_mask & SERVER_ACCESS_ADMINISTER )
1625                 {
1626                         SE_PRIV se_printop = SE_PRINT_OPERATOR;
1627
1628                         if (!lp_ms_add_printer_wizard()) {
1629                                 close_printer_handle(p, r->out.handle);
1630                                 ZERO_STRUCTP(r->out.handle);
1631                                 return WERR_ACCESS_DENIED;
1632                         }
1633
1634                         /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
1635                            and not a printer admin, then fail */
1636
1637                         if ((p->server_info->utok.uid != sec_initial_uid()) &&
1638                             !user_has_privileges(p->server_info->ptok,
1639                                                  &se_printop ) &&
1640                             !token_contains_name_in_list(
1641                                     uidtoname(p->server_info->utok.uid),
1642                                     NULL, NULL,
1643                                     p->server_info->ptok,
1644                                     lp_printer_admin(snum))) {
1645                                 close_printer_handle(p, r->out.handle);
1646                                 ZERO_STRUCTP(r->out.handle);
1647                                 return WERR_ACCESS_DENIED;
1648                         }
1649
1650                         r->in.access_mask = SERVER_ACCESS_ADMINISTER;
1651                 }
1652                 else
1653                 {
1654                         r->in.access_mask = SERVER_ACCESS_ENUMERATE;
1655                 }
1656
1657                 DEBUG(4,("Setting print server access = %s\n", (r->in.access_mask == SERVER_ACCESS_ADMINISTER)
1658                         ? "SERVER_ACCESS_ADMINISTER" : "SERVER_ACCESS_ENUMERATE" ));
1659
1660                 /* We fall through to return WERR_OK */
1661                 break;
1662
1663         case SPLHND_PRINTER:
1664                 /* NT doesn't let us connect to a printer if the connecting user
1665                    doesn't have print permission.  */
1666
1667                 if (!get_printer_snum(p, r->out.handle, &snum, NULL)) {
1668                         close_printer_handle(p, r->out.handle);
1669                         ZERO_STRUCTP(r->out.handle);
1670                         return WERR_BADFID;
1671                 }
1672
1673                 if (r->in.access_mask == SEC_FLAG_MAXIMUM_ALLOWED) {
1674                         r->in.access_mask = PRINTER_ACCESS_ADMINISTER;
1675                 }
1676
1677                 se_map_standard(&r->in.access_mask, &printer_std_mapping);
1678
1679                 /* map an empty access mask to the minimum access mask */
1680                 if (r->in.access_mask == 0x0)
1681                         r->in.access_mask = PRINTER_ACCESS_USE;
1682
1683                 /*
1684                  * If we are not serving the printer driver for this printer,
1685                  * map PRINTER_ACCESS_ADMINISTER to PRINTER_ACCESS_USE.  This
1686                  * will keep NT clients happy  --jerry
1687                  */
1688
1689                 if (lp_use_client_driver(snum)
1690                         && (r->in.access_mask & PRINTER_ACCESS_ADMINISTER))
1691                 {
1692                         r->in.access_mask = PRINTER_ACCESS_USE;
1693                 }
1694
1695                 /* check smb.conf parameters and the the sec_desc */
1696
1697                 if ( !check_access(get_client_fd(), lp_hostsallow(snum), lp_hostsdeny(snum)) ) {
1698                         DEBUG(3, ("access DENIED (hosts allow/deny) for printer open\n"));
1699                         ZERO_STRUCTP(r->out.handle);
1700                         return WERR_ACCESS_DENIED;
1701                 }
1702
1703                 if (!user_ok_token(uidtoname(p->server_info->utok.uid), NULL,
1704                                    p->server_info->ptok, snum) ||
1705                     !print_access_check(p->server_info, snum,
1706                                         r->in.access_mask)) {
1707                         DEBUG(3, ("access DENIED for printer open\n"));
1708                         close_printer_handle(p, r->out.handle);
1709                         ZERO_STRUCTP(r->out.handle);
1710                         return WERR_ACCESS_DENIED;
1711                 }
1712
1713                 if ((r->in.access_mask & SPECIFIC_RIGHTS_MASK)& ~(PRINTER_ACCESS_ADMINISTER|PRINTER_ACCESS_USE)) {
1714                         DEBUG(3, ("access DENIED for printer open - unknown bits\n"));
1715                         close_printer_handle(p, r->out.handle);
1716                         ZERO_STRUCTP(r->out.handle);
1717                         return WERR_ACCESS_DENIED;
1718                 }
1719
1720                 if (r->in.access_mask & PRINTER_ACCESS_ADMINISTER)
1721                         r->in.access_mask = PRINTER_ACCESS_ADMINISTER;
1722                 else
1723                         r->in.access_mask = PRINTER_ACCESS_USE;
1724
1725                 DEBUG(4,("Setting printer access = %s\n", (r->in.access_mask == PRINTER_ACCESS_ADMINISTER)
1726                         ? "PRINTER_ACCESS_ADMINISTER" : "PRINTER_ACCESS_USE" ));
1727
1728                 break;
1729
1730         default:
1731                 /* sanity check to prevent programmer error */
1732                 ZERO_STRUCTP(r->out.handle);
1733                 return WERR_BADFID;
1734         }
1735
1736         Printer->access_granted = r->in.access_mask;
1737
1738         /*
1739          * If the client sent a devmode in the OpenPrinter() call, then
1740          * save it here in case we get a job submission on this handle
1741          */
1742
1743          if ((Printer->printer_type != SPLHND_SERVER) &&
1744              r->in.devmode_ctr.devmode) {
1745                 convert_devicemode(Printer->sharename,
1746                                    r->in.devmode_ctr.devmode,
1747                                    &Printer->nt_devmode);
1748          }
1749
1750 #if 0   /* JERRY -- I'm doubtful this is really effective */
1751         /* HACK ALERT!!! Sleep for 1/3 of a second to try trigger a LAN/WAN
1752            optimization in Windows 2000 clients  --jerry */
1753
1754         if ( (r->in.access_mask == PRINTER_ACCESS_ADMINISTER)
1755                 && (RA_WIN2K == get_remote_arch()) )
1756         {
1757                 DEBUG(10,("_spoolss_OpenPrinterEx: Enabling LAN/WAN hack for Win2k clients.\n"));
1758                 sys_usleep( 500000 );
1759         }
1760 #endif
1761
1762         return WERR_OK;
1763 }
1764
1765 /****************************************************************************
1766 ****************************************************************************/
1767
1768 static bool printer_info2_to_nt_printer_info2(struct spoolss_SetPrinterInfo2 *r,
1769                                               NT_PRINTER_INFO_LEVEL_2 *d)
1770 {
1771         DEBUG(7,("printer_info2_to_nt_printer_info2\n"));
1772
1773         if (!r || !d) {
1774                 return false;
1775         }
1776
1777         d->attributes           = r->attributes;
1778         d->priority             = r->priority;
1779         d->default_priority     = r->defaultpriority;
1780         d->starttime            = r->starttime;
1781         d->untiltime            = r->untiltime;
1782         d->status               = r->status;
1783         d->cjobs                = r->cjobs;
1784
1785         fstrcpy(d->servername,  r->servername);
1786         fstrcpy(d->printername, r->printername);
1787         fstrcpy(d->sharename,   r->sharename);
1788         fstrcpy(d->portname,    r->portname);
1789         fstrcpy(d->drivername,  r->drivername);
1790         slprintf(d->comment, sizeof(d->comment)-1, "%s", r->comment);
1791         fstrcpy(d->location,    r->location);
1792         fstrcpy(d->sepfile,     r->sepfile);
1793         fstrcpy(d->printprocessor, r->printprocessor);
1794         fstrcpy(d->datatype,    r->datatype);
1795         fstrcpy(d->parameters,  r->parameters);
1796
1797         return true;
1798 }
1799
1800 /****************************************************************************
1801 ****************************************************************************/
1802
1803 static bool convert_printer_info(struct spoolss_SetPrinterInfoCtr *info_ctr,
1804                                  NT_PRINTER_INFO_LEVEL *printer)
1805 {
1806         bool ret;
1807
1808         switch (info_ctr->level) {
1809         case 2:
1810                 /* allocate memory if needed.  Messy because
1811                    convert_printer_info is used to update an existing
1812                    printer or build a new one */
1813
1814                 if (!printer->info_2) {
1815                         printer->info_2 = TALLOC_ZERO_P(printer, NT_PRINTER_INFO_LEVEL_2);
1816                         if (!printer->info_2) {
1817                                 DEBUG(0,("convert_printer_info: "
1818                                         "talloc() failed!\n"));
1819                                 return false;
1820                         }
1821                 }
1822
1823                 ret = printer_info2_to_nt_printer_info2(info_ctr->info.info2,
1824                                                         printer->info_2);
1825                 printer->info_2->setuptime = time(NULL);
1826                 return ret;
1827         }
1828
1829         return false;
1830 }
1831
1832 /*******************************************************************
1833 ********************************************************************/
1834
1835 static bool string_array_to_fstring_array(const char **sarray, fstring **farray)
1836 {
1837         int i;
1838
1839         if (!sarray) {
1840                 *farray = NULL;
1841                 return true;
1842         }
1843
1844         *farray = SMB_MALLOC_ARRAY(fstring, 1);
1845         if (!*farray) {
1846                 return false;
1847         }
1848
1849         for (i=0; sarray[i] != NULL; i++) {
1850                 *farray = SMB_REALLOC_ARRAY(*farray, fstring, i+2);
1851                 if (!*farray) {
1852                         return false;
1853                 }
1854                 fstrcpy((*farray)[i], sarray[i]);
1855         }
1856
1857         fstrcpy((*farray)[i], "");
1858
1859         return true;
1860 }
1861
1862 /*******************************************************************
1863 ********************************************************************/
1864
1865 static bool driver_info3_to_nt_driver_info3(struct spoolss_AddDriverInfo3 *r,
1866                                             NT_PRINTER_DRIVER_INFO_LEVEL_3 **p)
1867 {
1868         NT_PRINTER_DRIVER_INFO_LEVEL_3 *d;
1869
1870         DEBUG(7,("driver_info3_to_nt_driver_info3: Converting from UNICODE to ASCII\n"));
1871
1872         if (*p == NULL) {
1873                 *p = SMB_MALLOC_P(NT_PRINTER_DRIVER_INFO_LEVEL_3);
1874                 if (*p == NULL) {
1875                         return false;
1876                 }
1877                 ZERO_STRUCTP(*p);
1878         }
1879
1880         d = *p;
1881
1882         d->cversion =                   r->version;
1883
1884         fstrcpy(d->name,                r->driver_name);
1885         fstrcpy(d->environment,         r->architecture);
1886         fstrcpy(d->driverpath,          r->driver_path);
1887         fstrcpy(d->datafile,            r->data_file);
1888         fstrcpy(d->configfile,          r->config_file);
1889         fstrcpy(d->helpfile,            r->help_file);
1890         fstrcpy(d->monitorname,         r->monitor_name);
1891         fstrcpy(d->defaultdatatype,     r->default_datatype);
1892
1893         DEBUGADD(8,( "version:         %d\n", d->cversion));
1894         DEBUGADD(8,( "name:            %s\n", d->name));
1895         DEBUGADD(8,( "environment:     %s\n", d->environment));
1896         DEBUGADD(8,( "driverpath:      %s\n", d->driverpath));
1897         DEBUGADD(8,( "datafile:        %s\n", d->datafile));
1898         DEBUGADD(8,( "configfile:      %s\n", d->configfile));
1899         DEBUGADD(8,( "helpfile:        %s\n", d->helpfile));
1900         DEBUGADD(8,( "monitorname:     %s\n", d->monitorname));
1901         DEBUGADD(8,( "defaultdatatype: %s\n", d->defaultdatatype));
1902
1903         if (r->dependent_files) {
1904                 if (!string_array_to_fstring_array(r->dependent_files->string,
1905                                                    &d->dependentfiles)) {
1906                         SAFE_FREE(*p);
1907                         return false;
1908                 }
1909         }
1910
1911         return true;
1912 }
1913
1914 /*******************************************************************
1915 ********************************************************************/
1916
1917 static bool driver_info6_to_nt_driver_info6(struct spoolss_AddDriverInfo6 *r,
1918                                             NT_PRINTER_DRIVER_INFO_LEVEL_6 **p)
1919 {
1920         NT_PRINTER_DRIVER_INFO_LEVEL_6 *d;
1921
1922         DEBUG(7,("driver_info6_to_nt_driver_info6: Converting from UNICODE to ASCII\n"));
1923
1924         if (*p == NULL) {
1925                 *p = SMB_MALLOC_P(NT_PRINTER_DRIVER_INFO_LEVEL_6);
1926                 if (*p == NULL) {
1927                         return false;
1928                 }
1929                 ZERO_STRUCTP(*p);
1930         }
1931
1932         d = *p;
1933
1934         d->version =                    r->version;
1935
1936         fstrcpy(d->name,                r->driver_name);
1937         fstrcpy(d->environment,         r->architecture);
1938         fstrcpy(d->driverpath,          r->driver_path);
1939         fstrcpy(d->datafile,            r->data_file);
1940         fstrcpy(d->configfile,          r->config_file);
1941         fstrcpy(d->helpfile,            r->help_file);
1942         fstrcpy(d->monitorname,         r->monitor_name);
1943         fstrcpy(d->defaultdatatype,     r->default_datatype);
1944
1945         DEBUGADD(8,( "version:         %d\n", d->version));
1946         DEBUGADD(8,( "name:            %s\n", d->name));
1947         DEBUGADD(8,( "environment:     %s\n", d->environment));
1948         DEBUGADD(8,( "driverpath:      %s\n", d->driverpath));
1949         DEBUGADD(8,( "datafile:        %s\n", d->datafile));
1950         DEBUGADD(8,( "configfile:      %s\n", d->configfile));
1951         DEBUGADD(8,( "helpfile:        %s\n", d->helpfile));
1952         DEBUGADD(8,( "monitorname:     %s\n", d->monitorname));
1953         DEBUGADD(8,( "defaultdatatype: %s\n", d->defaultdatatype));
1954
1955         if (r->dependent_files) {
1956                 if (!string_array_to_fstring_array(r->dependent_files->string,
1957                                                    &d->dependentfiles)) {
1958                         goto error;
1959                 }
1960         }
1961
1962         if (r->previous_names) {
1963                 if (!string_array_to_fstring_array(r->previous_names->string,
1964                                                    &d->previousnames)) {
1965                         goto error;
1966                 }
1967         }
1968
1969         return true;
1970
1971  error:
1972         SAFE_FREE(*p);
1973         return false;
1974 }
1975
1976 /********************************************************************
1977  ********************************************************************/
1978
1979 static bool convert_printer_driver_info(const struct spoolss_AddDriverInfoCtr *r,
1980                                         NT_PRINTER_DRIVER_INFO_LEVEL *printer,
1981                                         uint32_t level)
1982 {
1983         switch (level) {
1984         case 3:
1985                 printer->info_3 = NULL;
1986                 if (!driver_info3_to_nt_driver_info3(r->info.info3, &printer->info_3)) {
1987                         return false;
1988                 }
1989                 break;
1990         case 6:
1991                 printer->info_6 = NULL;
1992                 if (!driver_info6_to_nt_driver_info6(r->info.info6, &printer->info_6)) {
1993                         return false;
1994                 }
1995                 break;
1996         default:
1997                 return false;
1998         }
1999
2000         return true;
2001 }
2002
2003 /********************************************************************
2004  * _spoolss_enddocprinter_internal.
2005  ********************************************************************/
2006
2007 static WERROR _spoolss_enddocprinter_internal(pipes_struct *p,
2008                                               struct policy_handle *handle)
2009 {
2010         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
2011         int snum;
2012
2013         if (!Printer) {
2014                 DEBUG(2,("_spoolss_enddocprinter_internal: Invalid handle (%s:%u:%u)\n", OUR_HANDLE(handle)));
2015                 return WERR_BADFID;
2016         }
2017
2018         if (!get_printer_snum(p, handle, &snum, NULL))
2019                 return WERR_BADFID;
2020
2021         Printer->document_started = false;
2022         print_job_end(snum, Printer->jobid,NORMAL_CLOSE);
2023         /* error codes unhandled so far ... */
2024
2025         return WERR_OK;
2026 }
2027
2028 /****************************************************************
2029  _spoolss_ClosePrinter
2030 ****************************************************************/
2031
2032 WERROR _spoolss_ClosePrinter(pipes_struct *p,
2033                              struct spoolss_ClosePrinter *r)
2034 {
2035         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
2036
2037         if (Printer && Printer->document_started)
2038                 _spoolss_enddocprinter_internal(p, r->in.handle);          /* print job was not closed */
2039
2040         if (!close_printer_handle(p, r->in.handle))
2041                 return WERR_BADFID;
2042
2043         /* clear the returned printer handle.  Observed behavior
2044            from Win2k server.  Don't think this really matters.
2045            Previous code just copied the value of the closed
2046            handle.    --jerry */
2047
2048         ZERO_STRUCTP(r->out.handle);
2049
2050         return WERR_OK;
2051 }
2052
2053 /****************************************************************
2054  _spoolss_DeletePrinter
2055 ****************************************************************/
2056
2057 WERROR _spoolss_DeletePrinter(pipes_struct *p,
2058                               struct spoolss_DeletePrinter *r)
2059 {
2060         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
2061         WERROR result;
2062
2063         if (Printer && Printer->document_started)
2064                 _spoolss_enddocprinter_internal(p, r->in.handle);  /* print job was not closed */
2065
2066         result = delete_printer_handle(p, r->in.handle);
2067
2068         update_c_setprinter(false);
2069
2070         return result;
2071 }
2072
2073 /*******************************************************************
2074  * static function to lookup the version id corresponding to an
2075  * long architecture string
2076  ******************************************************************/
2077
2078 static int get_version_id(const char *arch)
2079 {
2080         int i;
2081         struct print_architecture_table_node archi_table[]= {
2082
2083                 {"Windows 4.0",          "WIN40",       0 },
2084                 {"Windows NT x86",       "W32X86",      2 },
2085                 {"Windows NT R4000",     "W32MIPS",     2 },
2086                 {"Windows NT Alpha_AXP", "W32ALPHA",    2 },
2087                 {"Windows NT PowerPC",   "W32PPC",      2 },
2088                 {"Windows IA64",         "IA64",        3 },
2089                 {"Windows x64",          "x64",         3 },
2090                 {NULL,                   "",            -1 }
2091         };
2092
2093         for (i=0; archi_table[i].long_archi != NULL; i++)
2094         {
2095                 if (strcmp(arch, archi_table[i].long_archi) == 0)
2096                         return (archi_table[i].version);
2097         }
2098
2099         return -1;
2100 }
2101
2102 /****************************************************************
2103  _spoolss_DeletePrinterDriver
2104 ****************************************************************/
2105
2106 WERROR _spoolss_DeletePrinterDriver(pipes_struct *p,
2107                                     struct spoolss_DeletePrinterDriver *r)
2108 {
2109         NT_PRINTER_DRIVER_INFO_LEVEL    info;
2110         NT_PRINTER_DRIVER_INFO_LEVEL    info_win2k;
2111         int                             version;
2112         WERROR                          status;
2113         WERROR                          status_win2k = WERR_ACCESS_DENIED;
2114         SE_PRIV                         se_printop = SE_PRINT_OPERATOR;
2115
2116         /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
2117            and not a printer admin, then fail */
2118
2119         if ( (p->server_info->utok.uid != sec_initial_uid())
2120                 && !user_has_privileges(p->server_info->ptok, &se_printop )
2121                 && !token_contains_name_in_list(
2122                         uidtoname(p->server_info->utok.uid), NULL,
2123                         NULL, p->server_info->ptok,
2124                         lp_printer_admin(-1)) )
2125         {
2126                 return WERR_ACCESS_DENIED;
2127         }
2128
2129         /* check that we have a valid driver name first */
2130
2131         if ((version = get_version_id(r->in.architecture)) == -1)
2132                 return WERR_INVALID_ENVIRONMENT;
2133
2134         ZERO_STRUCT(info);
2135         ZERO_STRUCT(info_win2k);
2136
2137         if (!W_ERROR_IS_OK(get_a_printer_driver(&info, 3, r->in.driver,
2138                                                 r->in.architecture,
2139                                                 version)))
2140         {
2141                 /* try for Win2k driver if "Windows NT x86" */
2142
2143                 if ( version == 2 ) {
2144                         version = 3;
2145                         if (!W_ERROR_IS_OK(get_a_printer_driver(&info, 3,
2146                                                                 r->in.driver,
2147                                                                 r->in.architecture,
2148                                                                 version))) {
2149                                 status = WERR_UNKNOWN_PRINTER_DRIVER;
2150                                 goto done;
2151                         }
2152                 }
2153                 /* otherwise it was a failure */
2154                 else {
2155                         status = WERR_UNKNOWN_PRINTER_DRIVER;
2156                         goto done;
2157                 }
2158
2159         }
2160
2161         if (printer_driver_in_use(info.info_3)) {
2162                 status = WERR_PRINTER_DRIVER_IN_USE;
2163                 goto done;
2164         }
2165
2166         if ( version == 2 )
2167         {
2168                 if (W_ERROR_IS_OK(get_a_printer_driver(&info_win2k, 3,
2169                                                        r->in.driver,
2170                                                        r->in.architecture, 3)))
2171                 {
2172                         /* if we get to here, we now have 2 driver info structures to remove */
2173                         /* remove the Win2k driver first*/
2174
2175                         status_win2k = delete_printer_driver(
2176                                 p, info_win2k.info_3, 3, false);
2177                         free_a_printer_driver( info_win2k, 3 );
2178
2179                         /* this should not have failed---if it did, report to client */
2180                         if ( !W_ERROR_IS_OK(status_win2k) )
2181                         {
2182                                 status = status_win2k;
2183                                 goto done;
2184                         }
2185                 }
2186         }
2187
2188         status = delete_printer_driver(p, info.info_3, version, false);
2189
2190         /* if at least one of the deletes succeeded return OK */
2191
2192         if ( W_ERROR_IS_OK(status) || W_ERROR_IS_OK(status_win2k) )
2193                 status = WERR_OK;
2194
2195 done:
2196         free_a_printer_driver( info, 3 );
2197
2198         return status;
2199 }
2200
2201 /****************************************************************
2202  _spoolss_DeletePrinterDriverEx
2203 ****************************************************************/
2204
2205 WERROR _spoolss_DeletePrinterDriverEx(pipes_struct *p,
2206                                       struct spoolss_DeletePrinterDriverEx *r)
2207 {
2208         NT_PRINTER_DRIVER_INFO_LEVEL    info;
2209         NT_PRINTER_DRIVER_INFO_LEVEL    info_win2k;
2210         int                             version;
2211         bool                            delete_files;
2212         WERROR                          status;
2213         WERROR                          status_win2k = WERR_ACCESS_DENIED;
2214         SE_PRIV                         se_printop = SE_PRINT_OPERATOR;
2215
2216         /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
2217            and not a printer admin, then fail */
2218
2219         if ( (p->server_info->utok.uid != sec_initial_uid())
2220                 && !user_has_privileges(p->server_info->ptok, &se_printop )
2221                 && !token_contains_name_in_list(
2222                         uidtoname(p->server_info->utok.uid), NULL, NULL,
2223                         p->server_info->ptok, lp_printer_admin(-1)) )
2224         {
2225                 return WERR_ACCESS_DENIED;
2226         }
2227
2228         /* check that we have a valid driver name first */
2229         if ((version = get_version_id(r->in.architecture)) == -1) {
2230                 /* this is what NT returns */
2231                 return WERR_INVALID_ENVIRONMENT;
2232         }
2233
2234         if (r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION)
2235                 version = r->in.version;
2236
2237         ZERO_STRUCT(info);
2238         ZERO_STRUCT(info_win2k);
2239
2240         status = get_a_printer_driver(&info, 3, r->in.driver,
2241                                       r->in.architecture, version);
2242
2243         if ( !W_ERROR_IS_OK(status) )
2244         {
2245                 /*
2246                  * if the client asked for a specific version,
2247                  * or this is something other than Windows NT x86,
2248                  * then we've failed
2249                  */
2250
2251                 if ( (r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION) || (version !=2) )
2252                         goto done;
2253
2254                 /* try for Win2k driver if "Windows NT x86" */
2255
2256                 version = 3;
2257                 if (!W_ERROR_IS_OK(get_a_printer_driver(&info, 3, r->in.driver,
2258                                                         r->in.architecture,
2259                                                         version))) {
2260                         status = WERR_UNKNOWN_PRINTER_DRIVER;
2261                         goto done;
2262                 }
2263         }
2264
2265         if ( printer_driver_in_use(info.info_3) ) {
2266                 status = WERR_PRINTER_DRIVER_IN_USE;
2267                 goto done;
2268         }
2269
2270         /*
2271          * we have a couple of cases to consider.
2272          * (1) Are any files in use?  If so and DPD_DELTE_ALL_FILE is set,
2273          *     then the delete should fail if **any** files overlap with
2274          *     other drivers
2275          * (2) If DPD_DELTE_UNUSED_FILES is sert, then delete all
2276          *     non-overlapping files
2277          * (3) If neither DPD_DELTE_ALL_FILE nor DPD_DELTE_ALL_FILES
2278          *     is set, the do not delete any files
2279          * Refer to MSDN docs on DeletePrinterDriverEx() for details.
2280          */
2281
2282         delete_files = r->in.delete_flags & (DPD_DELETE_ALL_FILES|DPD_DELETE_UNUSED_FILES);
2283
2284         /* fail if any files are in use and DPD_DELETE_ALL_FILES is set */
2285
2286         if ( delete_files && printer_driver_files_in_use(info.info_3) & (r->in.delete_flags & DPD_DELETE_ALL_FILES) ) {
2287                 /* no idea of the correct error here */
2288                 status = WERR_ACCESS_DENIED;
2289                 goto done;
2290         }
2291
2292
2293         /* also check for W32X86/3 if necessary; maybe we already have? */
2294
2295         if ( (version == 2) && ((r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION) != DPD_DELETE_SPECIFIC_VERSION)  ) {
2296                 if (W_ERROR_IS_OK(get_a_printer_driver(&info_win2k, 3,
2297                                                        r->in.driver,
2298                                                        r->in.architecture, 3)))
2299                 {
2300
2301                         if ( delete_files && printer_driver_files_in_use(info_win2k.info_3) & (r->in.delete_flags & DPD_DELETE_ALL_FILES) ) {
2302                                 /* no idea of the correct error here */
2303                                 free_a_printer_driver( info_win2k, 3 );
2304                                 status = WERR_ACCESS_DENIED;
2305                                 goto done;
2306                         }
2307
2308                         /* if we get to here, we now have 2 driver info structures to remove */
2309                         /* remove the Win2k driver first*/
2310
2311                         status_win2k = delete_printer_driver(
2312                                 p, info_win2k.info_3, 3, delete_files);
2313                         free_a_printer_driver( info_win2k, 3 );
2314
2315                         /* this should not have failed---if it did, report to client */
2316
2317                         if ( !W_ERROR_IS_OK(status_win2k) )
2318                                 goto done;
2319                 }
2320         }
2321
2322         status = delete_printer_driver(p, info.info_3, version, delete_files);
2323
2324         if ( W_ERROR_IS_OK(status) || W_ERROR_IS_OK(status_win2k) )
2325                 status = WERR_OK;
2326 done:
2327         free_a_printer_driver( info, 3 );
2328
2329         return status;
2330 }
2331
2332
2333 /****************************************************************************
2334  Internal routine for removing printerdata
2335  ***************************************************************************/
2336
2337 static WERROR delete_printer_dataex( NT_PRINTER_INFO_LEVEL *printer, const char *key, const char *value )
2338 {
2339         return delete_printer_data( printer->info_2, key, value );
2340 }
2341
2342 /****************************************************************************
2343  Internal routine for storing printerdata
2344  ***************************************************************************/
2345
2346 WERROR set_printer_dataex(NT_PRINTER_INFO_LEVEL *printer,
2347                           const char *key, const char *value,
2348                           uint32_t type, uint8_t *data, int real_len)
2349 {
2350         /* the registry objects enforce uniqueness based on value name */
2351
2352         return add_printer_data( printer->info_2, key, value, type, data, real_len );
2353 }
2354
2355 /********************************************************************
2356  GetPrinterData on a printer server Handle.
2357 ********************************************************************/
2358
2359 static WERROR getprinterdata_printer_server(TALLOC_CTX *mem_ctx,
2360                                             const char *value,
2361                                             enum winreg_Type *type,
2362                                             union spoolss_PrinterData *data)
2363 {
2364         DEBUG(8,("getprinterdata_printer_server:%s\n", value));
2365
2366         if (!StrCaseCmp(value, "W3SvcInstalled")) {
2367                 *type = REG_DWORD;
2368                 data->value = 0x00;
2369                 return WERR_OK;
2370         }
2371
2372         if (!StrCaseCmp(value, "BeepEnabled")) {
2373                 *type = REG_DWORD;
2374                 data->value = 0x00;
2375                 return WERR_OK;
2376         }
2377
2378         if (!StrCaseCmp(value, "EventLog")) {
2379                 *type = REG_DWORD;
2380                 /* formally was 0x1b */
2381                 data->value = 0x00;
2382                 return WERR_OK;
2383         }
2384
2385         if (!StrCaseCmp(value, "NetPopup")) {
2386                 *type = REG_DWORD;
2387                 data->value = 0x00;
2388                 return WERR_OK;
2389         }
2390
2391         if (!StrCaseCmp(value, "MajorVersion")) {
2392                 *type = REG_DWORD;
2393
2394                 /* Windows NT 4.0 seems to not allow uploading of drivers
2395                    to a server that reports 0x3 as the MajorVersion.
2396                    need to investigate more how Win2k gets around this .
2397                    -- jerry */
2398
2399                 if (RA_WINNT == get_remote_arch()) {
2400                         data->value = 0x02;
2401                 } else {
2402                         data->value = 0x03;
2403                 }
2404
2405                 return WERR_OK;
2406         }
2407
2408         if (!StrCaseCmp(value, "MinorVersion")) {
2409                 *type = REG_DWORD;
2410                 data->value = 0x00;
2411                 return WERR_OK;
2412         }
2413
2414         /* REG_BINARY
2415          *  uint32_t size        = 0x114
2416          *  uint32_t major       = 5
2417          *  uint32_t minor       = [0|1]
2418          *  uint32_t build       = [2195|2600]
2419          *  extra unicode string = e.g. "Service Pack 3"
2420          */
2421         if (!StrCaseCmp(value, "OSVersion")) {
2422                 DATA_BLOB blob;
2423                 enum ndr_err_code ndr_err;
2424                 struct spoolss_OSVersion os;
2425
2426                 os.major                = 5;    /* Windows 2000 == 5.0 */
2427                 os.minor                = 0;
2428                 os.build                = 2195; /* build */
2429                 os.extra_string         = "";   /* leave extra string empty */
2430
2431                 ndr_err = ndr_push_struct_blob(&blob, mem_ctx, NULL, &os,
2432                         (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion);
2433                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2434                         return WERR_GENERAL_FAILURE;
2435                 }
2436
2437                 *type = REG_BINARY;
2438                 data->binary = blob;
2439
2440                 return WERR_OK;
2441         }
2442
2443
2444         if (!StrCaseCmp(value, "DefaultSpoolDirectory")) {
2445                 *type = REG_SZ;
2446
2447                 data->string = talloc_strdup(mem_ctx, "C:\\PRINTERS");
2448                 W_ERROR_HAVE_NO_MEMORY(data->string);
2449
2450                 return WERR_OK;
2451         }
2452
2453         if (!StrCaseCmp(value, "Architecture")) {
2454                 *type = REG_SZ;
2455
2456                 data->string = talloc_strdup(mem_ctx, "Windows NT x86");
2457                 W_ERROR_HAVE_NO_MEMORY(data->string);
2458
2459                 return WERR_OK;
2460         }
2461
2462         if (!StrCaseCmp(value, "DsPresent")) {
2463                 *type = REG_DWORD;
2464
2465                 /* only show the publish check box if we are a
2466                    member of a AD domain */
2467
2468                 if (lp_security() == SEC_ADS) {
2469                         data->value = 0x01;
2470                 } else {
2471                         data->value = 0x00;
2472                 }
2473                 return WERR_OK;
2474         }
2475
2476         if (!StrCaseCmp(value, "DNSMachineName")) {
2477                 const char *hostname = get_mydnsfullname();
2478
2479                 if (!hostname) {
2480                         return WERR_BADFILE;
2481                 }
2482
2483                 *type = REG_SZ;
2484                 data->string = talloc_strdup(mem_ctx, hostname);
2485                 W_ERROR_HAVE_NO_MEMORY(data->string);
2486
2487                 return WERR_OK;
2488         }
2489
2490         return WERR_INVALID_PARAM;
2491 }
2492
2493 /****************************************************************
2494  _spoolss_GetPrinterData
2495 ****************************************************************/
2496
2497 WERROR _spoolss_GetPrinterData(pipes_struct *p,
2498                                struct spoolss_GetPrinterData *r)
2499 {
2500         WERROR result;
2501         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
2502         NT_PRINTER_INFO_LEVEL *printer = NULL;
2503         int snum = 0;
2504
2505         /*
2506          * Reminder: when it's a string, the length is in BYTES
2507          * even if UNICODE is negociated.
2508          *
2509          * JFM, 4/19/1999
2510          */
2511
2512         /* in case of problem, return some default values */
2513
2514         *r->out.needed  = 0;
2515         *r->out.type    = 0;
2516
2517         DEBUG(4,("_spoolss_GetPrinterData\n"));
2518
2519         if (!Printer) {
2520                 DEBUG(2,("_spoolss_GetPrinterData: Invalid handle (%s:%u:%u).\n",
2521                         OUR_HANDLE(r->in.handle)));
2522                 result = WERR_BADFID;
2523                 goto done;
2524         }
2525
2526         if (Printer->printer_type == SPLHND_SERVER) {
2527                 result = getprinterdata_printer_server(p->mem_ctx,
2528                                                        r->in.value_name,
2529                                                        r->out.type,
2530                                                        r->out.data);
2531         } else {
2532                 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
2533                         result = WERR_BADFID;
2534                         goto done;
2535                 }
2536
2537                 result = get_a_printer(Printer, &printer, 2, lp_servicename(snum));
2538                 if (!W_ERROR_IS_OK(result)) {
2539                         goto done;
2540                 }
2541
2542                 /* XP sends this and wants to change id value from the PRINTER_INFO_0 */
2543
2544                 if (strequal(r->in.value_name, "ChangeId")) {
2545                         *r->out.type = REG_DWORD;
2546                         r->out.data->value = printer->info_2->changeid;
2547                         result = WERR_OK;
2548                 } else {
2549                         struct regval_blob *v;
2550                         DATA_BLOB blob;
2551
2552                         v = get_printer_data(printer->info_2,
2553                                              SPOOL_PRINTERDATA_KEY,
2554                                              r->in.value_name);
2555                         if (!v) {
2556                                 result = WERR_BADFILE;
2557                                 goto done;
2558                         }
2559
2560                         *r->out.type = v->type;
2561
2562                         blob = data_blob_const(v->data_p, v->size);
2563
2564                         result = pull_spoolss_PrinterData(p->mem_ctx, &blob,
2565                                                           r->out.data,
2566                                                           *r->out.type);
2567                 }
2568         }
2569
2570  done:
2571         /* cleanup & exit */
2572
2573         if (printer) {
2574                 free_a_printer(&printer, 2);
2575         }
2576
2577         if (!W_ERROR_IS_OK(result)) {
2578                 return result;
2579         }
2580
2581         *r->out.needed  = ndr_size_spoolss_PrinterData(r->out.data, *r->out.type, NULL, 0);
2582         *r->out.type    = SPOOLSS_BUFFER_OK(*r->out.type, REG_NONE);
2583         r->out.data     = SPOOLSS_BUFFER_OK(r->out.data, r->out.data);
2584
2585         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
2586 }
2587
2588 /*********************************************************
2589  Connect to the client machine.
2590 **********************************************************/
2591
2592 static bool spoolss_connect_to_client(struct rpc_pipe_client **pp_pipe,
2593                         struct sockaddr_storage *client_ss, const char *remote_machine)
2594 {
2595         NTSTATUS ret;
2596         struct cli_state *the_cli;
2597         struct sockaddr_storage rm_addr;
2598
2599         if ( is_zero_addr((struct sockaddr *)client_ss) ) {
2600                 if ( !resolve_name( remote_machine, &rm_addr, 0x20) ) {
2601                         DEBUG(2,("spoolss_connect_to_client: Can't resolve address for %s\n", remote_machine));
2602                         return false;
2603                 }
2604
2605                 if (ismyaddr((struct sockaddr *)&rm_addr)) {
2606                         DEBUG(0,("spoolss_connect_to_client: Machine %s is one of our addresses. Cannot add to ourselves.\n", remote_machine));
2607                         return false;
2608                 }
2609         } else {
2610                 char addr[INET6_ADDRSTRLEN];
2611                 rm_addr = *client_ss;
2612                 print_sockaddr(addr, sizeof(addr), &rm_addr);
2613                 DEBUG(5,("spoolss_connect_to_client: Using address %s (no name resolution necessary)\n",
2614                         addr));
2615         }
2616
2617         /* setup the connection */
2618
2619         ret = cli_full_connection( &the_cli, global_myname(), remote_machine,
2620                 &rm_addr, 0, "IPC$", "IPC",
2621                 "", /* username */
2622                 "", /* domain */
2623                 "", /* password */
2624                 0, lp_client_signing(), NULL );
2625
2626         if ( !NT_STATUS_IS_OK( ret ) ) {
2627                 DEBUG(2,("spoolss_connect_to_client: connection to [%s] failed!\n",
2628                         remote_machine ));
2629                 return false;
2630         }
2631
2632         if ( the_cli->protocol != PROTOCOL_NT1 ) {
2633                 DEBUG(0,("spoolss_connect_to_client: machine %s didn't negotiate NT protocol.\n", remote_machine));
2634                 cli_shutdown(the_cli);
2635                 return false;
2636         }
2637
2638         /*
2639          * Ok - we have an anonymous connection to the IPC$ share.
2640          * Now start the NT Domain stuff :-).
2641          */
2642
2643         ret = cli_rpc_pipe_open_noauth(the_cli, &ndr_table_spoolss.syntax_id, pp_pipe);
2644         if (!NT_STATUS_IS_OK(ret)) {
2645                 DEBUG(2,("spoolss_connect_to_client: unable to open the spoolss pipe on machine %s. Error was : %s.\n",
2646                         remote_machine, nt_errstr(ret)));
2647                 cli_shutdown(the_cli);
2648                 return false;
2649         }
2650
2651         return true;
2652 }
2653
2654 /***************************************************************************
2655  Connect to the client.
2656 ****************************************************************************/
2657
2658 static bool srv_spoolss_replyopenprinter(int snum, const char *printer,
2659                                         uint32_t localprinter, uint32_t type,
2660                                         struct policy_handle *handle,
2661                                         struct sockaddr_storage *client_ss)
2662 {
2663         WERROR result;
2664         NTSTATUS status;
2665
2666         /*
2667          * If it's the first connection, contact the client
2668          * and connect to the IPC$ share anonymously
2669          */
2670         if (smb_connections==0) {
2671                 fstring unix_printer;
2672
2673                 fstrcpy(unix_printer, printer+2); /* the +2 is to strip the leading 2 backslashs */
2674
2675                 if ( !spoolss_connect_to_client( &notify_cli_pipe, client_ss, unix_printer ))
2676                         return false;
2677
2678                 messaging_register(smbd_messaging_context(), NULL,
2679                                    MSG_PRINTER_NOTIFY2,
2680                                    receive_notify2_message_list);
2681                 /* Tell the connections db we're now interested in printer
2682                  * notify messages. */
2683                 register_message_flags(true, FLAG_MSG_PRINT_NOTIFY);
2684         }
2685
2686         /*
2687          * Tell the specific printing tdb we want messages for this printer
2688          * by registering our PID.
2689          */
2690
2691         if (!print_notify_register_pid(snum))
2692                 DEBUG(0,("print_notify_register_pid: Failed to register our pid for printer %s\n", printer ));
2693
2694         smb_connections++;
2695
2696         status = rpccli_spoolss_ReplyOpenPrinter(notify_cli_pipe, talloc_tos(),
2697                                                  printer,
2698                                                  localprinter,
2699                                                  type,
2700                                                  0,
2701                                                  NULL,
2702                                                  handle,
2703                                                  &result);
2704         if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result))
2705                 DEBUG(5,("srv_spoolss_reply_open_printer: Client RPC returned [%s]\n",
2706                         win_errstr(result)));
2707
2708         return (W_ERROR_IS_OK(result));
2709 }
2710
2711 /****************************************************************
2712  ****************************************************************/
2713
2714 static struct spoolss_NotifyOption *dup_spoolss_NotifyOption(TALLOC_CTX *mem_ctx,
2715                                                              const struct spoolss_NotifyOption *r)
2716 {
2717         struct spoolss_NotifyOption *option;
2718         uint32_t i,k;
2719
2720         if (!r) {
2721                 return NULL;
2722         }
2723
2724         option = talloc_zero(mem_ctx, struct spoolss_NotifyOption);
2725         if (!option) {
2726                 return NULL;
2727         }
2728
2729         *option = *r;
2730
2731         if (!option->count) {
2732                 return option;
2733         }
2734
2735         option->types = talloc_zero_array(option,
2736                 struct spoolss_NotifyOptionType, option->count);
2737         if (!option->types) {
2738                 talloc_free(option);
2739                 return NULL;
2740         }
2741
2742         for (i=0; i < option->count; i++) {
2743                 option->types[i] = r->types[i];
2744
2745                 if (option->types[i].count) {
2746                         option->types[i].fields = talloc_zero_array(option,
2747                                 union spoolss_Field, option->types[i].count);
2748                         if (!option->types[i].fields) {
2749                                 talloc_free(option);
2750                                 return NULL;
2751                         }
2752                         for (k=0; k<option->types[i].count; k++) {
2753                                 option->types[i].fields[k] =
2754                                         r->types[i].fields[k];
2755                         }
2756                 }
2757         }
2758
2759         return option;
2760 }
2761
2762 /****************************************************************
2763  * _spoolss_RemoteFindFirstPrinterChangeNotifyEx
2764  *
2765  * before replying OK: status=0 a rpc call is made to the workstation
2766  * asking ReplyOpenPrinter
2767  *
2768  * in fact ReplyOpenPrinter is the changenotify equivalent on the spoolss pipe
2769  * called from api_spoolss_rffpcnex
2770 ****************************************************************/
2771
2772 WERROR _spoolss_RemoteFindFirstPrinterChangeNotifyEx(pipes_struct *p,
2773                                                      struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
2774 {
2775         int snum = -1;
2776         struct spoolss_NotifyOption *option = r->in.notify_options;
2777         struct sockaddr_storage client_ss;
2778
2779         /* store the notify value in the printer struct */
2780
2781         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
2782
2783         if (!Printer) {
2784                 DEBUG(2,("_spoolss_RemoteFindFirstPrinterChangeNotifyEx: "
2785                         "Invalid handle (%s:%u:%u).\n",
2786                         OUR_HANDLE(r->in.handle)));
2787                 return WERR_BADFID;
2788         }
2789
2790         Printer->notify.flags           = r->in.flags;
2791         Printer->notify.options         = r->in.options;
2792         Printer->notify.printerlocal    = r->in.printer_local;
2793
2794         TALLOC_FREE(Printer->notify.option);
2795         Printer->notify.option = dup_spoolss_NotifyOption(Printer, option);
2796
2797         fstrcpy(Printer->notify.localmachine, r->in.local_machine);
2798
2799         /* Connect to the client machine and send a ReplyOpenPrinter */
2800
2801         if ( Printer->printer_type == SPLHND_SERVER)
2802                 snum = -1;
2803         else if ( (Printer->printer_type == SPLHND_PRINTER) &&
2804                         !get_printer_snum(p, r->in.handle, &snum, NULL) )
2805                 return WERR_BADFID;
2806
2807         if (!interpret_string_addr(&client_ss, p->client_address,
2808                                    AI_NUMERICHOST)) {
2809                 return WERR_SERVER_UNAVAILABLE;
2810         }
2811
2812         if(!srv_spoolss_replyopenprinter(snum, Printer->notify.localmachine,
2813                                         Printer->notify.printerlocal, 1,
2814                                         &Printer->notify.client_hnd, &client_ss))
2815                 return WERR_SERVER_UNAVAILABLE;
2816
2817         Printer->notify.client_connected = true;
2818
2819         return WERR_OK;
2820 }
2821
2822 /*******************************************************************
2823  * fill a notify_info_data with the servername
2824  ********************************************************************/
2825
2826 void spoolss_notify_server_name(int snum,
2827                                        struct spoolss_Notify *data,
2828                                        print_queue_struct *queue,
2829                                        NT_PRINTER_INFO_LEVEL *printer,
2830                                        TALLOC_CTX *mem_ctx)
2831 {
2832         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->servername);
2833 }
2834
2835 /*******************************************************************
2836  * fill a notify_info_data with the printername (not including the servername).
2837  ********************************************************************/
2838
2839 void spoolss_notify_printer_name(int snum,
2840                                         struct spoolss_Notify *data,
2841                                         print_queue_struct *queue,
2842                                         NT_PRINTER_INFO_LEVEL *printer,
2843                                         TALLOC_CTX *mem_ctx)
2844 {
2845         /* the notify name should not contain the \\server\ part */
2846         char *p = strrchr(printer->info_2->printername, '\\');
2847
2848         if (!p) {
2849                 p = printer->info_2->printername;
2850         } else {
2851                 p++;
2852         }
2853
2854         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, p);
2855 }
2856
2857 /*******************************************************************
2858  * fill a notify_info_data with the servicename
2859  ********************************************************************/
2860
2861 void spoolss_notify_share_name(int snum,
2862                                       struct spoolss_Notify *data,
2863                                       print_queue_struct *queue,
2864                                       NT_PRINTER_INFO_LEVEL *printer,
2865                                       TALLOC_CTX *mem_ctx)
2866 {
2867         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, lp_servicename(snum));
2868 }
2869
2870 /*******************************************************************
2871  * fill a notify_info_data with the port name
2872  ********************************************************************/
2873
2874 void spoolss_notify_port_name(int snum,
2875                                      struct spoolss_Notify *data,
2876                                      print_queue_struct *queue,
2877                                      NT_PRINTER_INFO_LEVEL *printer,
2878                                      TALLOC_CTX *mem_ctx)
2879 {
2880         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->portname);
2881 }
2882
2883 /*******************************************************************
2884  * fill a notify_info_data with the printername
2885  * but it doesn't exist, have to see what to do
2886  ********************************************************************/
2887
2888 void spoolss_notify_driver_name(int snum,
2889                                        struct spoolss_Notify *data,
2890                                        print_queue_struct *queue,
2891                                        NT_PRINTER_INFO_LEVEL *printer,
2892                                        TALLOC_CTX *mem_ctx)
2893 {
2894         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->drivername);
2895 }
2896
2897 /*******************************************************************
2898  * fill a notify_info_data with the comment
2899  ********************************************************************/
2900
2901 void spoolss_notify_comment(int snum,
2902                                    struct spoolss_Notify *data,
2903                                    print_queue_struct *queue,
2904                                    NT_PRINTER_INFO_LEVEL *printer,
2905                                    TALLOC_CTX *mem_ctx)
2906 {
2907         char *p;
2908
2909         if (*printer->info_2->comment == '\0') {
2910                 p = lp_comment(snum);
2911         } else {
2912                 p = printer->info_2->comment;
2913         }
2914
2915         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->comment);
2916 }
2917
2918 /*******************************************************************
2919  * fill a notify_info_data with the comment
2920  * location = "Room 1, floor 2, building 3"
2921  ********************************************************************/
2922
2923 void spoolss_notify_location(int snum,
2924                                     struct spoolss_Notify *data,
2925                                     print_queue_struct *queue,
2926                                     NT_PRINTER_INFO_LEVEL *printer,
2927                                     TALLOC_CTX *mem_ctx)
2928 {
2929         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->location);
2930 }
2931
2932 /*******************************************************************
2933  * fill a notify_info_data with the device mode
2934  * jfm:xxxx don't to it for know but that's a real problem !!!
2935  ********************************************************************/
2936
2937 static void spoolss_notify_devmode(int snum,
2938                                    struct spoolss_Notify *data,
2939                                    print_queue_struct *queue,
2940                                    NT_PRINTER_INFO_LEVEL *printer,
2941                                    TALLOC_CTX *mem_ctx)
2942 {
2943         /* for a dummy implementation we have to zero the fields */
2944         SETUP_SPOOLSS_NOTIFY_DATA_DEVMODE(data, NULL);
2945 }
2946
2947 /*******************************************************************
2948  * fill a notify_info_data with the separator file name
2949  ********************************************************************/
2950
2951 void spoolss_notify_sepfile(int snum,
2952                                    struct spoolss_Notify *data,
2953                                    print_queue_struct *queue,
2954                                    NT_PRINTER_INFO_LEVEL *printer,
2955                                    TALLOC_CTX *mem_ctx)
2956 {
2957         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->sepfile);
2958 }
2959
2960 /*******************************************************************
2961  * fill a notify_info_data with the print processor
2962  * jfm:xxxx return always winprint to indicate we don't do anything to it
2963  ********************************************************************/
2964
2965 void spoolss_notify_print_processor(int snum,
2966                                            struct spoolss_Notify *data,
2967                                            print_queue_struct *queue,
2968                                            NT_PRINTER_INFO_LEVEL *printer,
2969                                            TALLOC_CTX *mem_ctx)
2970 {
2971         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->printprocessor);
2972 }
2973
2974 /*******************************************************************
2975  * fill a notify_info_data with the print processor options
2976  * jfm:xxxx send an empty string
2977  ********************************************************************/
2978
2979 void spoolss_notify_parameters(int snum,
2980                                       struct spoolss_Notify *data,
2981                                       print_queue_struct *queue,
2982                                       NT_PRINTER_INFO_LEVEL *printer,
2983                                       TALLOC_CTX *mem_ctx)
2984 {
2985         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->parameters);
2986 }
2987
2988 /*******************************************************************
2989  * fill a notify_info_data with the data type
2990  * jfm:xxxx always send RAW as data type
2991  ********************************************************************/
2992
2993 void spoolss_notify_datatype(int snum,
2994                                     struct spoolss_Notify *data,
2995                                     print_queue_struct *queue,
2996                                     NT_PRINTER_INFO_LEVEL *printer,
2997                                     TALLOC_CTX *mem_ctx)
2998 {
2999         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->datatype);
3000 }
3001
3002 /*******************************************************************
3003  * fill a notify_info_data with the security descriptor
3004  * jfm:xxxx send an null pointer to say no security desc
3005  * have to implement security before !
3006  ********************************************************************/
3007
3008 static void spoolss_notify_security_desc(int snum,
3009                                          struct spoolss_Notify *data,
3010                                          print_queue_struct *queue,
3011                                          NT_PRINTER_INFO_LEVEL *printer,
3012                                          TALLOC_CTX *mem_ctx)
3013 {
3014         SETUP_SPOOLSS_NOTIFY_DATA_SECDESC(data,
3015                                           printer->info_2->secdesc_buf->sd_size,
3016                                           printer->info_2->secdesc_buf->sd);
3017 }
3018
3019 /*******************************************************************
3020  * fill a notify_info_data with the attributes
3021  * jfm:xxxx a samba printer is always shared
3022  ********************************************************************/
3023
3024 void spoolss_notify_attributes(int snum,
3025                                       struct spoolss_Notify *data,
3026                                       print_queue_struct *queue,
3027                                       NT_PRINTER_INFO_LEVEL *printer,
3028                                       TALLOC_CTX *mem_ctx)
3029 {
3030         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->attributes);
3031 }
3032
3033 /*******************************************************************
3034  * fill a notify_info_data with the priority
3035  ********************************************************************/
3036
3037 static void spoolss_notify_priority(int snum,
3038                                     struct spoolss_Notify *data,
3039                                     print_queue_struct *queue,
3040                                     NT_PRINTER_INFO_LEVEL *printer,
3041                                     TALLOC_CTX *mem_ctx)
3042 {
3043         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->priority);
3044 }
3045
3046 /*******************************************************************
3047  * fill a notify_info_data with the default priority
3048  ********************************************************************/
3049
3050 static void spoolss_notify_default_priority(int snum,
3051                                             struct spoolss_Notify *data,
3052                                             print_queue_struct *queue,
3053                                             NT_PRINTER_INFO_LEVEL *printer,
3054                                             TALLOC_CTX *mem_ctx)
3055 {
3056         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->default_priority);
3057 }
3058
3059 /*******************************************************************
3060  * fill a notify_info_data with the start time
3061  ********************************************************************/
3062
3063 static void spoolss_notify_start_time(int snum,
3064                                       struct spoolss_Notify *data,
3065                                       print_queue_struct *queue,
3066                                       NT_PRINTER_INFO_LEVEL *printer,
3067                                       TALLOC_CTX *mem_ctx)
3068 {
3069         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->starttime);
3070 }
3071
3072 /*******************************************************************
3073  * fill a notify_info_data with the until time
3074  ********************************************************************/
3075
3076 static void spoolss_notify_until_time(int snum,
3077                                       struct spoolss_Notify *data,
3078                                       print_queue_struct *queue,
3079                                       NT_PRINTER_INFO_LEVEL *printer,
3080                                       TALLOC_CTX *mem_ctx)
3081 {
3082         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->untiltime);
3083 }
3084
3085 /*******************************************************************
3086  * fill a notify_info_data with the status
3087  ********************************************************************/
3088
3089 static void spoolss_notify_status(int snum,
3090                                   struct spoolss_Notify *data,
3091                                   print_queue_struct *queue,
3092                                   NT_PRINTER_INFO_LEVEL *printer,
3093                                   TALLOC_CTX *mem_ctx)
3094 {
3095         print_status_struct status;
3096
3097         print_queue_length(snum, &status);
3098         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, status.status);
3099 }
3100
3101 /*******************************************************************
3102  * fill a notify_info_data with the number of jobs queued
3103  ********************************************************************/
3104
3105 void spoolss_notify_cjobs(int snum,
3106                                  struct spoolss_Notify *data,
3107                                  print_queue_struct *queue,
3108                                  NT_PRINTER_INFO_LEVEL *printer,
3109                                  TALLOC_CTX *mem_ctx)
3110 {
3111         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, print_queue_length(snum, NULL));
3112 }
3113
3114 /*******************************************************************
3115  * fill a notify_info_data with the average ppm
3116  ********************************************************************/
3117
3118 static void spoolss_notify_average_ppm(int snum,
3119                                        struct spoolss_Notify *data,
3120                                        print_queue_struct *queue,
3121                                        NT_PRINTER_INFO_LEVEL *printer,
3122                                        TALLOC_CTX *mem_ctx)
3123 {
3124         /* always respond 8 pages per minutes */
3125         /* a little hard ! */
3126         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->averageppm);
3127 }
3128
3129 /*******************************************************************
3130  * fill a notify_info_data with username
3131  ********************************************************************/
3132
3133 static void spoolss_notify_username(int snum,
3134                                     struct spoolss_Notify *data,
3135                                     print_queue_struct *queue,
3136                                     NT_PRINTER_INFO_LEVEL *printer,
3137                                     TALLOC_CTX *mem_ctx)
3138 {
3139         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, queue->fs_user);
3140 }
3141
3142 /*******************************************************************
3143  * fill a notify_info_data with job status
3144  ********************************************************************/
3145
3146 static void spoolss_notify_job_status(int snum,
3147                                       struct spoolss_Notify *data,
3148                                       print_queue_struct *queue,
3149                                       NT_PRINTER_INFO_LEVEL *printer,
3150                                       TALLOC_CTX *mem_ctx)
3151 {
3152         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, nt_printj_status(queue->status));
3153 }
3154
3155 /*******************************************************************
3156  * fill a notify_info_data with job name
3157  ********************************************************************/
3158
3159 static void spoolss_notify_job_name(int snum,
3160                                     struct spoolss_Notify *data,
3161                                     print_queue_struct *queue,
3162                                     NT_PRINTER_INFO_LEVEL *printer,
3163                                     TALLOC_CTX *mem_ctx)
3164 {
3165         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, queue->fs_file);
3166 }
3167
3168 /*******************************************************************
3169  * fill a notify_info_data with job status
3170  ********************************************************************/
3171
3172 static void spoolss_notify_job_status_string(int snum,
3173                                              struct spoolss_Notify *data,
3174                                              print_queue_struct *queue,
3175                                              NT_PRINTER_INFO_LEVEL *printer,
3176                                              TALLOC_CTX *mem_ctx)
3177 {
3178         /*
3179          * Now we're returning job status codes we just return a "" here. JRA.
3180          */
3181
3182         const char *p = "";
3183
3184 #if 0 /* NO LONGER NEEDED - JRA. 02/22/2001 */
3185         p = "unknown";
3186
3187         switch (queue->status) {
3188         case LPQ_QUEUED:
3189                 p = "Queued";
3190                 break;
3191         case LPQ_PAUSED:
3192                 p = "";    /* NT provides the paused string */
3193                 break;
3194         case LPQ_SPOOLING:
3195                 p = "Spooling";
3196                 break;
3197         case LPQ_PRINTING:
3198                 p = "Printing";
3199                 break;
3200         }
3201 #endif /* NO LONGER NEEDED. */
3202
3203         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, p);
3204 }
3205
3206 /*******************************************************************
3207  * fill a notify_info_data with job time
3208  ********************************************************************/
3209
3210 static void spoolss_notify_job_time(int snum,
3211                                     struct spoolss_Notify *data,
3212                                     print_queue_struct *queue,
3213                                     NT_PRINTER_INFO_LEVEL *printer,
3214                                     TALLOC_CTX *mem_ctx)
3215 {
3216         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, 0);
3217 }
3218
3219 /*******************************************************************
3220  * fill a notify_info_data with job size
3221  ********************************************************************/
3222
3223 static void spoolss_notify_job_size(int snum,
3224                                     struct spoolss_Notify *data,
3225                                     print_queue_struct *queue,
3226                                     NT_PRINTER_INFO_LEVEL *printer,
3227                                     TALLOC_CTX *mem_ctx)
3228 {
3229         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->size);
3230 }
3231
3232 /*******************************************************************
3233  * fill a notify_info_data with page info
3234  ********************************************************************/
3235 static void spoolss_notify_total_pages(int snum,
3236                                 struct spoolss_Notify *data,
3237                                 print_queue_struct *queue,
3238                                 NT_PRINTER_INFO_LEVEL *printer,
3239                                 TALLOC_CTX *mem_ctx)
3240 {
3241         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->page_count);
3242 }
3243
3244 /*******************************************************************
3245  * fill a notify_info_data with pages printed info.
3246  ********************************************************************/
3247 static void spoolss_notify_pages_printed(int snum,
3248                                 struct spoolss_Notify *data,
3249                                 print_queue_struct *queue,
3250                                 NT_PRINTER_INFO_LEVEL *printer,
3251                                 TALLOC_CTX *mem_ctx)
3252 {
3253         /* Add code when back-end tracks this */
3254         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, 0);
3255 }
3256
3257 /*******************************************************************
3258  Fill a notify_info_data with job position.
3259  ********************************************************************/
3260
3261 static void spoolss_notify_job_position(int snum,
3262                                         struct spoolss_Notify *data,
3263                                         print_queue_struct *queue,
3264                                         NT_PRINTER_INFO_LEVEL *printer,
3265                                         TALLOC_CTX *mem_ctx)
3266 {
3267         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->job);
3268 }
3269
3270 /*******************************************************************
3271  Fill a notify_info_data with submitted time.
3272  ********************************************************************/
3273
3274 static void spoolss_notify_submitted_time(int snum,
3275                                           struct spoolss_Notify *data,
3276                                           print_queue_struct *queue,
3277                                           NT_PRINTER_INFO_LEVEL *printer,
3278                                           TALLOC_CTX *mem_ctx)
3279 {
3280         data->data.string.string = NULL;
3281         data->data.string.size = 0;
3282
3283         init_systemtime_buffer(mem_ctx, gmtime(&queue->time),
3284                                &data->data.string.string,
3285                                &data->data.string.size);
3286
3287 }
3288
3289 struct s_notify_info_data_table
3290 {
3291         enum spoolss_NotifyType type;
3292         uint16_t field;
3293         const char *name;
3294         enum spoolss_NotifyTable variable_type;
3295         void (*fn) (int snum, struct spoolss_Notify *data,
3296                     print_queue_struct *queue,
3297                     NT_PRINTER_INFO_LEVEL *printer, TALLOC_CTX *mem_ctx);
3298 };
3299
3300 /* A table describing the various print notification constants and
3301    whether the notification data is a pointer to a variable sized
3302    buffer, a one value uint32_t or a two value uint32_t. */
3303
3304 static const struct s_notify_info_data_table notify_info_data_table[] =
3305 {
3306 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SERVER_NAME,         "PRINTER_NOTIFY_FIELD_SERVER_NAME",         NOTIFY_TABLE_STRING,   spoolss_notify_server_name },
3307 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRINTER_NAME,        "PRINTER_NOTIFY_FIELD_PRINTER_NAME",        NOTIFY_TABLE_STRING,   spoolss_notify_printer_name },
3308 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SHARE_NAME,          "PRINTER_NOTIFY_FIELD_SHARE_NAME",          NOTIFY_TABLE_STRING,   spoolss_notify_share_name },
3309 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PORT_NAME,           "PRINTER_NOTIFY_FIELD_PORT_NAME",           NOTIFY_TABLE_STRING,   spoolss_notify_port_name },
3310 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DRIVER_NAME,         "PRINTER_NOTIFY_FIELD_DRIVER_NAME",         NOTIFY_TABLE_STRING,   spoolss_notify_driver_name },
3311 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_COMMENT,             "PRINTER_NOTIFY_FIELD_COMMENT",             NOTIFY_TABLE_STRING,   spoolss_notify_comment },
3312 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_LOCATION,            "PRINTER_NOTIFY_FIELD_LOCATION",            NOTIFY_TABLE_STRING,   spoolss_notify_location },
3313 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DEVMODE,             "PRINTER_NOTIFY_FIELD_DEVMODE",             NOTIFY_TABLE_DEVMODE,  spoolss_notify_devmode },
3314 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SEPFILE,             "PRINTER_NOTIFY_FIELD_SEPFILE",             NOTIFY_TABLE_STRING,   spoolss_notify_sepfile },
3315 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR,     "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR",     NOTIFY_TABLE_STRING,   spoolss_notify_print_processor },
3316 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PARAMETERS,          "PRINTER_NOTIFY_FIELD_PARAMETERS",          NOTIFY_TABLE_STRING,   spoolss_notify_parameters },
3317 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DATATYPE,            "PRINTER_NOTIFY_FIELD_DATATYPE",            NOTIFY_TABLE_STRING,   spoolss_notify_datatype },
3318 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR, "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NOTIFY_TABLE_SECURITYDESCRIPTOR,   spoolss_notify_security_desc },
3319 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_ATTRIBUTES,          "PRINTER_NOTIFY_FIELD_ATTRIBUTES",          NOTIFY_TABLE_DWORD,    spoolss_notify_attributes },
3320 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRIORITY,            "PRINTER_NOTIFY_FIELD_PRIORITY",            NOTIFY_TABLE_DWORD,    spoolss_notify_priority },
3321 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY,    "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY",    NOTIFY_TABLE_DWORD,    spoolss_notify_default_priority },
3322 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_START_TIME,          "PRINTER_NOTIFY_FIELD_START_TIME",          NOTIFY_TABLE_DWORD,    spoolss_notify_start_time },
3323 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_UNTIL_TIME,          "PRINTER_NOTIFY_FIELD_UNTIL_TIME",          NOTIFY_TABLE_DWORD,    spoolss_notify_until_time },
3324 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_STATUS,              "PRINTER_NOTIFY_FIELD_STATUS",              NOTIFY_TABLE_DWORD,    spoolss_notify_status },
3325 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_STATUS_STRING,       "PRINTER_NOTIFY_FIELD_STATUS_STRING",       NOTIFY_TABLE_STRING,   NULL },
3326 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_CJOBS,               "PRINTER_NOTIFY_FIELD_CJOBS",               NOTIFY_TABLE_DWORD,    spoolss_notify_cjobs },
3327 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_AVERAGE_PPM,         "PRINTER_NOTIFY_FIELD_AVERAGE_PPM",         NOTIFY_TABLE_DWORD,    spoolss_notify_average_ppm },
3328 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_TOTAL_PAGES,         "PRINTER_NOTIFY_FIELD_TOTAL_PAGES",         NOTIFY_TABLE_DWORD,    NULL },
3329 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PAGES_PRINTED,       "PRINTER_NOTIFY_FIELD_PAGES_PRINTED",       NOTIFY_TABLE_DWORD,    NULL },
3330 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_TOTAL_BYTES,         "PRINTER_NOTIFY_FIELD_TOTAL_BYTES",         NOTIFY_TABLE_DWORD,    NULL },
3331 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_BYTES_PRINTED,       "PRINTER_NOTIFY_FIELD_BYTES_PRINTED",       NOTIFY_TABLE_DWORD,    NULL },
3332 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_PRINTER_NAME,            "JOB_NOTIFY_FIELD_PRINTER_NAME",            NOTIFY_TABLE_STRING,   spoolss_notify_printer_name },
3333 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_MACHINE_NAME,            "JOB_NOTIFY_FIELD_MACHINE_NAME",            NOTIFY_TABLE_STRING,   spoolss_notify_server_name },
3334 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_PORT_NAME,               "JOB_NOTIFY_FIELD_PORT_NAME",               NOTIFY_TABLE_STRING,   spoolss_notify_port_name },
3335 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_USER_NAME,               "JOB_NOTIFY_FIELD_USER_NAME",               NOTIFY_TABLE_STRING,   spoolss_notify_username },
3336 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_NOTIFY_NAME,             "JOB_NOTIFY_FIELD_NOTIFY_NAME",             NOTIFY_TABLE_STRING,   spoolss_notify_username },
3337 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_DATATYPE,                "JOB_NOTIFY_FIELD_DATATYPE",                NOTIFY_TABLE_STRING,   spoolss_notify_datatype },
3338 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_PRINT_PROCESSOR,         "JOB_NOTIFY_FIELD_PRINT_PROCESSOR",         NOTIFY_TABLE_STRING,   spoolss_notify_print_processor },
3339 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_PARAMETERS,              "JOB_NOTIFY_FIELD_PARAMETERS",              NOTIFY_TABLE_STRING,   spoolss_notify_parameters },
3340 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_DRIVER_NAME,             "JOB_NOTIFY_FIELD_DRIVER_NAME",             NOTIFY_TABLE_STRING,   spoolss_notify_driver_name },
3341 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_DEVMODE,                 "JOB_NOTIFY_FIELD_DEVMODE",                 NOTIFY_TABLE_DEVMODE,  spoolss_notify_devmode },
3342 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_STATUS,                  "JOB_NOTIFY_FIELD_STATUS",                  NOTIFY_TABLE_DWORD,    spoolss_notify_job_status },
3343 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_STATUS_STRING,           "JOB_NOTIFY_FIELD_STATUS_STRING",           NOTIFY_TABLE_STRING,   spoolss_notify_job_status_string },
3344 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR,     "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR",     NOTIFY_TABLE_SECURITYDESCRIPTOR,   NULL },
3345 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_DOCUMENT,                "JOB_NOTIFY_FIELD_DOCUMENT",                NOTIFY_TABLE_STRING,   spoolss_notify_job_name },
3346 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_PRIORITY,                "JOB_NOTIFY_FIELD_PRIORITY",                NOTIFY_TABLE_DWORD,    spoolss_notify_priority },
3347 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_POSITION,                "JOB_NOTIFY_FIELD_POSITION",                NOTIFY_TABLE_DWORD,    spoolss_notify_job_position },
3348 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_SUBMITTED,               "JOB_NOTIFY_FIELD_SUBMITTED",               NOTIFY_TABLE_TIME,     spoolss_notify_submitted_time },
3349 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_START_TIME,              "JOB_NOTIFY_FIELD_START_TIME",              NOTIFY_TABLE_DWORD,    spoolss_notify_start_time },
3350 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_UNTIL_TIME,              "JOB_NOTIFY_FIELD_UNTIL_TIME",              NOTIFY_TABLE_DWORD,    spoolss_notify_until_time },
3351 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_TIME,                    "JOB_NOTIFY_FIELD_TIME",                    NOTIFY_TABLE_DWORD,    spoolss_notify_job_time },
3352 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_TOTAL_PAGES,             "JOB_NOTIFY_FIELD_TOTAL_PAGES",             NOTIFY_TABLE_DWORD,    spoolss_notify_total_pages },
3353 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_PAGES_PRINTED,           "JOB_NOTIFY_FIELD_PAGES_PRINTED",           NOTIFY_TABLE_DWORD,    spoolss_notify_pages_printed },
3354 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_TOTAL_BYTES,             "JOB_NOTIFY_FIELD_TOTAL_BYTES",             NOTIFY_TABLE_DWORD,    spoolss_notify_job_size },
3355 };
3356
3357 /*******************************************************************
3358  Return the variable_type of info_data structure.
3359 ********************************************************************/
3360
3361 static uint32_t variable_type_of_notify_info_data(enum spoolss_NotifyType type,
3362                                                   uint16_t field)
3363 {
3364         int i=0;
3365
3366         for (i = 0; i < ARRAY_SIZE(notify_info_data_table); i++) {
3367                 if ( (notify_info_data_table[i].type == type) &&
3368                      (notify_info_data_table[i].field == field) ) {
3369                         return notify_info_data_table[i].variable_type;
3370                 }
3371         }
3372
3373         DEBUG(5, ("invalid notify data type %d/%d\n", type, field));
3374
3375         return 0;
3376 }
3377
3378 /****************************************************************************
3379 ****************************************************************************/
3380
3381 static bool search_notify(enum spoolss_NotifyType type,
3382                           uint16_t field,
3383                           int *value)
3384 {
3385         int i;
3386
3387         for (i = 0; i < ARRAY_SIZE(notify_info_data_table); i++) {
3388                 if (notify_info_data_table[i].type == type &&
3389                     notify_info_data_table[i].field == field &&
3390                     notify_info_data_table[i].fn != NULL) {
3391                         *value = i;
3392                         return true;
3393                 }
3394         }
3395
3396         return false;
3397 }
3398
3399 /****************************************************************************
3400 ****************************************************************************/
3401
3402 void construct_info_data(struct spoolss_Notify *info_data,
3403                          enum spoolss_NotifyType type,
3404                          uint16_t field,
3405                          int id)
3406 {
3407         info_data->type                 = type;
3408         info_data->field.field          = field;
3409         info_data->variable_type        = variable_type_of_notify_info_data(type, field);
3410         info_data->job_id               = id;
3411 }
3412
3413 /*******************************************************************
3414  *
3415  * fill a notify_info struct with info asked
3416  *
3417  ********************************************************************/
3418
3419 static bool construct_notify_printer_info(Printer_entry *print_hnd,
3420                                           struct spoolss_NotifyInfo *info,
3421                                           int snum,
3422                                           const struct spoolss_NotifyOptionType *option_type,
3423                                           uint32_t id,
3424                                           TALLOC_CTX *mem_ctx)
3425 {
3426         int field_num,j;
3427         enum spoolss_NotifyType type;
3428         uint16_t field;
3429
3430         struct spoolss_Notify *current_data;
3431         NT_PRINTER_INFO_LEVEL *printer = NULL;
3432         print_queue_struct *queue=NULL;
3433
3434         type = option_type->type;
3435
3436         DEBUG(4,("construct_notify_printer_info: Notify type: [%s], number of notify info: [%d] on printer: [%s]\n",
3437                 (type == PRINTER_NOTIFY_TYPE ? "PRINTER_NOTIFY_TYPE" : "JOB_NOTIFY_TYPE"),
3438                 option_type->count, lp_servicename(snum)));
3439
3440         if (!W_ERROR_IS_OK(get_a_printer(print_hnd, &printer, 2, lp_const_servicename(snum))))
3441                 return false;
3442
3443         for(field_num=0; field_num < option_type->count; field_num++) {
3444                 field = option_type->fields[field_num].field;
3445
3446                 DEBUG(4,("construct_notify_printer_info: notify [%d]: type [%x], field [%x]\n", field_num, type, field));
3447
3448                 if (!search_notify(type, field, &j) )
3449                         continue;
3450
3451                 info->notifies = TALLOC_REALLOC_ARRAY(info, info->notifies,
3452                                                       struct spoolss_Notify,
3453                                                       info->count + 1);
3454                 if (info->notifies == NULL) {
3455                         DEBUG(2,("construct_notify_printer_info: failed to enlarge buffer info->data!\n"));
3456                         free_a_printer(&printer, 2);
3457                         return false;
3458                 }
3459
3460                 current_data = &info->notifies[info->count];
3461
3462                 construct_info_data(current_data, type, field, id);
3463
3464                 DEBUG(10,("construct_notify_printer_info: calling [%s]  snum=%d  printername=[%s])\n",
3465                                 notify_info_data_table[j].name, snum, printer->info_2->printername ));
3466
3467                 notify_info_data_table[j].fn(snum, current_data, queue,
3468                                              printer, mem_ctx);
3469
3470                 info->count++;
3471         }
3472
3473         free_a_printer(&printer, 2);
3474         return true;
3475 }
3476
3477 /*******************************************************************
3478  *
3479  * fill a notify_info struct with info asked
3480  *
3481  ********************************************************************/
3482
3483 static bool construct_notify_jobs_info(print_queue_struct *queue,
3484                                        struct spoolss_NotifyInfo *info,
3485                                        NT_PRINTER_INFO_LEVEL *printer,
3486                                        int snum,
3487                                        const struct spoolss_NotifyOptionType *option_type,
3488                                        uint32_t id,
3489                                        TALLOC_CTX *mem_ctx)
3490 {
3491         int field_num,j;
3492         enum spoolss_NotifyType type;
3493         uint16_t field;
3494         struct spoolss_Notify *current_data;
3495
3496         DEBUG(4,("construct_notify_jobs_info\n"));
3497
3498         type = option_type->type;
3499
3500         DEBUGADD(4,("Notify type: [%s], number of notify info: [%d]\n",
3501                 (type == PRINTER_NOTIFY_TYPE ? "PRINTER_NOTIFY_TYPE" : "JOB_NOTIFY_TYPE"),
3502                 option_type->count));
3503
3504         for(field_num=0; field_num<option_type->count; field_num++) {
3505                 field = option_type->fields[field_num].field;
3506
3507                 if (!search_notify(type, field, &j) )
3508                         continue;
3509
3510                 info->notifies = TALLOC_REALLOC_ARRAY(info, info->notifies,
3511                                                       struct spoolss_Notify,
3512                                                       info->count + 1);
3513                 if (info->notifies == NULL) {
3514                         DEBUG(2,("construct_notify_jobs_info: failed to enlarg buffer info->data!\n"));
3515                         return false;
3516                 }
3517
3518                 current_data=&(info->notifies[info->count]);
3519
3520                 construct_info_data(current_data, type, field, id);
3521                 notify_info_data_table[j].fn(snum, current_data, queue,
3522                                              printer, mem_ctx);
3523                 info->count++;
3524         }
3525
3526         return true;
3527 }
3528
3529 /*
3530  * JFM: The enumeration is not that simple, it's even non obvious.
3531  *
3532  * let's take an example: I want to monitor the PRINTER SERVER for
3533  * the printer's name and the number of jobs currently queued.
3534  * So in the NOTIFY_OPTION, I have one NOTIFY_OPTION_TYPE structure.
3535  * Its type is PRINTER_NOTIFY_TYPE and it has 2 fields NAME and CJOBS.
3536  *
3537  * I have 3 printers on the back of my server.
3538  *
3539  * Now the response is a NOTIFY_INFO structure, with 6 NOTIFY_INFO_DATA
3540  * structures.
3541  *   Number     Data                    Id
3542  *      1       printer 1 name          1
3543  *      2       printer 1 cjob          1
3544  *      3       printer 2 name          2
3545  *      4       printer 2 cjob          2
3546  *      5       printer 3 name          3
3547  *      6       printer 3 name          3
3548  *
3549  * that's the print server case, the printer case is even worse.
3550  */
3551
3552 /*******************************************************************
3553  *
3554  * enumerate all printers on the printserver
3555  * fill a notify_info struct with info asked
3556  *
3557  ********************************************************************/
3558
3559 static WERROR printserver_notify_info(pipes_struct *p,
3560                                       struct policy_handle *hnd,
3561                                       struct spoolss_NotifyInfo *info,
3562                                       TALLOC_CTX *mem_ctx)
3563 {
3564         int snum;
3565         Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
3566         int n_services=lp_numservices();
3567         int i;
3568         struct spoolss_NotifyOption *option;
3569         struct spoolss_NotifyOptionType option_type;
3570
3571         DEBUG(4,("printserver_notify_info\n"));
3572
3573         if (!Printer)
3574                 return WERR_BADFID;
3575
3576         option = Printer->notify.option;
3577
3578         info->version   = 2;
3579         info->notifies  = NULL;
3580         info->count     = 0;
3581
3582         /* a bug in xp sp2 rc2 causes it to send a fnpcn request without
3583            sending a ffpcn() request first */
3584
3585         if ( !option )
3586                 return WERR_BADFID;
3587
3588         for (i=0; i<option->count; i++) {
3589                 option_type = option->types[i];
3590
3591                 if (option_type.type != PRINTER_NOTIFY_TYPE)
3592                         continue;
3593
3594                 for (snum=0; snum<n_services; snum++)
3595                 {
3596                         if ( lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum) )
3597                                 construct_notify_printer_info ( Printer, info, snum, &option_type, snum, mem_ctx );
3598                 }
3599         }
3600
3601 #if 0
3602         /*
3603          * Debugging information, don't delete.
3604          */
3605
3606         DEBUG(1,("dumping the NOTIFY_INFO\n"));
3607         DEBUGADD(1,("info->version:[%d], info->flags:[%d], info->count:[%d]\n", info->version, info->flags, info->count));
3608         DEBUGADD(1,("num\ttype\tfield\tres\tid\tsize\tenc_type\n"));
3609
3610         for (i=0; i<info->count; i++) {
3611                 DEBUGADD(1,("[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\n",
3612                 i, info->data[i].type, info->data[i].field, info->data[i].reserved,
3613                 info->data[i].id, info->data[i].size, info->data[i].enc_type));
3614         }
3615 #endif
3616
3617         return WERR_OK;
3618 }
3619
3620 /*******************************************************************
3621  *
3622  * fill a notify_info struct with info asked
3623  *
3624  ********************************************************************/
3625
3626 static WERROR printer_notify_info(pipes_struct *p, struct policy_handle *hnd,
3627                                   struct spoolss_NotifyInfo *info,
3628                                   TALLOC_CTX *mem_ctx)
3629 {
3630         int snum;
3631         Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
3632         int i;
3633         uint32_t id;
3634         struct spoolss_NotifyOption *option;
3635         struct spoolss_NotifyOptionType option_type;
3636         int count,j;
3637         print_queue_struct *queue=NULL;
3638         print_status_struct status;
3639
3640         DEBUG(4,("printer_notify_info\n"));
3641
3642         if (!Printer)
3643                 return WERR_BADFID;
3644
3645         option = Printer->notify.option;
3646         id = 0x0;
3647
3648         info->version   = 2;
3649         info->notifies  = NULL;
3650         info->count     = 0;
3651
3652         /* a bug in xp sp2 rc2 causes it to send a fnpcn request without
3653            sending a ffpcn() request first */
3654
3655         if ( !option )
3656                 return WERR_BADFID;
3657
3658         get_printer_snum(p, hnd, &snum, NULL);
3659
3660         for (i=0; i<option->count; i++) {
3661                 option_type = option->types[i];
3662
3663                 switch (option_type.type) {
3664                 case PRINTER_NOTIFY_TYPE:
3665                         if(construct_notify_printer_info(Printer, info, snum,
3666                                                          &option_type, id,
3667                                                          mem_ctx))
3668                                 id--;
3669                         break;
3670
3671                 case JOB_NOTIFY_TYPE: {
3672                         NT_PRINTER_INFO_LEVEL *printer = NULL;
3673
3674                         count = print_queue_status(snum, &queue, &status);
3675
3676                         if (!W_ERROR_IS_OK(get_a_printer(Printer, &printer, 2, lp_const_servicename(snum))))
3677                                 goto done;
3678
3679                         for (j=0; j<count; j++) {
3680                                 construct_notify_jobs_info(&queue[j], info,
3681                                                            printer, snum,
3682                                                            &option_type,
3683                                                            queue[j].job,
3684                                                            mem_ctx);
3685                         }
3686
3687                         free_a_printer(&printer, 2);
3688
3689                 done:
3690                         SAFE_FREE(queue);
3691                         break;
3692                 }
3693                 }
3694         }
3695
3696         /*
3697          * Debugging information, don't delete.
3698          */
3699         /*
3700         DEBUG(1,("dumping the NOTIFY_INFO\n"));
3701         DEBUGADD(1,("info->version:[%d], info->flags:[%d], info->count:[%d]\n", info->version, info->flags, info->count));
3702         DEBUGADD(1,("num\ttype\tfield\tres\tid\tsize\tenc_type\n"));
3703
3704         for (i=0; i<info->count; i++) {
3705                 DEBUGADD(1,("[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\n",
3706                 i, info->data[i].type, info->data[i].field, info->data[i].reserved,
3707                 info->data[i].id, info->data[i].size, info->data[i].enc_type));
3708         }
3709         */
3710         return WERR_OK;
3711 }
3712
3713 /****************************************************************
3714  _spoolss_RouterRefreshPrinterChangeNotify
3715 ****************************************************************/
3716
3717 WERROR _spoolss_RouterRefreshPrinterChangeNotify(pipes_struct *p,
3718                                                  struct spoolss_RouterRefreshPrinterChangeNotify *r)
3719 {
3720         struct spoolss_NotifyInfo *info;
3721
3722         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
3723         WERROR result = WERR_BADFID;
3724
3725         /* we always have a spoolss_NotifyInfo struct */
3726         info = talloc_zero(p->mem_ctx, struct spoolss_NotifyInfo);
3727         if (!info) {
3728                 result = WERR_NOMEM;
3729                 goto done;
3730         }
3731
3732         *r->out.info = info;
3733
3734         if (!Printer) {
3735                 DEBUG(2,("_spoolss_RouterRefreshPrinterChangeNotify: "
3736                         "Invalid handle (%s:%u:%u).\n",
3737                         OUR_HANDLE(r->in.handle)));
3738                 goto done;
3739         }
3740
3741         DEBUG(4,("Printer type %x\n",Printer->printer_type));
3742
3743         /*
3744          *      We are now using the change value, and
3745          *      I should check for PRINTER_NOTIFY_OPTIONS_REFRESH but as
3746          *      I don't have a global notification system, I'm sending back all the
3747          *      informations even when _NOTHING_ has changed.
3748          */
3749
3750         /* We need to keep track of the change value to send back in
3751            RRPCN replies otherwise our updates are ignored. */
3752
3753         Printer->notify.fnpcn = true;
3754
3755         if (Printer->notify.client_connected) {
3756                 DEBUG(10,("_spoolss_RouterRefreshPrinterChangeNotify: "
3757                         "Saving change value in request [%x]\n",
3758                         r->in.change_low));
3759                 Printer->notify.change = r->in.change_low;
3760         }
3761
3762         /* just ignore the spoolss_NotifyOption */
3763
3764         switch (Printer->printer_type) {
3765                 case SPLHND_SERVER:
3766                         result = printserver_notify_info(p, r->in.handle,
3767                                                          info, p->mem_ctx);
3768                         break;
3769
3770                 case SPLHND_PRINTER:
3771                         result = printer_notify_info(p, r->in.handle,
3772                                                      info, p->mem_ctx);
3773                         break;
3774         }
3775
3776         Printer->notify.fnpcn = false;
3777
3778 done:
3779         return result;
3780 }
3781
3782 /********************************************************************
3783  * construct_printer_info_0
3784  * fill a printer_info_0 struct
3785  ********************************************************************/
3786
3787 static WERROR construct_printer_info0(TALLOC_CTX *mem_ctx,
3788                                       const NT_PRINTER_INFO_LEVEL *ntprinter,
3789                                       struct spoolss_PrinterInfo0 *r,
3790                                       int snum)
3791 {
3792         int count;
3793         counter_printer_0 *session_counter;
3794         time_t setuptime;
3795         print_status_struct status;
3796
3797         r->printername          = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
3798         W_ERROR_HAVE_NO_MEMORY(r->printername);
3799
3800         r->servername           = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
3801         W_ERROR_HAVE_NO_MEMORY(r->servername);
3802
3803         count = print_queue_length(snum, &status);
3804
3805         /* check if we already have a counter for this printer */
3806         for (session_counter = counter_list; session_counter; session_counter = session_counter->next) {
3807                 if (session_counter->snum == snum)
3808                         break;
3809         }
3810
3811         /* it's the first time, add it to the list */
3812         if (session_counter == NULL) {
3813                 session_counter = SMB_MALLOC_P(counter_printer_0);
3814                 W_ERROR_HAVE_NO_MEMORY(session_counter);
3815                 ZERO_STRUCTP(session_counter);
3816                 session_counter->snum           = snum;
3817                 session_counter->counter        = 0;
3818                 DLIST_ADD(counter_list, session_counter);
3819         }
3820
3821         /* increment it */
3822         session_counter->counter++;
3823
3824         r->cjobs                        = count;
3825         r->total_jobs                   = 0;
3826         r->total_bytes                  = 0;
3827
3828         setuptime = (time_t)ntprinter->info_2->setuptime;
3829
3830         init_systemtime(&r->time, gmtime(&setuptime));
3831
3832         /* JFM:
3833          * the global_counter should be stored in a TDB as it's common to all the clients
3834          * and should be zeroed on samba startup
3835          */
3836         r->global_counter               = session_counter->counter;
3837         r->total_pages                  = 0;
3838         /* in 2.2 we reported ourselves as 0x0004 and 0x0565 */
3839         r->version                      = 0x0005;       /* NT 5 */
3840         r->free_build                   = 0x0893;       /* build 2195 */
3841         r->spooling                     = 0;
3842         r->max_spooling                 = 0;
3843         r->session_counter              = session_counter->counter;
3844         r->num_error_out_of_paper       = 0x0;
3845         r->num_error_not_ready          = 0x0;          /* number of print failure */
3846         r->job_error                    = 0x0;
3847         r->number_of_processors         = 0x1;
3848         r->processor_type               = PROCESSOR_INTEL_PENTIUM; /* 586 Pentium ? */
3849         r->high_part_total_bytes        = 0x0;
3850         r->change_id                    = ntprinter->info_2->changeid; /* ChangeID in milliseconds*/
3851         r->last_error                   = WERR_OK;
3852         r->status                       = nt_printq_status(status.status);
3853         r->enumerate_network_printers   = 0x0;
3854         r->c_setprinter                 = get_c_setprinter(); /* monotonically increasing sum of delta printer counts */
3855         r->processor_architecture       = 0x0;
3856         r->processor_level              = 0x6;          /* 6  ???*/
3857         r->ref_ic                       = 0;
3858         r->reserved2                    = 0;
3859         r->reserved3                    = 0;
3860
3861         return WERR_OK;
3862 }
3863
3864 /****************************************************************************
3865  Convert an NT_DEVICEMODE to a spoolss_DeviceMode structure.  Both pointers
3866  should be valid upon entry
3867 ****************************************************************************/
3868
3869 static WERROR convert_nt_devicemode(TALLOC_CTX *mem_ctx,
3870                                     struct spoolss_DeviceMode *r,
3871                                     const NT_DEVICEMODE *ntdevmode)
3872 {
3873         if (!r || !ntdevmode) {
3874                 return WERR_INVALID_PARAM;
3875         }
3876
3877         r->devicename           = talloc_strdup(mem_ctx, ntdevmode->devicename);
3878         W_ERROR_HAVE_NO_MEMORY(r->devicename);
3879
3880         r->specversion          = ntdevmode->specversion;
3881         r->driverversion        = ntdevmode->driverversion;
3882         r->size                 = ntdevmode->size;
3883         r->__driverextra_length = ntdevmode->driverextra;
3884         r->fields               = ntdevmode->fields;
3885
3886         r->orientation          = ntdevmode->orientation;
3887         r->papersize            = ntdevmode->papersize;
3888         r->paperlength          = ntdevmode->paperlength;
3889         r->paperwidth           = ntdevmode->paperwidth;
3890         r->scale                = ntdevmode->scale;
3891         r->copies               = ntdevmode->copies;
3892         r->defaultsource        = ntdevmode->defaultsource;
3893         r->printquality         = ntdevmode->printquality;
3894         r->color                = ntdevmode->color;
3895         r->duplex               = ntdevmode->duplex;
3896         r->yresolution          = ntdevmode->yresolution;
3897         r->ttoption             = ntdevmode->ttoption;
3898         r->collate              = ntdevmode->collate;
3899
3900         r->formname             = talloc_strdup(mem_ctx, ntdevmode->formname);
3901         W_ERROR_HAVE_NO_MEMORY(r->formname);
3902
3903         /* all 0 below are values that have not been set in the old parsing/copy
3904          * function, maybe they should... - gd */
3905
3906         r->logpixels            = 0;
3907         r->bitsperpel           = 0;
3908         r->pelswidth            = 0;
3909         r->pelsheight           = 0;
3910         r->displayflags         = 0;
3911         r->displayfrequency     = 0;
3912         r->icmmethod            = ntdevmode->icmmethod;
3913         r->icmintent            = ntdevmode->icmintent;
3914         r->mediatype            = ntdevmode->mediatype;
3915         r->dithertype           = ntdevmode->dithertype;
3916         r->reserved1            = 0;
3917         r->reserved2            = 0;
3918         r->panningwidth         = 0;
3919         r->panningheight        = 0;
3920
3921         if (ntdevmode->nt_dev_private != NULL) {
3922                 r->driverextra_data = data_blob_talloc(mem_ctx,
3923                         ntdevmode->nt_dev_private,
3924                         ntdevmode->driverextra);
3925                 W_ERROR_HAVE_NO_MEMORY(r->driverextra_data.data);
3926         }
3927
3928         return WERR_OK;
3929 }
3930
3931
3932 /****************************************************************************
3933  Create a spoolss_DeviceMode struct. Returns talloced memory.
3934 ****************************************************************************/
3935
3936 struct spoolss_DeviceMode *construct_dev_mode(TALLOC_CTX *mem_ctx,
3937                                               const char *servicename)
3938 {
3939         WERROR result;
3940         NT_PRINTER_INFO_LEVEL   *printer = NULL;
3941         struct spoolss_DeviceMode *devmode = NULL;
3942
3943         DEBUG(7,("construct_dev_mode\n"));
3944
3945         DEBUGADD(8,("getting printer characteristics\n"));
3946
3947         if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, servicename)))
3948                 return NULL;
3949
3950         if (!printer->info_2->devmode) {
3951                 DEBUG(5, ("BONG! There was no device mode!\n"));
3952                 goto done;
3953         }
3954
3955         devmode = TALLOC_ZERO_P(mem_ctx, struct spoolss_DeviceMode);
3956         if (!devmode) {
3957                 DEBUG(2,("construct_dev_mode: talloc fail.\n"));
3958                 goto done;
3959         }
3960
3961         DEBUGADD(8,("loading DEVICEMODE\n"));
3962
3963         result = convert_nt_devicemode(mem_ctx, devmode, printer->info_2->devmode);
3964         if (!W_ERROR_IS_OK(result)) {
3965                 TALLOC_FREE(devmode);
3966         }
3967
3968 done:
3969         free_a_printer(&printer,2);
3970
3971         return devmode;
3972 }
3973
3974 /********************************************************************
3975  * construct_printer_info3
3976  * fill a spoolss_PrinterInfo3 struct
3977  ********************************************************************/
3978
3979 static WERROR construct_printer_info3(TALLOC_CTX *mem_ctx,
3980                                       const NT_PRINTER_INFO_LEVEL *ntprinter,
3981                                       struct spoolss_PrinterInfo3 *r,
3982                                       int snum)
3983 {
3984         /* These are the components of the SD we are returning. */
3985
3986         if (ntprinter->info_2->secdesc_buf && ntprinter->info_2->secdesc_buf->sd_size != 0) {
3987                 /* don't use talloc_steal() here unless you do a deep steal of all
3988                    the SEC_DESC members */
3989
3990                 r->secdesc = dup_sec_desc(mem_ctx,
3991                                           ntprinter->info_2->secdesc_buf->sd);
3992                 W_ERROR_HAVE_NO_MEMORY(r->secdesc);
3993         }
3994
3995         return WERR_OK;
3996 }
3997
3998 /********************************************************************
3999  * construct_printer_info4
4000  * fill a spoolss_PrinterInfo4 struct
4001  ********************************************************************/
4002
4003 static WERROR construct_printer_info4(TALLOC_CTX *mem_ctx,
4004                                       const NT_PRINTER_INFO_LEVEL *ntprinter,
4005                                       struct spoolss_PrinterInfo4 *r,
4006                                       int snum)
4007 {
4008         r->printername  = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
4009         W_ERROR_HAVE_NO_MEMORY(r->printername);
4010         r->servername   = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
4011         W_ERROR_HAVE_NO_MEMORY(r->servername);
4012
4013         r->attributes   = ntprinter->info_2->attributes;
4014
4015         return WERR_OK;
4016 }
4017
4018 /********************************************************************
4019  * construct_printer_info5
4020  * fill a spoolss_PrinterInfo5 struct
4021  ********************************************************************/
4022
4023 static WERROR construct_printer_info5(TALLOC_CTX *mem_ctx,
4024                                       const NT_PRINTER_INFO_LEVEL *ntprinter,
4025                                       struct spoolss_PrinterInfo5 *r,
4026                                       int snum)
4027 {
4028         r->printername  = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
4029         W_ERROR_HAVE_NO_MEMORY(r->printername);
4030         r->portname     = talloc_strdup(mem_ctx, ntprinter->info_2->portname);
4031         W_ERROR_HAVE_NO_MEMORY(r->portname);
4032
4033         r->attributes   = ntprinter->info_2->attributes;
4034
4035         /* these two are not used by NT+ according to MSDN */
4036
4037         r->device_not_selected_timeout          = 0x0;  /* have seen 0x3a98 */
4038         r->transmission_retry_timeout           = 0x0;  /* have seen 0xafc8 */
4039
4040         return WERR_OK;
4041 }
4042
4043 /********************************************************************
4044  * construct_printer_info_6
4045  * fill a spoolss_PrinterInfo6 struct
4046  ********************************************************************/
4047
4048 static WERROR construct_printer_info6(TALLOC_CTX *mem_ctx,
4049                                       const NT_PRINTER_INFO_LEVEL *ntprinter,
4050                                       struct spoolss_PrinterInfo6 *r,
4051                                       int snum)
4052 {
4053         int count;
4054         print_status_struct status;
4055
4056         count = print_queue_length(snum, &status);
4057
4058         r->status = nt_printq_status(status.status);
4059
4060         return WERR_OK;
4061 }
4062
4063 /********************************************************************
4064  * construct_printer_info7
4065  * fill a spoolss_PrinterInfo7 struct
4066  ********************************************************************/
4067
4068 static WERROR construct_printer_info7(TALLOC_CTX *mem_ctx,
4069                                       Printer_entry *print_hnd,
4070                                       struct spoolss_PrinterInfo7 *r,
4071                                       int snum)
4072 {
4073         struct GUID guid;
4074
4075         if (is_printer_published(print_hnd, snum, &guid)) {
4076                 r->guid = talloc_strdup_upper(mem_ctx, GUID_string2(mem_ctx, &guid));
4077                 r->action = DSPRINT_PUBLISH;
4078         } else {
4079                 r->guid = talloc_strdup(mem_ctx, "");
4080                 r->action = DSPRINT_UNPUBLISH;
4081         }
4082         W_ERROR_HAVE_NO_MEMORY(r->guid);
4083
4084         return WERR_OK;
4085 }
4086
4087 /********************************************************************
4088  * construct_printer_info8
4089  * fill a spoolss_PrinterInfo8 struct
4090  ********************************************************************/
4091
4092 static WERROR construct_printer_info8(TALLOC_CTX *mem_ctx,
4093                                       const NT_PRINTER_INFO_LEVEL *ntprinter,
4094                                       struct spoolss_DeviceModeInfo *r,
4095                                       int snum)
4096 {
4097         struct spoolss_DeviceMode *devmode;
4098         WERROR result;
4099
4100         if (!ntprinter->info_2->devmode) {
4101                 r->devmode = NULL;
4102                 return WERR_OK;
4103         }
4104
4105         devmode = TALLOC_ZERO_P(mem_ctx, struct spoolss_DeviceMode);
4106         W_ERROR_HAVE_NO_MEMORY(devmode);
4107
4108         result = convert_nt_devicemode(mem_ctx, devmode, ntprinter->info_2->devmode);
4109         if (!W_ERROR_IS_OK(result)) {
4110                 TALLOC_FREE(devmode);
4111                 return result;
4112         }
4113
4114         r->devmode      = devmode;
4115
4116         return WERR_OK;
4117 }
4118
4119
4120 /********************************************************************
4121  * construct_printer_info1
4122  * fill a spoolss_PrinterInfo1 struct
4123 ********************************************************************/
4124
4125 static WERROR construct_printer_info1(TALLOC_CTX *mem_ctx,
4126                                       const NT_PRINTER_INFO_LEVEL *ntprinter,
4127                                       uint32_t flags,
4128                                       struct spoolss_PrinterInfo1 *r,
4129                                       int snum)
4130 {
4131         r->flags                = flags;
4132
4133         r->description          = talloc_asprintf(mem_ctx, "%s,%s,%s",
4134                                                   ntprinter->info_2->printername,
4135                                                   ntprinter->info_2->drivername,
4136                                                   ntprinter->info_2->location);
4137         W_ERROR_HAVE_NO_MEMORY(r->description);
4138
4139         if (*ntprinter->info_2->comment == '\0') {
4140                 r->comment      = talloc_strdup(mem_ctx, lp_comment(snum));
4141         } else {
4142                 r->comment      = talloc_strdup(mem_ctx, ntprinter->info_2->comment); /* saved comment */
4143         }
4144         W_ERROR_HAVE_NO_MEMORY(r->comment);
4145
4146         r->name                 = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
4147         W_ERROR_HAVE_NO_MEMORY(r->name);
4148
4149         return WERR_OK;
4150 }
4151
4152 /********************************************************************
4153  * construct_printer_info2
4154  * fill a spoolss_PrinterInfo2 struct
4155 ********************************************************************/
4156
4157 static WERROR construct_printer_info2(TALLOC_CTX *mem_ctx,
4158                                       const NT_PRINTER_INFO_LEVEL *ntprinter,
4159                                       struct spoolss_PrinterInfo2 *r,
4160                                       int snum)
4161 {
4162         int count;
4163
4164         print_status_struct status;
4165
4166         count = print_queue_length(snum, &status);
4167
4168         r->servername           = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
4169         W_ERROR_HAVE_NO_MEMORY(r->servername);
4170         r->printername          = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
4171         W_ERROR_HAVE_NO_MEMORY(r->printername);
4172         r->sharename            = talloc_strdup(mem_ctx, lp_servicename(snum));
4173         W_ERROR_HAVE_NO_MEMORY(r->sharename);
4174         r->portname             = talloc_strdup(mem_ctx, ntprinter->info_2->portname);
4175         W_ERROR_HAVE_NO_MEMORY(r->portname);
4176         r->drivername           = talloc_strdup(mem_ctx, ntprinter->info_2->drivername);
4177         W_ERROR_HAVE_NO_MEMORY(r->drivername);
4178
4179         if (*ntprinter->info_2->comment == '\0') {
4180                 r->comment      = talloc_strdup(mem_ctx, lp_comment(snum));
4181         } else {
4182                 r->comment      = talloc_strdup(mem_ctx, ntprinter->info_2->comment);
4183         }
4184         W_ERROR_HAVE_NO_MEMORY(r->comment);
4185
4186         r->location             = talloc_strdup(mem_ctx, ntprinter->info_2->location);
4187         W_ERROR_HAVE_NO_MEMORY(r->location);
4188         r->sepfile              = talloc_strdup(mem_ctx, ntprinter->info_2->sepfile);
4189         W_ERROR_HAVE_NO_MEMORY(r->sepfile);
4190         r->printprocessor       = talloc_strdup(mem_ctx, ntprinter->info_2->printprocessor);
4191         W_ERROR_HAVE_NO_MEMORY(r->printprocessor);
4192         r->datatype             = talloc_strdup(mem_ctx, ntprinter->info_2->datatype);
4193         W_ERROR_HAVE_NO_MEMORY(r->datatype);
4194         r->parameters           = talloc_strdup(mem_ctx, ntprinter->info_2->parameters);
4195         W_ERROR_HAVE_NO_MEMORY(r->parameters);
4196
4197         r->attributes           = ntprinter->info_2->attributes;
4198
4199         r->priority             = ntprinter->info_2->priority;
4200         r->defaultpriority      = ntprinter->info_2->default_priority;
4201         r->starttime            = ntprinter->info_2->starttime;
4202         r->untiltime            = ntprinter->info_2->untiltime;
4203         r->status               = nt_printq_status(status.status);
4204         r->cjobs                = count;
4205         r->averageppm           = ntprinter->info_2->averageppm;
4206
4207         r->devmode = construct_dev_mode(mem_ctx, lp_const_servicename(snum));
4208         if (!r->devmode) {
4209                 DEBUG(8,("Returning NULL Devicemode!\n"));
4210         }
4211
4212         r->secdesc              = NULL;
4213
4214         if (ntprinter->info_2->secdesc_buf && ntprinter->info_2->secdesc_buf->sd_size != 0) {
4215                 /* don't use talloc_steal() here unless you do a deep steal of all
4216                    the SEC_DESC members */
4217
4218                 r->secdesc      = dup_sec_desc(mem_ctx, ntprinter->info_2->secdesc_buf->sd);
4219         }
4220
4221         return WERR_OK;
4222 }
4223
4224 /********************************************************************
4225 ********************************************************************/
4226
4227 static bool snum_is_shared_printer(int snum)
4228 {
4229         return (lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum));
4230 }
4231
4232 /********************************************************************
4233  Spoolss_enumprinters.
4234 ********************************************************************/
4235
4236 static WERROR enum_all_printers_info_level(TALLOC_CTX *mem_ctx,
4237                                            uint32_t level,
4238                                            uint32_t flags,
4239                                            union spoolss_PrinterInfo **info_p,
4240                                            uint32_t *count_p)
4241 {
4242         int snum;
4243         int n_services = lp_numservices();
4244         union spoolss_PrinterInfo *info = NULL;
4245         uint32_t count = 0;
4246         WERROR result = WERR_OK;
4247
4248         *count_p = 0;
4249         *info_p = NULL;
4250
4251         for (snum = 0; snum < n_services; snum++) {
4252
4253                 NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
4254
4255                 if (!snum_is_shared_printer(snum)) {
4256                         continue;
4257                 }
4258
4259                 DEBUG(4,("Found a printer in smb.conf: %s[%x]\n",
4260                         lp_servicename(snum), snum));
4261
4262                 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4263                                             union spoolss_PrinterInfo,
4264                                             count + 1);
4265                 if (!info) {
4266                         result = WERR_NOMEM;
4267                         goto out;
4268                 }
4269
4270                 result = get_a_printer(NULL, &ntprinter, 2,
4271                                        lp_const_servicename(snum));
4272                 if (!W_ERROR_IS_OK(result)) {
4273                         goto out;
4274                 }
4275
4276                 switch (level) {
4277                 case 0:
4278                         result = construct_printer_info0(info, ntprinter,
4279                                                          &info[count].info0, snum);
4280                         break;
4281                 case 1:
4282                         result = construct_printer_info1(info, ntprinter, flags,
4283                                                          &info[count].info1, snum);
4284                         break;
4285                 case 2:
4286                         result = construct_printer_info2(info, ntprinter,
4287                                                          &info[count].info2, snum);
4288                         break;
4289                 case 4:
4290                         result = construct_printer_info4(info, ntprinter,
4291                                                          &info[count].info4, snum);
4292                         break;
4293                 case 5:
4294                         result = construct_printer_info5(info, ntprinter,
4295                                                          &info[count].info5, snum);
4296                         break;
4297
4298                 default:
4299                         result = WERR_UNKNOWN_LEVEL;
4300                         free_a_printer(&ntprinter, 2);
4301                         goto out;
4302                 }
4303
4304                 free_a_printer(&ntprinter, 2);
4305                 if (!W_ERROR_IS_OK(result)) {
4306                         goto out;
4307                 }
4308
4309                 count++;
4310         }
4311
4312         *count_p = count;
4313         *info_p = info;
4314
4315  out:
4316         if (!W_ERROR_IS_OK(result)) {
4317                 TALLOC_FREE(info);
4318                 return result;
4319         }
4320
4321         *info_p = info;
4322
4323         return WERR_OK;
4324 }
4325
4326 /********************************************************************
4327  * handle enumeration of printers at level 0
4328  ********************************************************************/
4329
4330 static WERROR enumprinters_level0(TALLOC_CTX *mem_ctx,
4331                                   uint32_t flags,
4332                                   const char *servername,
4333                                   union spoolss_PrinterInfo **info,
4334                                   uint32_t *count)
4335 {
4336         DEBUG(4,("enum_all_printers_info_0\n"));
4337
4338         return enum_all_printers_info_level(mem_ctx, 0, flags, info, count);
4339 }
4340
4341
4342 /********************************************************************
4343 ********************************************************************/
4344
4345 static WERROR enum_all_printers_info_1(TALLOC_CTX *mem_ctx,
4346                                        uint32_t flags,
4347                                        union spoolss_PrinterInfo **info,
4348                                        uint32_t *count)
4349 {
4350         DEBUG(4,("enum_all_printers_info_1\n"));
4351
4352         return enum_all_printers_info_level(mem_ctx, 1, flags, info, count);
4353 }
4354
4355 /********************************************************************
4356  enum_all_printers_info_1_local.
4357 *********************************************************************/
4358
4359 static WERROR enum_all_printers_info_1_local(TALLOC_CTX *mem_ctx,
4360                                              union spoolss_PrinterInfo **info,
4361                                              uint32_t *count)
4362 {
4363         DEBUG(4,("enum_all_printers_info_1_local\n"));
4364
4365         return enum_all_printers_info_1(mem_ctx, PRINTER_ENUM_ICON8, info, count);
4366 }
4367
4368 /********************************************************************
4369  enum_all_printers_info_1_name.
4370 *********************************************************************/
4371
4372 static WERROR enum_all_printers_info_1_name(TALLOC_CTX *mem_ctx,
4373                                             const char *name,
4374                                             union spoolss_PrinterInfo **info,
4375                                             uint32_t *count)
4376 {
4377         const char *s = name;
4378
4379         DEBUG(4,("enum_all_printers_info_1_name\n"));
4380
4381         if ((name[0] == '\\') && (name[1] == '\\')) {
4382                 s = name + 2;
4383         }
4384
4385         if (!is_myname_or_ipaddr(s)) {
4386                 return WERR_INVALID_NAME;
4387         }
4388
4389         return enum_all_printers_info_1(mem_ctx, PRINTER_ENUM_ICON8, info, count);
4390 }
4391
4392 /********************************************************************
4393  enum_all_printers_info_1_network.
4394 *********************************************************************/
4395
4396 static WERROR enum_all_printers_info_1_network(TALLOC_CTX *mem_ctx,
4397                                                const char *name,
4398                                                union spoolss_PrinterInfo **info,
4399                                                uint32_t *count)
4400 {
4401         const char *s = name;
4402
4403         DEBUG(4,("enum_all_printers_info_1_network\n"));
4404
4405         /* If we respond to a enum_printers level 1 on our name with flags
4406            set to PRINTER_ENUM_REMOTE with a list of printers then these
4407            printers incorrectly appear in the APW browse list.
4408            Specifically the printers for the server appear at the workgroup
4409            level where all the other servers in the domain are
4410            listed. Windows responds to this call with a
4411            WERR_CAN_NOT_COMPLETE so we should do the same. */
4412
4413         if (name[0] == '\\' && name[1] == '\\') {
4414                  s = name + 2;
4415         }
4416
4417         if (is_myname_or_ipaddr(s)) {
4418                  return WERR_CAN_NOT_COMPLETE;
4419         }
4420
4421         return enum_all_printers_info_1(mem_ctx, PRINTER_ENUM_NAME, info, count);
4422 }
4423
4424 /********************************************************************
4425  * api_spoolss_enumprinters
4426  *
4427  * called from api_spoolss_enumprinters (see this to understand)
4428  ********************************************************************/
4429
4430 static WERROR enum_all_printers_info_2(TALLOC_CTX *mem_ctx,
4431                                        union spoolss_PrinterInfo **info,
4432                                        uint32_t *count)
4433 {
4434         DEBUG(4,("enum_all_printers_info_2\n"));
4435
4436         return enum_all_printers_info_level(mem_ctx, 2, 0, info, count);
4437 }
4438
4439 /********************************************************************
4440  * handle enumeration of printers at level 1
4441  ********************************************************************/
4442
4443 static WERROR enumprinters_level1(TALLOC_CTX *mem_ctx,
4444                                   uint32_t flags,
4445                                   const char *name,
4446                                   union spoolss_PrinterInfo **info,
4447                                   uint32_t *count)
4448 {
4449         /* Not all the flags are equals */
4450
4451         if (flags & PRINTER_ENUM_LOCAL) {
4452                 return enum_all_printers_info_1_local(mem_ctx, info, count);
4453         }
4454
4455         if (flags & PRINTER_ENUM_NAME) {
4456                 return enum_all_printers_info_1_name(mem_ctx, name, info, count);
4457         }
4458
4459         if (flags & PRINTER_ENUM_NETWORK) {
4460                 return enum_all_printers_info_1_network(mem_ctx, name, info, count);
4461         }
4462
4463         return WERR_OK; /* NT4sp5 does that */
4464 }
4465
4466 /********************************************************************
4467  * handle enumeration of printers at level 2
4468  ********************************************************************/
4469
4470 static WERROR enumprinters_level2(TALLOC_CTX *mem_ctx,
4471                                   uint32_t flags,
4472                                   const char *servername,
4473                                   union spoolss_PrinterInfo **info,
4474                                   uint32_t *count)
4475 {
4476         if (flags & PRINTER_ENUM_LOCAL) {
4477                 return enum_all_printers_info_2(mem_ctx, info, count);
4478         }
4479
4480         if (flags & PRINTER_ENUM_NAME) {
4481                 if (!is_myname_or_ipaddr(canon_servername(servername))) {
4482                         return WERR_INVALID_NAME;
4483                 }
4484
4485                 return enum_all_printers_info_2(mem_ctx, info, count);
4486         }
4487
4488         if (flags & PRINTER_ENUM_REMOTE) {
4489                 return WERR_UNKNOWN_LEVEL;
4490         }
4491
4492         return WERR_OK;
4493 }
4494
4495 /********************************************************************
4496  * handle enumeration of printers at level 4
4497  ********************************************************************/
4498
4499 static WERROR enumprinters_level4(TALLOC_CTX *mem_ctx,
4500                                   uint32_t flags,
4501                                   const char *servername,
4502                                   union spoolss_PrinterInfo **info,
4503                                   uint32_t *count)
4504 {
4505         DEBUG(4,("enum_all_printers_info_4\n"));
4506
4507         return enum_all_printers_info_level(mem_ctx, 4, flags, info, count);
4508 }
4509
4510
4511 /********************************************************************
4512  * handle enumeration of printers at level 5
4513  ********************************************************************/
4514
4515 static WERROR enumprinters_level5(TALLOC_CTX *mem_ctx,
4516                                   uint32_t flags,
4517                                   const char *servername,
4518                                   union spoolss_PrinterInfo **info,
4519                                   uint32_t *count)
4520 {
4521         DEBUG(4,("enum_all_printers_info_5\n"));
4522
4523         return enum_all_printers_info_level(mem_ctx, 5, flags, info, count);
4524 }
4525
4526 /****************************************************************
4527  _spoolss_EnumPrinters
4528 ****************************************************************/
4529
4530 WERROR _spoolss_EnumPrinters(pipes_struct *p,
4531                              struct spoolss_EnumPrinters *r)
4532 {
4533         const char *name;
4534         WERROR result;
4535
4536         /* that's an [in out] buffer */
4537
4538         if (!r->in.buffer && (r->in.offered != 0)) {
4539                 return WERR_INVALID_PARAM;
4540         }
4541
4542         DEBUG(4,("_spoolss_EnumPrinters\n"));
4543
4544         *r->out.needed = 0;
4545         *r->out.count = 0;
4546         *r->out.info = NULL;
4547
4548         /*
4549          * Level 1:
4550          *          flags==PRINTER_ENUM_NAME
4551          *           if name=="" then enumerates all printers
4552          *           if name!="" then enumerate the printer
4553          *          flags==PRINTER_ENUM_REMOTE
4554          *          name is NULL, enumerate printers
4555          * Level 2: name!="" enumerates printers, name can't be NULL
4556          * Level 3: doesn't exist
4557          * Level 4: does a local registry lookup
4558          * Level 5: same as Level 2
4559          */
4560
4561         name = talloc_strdup_upper(p->mem_ctx, r->in.server);
4562         W_ERROR_HAVE_NO_MEMORY(name);
4563
4564         switch (r->in.level) {
4565         case 0:
4566                 result = enumprinters_level0(p->mem_ctx, r->in.flags, name,
4567                                              r->out.info, r->out.count);
4568                 break;
4569         case 1:
4570                 result = enumprinters_level1(p->mem_ctx, r->in.flags, name,
4571                                              r->out.info, r->out.count);
4572                 break;
4573         case 2:
4574                 result = enumprinters_level2(p->mem_ctx, r->in.flags, name,
4575                                              r->out.info, r->out.count);
4576                 break;
4577         case 4:
4578                 result = enumprinters_level4(p->mem_ctx, r->in.flags, name,
4579                                              r->out.info, r->out.count);
4580                 break;
4581         case 5:
4582                 result = enumprinters_level5(p->mem_ctx, r->in.flags, name,
4583                                              r->out.info, r->out.count);
4584                 break;
4585         default:
4586                 return WERR_UNKNOWN_LEVEL;
4587         }
4588
4589         if (!W_ERROR_IS_OK(result)) {
4590                 return result;
4591         }
4592
4593         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
4594                                                      spoolss_EnumPrinters, NULL,
4595                                                      *r->out.info, r->in.level,
4596                                                      *r->out.count);
4597         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
4598         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
4599
4600         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
4601 }
4602
4603 /****************************************************************
4604  _spoolss_GetPrinter
4605 ****************************************************************/
4606
4607 WERROR _spoolss_GetPrinter(pipes_struct *p,
4608                            struct spoolss_GetPrinter *r)
4609 {
4610         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
4611         NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
4612         WERROR result = WERR_OK;
4613
4614         int snum;
4615
4616         /* that's an [in out] buffer */
4617
4618         if (!r->in.buffer && (r->in.offered != 0)) {
4619                 return WERR_INVALID_PARAM;
4620         }
4621
4622         *r->out.needed = 0;
4623
4624         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
4625                 return WERR_BADFID;
4626         }
4627
4628         result = get_a_printer(Printer, &ntprinter, 2,
4629                                lp_const_servicename(snum));
4630         if (!W_ERROR_IS_OK(result)) {
4631                 return result;
4632         }
4633
4634         switch (r->in.level) {
4635         case 0:
4636                 result = construct_printer_info0(p->mem_ctx, ntprinter,
4637                                                  &r->out.info->info0, snum);
4638                 break;
4639         case 1:
4640                 result = construct_printer_info1(p->mem_ctx, ntprinter,
4641                                                  PRINTER_ENUM_ICON8,
4642                                                  &r->out.info->info1, snum);
4643                 break;
4644         case 2:
4645                 result = construct_printer_info2(p->mem_ctx, ntprinter,
4646                                                  &r->out.info->info2, snum);
4647                 break;
4648         case 3:
4649                 result = construct_printer_info3(p->mem_ctx, ntprinter,
4650                                                  &r->out.info->info3, snum);
4651                 break;
4652         case 4:
4653                 result = construct_printer_info4(p->mem_ctx, ntprinter,
4654                                                  &r->out.info->info4, snum);
4655                 break;
4656         case 5:
4657                 result = construct_printer_info5(p->mem_ctx, ntprinter,
4658                                                  &r->out.info->info5, snum);
4659                 break;
4660         case 6:
4661                 result = construct_printer_info6(p->mem_ctx, ntprinter,
4662                                                  &r->out.info->info6, snum);
4663                 break;
4664         case 7:
4665                 result = construct_printer_info7(p->mem_ctx, Printer,
4666                                                  &r->out.info->info7, snum);
4667                 break;
4668         case 8:
4669                 result = construct_printer_info8(p->mem_ctx, ntprinter,
4670                                                  &r->out.info->info8, snum);
4671                 break;
4672         default:
4673                 result = WERR_UNKNOWN_LEVEL;
4674                 break;
4675         }
4676
4677         free_a_printer(&ntprinter, 2);
4678
4679         if (!W_ERROR_IS_OK(result)) {
4680                 TALLOC_FREE(r->out.info);
4681                 return result;
4682         }
4683
4684         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_PrinterInfo, NULL,
4685                                                r->out.info, r->in.level);
4686         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
4687
4688         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
4689 }
4690
4691 /********************************************************************
4692  ********************************************************************/
4693
4694 static const char **string_array_from_driver_info(TALLOC_CTX *mem_ctx,
4695                                                   fstring *fstring_array,
4696                                                   const char *cservername)
4697 {
4698         int i, num_strings = 0;
4699         const char **array = NULL;
4700
4701         for (i=0; fstring_array && fstring_array[i][0] != '\0'; i++) {
4702
4703                 const char *str = talloc_asprintf(mem_ctx, "\\\\%s%s",
4704                                                   cservername, fstring_array[i]);
4705                 if (!str) {
4706                         TALLOC_FREE(array);
4707                         return NULL;
4708                 }
4709
4710
4711                 if (!add_string_to_array(mem_ctx, str, &array, &num_strings)) {
4712                         TALLOC_FREE(array);
4713                         return NULL;
4714                 }
4715         }
4716
4717         if (i > 0) {
4718                 ADD_TO_ARRAY(mem_ctx, const char *, NULL,
4719                              &array, &num_strings);
4720         }
4721
4722         return array;
4723 }
4724
4725 /********************************************************************
4726  * fill a spoolss_DriverInfo1 struct
4727  ********************************************************************/
4728
4729 static WERROR fill_printer_driver_info1(TALLOC_CTX *mem_ctx,
4730                                         struct spoolss_DriverInfo1 *r,
4731                                         const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
4732                                         const char *servername,
4733                                         const char *architecture)
4734 {
4735         r->driver_name          = talloc_strdup(mem_ctx, driver->info_3->name);
4736         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4737
4738         return WERR_OK;
4739 }
4740
4741 /********************************************************************
4742  * fill a spoolss_DriverInfo2 struct
4743  ********************************************************************/
4744
4745 static WERROR fill_printer_driver_info2(TALLOC_CTX *mem_ctx,
4746                                         struct spoolss_DriverInfo2 *r,
4747                                         const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
4748                                         const char *servername)
4749
4750 {
4751         const char *cservername = canon_servername(servername);
4752
4753         r->version              = driver->info_3->cversion;
4754
4755         r->driver_name          = talloc_strdup(mem_ctx, driver->info_3->name);
4756         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4757         r->architecture         = talloc_strdup(mem_ctx, driver->info_3->environment);
4758         W_ERROR_HAVE_NO_MEMORY(r->architecture);
4759
4760         if (strlen(driver->info_3->driverpath)) {
4761                 r->driver_path  = talloc_asprintf(mem_ctx, "\\\\%s%s",
4762                                 cservername, driver->info_3->driverpath);
4763         } else {
4764                 r->driver_path  = talloc_strdup(mem_ctx, "");
4765         }
4766         W_ERROR_HAVE_NO_MEMORY(r->driver_path);
4767
4768         if (strlen(driver->info_3->datafile)) {
4769                 r->data_file    = talloc_asprintf(mem_ctx, "\\\\%s%s",
4770                                 cservername, driver->info_3->datafile);
4771         } else {
4772                 r->data_file    = talloc_strdup(mem_ctx, "");
4773         }
4774         W_ERROR_HAVE_NO_MEMORY(r->data_file);
4775
4776         if (strlen(driver->info_3->configfile)) {
4777                 r->config_file  = talloc_asprintf(mem_ctx, "\\\\%s%s",
4778                                 cservername, driver->info_3->configfile);
4779         } else {
4780                 r->config_file  = talloc_strdup(mem_ctx, "");
4781         }
4782         W_ERROR_HAVE_NO_MEMORY(r->config_file);
4783
4784         return WERR_OK;
4785 }
4786
4787 /********************************************************************
4788  * fill a spoolss_DriverInfo3 struct
4789  ********************************************************************/
4790
4791 static WERROR fill_printer_driver_info3(TALLOC_CTX *mem_ctx,
4792                                         struct spoolss_DriverInfo3 *r,
4793                                         const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
4794                                         const char *servername)
4795 {
4796         const char *cservername = canon_servername(servername);
4797
4798         r->version              = driver->info_3->cversion;
4799
4800         r->driver_name          = talloc_strdup(mem_ctx, driver->info_3->name);
4801         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4802         r->architecture         = talloc_strdup(mem_ctx, driver->info_3->environment);
4803         W_ERROR_HAVE_NO_MEMORY(r->architecture);
4804
4805         if (strlen(driver->info_3->driverpath)) {
4806                 r->driver_path  = talloc_asprintf(mem_ctx, "\\\\%s%s",
4807                                 cservername, driver->info_3->driverpath);
4808         } else {
4809                 r->driver_path  = talloc_strdup(mem_ctx, "");
4810         }
4811         W_ERROR_HAVE_NO_MEMORY(r->driver_path);
4812
4813         if (strlen(driver->info_3->datafile)) {
4814                 r->data_file    = talloc_asprintf(mem_ctx, "\\\\%s%s",
4815                                 cservername, driver->info_3->datafile);
4816         } else {
4817                 r->data_file    = talloc_strdup(mem_ctx, "");
4818         }
4819         W_ERROR_HAVE_NO_MEMORY(r->data_file);
4820
4821         if (strlen(driver->info_3->configfile)) {
4822                 r->config_file  = talloc_asprintf(mem_ctx, "\\\\%s%s",
4823                                 cservername, driver->info_3->configfile);
4824         } else {
4825                 r->config_file  = talloc_strdup(mem_ctx, "");
4826         }
4827         W_ERROR_HAVE_NO_MEMORY(r->config_file);
4828
4829         if (strlen(driver->info_3->helpfile)) {
4830                 r->help_file    = talloc_asprintf(mem_ctx, "\\\\%s%s",
4831                                 cservername, driver->info_3->helpfile);
4832         } else {
4833                 r->help_file    = talloc_strdup(mem_ctx, "");
4834         }
4835         W_ERROR_HAVE_NO_MEMORY(r->help_file);
4836
4837         r->monitor_name         = talloc_strdup(mem_ctx, driver->info_3->monitorname);
4838         W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
4839         r->default_datatype     = talloc_strdup(mem_ctx, driver->info_3->defaultdatatype);
4840         W_ERROR_HAVE_NO_MEMORY(r->default_datatype);
4841
4842         r->dependent_files = string_array_from_driver_info(mem_ctx,
4843                                                            driver->info_3->dependentfiles,
4844                                                            cservername);
4845         return WERR_OK;
4846 }
4847
4848 /********************************************************************
4849  * fill a spoolss_DriverInfo4 struct
4850  ********************************************************************/
4851
4852 static WERROR fill_printer_driver_info4(TALLOC_CTX *mem_ctx,
4853                                         struct spoolss_DriverInfo4 *r,
4854                                         const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
4855                                         const char *servername)
4856 {
4857         const char *cservername = canon_servername(servername);
4858
4859         r->version              = driver->info_3->cversion;
4860
4861         r->driver_name          = talloc_strdup(mem_ctx, driver->info_3->name);
4862         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4863         r->architecture         = talloc_strdup(mem_ctx, driver->info_3->environment);
4864         W_ERROR_HAVE_NO_MEMORY(r->architecture);
4865
4866         if (strlen(driver->info_3->driverpath)) {
4867                 r->driver_path  = talloc_asprintf(mem_ctx, "\\\\%s%s",
4868                                 cservername, driver->info_3->driverpath);
4869         } else {
4870                 r->driver_path  = talloc_strdup(mem_ctx, "");
4871         }
4872         W_ERROR_HAVE_NO_MEMORY(r->driver_path);
4873
4874         if (strlen(driver->info_3->datafile)) {
4875                 r->data_file    = talloc_asprintf(mem_ctx, "\\\\%s%s",
4876                                 cservername, driver->info_3->datafile);
4877         } else {
4878                 r->data_file    = talloc_strdup(mem_ctx, "");
4879         }
4880         W_ERROR_HAVE_NO_MEMORY(r->data_file);
4881
4882         if (strlen(driver->info_3->configfile)) {
4883                 r->config_file  = talloc_asprintf(mem_ctx, "\\\\%s%s",
4884                                 cservername, driver->info_3->configfile);
4885         } else {
4886                 r->config_file  = talloc_strdup(mem_ctx, "");
4887         }
4888         W_ERROR_HAVE_NO_MEMORY(r->config_file);
4889
4890         if (strlen(driver->info_3->helpfile)) {
4891                 r->help_file    = talloc_asprintf(mem_ctx, "\\\\%s%s",
4892                                 cservername, driver->info_3->helpfile);
4893         } else {
4894                 r->help_file    = talloc_strdup(mem_ctx, "");
4895         }
4896         W_ERROR_HAVE_NO_MEMORY(r->help_file);
4897
4898         r->dependent_files = string_array_from_driver_info(mem_ctx,
4899                                                            driver->info_3->dependentfiles,
4900                                                            cservername);
4901
4902
4903         r->monitor_name         = talloc_strdup(mem_ctx, driver->info_3->monitorname);
4904         W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
4905         r->default_datatype     = talloc_strdup(mem_ctx, driver->info_3->defaultdatatype);
4906         W_ERROR_HAVE_NO_MEMORY(r->default_datatype);
4907
4908         r->previous_names = string_array_from_driver_info(mem_ctx,
4909                                                           NULL,
4910                                                           cservername);
4911
4912         return WERR_OK;
4913 }
4914
4915 /********************************************************************
4916  * fill a spoolss_DriverInfo5 struct
4917  ********************************************************************/
4918
4919 static WERROR fill_printer_driver_info5(TALLOC_CTX *mem_ctx,
4920                                         struct spoolss_DriverInfo5 *r,
4921                                         const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
4922                                         const char *servername)
4923 {
4924         const char *cservername = canon_servername(servername);
4925
4926         r->version              = driver->info_3->cversion;
4927
4928         r->driver_name          = talloc_strdup(mem_ctx, driver->info_3->name);
4929         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4930         r->architecture         = talloc_strdup(mem_ctx, driver->info_3->environment);
4931         W_ERROR_HAVE_NO_MEMORY(r->architecture);
4932
4933         if (strlen(driver->info_3->driverpath)) {
4934                 r->driver_path  = talloc_asprintf(mem_ctx, "\\\\%s%s",
4935                                 cservername, driver->info_3->driverpath);
4936         } else {
4937                 r->driver_path  = talloc_strdup(mem_ctx, "");
4938         }
4939         W_ERROR_HAVE_NO_MEMORY(r->driver_path);
4940
4941         if (strlen(driver->info_3->datafile)) {
4942                 r->data_file    = talloc_asprintf(mem_ctx, "\\\\%s%s",
4943                                 cservername, driver->info_3->datafile);
4944         } else {
4945                 r->data_file    = talloc_strdup(mem_ctx, "");
4946         }
4947         W_ERROR_HAVE_NO_MEMORY(r->data_file);
4948
4949         if (strlen(driver->info_3->configfile)) {
4950                 r->config_file  = talloc_asprintf(mem_ctx, "\\\\%s%s",
4951                                 cservername, driver->info_3->configfile);
4952         } else {
4953                 r->config_file  = talloc_strdup(mem_ctx, "");
4954         }
4955         W_ERROR_HAVE_NO_MEMORY(r->config_file);
4956
4957         r->driver_attributes    = 0;
4958         r->config_version       = 0;
4959         r->driver_version       = 0;
4960
4961         return WERR_OK;
4962 }
4963 /********************************************************************
4964  * fill a spoolss_DriverInfo6 struct
4965  ********************************************************************/
4966
4967 static WERROR fill_printer_driver_info6(TALLOC_CTX *mem_ctx,
4968                                         struct spoolss_DriverInfo6 *r,
4969                                         const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
4970                                         const char *servername)
4971 {
4972         const char *cservername = canon_servername(servername);
4973
4974         r->version              = driver->info_3->cversion;
4975
4976         r->driver_name          = talloc_strdup(mem_ctx, driver->info_3->name);
4977         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4978         r->architecture         = talloc_strdup(mem_ctx, driver->info_3->environment);
4979         W_ERROR_HAVE_NO_MEMORY(r->architecture);
4980
4981         if (strlen(driver->info_3->driverpath)) {
4982                 r->driver_path  = talloc_asprintf(mem_ctx, "\\\\%s%s",
4983                                 cservername, driver->info_3->driverpath);
4984         } else {
4985                 r->driver_path  = talloc_strdup(mem_ctx, "");
4986         }
4987         W_ERROR_HAVE_NO_MEMORY(r->driver_path);
4988
4989         if (strlen(driver->info_3->datafile)) {
4990                 r->data_file    = talloc_asprintf(mem_ctx, "\\\\%s%s",
4991                                 cservername, driver->info_3->datafile);
4992         } else {
4993                 r->data_file    = talloc_strdup(mem_ctx, "");
4994         }
4995         W_ERROR_HAVE_NO_MEMORY(r->data_file);
4996
4997         if (strlen(driver->info_3->configfile)) {
4998                 r->config_file  = talloc_asprintf(mem_ctx, "\\\\%s%s",
4999                                 cservername, driver->info_3->configfile);
5000         } else {
5001                 r->config_file  = talloc_strdup(mem_ctx, "");
5002         }
5003         W_ERROR_HAVE_NO_MEMORY(r->config_file);
5004
5005         if (strlen(driver->info_3->helpfile)) {
5006                 r->help_file    = talloc_asprintf(mem_ctx, "\\\\%s%s",
5007                                 cservername, driver->info_3->helpfile);
5008         } else {
5009                 r->help_file    = talloc_strdup(mem_ctx, "");
5010         }
5011         W_ERROR_HAVE_NO_MEMORY(r->help_file);
5012
5013         r->monitor_name         = talloc_strdup(mem_ctx, driver->info_3->monitorname);
5014         W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
5015         r->default_datatype     = talloc_strdup(mem_ctx, driver->info_3->defaultdatatype);
5016         W_ERROR_HAVE_NO_MEMORY(r->default_datatype);
5017
5018         r->dependent_files = string_array_from_driver_info(mem_ctx,
5019                                                            driver->info_3->dependentfiles,
5020                                                            cservername);
5021         r->previous_names = string_array_from_driver_info(mem_ctx,
5022                                                           NULL,
5023                                                           cservername);
5024
5025         r->driver_date          = 0;
5026         r->driver_version       = 0;
5027
5028         r->manufacturer_name    = talloc_strdup(mem_ctx, "");
5029         W_ERROR_HAVE_NO_MEMORY(r->manufacturer_name);
5030         r->manufacturer_url     = talloc_strdup(mem_ctx, "");
5031         W_ERROR_HAVE_NO_MEMORY(r->manufacturer_url);
5032         r->hardware_id          = talloc_strdup(mem_ctx, "");
5033         W_ERROR_HAVE_NO_MEMORY(r->hardware_id);
5034         r->provider             = talloc_strdup(mem_ctx, "");
5035         W_ERROR_HAVE_NO_MEMORY(r->provider);
5036
5037         return WERR_OK;
5038 }
5039
5040 /********************************************************************
5041  ********************************************************************/
5042 #if 0 /* disabled until marshalling issues are resolved - gd */
5043 static WERROR fill_spoolss_DriverFileInfo(TALLOC_CTX *mem_ctx,
5044                                           struct spoolss_DriverFileInfo *r,
5045                                           const char *cservername,
5046                                           const char *file_name,
5047                                           enum spoolss_DriverFileType file_type,
5048                                           uint32_t file_version)
5049 {
5050         r->file_name    = talloc_asprintf(mem_ctx, "\\\\%s%s",
5051                                           cservername, file_name);
5052         W_ERROR_HAVE_NO_MEMORY(r->file_name);
5053         r->file_type    = file_type;
5054         r->file_version = file_version;
5055
5056         return WERR_OK;
5057 }
5058
5059 /********************************************************************
5060  ********************************************************************/
5061
5062 static WERROR spoolss_DriverFileInfo_from_driver(TALLOC_CTX *mem_ctx,
5063                                                  const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
5064                                                  const char *cservername,
5065                                                  struct spoolss_DriverFileInfo **info_p,
5066                                                  uint32_t *count_p)
5067 {
5068         struct spoolss_DriverFileInfo *info = NULL;
5069         uint32_t count = 0;
5070         WERROR result;
5071         uint32_t i;
5072
5073         *info_p = NULL;
5074         *count_p = 0;
5075
5076         if (strlen(driver->info_3->driverpath)) {
5077                 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
5078                                             struct spoolss_DriverFileInfo,
5079                                             count + 1);
5080                 W_ERROR_HAVE_NO_MEMORY(info);
5081                 result = fill_spoolss_DriverFileInfo(info,
5082                                                      &info[count],
5083                                                      cservername,
5084                                                      driver->info_3->driverpath,
5085                                                      SPOOLSS_DRIVER_FILE_TYPE_RENDERING,
5086                                                      0);
5087                 W_ERROR_NOT_OK_RETURN(result);
5088                 count++;
5089         }
5090
5091         if (strlen(driver->info_3->configfile)) {
5092                 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
5093                                             struct spoolss_DriverFileInfo,
5094                                             count + 1);
5095                 W_ERROR_HAVE_NO_MEMORY(info);
5096                 result = fill_spoolss_DriverFileInfo(info,
5097                                                      &info[count],
5098                                                      cservername,
5099                                                      driver->info_3->configfile,
5100                                                      SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION,
5101                                                      0);
5102                 W_ERROR_NOT_OK_RETURN(result);
5103                 count++;
5104         }
5105
5106         if (strlen(driver->info_3->datafile)) {
5107                 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
5108                                             struct spoolss_DriverFileInfo,
5109                                             count + 1);
5110                 W_ERROR_HAVE_NO_MEMORY(info);
5111                 result = fill_spoolss_DriverFileInfo(info,
5112                                                      &info[count],
5113                                                      cservername,
5114                                                      driver->info_3->datafile,
5115                                                      SPOOLSS_DRIVER_FILE_TYPE_DATA,
5116                                                      0);
5117                 W_ERROR_NOT_OK_RETURN(result);
5118                 count++;
5119         }
5120
5121         if (strlen(driver->info_3->helpfile)) {
5122                 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
5123                                             struct spoolss_DriverFileInfo,
5124                                             count + 1);
5125                 W_ERROR_HAVE_NO_MEMORY(info);
5126                 result = fill_spoolss_DriverFileInfo(info,
5127                                                      &info[count],
5128                                                      cservername,
5129                                                      driver->info_3->helpfile,
5130                                                      SPOOLSS_DRIVER_FILE_TYPE_HELP,
5131                                                      0);
5132                 W_ERROR_NOT_OK_RETURN(result);
5133                 count++;
5134         }
5135
5136         for (i=0; driver->info_3->dependentfiles[i][0] != '\0'; i++) {
5137                 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
5138                                             struct spoolss_DriverFileInfo,
5139                                             count + 1);
5140                 W_ERROR_HAVE_NO_MEMORY(info);
5141                 result = fill_spoolss_DriverFileInfo(info,
5142                                                      &info[count],
5143                                                      cservername,
5144                                                      driver->info_3->dependentfiles[i],
5145                                                      SPOOLSS_DRIVER_FILE_TYPE_OTHER,
5146                                                      0);
5147                 W_ERROR_NOT_OK_RETURN(result);
5148                 count++;
5149         }
5150
5151         *info_p = info;
5152         *count_p = count;
5153
5154         return WERR_OK;
5155 }
5156
5157 /********************************************************************
5158  * fill a spoolss_DriverInfo101 struct
5159  ********************************************************************/
5160
5161 static WERROR fill_printer_driver_info101(TALLOC_CTX *mem_ctx,
5162                                           struct spoolss_DriverInfo101 *r,
5163                                           const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
5164                                           const char *servername)
5165 {
5166         const char *cservername = canon_servername(servername);
5167         WERROR result;
5168
5169         r->version              = driver->info_3->cversion;
5170
5171         r->driver_name          = talloc_strdup(mem_ctx, driver->info_3->name);
5172         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
5173         r->architecture         = talloc_strdup(mem_ctx, driver->info_3->environment);
5174         W_ERROR_HAVE_NO_MEMORY(r->architecture);
5175
5176         result = spoolss_DriverFileInfo_from_driver(mem_ctx, driver,
5177                                                     cservername,
5178                                                     &r->file_info,
5179                                                     &r->file_count);
5180         if (!W_ERROR_IS_OK(result)) {
5181                 return result;
5182         }
5183
5184         r->monitor_name         = talloc_strdup(mem_ctx, driver->info_3->monitorname);
5185         W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
5186
5187         r->default_datatype     = talloc_strdup(mem_ctx, driver->info_3->defaultdatatype);
5188         W_ERROR_HAVE_NO_MEMORY(r->default_datatype);
5189
5190         r->previous_names = string_array_from_driver_info(mem_ctx,
5191                                                           NULL,
5192                                                           cservername);
5193         r->driver_date          = 0;
5194         r->driver_version       = 0;
5195
5196         r->manufacturer_name    = talloc_strdup(mem_ctx, "");
5197         W_ERROR_HAVE_NO_MEMORY(r->manufacturer_name);
5198         r->manufacturer_url     = talloc_strdup(mem_ctx, "");
5199         W_ERROR_HAVE_NO_MEMORY(r->manufacturer_url);
5200         r->hardware_id          = talloc_strdup(mem_ctx, "");
5201         W_ERROR_HAVE_NO_MEMORY(r->hardware_id);
5202         r->provider             = talloc_strdup(mem_ctx, "");
5203         W_ERROR_HAVE_NO_MEMORY(r->provider);
5204
5205         return WERR_OK;
5206 }
5207 #endif
5208 /********************************************************************
5209  * construct_printer_driver_info_1
5210  ********************************************************************/
5211
5212 static WERROR construct_printer_driver_info_1(TALLOC_CTX *mem_ctx,
5213                                               struct spoolss_DriverInfo1 *r,
5214                                               int snum,
5215                                               const char *servername,
5216                                               const char *architecture,
5217                                               uint32_t version)
5218 {
5219         NT_PRINTER_INFO_LEVEL *printer = NULL;
5220         NT_PRINTER_DRIVER_INFO_LEVEL driver;
5221         WERROR result;
5222
5223         ZERO_STRUCT(driver);
5224
5225         if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, lp_const_servicename(snum))))
5226                 return WERR_INVALID_PRINTER_NAME;
5227
5228         if (!W_ERROR_IS_OK(get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version))) {
5229                 free_a_printer(&printer, 2);
5230                 return WERR_UNKNOWN_PRINTER_DRIVER;
5231         }
5232
5233         result = fill_printer_driver_info1(mem_ctx, r, &driver, servername, architecture);
5234
5235         free_a_printer(&printer,2);
5236
5237         return result;
5238 }
5239
5240 /********************************************************************
5241  * construct_printer_driver_info_2
5242  * fill a printer_info_2 struct
5243  ********************************************************************/
5244
5245 static WERROR construct_printer_driver_info_2(TALLOC_CTX *mem_ctx,
5246                                               struct spoolss_DriverInfo2 *r,
5247                                               int snum,
5248                                               const char *servername,
5249                                               const char *architecture,
5250                                               uint32_t version)
5251 {
5252         NT_PRINTER_INFO_LEVEL *printer = NULL;
5253         NT_PRINTER_DRIVER_INFO_LEVEL driver;
5254         WERROR result;
5255
5256         ZERO_STRUCT(printer);
5257         ZERO_STRUCT(driver);
5258
5259         if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, lp_const_servicename(snum))))
5260                 return WERR_INVALID_PRINTER_NAME;
5261
5262         if (!W_ERROR_IS_OK(get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version))) {
5263                 free_a_printer(&printer, 2);
5264                 return WERR_UNKNOWN_PRINTER_DRIVER;
5265         }
5266
5267         result = fill_printer_driver_info2(mem_ctx, r, &driver, servername);
5268
5269         free_a_printer(&printer,2);
5270
5271         return result;
5272 }
5273
5274 /********************************************************************
5275  * construct_printer_info_3
5276  * fill a printer_info_3 struct
5277  ********************************************************************/
5278
5279 static WERROR construct_printer_driver_info_3(TALLOC_CTX *mem_ctx,
5280                                               struct spoolss_DriverInfo3 *r,
5281                                               int snum,
5282                                               const char *servername,
5283                                               const char *architecture,
5284                                               uint32_t version)
5285 {
5286         NT_PRINTER_INFO_LEVEL *printer = NULL;
5287         NT_PRINTER_DRIVER_INFO_LEVEL driver;
5288         WERROR status;
5289         ZERO_STRUCT(driver);
5290
5291         status=get_a_printer(NULL, &printer, 2, lp_const_servicename(snum) );
5292         DEBUG(8,("construct_printer_driver_info_3: status: %s\n", win_errstr(status)));
5293         if (!W_ERROR_IS_OK(status))
5294                 return WERR_INVALID_PRINTER_NAME;
5295
5296         status=get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
5297         DEBUG(8,("construct_printer_driver_info_3: status: %s\n", win_errstr(status)));
5298
5299 #if 0   /* JERRY */
5300
5301         /*
5302          * I put this code in during testing.  Helpful when commenting out the
5303          * support for DRIVER_INFO_6 in regards to win2k.  Not needed in general
5304          * as win2k always queries the driver using an infor level of 6.
5305          * I've left it in (but ifdef'd out) because I'll probably
5306          * use it in experimentation again in the future.   --jerry 22/01/2002
5307          */
5308
5309         if (!W_ERROR_IS_OK(status)) {
5310                 /*
5311                  * Is this a W2k client ?
5312                  */
5313                 if (version == 3) {
5314                         /* Yes - try again with a WinNT driver. */
5315                         version = 2;
5316                         status=get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
5317                         DEBUG(8,("construct_printer_driver_info_3: status: %s\n", win_errstr(status)));
5318                 }
5319 #endif
5320
5321                 if (!W_ERROR_IS_OK(status)) {
5322                         free_a_printer(&printer,2);
5323                         return WERR_UNKNOWN_PRINTER_DRIVER;
5324                 }
5325
5326 #if 0   /* JERRY */
5327         }
5328 #endif
5329
5330
5331         status = fill_printer_driver_info3(mem_ctx, r, &driver, servername);
5332
5333         free_a_printer(&printer,2);
5334
5335         return status;
5336 }
5337
5338 /********************************************************************
5339  * construct_printer_info_6
5340  * fill a printer_info_6 struct
5341  ********************************************************************/
5342
5343 static WERROR construct_printer_driver_info_6(TALLOC_CTX *mem_ctx,
5344                                               struct spoolss_DriverInfo6 *r,
5345                                               int snum,
5346                                               const char *servername,
5347                                               const char *architecture,
5348                                               uint32_t version)
5349 {
5350         NT_PRINTER_INFO_LEVEL           *printer = NULL;
5351         NT_PRINTER_DRIVER_INFO_LEVEL    driver;
5352         WERROR                          status;
5353
5354         ZERO_STRUCT(driver);
5355
5356         status=get_a_printer(NULL, &printer, 2, lp_const_servicename(snum) );
5357
5358         DEBUG(8,("construct_printer_driver_info_6: status: %s\n", win_errstr(status)));
5359
5360         if (!W_ERROR_IS_OK(status))
5361                 return WERR_INVALID_PRINTER_NAME;
5362
5363         status = get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
5364
5365         DEBUG(8,("construct_printer_driver_info_6: status: %s\n", win_errstr(status)));
5366
5367         if (!W_ERROR_IS_OK(status))
5368         {
5369                 /*
5370                  * Is this a W2k client ?
5371                  */
5372
5373                 if (version < 3) {
5374                         free_a_printer(&printer,2);
5375                         return WERR_UNKNOWN_PRINTER_DRIVER;
5376                 }
5377
5378                 /* Yes - try again with a WinNT driver. */
5379                 version = 2;
5380                 status=get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
5381                 DEBUG(8,("construct_printer_driver_info_6: status: %s\n", win_errstr(status)));
5382                 if (!W_ERROR_IS_OK(status)) {
5383                         free_a_printer(&printer,2);
5384                         return WERR_UNKNOWN_PRINTER_DRIVER;
5385                 }
5386         }
5387
5388         status = fill_printer_driver_info6(mem_ctx, r, &driver, servername);
5389
5390         free_a_printer(&printer,2);
5391         free_a_printer_driver(driver, 3);
5392
5393         return status;
5394 }
5395 #if 0 /* disabled until marshalling issues are resolved - gd */
5396 /********************************************************************
5397  * construct_printer_info_101
5398  * fill a printer_info_101 struct
5399  ********************************************************************/
5400
5401 static WERROR construct_printer_driver_info_101(TALLOC_CTX *mem_ctx,
5402                                                 struct spoolss_DriverInfo101 *r,
5403                                                 int snum,
5404                                                 const char *servername,
5405                                                 const char *architecture,
5406                                                 uint32_t version)
5407 {
5408         NT_PRINTER_INFO_LEVEL           *printer = NULL;
5409         NT_PRINTER_DRIVER_INFO_LEVEL    driver;
5410         WERROR                          result;
5411
5412         ZERO_STRUCT(driver);
5413
5414         result = get_a_printer(NULL, &printer, 2, lp_const_servicename(snum));
5415
5416         DEBUG(8,("construct_printer_driver_info_101: status: %s\n",
5417                 win_errstr(result)));
5418
5419         if (!W_ERROR_IS_OK(result)) {
5420                 return WERR_INVALID_PRINTER_NAME;
5421         }
5422
5423         result = get_a_printer_driver(&driver, 3, printer->info_2->drivername,
5424                                       architecture, version);
5425
5426         DEBUG(8,("construct_printer_driver_info_101: status: %s\n",
5427                 win_errstr(result)));
5428
5429         if (!W_ERROR_IS_OK(result)) {
5430                 /*
5431                  * Is this a W2k client ?
5432                  */
5433
5434                 if (version < 3) {
5435                         free_a_printer(&printer, 2);
5436                         return WERR_UNKNOWN_PRINTER_DRIVER;
5437                 }
5438
5439                 /* Yes - try again with a WinNT driver. */
5440                 version = 2;
5441                 result = get_a_printer_driver(&driver, 3, printer->info_2->drivername,
5442                                               architecture, version);
5443                 DEBUG(8,("construct_printer_driver_info_6: status: %s\n",
5444                         win_errstr(result)));
5445                 if (!W_ERROR_IS_OK(result)) {
5446                         free_a_printer(&printer, 2);
5447                         return WERR_UNKNOWN_PRINTER_DRIVER;
5448                 }
5449         }
5450
5451         result = fill_printer_driver_info101(mem_ctx, r, &driver, servername);
5452
5453         free_a_printer(&printer, 2);
5454         free_a_printer_driver(driver, 3);
5455
5456         return result;
5457 }
5458 #endif
5459 /****************************************************************
5460  _spoolss_GetPrinterDriver2
5461 ****************************************************************/
5462
5463 WERROR _spoolss_GetPrinterDriver2(pipes_struct *p,
5464                                   struct spoolss_GetPrinterDriver2 *r)
5465 {
5466         Printer_entry *printer;
5467         WERROR result;
5468
5469         const char *servername;
5470         int snum;
5471
5472         /* that's an [in out] buffer */
5473
5474         if (!r->in.buffer && (r->in.offered != 0)) {
5475                 return WERR_INVALID_PARAM;
5476         }
5477
5478         DEBUG(4,("_spoolss_GetPrinterDriver2\n"));
5479
5480         if (!(printer = find_printer_index_by_hnd(p, r->in.handle))) {
5481                 DEBUG(0,("_spoolss_GetPrinterDriver2: invalid printer handle!\n"));
5482                 return WERR_INVALID_PRINTER_NAME;
5483         }
5484
5485         *r->out.needed = 0;
5486         *r->out.server_major_version = 0;
5487         *r->out.server_minor_version = 0;
5488
5489         servername = get_server_name(printer);
5490
5491         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5492                 return WERR_BADFID;
5493         }
5494
5495         switch (r->in.level) {
5496         case 1:
5497                 result = construct_printer_driver_info_1(p->mem_ctx,
5498                                                          &r->out.info->info1,
5499                                                          snum,
5500                                                          servername,
5501                                                          r->in.architecture,
5502                                                          r->in.client_major_version);
5503                 break;
5504         case 2:
5505                 result = construct_printer_driver_info_2(p->mem_ctx,
5506                                                          &r->out.info->info2,
5507                                                          snum,
5508                                                          servername,
5509                                                          r->in.architecture,
5510                                                          r->in.client_major_version);
5511                 break;
5512         case 3:
5513                 result = construct_printer_driver_info_3(p->mem_ctx,
5514                                                          &r->out.info->info3,
5515                                                          snum,
5516                                                          servername,
5517                                                          r->in.architecture,
5518                                                          r->in.client_major_version);
5519                 break;
5520         case 6:
5521                 result = construct_printer_driver_info_6(p->mem_ctx,
5522                                                          &r->out.info->info6,
5523                                                          snum,
5524                                                          servername,
5525                                                          r->in.architecture,
5526                                                          r->in.client_major_version);
5527                 break;
5528 #if 0 /* disabled until marshalling issues are resolved - gd */
5529         case 101:
5530                 result = construct_printer_driver_info_101(p->mem_ctx,
5531                                                            &r->out.info->info101,
5532                                                            snum,
5533                                                            servername,
5534                                                            r->in.architecture,
5535                                                            r->in.client_major_version);
5536                 break;
5537 #endif
5538         default:
5539                 result = WERR_UNKNOWN_LEVEL;
5540                 break;
5541         }
5542
5543         if (!W_ERROR_IS_OK(result)) {
5544                 TALLOC_FREE(r->out.info);
5545                 return result;
5546         }
5547
5548         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_DriverInfo, NULL,
5549                                                r->out.info, r->in.level);
5550         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
5551
5552         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
5553 }
5554
5555
5556 /****************************************************************
5557  _spoolss_StartPagePrinter
5558 ****************************************************************/
5559
5560 WERROR _spoolss_StartPagePrinter(pipes_struct *p,
5561                                  struct spoolss_StartPagePrinter *r)
5562 {
5563         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5564
5565         if (!Printer) {
5566                 DEBUG(3,("_spoolss_StartPagePrinter: "
5567                         "Error in startpageprinter printer handle\n"));
5568                 return WERR_BADFID;
5569         }
5570
5571         Printer->page_started = true;
5572         return WERR_OK;
5573 }
5574
5575 /****************************************************************
5576  _spoolss_EndPagePrinter
5577 ****************************************************************/
5578
5579 WERROR _spoolss_EndPagePrinter(pipes_struct *p,
5580                                struct spoolss_EndPagePrinter *r)
5581 {
5582         int snum;
5583
5584         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5585
5586         if (!Printer) {
5587                 DEBUG(2,("_spoolss_EndPagePrinter: Invalid handle (%s:%u:%u).\n",
5588                         OUR_HANDLE(r->in.handle)));
5589                 return WERR_BADFID;
5590         }
5591
5592         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5593                 return WERR_BADFID;
5594
5595         Printer->page_started = false;
5596         print_job_endpage(snum, Printer->jobid);
5597
5598         return WERR_OK;
5599 }
5600
5601 /****************************************************************
5602  _spoolss_StartDocPrinter
5603 ****************************************************************/
5604
5605 WERROR _spoolss_StartDocPrinter(pipes_struct *p,
5606                                 struct spoolss_StartDocPrinter *r)
5607 {
5608         struct spoolss_DocumentInfo1 *info_1;
5609         int snum;
5610         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5611
5612         if (!Printer) {
5613                 DEBUG(2,("_spoolss_StartDocPrinter: "
5614                         "Invalid handle (%s:%u:%u)\n",
5615                         OUR_HANDLE(r->in.handle)));
5616                 return WERR_BADFID;
5617         }
5618
5619         if (r->in.level != 1) {
5620                 return WERR_UNKNOWN_LEVEL;
5621         }
5622
5623         info_1 = r->in.info.info1;
5624
5625         /*
5626          * a nice thing with NT is it doesn't listen to what you tell it.
5627          * when asked to send _only_ RAW datas, it tries to send datas
5628          * in EMF format.
5629          *
5630          * So I add checks like in NT Server ...
5631          */
5632
5633         if (info_1->datatype) {
5634                 if (strcmp(info_1->datatype, "RAW") != 0) {
5635                         *r->out.job_id = 0;
5636                         return WERR_INVALID_DATATYPE;
5637                 }
5638         }
5639
5640         /* get the share number of the printer */
5641         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5642                 return WERR_BADFID;
5643         }
5644
5645         Printer->jobid = print_job_start(p->server_info, snum,
5646                                          info_1->document_name,
5647                                          Printer->nt_devmode);
5648
5649         /* An error occured in print_job_start() so return an appropriate
5650            NT error code. */
5651
5652         if (Printer->jobid == -1) {
5653                 return map_werror_from_unix(errno);
5654         }
5655
5656         Printer->document_started = true;
5657         *r->out.job_id = Printer->jobid;
5658
5659         return WERR_OK;
5660 }
5661
5662 /****************************************************************
5663  _spoolss_EndDocPrinter
5664 ****************************************************************/
5665
5666 WERROR _spoolss_EndDocPrinter(pipes_struct *p,
5667                               struct spoolss_EndDocPrinter *r)
5668 {
5669         return _spoolss_enddocprinter_internal(p, r->in.handle);
5670 }
5671
5672 /****************************************************************
5673  _spoolss_WritePrinter
5674 ****************************************************************/
5675
5676 WERROR _spoolss_WritePrinter(pipes_struct *p,
5677                              struct spoolss_WritePrinter *r)
5678 {
5679         uint32_t buffer_written;
5680         int snum;
5681         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5682
5683         if (!Printer) {
5684                 DEBUG(2,("_spoolss_WritePrinter: Invalid handle (%s:%u:%u)\n",
5685                         OUR_HANDLE(r->in.handle)));
5686                 *r->out.num_written = r->in._data_size;
5687                 return WERR_BADFID;
5688         }
5689
5690         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5691                 return WERR_BADFID;
5692
5693         buffer_written = (uint32_t)print_job_write(snum, Printer->jobid,
5694                                                    (const char *)r->in.data.data,
5695                                                    (SMB_OFF_T)-1,
5696                                                    (size_t)r->in._data_size);
5697         if (buffer_written == (uint32_t)-1) {
5698                 *r->out.num_written = 0;
5699                 if (errno == ENOSPC)
5700                         return WERR_NO_SPOOL_SPACE;
5701                 else
5702                         return WERR_ACCESS_DENIED;
5703         }
5704
5705         *r->out.num_written = r->in._data_size;
5706
5707         return WERR_OK;
5708 }
5709
5710 /********************************************************************
5711  * api_spoolss_getprinter
5712  * called from the spoolss dispatcher
5713  *
5714  ********************************************************************/
5715
5716 static WERROR control_printer(struct policy_handle *handle, uint32_t command,
5717                               pipes_struct *p)
5718 {
5719         int snum;
5720         WERROR errcode = WERR_BADFUNC;
5721         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5722
5723         if (!Printer) {
5724                 DEBUG(2,("control_printer: Invalid handle (%s:%u:%u)\n",
5725                         OUR_HANDLE(handle)));
5726                 return WERR_BADFID;
5727         }
5728
5729         if (!get_printer_snum(p, handle, &snum, NULL))
5730                 return WERR_BADFID;
5731
5732         switch (command) {
5733         case SPOOLSS_PRINTER_CONTROL_PAUSE:
5734                 errcode = print_queue_pause(p->server_info, snum);
5735                 break;
5736         case SPOOLSS_PRINTER_CONTROL_RESUME:
5737         case SPOOLSS_PRINTER_CONTROL_UNPAUSE:
5738                 errcode = print_queue_resume(p->server_info, snum);
5739                 break;
5740         case SPOOLSS_PRINTER_CONTROL_PURGE:
5741                 errcode = print_queue_purge(p->server_info, snum);
5742                 break;
5743         default:
5744                 return WERR_UNKNOWN_LEVEL;
5745         }
5746
5747         return errcode;
5748 }
5749
5750
5751 /****************************************************************
5752  _spoolss_AbortPrinter
5753  * From MSDN: "Deletes printer's spool file if printer is configured
5754  * for spooling"
5755 ****************************************************************/
5756
5757 WERROR _spoolss_AbortPrinter(pipes_struct *p,
5758                              struct spoolss_AbortPrinter *r)
5759 {
5760         Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
5761         int             snum;
5762         WERROR          errcode = WERR_OK;
5763
5764         if (!Printer) {
5765                 DEBUG(2,("_spoolss_AbortPrinter: Invalid handle (%s:%u:%u)\n",
5766                         OUR_HANDLE(r->in.handle)));
5767                 return WERR_BADFID;
5768         }
5769
5770         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5771                 return WERR_BADFID;
5772
5773         print_job_delete(p->server_info, snum, Printer->jobid, &errcode );
5774
5775         return errcode;
5776 }
5777
5778 /********************************************************************
5779  * called by spoolss_api_setprinter
5780  * when updating a printer description
5781  ********************************************************************/
5782
5783 static WERROR update_printer_sec(struct policy_handle *handle,
5784                                  pipes_struct *p, SEC_DESC_BUF *secdesc_ctr)
5785 {
5786         SEC_DESC_BUF *new_secdesc_ctr = NULL, *old_secdesc_ctr = NULL;
5787         WERROR result;
5788         int snum;
5789
5790         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5791
5792         if (!Printer || !get_printer_snum(p, handle, &snum, NULL)) {
5793                 DEBUG(2,("update_printer_sec: Invalid handle (%s:%u:%u)\n",
5794                          OUR_HANDLE(handle)));
5795
5796                 result = WERR_BADFID;
5797                 goto done;
5798         }
5799
5800         if (!secdesc_ctr) {
5801                 DEBUG(10,("update_printer_sec: secdesc_ctr is NULL !\n"));
5802                 result = WERR_INVALID_PARAM;
5803                 goto done;
5804         }
5805
5806         /* Check the user has permissions to change the security
5807            descriptor.  By experimentation with two NT machines, the user
5808            requires Full Access to the printer to change security
5809            information. */
5810
5811         if ( Printer->access_granted != PRINTER_ACCESS_ADMINISTER ) {
5812                 DEBUG(4,("update_printer_sec: updated denied by printer permissions\n"));
5813                 result = WERR_ACCESS_DENIED;
5814                 goto done;
5815         }
5816
5817         /* NT seems to like setting the security descriptor even though
5818            nothing may have actually changed. */
5819
5820         if ( !nt_printing_getsec(p->mem_ctx, Printer->sharename, &old_secdesc_ctr)) {
5821                 DEBUG(2,("update_printer_sec: nt_printing_getsec() failed\n"));
5822                 result = WERR_BADFID;
5823                 goto done;
5824         }
5825
5826         if (DEBUGLEVEL >= 10) {
5827                 SEC_ACL *the_acl;
5828                 int i;
5829
5830                 the_acl = old_secdesc_ctr->sd->dacl;
5831                 DEBUG(10, ("old_secdesc_ctr for %s has %d aces:\n",
5832                            PRINTERNAME(snum), the_acl->num_aces));
5833
5834                 for (i = 0; i < the_acl->num_aces; i++) {
5835                         DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
5836                                            &the_acl->aces[i].trustee),
5837                                   the_acl->aces[i].access_mask));
5838                 }
5839
5840                 the_acl = secdesc_ctr->sd->dacl;
5841
5842                 if (the_acl) {
5843                         DEBUG(10, ("secdesc_ctr for %s has %d aces:\n",
5844                                    PRINTERNAME(snum), the_acl->num_aces));
5845
5846                         for (i = 0; i < the_acl->num_aces; i++) {
5847                                 DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
5848                                                    &the_acl->aces[i].trustee),
5849                                            the_acl->aces[i].access_mask));
5850                         }
5851                 } else {
5852                         DEBUG(10, ("dacl for secdesc_ctr is NULL\n"));
5853                 }
5854         }
5855
5856         new_secdesc_ctr = sec_desc_merge(p->mem_ctx, secdesc_ctr, old_secdesc_ctr);
5857         if (!new_secdesc_ctr) {
5858                 result = WERR_NOMEM;
5859                 goto done;
5860         }
5861
5862         if (sec_desc_equal(new_secdesc_ctr->sd, old_secdesc_ctr->sd)) {
5863                 result = WERR_OK;
5864                 goto done;
5865         }
5866
5867         result = nt_printing_setsec(Printer->sharename, new_secdesc_ctr);
5868
5869  done:
5870
5871         return result;
5872 }
5873
5874 /********************************************************************
5875  Canonicalize printer info from a client
5876
5877  ATTN: It does not matter what we set the servername to hear
5878  since we do the necessary work in get_a_printer() to set it to
5879  the correct value based on what the client sent in the
5880  _spoolss_open_printer_ex().
5881  ********************************************************************/
5882
5883 static bool check_printer_ok(NT_PRINTER_INFO_LEVEL_2 *info, int snum)
5884 {
5885         fstring printername;
5886         const char *p;
5887
5888         DEBUG(5,("check_printer_ok: servername=%s printername=%s sharename=%s "
5889                 "portname=%s drivername=%s comment=%s location=%s\n",
5890                 info->servername, info->printername, info->sharename,
5891                 info->portname, info->drivername, info->comment, info->location));
5892
5893         /* we force some elements to "correct" values */
5894         slprintf(info->servername, sizeof(info->servername)-1, "\\\\%s", global_myname());
5895         fstrcpy(info->sharename, lp_servicename(snum));
5896
5897         /* check to see if we allow printername != sharename */
5898
5899         if ( lp_force_printername(snum) ) {
5900                 slprintf(info->printername, sizeof(info->printername)-1, "\\\\%s\\%s",
5901                         global_myname(), info->sharename );
5902         } else {
5903
5904                 /* make sure printername is in \\server\printername format */
5905
5906                 fstrcpy( printername, info->printername );
5907                 p = printername;
5908                 if ( printername[0] == '\\' && printername[1] == '\\' ) {
5909                         if ( (p = strchr_m( &printername[2], '\\' )) != NULL )
5910                                 p++;
5911                 }
5912
5913                 slprintf(info->printername, sizeof(info->printername)-1, "\\\\%s\\%s",
5914                          global_myname(), p );
5915         }
5916
5917         info->attributes |= PRINTER_ATTRIBUTE_SAMBA;
5918         info->attributes &= ~PRINTER_ATTRIBUTE_NOT_SAMBA;
5919
5920
5921
5922         return true;
5923 }
5924
5925 /****************************************************************************
5926 ****************************************************************************/
5927
5928 WERROR add_port_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, const char *portname, const char *uri )
5929 {
5930         char *cmd = lp_addport_cmd();
5931         char *command = NULL;
5932         int ret;
5933         SE_PRIV se_printop = SE_PRINT_OPERATOR;
5934         bool is_print_op = false;
5935
5936         if ( !*cmd ) {
5937                 return WERR_ACCESS_DENIED;
5938         }
5939
5940         command = talloc_asprintf(ctx,
5941                         "%s \"%s\" \"%s\"", cmd, portname, uri );
5942         if (!command) {
5943                 return WERR_NOMEM;
5944         }
5945
5946         if ( token )
5947                 is_print_op = user_has_privileges( token, &se_printop );
5948
5949         DEBUG(10,("Running [%s]\n", command));
5950
5951         /********* BEGIN SePrintOperatorPrivilege **********/
5952
5953         if ( is_print_op )
5954                 become_root();
5955
5956         ret = smbrun(command, NULL);
5957
5958         if ( is_print_op )
5959                 unbecome_root();
5960
5961         /********* END SePrintOperatorPrivilege **********/
5962
5963         DEBUGADD(10,("returned [%d]\n", ret));
5964
5965         TALLOC_FREE(command);
5966
5967         if ( ret != 0 ) {
5968                 return WERR_ACCESS_DENIED;
5969         }
5970
5971         return WERR_OK;
5972 }
5973
5974 /****************************************************************************
5975 ****************************************************************************/
5976
5977 bool add_printer_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, NT_PRINTER_INFO_LEVEL *printer)
5978 {
5979         char *cmd = lp_addprinter_cmd();
5980         char **qlines;
5981         char *command = NULL;
5982         int numlines;
5983         int ret;
5984         int fd;
5985         SE_PRIV se_printop = SE_PRINT_OPERATOR;
5986         bool is_print_op = false;
5987         char *remote_machine = talloc_strdup(ctx, "%m");
5988
5989         if (!remote_machine) {
5990                 return false;
5991         }
5992         remote_machine = talloc_sub_basic(ctx,
5993                                 current_user_info.smb_name,
5994                                 current_user_info.domain,
5995                                 remote_machine);
5996         if (!remote_machine) {
5997                 return false;
5998         }
5999
6000         command = talloc_asprintf(ctx,
6001                         "%s \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"",
6002                         cmd, printer->info_2->printername, printer->info_2->sharename,
6003                         printer->info_2->portname, printer->info_2->drivername,
6004                         printer->info_2->location, printer->info_2->comment, remote_machine);
6005         if (!command) {
6006                 return false;
6007         }
6008
6009         if ( token )
6010                 is_print_op = user_has_privileges( token, &se_printop );
6011
6012         DEBUG(10,("Running [%s]\n", command));
6013
6014         /********* BEGIN SePrintOperatorPrivilege **********/
6015
6016         if ( is_print_op )
6017                 become_root();
6018
6019         if ( (ret = smbrun(command, &fd)) == 0 ) {
6020                 /* Tell everyone we updated smb.conf. */
6021                 message_send_all(smbd_messaging_context(),
6022                                  MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
6023         }
6024
6025         if ( is_print_op )
6026                 unbecome_root();
6027
6028         /********* END SePrintOperatorPrivilege **********/
6029
6030         DEBUGADD(10,("returned [%d]\n", ret));
6031
6032         TALLOC_FREE(command);
6033         TALLOC_FREE(remote_machine);
6034
6035         if ( ret != 0 ) {
6036                 if (fd != -1)
6037                         close(fd);
6038                 return false;
6039         }
6040
6041         /* reload our services immediately */
6042         become_root();
6043         reload_services(false);
6044         unbecome_root();
6045
6046         numlines = 0;
6047         /* Get lines and convert them back to dos-codepage */
6048         qlines = fd_lines_load(fd, &numlines, 0, NULL);
6049         DEBUGADD(10,("Lines returned = [%d]\n", numlines));
6050         close(fd);
6051
6052         /* Set the portname to what the script says the portname should be. */
6053         /* but don't require anything to be return from the script exit a good error code */
6054
6055         if (numlines) {
6056                 /* Set the portname to what the script says the portname should be. */
6057                 strncpy(printer->info_2->portname, qlines[0], sizeof(printer->info_2->portname));
6058                 DEBUGADD(6,("Line[0] = [%s]\n", qlines[0]));
6059         }
6060
6061         TALLOC_FREE(qlines);
6062         return true;
6063 }
6064
6065
6066 /********************************************************************
6067  * Called by spoolss_api_setprinter
6068  * when updating a printer description.
6069  ********************************************************************/
6070
6071 static WERROR update_printer(pipes_struct *p, struct policy_handle *handle,
6072                              struct spoolss_SetPrinterInfoCtr *info_ctr,
6073                              struct spoolss_DeviceMode *devmode)
6074 {
6075         int snum;
6076         NT_PRINTER_INFO_LEVEL *printer = NULL, *old_printer = NULL;
6077         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
6078         WERROR result;
6079         UNISTR2 buffer;
6080         fstring asc_buffer;
6081
6082         DEBUG(8,("update_printer\n"));
6083
6084         result = WERR_OK;
6085
6086         if (!Printer) {
6087                 result = WERR_BADFID;
6088                 goto done;
6089         }
6090
6091         if (!get_printer_snum(p, handle, &snum, NULL)) {
6092                 result = WERR_BADFID;
6093                 goto done;
6094         }
6095
6096         if (!W_ERROR_IS_OK(get_a_printer(Printer, &printer, 2, lp_const_servicename(snum))) ||
6097             (!W_ERROR_IS_OK(get_a_printer(Printer, &old_printer, 2, lp_const_servicename(snum))))) {
6098                 result = WERR_BADFID;
6099                 goto done;
6100         }
6101
6102         DEBUGADD(8,("Converting info_2 struct\n"));
6103
6104         /*
6105          * convert_printer_info converts the incoming
6106          * info from the client and overwrites the info
6107          * just read from the tdb in the pointer 'printer'.
6108          */
6109
6110         if (!convert_printer_info(info_ctr, printer)) {
6111                 result =  WERR_NOMEM;
6112                 goto done;
6113         }
6114
6115         if (devmode) {
6116                 /* we have a valid devmode
6117                    convert it and link it*/
6118
6119                 DEBUGADD(8,("update_printer: Converting the devicemode struct\n"));
6120                 if (!convert_devicemode(printer->info_2->printername, devmode,
6121                                         &printer->info_2->devmode)) {
6122                         result =  WERR_NOMEM;
6123                         goto done;
6124                 }
6125         }
6126
6127         /* Do sanity check on the requested changes for Samba */
6128
6129         if (!check_printer_ok(printer->info_2, snum)) {
6130                 result = WERR_INVALID_PARAM;
6131                 goto done;
6132         }
6133
6134         /* FIXME!!! If the driver has changed we really should verify that
6135            it is installed before doing much else   --jerry */
6136
6137         /* Check calling user has permission to update printer description */
6138
6139         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
6140                 DEBUG(3, ("update_printer: printer property change denied by handle\n"));
6141                 result = WERR_ACCESS_DENIED;
6142                 goto done;
6143         }
6144
6145         /* Call addprinter hook */
6146         /* Check changes to see if this is really needed */
6147
6148         if ( *lp_addprinter_cmd()
6149                 && (!strequal(printer->info_2->drivername, old_printer->info_2->drivername)
6150                         || !strequal(printer->info_2->comment, old_printer->info_2->comment)
6151                         || !strequal(printer->info_2->portname, old_printer->info_2->portname)
6152                         || !strequal(printer->info_2->location, old_printer->info_2->location)) )
6153         {
6154                 /* add_printer_hook() will call reload_services() */
6155
6156                 if ( !add_printer_hook(p->mem_ctx, p->server_info->ptok,
6157                                        printer) ) {
6158                         result = WERR_ACCESS_DENIED;
6159                         goto done;
6160                 }
6161         }
6162
6163         /*
6164          * When a *new* driver is bound to a printer, the drivername is used to
6165          * lookup previously saved driver initialization info, which is then
6166          * bound to the printer, simulating what happens in the Windows arch.
6167          */
6168         if (!strequal(printer->info_2->drivername, old_printer->info_2->drivername))
6169         {
6170                 if (!set_driver_init(printer, 2))
6171                 {
6172                         DEBUG(5,("update_printer: Error restoring driver initialization data for driver [%s]!\n",
6173                                 printer->info_2->drivername));
6174                 }
6175
6176                 DEBUG(10,("update_printer: changing driver [%s]!  Sending event!\n",
6177                         printer->info_2->drivername));
6178
6179                 notify_printer_driver(snum, printer->info_2->drivername);
6180         }
6181
6182         /*
6183          * flag which changes actually occured.  This is a small subset of
6184          * all the possible changes.  We also have to update things in the
6185          * DsSpooler key.
6186          */
6187
6188         if (!strequal(printer->info_2->comment, old_printer->info_2->comment)) {
6189                 init_unistr2( &buffer, printer->info_2->comment, UNI_STR_TERMINATE);
6190                 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "description",
6191                         REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
6192
6193                 notify_printer_comment(snum, printer->info_2->comment);
6194         }
6195
6196         if (!strequal(printer->info_2->sharename, old_printer->info_2->sharename)) {
6197                 init_unistr2( &buffer, printer->info_2->sharename, UNI_STR_TERMINATE);
6198                 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "shareName",
6199                         REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
6200
6201                 notify_printer_sharename(snum, printer->info_2->sharename);
6202         }
6203
6204         if (!strequal(printer->info_2->printername, old_printer->info_2->printername)) {
6205                 char *pname;
6206
6207                 if ( (pname = strchr_m( printer->info_2->printername+2, '\\' )) != NULL )
6208                         pname++;
6209                 else
6210                         pname = printer->info_2->printername;
6211
6212
6213                 init_unistr2( &buffer, pname, UNI_STR_TERMINATE);
6214                 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "printerName",
6215                         REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
6216
6217                 notify_printer_printername( snum, pname );
6218         }
6219
6220         if (!strequal(printer->info_2->portname, old_printer->info_2->portname)) {
6221                 init_unistr2( &buffer, printer->info_2->portname, UNI_STR_TERMINATE);
6222                 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "portName",
6223                         REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
6224
6225                 notify_printer_port(snum, printer->info_2->portname);
6226         }
6227
6228         if (!strequal(printer->info_2->location, old_printer->info_2->location)) {
6229                 init_unistr2( &buffer, printer->info_2->location, UNI_STR_TERMINATE);
6230                 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "location",
6231                         REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
6232
6233                 notify_printer_location(snum, printer->info_2->location);
6234         }
6235
6236         /* here we need to update some more DsSpooler keys */
6237         /* uNCName, serverName, shortServerName */
6238
6239         init_unistr2( &buffer, global_myname(), UNI_STR_TERMINATE);
6240         set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "serverName",
6241                 REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
6242         set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "shortServerName",
6243                 REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
6244
6245         slprintf( asc_buffer, sizeof(asc_buffer)-1, "\\\\%s\\%s",
6246                  global_myname(), printer->info_2->sharename );
6247         init_unistr2( &buffer, asc_buffer, UNI_STR_TERMINATE);
6248         set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "uNCName",
6249                 REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
6250
6251         /* Update printer info */
6252         result = mod_a_printer(printer, 2);
6253
6254 done:
6255         free_a_printer(&printer, 2);
6256         free_a_printer(&old_printer, 2);
6257
6258
6259         return result;
6260 }
6261
6262 /****************************************************************************
6263 ****************************************************************************/
6264 static WERROR publish_or_unpublish_printer(pipes_struct *p,
6265                                            struct policy_handle *handle,
6266                                            struct spoolss_SetPrinterInfo7 *info7)
6267 {
6268 #ifdef HAVE_ADS
6269         int snum;
6270         Printer_entry *Printer;
6271
6272         if ( lp_security() != SEC_ADS ) {
6273                 return WERR_UNKNOWN_LEVEL;
6274         }
6275
6276         Printer = find_printer_index_by_hnd(p, handle);
6277
6278         DEBUG(5,("publish_or_unpublish_printer, action = %d\n",info7->action));
6279
6280         if (!Printer)
6281                 return WERR_BADFID;
6282
6283         if (!get_printer_snum(p, handle, &snum, NULL))
6284                 return WERR_BADFID;
6285
6286         nt_printer_publish(Printer, snum, info7->action);
6287
6288         return WERR_OK;
6289 #else
6290         return WERR_UNKNOWN_LEVEL;
6291 #endif
6292 }
6293
6294 /****************************************************************
6295  _spoolss_SetPrinter
6296 ****************************************************************/
6297
6298 WERROR _spoolss_SetPrinter(pipes_struct *p,
6299                            struct spoolss_SetPrinter *r)
6300 {
6301         WERROR result;
6302
6303         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
6304
6305         if (!Printer) {
6306                 DEBUG(2,("_spoolss_SetPrinter: Invalid handle (%s:%u:%u)\n",
6307                         OUR_HANDLE(r->in.handle)));
6308                 return WERR_BADFID;
6309         }
6310
6311         /* check the level */
6312         switch (r->in.info_ctr->level) {
6313                 case 0:
6314                         return control_printer(r->in.handle, r->in.command, p);
6315                 case 2:
6316                         result = update_printer(p, r->in.handle,
6317                                                 r->in.info_ctr,
6318                                                 r->in.devmode_ctr->devmode);
6319                         if (!W_ERROR_IS_OK(result))
6320                                 return result;
6321                         if (r->in.secdesc_ctr->sd)
6322                                 result = update_printer_sec(r->in.handle, p,
6323                                                             r->in.secdesc_ctr);
6324                         return result;
6325                 case 3:
6326                         return update_printer_sec(r->in.handle, p,
6327                                                   r->in.secdesc_ctr);
6328                 case 7:
6329                         return publish_or_unpublish_printer(p, r->in.handle,
6330                                                             r->in.info_ctr->info.info7);
6331                 default:
6332                         return WERR_UNKNOWN_LEVEL;
6333         }
6334 }
6335
6336 /****************************************************************
6337  _spoolss_FindClosePrinterNotify
6338 ****************************************************************/
6339
6340 WERROR _spoolss_FindClosePrinterNotify(pipes_struct *p,
6341                                        struct spoolss_FindClosePrinterNotify *r)
6342 {
6343         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
6344
6345         if (!Printer) {
6346                 DEBUG(2,("_spoolss_FindClosePrinterNotify: "
6347                         "Invalid handle (%s:%u:%u)\n", OUR_HANDLE(r->in.handle)));
6348                 return WERR_BADFID;
6349         }
6350
6351         if (Printer->notify.client_connected == true) {
6352                 int snum = -1;
6353
6354                 if ( Printer->printer_type == SPLHND_SERVER)
6355                         snum = -1;
6356                 else if ( (Printer->printer_type == SPLHND_PRINTER) &&
6357                                 !get_printer_snum(p, r->in.handle, &snum, NULL) )
6358                         return WERR_BADFID;
6359
6360                 srv_spoolss_replycloseprinter(snum, &Printer->notify.client_hnd);
6361         }
6362
6363         Printer->notify.flags=0;
6364         Printer->notify.options=0;
6365         Printer->notify.localmachine[0]='\0';
6366         Printer->notify.printerlocal=0;
6367         TALLOC_FREE(Printer->notify.option);
6368         Printer->notify.client_connected = false;
6369
6370         return WERR_OK;
6371 }
6372
6373 /****************************************************************
6374  _spoolss_AddJob
6375 ****************************************************************/
6376
6377 WERROR _spoolss_AddJob(pipes_struct *p,
6378                        struct spoolss_AddJob *r)
6379 {
6380         if (!r->in.buffer && (r->in.offered != 0)) {
6381                 return WERR_INVALID_PARAM;
6382         }
6383
6384         /* this is what a NT server returns for AddJob. AddJob must fail on
6385          * non-local printers */
6386
6387         if (r->in.level != 1) {
6388                 return WERR_UNKNOWN_LEVEL;
6389         }
6390
6391         return WERR_INVALID_PARAM;
6392 }
6393
6394 /****************************************************************************
6395 fill_job_info1
6396 ****************************************************************************/
6397
6398 static WERROR fill_job_info1(TALLOC_CTX *mem_ctx,
6399                              struct spoolss_JobInfo1 *r,
6400                              const print_queue_struct *queue,
6401                              int position, int snum,
6402                              const NT_PRINTER_INFO_LEVEL *ntprinter)
6403 {
6404         struct tm *t;
6405
6406         t = gmtime(&queue->time);
6407
6408         r->job_id               = queue->job;
6409
6410         r->printer_name         = talloc_strdup(mem_ctx, lp_servicename(snum));
6411         W_ERROR_HAVE_NO_MEMORY(r->printer_name);
6412         r->server_name          = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
6413         W_ERROR_HAVE_NO_MEMORY(r->server_name);
6414         r->user_name            = talloc_strdup(mem_ctx, queue->fs_user);
6415         W_ERROR_HAVE_NO_MEMORY(r->user_name);
6416         r->document_name        = talloc_strdup(mem_ctx, queue->fs_file);
6417         W_ERROR_HAVE_NO_MEMORY(r->document_name);
6418         r->data_type            = talloc_strdup(mem_ctx, "RAW");
6419         W_ERROR_HAVE_NO_MEMORY(r->data_type);
6420         r->text_status          = talloc_strdup(mem_ctx, "");
6421         W_ERROR_HAVE_NO_MEMORY(r->text_status);
6422
6423         r->status               = nt_printj_status(queue->status);
6424         r->priority             = queue->priority;
6425         r->position             = position;
6426         r->total_pages          = queue->page_count;
6427         r->pages_printed        = 0; /* ??? */
6428
6429         init_systemtime(&r->submitted, t);
6430
6431         return WERR_OK;
6432 }
6433
6434 /****************************************************************************
6435 fill_job_info2
6436 ****************************************************************************/
6437
6438 static WERROR fill_job_info2(TALLOC_CTX *mem_ctx,
6439                              struct spoolss_JobInfo2 *r,
6440                              const print_queue_struct *queue,
6441                              int position, int snum,
6442                              const NT_PRINTER_INFO_LEVEL *ntprinter,
6443                              struct spoolss_DeviceMode *devmode)
6444 {
6445         struct tm *t;
6446
6447         t = gmtime(&queue->time);
6448
6449         r->job_id               = queue->job;
6450
6451         r->printer_name         = talloc_strdup(mem_ctx, lp_servicename(snum));
6452         W_ERROR_HAVE_NO_MEMORY(r->printer_name);
6453         r->server_name          = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
6454         W_ERROR_HAVE_NO_MEMORY(r->server_name);
6455         r->user_name            = talloc_strdup(mem_ctx, queue->fs_user);
6456         W_ERROR_HAVE_NO_MEMORY(r->user_name);
6457         r->document_name        = talloc_strdup(mem_ctx, queue->fs_file);
6458         W_ERROR_HAVE_NO_MEMORY(r->document_name);
6459         r->notify_name          = talloc_strdup(mem_ctx, queue->fs_user);
6460         W_ERROR_HAVE_NO_MEMORY(r->notify_name);
6461         r->data_type            = talloc_strdup(mem_ctx, "RAW");
6462         W_ERROR_HAVE_NO_MEMORY(r->data_type);
6463         r->print_processor      = talloc_strdup(mem_ctx, "winprint");
6464         W_ERROR_HAVE_NO_MEMORY(r->print_processor);
6465         r->parameters           = talloc_strdup(mem_ctx, "");
6466         W_ERROR_HAVE_NO_MEMORY(r->parameters);
6467         r->driver_name          = talloc_strdup(mem_ctx, ntprinter->info_2->drivername);
6468         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
6469
6470         r->devmode              = devmode;
6471
6472         r->text_status          = talloc_strdup(mem_ctx, "");
6473         W_ERROR_HAVE_NO_MEMORY(r->text_status);
6474
6475         r->secdesc              = NULL;
6476
6477         r->status               = nt_printj_status(queue->status);
6478         r->priority             = queue->priority;
6479         r->position             = position;
6480         r->start_time           = 0;
6481         r->until_time           = 0;
6482         r->total_pages          = queue->page_count;
6483         r->size                 = queue->size;
6484         init_systemtime(&r->submitted, t);
6485         r->time                 = 0;
6486         r->pages_printed        = 0; /* ??? */
6487
6488         return WERR_OK;
6489 }
6490
6491 /****************************************************************************
6492 fill_job_info3
6493 ****************************************************************************/
6494
6495 static WERROR fill_job_info3(TALLOC_CTX *mem_ctx,
6496                              struct spoolss_JobInfo3 *r,
6497                              const print_queue_struct *queue,
6498                              const print_queue_struct *next_queue,
6499                              int position, int snum,
6500                              const NT_PRINTER_INFO_LEVEL *ntprinter)
6501 {
6502         r->job_id               = queue->job;
6503         r->next_job_id          = 0;
6504         if (next_queue) {
6505                 r->next_job_id  = next_queue->job;
6506         }
6507         r->reserved             = 0;
6508
6509         return WERR_OK;
6510 }
6511
6512 /****************************************************************************
6513  Enumjobs at level 1.
6514 ****************************************************************************/
6515
6516 static WERROR enumjobs_level1(TALLOC_CTX *mem_ctx,
6517                               const print_queue_struct *queue,
6518                               uint32_t num_queues, int snum,
6519                               const NT_PRINTER_INFO_LEVEL *ntprinter,
6520                               union spoolss_JobInfo **info_p,
6521                               uint32_t *count)
6522 {
6523         union spoolss_JobInfo *info;
6524         int i;
6525         WERROR result = WERR_OK;
6526
6527         info = TALLOC_ARRAY(mem_ctx, union spoolss_JobInfo, num_queues);
6528         W_ERROR_HAVE_NO_MEMORY(info);
6529
6530         *count = num_queues;
6531
6532         for (i=0; i<*count; i++) {
6533                 result = fill_job_info1(info,
6534                                         &info[i].info1,
6535                                         &queue[i],
6536                                         i,
6537                                         snum,
6538                                         ntprinter);
6539                 if (!W_ERROR_IS_OK(result)) {
6540                         goto out;
6541                 }
6542         }
6543
6544  out:
6545         if (!W_ERROR_IS_OK(result)) {
6546                 TALLOC_FREE(info);
6547                 *count = 0;
6548                 return result;
6549         }
6550
6551         *info_p = info;
6552
6553         return WERR_OK;
6554 }
6555
6556 /****************************************************************************
6557  Enumjobs at level 2.
6558 ****************************************************************************/
6559
6560 static WERROR enumjobs_level2(TALLOC_CTX *mem_ctx,
6561                               const print_queue_struct *queue,
6562                               uint32_t num_queues, int snum,
6563                               const NT_PRINTER_INFO_LEVEL *ntprinter,
6564                               union spoolss_JobInfo **info_p,
6565                               uint32_t *count)
6566 {
6567         union spoolss_JobInfo *info;
6568         int i;
6569         WERROR result = WERR_OK;
6570
6571         info = TALLOC_ARRAY(mem_ctx, union spoolss_JobInfo, num_queues);
6572         W_ERROR_HAVE_NO_MEMORY(info);
6573
6574         *count = num_queues;
6575
6576         for (i=0; i<*count; i++) {
6577
6578                 struct spoolss_DeviceMode *devmode;
6579
6580                 devmode = construct_dev_mode(info, lp_const_servicename(snum));
6581                 if (!devmode) {
6582                         result = WERR_NOMEM;
6583                         goto out;
6584                 }
6585
6586                 result = fill_job_info2(info,
6587                                         &info[i].info2,
6588                                         &queue[i],
6589                                         i,
6590                                         snum,
6591                                         ntprinter,
6592                                         devmode);
6593                 if (!W_ERROR_IS_OK(result)) {
6594                         goto out;
6595                 }
6596         }
6597
6598  out:
6599         if (!W_ERROR_IS_OK(result)) {
6600                 TALLOC_FREE(info);
6601                 *count = 0;
6602                 return result;
6603         }
6604
6605         *info_p = info;
6606
6607         return WERR_OK;
6608 }
6609
6610 /****************************************************************************
6611  Enumjobs at level 3.
6612 ****************************************************************************/
6613
6614 static WERROR enumjobs_level3(TALLOC_CTX *mem_ctx,
6615                               const print_queue_struct *queue,
6616                               uint32_t num_queues, int snum,
6617                               const NT_PRINTER_INFO_LEVEL *ntprinter,
6618                               union spoolss_JobInfo **info_p,
6619                               uint32_t *count)
6620 {
6621         union spoolss_JobInfo *info;
6622         int i;
6623         WERROR result = WERR_OK;
6624
6625         info = TALLOC_ARRAY(mem_ctx, union spoolss_JobInfo, num_queues);
6626         W_ERROR_HAVE_NO_MEMORY(info);
6627
6628         *count = num_queues;
6629
6630         for (i=0; i<*count; i++) {
6631                 const print_queue_struct *next_queue = NULL;
6632
6633                 if (i+1 < *count) {
6634                         next_queue = &queue[i+1];
6635                 }
6636
6637                 result = fill_job_info3(info,
6638                                         &info[i].info3,
6639                                         &queue[i],
6640                                         next_queue,
6641                                         i,
6642                                         snum,
6643                                         ntprinter);
6644                 if (!W_ERROR_IS_OK(result)) {
6645                         goto out;
6646                 }
6647         }
6648
6649  out:
6650         if (!W_ERROR_IS_OK(result)) {
6651                 TALLOC_FREE(info);
6652                 *count = 0;
6653                 return result;
6654         }
6655
6656         *info_p = info;
6657
6658         return WERR_OK;
6659 }
6660
6661 /****************************************************************
6662  _spoolss_EnumJobs
6663 ****************************************************************/
6664
6665 WERROR _spoolss_EnumJobs(pipes_struct *p,
6666                          struct spoolss_EnumJobs *r)
6667 {
6668         WERROR result;
6669         NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
6670         int snum;
6671         print_status_struct prt_status;
6672         print_queue_struct *queue = NULL;
6673         uint32_t count;
6674
6675         /* that's an [in out] buffer */
6676
6677         if (!r->in.buffer && (r->in.offered != 0)) {
6678                 return WERR_INVALID_PARAM;
6679         }
6680
6681         DEBUG(4,("_spoolss_EnumJobs\n"));
6682
6683         *r->out.needed = 0;
6684         *r->out.count = 0;
6685         *r->out.info = NULL;
6686
6687         /* lookup the printer snum and tdb entry */
6688
6689         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
6690                 return WERR_BADFID;
6691         }
6692
6693         result = get_a_printer(NULL, &ntprinter, 2, lp_servicename(snum));
6694         if (!W_ERROR_IS_OK(result)) {
6695                 return result;
6696         }
6697
6698         count = print_queue_status(snum, &queue, &prt_status);
6699         DEBUGADD(4,("count:[%d], status:[%d], [%s]\n",
6700                 count, prt_status.status, prt_status.message));
6701
6702         if (count == 0) {
6703                 SAFE_FREE(queue);
6704                 free_a_printer(&ntprinter, 2);
6705                 return WERR_OK;
6706         }
6707
6708         switch (r->in.level) {
6709         case 1:
6710                 result = enumjobs_level1(p->mem_ctx, queue, count, snum,
6711                                          ntprinter, r->out.info, r->out.count);
6712                 break;
6713         case 2:
6714                 result = enumjobs_level2(p->mem_ctx, queue, count, snum,
6715                                          ntprinter, r->out.info, r->out.count);
6716                 break;
6717         case 3:
6718                 result = enumjobs_level3(p->mem_ctx, queue, count, snum,
6719                                          ntprinter, r->out.info, r->out.count);
6720                 break;
6721         default:
6722                 result = WERR_UNKNOWN_LEVEL;
6723                 break;
6724         }
6725
6726         SAFE_FREE(queue);
6727         free_a_printer(&ntprinter, 2);
6728
6729         if (!W_ERROR_IS_OK(result)) {
6730                 return result;
6731         }
6732
6733         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
6734                                                      spoolss_EnumJobs, NULL,
6735                                                      *r->out.info, r->in.level,
6736                                                      *r->out.count);
6737         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
6738         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
6739
6740         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
6741 }
6742
6743 /****************************************************************
6744  _spoolss_ScheduleJob
6745 ****************************************************************/
6746
6747 WERROR _spoolss_ScheduleJob(pipes_struct *p,
6748                             struct spoolss_ScheduleJob *r)
6749 {
6750         return WERR_OK;
6751 }
6752
6753 /****************************************************************
6754  _spoolss_SetJob
6755 ****************************************************************/
6756
6757 WERROR _spoolss_SetJob(pipes_struct *p,
6758                        struct spoolss_SetJob *r)
6759 {
6760         int snum;
6761         WERROR errcode = WERR_BADFUNC;
6762
6763         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
6764                 return WERR_BADFID;
6765         }
6766
6767         if (!print_job_exists(lp_const_servicename(snum), r->in.job_id)) {
6768                 return WERR_INVALID_PRINTER_NAME;
6769         }
6770
6771         switch (r->in.command) {
6772         case SPOOLSS_JOB_CONTROL_CANCEL:
6773         case SPOOLSS_JOB_CONTROL_DELETE:
6774                 if (print_job_delete(p->server_info, snum, r->in.job_id, &errcode)) {
6775                         errcode = WERR_OK;
6776                 }
6777                 break;
6778         case SPOOLSS_JOB_CONTROL_PAUSE:
6779                 if (print_job_pause(p->server_info, snum, r->in.job_id, &errcode)) {
6780                         errcode = WERR_OK;
6781                 }
6782                 break;
6783         case SPOOLSS_JOB_CONTROL_RESTART:
6784         case SPOOLSS_JOB_CONTROL_RESUME:
6785                 if (print_job_resume(p->server_info, snum, r->in.job_id, &errcode)) {
6786                         errcode = WERR_OK;
6787                 }
6788                 break;
6789         default:
6790                 return WERR_UNKNOWN_LEVEL;
6791         }
6792
6793         return errcode;
6794 }
6795
6796 /****************************************************************************
6797  Enumerates all printer drivers by level.
6798 ****************************************************************************/
6799
6800 static WERROR enumprinterdrivers_level(TALLOC_CTX *mem_ctx,
6801                                        const char *servername,
6802                                        const char *architecture,
6803                                        uint32_t level,
6804                                        union spoolss_DriverInfo **info_p,
6805                                        uint32_t *count_p)
6806 {
6807         int i;
6808         int ndrivers;
6809         uint32_t version;
6810         fstring *list = NULL;
6811         NT_PRINTER_DRIVER_INFO_LEVEL driver;
6812         union spoolss_DriverInfo *info = NULL;
6813         uint32_t count = 0;
6814         WERROR result = WERR_OK;
6815
6816         *count_p = 0;
6817         *info_p = NULL;
6818
6819         for (version=0; version<DRIVER_MAX_VERSION; version++) {
6820                 list = NULL;
6821                 ndrivers = get_ntdrivers(&list, architecture, version);
6822                 DEBUGADD(4,("we have:[%d] drivers in environment [%s] and version [%d]\n",
6823                         ndrivers, architecture, version));
6824
6825                 if (ndrivers == -1) {
6826                         result = WERR_NOMEM;
6827                         goto out;
6828                 }
6829
6830                 if (ndrivers != 0) {
6831                         info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
6832                                                     union spoolss_DriverInfo,
6833                                                     count + ndrivers);
6834                         if (!info) {
6835                                 DEBUG(0,("enumprinterdrivers_level1: "
6836                                         "failed to enlarge driver info buffer!\n"));
6837                                 result = WERR_NOMEM;
6838                                 goto out;
6839                         }
6840                 }
6841
6842                 for (i=0; i<ndrivers; i++) {
6843                         DEBUGADD(5,("\tdriver: [%s]\n", list[i]));
6844                         ZERO_STRUCT(driver);
6845                         result = get_a_printer_driver(&driver, 3, list[i],
6846                                                       architecture, version);
6847                         if (!W_ERROR_IS_OK(result)) {
6848                                 goto out;
6849                         }
6850
6851                         switch (level) {
6852                         case 1:
6853                                 result = fill_printer_driver_info1(info, &info[count+i].info1,
6854                                                                    &driver, servername,
6855                                                                    architecture);
6856                                 break;
6857                         case 2:
6858                                 result = fill_printer_driver_info2(info, &info[count+i].info2,
6859                                                                    &driver, servername);
6860                                 break;
6861                         case 3:
6862                                 result = fill_printer_driver_info3(info, &info[count+i].info3,
6863                                                                    &driver, servername);
6864                                 break;
6865                         case 4:
6866                                 result = fill_printer_driver_info4(info, &info[count+i].info4,
6867                                                                    &driver, servername);
6868                                 break;
6869                         case 5:
6870                                 result = fill_printer_driver_info5(info, &info[count+i].info5,
6871                                                                    &driver, servername);
6872                                 break;
6873                         case 6:
6874                                 result = fill_printer_driver_info6(info, &info[count+i].info6,
6875                                                                    &driver, servername);
6876                                 break;
6877                         default:
6878                                 result = WERR_UNKNOWN_LEVEL;
6879                                 break;
6880                         }
6881
6882                         if (!W_ERROR_IS_OK(result)) {
6883                                 free_a_printer_driver(driver, 3);
6884                                 goto out;
6885                         }
6886                         free_a_printer_driver(driver, 3);
6887                 }
6888
6889                 count += ndrivers;
6890                 SAFE_FREE(list);
6891         }
6892
6893  out:
6894         SAFE_FREE(list);
6895
6896         if (!W_ERROR_IS_OK(result)) {
6897                 TALLOC_FREE(info);
6898                 return result;
6899         }
6900
6901         *info_p = info;
6902         *count_p = count;
6903
6904         return WERR_OK;
6905 }
6906
6907 /****************************************************************************
6908  Enumerates all printer drivers at level 1.
6909 ****************************************************************************/
6910
6911 static WERROR enumprinterdrivers_level1(TALLOC_CTX *mem_ctx,
6912                                         const char *servername,
6913                                         const char *architecture,
6914                                         union spoolss_DriverInfo **info_p,
6915                                         uint32_t *count)
6916 {
6917         return enumprinterdrivers_level(mem_ctx, servername, architecture, 1,
6918                                         info_p, count);
6919 }
6920
6921 /****************************************************************************
6922  Enumerates all printer drivers at level 2.
6923 ****************************************************************************/
6924
6925 static WERROR enumprinterdrivers_level2(TALLOC_CTX *mem_ctx,
6926                                         const char *servername,
6927                                         const char *architecture,
6928                                         union spoolss_DriverInfo **info_p,
6929                                         uint32_t *count)
6930 {
6931         return enumprinterdrivers_level(mem_ctx, servername, architecture, 2,
6932                                         info_p, count);
6933 }
6934
6935 /****************************************************************************
6936  Enumerates all printer drivers at level 3.
6937 ****************************************************************************/
6938
6939 static WERROR enumprinterdrivers_level3(TALLOC_CTX *mem_ctx,
6940                                         const char *servername,
6941                                         const char *architecture,
6942                                         union spoolss_DriverInfo **info_p,
6943                                         uint32_t *count)
6944 {
6945         return enumprinterdrivers_level(mem_ctx, servername, architecture, 3,
6946                                         info_p, count);
6947 }
6948
6949 /****************************************************************************
6950  Enumerates all printer drivers at level 4.
6951 ****************************************************************************/
6952
6953 static WERROR enumprinterdrivers_level4(TALLOC_CTX *mem_ctx,
6954                                         const char *servername,
6955                                         const char *architecture,
6956                                         union spoolss_DriverInfo **info_p,
6957                                         uint32_t *count)
6958 {
6959         return enumprinterdrivers_level(mem_ctx, servername, architecture, 4,
6960                                         info_p, count);
6961 }
6962
6963 /****************************************************************************
6964  Enumerates all printer drivers at level 5.
6965 ****************************************************************************/
6966
6967 static WERROR enumprinterdrivers_level5(TALLOC_CTX *mem_ctx,
6968                                         const char *servername,
6969                                         const char *architecture,
6970                                         union spoolss_DriverInfo **info_p,
6971                                         uint32_t *count)
6972 {
6973         return enumprinterdrivers_level(mem_ctx, servername, architecture, 5,
6974                                         info_p, count);
6975 }
6976
6977 /****************************************************************************
6978  Enumerates all printer drivers at level 6.
6979 ****************************************************************************/
6980
6981 static WERROR enumprinterdrivers_level6(TALLOC_CTX *mem_ctx,
6982                                         const char *servername,
6983                                         const char *architecture,
6984                                         union spoolss_DriverInfo **info_p,
6985                                         uint32_t *count)
6986 {
6987         return enumprinterdrivers_level(mem_ctx, servername, architecture, 6,
6988                                         info_p, count);
6989 }
6990
6991
6992 /****************************************************************
6993  _spoolss_EnumPrinterDrivers
6994 ****************************************************************/
6995
6996 WERROR _spoolss_EnumPrinterDrivers(pipes_struct *p,
6997                                    struct spoolss_EnumPrinterDrivers *r)
6998 {
6999         const char *cservername;
7000         WERROR result;
7001
7002         /* that's an [in out] buffer */
7003
7004         if (!r->in.buffer && (r->in.offered != 0)) {
7005                 return WERR_INVALID_PARAM;
7006         }
7007
7008         DEBUG(4,("_spoolss_EnumPrinterDrivers\n"));
7009
7010         *r->out.needed = 0;
7011         *r->out.count = 0;
7012         *r->out.info = NULL;
7013
7014         cservername = canon_servername(r->in.server);
7015
7016         if (!is_myname_or_ipaddr(cservername)) {
7017                 return WERR_UNKNOWN_PRINTER_DRIVER;
7018         }
7019
7020         switch (r->in.level) {
7021         case 1:
7022                 result = enumprinterdrivers_level1(p->mem_ctx, cservername,
7023                                                    r->in.environment,
7024                                                    r->out.info, r->out.count);
7025                 break;
7026         case 2:
7027                 result = enumprinterdrivers_level2(p->mem_ctx, cservername,
7028                                                    r->in.environment,
7029                                                    r->out.info, r->out.count);
7030                 break;
7031         case 3:
7032                 result = enumprinterdrivers_level3(p->mem_ctx, cservername,
7033                                                    r->in.environment,
7034                                                    r->out.info, r->out.count);
7035                 break;
7036         case 4:
7037                 result = enumprinterdrivers_level4(p->mem_ctx, cservername,
7038                                                    r->in.environment,
7039                                                    r->out.info, r->out.count);
7040                 break;
7041         case 5:
7042                 result = enumprinterdrivers_level5(p->mem_ctx, cservername,
7043                                                    r->in.environment,
7044                                                    r->out.info, r->out.count);
7045                 break;
7046         case 6:
7047                 result = enumprinterdrivers_level6(p->mem_ctx, cservername,
7048                                                    r->in.environment,
7049                                                    r->out.info, r->out.count);
7050                 break;
7051         default:
7052                 return WERR_UNKNOWN_LEVEL;
7053         }
7054
7055         if (!W_ERROR_IS_OK(result)) {
7056                 return result;
7057         }
7058
7059         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
7060                                                      spoolss_EnumPrinterDrivers, NULL,
7061                                                      *r->out.info, r->in.level,
7062                                                      *r->out.count);
7063         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
7064         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
7065
7066         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7067 }
7068
7069 /****************************************************************************
7070 ****************************************************************************/
7071
7072 static WERROR fill_form_info_1(TALLOC_CTX *mem_ctx,
7073                                struct spoolss_FormInfo1 *r,
7074                                const nt_forms_struct *form)
7075 {
7076         r->form_name    = talloc_strdup(mem_ctx, form->name);
7077         W_ERROR_HAVE_NO_MEMORY(r->form_name);
7078
7079         r->flags        = form->flag;
7080         r->size.width   = form->width;
7081         r->size.height  = form->length;
7082         r->area.left    = form->left;
7083         r->area.top     = form->top;
7084         r->area.right   = form->right;
7085         r->area.bottom  = form->bottom;
7086
7087         return WERR_OK;
7088 }
7089
7090 /****************************************************************
7091  spoolss_enumforms_level1
7092 ****************************************************************/
7093
7094 static WERROR spoolss_enumforms_level1(TALLOC_CTX *mem_ctx,
7095                                        const nt_forms_struct *builtin_forms,
7096                                        uint32_t num_builtin_forms,
7097                                        const nt_forms_struct *user_forms,
7098                                        uint32_t num_user_forms,
7099                                        union spoolss_FormInfo **info_p,
7100                                        uint32_t *count)
7101 {
7102         union spoolss_FormInfo *info;
7103         WERROR result = WERR_OK;
7104         int i;
7105
7106         *count = num_builtin_forms + num_user_forms;
7107
7108         info = TALLOC_ARRAY(mem_ctx, union spoolss_FormInfo, *count);
7109         W_ERROR_HAVE_NO_MEMORY(info);
7110
7111         /* construct the list of form structures */
7112         for (i=0; i<num_builtin_forms; i++) {
7113                 DEBUGADD(6,("Filling builtin form number [%d]\n",i));
7114                 result = fill_form_info_1(info, &info[i].info1,
7115                                           &builtin_forms[i]);
7116                 if (!W_ERROR_IS_OK(result)) {
7117                         goto out;
7118                 }
7119         }
7120
7121         for (i=0; i<num_user_forms; i++) {
7122                 DEBUGADD(6,("Filling user form number [%d]\n",i));
7123                 result = fill_form_info_1(info, &info[i+num_builtin_forms].info1,
7124                                           &user_forms[i]);
7125                 if (!W_ERROR_IS_OK(result)) {
7126                         goto out;
7127                 }
7128         }
7129
7130  out:
7131         if (!W_ERROR_IS_OK(result)) {
7132                 TALLOC_FREE(info);
7133                 *count = 0;
7134                 return result;
7135         }
7136
7137         *info_p = info;
7138
7139         return WERR_OK;
7140 }
7141
7142 /****************************************************************
7143  _spoolss_EnumForms
7144 ****************************************************************/
7145
7146 WERROR _spoolss_EnumForms(pipes_struct *p,
7147                           struct spoolss_EnumForms *r)
7148 {
7149         WERROR result;
7150         nt_forms_struct *user_forms = NULL;
7151         nt_forms_struct *builtin_forms = NULL;
7152         uint32_t num_user_forms;
7153         uint32_t num_builtin_forms;
7154
7155         *r->out.count = 0;
7156         *r->out.needed = 0;
7157         *r->out.info = NULL;
7158
7159         /* that's an [in out] buffer */
7160
7161         if (!r->in.buffer && (r->in.offered != 0) ) {
7162                 return WERR_INVALID_PARAM;
7163         }
7164
7165         DEBUG(4,("_spoolss_EnumForms\n"));
7166         DEBUGADD(5,("Offered buffer size [%d]\n", r->in.offered));
7167         DEBUGADD(5,("Info level [%d]\n",          r->in.level));
7168
7169         num_builtin_forms = get_builtin_ntforms(&builtin_forms);
7170         DEBUGADD(5,("Number of builtin forms [%d]\n", num_builtin_forms));
7171         num_user_forms = get_ntforms(&user_forms);
7172         DEBUGADD(5,("Number of user forms [%d]\n", num_user_forms));
7173
7174         if (num_user_forms + num_builtin_forms == 0) {
7175                 SAFE_FREE(builtin_forms);
7176                 SAFE_FREE(user_forms);
7177                 return WERR_NO_MORE_ITEMS;
7178         }
7179
7180         switch (r->in.level) {
7181         case 1:
7182                 result = spoolss_enumforms_level1(p->mem_ctx,
7183                                                   builtin_forms,
7184                                                   num_builtin_forms,
7185                                                   user_forms,
7186                                                   num_user_forms,
7187                                                   r->out.info,
7188                                                   r->out.count);
7189                 break;
7190         default:
7191                 result = WERR_UNKNOWN_LEVEL;
7192                 break;
7193         }
7194
7195         SAFE_FREE(user_forms);
7196         SAFE_FREE(builtin_forms);
7197
7198         if (!W_ERROR_IS_OK(result)) {
7199                 return result;
7200         }
7201
7202         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
7203                                                      spoolss_EnumForms, NULL,
7204                                                      *r->out.info, r->in.level,
7205                                                      *r->out.count);
7206         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
7207         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
7208
7209         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7210 }
7211
7212 /****************************************************************
7213 ****************************************************************/
7214
7215 static WERROR find_form_byname(const char *name,
7216                                nt_forms_struct *form)
7217 {
7218         nt_forms_struct *list = NULL;
7219         int num_forms = 0, i = 0;
7220
7221         if (get_a_builtin_ntform_by_string(name, form)) {
7222                 return WERR_OK;
7223         }
7224
7225         num_forms = get_ntforms(&list);
7226         DEBUGADD(5,("Number of forms [%d]\n", num_forms));
7227
7228         if (num_forms == 0) {
7229                 return WERR_BADFID;
7230         }
7231
7232         /* Check if the requested name is in the list of form structures */
7233         for (i = 0; i < num_forms; i++) {
7234
7235                 DEBUG(4,("checking form %s (want %s)\n", list[i].name, name));
7236
7237                 if (strequal(name, list[i].name)) {
7238                         DEBUGADD(6,("Found form %s number [%d]\n", name, i));
7239                         *form = list[i];
7240                         SAFE_FREE(list);
7241                         return WERR_OK;
7242                 }
7243         }
7244
7245         SAFE_FREE(list);
7246
7247         return WERR_BADFID;
7248 }
7249
7250 /****************************************************************
7251  _spoolss_GetForm
7252 ****************************************************************/
7253
7254 WERROR _spoolss_GetForm(pipes_struct *p,
7255                         struct spoolss_GetForm *r)
7256 {
7257         WERROR result;
7258         nt_forms_struct form;
7259
7260         /* that's an [in out] buffer */
7261
7262         if (!r->in.buffer && (r->in.offered != 0)) {
7263                 return WERR_INVALID_PARAM;
7264         }
7265
7266         DEBUG(4,("_spoolss_GetForm\n"));
7267         DEBUGADD(5,("Offered buffer size [%d]\n", r->in.offered));
7268         DEBUGADD(5,("Info level [%d]\n",          r->in.level));
7269
7270         result = find_form_byname(r->in.form_name, &form);
7271         if (!W_ERROR_IS_OK(result)) {
7272                 TALLOC_FREE(r->out.info);
7273                 return result;
7274         }
7275
7276         switch (r->in.level) {
7277         case 1:
7278                 result = fill_form_info_1(p->mem_ctx,
7279                                           &r->out.info->info1,
7280                                           &form);
7281                 break;
7282
7283         default:
7284                 result = WERR_UNKNOWN_LEVEL;
7285                 break;
7286         }
7287
7288         if (!W_ERROR_IS_OK(result)) {
7289                 TALLOC_FREE(r->out.info);
7290                 return result;
7291         }
7292
7293         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_FormInfo, NULL,
7294                                                r->out.info, r->in.level);
7295         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
7296
7297         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7298 }
7299
7300 /****************************************************************************
7301 ****************************************************************************/
7302
7303 static WERROR fill_port_1(TALLOC_CTX *mem_ctx,
7304                           struct spoolss_PortInfo1 *r,
7305                           const char *name)
7306 {
7307         r->port_name = talloc_strdup(mem_ctx, name);
7308         W_ERROR_HAVE_NO_MEMORY(r->port_name);
7309
7310         return WERR_OK;
7311 }
7312
7313 /****************************************************************************
7314  TODO: This probably needs distinguish between TCP/IP and Local ports
7315  somehow.
7316 ****************************************************************************/
7317
7318 static WERROR fill_port_2(TALLOC_CTX *mem_ctx,
7319                           struct spoolss_PortInfo2 *r,
7320                           const char *name)
7321 {
7322         r->port_name = talloc_strdup(mem_ctx, name);
7323         W_ERROR_HAVE_NO_MEMORY(r->port_name);
7324
7325         r->monitor_name = talloc_strdup(mem_ctx, "Local Monitor");
7326         W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
7327
7328         r->description = talloc_strdup(mem_ctx, SPL_LOCAL_PORT);
7329         W_ERROR_HAVE_NO_MEMORY(r->description);
7330
7331         r->port_type = SPOOLSS_PORT_TYPE_WRITE;
7332         r->reserved = 0;
7333
7334         return WERR_OK;
7335 }
7336
7337
7338 /****************************************************************************
7339  wrapper around the enumer ports command
7340 ****************************************************************************/
7341
7342 WERROR enumports_hook(TALLOC_CTX *ctx, int *count, char ***lines )
7343 {
7344         char *cmd = lp_enumports_cmd();
7345         char **qlines = NULL;
7346         char *command = NULL;
7347         int numlines;
7348         int ret;
7349         int fd;
7350
7351         *count = 0;
7352         *lines = NULL;
7353
7354         /* if no hook then just fill in the default port */
7355
7356         if ( !*cmd ) {
7357                 if (!(qlines = TALLOC_ARRAY( NULL, char*, 2 ))) {
7358                         return WERR_NOMEM;
7359                 }
7360                 if (!(qlines[0] = talloc_strdup(qlines, SAMBA_PRINTER_PORT_NAME ))) {
7361                         TALLOC_FREE(qlines);
7362                         return WERR_NOMEM;
7363                 }
7364                 qlines[1] = NULL;
7365                 numlines = 1;
7366         }
7367         else {
7368                 /* we have a valid enumport command */
7369
7370                 command = talloc_asprintf(ctx, "%s \"%d\"", cmd, 1);
7371                 if (!command) {
7372                         return WERR_NOMEM;
7373                 }
7374
7375                 DEBUG(10,("Running [%s]\n", command));
7376                 ret = smbrun(command, &fd);
7377                 DEBUG(10,("Returned [%d]\n", ret));
7378                 TALLOC_FREE(command);
7379                 if (ret != 0) {
7380                         if (fd != -1) {
7381                                 close(fd);
7382                         }
7383                         return WERR_ACCESS_DENIED;
7384                 }
7385
7386                 numlines = 0;
7387                 qlines = fd_lines_load(fd, &numlines, 0, NULL);
7388                 DEBUGADD(10,("Lines returned = [%d]\n", numlines));
7389                 close(fd);
7390         }
7391
7392         *count = numlines;
7393         *lines = qlines;
7394
7395         return WERR_OK;
7396 }
7397
7398 /****************************************************************************
7399  enumports level 1.
7400 ****************************************************************************/
7401
7402 static WERROR enumports_level_1(TALLOC_CTX *mem_ctx,
7403                                 union spoolss_PortInfo **info_p,
7404                                 uint32_t *count)
7405 {
7406         union spoolss_PortInfo *info = NULL;
7407         int i=0;
7408         WERROR result = WERR_OK;
7409         char **qlines = NULL;
7410         int numlines = 0;
7411
7412         result = enumports_hook(talloc_tos(), &numlines, &qlines );
7413         if (!W_ERROR_IS_OK(result)) {
7414                 goto out;
7415         }
7416
7417         if (numlines) {
7418                 info = TALLOC_ARRAY(mem_ctx, union spoolss_PortInfo, numlines);
7419                 if (!info) {
7420                         DEBUG(10,("Returning WERR_NOMEM\n"));
7421                         result = WERR_NOMEM;
7422                         goto out;
7423                 }
7424
7425                 for (i=0; i<numlines; i++) {
7426                         DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
7427                         result = fill_port_1(info, &info[i].info1, qlines[i]);
7428                         if (!W_ERROR_IS_OK(result)) {
7429                                 goto out;
7430                         }
7431                 }
7432         }
7433         TALLOC_FREE(qlines);
7434
7435 out:
7436         if (!W_ERROR_IS_OK(result)) {
7437                 TALLOC_FREE(info);
7438                 TALLOC_FREE(qlines);
7439                 *count = 0;
7440                 *info_p = NULL;
7441                 return result;
7442         }
7443
7444         *info_p = info;
7445         *count = numlines;
7446
7447         return WERR_OK;
7448 }
7449
7450 /****************************************************************************
7451  enumports level 2.
7452 ****************************************************************************/
7453
7454 static WERROR enumports_level_2(TALLOC_CTX *mem_ctx,
7455                                 union spoolss_PortInfo **info_p,
7456                                 uint32_t *count)
7457 {
7458         union spoolss_PortInfo *info = NULL;
7459         int i=0;
7460         WERROR result = WERR_OK;
7461         char **qlines = NULL;
7462         int numlines = 0;
7463
7464         result = enumports_hook(talloc_tos(), &numlines, &qlines );
7465         if (!W_ERROR_IS_OK(result)) {
7466                 goto out;
7467         }
7468
7469         if (numlines) {
7470                 info = TALLOC_ARRAY(mem_ctx, union spoolss_PortInfo, numlines);
7471                 if (!info) {
7472                         DEBUG(10,("Returning WERR_NOMEM\n"));
7473                         result = WERR_NOMEM;
7474                         goto out;
7475                 }
7476
7477                 for (i=0; i<numlines; i++) {
7478                         DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
7479                         result = fill_port_2(info, &info[i].info2, qlines[i]);
7480                         if (!W_ERROR_IS_OK(result)) {
7481                                 goto out;
7482                         }
7483                 }
7484         }
7485         TALLOC_FREE(qlines);
7486
7487 out:
7488         if (!W_ERROR_IS_OK(result)) {
7489                 TALLOC_FREE(info);
7490                 TALLOC_FREE(qlines);
7491                 *count = 0;
7492                 *info_p = NULL;
7493                 return result;
7494         }
7495
7496         *info_p = info;
7497         *count = numlines;
7498
7499         return WERR_OK;
7500 }
7501
7502 /****************************************************************
7503  _spoolss_EnumPorts
7504 ****************************************************************/
7505
7506 WERROR _spoolss_EnumPorts(pipes_struct *p,
7507                           struct spoolss_EnumPorts *r)
7508 {
7509         WERROR result;
7510
7511         /* that's an [in out] buffer */
7512
7513         if (!r->in.buffer && (r->in.offered != 0)) {
7514                 return WERR_INVALID_PARAM;
7515         }
7516
7517         DEBUG(4,("_spoolss_EnumPorts\n"));
7518
7519         *r->out.count = 0;
7520         *r->out.needed = 0;
7521         *r->out.info = NULL;
7522
7523         switch (r->in.level) {
7524         case 1:
7525                 result = enumports_level_1(p->mem_ctx, r->out.info,
7526                                            r->out.count);
7527                 break;
7528         case 2:
7529                 result = enumports_level_2(p->mem_ctx, r->out.info,
7530                                            r->out.count);
7531                 break;
7532         default:
7533                 return WERR_UNKNOWN_LEVEL;
7534         }
7535
7536         if (!W_ERROR_IS_OK(result)) {
7537                 return result;
7538         }
7539
7540         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
7541                                                      spoolss_EnumPorts, NULL,
7542                                                      *r->out.info, r->in.level,
7543                                                      *r->out.count);
7544         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
7545         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
7546
7547         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7548 }
7549
7550 /****************************************************************************
7551 ****************************************************************************/
7552
7553 static WERROR spoolss_addprinterex_level_2(pipes_struct *p,
7554                                            const char *server,
7555                                            struct spoolss_SetPrinterInfoCtr *info_ctr,
7556                                            struct spoolss_DeviceMode *devmode,
7557                                            struct security_descriptor *sec_desc,
7558                                            struct spoolss_UserLevelCtr *user_ctr,
7559                                            struct policy_handle *handle)
7560 {
7561         NT_PRINTER_INFO_LEVEL *printer = NULL;
7562         fstring name;
7563         int     snum;
7564         WERROR err = WERR_OK;
7565
7566         if ( !(printer = TALLOC_ZERO_P(NULL, NT_PRINTER_INFO_LEVEL)) ) {
7567                 DEBUG(0,("spoolss_addprinterex_level_2: malloc fail.\n"));
7568                 return WERR_NOMEM;
7569         }
7570
7571         /* convert from UNICODE to ASCII - this allocates the info_2 struct inside *printer.*/
7572         if (!convert_printer_info(info_ctr, printer)) {
7573                 free_a_printer(&printer, 2);
7574                 return WERR_NOMEM;
7575         }
7576
7577         /* check to see if the printer already exists */
7578
7579         if ((snum = print_queue_snum(printer->info_2->sharename)) != -1) {
7580                 DEBUG(5, ("spoolss_addprinterex_level_2: Attempted to add a printer named [%s] when one already existed!\n",
7581                         printer->info_2->sharename));
7582                 free_a_printer(&printer, 2);
7583                 return WERR_PRINTER_ALREADY_EXISTS;
7584         }
7585
7586         /* FIXME!!!  smbd should check to see if the driver is installed before
7587            trying to add a printer like this  --jerry */
7588
7589         if (*lp_addprinter_cmd() ) {
7590                 if ( !add_printer_hook(p->mem_ctx, p->server_info->ptok,
7591                                        printer) ) {
7592                         free_a_printer(&printer,2);
7593                         return WERR_ACCESS_DENIED;
7594                 }
7595         } else {
7596                 DEBUG(0,("spoolss_addprinterex_level_2: add printer for printer %s called and no"
7597                         "smb.conf parameter \"addprinter command\" is defined. This"
7598                         "parameter must exist for this call to succeed\n",
7599                         printer->info_2->sharename ));
7600         }
7601
7602         /* use our primary netbios name since get_a_printer() will convert
7603            it to what the client expects on a case by case basis */
7604
7605         slprintf(name, sizeof(name)-1, "\\\\%s\\%s", global_myname(),
7606              printer->info_2->sharename);
7607
7608
7609         if ((snum = print_queue_snum(printer->info_2->sharename)) == -1) {
7610                 free_a_printer(&printer,2);
7611                 return WERR_ACCESS_DENIED;
7612         }
7613
7614         /* you must be a printer admin to add a new printer */
7615         if (!print_access_check(p->server_info, snum, PRINTER_ACCESS_ADMINISTER)) {
7616                 free_a_printer(&printer,2);
7617                 return WERR_ACCESS_DENIED;
7618         }
7619
7620         /*
7621          * Do sanity check on the requested changes for Samba.
7622          */
7623
7624         if (!check_printer_ok(printer->info_2, snum)) {
7625                 free_a_printer(&printer,2);
7626                 return WERR_INVALID_PARAM;
7627         }
7628
7629         /*
7630          * When a printer is created, the drivername bound to the printer is used
7631          * to lookup previously saved driver initialization info, which is then
7632          * bound to the new printer, simulating what happens in the Windows arch.
7633          */
7634
7635         if (!devmode)
7636         {
7637                 set_driver_init(printer, 2);
7638         }
7639         else
7640         {
7641                 /* A valid devmode was included, convert and link it
7642                 */
7643                 DEBUGADD(10, ("spoolss_addprinterex_level_2: devmode included, converting\n"));
7644
7645                 if (!convert_devicemode(printer->info_2->printername, devmode,
7646                                         &printer->info_2->devmode)) {
7647                         return  WERR_NOMEM;
7648                 }
7649         }
7650
7651         /* write the ASCII on disk */
7652         err = mod_a_printer(printer, 2);
7653         if (!W_ERROR_IS_OK(err)) {
7654                 free_a_printer(&printer,2);
7655                 return err;
7656         }
7657
7658         if (!open_printer_hnd(p, handle, name, PRINTER_ACCESS_ADMINISTER)) {
7659                 /* Handle open failed - remove addition. */
7660                 del_a_printer(printer->info_2->sharename);
7661                 free_a_printer(&printer,2);
7662                 ZERO_STRUCTP(handle);
7663                 return WERR_ACCESS_DENIED;
7664         }
7665
7666         update_c_setprinter(false);
7667         free_a_printer(&printer,2);
7668
7669         return WERR_OK;
7670 }
7671
7672 /****************************************************************
7673  _spoolss_AddPrinterEx
7674 ****************************************************************/
7675
7676 WERROR _spoolss_AddPrinterEx(pipes_struct *p,
7677                              struct spoolss_AddPrinterEx *r)
7678 {
7679         switch (r->in.info_ctr->level) {
7680         case 1:
7681                 /* we don't handle yet */
7682                 /* but I know what to do ... */
7683                 return WERR_UNKNOWN_LEVEL;
7684         case 2:
7685                 return spoolss_addprinterex_level_2(p, r->in.server,
7686                                                     r->in.info_ctr,
7687                                                     r->in.devmode_ctr->devmode,
7688                                                     r->in.secdesc_ctr->sd,
7689                                                     r->in.userlevel_ctr,
7690                                                     r->out.handle);
7691         default:
7692                 return WERR_UNKNOWN_LEVEL;
7693         }
7694 }
7695
7696 /****************************************************************
7697  _spoolss_AddPrinterDriver
7698 ****************************************************************/
7699
7700 WERROR _spoolss_AddPrinterDriver(pipes_struct *p,
7701                                  struct spoolss_AddPrinterDriver *r)
7702 {
7703         uint32_t level = r->in.info_ctr->level;
7704         struct spoolss_AddDriverInfoCtr *info = r->in.info_ctr;
7705         WERROR err = WERR_OK;
7706         NT_PRINTER_DRIVER_INFO_LEVEL driver;
7707         const char *driver_name = NULL;
7708         uint32_t version;
7709         const char *fn;
7710
7711         switch (p->hdr_req.opnum) {
7712                 case NDR_SPOOLSS_ADDPRINTERDRIVER:
7713                         fn = "_spoolss_AddPrinterDriver";
7714                         break;
7715                 case NDR_SPOOLSS_ADDPRINTERDRIVEREX:
7716                         fn = "_spoolss_AddPrinterDriverEx";
7717                         break;
7718                 default:
7719                         return WERR_INVALID_PARAM;
7720         }
7721
7722
7723         /* FIXME */
7724         if (level != 3 && level != 6) {
7725                 /* Clever hack from Martin Zielinski <mz@seh.de>
7726                  * to allow downgrade from level 8 (Vista).
7727                  */
7728                 DEBUG(0,("%s: level %d not yet implemented\n", fn, level));
7729                 return WERR_UNKNOWN_LEVEL;
7730         }
7731
7732         ZERO_STRUCT(driver);
7733
7734         if (!convert_printer_driver_info(info, &driver, level)) {
7735                 err = WERR_NOMEM;
7736                 goto done;
7737         }
7738
7739         DEBUG(5,("Cleaning driver's information\n"));
7740         err = clean_up_driver_struct(p, driver, level);
7741         if (!W_ERROR_IS_OK(err))
7742                 goto done;
7743
7744         DEBUG(5,("Moving driver to final destination\n"));
7745         if( !W_ERROR_IS_OK(err = move_driver_to_download_area(p, driver, level,
7746                                                               &err)) ) {
7747                 goto done;
7748         }
7749
7750         if (add_a_printer_driver(driver, level)!=0) {
7751                 err = WERR_ACCESS_DENIED;
7752                 goto done;
7753         }
7754
7755         switch(level) {
7756         case 3:
7757                 driver_name = driver.info_3->name ? driver.info_3->name : "";
7758                 break;
7759         case 6:
7760                 driver_name = driver.info_6->name ? driver.info_6->name : "";
7761                 break;
7762         }
7763
7764         /*
7765          * I think this is where he DrvUpgradePrinter() hook would be
7766          * be called in a driver's interface DLL on a Windows NT 4.0/2k
7767          * server.  Right now, we just need to send ourselves a message
7768          * to update each printer bound to this driver.   --jerry
7769          */
7770
7771         if (!srv_spoolss_drv_upgrade_printer(driver_name)) {
7772                 DEBUG(0,("%s: Failed to send message about upgrading driver [%s]!\n",
7773                         fn, driver_name));
7774         }
7775
7776         /*
7777          * Based on the version (e.g. driver destination dir: 0=9x,2=Nt/2k,3=2k/Xp),
7778          * decide if the driver init data should be deleted. The rules are:
7779          *  1) never delete init data if it is a 9x driver, they don't use it anyway
7780          *  2) delete init data only if there is no 2k/Xp driver
7781          *  3) always delete init data
7782          * The generalized rule is always use init data from the highest order driver.
7783          * It is necessary to follow the driver install by an initialization step to
7784          * finish off this process.
7785         */
7786         if (level == 3)
7787                 version = driver.info_3->cversion;
7788         else if (level == 6)
7789                 version = driver.info_6->version;
7790         else
7791                 version = -1;
7792         switch (version) {
7793                 /*
7794                  * 9x printer driver - never delete init data
7795                 */
7796                 case 0:
7797                         DEBUG(10,("%s: init data not deleted for 9x driver [%s]\n",
7798                                 fn, driver_name));
7799                         break;
7800
7801                 /*
7802                  * Nt or 2k (compatiblity mode) printer driver - only delete init data if
7803                  * there is no 2k/Xp driver init data for this driver name.
7804                 */
7805                 case 2:
7806                 {
7807                         NT_PRINTER_DRIVER_INFO_LEVEL driver1;
7808
7809                         if (!W_ERROR_IS_OK(get_a_printer_driver(&driver1, 3, driver_name, "Windows NT x86", 3))) {
7810                                 /*
7811                                  * No 2k/Xp driver found, delete init data (if any) for the new Nt driver.
7812                                 */
7813                                 if (!del_driver_init(driver_name))
7814                                         DEBUG(6,("%s: del_driver_init(%s) Nt failed!\n",
7815                                                 fn, driver_name));
7816                         } else {
7817                                 /*
7818                                  * a 2k/Xp driver was found, don't delete init data because Nt driver will use it.
7819                                 */
7820                                 free_a_printer_driver(driver1,3);
7821                                 DEBUG(10,("%s: init data not deleted for Nt driver [%s]\n",
7822                                         fn, driver_name));
7823                         }
7824                 }
7825                 break;
7826
7827                 /*
7828                  * 2k or Xp printer driver - always delete init data
7829                 */
7830                 case 3:
7831                         if (!del_driver_init(driver_name))
7832                                 DEBUG(6,("%s: del_driver_init(%s) 2k/Xp failed!\n",
7833                                         fn, driver_name));
7834                         break;
7835
7836                 default:
7837                         DEBUG(0,("%s: invalid level=%d\n", fn, level));
7838                         break;
7839         }
7840
7841
7842 done:
7843         free_a_printer_driver(driver, level);
7844         return err;
7845 }
7846
7847 /****************************************************************
7848  _spoolss_AddPrinterDriverEx
7849 ****************************************************************/
7850
7851 WERROR _spoolss_AddPrinterDriverEx(pipes_struct *p,
7852                                    struct spoolss_AddPrinterDriverEx *r)
7853 {
7854         struct spoolss_AddPrinterDriver a;
7855
7856         /*
7857          * we only support the semantics of AddPrinterDriver()
7858          * i.e. only copy files that are newer than existing ones
7859          */
7860
7861         if (r->in.flags != APD_COPY_NEW_FILES) {
7862                 return WERR_ACCESS_DENIED;
7863         }
7864
7865         a.in.servername         = r->in.servername;
7866         a.in.info_ctr           = r->in.info_ctr;
7867
7868         return _spoolss_AddPrinterDriver(p, &a);
7869 }
7870
7871 /****************************************************************************
7872 ****************************************************************************/
7873
7874 struct _spoolss_paths {
7875         int type;
7876         const char *share;
7877         const char *dir;
7878 };
7879
7880 enum { SPOOLSS_DRIVER_PATH, SPOOLSS_PRTPROCS_PATH };
7881
7882 static const struct _spoolss_paths spoolss_paths[]= {
7883         { SPOOLSS_DRIVER_PATH,          "print$",       "DRIVERS" },
7884         { SPOOLSS_PRTPROCS_PATH,        "prnproc$",     "PRTPROCS" }
7885 };
7886
7887 static WERROR compose_spoolss_server_path(TALLOC_CTX *mem_ctx,
7888                                           const char *servername,
7889                                           const char *environment,
7890                                           int component,
7891                                           char **path)
7892 {
7893         const char *pservername = NULL;
7894         const char *long_archi = SPOOLSS_ARCHITECTURE_NT_X86;
7895         const char *short_archi;
7896
7897         *path = NULL;
7898
7899         /* environment may be empty */
7900         if (environment && strlen(environment)) {
7901                 long_archi = environment;
7902         }
7903
7904         /* servername may be empty */
7905         if (servername && strlen(servername)) {
7906                 pservername = canon_servername(servername);
7907
7908                 if (!is_myname_or_ipaddr(pservername)) {
7909                         return WERR_INVALID_PARAM;
7910                 }
7911         }
7912
7913         if (!(short_archi = get_short_archi(long_archi))) {
7914                 return WERR_INVALID_ENVIRONMENT;
7915         }
7916
7917         switch (component) {
7918         case SPOOLSS_PRTPROCS_PATH:
7919         case SPOOLSS_DRIVER_PATH:
7920                 if (pservername) {
7921                         *path = talloc_asprintf(mem_ctx,
7922                                         "\\\\%s\\%s\\%s",
7923                                         pservername,
7924                                         spoolss_paths[component].share,
7925                                         short_archi);
7926                 } else {
7927                         *path = talloc_asprintf(mem_ctx, "%s\\%s\\%s",
7928                                         SPOOLSS_DEFAULT_SERVER_PATH,
7929                                         spoolss_paths[component].dir,
7930                                         short_archi);
7931                 }
7932                 break;
7933         default:
7934                 return WERR_INVALID_PARAM;
7935         }
7936
7937         if (!*path) {
7938                 return WERR_NOMEM;
7939         }
7940
7941         return WERR_OK;
7942 }
7943
7944 /****************************************************************************
7945 ****************************************************************************/
7946
7947 static WERROR getprinterdriverdir_level_1(TALLOC_CTX *mem_ctx,
7948                                           const char *servername,
7949                                           const char *environment,
7950                                           struct spoolss_DriverDirectoryInfo1 *r)
7951 {
7952         WERROR werr;
7953         char *path = NULL;
7954
7955         werr = compose_spoolss_server_path(mem_ctx,
7956                                            servername,
7957                                            environment,
7958                                            SPOOLSS_DRIVER_PATH,
7959                                            &path);
7960         if (!W_ERROR_IS_OK(werr)) {
7961                 return werr;
7962         }
7963
7964         DEBUG(4,("printer driver directory: [%s]\n", path));
7965
7966         r->directory_name = path;
7967
7968         return WERR_OK;
7969 }
7970
7971 /****************************************************************
7972  _spoolss_GetPrinterDriverDirectory
7973 ****************************************************************/
7974
7975 WERROR _spoolss_GetPrinterDriverDirectory(pipes_struct *p,
7976                                           struct spoolss_GetPrinterDriverDirectory *r)
7977 {
7978         WERROR werror;
7979
7980         /* that's an [in out] buffer */
7981
7982         if (!r->in.buffer && (r->in.offered != 0)) {
7983                 return WERR_INVALID_PARAM;
7984         }
7985
7986         DEBUG(5,("_spoolss_GetPrinterDriverDirectory: level %d\n",
7987                 r->in.level));
7988
7989         *r->out.needed = 0;
7990
7991         /* r->in.level is ignored */
7992
7993         werror = getprinterdriverdir_level_1(p->mem_ctx,
7994                                              r->in.server,
7995                                              r->in.environment,
7996                                              &r->out.info->info1);
7997         if (!W_ERROR_IS_OK(werror)) {
7998                 TALLOC_FREE(r->out.info);
7999                 return werror;
8000         }
8001
8002         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_DriverDirectoryInfo, NULL,
8003                                                r->out.info, r->in.level);
8004         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
8005
8006         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8007 }
8008
8009 /****************************************************************
8010  _spoolss_EnumPrinterData
8011 ****************************************************************/
8012
8013 WERROR _spoolss_EnumPrinterData(pipes_struct *p,
8014                                 struct spoolss_EnumPrinterData *r)
8015 {
8016         NT_PRINTER_INFO_LEVEL *printer = NULL;
8017         Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
8018         int             snum;
8019         WERROR          result;
8020         struct regval_blob      *val = NULL;
8021         NT_PRINTER_DATA *p_data;
8022         int             i, key_index, num_values;
8023         int             name_length;
8024
8025         *r->out.value_needed    = 0;
8026         *r->out.type            = REG_NONE;
8027         *r->out.data_needed     = 0;
8028
8029         DEBUG(5,("_spoolss_EnumPrinterData\n"));
8030
8031         if (!Printer) {
8032                 DEBUG(2,("_spoolss_EnumPrinterData: Invalid handle (%s:%u:%u).\n",
8033                         OUR_HANDLE(r->in.handle)));
8034                 return WERR_BADFID;
8035         }
8036
8037         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8038                 return WERR_BADFID;
8039         }
8040
8041         result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8042         if (!W_ERROR_IS_OK(result)) {
8043                 return result;
8044         }
8045
8046         p_data = printer->info_2->data;
8047         key_index = lookup_printerkey( p_data, SPOOL_PRINTERDATA_KEY );
8048
8049         result = WERR_OK;
8050
8051         /*
8052          * The NT machine wants to know the biggest size of value and data
8053          *
8054          * cf: MSDN EnumPrinterData remark section
8055          */
8056
8057         if (!r->in.value_offered && !r->in.data_offered && (key_index != -1)) {
8058
8059                 uint32_t biggest_valuesize = 0;
8060                 uint32_t biggest_datasize = 0;
8061
8062                 DEBUGADD(6,("Activating NT mega-hack to find sizes\n"));
8063
8064                 num_values = regval_ctr_numvals( p_data->keys[key_index].values );
8065
8066                 for ( i=0; i<num_values; i++ )
8067                 {
8068                         val = regval_ctr_specific_value( p_data->keys[key_index].values, i );
8069
8070                         name_length = strlen(val->valuename);
8071                         if ( strlen(val->valuename) > biggest_valuesize )
8072                                 biggest_valuesize = name_length;
8073
8074                         if ( val->size > biggest_datasize )
8075                                 biggest_datasize = val->size;
8076
8077                         DEBUG(6,("current values: [%d], [%d]\n", biggest_valuesize,
8078                                 biggest_datasize));
8079                 }
8080
8081                 /* the value is an UNICODE string but real_value_size is the length
8082                    in bytes including the trailing 0 */
8083
8084                 *r->out.value_needed = 2 * (1 + biggest_valuesize);
8085                 *r->out.data_needed  = biggest_datasize;
8086
8087                 DEBUG(6,("final values: [%d], [%d]\n",
8088                         *r->out.value_needed, *r->out.data_needed));
8089
8090                 goto done;
8091         }
8092
8093         /*
8094          * the value len is wrong in NT sp3
8095          * that's the number of bytes not the number of unicode chars
8096          */
8097
8098         if (key_index != -1) {
8099                 val = regval_ctr_specific_value(p_data->keys[key_index].values,
8100                                                 r->in.enum_index);
8101         }
8102
8103         if (!val) {
8104
8105                 /* out_value should default to "" or else NT4 has
8106                    problems unmarshalling the response */
8107
8108                 if (r->in.value_offered) {
8109                         *r->out.value_needed = 1;
8110                         r->out.value_name = talloc_strdup(r, "");
8111                         if (!r->out.value_name) {
8112                                 result = WERR_NOMEM;
8113                                 goto done;
8114                         }
8115                 } else {
8116                         r->out.value_name = NULL;
8117                         *r->out.value_needed = 0;
8118                 }
8119
8120                 /* the data is counted in bytes */
8121
8122                 *r->out.data_needed = r->in.data_offered;
8123
8124                 result = WERR_NO_MORE_ITEMS;
8125         } else {
8126                 /*
8127                  * the value is:
8128                  * - counted in bytes in the request
8129                  * - counted in UNICODE chars in the max reply
8130                  * - counted in bytes in the real size
8131                  *
8132                  * take a pause *before* coding not *during* coding
8133                  */
8134
8135                 /* name */
8136                 if (r->in.value_offered) {
8137                         r->out.value_name = talloc_strdup(r, regval_name(val));
8138                         if (!r->out.value_name) {
8139                                 result = WERR_NOMEM;
8140                                 goto done;
8141                         }
8142                         *r->out.value_needed = strlen_m(regval_name(val));
8143                 } else {
8144                         r->out.value_name = NULL;
8145                         *r->out.value_needed = 0;
8146                 }
8147
8148                 /* type */
8149
8150                 *r->out.type = regval_type(val);
8151
8152                 /* data - counted in bytes */
8153
8154                 /*
8155                  * See the section "Dynamically Typed Query Parameters"
8156                  * in MS-RPRN.
8157                  */
8158
8159                 if (r->out.data && regval_data_p(val) &&
8160                                 regval_size(val) && r->in.data_offered) {
8161                         memcpy(r->out.data, regval_data_p(val),
8162                                 MIN(regval_size(val),r->in.data_offered));
8163                 }
8164
8165                 *r->out.data_needed = regval_size(val);
8166         }
8167
8168 done:
8169         free_a_printer(&printer, 2);
8170         return result;
8171 }
8172
8173 /****************************************************************
8174  _spoolss_SetPrinterData
8175 ****************************************************************/
8176
8177 WERROR _spoolss_SetPrinterData(pipes_struct *p,
8178                                struct spoolss_SetPrinterData *r)
8179 {
8180         NT_PRINTER_INFO_LEVEL *printer = NULL;
8181         int snum=0;
8182         WERROR result = WERR_OK;
8183         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8184         DATA_BLOB blob;
8185
8186         DEBUG(5,("_spoolss_SetPrinterData\n"));
8187
8188         if (!Printer) {
8189                 DEBUG(2,("_spoolss_SetPrinterData: Invalid handle (%s:%u:%u).\n",
8190                         OUR_HANDLE(r->in.handle)));
8191                 return WERR_BADFID;
8192         }
8193
8194         if (Printer->printer_type == SPLHND_SERVER) {
8195                 DEBUG(10,("_spoolss_SetPrinterData: "
8196                         "Not implemented for server handles yet\n"));
8197                 return WERR_INVALID_PARAM;
8198         }
8199
8200         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8201                 return WERR_BADFID;
8202         }
8203
8204         /*
8205          * Access check : NT returns "access denied" if you make a
8206          * SetPrinterData call without the necessary privildge.
8207          * we were originally returning OK if nothing changed
8208          * which made Win2k issue **a lot** of SetPrinterData
8209          * when connecting to a printer  --jerry
8210          */
8211
8212         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
8213                 DEBUG(3,("_spoolss_SetPrinterData: "
8214                         "change denied by handle access permissions\n"));
8215                 result = WERR_ACCESS_DENIED;
8216                 goto done;
8217         }
8218
8219         result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8220         if (!W_ERROR_IS_OK(result)) {
8221                 return result;
8222         }
8223
8224         result = push_spoolss_PrinterData(p->mem_ctx, &blob,
8225                                           r->in.type, &r->in.data);
8226         if (!W_ERROR_IS_OK(result)) {
8227                 goto done;
8228         }
8229
8230         /*
8231          * When client side code sets a magic printer data key, detect it and save
8232          * the current printer data and the magic key's data (its the DEVMODE) for
8233          * future printer/driver initializations.
8234          */
8235         if ((r->in.type == REG_BINARY) && strequal(r->in.value_name, PHANTOM_DEVMODE_KEY)) {
8236                 /* Set devmode and printer initialization info */
8237                 result = save_driver_init(printer, 2, blob.data, blob.length);
8238
8239                 srv_spoolss_reset_printerdata(printer->info_2->drivername);
8240
8241                 goto done;
8242         }
8243
8244         result = set_printer_dataex(printer, SPOOL_PRINTERDATA_KEY,
8245                                     r->in.value_name, r->in.type,
8246                                     blob.data, blob.length);
8247         if (W_ERROR_IS_OK(result)) {
8248                 result = mod_a_printer(printer, 2);
8249         }
8250
8251 done:
8252         free_a_printer(&printer, 2);
8253
8254         return result;
8255 }
8256
8257 /****************************************************************
8258  _spoolss_ResetPrinter
8259 ****************************************************************/
8260
8261 WERROR _spoolss_ResetPrinter(pipes_struct *p,
8262                              struct spoolss_ResetPrinter *r)
8263 {
8264         Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
8265         int             snum;
8266
8267         DEBUG(5,("_spoolss_ResetPrinter\n"));
8268
8269         /*
8270          * All we do is to check to see if the handle and queue is valid.
8271          * This call really doesn't mean anything to us because we only
8272          * support RAW printing.   --jerry
8273          */
8274
8275         if (!Printer) {
8276                 DEBUG(2,("_spoolss_ResetPrinter: Invalid handle (%s:%u:%u).\n",
8277                         OUR_HANDLE(r->in.handle)));
8278                 return WERR_BADFID;
8279         }
8280
8281         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8282                 return WERR_BADFID;
8283
8284
8285         /* blindly return success */
8286         return WERR_OK;
8287 }
8288
8289 /****************************************************************
8290  _spoolss_DeletePrinterData
8291 ****************************************************************/
8292
8293 WERROR _spoolss_DeletePrinterData(pipes_struct *p,
8294                                   struct spoolss_DeletePrinterData *r)
8295 {
8296         NT_PRINTER_INFO_LEVEL   *printer = NULL;
8297         int             snum=0;
8298         WERROR          status = WERR_OK;
8299         Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
8300
8301         DEBUG(5,("_spoolss_DeletePrinterData\n"));
8302
8303         if (!Printer) {
8304                 DEBUG(2,("_spoolss_DeletePrinterData: Invalid handle (%s:%u:%u).\n",
8305                         OUR_HANDLE(r->in.handle)));
8306                 return WERR_BADFID;
8307         }
8308
8309         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8310                 return WERR_BADFID;
8311
8312         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
8313                 DEBUG(3, ("_spoolss_DeletePrinterData: "
8314                         "printer properties change denied by handle\n"));
8315                 return WERR_ACCESS_DENIED;
8316         }
8317
8318         status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8319         if (!W_ERROR_IS_OK(status))
8320                 return status;
8321
8322         if (!r->in.value_name) {
8323                 free_a_printer(&printer, 2);
8324                 return WERR_NOMEM;
8325         }
8326
8327         status = delete_printer_dataex( printer, SPOOL_PRINTERDATA_KEY,
8328                                         r->in.value_name );
8329
8330         if ( W_ERROR_IS_OK(status) )
8331                 mod_a_printer( printer, 2 );
8332
8333         free_a_printer(&printer, 2);
8334
8335         return status;
8336 }
8337
8338 /****************************************************************
8339  _spoolss_AddForm
8340 ****************************************************************/
8341
8342 WERROR _spoolss_AddForm(pipes_struct *p,
8343                         struct spoolss_AddForm *r)
8344 {
8345         struct spoolss_AddFormInfo1 *form = r->in.info.info1;
8346         nt_forms_struct tmpForm;
8347         int snum = -1;
8348         WERROR status = WERR_OK;
8349         NT_PRINTER_INFO_LEVEL *printer = NULL;
8350         SE_PRIV se_printop = SE_PRINT_OPERATOR;
8351
8352         int count=0;
8353         nt_forms_struct *list=NULL;
8354         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8355
8356         DEBUG(5,("_spoolss_AddForm\n"));
8357
8358         if (!Printer) {
8359                 DEBUG(2,("_spoolss_AddForm: Invalid handle (%s:%u:%u).\n",
8360                         OUR_HANDLE(r->in.handle)));
8361                 return WERR_BADFID;
8362         }
8363
8364
8365         /* forms can be added on printer of on the print server handle */
8366
8367         if ( Printer->printer_type == SPLHND_PRINTER )
8368         {
8369                 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8370                         return WERR_BADFID;
8371
8372                 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8373                 if (!W_ERROR_IS_OK(status))
8374                         goto done;
8375         }
8376
8377         /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
8378            and not a printer admin, then fail */
8379
8380         if ((p->server_info->utok.uid != sec_initial_uid()) &&
8381              !user_has_privileges(p->server_info->ptok, &se_printop) &&
8382              !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
8383                                           NULL, NULL,
8384                                           p->server_info->ptok,
8385                                           lp_printer_admin(snum))) {
8386                 DEBUG(2,("_spoolss_Addform: denied by insufficient permissions.\n"));
8387                 return WERR_ACCESS_DENIED;
8388         }
8389
8390         /* can't add if builtin */
8391
8392         if (get_a_builtin_ntform_by_string(form->form_name, &tmpForm)) {
8393                 status = WERR_FILE_EXISTS;
8394                 goto done;
8395         }
8396
8397         count = get_ntforms(&list);
8398
8399         if(!add_a_form(&list, form, &count)) {
8400                 status =  WERR_NOMEM;
8401                 goto done;
8402         }
8403
8404         become_root();
8405         write_ntforms(&list, count);
8406         unbecome_root();
8407
8408         /*
8409          * ChangeID must always be set if this is a printer
8410          */
8411
8412         if ( Printer->printer_type == SPLHND_PRINTER )
8413                 status = mod_a_printer(printer, 2);
8414
8415 done:
8416         if ( printer )
8417                 free_a_printer(&printer, 2);
8418         SAFE_FREE(list);
8419
8420         return status;
8421 }
8422
8423 /****************************************************************
8424  _spoolss_DeleteForm
8425 ****************************************************************/
8426
8427 WERROR _spoolss_DeleteForm(pipes_struct *p,
8428                            struct spoolss_DeleteForm *r)
8429 {
8430         const char *form_name = r->in.form_name;
8431         nt_forms_struct tmpForm;
8432         int count=0;
8433         nt_forms_struct *list=NULL;
8434         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8435         int snum = -1;
8436         WERROR status = WERR_OK;
8437         NT_PRINTER_INFO_LEVEL *printer = NULL;
8438         SE_PRIV se_printop = SE_PRINT_OPERATOR;
8439         bool ret = false;
8440
8441         DEBUG(5,("_spoolss_DeleteForm\n"));
8442
8443         if (!Printer) {
8444                 DEBUG(2,("_spoolss_DeleteForm: Invalid handle (%s:%u:%u).\n",
8445                         OUR_HANDLE(r->in.handle)));
8446                 return WERR_BADFID;
8447         }
8448
8449         /* forms can be deleted on printer of on the print server handle */
8450
8451         if ( Printer->printer_type == SPLHND_PRINTER )
8452         {
8453                 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8454                         return WERR_BADFID;
8455
8456                 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8457                 if (!W_ERROR_IS_OK(status))
8458                         goto done;
8459         }
8460
8461         if ((p->server_info->utok.uid != sec_initial_uid()) &&
8462              !user_has_privileges(p->server_info->ptok, &se_printop) &&
8463              !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
8464                                           NULL, NULL,
8465                                           p->server_info->ptok,
8466                                           lp_printer_admin(snum))) {
8467                 DEBUG(2,("_spoolss_DeleteForm: denied by insufficient permissions.\n"));
8468                 return WERR_ACCESS_DENIED;
8469         }
8470
8471
8472         /* can't delete if builtin */
8473
8474         if (get_a_builtin_ntform_by_string(form_name,&tmpForm)) {
8475                 status = WERR_INVALID_PARAM;
8476                 goto done;
8477         }
8478
8479         count = get_ntforms(&list);
8480
8481         become_root();
8482         ret = delete_a_form(&list, form_name, &count, &status);
8483         unbecome_root();
8484         if (ret == false) {
8485                 goto done;
8486         }
8487
8488         /*
8489          * ChangeID must always be set if this is a printer
8490          */
8491
8492         if ( Printer->printer_type == SPLHND_PRINTER )
8493                 status = mod_a_printer(printer, 2);
8494
8495 done:
8496         if ( printer )
8497                 free_a_printer(&printer, 2);
8498         SAFE_FREE(list);
8499
8500         return status;
8501 }
8502
8503 /****************************************************************
8504  _spoolss_SetForm
8505 ****************************************************************/
8506
8507 WERROR _spoolss_SetForm(pipes_struct *p,
8508                         struct spoolss_SetForm *r)
8509 {
8510         struct spoolss_AddFormInfo1 *form = r->in.info.info1;
8511         nt_forms_struct tmpForm;
8512         int snum = -1;
8513         WERROR status = WERR_OK;
8514         NT_PRINTER_INFO_LEVEL *printer = NULL;
8515         SE_PRIV se_printop = SE_PRINT_OPERATOR;
8516
8517         int count=0;
8518         nt_forms_struct *list=NULL;
8519         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8520
8521         DEBUG(5,("_spoolss_SetForm\n"));
8522
8523         if (!Printer) {
8524                 DEBUG(2,("_spoolss_SetForm: Invalid handle (%s:%u:%u).\n",
8525                         OUR_HANDLE(r->in.handle)));
8526                 return WERR_BADFID;
8527         }
8528
8529         /* forms can be modified on printer of on the print server handle */
8530
8531         if ( Printer->printer_type == SPLHND_PRINTER )
8532         {
8533                 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8534                         return WERR_BADFID;
8535
8536                 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8537                 if (!W_ERROR_IS_OK(status))
8538                         goto done;
8539         }
8540
8541         /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
8542            and not a printer admin, then fail */
8543
8544         if ((p->server_info->utok.uid != sec_initial_uid()) &&
8545              !user_has_privileges(p->server_info->ptok, &se_printop) &&
8546              !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
8547                                           NULL, NULL,
8548                                           p->server_info->ptok,
8549                                           lp_printer_admin(snum))) {
8550                 DEBUG(2,("_spoolss_Setform: denied by insufficient permissions.\n"));
8551                 return WERR_ACCESS_DENIED;
8552         }
8553
8554         /* can't set if builtin */
8555         if (get_a_builtin_ntform_by_string(form->form_name, &tmpForm)) {
8556                 status = WERR_INVALID_PARAM;
8557                 goto done;
8558         }
8559
8560         count = get_ntforms(&list);
8561         update_a_form(&list, form, count);
8562         become_root();
8563         write_ntforms(&list, count);
8564         unbecome_root();
8565
8566         /*
8567          * ChangeID must always be set if this is a printer
8568          */
8569
8570         if ( Printer->printer_type == SPLHND_PRINTER )
8571                 status = mod_a_printer(printer, 2);
8572
8573
8574 done:
8575         if ( printer )
8576                 free_a_printer(&printer, 2);
8577         SAFE_FREE(list);
8578
8579         return status;
8580 }
8581
8582 /****************************************************************************
8583  fill_print_processor1
8584 ****************************************************************************/
8585
8586 static WERROR fill_print_processor1(TALLOC_CTX *mem_ctx,
8587                                     struct spoolss_PrintProcessorInfo1 *r,
8588                                     const char *print_processor_name)
8589 {
8590         r->print_processor_name = talloc_strdup(mem_ctx, print_processor_name);
8591         W_ERROR_HAVE_NO_MEMORY(r->print_processor_name);
8592
8593         return WERR_OK;
8594 }
8595
8596 /****************************************************************************
8597  enumprintprocessors level 1.
8598 ****************************************************************************/
8599
8600 static WERROR enumprintprocessors_level_1(TALLOC_CTX *mem_ctx,
8601                                           union spoolss_PrintProcessorInfo **info_p,
8602                                           uint32_t *count)
8603 {
8604         union spoolss_PrintProcessorInfo *info;
8605         WERROR result;
8606
8607         info = TALLOC_ARRAY(mem_ctx, union spoolss_PrintProcessorInfo, 1);
8608         W_ERROR_HAVE_NO_MEMORY(info);
8609
8610         *count = 1;
8611
8612         result = fill_print_processor1(info, &info[0].info1, "winprint");
8613         if (!W_ERROR_IS_OK(result)) {
8614                 goto out;
8615         }
8616
8617  out:
8618         if (!W_ERROR_IS_OK(result)) {
8619                 TALLOC_FREE(info);
8620                 *count = 0;
8621                 return result;
8622         }
8623
8624         *info_p = info;
8625
8626         return WERR_OK;
8627 }
8628
8629 /****************************************************************
8630  _spoolss_EnumPrintProcessors
8631 ****************************************************************/
8632
8633 WERROR _spoolss_EnumPrintProcessors(pipes_struct *p,
8634                                     struct spoolss_EnumPrintProcessors *r)
8635 {
8636         WERROR result;
8637
8638         /* that's an [in out] buffer */
8639
8640         if (!r->in.buffer && (r->in.offered != 0)) {
8641                 return WERR_INVALID_PARAM;
8642         }
8643
8644         DEBUG(5,("_spoolss_EnumPrintProcessors\n"));
8645
8646         /*
8647          * Enumerate the print processors ...
8648          *
8649          * Just reply with "winprint", to keep NT happy
8650          * and I can use my nice printer checker.
8651          */
8652
8653         *r->out.count = 0;
8654         *r->out.needed = 0;
8655         *r->out.info = NULL;
8656
8657         switch (r->in.level) {
8658         case 1:
8659                 result = enumprintprocessors_level_1(p->mem_ctx, r->out.info,
8660                                                      r->out.count);
8661                 break;
8662         default:
8663                 return WERR_UNKNOWN_LEVEL;
8664         }
8665
8666         if (!W_ERROR_IS_OK(result)) {
8667                 return result;
8668         }
8669
8670         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8671                                                      spoolss_EnumPrintProcessors, NULL,
8672                                                      *r->out.info, r->in.level,
8673                                                      *r->out.count);
8674         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8675         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8676
8677         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8678 }
8679
8680 /****************************************************************************
8681  fill_printprocdatatype1
8682 ****************************************************************************/
8683
8684 static WERROR fill_printprocdatatype1(TALLOC_CTX *mem_ctx,
8685                                       struct spoolss_PrintProcDataTypesInfo1 *r,
8686                                       const char *name_array)
8687 {
8688         r->name_array = talloc_strdup(mem_ctx, name_array);
8689         W_ERROR_HAVE_NO_MEMORY(r->name_array);
8690
8691         return WERR_OK;
8692 }
8693
8694 /****************************************************************************
8695  enumprintprocdatatypes level 1.
8696 ****************************************************************************/
8697
8698 static WERROR enumprintprocdatatypes_level_1(TALLOC_CTX *mem_ctx,
8699                                              union spoolss_PrintProcDataTypesInfo **info_p,
8700                                              uint32_t *count)
8701 {
8702         WERROR result;
8703         union spoolss_PrintProcDataTypesInfo *info;
8704
8705         info = TALLOC_ARRAY(mem_ctx, union spoolss_PrintProcDataTypesInfo, 1);
8706         W_ERROR_HAVE_NO_MEMORY(info);
8707
8708         *count = 1;
8709
8710         result = fill_printprocdatatype1(info, &info[0].info1, "RAW");
8711         if (!W_ERROR_IS_OK(result)) {
8712                 goto out;
8713         }
8714
8715  out:
8716         if (!W_ERROR_IS_OK(result)) {
8717                 TALLOC_FREE(info);
8718                 *count = 0;
8719                 return result;
8720         }
8721
8722         *info_p = info;
8723
8724         return WERR_OK;
8725 }
8726
8727 /****************************************************************
8728  _spoolss_EnumPrintProcDataTypes
8729 ****************************************************************/
8730
8731 WERROR _spoolss_EnumPrintProcDataTypes(pipes_struct *p,
8732                                        struct spoolss_EnumPrintProcDataTypes *r)
8733 {
8734         WERROR result;
8735
8736         /* that's an [in out] buffer */
8737
8738         if (!r->in.buffer && (r->in.offered != 0)) {
8739                 return WERR_INVALID_PARAM;
8740         }
8741
8742         DEBUG(5,("_spoolss_EnumPrintProcDataTypes\n"));
8743
8744         *r->out.count = 0;
8745         *r->out.needed = 0;
8746         *r->out.info = NULL;
8747
8748         switch (r->in.level) {
8749         case 1:
8750                 result = enumprintprocdatatypes_level_1(p->mem_ctx, r->out.info,
8751                                                         r->out.count);
8752                 break;
8753         default:
8754                 return WERR_UNKNOWN_LEVEL;
8755         }
8756
8757         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8758                                                      spoolss_EnumPrintProcDataTypes, NULL,
8759                                                      *r->out.info, r->in.level,
8760                                                      *r->out.count);
8761         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8762         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8763
8764         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8765 }
8766
8767 /****************************************************************************
8768  fill_monitor_1
8769 ****************************************************************************/
8770
8771 static WERROR fill_monitor_1(TALLOC_CTX *mem_ctx,
8772                              struct spoolss_MonitorInfo1 *r,
8773                              const char *monitor_name)
8774 {
8775         r->monitor_name                 = talloc_strdup(mem_ctx, monitor_name);
8776         W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
8777
8778         return WERR_OK;
8779 }
8780
8781 /****************************************************************************
8782  fill_monitor_2
8783 ****************************************************************************/
8784
8785 static WERROR fill_monitor_2(TALLOC_CTX *mem_ctx,
8786                              struct spoolss_MonitorInfo2 *r,
8787                              const char *monitor_name,
8788                              const char *environment,
8789                              const char *dll_name)
8790 {
8791         r->monitor_name                 = talloc_strdup(mem_ctx, monitor_name);
8792         W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
8793         r->environment                  = talloc_strdup(mem_ctx, environment);
8794         W_ERROR_HAVE_NO_MEMORY(r->environment);
8795         r->dll_name                     = talloc_strdup(mem_ctx, dll_name);
8796         W_ERROR_HAVE_NO_MEMORY(r->dll_name);
8797
8798         return WERR_OK;
8799 }
8800
8801 /****************************************************************************
8802  enumprintmonitors level 1.
8803 ****************************************************************************/
8804
8805 static WERROR enumprintmonitors_level_1(TALLOC_CTX *mem_ctx,
8806                                         union spoolss_MonitorInfo **info_p,
8807                                         uint32_t *count)
8808 {
8809         union spoolss_MonitorInfo *info;
8810         WERROR result = WERR_OK;
8811
8812         info = TALLOC_ARRAY(mem_ctx, union spoolss_MonitorInfo, 2);
8813         W_ERROR_HAVE_NO_MEMORY(info);
8814
8815         *count = 2;
8816
8817         result = fill_monitor_1(info, &info[0].info1,
8818                                 SPL_LOCAL_PORT);
8819         if (!W_ERROR_IS_OK(result)) {
8820                 goto out;
8821         }
8822
8823         result = fill_monitor_1(info, &info[1].info1,
8824                                 SPL_TCPIP_PORT);
8825         if (!W_ERROR_IS_OK(result)) {
8826                 goto out;
8827         }
8828
8829 out:
8830         if (!W_ERROR_IS_OK(result)) {
8831                 TALLOC_FREE(info);
8832                 *count = 0;
8833                 return result;
8834         }
8835
8836         *info_p = info;
8837
8838         return WERR_OK;
8839 }
8840
8841 /****************************************************************************
8842  enumprintmonitors level 2.
8843 ****************************************************************************/
8844
8845 static WERROR enumprintmonitors_level_2(TALLOC_CTX *mem_ctx,
8846                                         union spoolss_MonitorInfo **info_p,
8847                                         uint32_t *count)
8848 {
8849         union spoolss_MonitorInfo *info;
8850         WERROR result = WERR_OK;
8851
8852         info = TALLOC_ARRAY(mem_ctx, union spoolss_MonitorInfo, 2);
8853         W_ERROR_HAVE_NO_MEMORY(info);
8854
8855         *count = 2;
8856
8857         result = fill_monitor_2(info, &info[0].info2,
8858                                 SPL_LOCAL_PORT,
8859                                 "Windows NT X86", /* FIXME */
8860                                 "localmon.dll");
8861         if (!W_ERROR_IS_OK(result)) {
8862                 goto out;
8863         }
8864
8865         result = fill_monitor_2(info, &info[1].info2,
8866                                 SPL_TCPIP_PORT,
8867                                 "Windows NT X86", /* FIXME */
8868                                 "tcpmon.dll");
8869         if (!W_ERROR_IS_OK(result)) {
8870                 goto out;
8871         }
8872
8873 out:
8874         if (!W_ERROR_IS_OK(result)) {
8875                 TALLOC_FREE(info);
8876                 *count = 0;
8877                 return result;
8878         }
8879
8880         *info_p = info;
8881
8882         return WERR_OK;
8883 }
8884
8885 /****************************************************************
8886  _spoolss_EnumMonitors
8887 ****************************************************************/
8888
8889 WERROR _spoolss_EnumMonitors(pipes_struct *p,
8890                              struct spoolss_EnumMonitors *r)
8891 {
8892         WERROR result;
8893
8894         /* that's an [in out] buffer */
8895
8896         if (!r->in.buffer && (r->in.offered != 0)) {
8897                 return WERR_INVALID_PARAM;
8898         }
8899
8900         DEBUG(5,("_spoolss_EnumMonitors\n"));
8901
8902         /*
8903          * Enumerate the print monitors ...
8904          *
8905          * Just reply with "Local Port", to keep NT happy
8906          * and I can use my nice printer checker.
8907          */
8908
8909         *r->out.count = 0;
8910         *r->out.needed = 0;
8911         *r->out.info = NULL;
8912
8913         switch (r->in.level) {
8914         case 1:
8915                 result = enumprintmonitors_level_1(p->mem_ctx, r->out.info,
8916                                                    r->out.count);
8917                 break;
8918         case 2:
8919                 result = enumprintmonitors_level_2(p->mem_ctx, r->out.info,
8920                                                    r->out.count);
8921                 break;
8922         default:
8923                 return WERR_UNKNOWN_LEVEL;
8924         }
8925
8926         if (!W_ERROR_IS_OK(result)) {
8927                 return result;
8928         }
8929
8930         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8931                                                      spoolss_EnumMonitors, NULL,
8932                                                      *r->out.info, r->in.level,
8933                                                      *r->out.count);
8934         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8935         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8936
8937         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8938 }
8939
8940 /****************************************************************************
8941 ****************************************************************************/
8942
8943 static WERROR getjob_level_1(TALLOC_CTX *mem_ctx,
8944                              const print_queue_struct *queue,
8945                              int count, int snum,
8946                              const NT_PRINTER_INFO_LEVEL *ntprinter,
8947                              uint32_t jobid,
8948                              struct spoolss_JobInfo1 *r)
8949 {
8950         int i = 0;
8951         bool found = false;
8952
8953         for (i=0; i<count && found == false; i++) {
8954                 if (queue[i].job == (int)jobid) {
8955                         found = true;
8956                 }
8957         }
8958
8959         if (found == false) {
8960                 /* NT treats not found as bad param... yet another bad choice */
8961                 return WERR_INVALID_PARAM;
8962         }
8963
8964         return fill_job_info1(mem_ctx,
8965                               r,
8966                               &queue[i-1],
8967                               i,
8968                               snum,
8969                               ntprinter);
8970 }
8971
8972 /****************************************************************************
8973 ****************************************************************************/
8974
8975 static WERROR getjob_level_2(TALLOC_CTX *mem_ctx,
8976                              const print_queue_struct *queue,
8977                              int count, int snum,
8978                              const NT_PRINTER_INFO_LEVEL *ntprinter,
8979                              uint32_t jobid,
8980                              struct spoolss_JobInfo2 *r)
8981 {
8982         int i = 0;
8983         bool found = false;
8984         struct spoolss_DeviceMode *devmode;
8985         NT_DEVICEMODE *nt_devmode;
8986         WERROR result;
8987
8988         for (i=0; i<count && found == false; i++) {
8989                 if (queue[i].job == (int)jobid) {
8990                         found = true;
8991                 }
8992         }
8993
8994         if (found == false) {
8995                 /* NT treats not found as bad param... yet another bad
8996                    choice */
8997                 return WERR_INVALID_PARAM;
8998         }
8999
9000         /*
9001          * if the print job does not have a DEVMODE associated with it,
9002          * just use the one for the printer. A NULL devicemode is not
9003          *  a failure condition
9004          */
9005
9006         nt_devmode = print_job_devmode(lp_const_servicename(snum), jobid);
9007         if (nt_devmode) {
9008                 devmode = TALLOC_ZERO_P(mem_ctx, struct spoolss_DeviceMode);
9009                 W_ERROR_HAVE_NO_MEMORY(devmode);
9010                 result = convert_nt_devicemode(devmode, devmode, nt_devmode);
9011                 if (!W_ERROR_IS_OK(result)) {
9012                         return result;
9013                 }
9014         } else {
9015                 devmode = construct_dev_mode(mem_ctx, lp_const_servicename(snum));
9016                 W_ERROR_HAVE_NO_MEMORY(devmode);
9017         }
9018
9019         return fill_job_info2(mem_ctx,
9020                               r,
9021                               &queue[i-1],
9022                               i,
9023                               snum,
9024                               ntprinter,
9025                               devmode);
9026 }
9027
9028 /****************************************************************
9029  _spoolss_GetJob
9030 ****************************************************************/
9031
9032 WERROR _spoolss_GetJob(pipes_struct *p,
9033                        struct spoolss_GetJob *r)
9034 {
9035         WERROR result = WERR_OK;
9036         NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
9037         int snum;
9038         int count;
9039         print_queue_struct      *queue = NULL;
9040         print_status_struct prt_status;
9041
9042         /* that's an [in out] buffer */
9043
9044         if (!r->in.buffer && (r->in.offered != 0)) {
9045                 return WERR_INVALID_PARAM;
9046         }
9047
9048         DEBUG(5,("_spoolss_GetJob\n"));
9049
9050         *r->out.needed = 0;
9051
9052         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9053                 return WERR_BADFID;
9054         }
9055
9056         result = get_a_printer(NULL, &ntprinter, 2, lp_servicename(snum));
9057         if (!W_ERROR_IS_OK(result)) {
9058                 return result;
9059         }
9060
9061         count = print_queue_status(snum, &queue, &prt_status);
9062
9063         DEBUGADD(4,("count:[%d], prt_status:[%d], [%s]\n",
9064                      count, prt_status.status, prt_status.message));
9065
9066         switch (r->in.level) {
9067         case 1:
9068                 result = getjob_level_1(p->mem_ctx,
9069                                         queue, count, snum, ntprinter,
9070                                         r->in.job_id, &r->out.info->info1);
9071                 break;
9072         case 2:
9073                 result = getjob_level_2(p->mem_ctx,
9074                                         queue, count, snum, ntprinter,
9075                                         r->in.job_id, &r->out.info->info2);
9076                 break;
9077         default:
9078                 result = WERR_UNKNOWN_LEVEL;
9079                 break;
9080         }
9081
9082         SAFE_FREE(queue);
9083         free_a_printer(&ntprinter, 2);
9084
9085         if (!W_ERROR_IS_OK(result)) {
9086                 TALLOC_FREE(r->out.info);
9087                 return result;
9088         }
9089
9090         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_JobInfo, NULL,
9091                                                r->out.info, r->in.level);
9092         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
9093
9094         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
9095 }
9096
9097 /****************************************************************
9098  _spoolss_GetPrinterDataEx
9099
9100  From MSDN documentation of GetPrinterDataEx: pass request
9101  to GetPrinterData if key is "PrinterDriverData".
9102 ****************************************************************/
9103
9104 WERROR _spoolss_GetPrinterDataEx(pipes_struct *p,
9105                                  struct spoolss_GetPrinterDataEx *r)
9106 {
9107
9108         Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
9109         struct regval_blob              *val = NULL;
9110         NT_PRINTER_INFO_LEVEL   *printer = NULL;
9111         int                     snum = 0;
9112         WERROR result = WERR_OK;
9113
9114         DEBUG(4,("_spoolss_GetPrinterDataEx\n"));
9115
9116         DEBUG(10, ("_spoolss_GetPrinterDataEx: key => [%s], value => [%s]\n",
9117                 r->in.key_name, r->in.value_name));
9118
9119         /* in case of problem, return some default values */
9120
9121         *r->out.needed  = 0;
9122         *r->out.type    = REG_NONE;
9123
9124         if (!Printer) {
9125                 DEBUG(2,("_spoolss_GetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
9126                         OUR_HANDLE(r->in.handle)));
9127                 result = WERR_BADFID;
9128                 goto done;
9129         }
9130
9131         /* Is the handle to a printer or to the server? */
9132
9133         if (Printer->printer_type == SPLHND_SERVER) {
9134                 DEBUG(10,("_spoolss_GetPrinterDataEx: "
9135                         "Not implemented for server handles yet\n"));
9136                 result = WERR_INVALID_PARAM;
9137                 goto done;
9138         }
9139
9140         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9141                 return WERR_BADFID;
9142         }
9143
9144         result = get_a_printer(Printer, &printer, 2, lp_servicename(snum));
9145         if (!W_ERROR_IS_OK(result)) {
9146                 goto done;
9147         }
9148
9149         /* check to see if the keyname is valid */
9150         if (!strlen(r->in.key_name)) {
9151                 result = WERR_INVALID_PARAM;
9152                 goto done;
9153         }
9154
9155         if (lookup_printerkey(printer->info_2->data, r->in.key_name) == -1) {
9156                 DEBUG(4,("_spoolss_GetPrinterDataEx: "
9157                         "Invalid keyname [%s]\n", r->in.key_name ));
9158                 result = WERR_BADFILE;
9159                 goto done;
9160         }
9161
9162         /* When given a new keyname, we should just create it */
9163
9164         val = get_printer_data(printer->info_2,
9165                                r->in.key_name, r->in.value_name);
9166         if (!val) {
9167                 result = WERR_BADFILE;
9168                 goto done;
9169         }
9170
9171         *r->out.needed = regval_size(val);
9172
9173         if (*r->out.needed > r->in.offered) {
9174                 result = WERR_MORE_DATA;
9175                 goto done;
9176         }
9177
9178         *r->out.type = regval_type(val);
9179
9180         memcpy(r->out.buffer, regval_data_p(val), regval_size(val));
9181
9182  done:
9183         if (printer) {
9184                 free_a_printer(&printer, 2);
9185         }
9186
9187         return result;
9188 }
9189
9190 /****************************************************************
9191  _spoolss_SetPrinterDataEx
9192 ****************************************************************/
9193
9194 WERROR _spoolss_SetPrinterDataEx(pipes_struct *p,
9195                                  struct spoolss_SetPrinterDataEx *r)
9196 {
9197         NT_PRINTER_INFO_LEVEL   *printer = NULL;
9198         int                     snum = 0;
9199         WERROR                  result = WERR_OK;
9200         Printer_entry           *Printer = find_printer_index_by_hnd(p, r->in.handle);
9201         char                    *oid_string;
9202
9203         DEBUG(4,("_spoolss_SetPrinterDataEx\n"));
9204
9205         /* From MSDN documentation of SetPrinterDataEx: pass request to
9206            SetPrinterData if key is "PrinterDriverData" */
9207
9208         if (!Printer) {
9209                 DEBUG(2,("_spoolss_SetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
9210                         OUR_HANDLE(r->in.handle)));
9211                 return WERR_BADFID;
9212         }
9213
9214         if (Printer->printer_type == SPLHND_SERVER) {
9215                 DEBUG(10,("_spoolss_SetPrinterDataEx: "
9216                         "Not implemented for server handles yet\n"));
9217                 return WERR_INVALID_PARAM;
9218         }
9219
9220         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9221                 return WERR_BADFID;
9222         }
9223
9224         /*
9225          * Access check : NT returns "access denied" if you make a
9226          * SetPrinterData call without the necessary privildge.
9227          * we were originally returning OK if nothing changed
9228          * which made Win2k issue **a lot** of SetPrinterData
9229          * when connecting to a printer  --jerry
9230          */
9231
9232         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9233                 DEBUG(3, ("_spoolss_SetPrinterDataEx: "
9234                         "change denied by handle access permissions\n"));
9235                 return WERR_ACCESS_DENIED;
9236         }
9237
9238         result = get_a_printer(Printer, &printer, 2, lp_servicename(snum));
9239         if (!W_ERROR_IS_OK(result)) {
9240                 return result;
9241         }
9242
9243         /* check for OID in valuename */
9244
9245         oid_string = strchr(r->in.value_name, ',');
9246         if (oid_string) {
9247                 *oid_string = '\0';
9248                 oid_string++;
9249         }
9250
9251         /* save the registry data */
9252
9253         result = set_printer_dataex(printer, r->in.key_name, r->in.value_name,
9254                                     r->in.type, r->in.buffer, r->in.offered);
9255
9256         if (W_ERROR_IS_OK(result)) {
9257                 /* save the OID if one was specified */
9258                 if (oid_string) {
9259                         char *str = talloc_asprintf(p->mem_ctx, "%s\\%s",
9260                                 r->in.key_name, SPOOL_OID_KEY);
9261                         if (!str) {
9262                                 result = WERR_NOMEM;
9263                                 goto done;
9264                         }
9265
9266                         /*
9267                          * I'm not checking the status here on purpose.  Don't know
9268                          * if this is right, but I'm returning the status from the
9269                          * previous set_printer_dataex() call.  I have no idea if
9270                          * this is right.    --jerry
9271                          */
9272
9273                         set_printer_dataex(printer, str, r->in.value_name,
9274                                            REG_SZ, (uint8_t *)oid_string,
9275                                            strlen(oid_string)+1);
9276                 }
9277
9278                 result = mod_a_printer(printer, 2);
9279         }
9280
9281  done:
9282         free_a_printer(&printer, 2);
9283
9284         return result;
9285 }
9286
9287 /****************************************************************
9288  _spoolss_DeletePrinterDataEx
9289 ****************************************************************/
9290
9291 WERROR _spoolss_DeletePrinterDataEx(pipes_struct *p,
9292                                     struct spoolss_DeletePrinterDataEx *r)
9293 {
9294         NT_PRINTER_INFO_LEVEL   *printer = NULL;
9295         int             snum=0;
9296         WERROR          status = WERR_OK;
9297         Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
9298
9299         DEBUG(5,("_spoolss_DeletePrinterDataEx\n"));
9300
9301         if (!Printer) {
9302                 DEBUG(2,("_spoolss_DeletePrinterDataEx: "
9303                         "Invalid handle (%s:%u:%u).\n",
9304                         OUR_HANDLE(r->in.handle)));
9305                 return WERR_BADFID;
9306         }
9307
9308         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
9309                 return WERR_BADFID;
9310
9311         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9312                 DEBUG(3, ("_spoolss_DeletePrinterDataEx: "
9313                         "printer properties change denied by handle\n"));
9314                 return WERR_ACCESS_DENIED;
9315         }
9316
9317         if (!r->in.value_name || !r->in.key_name) {
9318                 return WERR_NOMEM;
9319         }
9320
9321         status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9322         if (!W_ERROR_IS_OK(status))
9323                 return status;
9324
9325         status = delete_printer_dataex( printer, r->in.key_name, r->in.value_name );
9326
9327         if ( W_ERROR_IS_OK(status) )
9328                 mod_a_printer( printer, 2 );
9329
9330         free_a_printer(&printer, 2);
9331
9332         return status;
9333 }
9334
9335 /****************************************************************
9336  _spoolss_EnumPrinterKey
9337 ****************************************************************/
9338
9339 WERROR _spoolss_EnumPrinterKey(pipes_struct *p,
9340                                struct spoolss_EnumPrinterKey *r)
9341 {
9342         fstring         *keynames = NULL;
9343         int             num_keys;
9344         Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
9345         NT_PRINTER_DATA *data;
9346         NT_PRINTER_INFO_LEVEL   *printer = NULL;
9347         int             snum = 0;
9348         WERROR          result = WERR_BADFILE;
9349         int i;
9350         const char **array = NULL;
9351         DATA_BLOB blob;
9352
9353         DEBUG(4,("_spoolss_EnumPrinterKey\n"));
9354
9355         if (!Printer) {
9356                 DEBUG(2,("_spoolss_EnumPrinterKey: Invalid handle (%s:%u:%u).\n",
9357                         OUR_HANDLE(r->in.handle)));
9358                 return WERR_BADFID;
9359         }
9360
9361         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9362                 return WERR_BADFID;
9363         }
9364
9365         result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9366         if (!W_ERROR_IS_OK(result)) {
9367                 return result;
9368         }
9369
9370         /* get the list of subkey names */
9371
9372         data = printer->info_2->data;
9373
9374         num_keys = get_printer_subkeys(data, r->in.key_name, &keynames);
9375         if (num_keys == -1) {
9376                 result = WERR_BADFILE;
9377                 goto done;
9378         }
9379
9380         array = talloc_zero_array(r->out.key_buffer, const char *, num_keys + 2);
9381         if (!array) {
9382                 result = WERR_NOMEM;
9383                 goto done;
9384         }
9385
9386         if (!num_keys) {
9387                 array[0] = talloc_strdup(array, "");
9388                 if (!array[0]) {
9389                         result = WERR_NOMEM;
9390                         goto done;
9391                 }
9392         }
9393
9394         for (i=0; i < num_keys; i++) {
9395
9396                 DEBUG(10,("_spoolss_EnumPrinterKey: adding keyname: %s\n",
9397                         keynames[i]));
9398
9399                 array[i] = talloc_strdup(array, keynames[i]);
9400                 if (!array[i]) {
9401                         result = WERR_NOMEM;
9402                         goto done;
9403                 }
9404         }
9405
9406         if (!push_reg_multi_sz(p->mem_ctx, &blob, array)) {
9407                 result = WERR_NOMEM;
9408                 goto done;
9409         }
9410
9411         *r->out._ndr_size = r->in.offered / 2;
9412         *r->out.needed = blob.length;
9413
9414         if (r->in.offered < *r->out.needed) {
9415                 result = WERR_MORE_DATA;
9416         } else {
9417                 result = WERR_OK;
9418                 r->out.key_buffer->string_array = array;
9419         }
9420
9421  done:
9422         if (!W_ERROR_IS_OK(result)) {
9423                 TALLOC_FREE(array);
9424                 if (!W_ERROR_EQUAL(result, WERR_MORE_DATA)) {
9425                         *r->out.needed = 0;
9426                 }
9427         }
9428
9429         free_a_printer(&printer, 2);
9430         SAFE_FREE(keynames);
9431
9432         return result;
9433 }
9434
9435 /****************************************************************
9436  _spoolss_DeletePrinterKey
9437 ****************************************************************/
9438
9439 WERROR _spoolss_DeletePrinterKey(pipes_struct *p,
9440                                  struct spoolss_DeletePrinterKey *r)
9441 {
9442         Printer_entry           *Printer = find_printer_index_by_hnd(p, r->in.handle);
9443         NT_PRINTER_INFO_LEVEL   *printer = NULL;
9444         int                     snum=0;
9445         WERROR                  status;
9446
9447         DEBUG(5,("_spoolss_DeletePrinterKey\n"));
9448
9449         if (!Printer) {
9450                 DEBUG(2,("_spoolss_DeletePrinterKey: Invalid handle (%s:%u:%u).\n",
9451                         OUR_HANDLE(r->in.handle)));
9452                 return WERR_BADFID;
9453         }
9454
9455         /* if keyname == NULL, return error */
9456
9457         if ( !r->in.key_name )
9458                 return WERR_INVALID_PARAM;
9459
9460         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
9461                 return WERR_BADFID;
9462
9463         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9464                 DEBUG(3, ("_spoolss_DeletePrinterKey: "
9465                         "printer properties change denied by handle\n"));
9466                 return WERR_ACCESS_DENIED;
9467         }
9468
9469         status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9470         if (!W_ERROR_IS_OK(status))
9471                 return status;
9472
9473         /* delete the key and all subneys */
9474
9475         status = delete_all_printer_data( printer->info_2, r->in.key_name );
9476
9477         if ( W_ERROR_IS_OK(status) )
9478                 status = mod_a_printer(printer, 2);
9479
9480         free_a_printer( &printer, 2 );
9481
9482         return status;
9483 }
9484
9485 /****************************************************************
9486 ****************************************************************/
9487
9488 static WERROR registry_value_to_printer_enum_value(TALLOC_CTX *mem_ctx,
9489                                                    struct regval_blob *v,
9490                                                    struct spoolss_PrinterEnumValues *r)
9491 {
9492         WERROR result;
9493
9494         r->data = TALLOC_ZERO_P(mem_ctx, union spoolss_PrinterData);
9495         W_ERROR_HAVE_NO_MEMORY(r->data);
9496
9497         r->value_name   = talloc_strdup(mem_ctx, regval_name(v));
9498         W_ERROR_HAVE_NO_MEMORY(r->value_name);
9499
9500         r->type         = regval_type(v);
9501         r->data_length  = regval_size(v);
9502
9503         if (r->data_length) {
9504                 DATA_BLOB blob = data_blob_const(regval_data_p(v),
9505                                                  regval_size(v));
9506                 result = pull_spoolss_PrinterData(mem_ctx, &blob,
9507                                                   r->data,
9508                                                   r->type);
9509                 if (!W_ERROR_IS_OK(result)) {
9510                         return result;
9511                 }
9512         }
9513
9514         return WERR_OK;
9515 }
9516
9517 /****************************************************************
9518  _spoolss_EnumPrinterDataEx
9519 ****************************************************************/
9520
9521 WERROR _spoolss_EnumPrinterDataEx(pipes_struct *p,
9522                                   struct spoolss_EnumPrinterDataEx *r)
9523 {
9524         uint32_t        count = 0;
9525         NT_PRINTER_INFO_LEVEL   *printer = NULL;
9526         struct spoolss_PrinterEnumValues *info = NULL;
9527         NT_PRINTER_DATA         *p_data;
9528         Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
9529         int             snum;
9530         WERROR          result;
9531         int             key_index;
9532         int             i;
9533
9534         DEBUG(4,("_spoolss_EnumPrinterDataEx\n"));
9535
9536         *r->out.count = 0;
9537         *r->out.needed = 0;
9538         *r->out.info = NULL;
9539
9540         if (!Printer) {
9541                 DEBUG(2,("_spoolss_EnumPrinterDataEx: Invalid handle (%s:%u:%u1<).\n",
9542                         OUR_HANDLE(r->in.handle)));
9543                 return WERR_BADFID;
9544         }
9545
9546         /*
9547          * first check for a keyname of NULL or "".  Win2k seems to send
9548          * this a lot and we should send back WERR_INVALID_PARAM
9549          * no need to spend time looking up the printer in this case.
9550          * --jerry
9551          */
9552
9553         if (!strlen(r->in.key_name)) {
9554                 result = WERR_INVALID_PARAM;
9555                 goto done;
9556         }
9557
9558         /* get the printer off of disk */
9559
9560         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9561                 return WERR_BADFID;
9562         }
9563
9564         ZERO_STRUCT(printer);
9565         result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9566         if (!W_ERROR_IS_OK(result)) {
9567                 return result;
9568         }
9569
9570         /* now look for a match on the key name */
9571
9572         p_data = printer->info_2->data;
9573
9574         key_index = lookup_printerkey(p_data, r->in.key_name);
9575         if (key_index == -1) {
9576                 DEBUG(10,("_spoolss_EnumPrinterDataEx: Unknown keyname [%s]\n",
9577                         r->in.key_name));
9578                 result = WERR_INVALID_PARAM;
9579                 goto done;
9580         }
9581
9582         /* allocate the memory for the array of pointers -- if necessary */
9583
9584         count = regval_ctr_numvals(p_data->keys[key_index].values);
9585         if (!count) {
9586                 result = WERR_OK; /* ??? */
9587                 goto done;
9588         }
9589
9590         info = TALLOC_ZERO_ARRAY(p->mem_ctx,
9591                                  struct spoolss_PrinterEnumValues,
9592                                  count);
9593         if (!info) {
9594                 DEBUG(0,("_spoolss_EnumPrinterDataEx: talloc() failed\n"));
9595                 result = WERR_NOMEM;
9596                 goto done;
9597         }
9598
9599         /*
9600          * loop through all params and build the array to pass
9601          * back to the  client
9602          */
9603
9604         for (i=0; i < count; i++) {
9605
9606                 struct regval_blob      *val;
9607
9608                 /* lookup the registry value */
9609
9610                 val = regval_ctr_specific_value(p_data->keys[key_index].values, i);
9611
9612                 DEBUG(10,("retrieved value number [%d] [%s]\n", i, regval_name(val)));
9613
9614                 /* copy the data */
9615
9616                 result = registry_value_to_printer_enum_value(info, val, &info[i]);
9617                 if (!W_ERROR_IS_OK(result)) {
9618                         goto done;
9619                 }
9620         }
9621
9622 #if 0 /* FIXME - gd */
9623         /* housekeeping information in the reply */
9624
9625         /* Fix from Martin Zielinski <mz@seh.de> - ensure
9626          * the hand marshalled container size is a multiple
9627          * of 4 bytes for RPC alignment.
9628          */
9629
9630         if (needed % 4) {
9631                 needed += 4-(needed % 4);
9632         }
9633 #endif
9634         *r->out.count   = count;
9635         *r->out.info    = info;
9636
9637  done:
9638
9639         if (printer) {
9640                 free_a_printer(&printer, 2);
9641         }
9642
9643         if (!W_ERROR_IS_OK(result)) {
9644                 return result;
9645         }
9646
9647         *r->out.needed  = SPOOLSS_BUFFER_ARRAY(p->mem_ctx,
9648                                                spoolss_EnumPrinterDataEx, NULL,
9649                                                *r->out.info,
9650                                                *r->out.count);
9651         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
9652         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, *r->out.count);
9653
9654         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
9655 }
9656
9657 /****************************************************************************
9658 ****************************************************************************/
9659
9660 static WERROR getprintprocessordirectory_level_1(TALLOC_CTX *mem_ctx,
9661                                                  const char *servername,
9662                                                  const char *environment,
9663                                                  struct spoolss_PrintProcessorDirectoryInfo1 *r)
9664 {
9665         WERROR werr;
9666         char *path = NULL;
9667
9668         werr = compose_spoolss_server_path(mem_ctx,
9669                                            servername,
9670                                            environment,
9671                                            SPOOLSS_PRTPROCS_PATH,
9672                                            &path);
9673         if (!W_ERROR_IS_OK(werr)) {
9674                 return werr;
9675         }
9676
9677         DEBUG(4,("print processor directory: [%s]\n", path));
9678
9679         r->directory_name = path;
9680
9681         return WERR_OK;
9682 }
9683
9684 /****************************************************************
9685  _spoolss_GetPrintProcessorDirectory
9686 ****************************************************************/
9687
9688 WERROR _spoolss_GetPrintProcessorDirectory(pipes_struct *p,
9689                                            struct spoolss_GetPrintProcessorDirectory *r)
9690 {
9691         WERROR result;
9692
9693         /* that's an [in out] buffer */
9694
9695         if (!r->in.buffer && (r->in.offered != 0)) {
9696                 return WERR_INVALID_PARAM;
9697         }
9698
9699         DEBUG(5,("_spoolss_GetPrintProcessorDirectory: level %d\n",
9700                 r->in.level));
9701
9702         *r->out.needed = 0;
9703
9704         /* r->in.level is ignored */
9705
9706         /* We always should reply with a local print processor directory so that
9707          * users are not forced to have a [prnproc$] share on the Samba spoolss
9708          * server - Guenther */
9709
9710         result = getprintprocessordirectory_level_1(p->mem_ctx,
9711                                                     NULL, /* r->in.server */
9712                                                     r->in.environment,
9713                                                     &r->out.info->info1);
9714         if (!W_ERROR_IS_OK(result)) {
9715                 TALLOC_FREE(r->out.info);
9716                 return result;
9717         }
9718
9719         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_PrintProcessorDirectoryInfo, NULL,
9720                                                r->out.info, r->in.level);
9721         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
9722
9723         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
9724 }
9725
9726 /*******************************************************************
9727  ********************************************************************/
9728
9729 static bool push_monitorui_buf(TALLOC_CTX *mem_ctx, DATA_BLOB *buf,
9730                                const char *dllname)
9731 {
9732         enum ndr_err_code ndr_err;
9733         struct spoolss_MonitorUi ui;
9734
9735         ui.dll_name = dllname;
9736
9737         ndr_err = ndr_push_struct_blob(buf, mem_ctx, NULL, &ui,
9738                        (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorUi);
9739         if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9740                 NDR_PRINT_DEBUG(spoolss_MonitorUi, &ui);
9741         }
9742         return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9743 }
9744
9745 /*******************************************************************
9746  Streams the monitor UI DLL name in UNICODE
9747 *******************************************************************/
9748
9749 static WERROR xcvtcp_monitorui(TALLOC_CTX *mem_ctx,
9750                                NT_USER_TOKEN *token, DATA_BLOB *in,
9751                                DATA_BLOB *out, uint32_t *needed)
9752 {
9753         const char *dllname = "tcpmonui.dll";
9754
9755         *needed = (strlen(dllname)+1) * 2;
9756
9757         if (out->length < *needed) {
9758                 return WERR_INSUFFICIENT_BUFFER;
9759         }
9760
9761         if (!push_monitorui_buf(mem_ctx, out, dllname)) {
9762                 return WERR_NOMEM;
9763         }
9764
9765         return WERR_OK;
9766 }
9767
9768 /*******************************************************************
9769  ********************************************************************/
9770
9771 static bool pull_port_data_1(TALLOC_CTX *mem_ctx,
9772                              struct spoolss_PortData1 *port1,
9773                              const DATA_BLOB *buf)
9774 {
9775         enum ndr_err_code ndr_err;
9776         ndr_err = ndr_pull_struct_blob(buf, mem_ctx, NULL, port1,
9777                        (ndr_pull_flags_fn_t)ndr_pull_spoolss_PortData1);
9778         if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9779                 NDR_PRINT_DEBUG(spoolss_PortData1, port1);
9780         }
9781         return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9782 }
9783
9784 /*******************************************************************
9785  ********************************************************************/
9786
9787 static bool pull_port_data_2(TALLOC_CTX *mem_ctx,
9788                              struct spoolss_PortData2 *port2,
9789                              const DATA_BLOB *buf)
9790 {
9791         enum ndr_err_code ndr_err;
9792         ndr_err = ndr_pull_struct_blob(buf, mem_ctx, NULL, port2,
9793                        (ndr_pull_flags_fn_t)ndr_pull_spoolss_PortData2);
9794         if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9795                 NDR_PRINT_DEBUG(spoolss_PortData2, port2);
9796         }
9797         return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9798 }
9799
9800 /*******************************************************************
9801  Create a new TCP/IP port
9802 *******************************************************************/
9803
9804 static WERROR xcvtcp_addport(TALLOC_CTX *mem_ctx,
9805                              NT_USER_TOKEN *token, DATA_BLOB *in,
9806                              DATA_BLOB *out, uint32_t *needed)
9807 {
9808         struct spoolss_PortData1 port1;
9809         struct spoolss_PortData2 port2;
9810         char *device_uri = NULL;
9811         uint32_t version;
9812
9813         const char *portname;
9814         const char *hostaddress;
9815         const char *queue;
9816         uint32_t port_number;
9817         uint32_t protocol;
9818
9819         /* peek for spoolss_PortData version */
9820
9821         if (!in || (in->length < (128 + 4))) {
9822                 return WERR_GENERAL_FAILURE;
9823         }
9824
9825         version = IVAL(in->data, 128);
9826
9827         switch (version) {
9828                 case 1:
9829                         ZERO_STRUCT(port1);
9830
9831                         if (!pull_port_data_1(mem_ctx, &port1, in)) {
9832                                 return WERR_NOMEM;
9833                         }
9834
9835                         portname        = port1.portname;
9836                         hostaddress     = port1.hostaddress;
9837                         queue           = port1.queue;
9838                         protocol        = port1.protocol;
9839                         port_number     = port1.port_number;
9840
9841                         break;
9842                 case 2:
9843                         ZERO_STRUCT(port2);
9844
9845                         if (!pull_port_data_2(mem_ctx, &port2, in)) {
9846                                 return WERR_NOMEM;
9847                         }
9848
9849                         portname        = port2.portname;
9850                         hostaddress     = port2.hostaddress;
9851                         queue           = port2.queue;
9852                         protocol        = port2.protocol;
9853                         port_number     = port2.port_number;
9854
9855                         break;
9856                 default:
9857                         DEBUG(1,("xcvtcp_addport: "
9858                                 "unknown version of port_data: %d\n", version));
9859                         return WERR_UNKNOWN_PORT;
9860         }
9861
9862         /* create the device URI and call the add_port_hook() */
9863
9864         switch (protocol) {
9865         case PROTOCOL_RAWTCP_TYPE:
9866                 device_uri = talloc_asprintf(mem_ctx,
9867                                 "socket://%s:%d/", hostaddress,
9868                                 port_number);
9869                 break;
9870
9871         case PROTOCOL_LPR_TYPE:
9872                 device_uri = talloc_asprintf(mem_ctx,
9873                         "lpr://%s/%s", hostaddress, queue );
9874                 break;
9875
9876         default:
9877                 return WERR_UNKNOWN_PORT;
9878         }
9879
9880         if (!device_uri) {
9881                 return WERR_NOMEM;
9882         }
9883
9884         return add_port_hook(mem_ctx, token, portname, device_uri);
9885 }
9886
9887 /*******************************************************************
9888 *******************************************************************/
9889
9890 struct xcv_api_table xcvtcp_cmds[] = {
9891         { "MonitorUI",  xcvtcp_monitorui },
9892         { "AddPort",    xcvtcp_addport},
9893         { NULL,         NULL }
9894 };
9895
9896 static WERROR process_xcvtcp_command(TALLOC_CTX *mem_ctx,
9897                                      NT_USER_TOKEN *token, const char *command,
9898                                      DATA_BLOB *inbuf,
9899                                      DATA_BLOB *outbuf,
9900                                      uint32_t *needed )
9901 {
9902         int i;
9903
9904         DEBUG(10,("process_xcvtcp_command: Received command \"%s\"\n", command));
9905
9906         for ( i=0; xcvtcp_cmds[i].name; i++ ) {
9907                 if ( strcmp( command, xcvtcp_cmds[i].name ) == 0 )
9908                         return xcvtcp_cmds[i].fn(mem_ctx, token, inbuf, outbuf, needed);
9909         }
9910
9911         return WERR_BADFUNC;
9912 }
9913
9914 /*******************************************************************
9915 *******************************************************************/
9916 #if 0   /* don't support management using the "Local Port" monitor */
9917
9918 static WERROR xcvlocal_monitorui(TALLOC_CTX *mem_ctx,
9919                                  NT_USER_TOKEN *token, DATA_BLOB *in,
9920                                  DATA_BLOB *out, uint32_t *needed)
9921 {
9922         const char *dllname = "localui.dll";
9923
9924         *needed = (strlen(dllname)+1) * 2;
9925
9926         if (out->length < *needed) {
9927                 return WERR_INSUFFICIENT_BUFFER;
9928         }
9929
9930         if (!push_monitorui_buf(mem_ctx, out, dllname)) {
9931                 return WERR_NOMEM;
9932         }
9933
9934         return WERR_OK;
9935 }
9936
9937 /*******************************************************************
9938 *******************************************************************/
9939
9940 struct xcv_api_table xcvlocal_cmds[] = {
9941         { "MonitorUI",  xcvlocal_monitorui },
9942         { NULL,         NULL }
9943 };
9944 #else
9945 struct xcv_api_table xcvlocal_cmds[] = {
9946         { NULL,         NULL }
9947 };
9948 #endif
9949
9950
9951
9952 /*******************************************************************
9953 *******************************************************************/
9954
9955 static WERROR process_xcvlocal_command(TALLOC_CTX *mem_ctx,
9956                                        NT_USER_TOKEN *token, const char *command,
9957                                        DATA_BLOB *inbuf, DATA_BLOB *outbuf,
9958                                        uint32_t *needed)
9959 {
9960         int i;
9961
9962         DEBUG(10,("process_xcvlocal_command: Received command \"%s\"\n", command));
9963
9964         for ( i=0; xcvlocal_cmds[i].name; i++ ) {
9965                 if ( strcmp( command, xcvlocal_cmds[i].name ) == 0 )
9966                         return xcvlocal_cmds[i].fn(mem_ctx, token, inbuf, outbuf, needed);
9967         }
9968         return WERR_BADFUNC;
9969 }
9970
9971 /****************************************************************
9972  _spoolss_XcvData
9973 ****************************************************************/
9974
9975 WERROR _spoolss_XcvData(pipes_struct *p,
9976                         struct spoolss_XcvData *r)
9977 {
9978         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9979         DATA_BLOB out_data = data_blob_null;
9980         WERROR werror;
9981
9982         if (!Printer) {
9983                 DEBUG(2,("_spoolss_XcvData: Invalid handle (%s:%u:%u).\n",
9984                         OUR_HANDLE(r->in.handle)));
9985                 return WERR_BADFID;
9986         }
9987
9988         /* Has to be a handle to the TCP/IP port monitor */
9989
9990         if ( !(Printer->printer_type & (SPLHND_PORTMON_LOCAL|SPLHND_PORTMON_TCP)) ) {
9991                 DEBUG(2,("_spoolss_XcvData: Call only valid for Port Monitors\n"));
9992                 return WERR_BADFID;
9993         }
9994
9995         /* requires administrative access to the server */
9996
9997         if ( !(Printer->access_granted & SERVER_ACCESS_ADMINISTER) ) {
9998                 DEBUG(2,("_spoolss_XcvData: denied by handle permissions.\n"));
9999                 return WERR_ACCESS_DENIED;
10000         }
10001
10002         /* Allocate the outgoing buffer */
10003
10004         if (r->in.out_data_size) {
10005                 out_data = data_blob_talloc_zero(p->mem_ctx, r->in.out_data_size);
10006                 if (out_data.data == NULL) {
10007                         return WERR_NOMEM;
10008                 }
10009         }
10010
10011         switch ( Printer->printer_type ) {
10012         case SPLHND_PORTMON_TCP:
10013                 werror = process_xcvtcp_command(p->mem_ctx,
10014                                                 p->server_info->ptok,
10015                                                 r->in.function_name,
10016                                                 &r->in.in_data, &out_data,
10017                                                 r->out.needed);
10018                 break;
10019         case SPLHND_PORTMON_LOCAL:
10020                 werror = process_xcvlocal_command(p->mem_ctx,
10021                                                   p->server_info->ptok,
10022                                                   r->in.function_name,
10023                                                   &r->in.in_data, &out_data,
10024                                                   r->out.needed);
10025                 break;
10026         default:
10027                 werror = WERR_INVALID_PRINT_MONITOR;
10028         }
10029
10030         if (!W_ERROR_IS_OK(werror)) {
10031                 return werror;
10032         }
10033
10034         *r->out.status_code = 0;
10035
10036         if (r->out.out_data && out_data.data && r->in.out_data_size && out_data.length) {
10037                 memcpy(r->out.out_data, out_data.data,
10038                         MIN(r->in.out_data_size, out_data.length));
10039         }
10040
10041         return WERR_OK;
10042 }
10043
10044 /****************************************************************
10045  _spoolss_AddPrintProcessor
10046 ****************************************************************/
10047
10048 WERROR _spoolss_AddPrintProcessor(pipes_struct *p,
10049                                   struct spoolss_AddPrintProcessor *r)
10050 {
10051         /* for now, just indicate success and ignore the add.  We'll
10052            automatically set the winprint processor for printer
10053            entries later.  Used to debug the LexMark Optra S 1855 PCL
10054            driver --jerry */
10055
10056         return WERR_OK;
10057 }
10058
10059 /****************************************************************
10060  _spoolss_AddPort
10061 ****************************************************************/
10062
10063 WERROR _spoolss_AddPort(pipes_struct *p,
10064                         struct spoolss_AddPort *r)
10065 {
10066         /* do what w2k3 does */
10067
10068         return WERR_NOT_SUPPORTED;
10069 }
10070
10071 /****************************************************************
10072  _spoolss_AddPrinter
10073 ****************************************************************/
10074
10075 WERROR _spoolss_AddPrinter(pipes_struct *p,
10076                            struct spoolss_AddPrinter *r)
10077 {
10078         p->rng_fault_state = true;
10079         return WERR_NOT_SUPPORTED;
10080 }
10081
10082 /****************************************************************
10083  _spoolss_GetPrinterDriver
10084 ****************************************************************/
10085
10086 WERROR _spoolss_GetPrinterDriver(pipes_struct *p,
10087                                  struct spoolss_GetPrinterDriver *r)
10088 {
10089         p->rng_fault_state = true;
10090         return WERR_NOT_SUPPORTED;
10091 }
10092
10093 /****************************************************************
10094  _spoolss_ReadPrinter
10095 ****************************************************************/
10096
10097 WERROR _spoolss_ReadPrinter(pipes_struct *p,
10098                             struct spoolss_ReadPrinter *r)
10099 {
10100         p->rng_fault_state = true;
10101         return WERR_NOT_SUPPORTED;
10102 }
10103
10104 /****************************************************************
10105  _spoolss_WaitForPrinterChange
10106 ****************************************************************/
10107
10108 WERROR _spoolss_WaitForPrinterChange(pipes_struct *p,
10109                                      struct spoolss_WaitForPrinterChange *r)
10110 {
10111         p->rng_fault_state = true;
10112         return WERR_NOT_SUPPORTED;
10113 }
10114
10115 /****************************************************************
10116  _spoolss_ConfigurePort
10117 ****************************************************************/
10118
10119 WERROR _spoolss_ConfigurePort(pipes_struct *p,
10120                               struct spoolss_ConfigurePort *r)
10121 {
10122         p->rng_fault_state = true;
10123         return WERR_NOT_SUPPORTED;
10124 }
10125
10126 /****************************************************************
10127  _spoolss_DeletePort
10128 ****************************************************************/
10129
10130 WERROR _spoolss_DeletePort(pipes_struct *p,
10131                            struct spoolss_DeletePort *r)
10132 {
10133         p->rng_fault_state = true;
10134         return WERR_NOT_SUPPORTED;
10135 }
10136
10137 /****************************************************************
10138  _spoolss_CreatePrinterIC
10139 ****************************************************************/
10140
10141 WERROR _spoolss_CreatePrinterIC(pipes_struct *p,
10142                                 struct spoolss_CreatePrinterIC *r)
10143 {
10144         p->rng_fault_state = true;
10145         return WERR_NOT_SUPPORTED;
10146 }
10147
10148 /****************************************************************
10149  _spoolss_PlayGDIScriptOnPrinterIC
10150 ****************************************************************/
10151
10152 WERROR _spoolss_PlayGDIScriptOnPrinterIC(pipes_struct *p,
10153                                          struct spoolss_PlayGDIScriptOnPrinterIC *r)
10154 {
10155         p->rng_fault_state = true;
10156         return WERR_NOT_SUPPORTED;
10157 }
10158
10159 /****************************************************************
10160  _spoolss_DeletePrinterIC
10161 ****************************************************************/
10162
10163 WERROR _spoolss_DeletePrinterIC(pipes_struct *p,
10164                                 struct spoolss_DeletePrinterIC *r)
10165 {
10166         p->rng_fault_state = true;
10167         return WERR_NOT_SUPPORTED;
10168 }
10169
10170 /****************************************************************
10171  _spoolss_AddPrinterConnection
10172 ****************************************************************/
10173
10174 WERROR _spoolss_AddPrinterConnection(pipes_struct *p,
10175                                      struct spoolss_AddPrinterConnection *r)
10176 {
10177         p->rng_fault_state = true;
10178         return WERR_NOT_SUPPORTED;
10179 }
10180
10181 /****************************************************************
10182  _spoolss_DeletePrinterConnection
10183 ****************************************************************/
10184
10185 WERROR _spoolss_DeletePrinterConnection(pipes_struct *p,
10186                                         struct spoolss_DeletePrinterConnection *r)
10187 {
10188         p->rng_fault_state = true;
10189         return WERR_NOT_SUPPORTED;
10190 }
10191
10192 /****************************************************************
10193  _spoolss_PrinterMessageBox
10194 ****************************************************************/
10195
10196 WERROR _spoolss_PrinterMessageBox(pipes_struct *p,
10197                                   struct spoolss_PrinterMessageBox *r)
10198 {
10199         p->rng_fault_state = true;
10200         return WERR_NOT_SUPPORTED;
10201 }
10202
10203 /****************************************************************
10204  _spoolss_AddMonitor
10205 ****************************************************************/
10206
10207 WERROR _spoolss_AddMonitor(pipes_struct *p,
10208                            struct spoolss_AddMonitor *r)
10209 {
10210         p->rng_fault_state = true;
10211         return WERR_NOT_SUPPORTED;
10212 }
10213
10214 /****************************************************************
10215  _spoolss_DeleteMonitor
10216 ****************************************************************/
10217
10218 WERROR _spoolss_DeleteMonitor(pipes_struct *p,
10219                               struct spoolss_DeleteMonitor *r)
10220 {
10221         p->rng_fault_state = true;
10222         return WERR_NOT_SUPPORTED;
10223 }
10224
10225 /****************************************************************
10226  _spoolss_DeletePrintProcessor
10227 ****************************************************************/
10228
10229 WERROR _spoolss_DeletePrintProcessor(pipes_struct *p,
10230                                      struct spoolss_DeletePrintProcessor *r)
10231 {
10232         p->rng_fault_state = true;
10233         return WERR_NOT_SUPPORTED;
10234 }
10235
10236 /****************************************************************
10237  _spoolss_AddPrintProvidor
10238 ****************************************************************/
10239
10240 WERROR _spoolss_AddPrintProvidor(pipes_struct *p,
10241                                  struct spoolss_AddPrintProvidor *r)
10242 {
10243         p->rng_fault_state = true;
10244         return WERR_NOT_SUPPORTED;
10245 }
10246
10247 /****************************************************************
10248  _spoolss_DeletePrintProvidor
10249 ****************************************************************/
10250
10251 WERROR _spoolss_DeletePrintProvidor(pipes_struct *p,
10252                                     struct spoolss_DeletePrintProvidor *r)
10253 {
10254         p->rng_fault_state = true;
10255         return WERR_NOT_SUPPORTED;
10256 }
10257
10258 /****************************************************************
10259  _spoolss_FindFirstPrinterChangeNotification
10260 ****************************************************************/
10261
10262 WERROR _spoolss_FindFirstPrinterChangeNotification(pipes_struct *p,
10263                                                    struct spoolss_FindFirstPrinterChangeNotification *r)
10264 {
10265         p->rng_fault_state = true;
10266         return WERR_NOT_SUPPORTED;
10267 }
10268
10269 /****************************************************************
10270  _spoolss_FindNextPrinterChangeNotification
10271 ****************************************************************/
10272
10273 WERROR _spoolss_FindNextPrinterChangeNotification(pipes_struct *p,
10274                                                   struct spoolss_FindNextPrinterChangeNotification *r)
10275 {
10276         p->rng_fault_state = true;
10277         return WERR_NOT_SUPPORTED;
10278 }
10279
10280 /****************************************************************
10281  _spoolss_RouterFindFirstPrinterChangeNotificationOld
10282 ****************************************************************/
10283
10284 WERROR _spoolss_RouterFindFirstPrinterChangeNotificationOld(pipes_struct *p,
10285                                                             struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
10286 {
10287         p->rng_fault_state = true;
10288         return WERR_NOT_SUPPORTED;
10289 }
10290
10291 /****************************************************************
10292  _spoolss_ReplyOpenPrinter
10293 ****************************************************************/
10294
10295 WERROR _spoolss_ReplyOpenPrinter(pipes_struct *p,
10296                                  struct spoolss_ReplyOpenPrinter *r)
10297 {
10298         p->rng_fault_state = true;
10299         return WERR_NOT_SUPPORTED;
10300 }
10301
10302 /****************************************************************
10303  _spoolss_RouterReplyPrinter
10304 ****************************************************************/
10305
10306 WERROR _spoolss_RouterReplyPrinter(pipes_struct *p,
10307                                    struct spoolss_RouterReplyPrinter *r)
10308 {
10309         p->rng_fault_state = true;
10310         return WERR_NOT_SUPPORTED;
10311 }
10312
10313 /****************************************************************
10314  _spoolss_ReplyClosePrinter
10315 ****************************************************************/
10316
10317 WERROR _spoolss_ReplyClosePrinter(pipes_struct *p,
10318                                   struct spoolss_ReplyClosePrinter *r)
10319 {
10320         p->rng_fault_state = true;
10321         return WERR_NOT_SUPPORTED;
10322 }
10323
10324 /****************************************************************
10325  _spoolss_AddPortEx
10326 ****************************************************************/
10327
10328 WERROR _spoolss_AddPortEx(pipes_struct *p,
10329                           struct spoolss_AddPortEx *r)
10330 {
10331         p->rng_fault_state = true;
10332         return WERR_NOT_SUPPORTED;
10333 }
10334
10335 /****************************************************************
10336  _spoolss_RouterFindFirstPrinterChangeNotification
10337 ****************************************************************/
10338
10339 WERROR _spoolss_RouterFindFirstPrinterChangeNotification(pipes_struct *p,
10340                                                          struct spoolss_RouterFindFirstPrinterChangeNotification *r)
10341 {
10342         p->rng_fault_state = true;
10343         return WERR_NOT_SUPPORTED;
10344 }
10345
10346 /****************************************************************
10347  _spoolss_SpoolerInit
10348 ****************************************************************/
10349
10350 WERROR _spoolss_SpoolerInit(pipes_struct *p,
10351                             struct spoolss_SpoolerInit *r)
10352 {
10353         p->rng_fault_state = true;
10354         return WERR_NOT_SUPPORTED;
10355 }
10356
10357 /****************************************************************
10358  _spoolss_ResetPrinterEx
10359 ****************************************************************/
10360
10361 WERROR _spoolss_ResetPrinterEx(pipes_struct *p,
10362                                struct spoolss_ResetPrinterEx *r)
10363 {
10364         p->rng_fault_state = true;
10365         return WERR_NOT_SUPPORTED;
10366 }
10367
10368 /****************************************************************
10369  _spoolss_RouterReplyPrinterEx
10370 ****************************************************************/
10371
10372 WERROR _spoolss_RouterReplyPrinterEx(pipes_struct *p,
10373                                      struct spoolss_RouterReplyPrinterEx *r)
10374 {
10375         p->rng_fault_state = true;
10376         return WERR_NOT_SUPPORTED;
10377 }
10378
10379 /****************************************************************
10380  _spoolss_44
10381 ****************************************************************/
10382
10383 WERROR _spoolss_44(pipes_struct *p,
10384                    struct spoolss_44 *r)
10385 {
10386         p->rng_fault_state = true;
10387         return WERR_NOT_SUPPORTED;
10388 }
10389
10390 /****************************************************************
10391  _spoolss_47
10392 ****************************************************************/
10393
10394 WERROR _spoolss_47(pipes_struct *p,
10395                    struct spoolss_47 *r)
10396 {
10397         p->rng_fault_state = true;
10398         return WERR_NOT_SUPPORTED;
10399 }
10400
10401 /****************************************************************
10402  _spoolss_4a
10403 ****************************************************************/
10404
10405 WERROR _spoolss_4a(pipes_struct *p,
10406                    struct spoolss_4a *r)
10407 {
10408         p->rng_fault_state = true;
10409         return WERR_NOT_SUPPORTED;
10410 }
10411
10412 /****************************************************************
10413  _spoolss_4b
10414 ****************************************************************/
10415
10416 WERROR _spoolss_4b(pipes_struct *p,
10417                    struct spoolss_4b *r)
10418 {
10419         p->rng_fault_state = true;
10420         return WERR_NOT_SUPPORTED;
10421 }
10422
10423 /****************************************************************
10424  _spoolss_4c
10425 ****************************************************************/
10426
10427 WERROR _spoolss_4c(pipes_struct *p,
10428                    struct spoolss_4c *r)
10429 {
10430         p->rng_fault_state = true;
10431         return WERR_NOT_SUPPORTED;
10432 }
10433
10434 /****************************************************************
10435  _spoolss_53
10436 ****************************************************************/
10437
10438 WERROR _spoolss_53(pipes_struct *p,
10439                    struct spoolss_53 *r)
10440 {
10441         p->rng_fault_state = true;
10442         return WERR_NOT_SUPPORTED;
10443 }
10444
10445 /****************************************************************
10446  _spoolss_55
10447 ****************************************************************/
10448
10449 WERROR _spoolss_55(pipes_struct *p,
10450                    struct spoolss_55 *r)
10451 {
10452         p->rng_fault_state = true;
10453         return WERR_NOT_SUPPORTED;
10454 }
10455
10456 /****************************************************************
10457  _spoolss_56
10458 ****************************************************************/
10459
10460 WERROR _spoolss_56(pipes_struct *p,
10461                    struct spoolss_56 *r)
10462 {
10463         p->rng_fault_state = true;
10464         return WERR_NOT_SUPPORTED;
10465 }
10466
10467 /****************************************************************
10468  _spoolss_57
10469 ****************************************************************/
10470
10471 WERROR _spoolss_57(pipes_struct *p,
10472                    struct spoolss_57 *r)
10473 {
10474         p->rng_fault_state = true;
10475         return WERR_NOT_SUPPORTED;
10476 }
10477
10478 /****************************************************************
10479  _spoolss_5a
10480 ****************************************************************/
10481
10482 WERROR _spoolss_5a(pipes_struct *p,
10483                    struct spoolss_5a *r)
10484 {
10485         p->rng_fault_state = true;
10486         return WERR_NOT_SUPPORTED;
10487 }
10488
10489 /****************************************************************
10490  _spoolss_5b
10491 ****************************************************************/
10492
10493 WERROR _spoolss_5b(pipes_struct *p,
10494                    struct spoolss_5b *r)
10495 {
10496         p->rng_fault_state = true;
10497         return WERR_NOT_SUPPORTED;
10498 }
10499
10500 /****************************************************************
10501  _spoolss_5c
10502 ****************************************************************/
10503
10504 WERROR _spoolss_5c(pipes_struct *p,
10505                    struct spoolss_5c *r)
10506 {
10507         p->rng_fault_state = true;
10508         return WERR_NOT_SUPPORTED;
10509 }
10510
10511 /****************************************************************
10512  _spoolss_5d
10513 ****************************************************************/
10514
10515 WERROR _spoolss_5d(pipes_struct *p,
10516                    struct spoolss_5d *r)
10517 {
10518         p->rng_fault_state = true;
10519         return WERR_NOT_SUPPORTED;
10520 }
10521
10522 /****************************************************************
10523  _spoolss_5e
10524 ****************************************************************/
10525
10526 WERROR _spoolss_5e(pipes_struct *p,
10527                    struct spoolss_5e *r)
10528 {
10529         p->rng_fault_state = true;
10530         return WERR_NOT_SUPPORTED;
10531 }
10532
10533 /****************************************************************
10534  _spoolss_5f
10535 ****************************************************************/
10536
10537 WERROR _spoolss_5f(pipes_struct *p,
10538                    struct spoolss_5f *r)
10539 {
10540         p->rng_fault_state = true;
10541         return WERR_NOT_SUPPORTED;
10542 }
10543