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