source3/rpc_server/srv_spoolss_nt.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *  RPC Pipe client / server routines
   4  *  Copyright (C) Andrew Tridgell              1992-2000,
   5  *  Copyright (C) Luke Kenneth Casson Leighton 1996-2000,
   6  *  Copyright (C) Jean François Micouleau      1998-2000,
   7  *  Copyright (C) Jeremy Allison               2001-2002,
   8  *  Copyright (C) Gerald Carter                2000-2004,
   9  *  Copyright (C) Tim Potter                   2001-2002.
  10  *
  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                 /* don't use talloc_steal() here unless you do a deep steal of all
4175                    the SEC_DESC members */
4176
4177                 printer->secdesc = dup_sec_desc( get_talloc_ctx(),
4178                         ntprinter->info_2->secdesc_buf->sec );
4179         }
4180
4181         free_a_printer(&ntprinter, 2);
4182
4183         return True;
4184 }
4185
4186 /********************************************************************
4187  * construct_printer_info_3
4188  * fill a printer_info_3 struct
4189  ********************************************************************/
4190
4191 static BOOL construct_printer_info_3(Printer_entry *print_hnd, PRINTER_INFO_3 **pp_printer, int snum)
4192 {
4193         NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
4194         PRINTER_INFO_3 *printer = NULL;
4195
4196         if (!W_ERROR_IS_OK(get_a_printer(print_hnd, &ntprinter, 2, lp_const_servicename(snum))))
4197                 return False;
4198
4199         *pp_printer = NULL;
4200         if ((printer = SMB_MALLOC_P(PRINTER_INFO_3)) == NULL) {
4201                 DEBUG(2,("construct_printer_info_3: malloc fail.\n"));
4202                 return False;
4203         }
4204
4205         ZERO_STRUCTP(printer);
4206
4207         /* These are the components of the SD we are returning. */
4208
4209         printer->flags = 0x4;
4210
4211         if (ntprinter->info_2->secdesc_buf && ntprinter->info_2->secdesc_buf->len != 0) {
4212                 /* don't use talloc_steal() here unless you do a deep steal of all
4213                    the SEC_DESC members */
4214
4215                 printer->secdesc = dup_sec_desc( get_talloc_ctx(),
4216                         ntprinter->info_2->secdesc_buf->sec );
4217         }
4218
4219         free_a_printer(&ntprinter, 2);
4220
4221         *pp_printer = printer;
4222         return True;
4223 }
4224
4225 /********************************************************************
4226  * construct_printer_info_4
4227  * fill a printer_info_4 struct
4228  ********************************************************************/
4229
4230 static BOOL construct_printer_info_4(Printer_entry *print_hnd, PRINTER_INFO_4 *printer, int snum)
4231 {
4232         NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
4233
4234         if (!W_ERROR_IS_OK(get_a_printer(print_hnd, &ntprinter, 2, lp_const_servicename(snum))))
4235                 return False;
4236
4237         init_unistr(&printer->printername, ntprinter->info_2->printername);                             /* printername*/
4238         init_unistr(&printer->servername, ntprinter->info_2->servername); /* servername*/
4239         printer->attributes = ntprinter->info_2->attributes;
4240
4241         free_a_printer(&ntprinter, 2);
4242         return True;
4243 }
4244
4245 /********************************************************************
4246  * construct_printer_info_5
4247  * fill a printer_info_5 struct
4248  ********************************************************************/
4249
4250 static BOOL construct_printer_info_5(Printer_entry *print_hnd, PRINTER_INFO_5 *printer, int snum)
4251 {
4252         NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
4253
4254         if (!W_ERROR_IS_OK(get_a_printer(print_hnd, &ntprinter, 2, lp_const_servicename(snum))))
4255                 return False;
4256
4257         init_unistr(&printer->printername, ntprinter->info_2->printername);
4258         init_unistr(&printer->portname, ntprinter->info_2->portname);
4259         printer->attributes = ntprinter->info_2->attributes;
4260
4261         /* these two are not used by NT+ according to MSDN */
4262
4263         printer->device_not_selected_timeout = 0x0;  /* have seen 0x3a98 */
4264         printer->transmission_retry_timeout  = 0x0;  /* have seen 0xafc8 */
4265
4266         free_a_printer(&ntprinter, 2);
4267
4268         return True;
4269 }
4270
4271 /********************************************************************
4272  * construct_printer_info_7
4273  * fill a printer_info_7 struct
4274  ********************************************************************/
4275
4276 static BOOL construct_printer_info_7(Printer_entry *print_hnd, PRINTER_INFO_7 *printer, int snum)
4277 {
4278         char *guid_str = NULL;
4279         struct uuid guid;
4280
4281         if (is_printer_published(print_hnd, snum, &guid)) {
4282                 asprintf(&guid_str, "{%s}", smb_uuid_string_static(guid));
4283                 strupper_m(guid_str);
4284                 init_unistr(&printer->guid, guid_str);
4285                 printer->action = SPOOL_DS_PUBLISH;
4286         } else {
4287                 init_unistr(&printer->guid, "");
4288                 printer->action = SPOOL_DS_UNPUBLISH;
4289         }
4290
4291         return True;
4292 }
4293
4294 /********************************************************************
4295  Spoolss_enumprinters.
4296 ********************************************************************/
4297
4298 static WERROR enum_all_printers_info_1(uint32 flags, RPC_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
4299 {
4300         int snum;
4301         int i;
4302         int n_services=lp_numservices();
4303         PRINTER_INFO_1 *tp, *printers=NULL;
4304         PRINTER_INFO_1 current_prt;
4305         WERROR result = WERR_OK;
4306
4307         DEBUG(4,("enum_all_printers_info_1\n"));
4308
4309         for (snum=0; snum<n_services; snum++) {
4310                 if (lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum) ) {
4311                         DEBUG(4,("Found a printer in smb.conf: %s[%x]\n", lp_servicename(snum), snum));
4312
4313                         if (construct_printer_info_1(NULL, flags, &current_prt, snum)) {
4314                                 if((tp=SMB_REALLOC_ARRAY(printers, PRINTER_INFO_1, *returned +1)) == NULL) {
4315                                         DEBUG(2,("enum_all_printers_info_1: failed to enlarge printers buffer!\n"));
4316                                         SAFE_FREE(printers);
4317                                         *returned=0;
4318                                         return WERR_NOMEM;
4319                                 }
4320                                 else printers = tp;
4321                                 DEBUG(4,("ReAlloced memory for [%d] PRINTER_INFO_1\n", *returned));
4322
4323                                 memcpy(&printers[*returned], &current_prt, sizeof(PRINTER_INFO_1));
4324                                 (*returned)++;
4325                         }
4326                 }
4327         }
4328
4329         /* check the required size. */
4330         for (i=0; i<*returned; i++)
4331                 (*needed) += spoolss_size_printer_info_1(&printers[i]);
4332
4333         if (*needed > offered) {
4334                 result = WERR_INSUFFICIENT_BUFFER;
4335                 goto out;
4336         }
4337
4338         if (!rpcbuf_alloc_size(buffer, *needed)) {
4339                 result = WERR_NOMEM;
4340                 goto out;
4341         }
4342
4343         /* fill the buffer with the structures */
4344         for (i=0; i<*returned; i++)
4345                 smb_io_printer_info_1("", buffer, &printers[i], 0);
4346
4347 out:
4348         /* clear memory */
4349
4350         SAFE_FREE(printers);
4351
4352         if ( !W_ERROR_IS_OK(result) )
4353                 *returned = 0;
4354
4355         return result;
4356 }
4357
4358 /********************************************************************
4359  enum_all_printers_info_1_local.
4360 *********************************************************************/
4361
4362 static WERROR enum_all_printers_info_1_local(RPC_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
4363 {
4364         DEBUG(4,("enum_all_printers_info_1_local\n"));
4365
4366         return enum_all_printers_info_1(PRINTER_ENUM_ICON8, buffer, offered, needed, returned);
4367 }
4368
4369 /********************************************************************
4370  enum_all_printers_info_1_name.
4371 *********************************************************************/
4372
4373 static WERROR enum_all_printers_info_1_name(fstring name, RPC_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
4374 {
4375         char *s = name;
4376
4377         DEBUG(4,("enum_all_printers_info_1_name\n"));
4378
4379         if ((name[0] == '\\') && (name[1] == '\\'))
4380                 s = name + 2;
4381
4382         if (is_myname_or_ipaddr(s)) {
4383                 return enum_all_printers_info_1(PRINTER_ENUM_ICON8, buffer, offered, needed, returned);
4384         }
4385         else
4386                 return WERR_INVALID_NAME;
4387 }
4388
4389 #if 0   /* JERRY -- disabled for now.  Don't think this is used, tested, or correct */
4390 /********************************************************************
4391  enum_all_printers_info_1_remote.
4392 *********************************************************************/
4393
4394 static WERROR enum_all_printers_info_1_remote(fstring name, RPC_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
4395 {
4396         PRINTER_INFO_1 *printer;
4397         fstring printername;
4398         fstring desc;
4399         fstring comment;
4400         DEBUG(4,("enum_all_printers_info_1_remote\n"));
4401         WERROR result = WERR_OK;
4402
4403         /* JFM: currently it's more a place holder than anything else.
4404          * In the spooler world there is a notion of server registration.
4405          * the print servers are registered on the PDC (in the same domain)
4406          *
4407          * We should have a TDB here. The registration is done thru an
4408          * undocumented RPC call.
4409          */
4410
4411         if((printer=SMB_MALLOC_P(PRINTER_INFO_1)) == NULL)
4412                 return WERR_NOMEM;
4413
4414         *returned=1;
4415
4416         slprintf(printername, sizeof(printername)-1,"Windows NT Remote Printers!!\\\\%s", name);
4417         slprintf(desc, sizeof(desc)-1,"%s", name);
4418         slprintf(comment, sizeof(comment)-1, "Logged on Domain");
4419
4420         init_unistr(&printer->description, desc);
4421         init_unistr(&printer->name, printername);
4422         init_unistr(&printer->comment, comment);
4423         printer->flags=PRINTER_ENUM_ICON3|PRINTER_ENUM_CONTAINER;
4424
4425         /* check the required size. */
4426         *needed += spoolss_size_printer_info_1(printer);
4427
4428         if (*needed > offered) {
4429                 result = WERR_INSUFFICIENT_BUFFER;
4430                 goto out;
4431         }
4432
4433         if (!rpcbuf_alloc_size(buffer, *needed)) {
4434                 result = WERR_NOMEM;
4435                 goto out;
4436         }
4437
4438         /* fill the buffer with the structures */
4439         smb_io_printer_info_1("", buffer, printer, 0);
4440
4441 out:
4442         /* clear memory */
4443         SAFE_FREE(printer);
4444
4445         if ( !W_ERROR_IS_OK(result) )
4446                 *returned = 0;
4447
4448         return result;
4449 }
4450
4451 #endif
4452
4453 /********************************************************************
4454  enum_all_printers_info_1_network.
4455 *********************************************************************/
4456
4457 static WERROR enum_all_printers_info_1_network(fstring name, RPC_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
4458 {
4459         char *s = name;
4460
4461         DEBUG(4,("enum_all_printers_info_1_network\n"));
4462
4463         /* If we respond to a enum_printers level 1 on our name with flags
4464            set to PRINTER_ENUM_REMOTE with a list of printers then these
4465            printers incorrectly appear in the APW browse list.
4466            Specifically the printers for the server appear at the workgroup
4467            level where all the other servers in the domain are
4468            listed. Windows responds to this call with a
4469            WERR_CAN_NOT_COMPLETE so we should do the same. */
4470
4471         if (name[0] == '\\' && name[1] == '\\')
4472                  s = name + 2;
4473
4474         if (is_myname_or_ipaddr(s))
4475                  return WERR_CAN_NOT_COMPLETE;
4476
4477         return enum_all_printers_info_1(PRINTER_ENUM_UNKNOWN_8, buffer, offered, needed, returned);
4478 }
4479
4480 /********************************************************************
4481  * api_spoolss_enumprinters
4482  *
4483  * called from api_spoolss_enumprinters (see this to understand)
4484  ********************************************************************/
4485
4486 static WERROR enum_all_printers_info_2(RPC_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
4487 {
4488         int snum;
4489         int i;
4490         int n_services=lp_numservices();
4491         PRINTER_INFO_2 *tp, *printers=NULL;
4492         PRINTER_INFO_2 current_prt;
4493         WERROR result = WERR_OK;
4494
4495         for (snum=0; snum<n_services; snum++) {
4496                 if (lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum) ) {
4497                         DEBUG(4,("Found a printer in smb.conf: %s[%x]\n", lp_servicename(snum), snum));
4498
4499                         if (construct_printer_info_2(NULL, &current_prt, snum))
4500                         {
4501                                 if ( !(tp=SMB_REALLOC_ARRAY(printers, PRINTER_INFO_2, *returned +1)) ) {
4502                                         DEBUG(2,("enum_all_printers_info_2: failed to enlarge printers buffer!\n"));
4503                                         SAFE_FREE(printers);
4504                                         *returned = 0;
4505                                         return WERR_NOMEM;
4506                                 }
4507
4508                                 DEBUG(4,("ReAlloced memory for [%d] PRINTER_INFO_2\n", *returned));
4509
4510                                 printers = tp;
4511                                 memcpy(&printers[*returned], &current_prt, sizeof(PRINTER_INFO_2));
4512
4513                                 (*returned)++;
4514                         }
4515                 }
4516         }
4517
4518         /* check the required size. */
4519         for (i=0; i<*returned; i++)
4520                 (*needed) += spoolss_size_printer_info_2(&printers[i]);
4521
4522         if (*needed > offered) {
4523                 result = WERR_INSUFFICIENT_BUFFER;
4524                 goto out;
4525         }
4526
4527         if (!rpcbuf_alloc_size(buffer, *needed)) {
4528                 result = WERR_NOMEM;
4529                 goto out;
4530         }
4531
4532         /* fill the buffer with the structures */
4533         for (i=0; i<*returned; i++)
4534                 smb_io_printer_info_2("", buffer, &(printers[i]), 0);
4535
4536 out:
4537         /* clear memory */
4538
4539         for (i=0; i<*returned; i++)
4540                 free_devmode(printers[i].devmode);
4541
4542         SAFE_FREE(printers);
4543
4544         if ( !W_ERROR_IS_OK(result) )
4545                 *returned = 0;
4546
4547         return result;
4548 }
4549
4550 /********************************************************************
4551  * handle enumeration of printers at level 1
4552  ********************************************************************/
4553
4554 static WERROR enumprinters_level1( uint32 flags, fstring name,
4555                                  RPC_BUFFER *buffer, uint32 offered,
4556                                  uint32 *needed, uint32 *returned)
4557 {
4558         /* Not all the flags are equals */
4559
4560         if (flags & PRINTER_ENUM_LOCAL)
4561                 return enum_all_printers_info_1_local(buffer, offered, needed, returned);
4562
4563         if (flags & PRINTER_ENUM_NAME)
4564                 return enum_all_printers_info_1_name(name, buffer, offered, needed, returned);
4565
4566 #if 0   /* JERRY - disabled for now */
4567         if (flags & PRINTER_ENUM_REMOTE)
4568                 return enum_all_printers_info_1_remote(name, buffer, offered, needed, returned);
4569 #endif
4570
4571         if (flags & PRINTER_ENUM_NETWORK)
4572                 return enum_all_printers_info_1_network(name, buffer, offered, needed, returned);
4573
4574         return WERR_OK; /* NT4sp5 does that */
4575 }
4576
4577 /********************************************************************
4578  * handle enumeration of printers at level 2
4579  ********************************************************************/
4580
4581 static WERROR enumprinters_level2( uint32 flags, fstring servername,
4582                                  RPC_BUFFER *buffer, uint32 offered,
4583                                  uint32 *needed, uint32 *returned)
4584 {
4585         char *s = servername;
4586
4587         if (flags & PRINTER_ENUM_LOCAL) {
4588                         return enum_all_printers_info_2(buffer, offered, needed, returned);
4589         }
4590
4591         if (flags & PRINTER_ENUM_NAME) {
4592                 if ((servername[0] == '\\') && (servername[1] == '\\'))
4593                         s = servername + 2;
4594                 if (is_myname_or_ipaddr(s))
4595                         return enum_all_printers_info_2(buffer, offered, needed, returned);
4596                 else
4597                         return WERR_INVALID_NAME;
4598         }
4599
4600         if (flags & PRINTER_ENUM_REMOTE)
4601                 return WERR_UNKNOWN_LEVEL;
4602
4603         return WERR_OK;
4604 }
4605
4606 /********************************************************************
4607  * handle enumeration of printers at level 5
4608  ********************************************************************/
4609
4610 static WERROR enumprinters_level5( uint32 flags, fstring servername,
4611                                  RPC_BUFFER *buffer, uint32 offered,
4612                                  uint32 *needed, uint32 *returned)
4613 {
4614 /*      return enum_all_printers_info_5(buffer, offered, needed, returned);*/
4615         return WERR_OK;
4616 }
4617
4618 /********************************************************************
4619  * api_spoolss_enumprinters
4620  *
4621  * called from api_spoolss_enumprinters (see this to understand)
4622  ********************************************************************/
4623
4624 WERROR _spoolss_enumprinters( pipes_struct *p, SPOOL_Q_ENUMPRINTERS *q_u, SPOOL_R_ENUMPRINTERS *r_u)
4625 {
4626         uint32 flags = q_u->flags;
4627         UNISTR2 *servername = &q_u->servername;
4628         uint32 level = q_u->level;
4629         RPC_BUFFER *buffer = NULL;
4630         uint32 offered = q_u->offered;
4631         uint32 *needed = &r_u->needed;
4632         uint32 *returned = &r_u->returned;
4633
4634         fstring name;
4635
4636         /* that's an [in out] buffer */
4637
4638         if ( q_u->buffer ) {
4639                 rpcbuf_move(q_u->buffer, &r_u->buffer);
4640                 buffer = r_u->buffer;
4641         }
4642
4643         DEBUG(4,("_spoolss_enumprinters\n"));
4644
4645         *needed=0;
4646         *returned=0;
4647
4648         /*
4649          * Level 1:
4650          *          flags==PRINTER_ENUM_NAME
4651          *           if name=="" then enumerates all printers
4652          *           if name!="" then enumerate the printer
4653          *          flags==PRINTER_ENUM_REMOTE
4654          *          name is NULL, enumerate printers
4655          * Level 2: name!="" enumerates printers, name can't be NULL
4656          * Level 3: doesn't exist
4657          * Level 4: does a local registry lookup
4658          * Level 5: same as Level 2
4659          */
4660
4661         unistr2_to_ascii(name, servername, sizeof(name)-1);
4662         strupper_m(name);
4663
4664         switch (level) {
4665         case 1:
4666                 return enumprinters_level1(flags, name, buffer, offered, needed, returned);
4667         case 2:
4668                 return enumprinters_level2(flags, name, buffer, offered, needed, returned);
4669         case 5:
4670                 return enumprinters_level5(flags, name, buffer, offered, needed, returned);
4671         case 3:
4672         case 4:
4673                 break;
4674         }
4675         return WERR_UNKNOWN_LEVEL;
4676 }
4677
4678 /****************************************************************************
4679 ****************************************************************************/
4680
4681 static WERROR getprinter_level_0(Printer_entry *print_hnd, int snum, RPC_BUFFER *buffer, uint32 offered, uint32 *needed)
4682 {
4683         PRINTER_INFO_0 *printer=NULL;
4684         WERROR result = WERR_OK;
4685
4686         if((printer=SMB_MALLOC_P(PRINTER_INFO_0)) == NULL)
4687                 return WERR_NOMEM;
4688
4689         construct_printer_info_0(print_hnd, printer, snum);
4690
4691         /* check the required size. */
4692         *needed += spoolss_size_printer_info_0(printer);
4693
4694         if (*needed > offered) {
4695                 result = WERR_INSUFFICIENT_BUFFER;
4696                 goto out;
4697         }
4698
4699         if (!rpcbuf_alloc_size(buffer, *needed)) {
4700                 result = WERR_NOMEM;
4701                 goto out;
4702         }
4703
4704         /* fill the buffer with the structures */
4705         smb_io_printer_info_0("", buffer, printer, 0);
4706
4707 out:
4708         /* clear memory */
4709
4710         SAFE_FREE(printer);
4711
4712         return result;
4713 }
4714
4715 /****************************************************************************
4716 ****************************************************************************/
4717
4718 static WERROR getprinter_level_1(Printer_entry *print_hnd, int snum, RPC_BUFFER *buffer, uint32 offered, uint32 *needed)
4719 {
4720         PRINTER_INFO_1 *printer=NULL;
4721         WERROR result = WERR_OK;
4722
4723         if((printer=SMB_MALLOC_P(PRINTER_INFO_1)) == NULL)
4724                 return WERR_NOMEM;
4725
4726         construct_printer_info_1(print_hnd, PRINTER_ENUM_ICON8, printer, snum);
4727
4728         /* check the required size. */
4729         *needed += spoolss_size_printer_info_1(printer);
4730
4731         if (*needed > offered) {
4732                 result = WERR_INSUFFICIENT_BUFFER;
4733                 goto out;
4734         }
4735
4736         if (!rpcbuf_alloc_size(buffer, *needed)) {
4737                 result = WERR_NOMEM;
4738                 goto out;
4739         }
4740
4741         /* fill the buffer with the structures */
4742         smb_io_printer_info_1("", buffer, printer, 0);
4743
4744 out:
4745         /* clear memory */
4746         SAFE_FREE(printer);
4747
4748         return result;
4749 }
4750
4751 /****************************************************************************
4752 ****************************************************************************/
4753
4754 static WERROR getprinter_level_2(Printer_entry *print_hnd, int snum, RPC_BUFFER *buffer, uint32 offered, uint32 *needed)
4755 {
4756         PRINTER_INFO_2 *printer=NULL;
4757         WERROR result = WERR_OK;
4758
4759         if((printer=SMB_MALLOC_P(PRINTER_INFO_2))==NULL)
4760                 return WERR_NOMEM;
4761
4762         construct_printer_info_2(print_hnd, printer, snum);
4763
4764         /* check the required size. */
4765         *needed += spoolss_size_printer_info_2(printer);
4766
4767         if (*needed > offered) {
4768                 result = WERR_INSUFFICIENT_BUFFER;
4769                 goto out;
4770         }
4771
4772         if (!rpcbuf_alloc_size(buffer, *needed)) {
4773                 result = WERR_NOMEM;
4774                 goto out;
4775         }
4776
4777         /* fill the buffer with the structures */
4778         if (!smb_io_printer_info_2("", buffer, printer, 0))
4779                 result = WERR_NOMEM;
4780
4781 out:
4782         /* clear memory */
4783         free_printer_info_2(printer);
4784
4785         return result;
4786 }
4787
4788 /****************************************************************************
4789 ****************************************************************************/
4790
4791 static WERROR getprinter_level_3(Printer_entry *print_hnd, int snum, RPC_BUFFER *buffer, uint32 offered, uint32 *needed)
4792 {
4793         PRINTER_INFO_3 *printer=NULL;
4794         WERROR result = WERR_OK;
4795
4796         if (!construct_printer_info_3(print_hnd, &printer, snum))
4797                 return WERR_NOMEM;
4798
4799         /* check the required size. */
4800         *needed += spoolss_size_printer_info_3(printer);
4801
4802         if (*needed > offered) {
4803                 result = WERR_INSUFFICIENT_BUFFER;
4804                 goto out;
4805         }
4806
4807         if (!rpcbuf_alloc_size(buffer, *needed)) {
4808                 result = WERR_NOMEM;
4809                 goto out;
4810         }
4811
4812         /* fill the buffer with the structures */
4813         smb_io_printer_info_3("", buffer, printer, 0);
4814
4815 out:
4816         /* clear memory */
4817         free_printer_info_3(printer);
4818
4819         return result;
4820 }
4821
4822 /****************************************************************************
4823 ****************************************************************************/
4824
4825 static WERROR getprinter_level_4(Printer_entry *print_hnd, int snum, RPC_BUFFER *buffer, uint32 offered, uint32 *needed)
4826 {
4827         PRINTER_INFO_4 *printer=NULL;
4828         WERROR result = WERR_OK;
4829
4830         if((printer=SMB_MALLOC_P(PRINTER_INFO_4))==NULL)
4831                 return WERR_NOMEM;
4832
4833         if (!construct_printer_info_4(print_hnd, printer, snum))
4834                 return WERR_NOMEM;
4835
4836         /* check the required size. */
4837         *needed += spoolss_size_printer_info_4(printer);
4838
4839         if (*needed > offered) {
4840                 result = WERR_INSUFFICIENT_BUFFER;
4841                 goto out;
4842         }
4843
4844         if (!rpcbuf_alloc_size(buffer, *needed)) {
4845                 result = WERR_NOMEM;
4846                 goto out;
4847         }
4848
4849         /* fill the buffer with the structures */
4850         smb_io_printer_info_4("", buffer, printer, 0);
4851
4852 out:
4853         /* clear memory */
4854         free_printer_info_4(printer);
4855
4856         return result;
4857 }
4858
4859 /****************************************************************************
4860 ****************************************************************************/
4861
4862 static WERROR getprinter_level_5(Printer_entry *print_hnd, int snum, RPC_BUFFER *buffer, uint32 offered, uint32 *needed)
4863 {
4864         PRINTER_INFO_5 *printer=NULL;
4865         WERROR result = WERR_OK;
4866
4867         if((printer=SMB_MALLOC_P(PRINTER_INFO_5))==NULL)
4868                 return WERR_NOMEM;
4869
4870         if (!construct_printer_info_5(print_hnd, printer, snum))
4871                 return WERR_NOMEM;
4872
4873         /* check the required size. */
4874         *needed += spoolss_size_printer_info_5(printer);
4875
4876         if (*needed > offered) {
4877                 result = WERR_INSUFFICIENT_BUFFER;
4878                 goto out;
4879         }
4880
4881         if (!rpcbuf_alloc_size(buffer, *needed)) {
4882                 result = WERR_NOMEM;
4883                 goto out;
4884         }
4885
4886         /* fill the buffer with the structures */
4887         smb_io_printer_info_5("", buffer, printer, 0);
4888
4889 out:
4890         /* clear memory */
4891         free_printer_info_5(printer);
4892
4893         return result;
4894 }
4895
4896 static WERROR getprinter_level_7(Printer_entry *print_hnd, int snum, RPC_BUFFER *buffer, uint32 offered, uint32 *needed)
4897 {
4898         PRINTER_INFO_7 *printer=NULL;
4899         WERROR result = WERR_OK;
4900
4901         if((printer=SMB_MALLOC_P(PRINTER_INFO_7))==NULL)
4902                 return WERR_NOMEM;
4903
4904         if (!construct_printer_info_7(print_hnd, printer, snum))
4905                 return WERR_NOMEM;
4906
4907         /* check the required size. */
4908         *needed += spoolss_size_printer_info_7(printer);
4909
4910         if (*needed > offered) {
4911                 result = WERR_INSUFFICIENT_BUFFER;
4912                 goto out;
4913         }
4914
4915         if (!rpcbuf_alloc_size(buffer, *needed)) {
4916                 result = WERR_NOMEM;
4917                 goto out;
4918
4919         }
4920
4921         /* fill the buffer with the structures */
4922         smb_io_printer_info_7("", buffer, printer, 0);
4923
4924 out:
4925         /* clear memory */
4926         free_printer_info_7(printer);
4927
4928         return result;
4929 }
4930
4931 /****************************************************************************
4932 ****************************************************************************/
4933
4934 WERROR _spoolss_getprinter(pipes_struct *p, SPOOL_Q_GETPRINTER *q_u, SPOOL_R_GETPRINTER *r_u)
4935 {
4936         POLICY_HND *handle = &q_u->handle;
4937         uint32 level = q_u->level;
4938         RPC_BUFFER *buffer = NULL;
4939         uint32 offered = q_u->offered;
4940         uint32 *needed = &r_u->needed;
4941         Printer_entry *Printer=find_printer_index_by_hnd(p, handle);
4942
4943         int snum;
4944
4945         /* that's an [in out] buffer */
4946
4947         if ( q_u->buffer ) {
4948                 rpcbuf_move(q_u->buffer, &r_u->buffer);
4949                 buffer = r_u->buffer;
4950         }
4951
4952         *needed=0;
4953
4954         if (!get_printer_snum(p, handle, &snum))
4955                 return WERR_BADFID;
4956
4957         switch (level) {
4958         case 0:
4959                 return getprinter_level_0(Printer, snum, buffer, offered, needed);
4960         case 1:
4961                 return getprinter_level_1(Printer, snum, buffer, offered, needed);
4962         case 2:
4963                 return getprinter_level_2(Printer, snum, buffer, offered, needed);
4964         case 3:
4965                 return getprinter_level_3(Printer, snum, buffer, offered, needed);
4966         case 4:
4967                 return getprinter_level_4(Printer, snum, buffer, offered, needed);
4968         case 5:
4969                 return getprinter_level_5(Printer, snum, buffer, offered, needed);
4970         case 7:
4971                 return getprinter_level_7(Printer, snum, buffer, offered, needed);
4972         }
4973         return WERR_UNKNOWN_LEVEL;
4974 }
4975
4976 /********************************************************************
4977  * fill a DRIVER_INFO_1 struct
4978  ********************************************************************/
4979
4980 static void fill_printer_driver_info_1(DRIVER_INFO_1 *info, NT_PRINTER_DRIVER_INFO_LEVEL driver, fstring servername, fstring architecture)
4981 {
4982         init_unistr( &info->name, driver.info_3->name);
4983 }
4984
4985 /********************************************************************
4986  * construct_printer_driver_info_1
4987  ********************************************************************/
4988
4989 static WERROR construct_printer_driver_info_1(DRIVER_INFO_1 *info, int snum, fstring servername, fstring architecture, uint32 version)
4990 {
4991         NT_PRINTER_INFO_LEVEL *printer = NULL;
4992         NT_PRINTER_DRIVER_INFO_LEVEL driver;
4993
4994         ZERO_STRUCT(driver);
4995
4996         if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, lp_const_servicename(snum))))
4997                 return WERR_INVALID_PRINTER_NAME;
4998
4999         if (!W_ERROR_IS_OK(get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version)))
5000                 return WERR_UNKNOWN_PRINTER_DRIVER;
5001
5002         fill_printer_driver_info_1(info, driver, servername, architecture);
5003
5004         free_a_printer(&printer,2);
5005
5006         return WERR_OK;
5007 }
5008
5009 /********************************************************************
5010  * construct_printer_driver_info_2
5011  * fill a printer_info_2 struct
5012  ********************************************************************/
5013
5014 static void fill_printer_driver_info_2(DRIVER_INFO_2 *info, NT_PRINTER_DRIVER_INFO_LEVEL driver, fstring servername)
5015 {
5016         pstring temp;
5017
5018         info->version=driver.info_3->cversion;
5019
5020         init_unistr( &info->name, driver.info_3->name );
5021         init_unistr( &info->architecture, driver.info_3->environment );
5022
5023
5024     if (strlen(driver.info_3->driverpath)) {
5025                 slprintf(temp, sizeof(temp)-1, "\\\\%s%s", servername, driver.info_3->driverpath);
5026                 init_unistr( &info->driverpath, temp );
5027     } else
5028         init_unistr( &info->driverpath, "" );
5029
5030         if (strlen(driver.info_3->datafile)) {
5031                 slprintf(temp, sizeof(temp)-1, "\\\\%s%s", servername, driver.info_3->datafile);
5032                 init_unistr( &info->datafile, temp );
5033         } else
5034                 init_unistr( &info->datafile, "" );
5035
5036         if (strlen(driver.info_3->configfile)) {
5037                 slprintf(temp, sizeof(temp)-1, "\\\\%s%s", servername, driver.info_3->configfile);
5038                 init_unistr( &info->configfile, temp );
5039         } else
5040                 init_unistr( &info->configfile, "" );
5041 }
5042
5043 /********************************************************************
5044  * construct_printer_driver_info_2
5045  * fill a printer_info_2 struct
5046  ********************************************************************/
5047
5048 static WERROR construct_printer_driver_info_2(DRIVER_INFO_2 *info, int snum, fstring servername, fstring architecture, uint32 version)
5049 {
5050         NT_PRINTER_INFO_LEVEL *printer = NULL;
5051         NT_PRINTER_DRIVER_INFO_LEVEL driver;
5052
5053         ZERO_STRUCT(printer);
5054         ZERO_STRUCT(driver);
5055
5056         if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, lp_const_servicename(snum))))
5057                 return WERR_INVALID_PRINTER_NAME;
5058
5059         if (!W_ERROR_IS_OK(get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version)))
5060                 return WERR_UNKNOWN_PRINTER_DRIVER;
5061
5062         fill_printer_driver_info_2(info, driver, servername);
5063
5064         free_a_printer(&printer,2);
5065
5066         return WERR_OK;
5067 }
5068
5069 /********************************************************************
5070  * copy a strings array and convert to UNICODE
5071  *
5072  * convert an array of ascii string to a UNICODE string
5073  ********************************************************************/
5074
5075 static uint32 init_unistr_array(uint16 **uni_array, fstring *char_array, const char *servername)
5076 {
5077         int i=0;
5078         int j=0;
5079         const char *v;
5080         pstring line;
5081         uint16 *tuary;
5082
5083         DEBUG(6,("init_unistr_array\n"));
5084         *uni_array=NULL;
5085
5086         while (True)
5087         {
5088                 if ( !char_array )
5089                         v = "";
5090                 else
5091                 {
5092                         v = char_array[i];
5093                         if (!v)
5094                                 v = ""; /* hack to handle null lists */
5095                 }
5096
5097                 /* hack to allow this to be used in places other than when generating
5098                    the list of dependent files */
5099
5100                 if ( servername )
5101                         slprintf( line, sizeof(line)-1, "\\\\%s%s", servername, v );
5102                 else
5103                         pstrcpy( line, v );
5104
5105                 DEBUGADD(6,("%d:%s:%lu\n", i, line, (unsigned long)strlen(line)));
5106
5107                 /* add one extra unit16 for the second terminating NULL */
5108
5109                 if ( (tuary=SMB_REALLOC_ARRAY(*uni_array, uint16, j+1+strlen(line)+2)) == NULL ) {
5110                         DEBUG(2,("init_unistr_array: Realloc error\n" ));
5111                         return 0;
5112                 } else
5113                         *uni_array = tuary;
5114
5115                 if ( !strlen(v) )
5116                         break;
5117
5118                 j += (rpcstr_push((*uni_array+j), line, sizeof(uint16)*strlen(line)+2, STR_TERMINATE) / sizeof(uint16));
5119                 i++;
5120         }
5121
5122         if (*uni_array) {
5123                 /* special case for ""; we need to add both NULL's here */
5124                 if (!j)
5125                         (*uni_array)[j++]=0x0000;
5126                 (*uni_array)[j]=0x0000;
5127         }
5128
5129         DEBUGADD(6,("last one:done\n"));
5130
5131         /* return size of array in uint16's */
5132
5133         return j+1;
5134 }
5135
5136 /********************************************************************
5137  * construct_printer_info_3
5138  * fill a printer_info_3 struct
5139  ********************************************************************/
5140
5141 static void fill_printer_driver_info_3(DRIVER_INFO_3 *info, NT_PRINTER_DRIVER_INFO_LEVEL driver, fstring servername)
5142 {
5143         pstring temp;
5144
5145         ZERO_STRUCTP(info);
5146
5147         info->version=driver.info_3->cversion;
5148
5149         init_unistr( &info->name, driver.info_3->name );
5150         init_unistr( &info->architecture, driver.info_3->environment );
5151
5152         if (strlen(driver.info_3->driverpath)) {
5153                 slprintf(temp, sizeof(temp)-1, "\\\\%s%s", servername, driver.info_3->driverpath);
5154                 init_unistr( &info->driverpath, temp );
5155         } else
5156                 init_unistr( &info->driverpath, "" );
5157
5158         if (strlen(driver.info_3->datafile)) {
5159                 slprintf(temp, sizeof(temp)-1, "\\\\%s%s", servername, driver.info_3->datafile);
5160                 init_unistr( &info->datafile, temp );
5161         } else
5162                 init_unistr( &info->datafile, "" );
5163
5164         if (strlen(driver.info_3->configfile)) {
5165                 slprintf(temp, sizeof(temp)-1, "\\\\%s%s", servername, driver.info_3->configfile);
5166                 init_unistr( &info->configfile, temp );
5167         } else
5168                 init_unistr( &info->configfile, "" );
5169
5170         if (strlen(driver.info_3->helpfile)) {
5171                 slprintf(temp, sizeof(temp)-1, "\\\\%s%s", servername, driver.info_3->helpfile);
5172                 init_unistr( &info->helpfile, temp );
5173         } else
5174                 init_unistr( &info->helpfile, "" );
5175
5176         init_unistr( &info->monitorname, driver.info_3->monitorname );
5177         init_unistr( &info->defaultdatatype, driver.info_3->defaultdatatype );
5178
5179         info->dependentfiles=NULL;
5180         init_unistr_array(&info->dependentfiles, driver.info_3->dependentfiles, servername);
5181 }
5182
5183 /********************************************************************
5184  * construct_printer_info_3
5185  * fill a printer_info_3 struct
5186  ********************************************************************/
5187
5188 static WERROR construct_printer_driver_info_3(DRIVER_INFO_3 *info, int snum, fstring servername, fstring architecture, uint32 version)
5189 {
5190         NT_PRINTER_INFO_LEVEL *printer = NULL;
5191         NT_PRINTER_DRIVER_INFO_LEVEL driver;
5192         WERROR status;
5193         ZERO_STRUCT(driver);
5194
5195         status=get_a_printer(NULL, &printer, 2, lp_const_servicename(snum) );
5196         DEBUG(8,("construct_printer_driver_info_3: status: %s\n", dos_errstr(status)));
5197         if (!W_ERROR_IS_OK(status))
5198                 return WERR_INVALID_PRINTER_NAME;
5199
5200         status=get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
5201         DEBUG(8,("construct_printer_driver_info_3: status: %s\n", dos_errstr(status)));
5202
5203 #if 0   /* JERRY */
5204
5205         /*
5206          * I put this code in during testing.  Helpful when commenting out the
5207          * support for DRIVER_INFO_6 in regards to win2k.  Not needed in general
5208          * as win2k always queries the driver using an infor level of 6.
5209          * I've left it in (but ifdef'd out) because I'll probably
5210          * use it in experimentation again in the future.   --jerry 22/01/2002
5211          */
5212
5213         if (!W_ERROR_IS_OK(status)) {
5214                 /*
5215                  * Is this a W2k client ?
5216                  */
5217                 if (version == 3) {
5218                         /* Yes - try again with a WinNT driver. */
5219                         version = 2;
5220                         status=get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
5221                         DEBUG(8,("construct_printer_driver_info_3: status: %s\n", dos_errstr(status)));
5222                 }
5223 #endif
5224
5225                 if (!W_ERROR_IS_OK(status)) {
5226                         free_a_printer(&printer,2);
5227                         return WERR_UNKNOWN_PRINTER_DRIVER;
5228                 }
5229
5230 #if 0   /* JERRY */
5231         }
5232 #endif
5233
5234
5235         fill_printer_driver_info_3(info, driver, servername);
5236
5237         free_a_printer(&printer,2);
5238
5239         return WERR_OK;
5240 }
5241
5242 /********************************************************************
5243  * construct_printer_info_6
5244  * fill a printer_info_6 struct - we know that driver is really level 3. This sucks. JRA.
5245  ********************************************************************/
5246
5247 static void fill_printer_driver_info_6(DRIVER_INFO_6 *info, NT_PRINTER_DRIVER_INFO_LEVEL driver, fstring servername)
5248 {
5249         pstring temp;
5250         fstring nullstr;
5251
5252         ZERO_STRUCTP(info);
5253         memset(&nullstr, '\0', sizeof(fstring));
5254
5255         info->version=driver.info_3->cversion;
5256
5257         init_unistr( &info->name, driver.info_3->name );
5258         init_unistr( &info->architecture, driver.info_3->environment );
5259
5260         if (strlen(driver.info_3->driverpath)) {
5261                 slprintf(temp, sizeof(temp)-1, "\\\\%s%s", servername, driver.info_3->driverpath);
5262                 init_unistr( &info->driverpath, temp );
5263         } else
5264                 init_unistr( &info->driverpath, "" );
5265
5266         if (strlen(driver.info_3->datafile)) {
5267                 slprintf(temp, sizeof(temp)-1, "\\\\%s%s", servername, driver.info_3->datafile);
5268                 init_unistr( &info->datafile, temp );
5269         } else
5270                 init_unistr( &info->datafile, "" );
5271
5272         if (strlen(driver.info_3->configfile)) {
5273                 slprintf(temp, sizeof(temp)-1, "\\\\%s%s", servername, driver.info_3->configfile);
5274                 init_unistr( &info->configfile, temp );
5275         } else
5276                 init_unistr( &info->configfile, "" );
5277
5278         if (strlen(driver.info_3->helpfile)) {
5279                 slprintf(temp, sizeof(temp)-1, "\\\\%s%s", servername, driver.info_3->helpfile);
5280                 init_unistr( &info->helpfile, temp );
5281         } else
5282                 init_unistr( &info->helpfile, "" );
5283
5284         init_unistr( &info->monitorname, driver.info_3->monitorname );
5285         init_unistr( &info->defaultdatatype, driver.info_3->defaultdatatype );
5286
5287         info->dependentfiles = NULL;
5288         init_unistr_array( &info->dependentfiles, driver.info_3->dependentfiles, servername );
5289
5290         info->previousdrivernames=NULL;
5291         init_unistr_array(&info->previousdrivernames, &nullstr, servername);
5292
5293         info->driver_date.low=0;
5294         info->driver_date.high=0;
5295
5296         info->padding=0;
5297         info->driver_version_low=0;
5298         info->driver_version_high=0;
5299
5300         init_unistr( &info->mfgname, "");
5301         init_unistr( &info->oem_url, "");
5302         init_unistr( &info->hardware_id, "");
5303         init_unistr( &info->provider, "");
5304 }
5305
5306 /********************************************************************
5307  * construct_printer_info_6
5308  * fill a printer_info_6 struct
5309  ********************************************************************/
5310
5311 static WERROR construct_printer_driver_info_6(DRIVER_INFO_6 *info, int snum,
5312               fstring servername, fstring architecture, uint32 version)
5313 {
5314         NT_PRINTER_INFO_LEVEL           *printer = NULL;
5315         NT_PRINTER_DRIVER_INFO_LEVEL    driver;
5316         WERROR                          status;
5317
5318         ZERO_STRUCT(driver);
5319
5320         status=get_a_printer(NULL, &printer, 2, lp_const_servicename(snum) );
5321
5322         DEBUG(8,("construct_printer_driver_info_6: status: %s\n", dos_errstr(status)));
5323
5324         if (!W_ERROR_IS_OK(status))
5325                 return WERR_INVALID_PRINTER_NAME;
5326
5327         status = get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
5328
5329         DEBUG(8,("construct_printer_driver_info_6: status: %s\n", dos_errstr(status)));
5330
5331         if (!W_ERROR_IS_OK(status))
5332         {
5333                 /*
5334                  * Is this a W2k client ?
5335                  */
5336
5337                 if (version < 3) {
5338                         free_a_printer(&printer,2);
5339                         return WERR_UNKNOWN_PRINTER_DRIVER;
5340                 }
5341
5342                 /* Yes - try again with a WinNT driver. */
5343                 version = 2;
5344                 status=get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
5345                 DEBUG(8,("construct_printer_driver_info_6: status: %s\n", dos_errstr(status)));
5346                 if (!W_ERROR_IS_OK(status)) {
5347                         free_a_printer(&printer,2);
5348                         return WERR_UNKNOWN_PRINTER_DRIVER;
5349                 }
5350         }
5351
5352         fill_printer_driver_info_6(info, driver, servername);
5353
5354         free_a_printer(&printer,2);
5355         free_a_printer_driver(driver, 3);
5356
5357         return WERR_OK;
5358 }
5359
5360 /****************************************************************************
5361 ****************************************************************************/
5362
5363 static void free_printer_driver_info_3(DRIVER_INFO_3 *info)
5364 {
5365         SAFE_FREE(info->dependentfiles);
5366 }
5367
5368 /****************************************************************************
5369 ****************************************************************************/
5370
5371 static void free_printer_driver_info_6(DRIVER_INFO_6 *info)
5372 {
5373         SAFE_FREE(info->dependentfiles);
5374 }
5375
5376 /****************************************************************************
5377 ****************************************************************************/
5378
5379 static WERROR getprinterdriver2_level1(fstring servername, fstring architecture, uint32 version, int snum, RPC_BUFFER *buffer, uint32 offered, uint32 *needed)
5380 {
5381         DRIVER_INFO_1 *info=NULL;
5382         WERROR result;
5383
5384         if((info=SMB_MALLOC_P(DRIVER_INFO_1)) == NULL)
5385                 return WERR_NOMEM;
5386
5387         result = construct_printer_driver_info_1(info, snum, servername, architecture, version);
5388         if (!W_ERROR_IS_OK(result))
5389                 goto out;
5390
5391         /* check the required size. */
5392         *needed += spoolss_size_printer_driver_info_1(info);
5393
5394         if (*needed > offered) {
5395                 result = WERR_INSUFFICIENT_BUFFER;
5396                 goto out;
5397         }
5398
5399         if (!rpcbuf_alloc_size(buffer, *needed)) {
5400                 result = WERR_NOMEM;
5401                 goto out;
5402         }
5403
5404         /* fill the buffer with the structures */
5405         smb_io_printer_driver_info_1("", buffer, info, 0);
5406
5407 out:
5408         /* clear memory */
5409         SAFE_FREE(info);
5410
5411         return result;
5412 }
5413
5414 /****************************************************************************
5415 ****************************************************************************/
5416
5417 static WERROR getprinterdriver2_level2(fstring servername, fstring architecture, uint32 version, int snum, RPC_BUFFER *buffer, uint32 offered, uint32 *needed)
5418 {
5419         DRIVER_INFO_2 *info=NULL;
5420         WERROR result;
5421
5422         if((info=SMB_MALLOC_P(DRIVER_INFO_2)) == NULL)
5423                 return WERR_NOMEM;
5424
5425         result = construct_printer_driver_info_2(info, snum, servername, architecture, version);
5426         if (!W_ERROR_IS_OK(result))
5427                 goto out;
5428
5429         /* check the required size. */
5430         *needed += spoolss_size_printer_driver_info_2(info);
5431
5432         if (*needed > offered) {
5433                 result = WERR_INSUFFICIENT_BUFFER;
5434                 goto out;
5435         }
5436
5437         if (!rpcbuf_alloc_size(buffer, *needed)) {
5438                 result = WERR_NOMEM;
5439                 goto out;
5440         }
5441
5442         /* fill the buffer with the structures */
5443         smb_io_printer_driver_info_2("", buffer, info, 0);
5444
5445 out:
5446         /* clear memory */
5447         SAFE_FREE(info);
5448
5449         return result;
5450 }
5451
5452 /****************************************************************************
5453 ****************************************************************************/
5454
5455 static WERROR getprinterdriver2_level3(fstring servername, fstring architecture, uint32 version, int snum, RPC_BUFFER *buffer, uint32 offered, uint32 *needed)
5456 {
5457         DRIVER_INFO_3 info;
5458         WERROR result;
5459
5460         ZERO_STRUCT(info);
5461
5462         result = construct_printer_driver_info_3(&info, snum, servername, architecture, version);
5463         if (!W_ERROR_IS_OK(result))
5464                 goto out;
5465
5466         /* check the required size. */
5467         *needed += spoolss_size_printer_driver_info_3(&info);
5468
5469         if (*needed > offered) {
5470                 result = WERR_INSUFFICIENT_BUFFER;
5471                 goto out;
5472         }
5473
5474         if (!rpcbuf_alloc_size(buffer, *needed)) {
5475                 result = WERR_NOMEM;
5476                 goto out;
5477         }
5478
5479         /* fill the buffer with the structures */
5480         smb_io_printer_driver_info_3("", buffer, &info, 0);
5481
5482 out:
5483         free_printer_driver_info_3(&info);
5484
5485         return result;
5486 }
5487
5488 /****************************************************************************
5489 ****************************************************************************/
5490
5491 static WERROR getprinterdriver2_level6(fstring servername, fstring architecture, uint32 version, int snum, RPC_BUFFER *buffer, uint32 offered, uint32 *needed)
5492 {
5493         DRIVER_INFO_6 info;
5494         WERROR result;
5495
5496         ZERO_STRUCT(info);
5497
5498         result = construct_printer_driver_info_6(&info, snum, servername, architecture, version);
5499         if (!W_ERROR_IS_OK(result))
5500                 goto out;
5501
5502         /* check the required size. */
5503         *needed += spoolss_size_printer_driver_info_6(&info);
5504
5505         if (*needed > offered) {
5506                 result = WERR_INSUFFICIENT_BUFFER;
5507                 goto out;
5508         }
5509
5510         if (!rpcbuf_alloc_size(buffer, *needed)) {
5511                 result = WERR_NOMEM;
5512                 goto out;
5513         }
5514
5515         /* fill the buffer with the structures */
5516         smb_io_printer_driver_info_6("", buffer, &info, 0);
5517
5518 out:
5519         free_printer_driver_info_6(&info);
5520
5521         return result;
5522 }
5523
5524 /****************************************************************************
5525 ****************************************************************************/
5526
5527 WERROR _spoolss_getprinterdriver2(pipes_struct *p, SPOOL_Q_GETPRINTERDRIVER2 *q_u, SPOOL_R_GETPRINTERDRIVER2 *r_u)
5528 {
5529         POLICY_HND *handle = &q_u->handle;
5530         UNISTR2 *uni_arch = &q_u->architecture;
5531         uint32 level = q_u->level;
5532         uint32 clientmajorversion = q_u->clientmajorversion;
5533         RPC_BUFFER *buffer = NULL;
5534         uint32 offered = q_u->offered;
5535         uint32 *needed = &r_u->needed;
5536         uint32 *servermajorversion = &r_u->servermajorversion;
5537         uint32 *serverminorversion = &r_u->serverminorversion;
5538         Printer_entry *printer;
5539
5540         fstring servername;
5541         fstring architecture;
5542         int snum;
5543
5544         /* that's an [in out] buffer */
5545
5546         if ( q_u->buffer ) {
5547                 rpcbuf_move(q_u->buffer, &r_u->buffer);
5548                 buffer = r_u->buffer;
5549         }
5550
5551         DEBUG(4,("_spoolss_getprinterdriver2\n"));
5552
5553         if ( !(printer = find_printer_index_by_hnd( p, handle )) ) {
5554                 DEBUG(0,("_spoolss_getprinterdriver2: invalid printer handle!\n"));
5555                 return WERR_INVALID_PRINTER_NAME;
5556         }
5557
5558         *needed = 0;
5559         *servermajorversion = 0;
5560         *serverminorversion = 0;
5561
5562         fstrcpy(servername, get_server_name( printer ));
5563         unistr2_to_ascii(architecture, uni_arch, sizeof(architecture)-1);
5564
5565         if (!get_printer_snum(p, handle, &snum))
5566                 return WERR_BADFID;
5567
5568         switch (level) {
5569         case 1:
5570                 return getprinterdriver2_level1(servername, architecture, clientmajorversion, snum, buffer, offered, needed);
5571         case 2:
5572                 return getprinterdriver2_level2(servername, architecture, clientmajorversion, snum, buffer, offered, needed);
5573         case 3:
5574                 return getprinterdriver2_level3(servername, architecture, clientmajorversion, snum, buffer, offered, needed);
5575         case 6:
5576                 return getprinterdriver2_level6(servername, architecture, clientmajorversion, snum, buffer, offered, needed);
5577 #if 0   /* JERRY */
5578         case 101:
5579                 /* apparently this call is the equivalent of
5580                    EnumPrinterDataEx() for the DsDriver key */
5581                 break;
5582 #endif
5583         }
5584
5585         return WERR_UNKNOWN_LEVEL;
5586 }
5587
5588 /****************************************************************************
5589 ****************************************************************************/
5590
5591 WERROR _spoolss_startpageprinter(pipes_struct *p, SPOOL_Q_STARTPAGEPRINTER *q_u, SPOOL_R_STARTPAGEPRINTER *r_u)
5592 {
5593         POLICY_HND *handle = &q_u->handle;
5594
5595         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5596
5597         if (!Printer) {
5598                 DEBUG(3,("Error in startpageprinter printer handle\n"));
5599                 return WERR_BADFID;
5600         }
5601
5602         Printer->page_started=True;
5603         return WERR_OK;
5604 }
5605
5606 /****************************************************************************
5607 ****************************************************************************/
5608
5609 WERROR _spoolss_endpageprinter(pipes_struct *p, SPOOL_Q_ENDPAGEPRINTER *q_u, SPOOL_R_ENDPAGEPRINTER *r_u)
5610 {
5611         POLICY_HND *handle = &q_u->handle;
5612         int snum;
5613
5614         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5615
5616         if (!Printer) {
5617                 DEBUG(2,("_spoolss_endpageprinter: Invalid handle (%s:%u:%u).\n",OUR_HANDLE(handle)));
5618                 return WERR_BADFID;
5619         }
5620
5621         if (!get_printer_snum(p, handle, &snum))
5622                 return WERR_BADFID;
5623
5624         Printer->page_started=False;
5625         print_job_endpage(snum, Printer->jobid);
5626
5627         return WERR_OK;
5628 }
5629
5630 /********************************************************************
5631  * api_spoolss_getprinter
5632  * called from the spoolss dispatcher
5633  *
5634  ********************************************************************/
5635
5636 WERROR _spoolss_startdocprinter(pipes_struct *p, SPOOL_Q_STARTDOCPRINTER *q_u, SPOOL_R_STARTDOCPRINTER *r_u)
5637 {
5638         POLICY_HND *handle = &q_u->handle;
5639         DOC_INFO *docinfo = &q_u->doc_info_container.docinfo;
5640         uint32 *jobid = &r_u->jobid;
5641
5642         DOC_INFO_1 *info_1 = &docinfo->doc_info_1;
5643         int snum;
5644         pstring jobname;
5645         fstring datatype;
5646         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5647         struct current_user user;
5648
5649         if (!Printer) {
5650                 DEBUG(2,("_spoolss_startdocprinter: Invalid handle (%s:%u:%u)\n", OUR_HANDLE(handle)));
5651                 return WERR_BADFID;
5652         }
5653
5654         get_current_user(&user, p);
5655
5656         /*
5657          * a nice thing with NT is it doesn't listen to what you tell it.
5658          * when asked to send _only_ RAW datas, it tries to send datas
5659          * in EMF format.
5660          *
5661          * So I add checks like in NT Server ...
5662          */
5663
5664         if (info_1->p_datatype != 0) {
5665                 unistr2_to_ascii(datatype, &info_1->datatype, sizeof(datatype));
5666                 if (strcmp(datatype, "RAW") != 0) {
5667                         (*jobid)=0;
5668                         return WERR_INVALID_DATATYPE;
5669                 }
5670         }
5671
5672         /* get the share number of the printer */
5673         if (!get_printer_snum(p, handle, &snum)) {
5674                 return WERR_BADFID;
5675         }
5676
5677         unistr2_to_ascii(jobname, &info_1->docname, sizeof(jobname));
5678
5679         Printer->jobid = print_job_start(&user, snum, jobname, Printer->nt_devmode);
5680
5681         /* An error occured in print_job_start() so return an appropriate
5682            NT error code. */
5683
5684         if (Printer->jobid == -1) {
5685                 return map_werror_from_unix(errno);
5686         }
5687
5688         Printer->document_started=True;
5689         (*jobid) = Printer->jobid;
5690
5691         return WERR_OK;
5692 }
5693
5694 /********************************************************************
5695  * api_spoolss_getprinter
5696  * called from the spoolss dispatcher
5697  *
5698  ********************************************************************/
5699
5700 WERROR _spoolss_enddocprinter(pipes_struct *p, SPOOL_Q_ENDDOCPRINTER *q_u, SPOOL_R_ENDDOCPRINTER *r_u)
5701 {
5702         POLICY_HND *handle = &q_u->handle;
5703
5704         return _spoolss_enddocprinter_internal(p, handle);
5705 }
5706
5707 /****************************************************************************
5708 ****************************************************************************/
5709
5710 WERROR _spoolss_writeprinter(pipes_struct *p, SPOOL_Q_WRITEPRINTER *q_u, SPOOL_R_WRITEPRINTER *r_u)
5711 {
5712         POLICY_HND *handle = &q_u->handle;
5713         uint32 buffer_size = q_u->buffer_size;
5714         uint8 *buffer = q_u->buffer;
5715         uint32 *buffer_written = &q_u->buffer_size2;
5716         int snum;
5717         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5718
5719         if (!Printer) {
5720                 DEBUG(2,("_spoolss_writeprinter: Invalid handle (%s:%u:%u)\n",OUR_HANDLE(handle)));
5721                 r_u->buffer_written = q_u->buffer_size2;
5722                 return WERR_BADFID;
5723         }
5724
5725         if (!get_printer_snum(p, handle, &snum))
5726                 return WERR_BADFID;
5727
5728         (*buffer_written) = (uint32)print_job_write(snum, Printer->jobid, (const char *)buffer,
5729                                         (SMB_OFF_T)-1, (size_t)buffer_size);
5730         if (*buffer_written == (uint32)-1) {
5731                 r_u->buffer_written = 0;
5732                 if (errno == ENOSPC)
5733                         return WERR_NO_SPOOL_SPACE;
5734                 else
5735                         return WERR_ACCESS_DENIED;
5736         }
5737
5738         r_u->buffer_written = q_u->buffer_size2;
5739
5740         return WERR_OK;
5741 }
5742
5743 /********************************************************************
5744  * api_spoolss_getprinter
5745  * called from the spoolss dispatcher
5746  *
5747  ********************************************************************/
5748
5749 static WERROR control_printer(POLICY_HND *handle, uint32 command,
5750                               pipes_struct *p)
5751 {
5752         struct current_user user;
5753         int snum;
5754         WERROR errcode = WERR_BADFUNC;
5755         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5756
5757         get_current_user(&user, p);
5758
5759         if (!Printer) {
5760                 DEBUG(2,("control_printer: Invalid handle (%s:%u:%u)\n", OUR_HANDLE(handle)));
5761                 return WERR_BADFID;
5762         }
5763
5764         if (!get_printer_snum(p, handle, &snum))
5765                 return WERR_BADFID;
5766
5767         switch (command) {
5768         case PRINTER_CONTROL_PAUSE:
5769                 if (print_queue_pause(&user, snum, &errcode)) {
5770                         errcode = WERR_OK;
5771                 }
5772                 break;
5773         case PRINTER_CONTROL_RESUME:
5774         case PRINTER_CONTROL_UNPAUSE:
5775                 if (print_queue_resume(&user, snum, &errcode)) {
5776                         errcode = WERR_OK;
5777                 }
5778                 break;
5779         case PRINTER_CONTROL_PURGE:
5780                 if (print_queue_purge(&user, snum, &errcode)) {
5781                         errcode = WERR_OK;
5782                 }
5783                 break;
5784         default:
5785                 return WERR_UNKNOWN_LEVEL;
5786         }
5787
5788         return errcode;
5789 }
5790
5791 /********************************************************************
5792  * api_spoolss_abortprinter
5793  * From MSDN: "Deletes printer's spool file if printer is configured
5794  * for spooling"
5795  ********************************************************************/
5796
5797 WERROR _spoolss_abortprinter(pipes_struct *p, SPOOL_Q_ABORTPRINTER *q_u, SPOOL_R_ABORTPRINTER *r_u)
5798 {
5799         POLICY_HND      *handle = &q_u->handle;
5800         Printer_entry   *Printer = find_printer_index_by_hnd(p, handle);
5801         int             snum;
5802         struct          current_user user;
5803         WERROR          errcode = WERR_OK;
5804
5805         if (!Printer) {
5806                 DEBUG(2,("_spoolss_abortprinter: Invalid handle (%s:%u:%u)\n",OUR_HANDLE(handle)));
5807                 return WERR_BADFID;
5808         }
5809
5810         if (!get_printer_snum(p, handle, &snum))
5811                 return WERR_BADFID;
5812
5813         get_current_user( &user, p );
5814
5815         print_job_delete( &user, snum, Printer->jobid, &errcode );
5816
5817         return errcode;
5818 }
5819
5820 /********************************************************************
5821  * called by spoolss_api_setprinter
5822  * when updating a printer description
5823  ********************************************************************/
5824
5825 static WERROR update_printer_sec(POLICY_HND *handle, uint32 level,
5826                                  const SPOOL_PRINTER_INFO_LEVEL *info,
5827                                  pipes_struct *p, SEC_DESC_BUF *secdesc_ctr)
5828 {
5829         SEC_DESC_BUF *new_secdesc_ctr = NULL, *old_secdesc_ctr = NULL;
5830         WERROR result;
5831         int snum;
5832
5833         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5834
5835         if (!Printer || !get_printer_snum(p, handle, &snum)) {
5836                 DEBUG(2,("update_printer_sec: Invalid handle (%s:%u:%u)\n",
5837                          OUR_HANDLE(handle)));
5838
5839                 result = WERR_BADFID;
5840                 goto done;
5841         }
5842
5843         /* Check the user has permissions to change the security
5844            descriptor.  By experimentation with two NT machines, the user
5845            requires Full Access to the printer to change security
5846            information. */
5847
5848         if ( Printer->access_granted != PRINTER_ACCESS_ADMINISTER ) {
5849                 DEBUG(4,("update_printer_sec: updated denied by printer permissions\n"));
5850                 result = WERR_ACCESS_DENIED;
5851                 goto done;
5852         }
5853
5854         /* NT seems to like setting the security descriptor even though
5855            nothing may have actually changed. */
5856
5857         nt_printing_getsec(p->mem_ctx, Printer->sharename, &old_secdesc_ctr);
5858
5859         if (DEBUGLEVEL >= 10) {
5860                 SEC_ACL *the_acl;
5861                 int i;
5862
5863                 the_acl = old_secdesc_ctr->sec->dacl;
5864                 DEBUG(10, ("old_secdesc_ctr for %s has %d aces:\n",
5865                            PRINTERNAME(snum), the_acl->num_aces));
5866
5867                 for (i = 0; i < the_acl->num_aces; i++) {
5868                         fstring sid_str;
5869
5870                         sid_to_string(sid_str, &the_acl->ace[i].trustee);
5871
5872                         DEBUG(10, ("%s 0x%08x\n", sid_str,
5873                                   the_acl->ace[i].info.mask));
5874                 }
5875
5876                 the_acl = secdesc_ctr->sec->dacl;
5877
5878                 if (the_acl) {
5879                         DEBUG(10, ("secdesc_ctr for %s has %d aces:\n",
5880                                    PRINTERNAME(snum), the_acl->num_aces));
5881
5882                         for (i = 0; i < the_acl->num_aces; i++) {
5883                                 fstring sid_str;
5884
5885                                 sid_to_string(sid_str, &the_acl->ace[i].trustee);
5886
5887                                 DEBUG(10, ("%s 0x%08x\n", sid_str,
5888                                            the_acl->ace[i].info.mask));
5889                         }
5890                 } else {
5891                         DEBUG(10, ("dacl for secdesc_ctr is NULL\n"));
5892                 }
5893         }
5894
5895         new_secdesc_ctr = sec_desc_merge(p->mem_ctx, secdesc_ctr, old_secdesc_ctr);
5896
5897         if (sec_desc_equal(new_secdesc_ctr->sec, old_secdesc_ctr->sec)) {
5898                 result = WERR_OK;
5899                 goto done;
5900         }
5901
5902         result = nt_printing_setsec(Printer->sharename, new_secdesc_ctr);
5903
5904  done:
5905
5906         return result;
5907 }
5908
5909 /********************************************************************
5910  Canonicalize printer info from a client
5911
5912  ATTN: It does not matter what we set the servername to hear
5913  since we do the necessary work in get_a_printer() to set it to
5914  the correct value based on what the client sent in the
5915  _spoolss_open_printer_ex().
5916  ********************************************************************/
5917
5918 static BOOL check_printer_ok(NT_PRINTER_INFO_LEVEL_2 *info, int snum)
5919 {
5920         fstring printername;
5921         const char *p;
5922
5923         DEBUG(5,("check_printer_ok: servername=%s printername=%s sharename=%s "
5924                 "portname=%s drivername=%s comment=%s location=%s\n",
5925                 info->servername, info->printername, info->sharename,
5926                 info->portname, info->drivername, info->comment, info->location));
5927
5928         /* we force some elements to "correct" values */
5929         slprintf(info->servername, sizeof(info->servername)-1, "\\\\%s", global_myname());
5930         fstrcpy(info->sharename, lp_servicename(snum));
5931
5932         /* check to see if we allow printername != sharename */
5933
5934         if ( lp_force_printername(snum) ) {
5935                 slprintf(info->printername, sizeof(info->printername)-1, "\\\\%s\\%s",
5936                         global_myname(), info->sharename );
5937         } else {
5938
5939                 /* make sure printername is in \\server\printername format */
5940
5941                 fstrcpy( printername, info->printername );
5942                 p = printername;
5943                 if ( printername[0] == '\\' && printername[1] == '\\' ) {
5944                         if ( (p = strchr_m( &printername[2], '\\' )) != NULL )
5945                                 p++;
5946                 }
5947
5948                 slprintf(info->printername, sizeof(info->printername)-1, "\\\\%s\\%s",
5949                          global_myname(), p );
5950         }
5951
5952         info->attributes |= PRINTER_ATTRIBUTE_SAMBA;
5953         info->attributes &= ~PRINTER_ATTRIBUTE_NOT_SAMBA;
5954
5955
5956
5957         return True;
5958 }
5959
5960 /****************************************************************************
5961 ****************************************************************************/
5962
5963 BOOL add_printer_hook(NT_USER_TOKEN *token, NT_PRINTER_INFO_LEVEL *printer)
5964 {
5965         char *cmd = lp_addprinter_cmd();
5966         char **qlines;
5967         pstring command;
5968         int numlines;
5969         int ret;
5970         int fd;
5971         fstring remote_machine = "%m";
5972         SE_PRIV se_printop = SE_PRINT_OPERATOR;
5973         BOOL is_print_op = False;
5974
5975         standard_sub_basic(current_user_info.smb_name, remote_machine,sizeof(remote_machine));
5976
5977         slprintf(command, sizeof(command)-1, "%s \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"",
5978                         cmd, printer->info_2->printername, printer->info_2->sharename,
5979                         printer->info_2->portname, printer->info_2->drivername,
5980                         printer->info_2->location, printer->info_2->comment, remote_machine);
5981
5982         if ( token )
5983                 is_print_op = user_has_privileges( token, &se_printop );
5984
5985         DEBUG(10,("Running [%s]\n", command));
5986
5987         /********* BEGIN SePrintOperatorPrivilege **********/
5988
5989         if ( is_print_op )
5990                 become_root();
5991
5992         if ( (ret = smbrun(command, &fd)) == 0 ) {
5993                 /* Tell everyone we updated smb.conf. */
5994                 message_send_all(conn_tdb_ctx(), MSG_SMB_CONF_UPDATED, NULL, 0, False, NULL);
5995         }
5996
5997         if ( is_print_op )
5998                 unbecome_root();
5999
6000         /********* END SePrintOperatorPrivilege **********/
6001
6002         DEBUGADD(10,("returned [%d]\n", ret));
6003
6004         if ( ret != 0 ) {
6005                 if (fd != -1)
6006                         close(fd);
6007                 return False;
6008         }
6009
6010         /* reload our services immediately */
6011         reload_services( False );
6012
6013         numlines = 0;
6014         /* Get lines and convert them back to dos-codepage */
6015         qlines = fd_lines_load(fd, &numlines);
6016         DEBUGADD(10,("Lines returned = [%d]\n", numlines));
6017         close(fd);
6018
6019         /* Set the portname to what the script says the portname should be. */
6020         /* but don't require anything to be return from the script exit a good error code */
6021
6022         if (numlines) {
6023                 /* Set the portname to what the script says the portname should be. */
6024                 strncpy(printer->info_2->portname, qlines[0], sizeof(printer->info_2->portname));
6025                 DEBUGADD(6,("Line[0] = [%s]\n", qlines[0]));
6026         }
6027
6028         file_lines_free(qlines);
6029         return True;
6030 }
6031
6032 /********************************************************************
6033  * Called by spoolss_api_setprinter
6034  * when updating a printer description.
6035  ********************************************************************/
6036
6037 static WERROR update_printer(pipes_struct *p, POLICY_HND *handle, uint32 level,
6038                            const SPOOL_PRINTER_INFO_LEVEL *info,
6039                            DEVICEMODE *devmode)
6040 {
6041         int snum;
6042         NT_PRINTER_INFO_LEVEL *printer = NULL, *old_printer = NULL;
6043         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
6044         WERROR result;
6045         UNISTR2 buffer;
6046         fstring asc_buffer;
6047
6048         DEBUG(8,("update_printer\n"));
6049
6050         result = WERR_OK;
6051
6052         if (!Printer) {
6053                 result = WERR_BADFID;
6054                 goto done;
6055         }
6056
6057         if (!get_printer_snum(p, handle, &snum)) {
6058                 result = WERR_BADFID;
6059                 goto done;
6060         }
6061
6062         if (!W_ERROR_IS_OK(get_a_printer(Printer, &printer, 2, lp_const_servicename(snum))) ||
6063             (!W_ERROR_IS_OK(get_a_printer(Printer, &old_printer, 2, lp_const_servicename(snum))))) {
6064                 result = WERR_BADFID;
6065                 goto done;
6066         }
6067
6068         DEBUGADD(8,("Converting info_2 struct\n"));
6069
6070         /*
6071          * convert_printer_info converts the incoming
6072          * info from the client and overwrites the info
6073          * just read from the tdb in the pointer 'printer'.
6074          */
6075
6076         if (!convert_printer_info(info, printer, level)) {
6077                 result =  WERR_NOMEM;
6078                 goto done;
6079         }
6080
6081         if (devmode) {
6082                 /* we have a valid devmode
6083                    convert it and link it*/
6084
6085                 DEBUGADD(8,("update_printer: Converting the devicemode struct\n"));
6086                 if (!convert_devicemode(printer->info_2->printername, devmode,
6087                                 &printer->info_2->devmode)) {
6088                         result =  WERR_NOMEM;
6089                         goto done;
6090                 }
6091         }
6092
6093         /* Do sanity check on the requested changes for Samba */
6094
6095         if (!check_printer_ok(printer->info_2, snum)) {
6096                 result = WERR_INVALID_PARAM;
6097                 goto done;
6098         }
6099
6100         /* FIXME!!! If the driver has changed we really should verify that
6101            it is installed before doing much else   --jerry */
6102
6103         /* Check calling user has permission to update printer description */
6104
6105         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
6106                 DEBUG(3, ("update_printer: printer property change denied by handle\n"));
6107                 result = WERR_ACCESS_DENIED;
6108                 goto done;
6109         }
6110
6111         /* Call addprinter hook */
6112         /* Check changes to see if this is really needed */
6113
6114         if ( *lp_addprinter_cmd()
6115                 && (!strequal(printer->info_2->drivername, old_printer->info_2->drivername)
6116                         || !strequal(printer->info_2->comment, old_printer->info_2->comment)
6117                         || !strequal(printer->info_2->portname, old_printer->info_2->portname)
6118                         || !strequal(printer->info_2->location, old_printer->info_2->location)) )
6119         {
6120                 if ( !add_printer_hook(p->pipe_user.nt_user_token, printer) ) {
6121                         result = WERR_ACCESS_DENIED;
6122                         goto done;
6123                 }
6124
6125                 /*
6126                  * make sure we actually reload the services after
6127                  * this as smb.conf could have a new section in it
6128                  * .... shouldn't .... but could
6129                  */
6130                 reload_services(False);
6131         }
6132
6133         /*
6134          * When a *new* driver is bound to a printer, the drivername is used to
6135          * lookup previously saved driver initialization info, which is then
6136          * bound to the printer, simulating what happens in the Windows arch.
6137          */
6138         if (!strequal(printer->info_2->drivername, old_printer->info_2->drivername))
6139         {
6140                 if (!set_driver_init(printer, 2))
6141                 {
6142                         DEBUG(5,("update_printer: Error restoring driver initialization data for driver [%s]!\n",
6143                                 printer->info_2->drivername));
6144                 }
6145
6146                 DEBUG(10,("update_printer: changing driver [%s]!  Sending event!\n",
6147                         printer->info_2->drivername));
6148
6149                 notify_printer_driver(snum, printer->info_2->drivername);
6150         }
6151
6152         /*
6153          * flag which changes actually occured.  This is a small subset of
6154          * all the possible changes.  We also have to update things in the
6155          * DsSpooler key.
6156          */
6157
6158         if (!strequal(printer->info_2->comment, old_printer->info_2->comment)) {
6159                 init_unistr2( &buffer, printer->info_2->comment, UNI_STR_TERMINATE);
6160                 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "description",
6161                         REG_SZ, (uint8*)buffer.buffer, buffer.uni_str_len*2 );
6162
6163                 notify_printer_comment(snum, printer->info_2->comment);
6164         }
6165
6166         if (!strequal(printer->info_2->sharename, old_printer->info_2->sharename)) {
6167                 init_unistr2( &buffer, printer->info_2->sharename, UNI_STR_TERMINATE);
6168                 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "shareName",
6169                         REG_SZ, (uint8*)buffer.buffer, buffer.uni_str_len*2 );
6170
6171                 notify_printer_sharename(snum, printer->info_2->sharename);
6172         }
6173
6174         if (!strequal(printer->info_2->printername, old_printer->info_2->printername)) {
6175                 char *pname;
6176
6177                 if ( (pname = strchr_m( printer->info_2->printername+2, '\\' )) != NULL )
6178                         pname++;
6179                 else
6180                         pname = printer->info_2->printername;
6181
6182
6183                 init_unistr2( &buffer, pname, UNI_STR_TERMINATE);
6184                 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "printerName",
6185                         REG_SZ, (uint8*)buffer.buffer, buffer.uni_str_len*2 );
6186
6187                 notify_printer_printername( snum, pname );
6188         }
6189
6190         if (!strequal(printer->info_2->portname, old_printer->info_2->portname)) {
6191                 init_unistr2( &buffer, printer->info_2->portname, UNI_STR_TERMINATE);
6192                 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "portName",
6193                         REG_SZ, (uint8*)buffer.buffer, buffer.uni_str_len*2 );
6194
6195                 notify_printer_port(snum, printer->info_2->portname);
6196         }
6197
6198         if (!strequal(printer->info_2->location, old_printer->info_2->location)) {
6199                 init_unistr2( &buffer, printer->info_2->location, UNI_STR_TERMINATE);
6200                 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "location",
6201                         REG_SZ, (uint8*)buffer.buffer, buffer.uni_str_len*2 );
6202
6203                 notify_printer_location(snum, printer->info_2->location);
6204         }
6205
6206         /* here we need to update some more DsSpooler keys */
6207         /* uNCName, serverName, shortServerName */
6208
6209         init_unistr2( &buffer, global_myname(), UNI_STR_TERMINATE);
6210         set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "serverName",
6211                 REG_SZ, (uint8*)buffer.buffer, buffer.uni_str_len*2 );
6212         set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "shortServerName",
6213                 REG_SZ, (uint8*)buffer.buffer, buffer.uni_str_len*2 );
6214
6215         slprintf( asc_buffer, sizeof(asc_buffer)-1, "\\\\%s\\%s",
6216                  global_myname(), printer->info_2->sharename );
6217         init_unistr2( &buffer, asc_buffer, UNI_STR_TERMINATE);
6218         set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "uNCName",
6219                 REG_SZ, (uint8*)buffer.buffer, buffer.uni_str_len*2 );
6220
6221         /* Update printer info */
6222         result = mod_a_printer(printer, 2);
6223
6224 done:
6225         free_a_printer(&printer, 2);
6226         free_a_printer(&old_printer, 2);
6227
6228
6229         return result;
6230 }
6231
6232 /****************************************************************************
6233 ****************************************************************************/
6234 static WERROR publish_or_unpublish_printer(pipes_struct *p, POLICY_HND *handle,
6235                                    const SPOOL_PRINTER_INFO_LEVEL *info)
6236 {
6237 #ifdef HAVE_ADS
6238         SPOOL_PRINTER_INFO_LEVEL_7 *info7 = info->info_7;
6239         int snum;
6240         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
6241
6242         DEBUG(5,("publish_or_unpublish_printer, action = %d\n",info7->action));
6243
6244         if (!Printer)
6245                 return WERR_BADFID;
6246
6247         if (!get_printer_snum(p, handle, &snum))
6248                 return WERR_BADFID;
6249
6250         nt_printer_publish(Printer, snum, info7->action);
6251
6252         return WERR_OK;
6253 #else
6254         return WERR_UNKNOWN_LEVEL;
6255 #endif
6256 }
6257 /****************************************************************************
6258 ****************************************************************************/
6259
6260 WERROR _spoolss_setprinter(pipes_struct *p, SPOOL_Q_SETPRINTER *q_u, SPOOL_R_SETPRINTER *r_u)
6261 {
6262         POLICY_HND *handle = &q_u->handle;
6263         uint32 level = q_u->level;
6264         SPOOL_PRINTER_INFO_LEVEL *info = &q_u->info;
6265         DEVMODE_CTR devmode_ctr = q_u->devmode_ctr;
6266         SEC_DESC_BUF *secdesc_ctr = q_u->secdesc_ctr;
6267         uint32 command = q_u->command;
6268         WERROR result;
6269
6270         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
6271
6272         if (!Printer) {
6273                 DEBUG(2,("_spoolss_setprinter: Invalid handle (%s:%u:%u)\n", OUR_HANDLE(handle)));
6274                 return WERR_BADFID;
6275         }
6276
6277         /* check the level */
6278         switch (level) {
6279                 case 0:
6280                         return control_printer(handle, command, p);
6281                 case 2:
6282                         result = update_printer(p, handle, level, info, devmode_ctr.devmode);
6283                         if (!W_ERROR_IS_OK(result))
6284                                 return result;
6285                         if (secdesc_ctr)
6286                                 result = update_printer_sec(handle, level, info, p, secdesc_ctr);
6287                         return result;
6288                 case 3:
6289                         return update_printer_sec(handle, level, info, p,
6290                                                   secdesc_ctr);
6291                 case 7:
6292                         return publish_or_unpublish_printer(p, handle, info);
6293                 default:
6294                         return WERR_UNKNOWN_LEVEL;
6295         }
6296 }
6297
6298 /****************************************************************************
6299 ****************************************************************************/
6300
6301 WERROR _spoolss_fcpn(pipes_struct *p, SPOOL_Q_FCPN *q_u, SPOOL_R_FCPN *r_u)
6302 {
6303         POLICY_HND *handle = &q_u->handle;
6304         Printer_entry *Printer= find_printer_index_by_hnd(p, handle);
6305
6306         if (!Printer) {
6307                 DEBUG(2,("_spoolss_fcpn: Invalid handle (%s:%u:%u)\n", OUR_HANDLE(handle)));
6308                 return WERR_BADFID;
6309         }
6310
6311         if (Printer->notify.client_connected==True) {
6312                 int snum = -1;
6313
6314                 if ( Printer->printer_type == PRINTER_HANDLE_IS_PRINTSERVER)
6315                         snum = -1;
6316                 else if ( (Printer->printer_type == PRINTER_HANDLE_IS_PRINTER) &&
6317                                 !get_printer_snum(p, handle, &snum) )
6318                         return WERR_BADFID;
6319
6320                 srv_spoolss_replycloseprinter(snum, &Printer->notify.client_hnd);
6321         }
6322
6323         Printer->notify.flags=0;
6324         Printer->notify.options=0;
6325         Printer->notify.localmachine[0]='\0';
6326         Printer->notify.printerlocal=0;
6327         if (Printer->notify.option)
6328                 free_spool_notify_option(&Printer->notify.option);
6329         Printer->notify.client_connected=False;
6330
6331         return WERR_OK;
6332 }
6333
6334 /****************************************************************************
6335 ****************************************************************************/
6336
6337 WERROR _spoolss_addjob(pipes_struct *p, SPOOL_Q_ADDJOB *q_u, SPOOL_R_ADDJOB *r_u)
6338 {
6339         /* that's an [in out] buffer */
6340
6341         if ( q_u->buffer )
6342                 rpcbuf_move(q_u->buffer, &r_u->buffer);
6343
6344         r_u->needed = 0;
6345         return WERR_INVALID_PARAM; /* this is what a NT server
6346                                            returns for AddJob. AddJob
6347                                            must fail on non-local
6348                                            printers */
6349 }
6350
6351 /****************************************************************************
6352 ****************************************************************************/
6353
6354 static void fill_job_info_1(JOB_INFO_1 *job_info, print_queue_struct *queue,
6355                             int position, int snum,
6356                             NT_PRINTER_INFO_LEVEL *ntprinter)
6357 {
6358         struct tm *t;
6359
6360         t=gmtime(&queue->time);
6361
6362         job_info->jobid=queue->job;
6363         init_unistr(&job_info->printername, lp_servicename(snum));
6364         init_unistr(&job_info->machinename, ntprinter->info_2->servername);
6365         init_unistr(&job_info->username, queue->fs_user);
6366         init_unistr(&job_info->document, queue->fs_file);
6367         init_unistr(&job_info->datatype, "RAW");
6368         init_unistr(&job_info->text_status, "");
6369         job_info->status=nt_printj_status(queue->status);
6370         job_info->priority=queue->priority;
6371         job_info->position=position;
6372         job_info->totalpages=queue->page_count;
6373         job_info->pagesprinted=0;
6374
6375         make_systemtime(&job_info->submitted, t);
6376 }
6377
6378 /****************************************************************************
6379 ****************************************************************************/
6380
6381 static BOOL fill_job_info_2(JOB_INFO_2 *job_info, print_queue_struct *queue,
6382                             int position, int snum,
6383                             NT_PRINTER_INFO_LEVEL *ntprinter,
6384                             DEVICEMODE *devmode)
6385 {
6386         struct tm *t;
6387
6388         t=gmtime(&queue->time);
6389
6390         job_info->jobid=queue->job;
6391
6392         init_unistr(&job_info->printername, ntprinter->info_2->printername);
6393
6394         init_unistr(&job_info->machinename, ntprinter->info_2->servername);
6395         init_unistr(&job_info->username, queue->fs_user);
6396         init_unistr(&job_info->document, queue->fs_file);
6397         init_unistr(&job_info->notifyname, queue->fs_user);
6398         init_unistr(&job_info->datatype, "RAW");
6399         init_unistr(&job_info->printprocessor, "winprint");
6400         init_unistr(&job_info->parameters, "");
6401         init_unistr(&job_info->drivername, ntprinter->info_2->drivername);
6402         init_unistr(&job_info->text_status, "");
6403
6404 /* and here the security descriptor */
6405
6406         job_info->status=nt_printj_status(queue->status);
6407         job_info->priority=queue->priority;
6408         job_info->position=position;
6409         job_info->starttime=0;
6410         job_info->untiltime=0;
6411         job_info->totalpages=queue->page_count;
6412         job_info->size=queue->size;
6413         make_systemtime(&(job_info->submitted), t);
6414         job_info->timeelapsed=0;
6415         job_info->pagesprinted=0;
6416
6417         job_info->devmode = devmode;
6418
6419         return (True);
6420 }
6421
6422 /****************************************************************************
6423  Enumjobs at level 1.
6424 ****************************************************************************/
6425
6426 static WERROR enumjobs_level1(print_queue_struct *queue, int snum,
6427                               NT_PRINTER_INFO_LEVEL *ntprinter,
6428                               RPC_BUFFER *buffer, uint32 offered,
6429                               uint32 *needed, uint32 *returned)
6430 {
6431         JOB_INFO_1 *info;
6432         int i;
6433         WERROR result = WERR_OK;
6434
6435         info=SMB_MALLOC_ARRAY(JOB_INFO_1,*returned);
6436         if (info==NULL) {
6437                 SAFE_FREE(queue);
6438                 *returned=0;
6439                 return WERR_NOMEM;
6440         }
6441
6442         for (i=0; i<*returned; i++)
6443                 fill_job_info_1( &info[i], &queue[i], i, snum, ntprinter );
6444
6445         SAFE_FREE(queue);
6446
6447         /* check the required size. */
6448         for (i=0; i<*returned; i++)
6449                 (*needed) += spoolss_size_job_info_1(&info[i]);
6450
6451         if (*needed > offered) {
6452                 result = WERR_INSUFFICIENT_BUFFER;
6453                 goto out;
6454         }
6455
6456         if (!rpcbuf_alloc_size(buffer, *needed)) {
6457                 result = WERR_NOMEM;
6458                 goto out;
6459         }
6460
6461         /* fill the buffer with the structures */
6462         for (i=0; i<*returned; i++)
6463                 smb_io_job_info_1("", buffer, &info[i], 0);
6464
6465 out:
6466         /* clear memory */
6467         SAFE_FREE(info);
6468
6469         if ( !W_ERROR_IS_OK(result) )
6470                 *returned = 0;
6471
6472         return result;
6473 }
6474
6475 /****************************************************************************
6476  Enumjobs at level 2.
6477 ****************************************************************************/
6478
6479 static WERROR enumjobs_level2(print_queue_struct *queue, int snum,
6480                               NT_PRINTER_INFO_LEVEL *ntprinter,
6481                               RPC_BUFFER *buffer, uint32 offered,
6482                               uint32 *needed, uint32 *returned)
6483 {
6484         JOB_INFO_2 *info = NULL;
6485         int i;
6486         WERROR result = WERR_OK;
6487         DEVICEMODE *devmode = NULL;
6488
6489         if ( !(info = SMB_MALLOC_ARRAY(JOB_INFO_2,*returned)) ) {
6490                 *returned=0;
6491                 return WERR_NOMEM;
6492         }
6493
6494         /* this should not be a failure condition if the devmode is NULL */
6495
6496         devmode = construct_dev_mode(snum);
6497
6498         for (i=0; i<*returned; i++)
6499                 fill_job_info_2(&(info[i]), &queue[i], i, snum, ntprinter, devmode);
6500
6501         free_a_printer(&ntprinter, 2);
6502         SAFE_FREE(queue);
6503
6504         /* check the required size. */
6505         for (i=0; i<*returned; i++)
6506                 (*needed) += spoolss_size_job_info_2(&info[i]);
6507
6508         if (*needed > offered) {
6509                 result = WERR_INSUFFICIENT_BUFFER;
6510                 goto out;
6511         }
6512
6513         if (!rpcbuf_alloc_size(buffer, *needed)) {
6514                 result = WERR_NOMEM;
6515                 goto out;
6516         }
6517
6518         /* fill the buffer with the structures */
6519         for (i=0; i<*returned; i++)
6520                 smb_io_job_info_2("", buffer, &info[i], 0);
6521
6522 out:
6523         free_devmode(devmode);
6524         SAFE_FREE(info);
6525
6526         if ( !W_ERROR_IS_OK(result) )
6527                 *returned = 0;
6528
6529         return result;
6530
6531 }
6532
6533 /****************************************************************************
6534  Enumjobs.
6535 ****************************************************************************/
6536
6537 WERROR _spoolss_enumjobs( pipes_struct *p, SPOOL_Q_ENUMJOBS *q_u, SPOOL_R_ENUMJOBS *r_u)
6538 {
6539         POLICY_HND *handle = &q_u->handle;
6540         uint32 level = q_u->level;
6541         RPC_BUFFER *buffer = NULL;
6542         uint32 offered = q_u->offered;
6543         uint32 *needed = &r_u->needed;
6544         uint32 *returned = &r_u->returned;
6545         WERROR wret;
6546         NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
6547         int snum;
6548         print_status_struct prt_status;
6549         print_queue_struct *queue=NULL;
6550
6551         /* that's an [in out] buffer */
6552
6553         if ( q_u->buffer ) {
6554                 rpcbuf_move(q_u->buffer, &r_u->buffer);
6555                 buffer = r_u->buffer;
6556         }
6557
6558         DEBUG(4,("_spoolss_enumjobs\n"));
6559
6560         *needed=0;
6561         *returned=0;
6562
6563         /* lookup the printer snum and tdb entry */
6564
6565         if (!get_printer_snum(p, handle, &snum))
6566                 return WERR_BADFID;
6567
6568         wret = get_a_printer(NULL, &ntprinter, 2, lp_servicename(snum));
6569         if ( !W_ERROR_IS_OK(wret) )
6570                 return wret;
6571
6572         *returned = print_queue_status(snum, &queue, &prt_status);
6573         DEBUGADD(4,("count:[%d], status:[%d], [%s]\n", *returned, prt_status.status, prt_status.message));
6574
6575         if (*returned == 0) {
6576                 SAFE_FREE(queue);
6577                 return WERR_OK;
6578         }
6579
6580         switch (level) {
6581         case 1:
6582                 wret = enumjobs_level1(queue, snum, ntprinter, buffer, offered, needed, returned);
6583                 return wret;
6584         case 2:
6585                 wret = enumjobs_level2(queue, snum, ntprinter, buffer, offered, needed, returned);
6586                 return wret;
6587         default:
6588                 SAFE_FREE(queue);
6589                 *returned=0;
6590                 wret = WERR_UNKNOWN_LEVEL;
6591         }
6592
6593         free_a_printer( &ntprinter, 2 );
6594         return wret;
6595 }
6596
6597 /****************************************************************************
6598 ****************************************************************************/
6599
6600 WERROR _spoolss_schedulejob( pipes_struct *p, SPOOL_Q_SCHEDULEJOB *q_u, SPOOL_R_SCHEDULEJOB *r_u)
6601 {
6602         return WERR_OK;
6603 }
6604
6605 /****************************************************************************
6606 ****************************************************************************/
6607
6608 WERROR _spoolss_setjob(pipes_struct *p, SPOOL_Q_SETJOB *q_u, SPOOL_R_SETJOB *r_u)
6609 {
6610         POLICY_HND *handle = &q_u->handle;
6611         uint32 jobid = q_u->jobid;
6612         uint32 command = q_u->command;
6613
6614         struct current_user user;
6615         int snum;
6616         WERROR errcode = WERR_BADFUNC;
6617
6618         if (!get_printer_snum(p, handle, &snum)) {
6619                 return WERR_BADFID;
6620         }
6621
6622         if (!print_job_exists(lp_const_servicename(snum), jobid)) {
6623                 return WERR_INVALID_PRINTER_NAME;
6624         }
6625
6626         get_current_user(&user, p);
6627
6628         switch (command) {
6629         case JOB_CONTROL_CANCEL:
6630         case JOB_CONTROL_DELETE:
6631                 if (print_job_delete(&user, snum, jobid, &errcode)) {
6632                         errcode = WERR_OK;
6633                 }
6634                 break;
6635         case JOB_CONTROL_PAUSE:
6636                 if (print_job_pause(&user, snum, jobid, &errcode)) {
6637                         errcode = WERR_OK;
6638                 }
6639                 break;
6640         case JOB_CONTROL_RESTART:
6641         case JOB_CONTROL_RESUME:
6642                 if (print_job_resume(&user, snum, jobid, &errcode)) {
6643                         errcode = WERR_OK;
6644                 }
6645                 break;
6646         default:
6647                 return WERR_UNKNOWN_LEVEL;
6648         }
6649
6650         return errcode;
6651 }
6652
6653 /****************************************************************************
6654  Enumerates all printer drivers at level 1.
6655 ****************************************************************************/
6656
6657 static WERROR enumprinterdrivers_level1(fstring servername, fstring architecture, RPC_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
6658 {
6659         int i;
6660         int ndrivers;
6661         uint32 version;
6662         fstring *list = NULL;
6663         NT_PRINTER_DRIVER_INFO_LEVEL driver;
6664         DRIVER_INFO_1 *tdi1, *driver_info_1=NULL;
6665         WERROR result = WERR_OK;
6666
6667         *returned=0;
6668
6669         for (version=0; version<DRIVER_MAX_VERSION; version++) {
6670                 list=NULL;
6671                 ndrivers=get_ntdrivers(&list, architecture, version);
6672                 DEBUGADD(4,("we have:[%d] drivers in environment [%s] and version [%d]\n", ndrivers, architecture, version));
6673
6674                 if(ndrivers == -1)
6675                         return WERR_NOMEM;
6676
6677                 if(ndrivers != 0) {
6678                         if((tdi1=SMB_REALLOC_ARRAY(driver_info_1, DRIVER_INFO_1, *returned+ndrivers )) == NULL) {
6679                                 DEBUG(0,("enumprinterdrivers_level1: failed to enlarge driver info buffer!\n"));
6680                                 SAFE_FREE(driver_info_1);
6681                                 SAFE_FREE(list);
6682                                 return WERR_NOMEM;
6683                         }
6684                         else driver_info_1 = tdi1;
6685                 }
6686
6687                 for (i=0; i<ndrivers; i++) {
6688                         WERROR status;
6689                         DEBUGADD(5,("\tdriver: [%s]\n", list[i]));
6690                         ZERO_STRUCT(driver);
6691                         status = get_a_printer_driver(&driver, 3, list[i],
6692                                                       architecture, version);
6693                         if (!W_ERROR_IS_OK(status)) {
6694                                 SAFE_FREE(list);
6695                                 return status;
6696                         }
6697                         fill_printer_driver_info_1(&driver_info_1[*returned+i], driver, servername, architecture );
6698                         free_a_printer_driver(driver, 3);
6699                 }
6700
6701                 *returned+=ndrivers;
6702                 SAFE_FREE(list);
6703         }
6704
6705         /* check the required size. */
6706         for (i=0; i<*returned; i++) {
6707                 DEBUGADD(6,("adding driver [%d]'s size\n",i));
6708                 *needed += spoolss_size_printer_driver_info_1(&driver_info_1[i]);
6709         }
6710
6711         if (*needed > offered) {
6712                 result = WERR_INSUFFICIENT_BUFFER;
6713                 goto out;
6714         }
6715
6716         if (!rpcbuf_alloc_size(buffer, *needed)) {
6717                 result = WERR_NOMEM;
6718                 goto out;
6719         }
6720
6721         /* fill the buffer with the driver structures */
6722         for (i=0; i<*returned; i++) {
6723                 DEBUGADD(6,("adding driver [%d] to buffer\n",i));
6724                 smb_io_printer_driver_info_1("", buffer, &driver_info_1[i], 0);
6725         }
6726
6727 out:
6728         SAFE_FREE(driver_info_1);
6729
6730         if ( !W_ERROR_IS_OK(result) )
6731                 *returned = 0;
6732
6733         return result;
6734 }
6735
6736 /****************************************************************************
6737  Enumerates all printer drivers at level 2.
6738 ****************************************************************************/
6739
6740 static WERROR enumprinterdrivers_level2(fstring servername, fstring architecture, RPC_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
6741 {
6742         int i;
6743         int ndrivers;
6744         uint32 version;
6745         fstring *list = NULL;
6746         NT_PRINTER_DRIVER_INFO_LEVEL driver;
6747         DRIVER_INFO_2 *tdi2, *driver_info_2=NULL;
6748         WERROR result = WERR_OK;
6749
6750         *returned=0;
6751
6752         for (version=0; version<DRIVER_MAX_VERSION; version++) {
6753                 list=NULL;
6754                 ndrivers=get_ntdrivers(&list, architecture, version);
6755                 DEBUGADD(4,("we have:[%d] drivers in environment [%s] and version [%d]\n", ndrivers, architecture, version));
6756
6757                 if(ndrivers == -1)
6758                         return WERR_NOMEM;
6759
6760                 if(ndrivers != 0) {
6761                         if((tdi2=SMB_REALLOC_ARRAY(driver_info_2, DRIVER_INFO_2, *returned+ndrivers )) == NULL) {
6762                                 DEBUG(0,("enumprinterdrivers_level2: failed to enlarge driver info buffer!\n"));
6763                                 SAFE_FREE(driver_info_2);
6764                                 SAFE_FREE(list);
6765                                 return WERR_NOMEM;
6766                         }
6767                         else driver_info_2 = tdi2;
6768                 }
6769
6770                 for (i=0; i<ndrivers; i++) {
6771                         WERROR status;
6772
6773                         DEBUGADD(5,("\tdriver: [%s]\n", list[i]));
6774                         ZERO_STRUCT(driver);
6775                         status = get_a_printer_driver(&driver, 3, list[i],
6776                                                       architecture, version);
6777                         if (!W_ERROR_IS_OK(status)) {
6778                                 SAFE_FREE(list);
6779                                 return status;
6780                         }
6781                         fill_printer_driver_info_2(&driver_info_2[*returned+i], driver, servername);
6782                         free_a_printer_driver(driver, 3);
6783                 }
6784
6785                 *returned+=ndrivers;
6786                 SAFE_FREE(list);
6787         }
6788
6789         /* check the required size. */
6790         for (i=0; i<*returned; i++) {
6791                 DEBUGADD(6,("adding driver [%d]'s size\n",i));
6792                 *needed += spoolss_size_printer_driver_info_2(&(driver_info_2[i]));
6793         }
6794
6795         if (*needed > offered) {
6796                 result = WERR_INSUFFICIENT_BUFFER;
6797                 goto out;
6798         }
6799
6800         if (!rpcbuf_alloc_size(buffer, *needed)) {
6801                 result = WERR_NOMEM;
6802                 goto out;
6803         }
6804
6805         /* fill the buffer with the form structures */
6806         for (i=0; i<*returned; i++) {
6807                 DEBUGADD(6,("adding driver [%d] to buffer\n",i));
6808                 smb_io_printer_driver_info_2("", buffer, &(driver_info_2[i]), 0);
6809         }
6810
6811 out:
6812         SAFE_FREE(driver_info_2);
6813
6814         if ( !W_ERROR_IS_OK(result) )
6815                 *returned = 0;
6816
6817         return result;
6818 }
6819
6820 /****************************************************************************
6821  Enumerates all printer drivers at level 3.
6822 ****************************************************************************/
6823
6824 static WERROR enumprinterdrivers_level3(fstring servername, fstring architecture, RPC_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
6825 {
6826         int i;
6827         int ndrivers;
6828         uint32 version;
6829         fstring *list = NULL;
6830         NT_PRINTER_DRIVER_INFO_LEVEL driver;
6831         DRIVER_INFO_3 *tdi3, *driver_info_3=NULL;
6832         WERROR result = WERR_OK;
6833
6834         *returned=0;
6835
6836         for (version=0; version<DRIVER_MAX_VERSION; version++) {
6837                 list=NULL;
6838                 ndrivers=get_ntdrivers(&list, architecture, version);
6839                 DEBUGADD(4,("we have:[%d] drivers in environment [%s] and version [%d]\n", ndrivers, architecture, version));
6840
6841                 if(ndrivers == -1)
6842                         return WERR_NOMEM;
6843
6844                 if(ndrivers != 0) {
6845                         if((tdi3=SMB_REALLOC_ARRAY(driver_info_3, DRIVER_INFO_3, *returned+ndrivers )) == NULL) {
6846                                 DEBUG(0,("enumprinterdrivers_level3: failed to enlarge driver info buffer!\n"));
6847                                 SAFE_FREE(driver_info_3);
6848                                 SAFE_FREE(list);
6849                                 return WERR_NOMEM;
6850                         }
6851                         else driver_info_3 = tdi3;
6852                 }
6853
6854                 for (i=0; i<ndrivers; i++) {
6855                         WERROR status;
6856
6857                         DEBUGADD(5,("\tdriver: [%s]\n", list[i]));
6858                         ZERO_STRUCT(driver);
6859                         status = get_a_printer_driver(&driver, 3, list[i],
6860                                                       architecture, version);
6861                         if (!W_ERROR_IS_OK(status)) {
6862                                 SAFE_FREE(list);
6863                                 return status;
6864                         }
6865                         fill_printer_driver_info_3(&driver_info_3[*returned+i], driver, servername);
6866                         free_a_printer_driver(driver, 3);
6867                 }
6868
6869                 *returned+=ndrivers;
6870                 SAFE_FREE(list);
6871         }
6872
6873         /* check the required size. */
6874         for (i=0; i<*returned; i++) {
6875                 DEBUGADD(6,("adding driver [%d]'s size\n",i));
6876                 *needed += spoolss_size_printer_driver_info_3(&driver_info_3[i]);
6877         }
6878
6879         if (*needed > offered) {
6880                 result = WERR_INSUFFICIENT_BUFFER;
6881                 goto out;
6882         }
6883
6884         if (!rpcbuf_alloc_size(buffer, *needed)) {
6885                 result = WERR_NOMEM;
6886                 goto out;
6887         }
6888
6889         /* fill the buffer with the driver structures */
6890         for (i=0; i<*returned; i++) {
6891                 DEBUGADD(6,("adding driver [%d] to buffer\n",i));
6892                 smb_io_printer_driver_info_3("", buffer, &driver_info_3[i], 0);
6893         }
6894
6895 out:
6896         for (i=0; i<*returned; i++)
6897                 SAFE_FREE(driver_info_3[i].dependentfiles);
6898
6899         SAFE_FREE(driver_info_3);
6900
6901         if ( !W_ERROR_IS_OK(result) )
6902                 *returned = 0;
6903
6904         return result;
6905 }
6906
6907 /****************************************************************************
6908  Enumerates all printer drivers.
6909 ****************************************************************************/
6910
6911 WERROR _spoolss_enumprinterdrivers( pipes_struct *p, SPOOL_Q_ENUMPRINTERDRIVERS *q_u, SPOOL_R_ENUMPRINTERDRIVERS *r_u)
6912 {
6913         uint32 level = q_u->level;
6914         RPC_BUFFER *buffer = NULL;
6915         uint32 offered = q_u->offered;
6916         uint32 *needed = &r_u->needed;
6917         uint32 *returned = &r_u->returned;
6918
6919         fstring servername;
6920         fstring architecture;
6921
6922         /* that's an [in out] buffer */
6923
6924         if ( q_u->buffer ) {
6925                 rpcbuf_move(q_u->buffer, &r_u->buffer);
6926                 buffer = r_u->buffer;
6927         }
6928
6929         DEBUG(4,("_spoolss_enumprinterdrivers\n"));
6930
6931         *needed   = 0;
6932         *returned = 0;
6933
6934         unistr2_to_ascii(architecture, &q_u->environment, sizeof(architecture)-1);
6935         unistr2_to_ascii(servername, &q_u->name, sizeof(servername)-1);
6936
6937         if ( !is_myname_or_ipaddr( servername ) )
6938                 return WERR_UNKNOWN_PRINTER_DRIVER;
6939
6940         switch (level) {
6941         case 1:
6942                 return enumprinterdrivers_level1(servername, architecture, buffer, offered, needed, returned);
6943         case 2:
6944                 return enumprinterdrivers_level2(servername, architecture, buffer, offered, needed, returned);
6945         case 3:
6946                 return enumprinterdrivers_level3(servername, architecture, buffer, offered, needed, returned);
6947         default:
6948                 return WERR_UNKNOWN_LEVEL;
6949         }
6950 }
6951
6952 /****************************************************************************
6953 ****************************************************************************/
6954
6955 static void fill_form_1(FORM_1 *form, nt_forms_struct *list)
6956 {
6957         form->flag=list->flag;
6958         init_unistr(&form->name, list->name);
6959         form->width=list->width;
6960         form->length=list->length;
6961         form->left=list->left;
6962         form->top=list->top;
6963         form->right=list->right;
6964         form->bottom=list->bottom;
6965 }
6966
6967 /****************************************************************************
6968 ****************************************************************************/
6969
6970 WERROR _spoolss_enumforms(pipes_struct *p, SPOOL_Q_ENUMFORMS *q_u, SPOOL_R_ENUMFORMS *r_u)
6971 {
6972         uint32 level = q_u->level;
6973         RPC_BUFFER *buffer = NULL;
6974         uint32 offered = q_u->offered;
6975         uint32 *needed = &r_u->needed;
6976         uint32 *numofforms = &r_u->numofforms;
6977         uint32 numbuiltinforms;
6978
6979         nt_forms_struct *list=NULL;
6980         nt_forms_struct *builtinlist=NULL;
6981         FORM_1 *forms_1;
6982         int buffer_size=0;
6983         int i;
6984
6985         /* that's an [in out] buffer */
6986
6987         if ( q_u->buffer ) {
6988                 rpcbuf_move(q_u->buffer, &r_u->buffer);
6989                 buffer = r_u->buffer;
6990         }
6991
6992         DEBUG(4,("_spoolss_enumforms\n"));
6993         DEBUGADD(5,("Offered buffer size [%d]\n", offered));
6994         DEBUGADD(5,("Info level [%d]\n",          level));
6995
6996         numbuiltinforms = get_builtin_ntforms(&builtinlist);
6997         DEBUGADD(5,("Number of builtin forms [%d]\n",     numbuiltinforms));
6998         *numofforms = get_ntforms(&list);
6999         DEBUGADD(5,("Number of user forms [%d]\n",     *numofforms));
7000         *numofforms += numbuiltinforms;
7001
7002         if (*numofforms == 0)
7003                 return WERR_NO_MORE_ITEMS;
7004
7005         switch (level) {
7006         case 1:
7007                 if ((forms_1=SMB_MALLOC_ARRAY(FORM_1, *numofforms)) == NULL) {
7008                         *numofforms=0;
7009                         return WERR_NOMEM;
7010                 }
7011
7012                 /* construct the list of form structures */
7013                 for (i=0; i<numbuiltinforms; i++) {
7014                         DEBUGADD(6,("Filling form number [%d]\n",i));
7015                         fill_form_1(&forms_1[i], &builtinlist[i]);
7016                 }
7017
7018                 SAFE_FREE(builtinlist);
7019
7020                 for (; i<*numofforms; i++) {
7021                         DEBUGADD(6,("Filling form number [%d]\n",i));
7022                         fill_form_1(&forms_1[i], &list[i-numbuiltinforms]);
7023                 }
7024
7025                 SAFE_FREE(list);
7026
7027                 /* check the required size. */
7028                 for (i=0; i<numbuiltinforms; i++) {
7029                         DEBUGADD(6,("adding form [%d]'s size\n",i));
7030                         buffer_size += spoolss_size_form_1(&forms_1[i]);
7031                 }
7032                 for (; i<*numofforms; i++) {
7033                         DEBUGADD(6,("adding form [%d]'s size\n",i));
7034                         buffer_size += spoolss_size_form_1(&forms_1[i]);
7035                 }
7036
7037                 *needed=buffer_size;
7038
7039                 if (*needed > offered) {
7040                         SAFE_FREE(forms_1);
7041                         *numofforms=0;
7042                         return WERR_INSUFFICIENT_BUFFER;
7043                 }
7044
7045                 if (!rpcbuf_alloc_size(buffer, buffer_size)){
7046                         SAFE_FREE(forms_1);
7047                         *numofforms=0;
7048                         return WERR_NOMEM;
7049                 }
7050
7051                 /* fill the buffer with the form structures */
7052                 for (i=0; i<numbuiltinforms; i++) {
7053                         DEBUGADD(6,("adding form [%d] to buffer\n",i));
7054                         smb_io_form_1("", buffer, &forms_1[i], 0);
7055                 }
7056                 for (; i<*numofforms; i++) {
7057                         DEBUGADD(6,("adding form [%d] to buffer\n",i));
7058                         smb_io_form_1("", buffer, &forms_1[i], 0);
7059                 }
7060
7061                 SAFE_FREE(forms_1);
7062
7063                 return WERR_OK;
7064
7065         default:
7066                 SAFE_FREE(list);
7067                 SAFE_FREE(builtinlist);
7068                 return WERR_UNKNOWN_LEVEL;
7069         }
7070
7071 }
7072
7073 /****************************************************************************
7074 ****************************************************************************/
7075
7076 WERROR _spoolss_getform(pipes_struct *p, SPOOL_Q_GETFORM *q_u, SPOOL_R_GETFORM *r_u)
7077 {
7078         uint32 level = q_u->level;
7079         UNISTR2 *uni_formname = &q_u->formname;
7080         RPC_BUFFER *buffer = NULL;
7081         uint32 offered = q_u->offered;
7082         uint32 *needed = &r_u->needed;
7083
7084         nt_forms_struct *list=NULL;
7085         nt_forms_struct builtin_form;
7086         BOOL foundBuiltin;
7087         FORM_1 form_1;
7088         fstring form_name;
7089         int buffer_size=0;
7090         int numofforms=0, i=0;
7091
7092         /* that's an [in out] buffer */
7093
7094         if ( q_u->buffer ) {
7095                 rpcbuf_move(q_u->buffer, &r_u->buffer);
7096                 buffer = r_u->buffer;
7097         }
7098
7099         unistr2_to_ascii(form_name, uni_formname, sizeof(form_name)-1);
7100
7101         DEBUG(4,("_spoolss_getform\n"));
7102         DEBUGADD(5,("Offered buffer size [%d]\n", offered));
7103         DEBUGADD(5,("Info level [%d]\n",          level));
7104
7105         foundBuiltin = get_a_builtin_ntform(uni_formname,&builtin_form);
7106         if (!foundBuiltin) {
7107                 numofforms = get_ntforms(&list);
7108                 DEBUGADD(5,("Number of forms [%d]\n",     numofforms));
7109
7110                 if (numofforms == 0)
7111                         return WERR_BADFID;
7112         }
7113
7114         switch (level) {
7115         case 1:
7116                 if (foundBuiltin) {
7117                         fill_form_1(&form_1, &builtin_form);
7118                 } else {
7119
7120                         /* Check if the requested name is in the list of form structures */
7121                         for (i=0; i<numofforms; i++) {
7122
7123                                 DEBUG(4,("_spoolss_getform: checking form %s (want %s)\n", list[i].name, form_name));
7124
7125                                 if (strequal(form_name, list[i].name)) {
7126                                         DEBUGADD(6,("Found form %s number [%d]\n", form_name, i));
7127                                         fill_form_1(&form_1, &list[i]);
7128                                         break;
7129                                 }
7130                         }
7131
7132                         SAFE_FREE(list);
7133                         if (i == numofforms) {
7134                                 return WERR_BADFID;
7135                         }
7136                 }
7137                 /* check the required size. */
7138
7139                 *needed=spoolss_size_form_1(&form_1);
7140
7141                 if (*needed > offered)
7142                         return WERR_INSUFFICIENT_BUFFER;
7143
7144                 if (!rpcbuf_alloc_size(buffer, buffer_size))
7145                         return WERR_NOMEM;
7146
7147                 /* fill the buffer with the form structures */
7148                 DEBUGADD(6,("adding form %s [%d] to buffer\n", form_name, i));
7149                 smb_io_form_1("", buffer, &form_1, 0);
7150
7151                 return WERR_OK;
7152
7153         default:
7154                 SAFE_FREE(list);
7155                 return WERR_UNKNOWN_LEVEL;
7156         }
7157 }
7158
7159 /****************************************************************************
7160 ****************************************************************************/
7161
7162 static void fill_port_1(PORT_INFO_1 *port, const char *name)
7163 {
7164         init_unistr(&port->port_name, name);
7165 }
7166
7167 /****************************************************************************
7168 ****************************************************************************/
7169
7170 static void fill_port_2(PORT_INFO_2 *port, const char *name)
7171 {
7172         init_unistr(&port->port_name, name);
7173         init_unistr(&port->monitor_name, "Local Monitor");
7174         init_unistr(&port->description, "Local Port");
7175         port->port_type=PORT_TYPE_WRITE;
7176         port->reserved=0x0;
7177 }
7178
7179
7180 /****************************************************************************
7181  wrapper around the enumer ports command
7182 ****************************************************************************/
7183
7184 WERROR enumports_hook( int *count, char ***lines )
7185 {
7186         char *cmd = lp_enumports_cmd();
7187         char **qlines;
7188         pstring command;
7189         int numlines;
7190         int ret;
7191         int fd;
7192
7193
7194         /* if no hook then just fill in the default port */
7195
7196         if ( !*cmd ) {
7197                 qlines = SMB_MALLOC_ARRAY( char*, 2 );
7198                 qlines[0] = SMB_STRDUP( SAMBA_PRINTER_PORT_NAME );
7199                 qlines[1] = NULL;
7200                 numlines = 1;
7201         }
7202         else {
7203                 /* we have a valid enumport command */
7204
7205                 slprintf(command, sizeof(command)-1, "%s \"%d\"", cmd, 1);
7206
7207                 DEBUG(10,("Running [%s]\n", command));
7208                 ret = smbrun(command, &fd);
7209                 DEBUG(10,("Returned [%d]\n", ret));
7210                 if (ret != 0) {
7211                         if (fd != -1)
7212                                 close(fd);
7213
7214                         return WERR_ACCESS_DENIED;
7215                 }
7216
7217                 numlines = 0;
7218                 qlines = fd_lines_load(fd, &numlines);
7219                 DEBUGADD(10,("Lines returned = [%d]\n", numlines));
7220                 close(fd);
7221         }
7222
7223         *count = numlines;
7224         *lines = qlines;
7225
7226         return WERR_OK;
7227 }
7228
7229 /****************************************************************************
7230  enumports level 1.
7231 ****************************************************************************/
7232
7233 static WERROR enumports_level_1(RPC_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
7234 {
7235         PORT_INFO_1 *ports=NULL;
7236         int i=0;
7237         WERROR result = WERR_OK;
7238         char **qlines;
7239         int numlines;
7240
7241         if ( !W_ERROR_IS_OK(result = enumports_hook( &numlines, &qlines )) )
7242                 return result;
7243
7244         if(numlines) {
7245                 if((ports=SMB_MALLOC_ARRAY( PORT_INFO_1, numlines )) == NULL) {
7246                         DEBUG(10,("Returning WERR_NOMEM [%s]\n",
7247                                   dos_errstr(WERR_NOMEM)));
7248                         file_lines_free(qlines);
7249                         return WERR_NOMEM;
7250                 }
7251
7252                 for (i=0; i<numlines; i++) {
7253                         DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
7254                         fill_port_1(&ports[i], qlines[i]);
7255                 }
7256
7257                 file_lines_free(qlines);
7258         }
7259
7260         *returned = numlines;
7261
7262         /* check the required size. */
7263         for (i=0; i<*returned; i++) {
7264                 DEBUGADD(6,("adding port [%d]'s size\n", i));
7265                 *needed += spoolss_size_port_info_1(&ports[i]);
7266         }
7267
7268         if (*needed > offered) {
7269                 result = WERR_INSUFFICIENT_BUFFER;
7270                 goto out;
7271         }
7272
7273         if (!rpcbuf_alloc_size(buffer, *needed)) {
7274                 result = WERR_NOMEM;
7275                 goto out;
7276         }
7277
7278         /* fill the buffer with the ports structures */
7279         for (i=0; i<*returned; i++) {
7280                 DEBUGADD(6,("adding port [%d] to buffer\n", i));
7281                 smb_io_port_1("", buffer, &ports[i], 0);
7282         }
7283
7284 out:
7285         SAFE_FREE(ports);
7286
7287         if ( !W_ERROR_IS_OK(result) )
7288                 *returned = 0;
7289
7290         return result;
7291 }
7292
7293 /****************************************************************************
7294  enumports level 2.
7295 ****************************************************************************/
7296
7297 static WERROR enumports_level_2(RPC_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
7298 {
7299         PORT_INFO_2 *ports=NULL;
7300         int i=0;
7301         WERROR result = WERR_OK;
7302         char **qlines;
7303         int numlines;
7304
7305         if ( !W_ERROR_IS_OK(result = enumports_hook( &numlines, &qlines )) )
7306                 return result;
7307
7308
7309         if(numlines) {
7310                 if((ports=SMB_MALLOC_ARRAY( PORT_INFO_2, numlines)) == NULL) {
7311                         file_lines_free(qlines);
7312                         return WERR_NOMEM;
7313                 }
7314
7315                 for (i=0; i<numlines; i++) {
7316                         DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
7317                         fill_port_2(&(ports[i]), qlines[i]);
7318                 }
7319
7320                 file_lines_free(qlines);
7321         }
7322
7323         *returned = numlines;
7324
7325         /* check the required size. */
7326         for (i=0; i<*returned; i++) {
7327                 DEBUGADD(6,("adding port [%d]'s size\n", i));
7328                 *needed += spoolss_size_port_info_2(&ports[i]);
7329         }
7330
7331         if (*needed > offered) {
7332                 result = WERR_INSUFFICIENT_BUFFER;
7333                 goto out;
7334         }
7335
7336         if (!rpcbuf_alloc_size(buffer, *needed)) {
7337                 result = WERR_NOMEM;
7338                 goto out;
7339         }
7340
7341         /* fill the buffer with the ports structures */
7342         for (i=0; i<*returned; i++) {
7343                 DEBUGADD(6,("adding port [%d] to buffer\n", i));
7344                 smb_io_port_2("", buffer, &ports[i], 0);
7345         }
7346
7347 out:
7348         SAFE_FREE(ports);
7349
7350         if ( !W_ERROR_IS_OK(result) )
7351                 *returned = 0;
7352
7353         return result;
7354 }
7355
7356 /****************************************************************************
7357  enumports.
7358 ****************************************************************************/
7359
7360 WERROR _spoolss_enumports( pipes_struct *p, SPOOL_Q_ENUMPORTS *q_u, SPOOL_R_ENUMPORTS *r_u)
7361 {
7362         uint32 level = q_u->level;
7363         RPC_BUFFER *buffer = NULL;
7364         uint32 offered = q_u->offered;
7365         uint32 *needed = &r_u->needed;
7366         uint32 *returned = &r_u->returned;
7367
7368         /* that's an [in out] buffer */
7369
7370         if ( q_u->buffer ) {
7371                 rpcbuf_move(q_u->buffer, &r_u->buffer);
7372                 buffer = r_u->buffer;
7373         }
7374
7375         DEBUG(4,("_spoolss_enumports\n"));
7376
7377         *returned=0;
7378         *needed=0;
7379
7380         switch (level) {
7381         case 1:
7382                 return enumports_level_1(buffer, offered, needed, returned);
7383         case 2:
7384                 return enumports_level_2(buffer, offered, needed, returned);
7385         default:
7386                 return WERR_UNKNOWN_LEVEL;
7387         }
7388 }
7389
7390 /****************************************************************************
7391 ****************************************************************************/
7392
7393 static WERROR spoolss_addprinterex_level_2( pipes_struct *p, const UNISTR2 *uni_srv_name,
7394                                 const SPOOL_PRINTER_INFO_LEVEL *info,
7395                                 DEVICEMODE *devmode, SEC_DESC_BUF *sec_desc_buf,
7396                                 uint32 user_switch, const SPOOL_USER_CTR *user,
7397                                 POLICY_HND *handle)
7398 {
7399         NT_PRINTER_INFO_LEVEL *printer = NULL;
7400         fstring name;
7401         int     snum;
7402         WERROR err = WERR_OK;
7403
7404         if ((printer = SMB_MALLOC_P(NT_PRINTER_INFO_LEVEL)) == NULL) {
7405                 DEBUG(0,("spoolss_addprinterex_level_2: malloc fail.\n"));
7406                 return WERR_NOMEM;
7407         }
7408
7409         ZERO_STRUCTP(printer);
7410
7411         /* convert from UNICODE to ASCII - this allocates the info_2 struct inside *printer.*/
7412         if (!convert_printer_info(info, printer, 2)) {
7413                 free_a_printer(&printer, 2);
7414                 return WERR_NOMEM;
7415         }
7416
7417         /* check to see if the printer already exists */
7418
7419         if ((snum = print_queue_snum(printer->info_2->sharename)) != -1) {
7420                 DEBUG(5, ("spoolss_addprinterex_level_2: Attempted to add a printer named [%s] when one already existed!\n",
7421                         printer->info_2->sharename));
7422                 free_a_printer(&printer, 2);
7423                 return WERR_PRINTER_ALREADY_EXISTS;
7424         }
7425
7426         /* FIXME!!!  smbd should check to see if the driver is installed before
7427            trying to add a printer like this  --jerry */
7428
7429         if (*lp_addprinter_cmd() ) {
7430                 if ( !add_printer_hook(p->pipe_user.nt_user_token, printer) ) {
7431                         free_a_printer(&printer,2);
7432                         return WERR_ACCESS_DENIED;
7433                 }
7434         } else {
7435                 DEBUG(0,("spoolss_addprinterex_level_2: add printer for printer %s called and no"
7436                         "smb.conf parameter \"addprinter command\" is defined. This"
7437                         "parameter must exist for this call to succeed\n",
7438                         printer->info_2->sharename ));
7439         }
7440
7441         /* use our primary netbios name since get_a_printer() will convert
7442            it to what the client expects on a case by case basis */
7443
7444         slprintf(name, sizeof(name)-1, "\\\\%s\\%s", global_myname(),
7445              printer->info_2->sharename);
7446
7447
7448         if ((snum = print_queue_snum(printer->info_2->sharename)) == -1) {
7449                 free_a_printer(&printer,2);
7450                 return WERR_ACCESS_DENIED;
7451         }
7452
7453         /* you must be a printer admin to add a new printer */
7454         if (!print_access_check(NULL, snum, PRINTER_ACCESS_ADMINISTER)) {
7455                 free_a_printer(&printer,2);
7456                 return WERR_ACCESS_DENIED;
7457         }
7458
7459         /*
7460          * Do sanity check on the requested changes for Samba.
7461          */
7462
7463         if (!check_printer_ok(printer->info_2, snum)) {
7464                 free_a_printer(&printer,2);
7465                 return WERR_INVALID_PARAM;
7466         }
7467
7468         /*
7469          * When a printer is created, the drivername bound to the printer is used
7470          * to lookup previously saved driver initialization info, which is then
7471          * bound to the new printer, simulating what happens in the Windows arch.
7472          */
7473
7474         if (!devmode)
7475         {
7476                 set_driver_init(printer, 2);
7477         }
7478         else
7479         {
7480                 /* A valid devmode was included, convert and link it
7481                 */
7482                 DEBUGADD(10, ("spoolss_addprinterex_level_2: devmode included, converting\n"));
7483
7484                 if (!convert_devicemode(printer->info_2->printername, devmode,
7485                                 &printer->info_2->devmode))
7486                         return  WERR_NOMEM;
7487         }
7488
7489         /* write the ASCII on disk */
7490         err = mod_a_printer(printer, 2);
7491         if (!W_ERROR_IS_OK(err)) {
7492                 free_a_printer(&printer,2);
7493                 return err;
7494         }
7495
7496         if (!open_printer_hnd(p, handle, name, PRINTER_ACCESS_ADMINISTER)) {
7497                 /* Handle open failed - remove addition. */
7498                 del_a_printer(printer->info_2->sharename);
7499                 free_a_printer(&printer,2);
7500                 return WERR_ACCESS_DENIED;
7501         }
7502
7503         update_c_setprinter(False);
7504         free_a_printer(&printer,2);
7505
7506         return WERR_OK;
7507 }
7508
7509 /****************************************************************************
7510 ****************************************************************************/
7511
7512 WERROR _spoolss_addprinterex( pipes_struct *p, SPOOL_Q_ADDPRINTEREX *q_u, SPOOL_R_ADDPRINTEREX *r_u)
7513 {
7514         UNISTR2 *uni_srv_name = q_u->server_name;
7515         uint32 level = q_u->level;
7516         SPOOL_PRINTER_INFO_LEVEL *info = &q_u->info;
7517         DEVICEMODE *devmode = q_u->devmode_ctr.devmode;
7518         SEC_DESC_BUF *sdb = q_u->secdesc_ctr;
7519         uint32 user_switch = q_u->user_switch;
7520         SPOOL_USER_CTR *user = &q_u->user_ctr;
7521         POLICY_HND *handle = &r_u->handle;
7522
7523         switch (level) {
7524                 case 1:
7525                         /* we don't handle yet */
7526                         /* but I know what to do ... */
7527                         return WERR_UNKNOWN_LEVEL;
7528                 case 2:
7529                         return spoolss_addprinterex_level_2(p, uni_srv_name, info,
7530                                                             devmode, sdb,
7531                                                             user_switch, user, handle);
7532                 default:
7533                         return WERR_UNKNOWN_LEVEL;
7534         }
7535 }
7536
7537 /****************************************************************************
7538 ****************************************************************************/
7539
7540 WERROR _spoolss_addprinterdriver(pipes_struct *p, SPOOL_Q_ADDPRINTERDRIVER *q_u, SPOOL_R_ADDPRINTERDRIVER *r_u)
7541 {
7542         uint32 level = q_u->level;
7543         SPOOL_PRINTER_DRIVER_INFO_LEVEL *info = &q_u->info;
7544         WERROR err = WERR_OK;
7545         NT_PRINTER_DRIVER_INFO_LEVEL driver;
7546         struct current_user user;
7547         fstring driver_name;
7548         uint32 version;
7549
7550         ZERO_STRUCT(driver);
7551
7552         get_current_user(&user, p);
7553
7554         if (!convert_printer_driver_info(info, &driver, level)) {
7555                 err = WERR_NOMEM;
7556                 goto done;
7557         }
7558
7559         DEBUG(5,("Cleaning driver's information\n"));
7560         err = clean_up_driver_struct(driver, level, &user);
7561         if (!W_ERROR_IS_OK(err))
7562                 goto done;
7563
7564         DEBUG(5,("Moving driver to final destination\n"));
7565         if( !W_ERROR_IS_OK(err = move_driver_to_download_area(driver, level, &user, &err)) ) {
7566                 goto done;
7567         }
7568
7569         if (add_a_printer_driver(driver, level)!=0) {
7570                 err = WERR_ACCESS_DENIED;
7571                 goto done;
7572         }
7573
7574         /* BEGIN_ADMIN_LOG */
7575         switch(level) {
7576             case 3:
7577                 fstrcpy(driver_name, driver.info_3->name ? driver.info_3->name : "");
7578                 sys_adminlog(LOG_INFO,"Added printer driver. Print driver name: %s. Print driver OS: %s. Administrator name: %s.",
7579                         driver_name, get_drv_ver_to_os(driver.info_3->cversion),uidtoname(user.uid));
7580                 break;
7581             case 6:
7582                 fstrcpy(driver_name, driver.info_6->name ?  driver.info_6->name : "");
7583                 sys_adminlog(LOG_INFO,"Added printer driver. Print driver name: %s. Print driver OS: %s. Administrator name: %s.",
7584                         driver_name, get_drv_ver_to_os(driver.info_6->version),uidtoname(user.uid));
7585                 break;
7586         }
7587         /* END_ADMIN_LOG */
7588
7589         /*
7590          * I think this is where he DrvUpgradePrinter() hook would be
7591          * be called in a driver's interface DLL on a Windows NT 4.0/2k
7592          * server.  Right now, we just need to send ourselves a message
7593          * to update each printer bound to this driver.   --jerry
7594          */
7595
7596         if (!srv_spoolss_drv_upgrade_printer(driver_name)) {
7597                 DEBUG(0,("_spoolss_addprinterdriver: Failed to send message about upgrading driver [%s]!\n",
7598                         driver_name));
7599         }
7600
7601         /*
7602          * Based on the version (e.g. driver destination dir: 0=9x,2=Nt/2k,3=2k/Xp),
7603          * decide if the driver init data should be deleted. The rules are:
7604          *  1) never delete init data if it is a 9x driver, they don't use it anyway
7605          *  2) delete init data only if there is no 2k/Xp driver
7606          *  3) always delete init data
7607          * The generalized rule is always use init data from the highest order driver.
7608          * It is necessary to follow the driver install by an initialization step to
7609          * finish off this process.
7610         */
7611         if (level == 3)
7612                 version = driver.info_3->cversion;
7613         else if (level == 6)
7614                 version = driver.info_6->version;
7615         else
7616                 version = -1;
7617         switch (version) {
7618                 /*
7619                  * 9x printer driver - never delete init data
7620                 */
7621                 case 0:
7622                         DEBUG(10,("_spoolss_addprinterdriver: init data not deleted for 9x driver [%s]\n",
7623                                         driver_name));
7624                         break;
7625
7626                 /*
7627                  * Nt or 2k (compatiblity mode) printer driver - only delete init data if
7628                  * there is no 2k/Xp driver init data for this driver name.
7629                 */
7630                 case 2:
7631                 {
7632                         NT_PRINTER_DRIVER_INFO_LEVEL driver1;
7633
7634                         if (!W_ERROR_IS_OK(get_a_printer_driver(&driver1, 3, driver_name, "Windows NT x86", 3))) {
7635                                 /*
7636                                  * No 2k/Xp driver found, delete init data (if any) for the new Nt driver.
7637                                 */
7638                                 if (!del_driver_init(driver_name))
7639                                         DEBUG(6,("_spoolss_addprinterdriver: del_driver_init(%s) Nt failed!\n", driver_name));
7640                         } else {
7641                                 /*
7642                                  * a 2k/Xp driver was found, don't delete init data because Nt driver will use it.
7643                                 */
7644                                 free_a_printer_driver(driver1,3);
7645                                 DEBUG(10,("_spoolss_addprinterdriver: init data not deleted for Nt driver [%s]\n",
7646                                                 driver_name));
7647                         }
7648                 }
7649                 break;
7650
7651                 /*
7652                  * 2k or Xp printer driver - always delete init data
7653                 */
7654                 case 3:
7655                         if (!del_driver_init(driver_name))
7656                                 DEBUG(6,("_spoolss_addprinterdriver: del_driver_init(%s) 2k/Xp failed!\n", driver_name));
7657                         break;
7658
7659                 default:
7660                         DEBUG(0,("_spoolss_addprinterdriver: invalid level=%d\n", level));
7661                         break;
7662         }
7663
7664
7665 done:
7666         free_a_printer_driver(driver, level);
7667         return err;
7668 }
7669
7670 /********************************************************************
7671  * spoolss_addprinterdriverex
7672  ********************************************************************/
7673
7674 WERROR _spoolss_addprinterdriverex(pipes_struct *p, SPOOL_Q_ADDPRINTERDRIVEREX *q_u, SPOOL_R_ADDPRINTERDRIVEREX *r_u)
7675 {
7676         SPOOL_Q_ADDPRINTERDRIVER q_u_local;
7677         SPOOL_R_ADDPRINTERDRIVER r_u_local;
7678
7679         /*
7680          * we only support the semantics of AddPrinterDriver()
7681          * i.e. only copy files that are newer than existing ones
7682          */
7683
7684         if ( q_u->copy_flags != APD_COPY_NEW_FILES )
7685                 return WERR_ACCESS_DENIED;
7686
7687         ZERO_STRUCT(q_u_local);
7688         ZERO_STRUCT(r_u_local);
7689
7690         /* just pass the information off to _spoolss_addprinterdriver() */
7691         q_u_local.server_name_ptr = q_u->server_name_ptr;
7692         copy_unistr2(&q_u_local.server_name, &q_u->server_name);
7693         q_u_local.level = q_u->level;
7694         memcpy( &q_u_local.info, &q_u->info, sizeof(SPOOL_PRINTER_DRIVER_INFO_LEVEL) );
7695
7696         return _spoolss_addprinterdriver( p, &q_u_local, &r_u_local );
7697 }
7698
7699 /****************************************************************************
7700 ****************************************************************************/
7701
7702 static void fill_driverdir_1(DRIVER_DIRECTORY_1 *info, char *name)
7703 {
7704         init_unistr(&info->name, name);
7705 }
7706
7707 /****************************************************************************
7708 ****************************************************************************/
7709
7710 static WERROR getprinterdriverdir_level_1(UNISTR2 *name, UNISTR2 *uni_environment, RPC_BUFFER *buffer, uint32 offered, uint32 *needed)
7711 {
7712         pstring path;
7713         pstring long_archi;
7714         fstring servername;
7715         char *pservername;
7716         const char *short_archi;
7717         DRIVER_DIRECTORY_1 *info=NULL;
7718         WERROR result = WERR_OK;
7719
7720         unistr2_to_ascii(servername, name, sizeof(servername)-1);
7721         unistr2_to_ascii(long_archi, uni_environment, sizeof(long_archi)-1);
7722
7723         /* check for beginning double '\'s and that the server
7724            long enough */
7725
7726         pservername = servername;
7727         if ( *pservername == '\\' && strlen(servername)>2 ) {
7728                 pservername += 2;
7729         }
7730
7731         if ( !is_myname_or_ipaddr( pservername ) )
7732                 return WERR_INVALID_PARAM;
7733
7734         if (!(short_archi = get_short_archi(long_archi)))
7735                 return WERR_INVALID_ENVIRONMENT;
7736
7737         if((info=SMB_MALLOC_P(DRIVER_DIRECTORY_1)) == NULL)
7738                 return WERR_NOMEM;
7739
7740         slprintf(path, sizeof(path)-1, "\\\\%s\\print$\\%s", pservername, short_archi);
7741
7742         DEBUG(4,("printer driver directory: [%s]\n", path));
7743
7744         fill_driverdir_1(info, path);
7745
7746         *needed += spoolss_size_driverdir_info_1(info);
7747
7748         if (*needed > offered) {
7749                 result = WERR_INSUFFICIENT_BUFFER;
7750                 goto out;
7751         }
7752
7753         if (!rpcbuf_alloc_size(buffer, *needed)) {
7754                 result = WERR_NOMEM;
7755                 goto out;
7756         }
7757
7758         smb_io_driverdir_1("", buffer, info, 0);
7759
7760 out:
7761         SAFE_FREE(info);
7762
7763         return result;
7764 }
7765
7766 /****************************************************************************
7767 ****************************************************************************/
7768
7769 WERROR _spoolss_getprinterdriverdirectory(pipes_struct *p, SPOOL_Q_GETPRINTERDRIVERDIR *q_u, SPOOL_R_GETPRINTERDRIVERDIR *r_u)
7770 {
7771         UNISTR2 *name = &q_u->name;
7772         UNISTR2 *uni_environment = &q_u->environment;
7773         uint32 level = q_u->level;
7774         RPC_BUFFER *buffer = NULL;
7775         uint32 offered = q_u->offered;
7776         uint32 *needed = &r_u->needed;
7777
7778         /* that's an [in out] buffer */
7779
7780         if ( q_u->buffer ) {
7781                 rpcbuf_move(q_u->buffer, &r_u->buffer);
7782                 buffer = r_u->buffer;
7783         }
7784
7785         DEBUG(4,("_spoolss_getprinterdriverdirectory\n"));
7786
7787         *needed=0;
7788
7789         switch(level) {
7790         case 1:
7791                 return getprinterdriverdir_level_1(name, uni_environment, buffer, offered, needed);
7792         default:
7793                 return WERR_UNKNOWN_LEVEL;
7794         }
7795 }
7796
7797 /****************************************************************************
7798 ****************************************************************************/
7799
7800 WERROR _spoolss_enumprinterdata(pipes_struct *p, SPOOL_Q_ENUMPRINTERDATA *q_u, SPOOL_R_ENUMPRINTERDATA *r_u)
7801 {
7802         POLICY_HND *handle = &q_u->handle;
7803         uint32 idx               = q_u->index;
7804         uint32 in_value_len      = q_u->valuesize;
7805         uint32 in_data_len       = q_u->datasize;
7806         uint32 *out_max_value_len = &r_u->valuesize;
7807         uint16 **out_value       = &r_u->value;
7808         uint32 *out_value_len    = &r_u->realvaluesize;
7809         uint32 *out_type         = &r_u->type;
7810         uint32 *out_max_data_len = &r_u->datasize;
7811         uint8  **data_out        = &r_u->data;
7812         uint32 *out_data_len     = &r_u->realdatasize;
7813
7814         NT_PRINTER_INFO_LEVEL *printer = NULL;
7815
7816         uint32          biggest_valuesize;
7817         uint32          biggest_datasize;
7818         uint32          data_len;
7819         Printer_entry   *Printer = find_printer_index_by_hnd(p, handle);
7820         int             snum;
7821         WERROR          result;
7822         REGISTRY_VALUE  *val = NULL;
7823         NT_PRINTER_DATA *p_data;
7824         int             i, key_index, num_values;
7825         int             name_length;
7826
7827         *out_type = 0;
7828
7829         *out_max_data_len = 0;
7830         *data_out         = NULL;
7831         *out_data_len     = 0;
7832
7833         DEBUG(5,("spoolss_enumprinterdata\n"));
7834
7835         if (!Printer) {
7836                 DEBUG(2,("_spoolss_enumprinterdata: Invalid handle (%s:%u:%u).\n", OUR_HANDLE(handle)));
7837                 return WERR_BADFID;
7838         }
7839
7840         if (!get_printer_snum(p,handle, &snum))
7841                 return WERR_BADFID;
7842
7843         result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
7844         if (!W_ERROR_IS_OK(result))
7845                 return result;
7846
7847         p_data = printer->info_2->data;
7848         key_index = lookup_printerkey( p_data, SPOOL_PRINTERDATA_KEY );
7849
7850         result = WERR_OK;
7851
7852         /*
7853          * The NT machine wants to know the biggest size of value and data
7854          *
7855          * cf: MSDN EnumPrinterData remark section
7856          */
7857
7858         if ( !in_value_len && !in_data_len && (key_index != -1) )
7859         {
7860                 DEBUGADD(6,("Activating NT mega-hack to find sizes\n"));
7861
7862                 biggest_valuesize = 0;
7863                 biggest_datasize  = 0;
7864
7865                 num_values = regval_ctr_numvals( p_data->keys[key_index].values );
7866
7867                 for ( i=0; i<num_values; i++ )
7868                 {
7869                         val = regval_ctr_specific_value( p_data->keys[key_index].values, i );
7870
7871                         name_length = strlen(val->valuename);
7872                         if ( strlen(val->valuename) > biggest_valuesize )
7873                                 biggest_valuesize = name_length;
7874
7875                         if ( val->size > biggest_datasize )
7876                                 biggest_datasize = val->size;
7877
7878                         DEBUG(6,("current values: [%d], [%d]\n", biggest_valuesize,
7879                                 biggest_datasize));
7880                 }
7881
7882                 /* the value is an UNICODE string but real_value_size is the length
7883                    in bytes including the trailing 0 */
7884
7885                 *out_value_len = 2 * (1+biggest_valuesize);
7886                 *out_data_len  = biggest_datasize;
7887
7888                 DEBUG(6,("final values: [%d], [%d]\n", *out_value_len, *out_data_len));
7889
7890                 goto done;
7891         }
7892
7893         /*
7894          * the value len is wrong in NT sp3
7895          * that's the number of bytes not the number of unicode chars
7896          */
7897
7898         if ( key_index != -1 )
7899                 val = regval_ctr_specific_value( p_data->keys[key_index].values, idx );
7900
7901         if ( !val )
7902         {
7903
7904                 /* out_value should default to "" or else NT4 has
7905                    problems unmarshalling the response */
7906
7907                 *out_max_value_len=(in_value_len/sizeof(uint16));
7908
7909                 if((*out_value=(uint16 *)TALLOC_ZERO(p->mem_ctx, in_value_len*sizeof(uint8))) == NULL)
7910                 {
7911                         result = WERR_NOMEM;
7912                         goto done;
7913                 }
7914
7915                 *out_value_len = (uint32)rpcstr_push((char *)*out_value, "", in_value_len, 0);
7916
7917                 /* the data is counted in bytes */
7918
7919                 *out_max_data_len = in_data_len;
7920                 *out_data_len     = in_data_len;
7921
7922                 /* only allocate when given a non-zero data_len */
7923
7924                 if ( in_data_len && ((*data_out=(uint8 *)TALLOC_ZERO(p->mem_ctx, in_data_len*sizeof(uint8))) == NULL) )
7925                 {
7926                         result = WERR_NOMEM;
7927                         goto done;
7928                 }
7929
7930                 result = WERR_NO_MORE_ITEMS;
7931         }
7932         else
7933         {
7934                 /*
7935                  * the value is:
7936                  * - counted in bytes in the request
7937                  * - counted in UNICODE chars in the max reply
7938                  * - counted in bytes in the real size
7939                  *
7940                  * take a pause *before* coding not *during* coding
7941                  */
7942
7943                 /* name */
7944                 *out_max_value_len=(in_value_len/sizeof(uint16));
7945                 if ( (*out_value = (uint16 *)TALLOC_ZERO(p->mem_ctx, in_value_len*sizeof(uint8))) == NULL )
7946                 {
7947                         result = WERR_NOMEM;
7948                         goto done;
7949                 }
7950
7951                 *out_value_len = (uint32)rpcstr_push((char *)*out_value, regval_name(val), in_value_len, 0);
7952
7953                 /* type */
7954
7955                 *out_type = regval_type( val );
7956
7957                 /* data - counted in bytes */
7958
7959                 *out_max_data_len = in_data_len;
7960                 if ( in_data_len && (*data_out = (uint8 *)TALLOC_ZERO(p->mem_ctx, in_data_len*sizeof(uint8))) == NULL)
7961                 {
7962                         result = WERR_NOMEM;
7963                         goto done;
7964                 }
7965                 data_len = regval_size(val);
7966                 if ( *data_out )
7967                         memcpy( *data_out, regval_data_p(val), data_len );
7968                 *out_data_len = data_len;
7969         }
7970
7971 done:
7972         free_a_printer(&printer, 2);
7973         return result;
7974 }
7975
7976 /****************************************************************************
7977 ****************************************************************************/
7978
7979 WERROR _spoolss_setprinterdata( pipes_struct *p, SPOOL_Q_SETPRINTERDATA *q_u, SPOOL_R_SETPRINTERDATA *r_u)
7980 {
7981         POLICY_HND              *handle = &q_u->handle;
7982         UNISTR2                 *value = &q_u->value;
7983         uint32                  type = q_u->type;
7984         uint8                   *data = q_u->data;
7985         uint32                  real_len = q_u->real_len;
7986
7987         NT_PRINTER_INFO_LEVEL   *printer = NULL;
7988         int                     snum=0;
7989         WERROR                  status = WERR_OK;
7990         Printer_entry           *Printer=find_printer_index_by_hnd(p, handle);
7991         fstring                 valuename;
7992
7993         DEBUG(5,("spoolss_setprinterdata\n"));
7994
7995         if (!Printer) {
7996                 DEBUG(2,("_spoolss_setprinterdata: Invalid handle (%s:%u:%u).\n", OUR_HANDLE(handle)));
7997                 return WERR_BADFID;
7998         }
7999
8000         if ( Printer->printer_type == PRINTER_HANDLE_IS_PRINTSERVER ) {
8001                 DEBUG(10,("_spoolss_setprinterdata: Not implemented for server handles yet\n"));
8002                 return WERR_INVALID_PARAM;
8003         }
8004
8005         if (!get_printer_snum(p,handle, &snum))
8006                 return WERR_BADFID;
8007
8008         /*
8009          * Access check : NT returns "access denied" if you make a
8010          * SetPrinterData call without the necessary privildge.
8011          * we were originally returning OK if nothing changed
8012          * which made Win2k issue **a lot** of SetPrinterData
8013          * when connecting to a printer  --jerry
8014          */
8015
8016         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER)
8017         {
8018                 DEBUG(3, ("_spoolss_setprinterdata: change denied by handle access permissions\n"));
8019                 status = WERR_ACCESS_DENIED;
8020                 goto done;
8021         }
8022
8023         status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8024         if (!W_ERROR_IS_OK(status))
8025                 return status;
8026
8027         unistr2_to_ascii( valuename, value, sizeof(valuename)-1 );
8028
8029         /*
8030          * When client side code sets a magic printer data key, detect it and save
8031          * the current printer data and the magic key's data (its the DEVMODE) for
8032          * future printer/driver initializations.
8033          */
8034         if ( (type == REG_BINARY) && strequal( valuename, PHANTOM_DEVMODE_KEY))
8035         {
8036                 /* Set devmode and printer initialization info */
8037                 status = save_driver_init( printer, 2, data, real_len );
8038
8039                 srv_spoolss_reset_printerdata( printer->info_2->drivername );
8040         }
8041         else
8042         {
8043         status = set_printer_dataex( printer, SPOOL_PRINTERDATA_KEY, valuename,
8044                                         type, data, real_len );
8045                 if ( W_ERROR_IS_OK(status) )
8046                         status = mod_a_printer(printer, 2);
8047         }
8048
8049 done:
8050         free_a_printer(&printer, 2);
8051
8052         return status;
8053 }
8054
8055 /****************************************************************************
8056 ****************************************************************************/
8057
8058 WERROR _spoolss_resetprinter(pipes_struct *p, SPOOL_Q_RESETPRINTER *q_u, SPOOL_R_RESETPRINTER *r_u)
8059 {
8060         POLICY_HND      *handle = &q_u->handle;
8061         Printer_entry   *Printer=find_printer_index_by_hnd(p, handle);
8062         int             snum;
8063
8064         DEBUG(5,("_spoolss_resetprinter\n"));
8065
8066         /*
8067          * All we do is to check to see if the handle and queue is valid.
8068          * This call really doesn't mean anything to us because we only
8069          * support RAW printing.   --jerry
8070          */
8071
8072         if (!Printer) {
8073                 DEBUG(2,("_spoolss_resetprinter: Invalid handle (%s:%u:%u).\n", OUR_HANDLE(handle)));
8074                 return WERR_BADFID;
8075         }
8076
8077         if (!get_printer_snum(p,handle, &snum))
8078                 return WERR_BADFID;
8079
8080
8081         /* blindly return success */
8082         return WERR_OK;
8083 }
8084
8085
8086 /****************************************************************************
8087 ****************************************************************************/
8088
8089 WERROR _spoolss_deleteprinterdata(pipes_struct *p, SPOOL_Q_DELETEPRINTERDATA *q_u, SPOOL_R_DELETEPRINTERDATA *r_u)
8090 {
8091         POLICY_HND      *handle = &q_u->handle;
8092         UNISTR2         *value = &q_u->valuename;
8093
8094         NT_PRINTER_INFO_LEVEL   *printer = NULL;
8095         int             snum=0;
8096         WERROR          status = WERR_OK;
8097         Printer_entry   *Printer=find_printer_index_by_hnd(p, handle);
8098         pstring         valuename;
8099
8100         DEBUG(5,("spoolss_deleteprinterdata\n"));
8101
8102         if (!Printer) {
8103                 DEBUG(2,("_spoolss_deleteprinterdata: Invalid handle (%s:%u:%u).\n", OUR_HANDLE(handle)));
8104                 return WERR_BADFID;
8105         }
8106
8107         if (!get_printer_snum(p, handle, &snum))
8108                 return WERR_BADFID;
8109
8110         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
8111                 DEBUG(3, ("_spoolss_deleteprinterdata: printer properties change denied by handle\n"));
8112                 return WERR_ACCESS_DENIED;
8113         }
8114
8115         status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8116         if (!W_ERROR_IS_OK(status))
8117                 return status;
8118
8119         unistr2_to_ascii( valuename, value, sizeof(valuename)-1 );
8120
8121         status = delete_printer_dataex( printer, SPOOL_PRINTERDATA_KEY, valuename );
8122
8123         if ( W_ERROR_IS_OK(status) )
8124                 mod_a_printer( printer, 2 );
8125
8126         free_a_printer(&printer, 2);
8127
8128         return status;
8129 }
8130
8131 /****************************************************************************
8132 ****************************************************************************/
8133
8134 WERROR _spoolss_addform( pipes_struct *p, SPOOL_Q_ADDFORM *q_u, SPOOL_R_ADDFORM *r_u)
8135 {
8136         POLICY_HND *handle = &q_u->handle;
8137         FORM *form = &q_u->form;
8138         nt_forms_struct tmpForm;
8139         int snum;
8140         WERROR status = WERR_OK;
8141         NT_PRINTER_INFO_LEVEL *printer = NULL;
8142
8143         int count=0;
8144         nt_forms_struct *list=NULL;
8145         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
8146
8147         DEBUG(5,("spoolss_addform\n"));
8148
8149         if (!Printer) {
8150                 DEBUG(2,("_spoolss_addform: Invalid handle (%s:%u:%u).\n", OUR_HANDLE(handle)));
8151                 return WERR_BADFID;
8152         }
8153
8154
8155         /* forms can be added on printer of on the print server handle */
8156
8157         if ( Printer->printer_type == PRINTER_HANDLE_IS_PRINTER )
8158         {
8159                 if (!get_printer_snum(p,handle, &snum))
8160                         return WERR_BADFID;
8161
8162                 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8163                 if (!W_ERROR_IS_OK(status))
8164                         goto done;
8165         }
8166
8167         if ( !(Printer->access_granted & (PRINTER_ACCESS_ADMINISTER|SERVER_ACCESS_ADMINISTER)) ) {
8168                 DEBUG(2,("_spoolss_addform: denied by handle permissions.\n"));
8169                 status = WERR_ACCESS_DENIED;
8170                 goto done;
8171         }
8172
8173         /* can't add if builtin */
8174
8175         if (get_a_builtin_ntform(&form->name,&tmpForm)) {
8176                 status = WERR_ALREADY_EXISTS;
8177                 goto done;
8178         }
8179
8180         count = get_ntforms(&list);
8181
8182         if(!add_a_form(&list, form, &count)) {
8183                 status =  WERR_NOMEM;
8184                 goto done;
8185         }
8186
8187         write_ntforms(&list, count);
8188
8189         /*
8190          * ChangeID must always be set if this is a printer
8191          */
8192
8193         if ( Printer->printer_type == PRINTER_HANDLE_IS_PRINTER )
8194                 status = mod_a_printer(printer, 2);
8195
8196 done:
8197         if ( printer )
8198                 free_a_printer(&printer, 2);
8199         SAFE_FREE(list);
8200
8201         return status;
8202 }
8203
8204 /****************************************************************************
8205 ****************************************************************************/
8206
8207 WERROR _spoolss_deleteform( pipes_struct *p, SPOOL_Q_DELETEFORM *q_u, SPOOL_R_DELETEFORM *r_u)
8208 {
8209         POLICY_HND *handle = &q_u->handle;
8210         UNISTR2 *form_name = &q_u->name;
8211         nt_forms_struct tmpForm;
8212         int count=0;
8213         nt_forms_struct *list=NULL;
8214         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
8215         int snum;
8216         WERROR status = WERR_OK;
8217         NT_PRINTER_INFO_LEVEL *printer = NULL;
8218
8219         DEBUG(5,("spoolss_deleteform\n"));
8220
8221         if (!Printer) {
8222                 DEBUG(2,("_spoolss_deleteform: Invalid handle (%s:%u:%u).\n", OUR_HANDLE(handle)));
8223                 return WERR_BADFID;
8224         }
8225
8226         /* forms can be deleted on printer of on the print server handle */
8227
8228         if ( Printer->printer_type == PRINTER_HANDLE_IS_PRINTER )
8229         {
8230                 if (!get_printer_snum(p,handle, &snum))
8231                         return WERR_BADFID;
8232
8233                 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8234                 if (!W_ERROR_IS_OK(status))
8235                         goto done;
8236         }
8237
8238         if ( !(Printer->access_granted & (PRINTER_ACCESS_ADMINISTER|SERVER_ACCESS_ADMINISTER)) ) {
8239                 DEBUG(2,("_spoolss_deleteform: denied by handle permissions.\n"));
8240                 status = WERR_ACCESS_DENIED;
8241                 goto done;
8242         }
8243
8244         /* can't delete if builtin */
8245
8246         if (get_a_builtin_ntform(form_name,&tmpForm)) {
8247                 status = WERR_INVALID_PARAM;
8248                 goto done;
8249         }
8250
8251         count = get_ntforms(&list);
8252
8253         if ( !delete_a_form(&list, form_name, &count, &status ))
8254                 goto done;
8255
8256         /*
8257          * ChangeID must always be set if this is a printer
8258          */
8259
8260         if ( Printer->printer_type == PRINTER_HANDLE_IS_PRINTER )
8261                 status = mod_a_printer(printer, 2);
8262
8263 done:
8264         if ( printer )
8265                 free_a_printer(&printer, 2);
8266         SAFE_FREE(list);
8267
8268         return status;
8269 }
8270
8271 /****************************************************************************
8272 ****************************************************************************/
8273
8274 WERROR _spoolss_setform(pipes_struct *p, SPOOL_Q_SETFORM *q_u, SPOOL_R_SETFORM *r_u)
8275 {
8276         POLICY_HND *handle = &q_u->handle;
8277         FORM *form = &q_u->form;
8278         nt_forms_struct tmpForm;
8279         int snum;
8280         WERROR status = WERR_OK;
8281         NT_PRINTER_INFO_LEVEL *printer = NULL;
8282
8283         int count=0;
8284         nt_forms_struct *list=NULL;
8285         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
8286
8287         DEBUG(5,("spoolss_setform\n"));
8288
8289         if (!Printer) {
8290                 DEBUG(2,("_spoolss_setform: Invalid handle (%s:%u:%u).\n", OUR_HANDLE(handle)));
8291                 return WERR_BADFID;
8292         }
8293
8294         /* forms can be modified on printer of on the print server handle */
8295
8296         if ( Printer->printer_type == PRINTER_HANDLE_IS_PRINTER )
8297         {
8298                 if (!get_printer_snum(p,handle, &snum))
8299                         return WERR_BADFID;
8300
8301                 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8302                 if (!W_ERROR_IS_OK(status))
8303                         goto done;
8304         }
8305
8306         if ( !(Printer->access_granted & (PRINTER_ACCESS_ADMINISTER|SERVER_ACCESS_ADMINISTER)) ) {
8307                 DEBUG(2,("_spoolss_setform: denied by handle permissions\n"));
8308                 status = WERR_ACCESS_DENIED;
8309                 goto done;
8310         }
8311
8312         /* can't set if builtin */
8313         if (get_a_builtin_ntform(&form->name,&tmpForm)) {
8314                 status = WERR_INVALID_PARAM;
8315                 goto done;
8316         }
8317
8318         count = get_ntforms(&list);
8319         update_a_form(&list, form, count);
8320         write_ntforms(&list, count);
8321
8322         /*
8323          * ChangeID must always be set if this is a printer
8324          */
8325
8326         if ( Printer->printer_type == PRINTER_HANDLE_IS_PRINTER )
8327                 status = mod_a_printer(printer, 2);
8328
8329
8330 done:
8331         if ( printer )
8332                 free_a_printer(&printer, 2);
8333         SAFE_FREE(list);
8334
8335         return status;
8336 }
8337
8338 /****************************************************************************
8339  enumprintprocessors level 1.
8340 ****************************************************************************/
8341
8342 static WERROR enumprintprocessors_level_1(RPC_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
8343 {
8344         PRINTPROCESSOR_1 *info_1=NULL;
8345         WERROR result = WERR_OK;
8346
8347         if((info_1 = SMB_MALLOC_P(PRINTPROCESSOR_1)) == NULL)
8348                 return WERR_NOMEM;
8349
8350         (*returned) = 0x1;
8351
8352         init_unistr(&info_1->name, "winprint");
8353
8354         *needed += spoolss_size_printprocessor_info_1(info_1);
8355
8356         if (*needed > offered) {
8357                 result = WERR_INSUFFICIENT_BUFFER;
8358                 goto out;
8359         }
8360
8361         if (!rpcbuf_alloc_size(buffer, *needed)) {
8362                 result = WERR_NOMEM;
8363                 goto out;
8364         }
8365
8366         smb_io_printprocessor_info_1("", buffer, info_1, 0);
8367
8368 out:
8369         SAFE_FREE(info_1);
8370
8371         if ( !W_ERROR_IS_OK(result) )
8372                 *returned = 0;
8373
8374         return result;
8375 }
8376
8377 /****************************************************************************
8378 ****************************************************************************/
8379
8380 WERROR _spoolss_enumprintprocessors(pipes_struct *p, SPOOL_Q_ENUMPRINTPROCESSORS *q_u, SPOOL_R_ENUMPRINTPROCESSORS *r_u)
8381 {
8382         uint32 level = q_u->level;
8383         RPC_BUFFER *buffer = NULL;
8384         uint32 offered = q_u->offered;
8385         uint32 *needed = &r_u->needed;
8386         uint32 *returned = &r_u->returned;
8387
8388         /* that's an [in out] buffer */
8389
8390         if ( q_u->buffer ) {
8391                 rpcbuf_move(q_u->buffer, &r_u->buffer);
8392                 buffer = r_u->buffer;
8393         }
8394
8395         DEBUG(5,("spoolss_enumprintprocessors\n"));
8396
8397         /*
8398          * Enumerate the print processors ...
8399          *
8400          * Just reply with "winprint", to keep NT happy
8401          * and I can use my nice printer checker.
8402          */
8403
8404         *returned=0;
8405         *needed=0;
8406
8407         switch (level) {
8408         case 1:
8409                 return enumprintprocessors_level_1(buffer, offered, needed, returned);
8410         default:
8411                 return WERR_UNKNOWN_LEVEL;
8412         }
8413 }
8414
8415 /****************************************************************************
8416  enumprintprocdatatypes level 1.
8417 ****************************************************************************/
8418
8419 static WERROR enumprintprocdatatypes_level_1(RPC_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
8420 {
8421         PRINTPROCDATATYPE_1 *info_1=NULL;
8422         WERROR result = WERR_NOMEM;
8423
8424         if((info_1 = SMB_MALLOC_P(PRINTPROCDATATYPE_1)) == NULL)
8425                 return WERR_NOMEM;
8426
8427         (*returned) = 0x1;
8428
8429         init_unistr(&info_1->name, "RAW");
8430
8431         *needed += spoolss_size_printprocdatatype_info_1(info_1);
8432
8433         if (*needed > offered) {
8434                 result = WERR_INSUFFICIENT_BUFFER;
8435                 goto out;
8436         }
8437
8438         if (!rpcbuf_alloc_size(buffer, *needed)) {
8439                 result = WERR_NOMEM;
8440                 goto out;
8441         }
8442
8443         smb_io_printprocdatatype_info_1("", buffer, info_1, 0);
8444
8445 out:
8446         SAFE_FREE(info_1);
8447
8448         if ( !W_ERROR_IS_OK(result) )
8449                 *returned = 0;
8450
8451         return result;
8452 }
8453
8454 /****************************************************************************
8455 ****************************************************************************/
8456
8457 WERROR _spoolss_enumprintprocdatatypes(pipes_struct *p, SPOOL_Q_ENUMPRINTPROCDATATYPES *q_u, SPOOL_R_ENUMPRINTPROCDATATYPES *r_u)
8458 {
8459         uint32 level = q_u->level;
8460         RPC_BUFFER *buffer = NULL;
8461         uint32 offered = q_u->offered;
8462         uint32 *needed = &r_u->needed;
8463         uint32 *returned = &r_u->returned;
8464
8465         /* that's an [in out] buffer */
8466
8467         if ( q_u->buffer ) {
8468                 rpcbuf_move(q_u->buffer, &r_u->buffer);
8469                 buffer = r_u->buffer;
8470         }
8471
8472         DEBUG(5,("_spoolss_enumprintprocdatatypes\n"));
8473
8474         *returned=0;
8475         *needed=0;
8476
8477         switch (level) {
8478         case 1:
8479                 return enumprintprocdatatypes_level_1(buffer, offered, needed, returned);
8480         default:
8481                 return WERR_UNKNOWN_LEVEL;
8482         }
8483 }
8484
8485 /****************************************************************************
8486  enumprintmonitors level 1.
8487 ****************************************************************************/
8488
8489 static WERROR enumprintmonitors_level_1(RPC_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
8490 {
8491         PRINTMONITOR_1 *info_1=NULL;
8492         WERROR result = WERR_OK;
8493
8494         if((info_1 = SMB_MALLOC_P(PRINTMONITOR_1)) == NULL)
8495                 return WERR_NOMEM;
8496
8497         (*returned) = 0x1;
8498
8499         init_unistr(&info_1->name, "Local Port");
8500
8501         *needed += spoolss_size_printmonitor_info_1(info_1);
8502
8503         if (*needed > offered) {
8504                 result = WERR_INSUFFICIENT_BUFFER;
8505                 goto out;
8506         }
8507
8508         if (!rpcbuf_alloc_size(buffer, *needed)) {
8509                 result = WERR_NOMEM;
8510                 goto out;
8511         }
8512
8513         smb_io_printmonitor_info_1("", buffer, info_1, 0);
8514
8515 out:
8516         SAFE_FREE(info_1);
8517
8518         if ( !W_ERROR_IS_OK(result) )
8519                 *returned = 0;
8520
8521         return result;
8522 }
8523
8524 /****************************************************************************
8525  enumprintmonitors level 2.
8526 ****************************************************************************/
8527
8528 static WERROR enumprintmonitors_level_2(RPC_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
8529 {
8530         PRINTMONITOR_2 *info_2=NULL;
8531         WERROR result = WERR_OK;
8532
8533         if((info_2 = SMB_MALLOC_P(PRINTMONITOR_2)) == NULL)
8534                 return WERR_NOMEM;
8535
8536         (*returned) = 0x1;
8537
8538         init_unistr(&info_2->name, "Local Port");
8539         init_unistr(&info_2->environment, "Windows NT X86");
8540         init_unistr(&info_2->dll_name, "localmon.dll");
8541
8542         *needed += spoolss_size_printmonitor_info_2(info_2);
8543
8544         if (*needed > offered) {
8545                 result = WERR_INSUFFICIENT_BUFFER;
8546                 goto out;
8547         }
8548
8549         if (!rpcbuf_alloc_size(buffer, *needed)) {
8550                 result = WERR_NOMEM;
8551                 goto out;
8552         }
8553
8554         smb_io_printmonitor_info_2("", buffer, info_2, 0);
8555
8556 out:
8557         SAFE_FREE(info_2);
8558
8559         if ( !W_ERROR_IS_OK(result) )
8560                 *returned = 0;
8561
8562         return result;
8563 }
8564
8565 /****************************************************************************
8566 ****************************************************************************/
8567
8568 WERROR _spoolss_enumprintmonitors(pipes_struct *p, SPOOL_Q_ENUMPRINTMONITORS *q_u, SPOOL_R_ENUMPRINTMONITORS *r_u)
8569 {
8570         uint32 level = q_u->level;
8571         RPC_BUFFER *buffer = NULL;
8572         uint32 offered = q_u->offered;
8573         uint32 *needed = &r_u->needed;
8574         uint32 *returned = &r_u->returned;
8575
8576         /* that's an [in out] buffer */
8577
8578         if ( q_u->buffer ) {
8579                 rpcbuf_move(q_u->buffer, &r_u->buffer);
8580                 buffer = r_u->buffer;
8581         }
8582
8583         DEBUG(5,("spoolss_enumprintmonitors\n"));
8584
8585         /*
8586          * Enumerate the print monitors ...
8587          *
8588          * Just reply with "Local Port", to keep NT happy
8589          * and I can use my nice printer checker.
8590          */
8591
8592         *returned=0;
8593         *needed=0;
8594
8595         switch (level) {
8596         case 1:
8597                 return enumprintmonitors_level_1(buffer, offered, needed, returned);
8598         case 2:
8599                 return enumprintmonitors_level_2(buffer, offered, needed, returned);
8600         default:
8601                 return WERR_UNKNOWN_LEVEL;
8602         }
8603 }
8604
8605 /****************************************************************************
8606 ****************************************************************************/
8607
8608 static WERROR getjob_level_1(print_queue_struct **queue, int count, int snum,
8609                              NT_PRINTER_INFO_LEVEL *ntprinter,
8610                              uint32 jobid, RPC_BUFFER *buffer, uint32 offered,
8611                              uint32 *needed)
8612 {
8613         int i=0;
8614         BOOL found=False;
8615         JOB_INFO_1 *info_1=NULL;
8616         WERROR result = WERR_OK;
8617
8618         info_1=SMB_MALLOC_P(JOB_INFO_1);
8619
8620         if (info_1 == NULL) {
8621                 return WERR_NOMEM;
8622         }
8623
8624         for (i=0; i<count && found==False; i++) {
8625                 if ((*queue)[i].job==(int)jobid)
8626                         found=True;
8627         }
8628
8629         if (found==False) {
8630                 SAFE_FREE(info_1);
8631                 /* NT treats not found as bad param... yet another bad choice */
8632                 return WERR_INVALID_PARAM;
8633         }
8634
8635         fill_job_info_1( info_1, &((*queue)[i-1]), i, snum, ntprinter );
8636
8637         *needed += spoolss_size_job_info_1(info_1);
8638
8639         if (*needed > offered) {
8640                 result = WERR_INSUFFICIENT_BUFFER;
8641                 goto out;
8642         }
8643
8644         if (!rpcbuf_alloc_size(buffer, *needed)) {
8645                 result = WERR_NOMEM;
8646                 goto out;
8647         }
8648
8649         smb_io_job_info_1("", buffer, info_1, 0);
8650
8651 out:
8652         SAFE_FREE(info_1);
8653
8654         return result;
8655 }
8656
8657 /****************************************************************************
8658 ****************************************************************************/
8659
8660 static WERROR getjob_level_2(print_queue_struct **queue, int count, int snum,
8661                              NT_PRINTER_INFO_LEVEL *ntprinter,
8662                              uint32 jobid, RPC_BUFFER *buffer, uint32 offered,
8663                              uint32 *needed)
8664 {
8665         int             i = 0;
8666         BOOL            found = False;
8667         JOB_INFO_2      *info_2;
8668         WERROR          result;
8669         DEVICEMODE      *devmode = NULL;
8670         NT_DEVICEMODE   *nt_devmode = NULL;
8671
8672         if ( !(info_2=SMB_MALLOC_P(JOB_INFO_2)) )
8673                 return WERR_NOMEM;
8674
8675         ZERO_STRUCTP(info_2);
8676
8677         for ( i=0; i<count && found==False; i++ )
8678         {
8679                 if ((*queue)[i].job == (int)jobid)
8680                         found = True;
8681         }
8682
8683         if ( !found ) {
8684                 /* NT treats not found as bad param... yet another bad
8685                    choice */
8686                 result = WERR_INVALID_PARAM;
8687                 goto done;
8688         }
8689
8690         /*
8691          * if the print job does not have a DEVMODE associated with it,
8692          * just use the one for the printer. A NULL devicemode is not
8693          *  a failure condition
8694          */
8695
8696         if ( !(nt_devmode=print_job_devmode( lp_const_servicename(snum), jobid )) )
8697                 devmode = construct_dev_mode(snum);
8698         else {
8699                 if ((devmode = SMB_MALLOC_P(DEVICEMODE)) != NULL) {
8700                         ZERO_STRUCTP( devmode );
8701                         convert_nt_devicemode( devmode, nt_devmode );
8702                 }
8703         }
8704
8705         fill_job_info_2(info_2, &((*queue)[i-1]), i, snum, ntprinter, devmode);
8706
8707         *needed += spoolss_size_job_info_2(info_2);
8708
8709         if (*needed > offered) {
8710                 result = WERR_INSUFFICIENT_BUFFER;
8711                 goto done;
8712         }
8713
8714         if (!rpcbuf_alloc_size(buffer, *needed)) {
8715                 result = WERR_NOMEM;
8716                 goto done;
8717         }
8718
8719         smb_io_job_info_2("", buffer, info_2, 0);
8720
8721         result = WERR_OK;
8722
8723  done:
8724         /* Cleanup allocated memory */
8725
8726         free_job_info_2(info_2);        /* Also frees devmode */
8727         SAFE_FREE(info_2);
8728
8729         return result;
8730 }
8731
8732 /****************************************************************************
8733 ****************************************************************************/
8734
8735 WERROR _spoolss_getjob( pipes_struct *p, SPOOL_Q_GETJOB *q_u, SPOOL_R_GETJOB *r_u)
8736 {
8737         POLICY_HND *handle = &q_u->handle;
8738         uint32 jobid = q_u->jobid;
8739         uint32 level = q_u->level;
8740         RPC_BUFFER *buffer = NULL;
8741         uint32 offered = q_u->offered;
8742         uint32 *needed = &r_u->needed;
8743         WERROR          wstatus = WERR_OK;
8744         NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
8745         int snum;
8746         int count;
8747         print_queue_struct      *queue = NULL;
8748         print_status_struct prt_status;
8749
8750         /* that's an [in out] buffer */
8751
8752         if ( q_u->buffer ) {
8753                 rpcbuf_move(q_u->buffer, &r_u->buffer);
8754                 buffer = r_u->buffer;
8755         }
8756
8757         DEBUG(5,("spoolss_getjob\n"));
8758
8759         *needed = 0;
8760
8761         if (!get_printer_snum(p, handle, &snum))
8762                 return WERR_BADFID;
8763
8764         wstatus = get_a_printer(NULL, &ntprinter, 2, lp_servicename(snum));
8765         if ( !W_ERROR_IS_OK(wstatus) )
8766                 return wstatus;
8767
8768         count = print_queue_status(snum, &queue, &prt_status);
8769
8770         DEBUGADD(4,("count:[%d], prt_status:[%d], [%s]\n",
8771                      count, prt_status.status, prt_status.message));
8772
8773         switch ( level ) {
8774         case 1:
8775                         wstatus = getjob_level_1(&queue, count, snum, ntprinter, jobid,
8776                                 buffer, offered, needed);
8777                         break;
8778         case 2:
8779                         wstatus = getjob_level_2(&queue, count, snum, ntprinter, jobid,
8780                                 buffer, offered, needed);
8781                         break;
8782         default:
8783                         wstatus = WERR_UNKNOWN_LEVEL;
8784                         break;
8785         }
8786
8787         SAFE_FREE(queue);
8788         free_a_printer( &ntprinter, 2 );
8789
8790         return wstatus;
8791 }
8792
8793 /********************************************************************
8794  spoolss_getprinterdataex
8795
8796  From MSDN documentation of GetPrinterDataEx: pass request
8797  to GetPrinterData if key is "PrinterDriverData".
8798  ********************************************************************/
8799
8800 WERROR _spoolss_getprinterdataex(pipes_struct *p, SPOOL_Q_GETPRINTERDATAEX *q_u, SPOOL_R_GETPRINTERDATAEX *r_u)
8801 {
8802         POLICY_HND      *handle = &q_u->handle;
8803         uint32          in_size = q_u->size;
8804         uint32          *type = &r_u->type;
8805         uint32          *out_size = &r_u->size;
8806         uint8           **data = &r_u->data;
8807         uint32          *needed = &r_u->needed;
8808         fstring         keyname, valuename;
8809
8810         Printer_entry   *Printer = find_printer_index_by_hnd(p, handle);
8811
8812         NT_PRINTER_INFO_LEVEL   *printer = NULL;
8813         int                     snum = 0;
8814         WERROR                  status = WERR_OK;
8815
8816         DEBUG(4,("_spoolss_getprinterdataex\n"));
8817
8818         unistr2_to_ascii(keyname, &q_u->keyname, sizeof(keyname) - 1);
8819         unistr2_to_ascii(valuename, &q_u->valuename, sizeof(valuename) - 1);
8820
8821         DEBUG(10, ("_spoolss_getprinterdataex: key => [%s], value => [%s]\n",
8822                 keyname, valuename));
8823
8824         /* in case of problem, return some default values */
8825
8826         *needed   = 0;
8827         *type     = 0;
8828         *out_size = in_size;
8829
8830         if (!Printer) {
8831                 DEBUG(2,("_spoolss_getprinterdataex: Invalid handle (%s:%u:%u).\n", OUR_HANDLE(handle)));
8832                 status = WERR_BADFID;
8833                 goto done;
8834         }
8835
8836         /* Is the handle to a printer or to the server? */
8837
8838         if (Printer->printer_type == PRINTER_HANDLE_IS_PRINTSERVER) {
8839                 DEBUG(10,("_spoolss_getprinterdataex: Not implemented for server handles yet\n"));
8840                 status = WERR_INVALID_PARAM;
8841                 goto done;
8842         }
8843
8844         if ( !get_printer_snum(p,handle, &snum) )
8845                 return WERR_BADFID;
8846
8847         status = get_a_printer(Printer, &printer, 2, lp_servicename(snum));
8848         if ( !W_ERROR_IS_OK(status) )
8849                 goto done;
8850
8851         /* check to see if the keyname is valid */
8852         if ( !strlen(keyname) ) {
8853                 status = WERR_INVALID_PARAM;
8854                 goto done;
8855         }
8856
8857         if ( lookup_printerkey( printer->info_2->data, keyname ) == -1 ) {
8858                 DEBUG(4,("_spoolss_getprinterdataex: Invalid keyname [%s]\n", keyname ));
8859                 free_a_printer( &printer, 2 );
8860                 status = WERR_BADFILE;
8861                 goto done;
8862         }
8863
8864         /* When given a new keyname, we should just create it */
8865
8866         status = get_printer_dataex( p->mem_ctx, printer, keyname, valuename, type, data, needed, in_size );
8867
8868         if (*needed > *out_size)
8869                 status = WERR_MORE_DATA;
8870
8871 done:
8872         if ( !W_ERROR_IS_OK(status) )
8873         {
8874                 DEBUG(5, ("error: allocating %d\n", *out_size));
8875
8876                 /* reply this param doesn't exist */
8877
8878                 if ( *out_size )
8879                 {
8880                         if( (*data=(uint8 *)TALLOC_ZERO(p->mem_ctx, *out_size*sizeof(uint8))) == NULL ) {
8881                                 status = WERR_NOMEM;
8882                                 goto done;
8883                         }
8884                 }
8885                 else {
8886                         *data = NULL;
8887         }
8888         }
8889
8890         if ( printer )
8891         free_a_printer( &printer, 2 );
8892
8893         return status;
8894 }
8895
8896 /********************************************************************
8897  * spoolss_setprinterdataex
8898  ********************************************************************/
8899
8900 WERROR _spoolss_setprinterdataex(pipes_struct *p, SPOOL_Q_SETPRINTERDATAEX *q_u, SPOOL_R_SETPRINTERDATAEX *r_u)
8901 {
8902         POLICY_HND              *handle = &q_u->handle;
8903         uint32                  type = q_u->type;
8904         uint8                   *data = q_u->data;
8905         uint32                  real_len = q_u->real_len;
8906
8907         NT_PRINTER_INFO_LEVEL   *printer = NULL;
8908         int                     snum = 0;
8909         WERROR                  status = WERR_OK;
8910         Printer_entry           *Printer = find_printer_index_by_hnd(p, handle);
8911         fstring                 valuename;
8912         fstring                 keyname;
8913         char                    *oid_string;
8914
8915         DEBUG(4,("_spoolss_setprinterdataex\n"));
8916
8917         /* From MSDN documentation of SetPrinterDataEx: pass request to
8918            SetPrinterData if key is "PrinterDriverData" */
8919
8920         if (!Printer) {
8921                 DEBUG(2,("_spoolss_setprinterdataex: Invalid handle (%s:%u:%u).\n", OUR_HANDLE(handle)));
8922                 return WERR_BADFID;
8923         }
8924
8925         if ( Printer->printer_type == PRINTER_HANDLE_IS_PRINTSERVER ) {
8926                 DEBUG(10,("_spoolss_setprinterdataex: Not implemented for server handles yet\n"));
8927                 return WERR_INVALID_PARAM;
8928         }
8929
8930         if ( !get_printer_snum(p,handle, &snum) )
8931                 return WERR_BADFID;
8932
8933         /*
8934          * Access check : NT returns "access denied" if you make a
8935          * SetPrinterData call without the necessary privildge.
8936          * we were originally returning OK if nothing changed
8937          * which made Win2k issue **a lot** of SetPrinterData
8938          * when connecting to a printer  --jerry
8939          */
8940
8941         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER)
8942         {
8943                 DEBUG(3, ("_spoolss_setprinterdataex: change denied by handle access permissions\n"));
8944                 return WERR_ACCESS_DENIED;
8945         }
8946
8947         status = get_a_printer(Printer, &printer, 2, lp_servicename(snum));
8948         if (!W_ERROR_IS_OK(status))
8949                 return status;
8950
8951         unistr2_to_ascii( valuename, &q_u->value, sizeof(valuename) - 1);
8952         unistr2_to_ascii( keyname, &q_u->key, sizeof(keyname) - 1);
8953
8954         /* check for OID in valuename */
8955
8956         if ( (oid_string = strchr( valuename, ',' )) != NULL )
8957         {
8958                 *oid_string = '\0';
8959                 oid_string++;
8960         }
8961
8962         /* save the registry data */
8963
8964         status = set_printer_dataex( printer, keyname, valuename, type, data, real_len );
8965
8966         if ( W_ERROR_IS_OK(status) )
8967         {
8968                 /* save the OID if one was specified */
8969                 if ( oid_string ) {
8970                         fstrcat( keyname, "\\" );
8971                         fstrcat( keyname, SPOOL_OID_KEY );
8972
8973                         /*
8974                          * I'm not checking the status here on purpose.  Don't know
8975                          * if this is right, but I'm returning the status from the
8976                          * previous set_printer_dataex() call.  I have no idea if
8977                          * this is right.    --jerry
8978                          */
8979
8980                         set_printer_dataex( printer, keyname, valuename,
8981                                             REG_SZ, (void*)oid_string, strlen(oid_string)+1 );
8982                 }
8983
8984                 status = mod_a_printer(printer, 2);
8985         }
8986
8987         free_a_printer(&printer, 2);
8988
8989         return status;
8990 }
8991
8992
8993 /********************************************************************
8994  * spoolss_deleteprinterdataex
8995  ********************************************************************/
8996
8997 WERROR _spoolss_deleteprinterdataex(pipes_struct *p, SPOOL_Q_DELETEPRINTERDATAEX *q_u, SPOOL_R_DELETEPRINTERDATAEX *r_u)
8998 {
8999         POLICY_HND      *handle = &q_u->handle;
9000         UNISTR2         *value = &q_u->valuename;
9001         UNISTR2         *key = &q_u->keyname;
9002
9003         NT_PRINTER_INFO_LEVEL   *printer = NULL;
9004         int             snum=0;
9005         WERROR          status = WERR_OK;
9006         Printer_entry   *Printer=find_printer_index_by_hnd(p, handle);
9007         pstring         valuename, keyname;
9008
9009         DEBUG(5,("spoolss_deleteprinterdataex\n"));
9010
9011         if (!Printer) {
9012                 DEBUG(2,("_spoolss_deleteprinterdata: Invalid handle (%s:%u:%u).\n", OUR_HANDLE(handle)));
9013                 return WERR_BADFID;
9014         }
9015
9016         if (!get_printer_snum(p, handle, &snum))
9017                 return WERR_BADFID;
9018
9019         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9020                 DEBUG(3, ("_spoolss_deleteprinterdataex: printer properties change denied by handle\n"));
9021                 return WERR_ACCESS_DENIED;
9022         }
9023
9024         status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9025         if (!W_ERROR_IS_OK(status))
9026                 return status;
9027
9028         unistr2_to_ascii( valuename, value, sizeof(valuename)-1 );
9029         unistr2_to_ascii( keyname, key, sizeof(keyname)-1 );
9030
9031         status = delete_printer_dataex( printer, keyname, valuename );
9032
9033         if ( W_ERROR_IS_OK(status) )
9034                 mod_a_printer( printer, 2 );
9035
9036         free_a_printer(&printer, 2);
9037
9038         return status;
9039 }
9040
9041 /********************************************************************
9042  * spoolss_enumprinterkey
9043  ********************************************************************/
9044
9045
9046 WERROR _spoolss_enumprinterkey(pipes_struct *p, SPOOL_Q_ENUMPRINTERKEY *q_u, SPOOL_R_ENUMPRINTERKEY *r_u)
9047 {
9048         fstring         key;
9049         fstring         *keynames = NULL;
9050         uint16          *enumkeys = NULL;
9051         int             num_keys;
9052         int             printerkey_len;
9053         POLICY_HND      *handle = &q_u->handle;
9054         Printer_entry   *Printer = find_printer_index_by_hnd(p, handle);
9055         NT_PRINTER_DATA *data;
9056         NT_PRINTER_INFO_LEVEL   *printer = NULL;
9057         int             snum = 0;
9058         WERROR          status = WERR_BADFILE;
9059
9060
9061         DEBUG(4,("_spoolss_enumprinterkey\n"));
9062
9063         if (!Printer) {
9064                 DEBUG(2,("_spoolss_enumprinterkey: Invalid handle (%s:%u:%u).\n", OUR_HANDLE(handle)));
9065                 return WERR_BADFID;
9066         }
9067
9068         if ( !get_printer_snum(p,handle, &snum) )
9069                 return WERR_BADFID;
9070
9071         status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9072         if (!W_ERROR_IS_OK(status))
9073                 return status;
9074
9075         /* get the list of subkey names */
9076
9077         unistr2_to_ascii( key, &q_u->key, sizeof(key)-1 );
9078         data = printer->info_2->data;
9079
9080         num_keys = get_printer_subkeys( data, key, &keynames );
9081
9082         if ( num_keys == -1 ) {
9083                 status = WERR_BADFILE;
9084                 goto done;
9085         }
9086
9087         printerkey_len = init_unistr_array( &enumkeys,  keynames, NULL );
9088
9089         r_u->needed = printerkey_len*2;
9090
9091         if ( q_u->size < r_u->needed ) {
9092                 status = WERR_MORE_DATA;
9093                 goto done;
9094         }
9095
9096         if (!make_spoolss_buffer5(p->mem_ctx, &r_u->keys, printerkey_len, enumkeys)) {
9097                 status = WERR_NOMEM;
9098                 goto done;
9099         }
9100
9101         status = WERR_OK;
9102
9103         if ( q_u->size < r_u->needed )
9104                 status = WERR_MORE_DATA;
9105
9106 done:
9107         free_a_printer( &printer, 2 );
9108         SAFE_FREE( keynames );
9109
9110         return status;
9111 }
9112
9113 /********************************************************************
9114  * spoolss_deleteprinterkey
9115  ********************************************************************/
9116
9117 WERROR _spoolss_deleteprinterkey(pipes_struct *p, SPOOL_Q_DELETEPRINTERKEY *q_u, SPOOL_R_DELETEPRINTERKEY *r_u)
9118 {
9119         POLICY_HND              *handle = &q_u->handle;
9120         Printer_entry           *Printer = find_printer_index_by_hnd(p, &q_u->handle);
9121         fstring                 key;
9122         NT_PRINTER_INFO_LEVEL   *printer = NULL;
9123         int                     snum=0;
9124         WERROR                  status;
9125
9126         DEBUG(5,("spoolss_deleteprinterkey\n"));
9127
9128         if (!Printer) {
9129                 DEBUG(2,("_spoolss_deleteprinterkey: Invalid handle (%s:%u:%u).\n", OUR_HANDLE(handle)));
9130                 return WERR_BADFID;
9131         }
9132
9133         /* if keyname == NULL, return error */
9134
9135         if ( !q_u->keyname.buffer )
9136                 return WERR_INVALID_PARAM;
9137
9138         if (!get_printer_snum(p, handle, &snum))
9139                 return WERR_BADFID;
9140
9141         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9142                 DEBUG(3, ("_spoolss_deleteprinterkey: printer properties change denied by handle\n"));
9143                 return WERR_ACCESS_DENIED;
9144         }
9145
9146         status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9147         if (!W_ERROR_IS_OK(status))
9148                 return status;
9149
9150         /* delete the key and all subneys */
9151
9152         unistr2_to_ascii(key, &q_u->keyname, sizeof(key) - 1);
9153
9154         status = delete_all_printer_data( printer->info_2, key );
9155
9156         if ( W_ERROR_IS_OK(status) )
9157                 status = mod_a_printer(printer, 2);
9158
9159         free_a_printer( &printer, 2 );
9160
9161         return status;
9162 }
9163
9164
9165 /********************************************************************
9166  * spoolss_enumprinterdataex
9167  ********************************************************************/
9168
9169 WERROR _spoolss_enumprinterdataex(pipes_struct *p, SPOOL_Q_ENUMPRINTERDATAEX *q_u, SPOOL_R_ENUMPRINTERDATAEX *r_u)
9170 {
9171         POLICY_HND      *handle = &q_u->handle;
9172         uint32          in_size = q_u->size;
9173         uint32          num_entries,
9174                         needed;
9175         NT_PRINTER_INFO_LEVEL   *printer = NULL;
9176         PRINTER_ENUM_VALUES     *enum_values = NULL;
9177         NT_PRINTER_DATA         *p_data;
9178         fstring         key;
9179         Printer_entry   *Printer = find_printer_index_by_hnd(p, handle);
9180         int             snum;
9181         WERROR          result;
9182         int             key_index;
9183         int             i;
9184         REGISTRY_VALUE  *val;
9185         char            *value_name;
9186         uint32          data_len;
9187
9188
9189         DEBUG(4,("_spoolss_enumprinterdataex\n"));
9190
9191         if (!Printer) {
9192                 DEBUG(2,("_spoolss_enumprinterdataex: Invalid handle (%s:%u:%u1<).\n", OUR_HANDLE(handle)));
9193                 return WERR_BADFID;
9194         }
9195
9196         /*
9197          * first check for a keyname of NULL or "".  Win2k seems to send
9198          * this a lot and we should send back WERR_INVALID_PARAM
9199          * no need to spend time looking up the printer in this case.
9200          * --jerry
9201          */
9202
9203         unistr2_to_ascii(key, &q_u->key, sizeof(key) - 1);
9204         if ( !strlen(key) ) {
9205                 result = WERR_INVALID_PARAM;
9206                 goto done;
9207         }
9208
9209         /* get the printer off of disk */
9210
9211         if (!get_printer_snum(p,handle, &snum))
9212                 return WERR_BADFID;
9213
9214         ZERO_STRUCT(printer);
9215         result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9216         if (!W_ERROR_IS_OK(result))
9217                 return result;
9218
9219         /* now look for a match on the key name */
9220
9221         p_data = printer->info_2->data;
9222
9223         unistr2_to_ascii(key, &q_u->key, sizeof(key) - 1);
9224         if ( (key_index = lookup_printerkey( p_data, key)) == -1  )
9225         {
9226                 DEBUG(10,("_spoolss_enumprinterdataex: Unknown keyname [%s]\n", key));
9227                 result = WERR_INVALID_PARAM;
9228                 goto done;
9229         }
9230
9231         result = WERR_OK;
9232         needed = 0;
9233
9234         /* allocate the memory for the array of pointers -- if necessary */
9235
9236         num_entries = regval_ctr_numvals( p_data->keys[key_index].values );
9237         if ( num_entries )
9238         {
9239                 if ( (enum_values=TALLOC_ARRAY(p->mem_ctx, PRINTER_ENUM_VALUES, num_entries)) == NULL )
9240                 {
9241                         DEBUG(0,("_spoolss_enumprinterdataex: talloc() failed to allocate memory for [%lu] bytes!\n",
9242                                 (unsigned long)num_entries*sizeof(PRINTER_ENUM_VALUES)));
9243                         result = WERR_NOMEM;
9244                         goto done;
9245                 }
9246
9247                 memset( enum_values, 0x0, num_entries*sizeof(PRINTER_ENUM_VALUES) );
9248         }
9249
9250         /*
9251          * loop through all params and build the array to pass
9252          * back to the  client
9253          */
9254
9255         for ( i=0; i<num_entries; i++ )
9256         {
9257                 /* lookup the registry value */
9258
9259                 val = regval_ctr_specific_value( p_data->keys[key_index].values, i );
9260                 DEBUG(10,("retrieved value number [%d] [%s]\n", i, regval_name(val) ));
9261
9262                 /* copy the data */
9263
9264                 value_name = regval_name( val );
9265                 init_unistr( &enum_values[i].valuename, value_name );
9266                 enum_values[i].value_len = (strlen(value_name)+1) * 2;
9267                 enum_values[i].type      = regval_type( val );
9268
9269                 data_len = regval_size( val );
9270                 if ( data_len ) {
9271                         if ( !(enum_values[i].data = TALLOC_MEMDUP(p->mem_ctx, regval_data_p(val), data_len)) )
9272                         {
9273                                 DEBUG(0,("talloc_memdup failed to allocate memory [data_len=%d] for data!\n",
9274                                         data_len ));
9275                                 result = WERR_NOMEM;
9276                                 goto done;
9277                         }
9278                 }
9279                 enum_values[i].data_len = data_len;
9280
9281                 /* keep track of the size of the array in bytes */
9282
9283                 needed += spoolss_size_printer_enum_values(&enum_values[i]);
9284         }
9285
9286         /* housekeeping information in the reply */
9287
9288         r_u->needed     = needed;
9289         r_u->returned   = num_entries;
9290
9291         if (needed > in_size) {
9292                 result = WERR_MORE_DATA;
9293                 goto done;
9294         }
9295
9296         /* copy data into the reply */
9297
9298         r_u->ctr.size           = r_u->needed;
9299         r_u->ctr.size_of_array  = r_u->returned;
9300         r_u->ctr.values         = enum_values;
9301
9302
9303
9304 done:
9305         if ( printer )
9306         free_a_printer(&printer, 2);
9307
9308         return result;
9309 }
9310
9311 /****************************************************************************
9312 ****************************************************************************/
9313
9314 static void fill_printprocessordirectory_1(PRINTPROCESSOR_DIRECTORY_1 *info, char *name)
9315 {
9316         init_unistr(&info->name, name);
9317 }
9318
9319 static WERROR getprintprocessordirectory_level_1(UNISTR2 *name,
9320                                                  UNISTR2 *environment,
9321                                                  RPC_BUFFER *buffer,
9322                                                  uint32 offered,
9323                                                  uint32 *needed)
9324 {
9325         pstring path;
9326         pstring long_archi;
9327         PRINTPROCESSOR_DIRECTORY_1 *info=NULL;
9328         WERROR result = WERR_OK;
9329
9330         unistr2_to_ascii(long_archi, environment, sizeof(long_archi)-1);
9331
9332         if (!get_short_archi(long_archi))
9333                 return WERR_INVALID_ENVIRONMENT;
9334
9335         if((info=SMB_MALLOC_P(PRINTPROCESSOR_DIRECTORY_1)) == NULL)
9336                 return WERR_NOMEM;
9337
9338         pstrcpy(path, "C:\\WINNT\\System32\\spool\\PRTPROCS\\W32X86");
9339
9340         fill_printprocessordirectory_1(info, path);
9341
9342         *needed += spoolss_size_printprocessordirectory_info_1(info);
9343
9344         if (*needed > offered) {
9345                 result = WERR_INSUFFICIENT_BUFFER;
9346                 goto out;
9347         }
9348
9349         if (!rpcbuf_alloc_size(buffer, *needed)) {
9350                 result = WERR_INSUFFICIENT_BUFFER;
9351                 goto out;
9352         }
9353
9354         smb_io_printprocessordirectory_1("", buffer, info, 0);
9355
9356 out:
9357         SAFE_FREE(info);
9358
9359         return result;
9360 }
9361
9362 WERROR _spoolss_getprintprocessordirectory(pipes_struct *p, SPOOL_Q_GETPRINTPROCESSORDIRECTORY *q_u, SPOOL_R_GETPRINTPROCESSORDIRECTORY *r_u)
9363 {
9364         uint32 level = q_u->level;
9365         RPC_BUFFER *buffer = NULL;
9366         uint32 offered = q_u->offered;
9367         uint32 *needed = &r_u->needed;
9368         WERROR result;
9369
9370         /* that's an [in out] buffer */
9371
9372         if ( q_u->buffer ) {
9373                 rpcbuf_move(q_u->buffer, &r_u->buffer);
9374                 buffer = r_u->buffer;
9375         }
9376
9377         DEBUG(5,("_spoolss_getprintprocessordirectory\n"));
9378
9379         *needed=0;
9380
9381         switch(level) {
9382         case 1:
9383                 result = getprintprocessordirectory_level_1
9384                   (&q_u->name, &q_u->environment, buffer, offered, needed);
9385                 break;
9386         default:
9387                 result = WERR_UNKNOWN_LEVEL;
9388         }
9389
9390         return result;
9391 }
9392
9393 #if 0
9394
9395 WERROR _spoolss_replyopenprinter(pipes_struct *p, SPOOL_Q_REPLYOPENPRINTER *q_u,
9396                                  SPOOL_R_REPLYOPENPRINTER *r_u)
9397 {
9398         DEBUG(5,("_spoolss_replyopenprinter\n"));
9399
9400         DEBUG(10, ("replyopenprinter for localprinter %d\n", q_u->printer));
9401
9402         return WERR_OK;
9403 }
9404
9405 WERROR _spoolss_replycloseprinter(pipes_struct *p, SPOOL_Q_REPLYCLOSEPRINTER *q_u,
9406                                   SPOOL_R_REPLYCLOSEPRINTER *r_u)
9407 {
9408         DEBUG(5,("_spoolss_replycloseprinter\n"));
9409         return WERR_OK;
9410 }
9411
9412 #endif