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