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