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