source3/rpc_server/srv_spoolss_nt.c

   1 /*
   2  *  Unix SMB/Netbios implementation.
   3  *  Version 1.9.
   4  *  RPC Pipe client / server routines
   5  *  Copyright (C) Andrew Tridgell              1992-2000,
   6  *  Copyright (C) Luke Kenneth Casson Leighton 1996-2000,
   7  *  Copyright (C) Jean François Micouleau      1998-2000.
   8  *  Copyright (C) Jeremy Allison                    2001.
   9  *  Copyright (C) Gerald Carter                2000-2001.
  10  *  Copyright (C) Tim Potter                        2001.
  11  *
  12  *  This program is free software; you can redistribute it and/or modify
  13  *  it under the terms of the GNU General Public License as published by
  14  *  the Free Software Foundation; either version 2 of the License, or
  15  *  (at your option) any later version.
  16  *
  17  *  This program is distributed in the hope that it will be useful,
  18  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  *  GNU General Public License for more details.
  21  *
  22  *  You should have received a copy of the GNU General Public License
  23  *  along with this program; if not, write to the Free Software
  24  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  25  */
  26
  27 /* Since the SPOOLSS rpc routines are basically DOS 16-bit calls wrapped
  28    up, all the errors returned are DOS errors, not NT status codes. */
  29
  30 #include "includes.h"
  31
  32 #ifndef MAX_OPEN_PRINTER_EXS
  33 #define MAX_OPEN_PRINTER_EXS 50
  34 #endif
  35
  36 #define PHANTOM_DEVMODE_KEY "_p_f_a_n_t_0_m_"
  37 #define PRINTER_HANDLE_IS_PRINTER       0
  38 #define PRINTER_HANDLE_IS_PRINTSERVER   1
  39
  40 struct table_node {
  41         char    *long_archi;
  42         char    *short_archi;
  43         int     version;
  44 };
  45
  46
  47 /* structure to store the printer handles */
  48 /* and a reference to what it's pointing to */
  49 /* and the notify info asked about */
  50 /* that's the central struct */
  51 typedef struct _Printer{
  52         BOOL document_started;
  53         BOOL page_started;
  54     int jobid; /* jobid in printing backend */
  55         BOOL printer_type;
  56         union {
  57                 fstring handlename;
  58                 fstring printerservername;
  59         } dev;
  60         uint32 type;
  61         uint32 access;
  62         struct {
  63                 uint32 flags;
  64                 uint32 options;
  65                 fstring localmachine;
  66                 uint32 printerlocal;
  67                 SPOOL_NOTIFY_OPTION *option;
  68                 POLICY_HND client_hnd;
  69                 uint32 client_connected;
  70         } notify;
  71         struct {
  72                 fstring machine;
  73                 fstring user;
  74         } client;
  75 } Printer_entry;
  76
  77 typedef struct _counter_printer_0 {
  78         ubi_dlNode Next;
  79         ubi_dlNode Prev;
  80
  81         int snum;
  82         uint32 counter;
  83 } counter_printer_0;
  84
  85 static ubi_dlList counter_list;
  86
  87 static struct cli_state cli;
  88 static uint32 smb_connections=0;
  89
  90 #define OUR_HANDLE(hnd) ((hnd==NULL)?"NULL":(IVAL(hnd->data5,4)==(uint32)sys_getpid()?"OURS":"OTHER"))
  91
  92 /* translate between internal status numbers and NT status numbers */
  93 static int nt_printj_status(int v)
  94 {
  95         switch (v) {
  96         case LPQ_QUEUED:
  97                 return 0;
  98         case LPQ_PAUSED:
  99                 return JOB_STATUS_PAUSED;
 100         case LPQ_SPOOLING:
 101                 return JOB_STATUS_SPOOLING;
 102         case LPQ_PRINTING:
 103                 return JOB_STATUS_PRINTING;
 104         case LPQ_ERROR:
 105                 return JOB_STATUS_ERROR;
 106         case LPQ_DELETING:
 107                 return JOB_STATUS_DELETING;
 108         case LPQ_OFFLINE:
 109                 return JOB_STATUS_OFFLINE;
 110         case LPQ_PAPEROUT:
 111                 return JOB_STATUS_PAPEROUT;
 112         case LPQ_PRINTED:
 113                 return JOB_STATUS_PRINTED;
 114         case LPQ_DELETED:
 115                 return JOB_STATUS_DELETED;
 116         case LPQ_BLOCKED:
 117                 return JOB_STATUS_BLOCKED;
 118         case LPQ_USER_INTERVENTION:
 119                 return JOB_STATUS_USER_INTERVENTION;
 120         }
 121         return 0;
 122 }
 123
 124 static int nt_printq_status(int v)
 125 {
 126         switch (v) {
 127         case LPQ_PAUSED:
 128                 return PRINTER_STATUS_PAUSED;
 129         case LPQ_QUEUED:
 130         case LPQ_SPOOLING:
 131         case LPQ_PRINTING:
 132                 return 0;
 133         }
 134         return 0;
 135 }
 136
 137 /****************************************************************************
 138  Functions to handle SPOOL_NOTIFY_OPTION struct stored in Printer_entry.
 139 ****************************************************************************/
 140
 141 static void free_spool_notify_option(SPOOL_NOTIFY_OPTION **pp)
 142 {
 143         if (*pp == NULL)
 144                 return;
 145
 146         SAFE_FREE((*pp)->ctr.type);
 147         SAFE_FREE(*pp);
 148 }
 149
 150 /***************************************************************************
 151  Disconnect from the client
 152 ****************************************************************************/
 153
 154 static void srv_spoolss_replycloseprinter(POLICY_HND *handle)
 155 {
 156         WERROR status;
 157
 158         /* weird if the test succeds !!! */
 159         if (smb_connections==0) {
 160                 DEBUG(0,("srv_spoolss_replycloseprinter:Trying to close non-existant notify backchannel !\n"));
 161                 return;
 162         }
 163
 164         if(!cli_spoolss_reply_close_printer(&cli, handle, &status))
 165                 DEBUG(0,("srv_spoolss_replycloseprinter: reply_close_printer failed.\n"));
 166
 167         /* if it's the last connection, deconnect the IPC$ share */
 168         if (smb_connections==1) {
 169                 if(!spoolss_disconnect_from_client(&cli))
 170                         return;
 171
 172                 message_deregister(MSG_PRINTER_NOTIFY);
 173         }
 174
 175         smb_connections--;
 176 }
 177
 178 /****************************************************************************
 179  Functions to free a printer entry datastruct.
 180 ****************************************************************************/
 181
 182 static void free_printer_entry(void *ptr)
 183 {
 184         Printer_entry *Printer = (Printer_entry *)ptr;
 185
 186         if (Printer->notify.client_connected==True)
 187                 srv_spoolss_replycloseprinter(&Printer->notify.client_hnd);
 188
 189         Printer->notify.flags=0;
 190         Printer->notify.options=0;
 191         Printer->notify.localmachine[0]='\0';
 192         Printer->notify.printerlocal=0;
 193         free_spool_notify_option(&Printer->notify.option);
 194         Printer->notify.option=NULL;
 195         Printer->notify.client_connected=False;
 196
 197         SAFE_FREE(Printer);
 198 }
 199
 200 /****************************************************************************
 201  Functions to duplicate a SPOOL_NOTIFY_OPTION struct stored in Printer_entry.
 202 ****************************************************************************/
 203
 204 SPOOL_NOTIFY_OPTION *dup_spool_notify_option(SPOOL_NOTIFY_OPTION *sp)
 205 {
 206         SPOOL_NOTIFY_OPTION *new_sp = NULL;
 207
 208         if (!sp)
 209                 return NULL;
 210
 211         new_sp = (SPOOL_NOTIFY_OPTION *)malloc(sizeof(SPOOL_NOTIFY_OPTION));
 212         if (!new_sp)
 213                 return NULL;
 214
 215         *new_sp = *sp;
 216
 217         if (sp->ctr.count) {
 218                 new_sp->ctr.type = (SPOOL_NOTIFY_OPTION_TYPE *)memdup(sp->ctr.type, sizeof(SPOOL_NOTIFY_OPTION_TYPE) * sp->ctr.count);
 219
 220                 if (!new_sp->ctr.type) {
 221                         SAFE_FREE(new_sp);
 222                         return NULL;
 223                 }
 224         }
 225
 226         return new_sp;
 227 }
 228
 229 /****************************************************************************
 230   find printer index by handle
 231 ****************************************************************************/
 232
 233 static Printer_entry *find_printer_index_by_hnd(pipes_struct *p, POLICY_HND *hnd)
 234 {
 235         Printer_entry *find_printer = NULL;
 236
 237         if(!find_policy_by_hnd(p,hnd,(void **)&find_printer)) {
 238                 DEBUG(3,("find_printer_index_by_hnd: Printer handle not found: "));
 239                 return NULL;
 240         }
 241
 242         return find_printer;
 243 }
 244
 245 /****************************************************************************
 246   close printer index by handle
 247 ****************************************************************************/
 248
 249 static BOOL close_printer_handle(pipes_struct *p, POLICY_HND *hnd)
 250 {
 251         Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
 252
 253         if (!Printer) {
 254                 DEBUG(0,("close_printer_handle: Invalid handle (%s)\n", OUR_HANDLE(hnd)));
 255                 return False;
 256         }
 257
 258         close_policy_hnd(p, hnd);
 259
 260         return True;
 261 }
 262
 263 /****************************************************************************
 264   delete a printer given a handle
 265 ****************************************************************************/
 266 static WERROR delete_printer_handle(pipes_struct *p, POLICY_HND *hnd)
 267 {
 268         Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
 269
 270         if (!Printer) {
 271                 DEBUG(0,("delete_printer_handle: Invalid handle (%s)\n", OUR_HANDLE(hnd)));
 272                 return WERR_BADFID;
 273         }
 274
 275         if (del_a_printer(Printer->dev.handlename) != 0) {
 276                 DEBUG(3,("Error deleting printer %s\n", Printer->dev.handlename));
 277                 return WERR_BADFID;
 278         }
 279
 280         /* Check calling user has permission to delete printer.  Note that
 281            since we set the snum parameter to -1 only administrators can
 282            delete the printer.  This stops people with the Full Control
 283            permission from deleting the printer. */
 284
 285         if (!print_access_check(NULL, -1, PRINTER_ACCESS_ADMINISTER)) {
 286                 DEBUG(3, ("printer delete denied by security descriptor\n"));
 287                 return WERR_ACCESS_DENIED;
 288         }
 289
 290         if (*lp_deleteprinter_cmd()) {
 291
 292                 char *cmd = lp_deleteprinter_cmd();
 293                 pstring command;
 294                 int ret;
 295                 int i;
 296
 297                 /* Printer->dev.handlename equals portname equals sharename */
 298                 slprintf(command, sizeof(command)-1, "%s \"%s\"", cmd,
 299                                         Printer->dev.handlename);
 300
 301                 DEBUG(10,("Running [%s]\n", command));
 302                 ret = smbrun(command, NULL);
 303                 if (ret != 0) {
 304                         return WERR_BADFID; /* What to return here? */
 305                 }
 306                 DEBUGADD(10,("returned [%d]\n", ret));
 307
 308                 /* Send SIGHUP to process group... is there a better way? */
 309                 kill(0, SIGHUP);
 310
 311                 if ( ( i = lp_servicenumber( Printer->dev.handlename ) ) >= 0 ) {
 312                         lp_killservice( i );
 313                         return WERR_OK;
 314                 } else
 315                         return WERR_ACCESS_DENIED;
 316         }
 317
 318         return WERR_OK;
 319 }
 320
 321 /****************************************************************************
 322   return the snum of a printer corresponding to an handle
 323 ****************************************************************************/
 324 static BOOL get_printer_snum(pipes_struct *p, POLICY_HND *hnd, int *number)
 325 {
 326         Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
 327
 328         if (!Printer) {
 329                 DEBUG(0,("get_printer_snum: Invalid handle (%s)\n", OUR_HANDLE(hnd)));
 330                 return False;
 331         }
 332
 333         switch (Printer->printer_type) {
 334         case PRINTER_HANDLE_IS_PRINTER:
 335                 DEBUG(4,("short name:%s\n", Printer->dev.handlename));
 336                 *number = print_queue_snum(Printer->dev.handlename);
 337                 return (*number != -1);
 338         case PRINTER_HANDLE_IS_PRINTSERVER:
 339                 return False;
 340         default:
 341                 return False;
 342         }
 343 }
 344
 345 /****************************************************************************
 346   set printer handle type.
 347 ****************************************************************************/
 348 static BOOL set_printer_hnd_accesstype(pipes_struct *p, POLICY_HND *hnd, uint32 access_required)
 349 {
 350         Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
 351
 352         if (!Printer) {
 353                 DEBUG(0,("set_printer_hnd_accesstype: Invalid handle (%s)", OUR_HANDLE(hnd)));
 354                 return False;
 355         }
 356
 357         DEBUG(4,("Setting printer access=%x\n", access_required));
 358         Printer->access = access_required;
 359         return True;
 360 }
 361
 362 /****************************************************************************
 363  Set printer handle type.
 364  Check if it's \\server or \\server\printer
 365 ****************************************************************************/
 366
 367 static BOOL set_printer_hnd_printertype(Printer_entry *Printer, char *handlename)
 368 {
 369         DEBUG(3,("Setting printer type=%s\n", handlename));
 370
 371         if ( strlen(handlename) < 3 ) {
 372                 DEBUGADD(4,("A print server must have at least 1 char ! %s\n", handlename));
 373                 return False;
 374         }
 375
 376         /* it's a print server */
 377         if (*handlename=='\\' && *(handlename+1)=='\\' && !strchr_m(handlename+2, '\\')) {
 378                 DEBUGADD(4,("Printer is a print server\n"));
 379                 Printer->printer_type = PRINTER_HANDLE_IS_PRINTSERVER;
 380         }
 381         /* it's a printer */
 382         else {
 383                 DEBUGADD(4,("Printer is a printer\n"));
 384                 Printer->printer_type = PRINTER_HANDLE_IS_PRINTER;
 385         }
 386
 387         return True;
 388 }
 389
 390 /****************************************************************************
 391  Set printer handle name.
 392 ****************************************************************************/
 393
 394 static BOOL set_printer_hnd_name(Printer_entry *Printer, char *handlename)
 395 {
 396         NT_PRINTER_INFO_LEVEL *printer = NULL;
 397         int snum;
 398         int n_services=lp_numservices();
 399         char *aprinter;
 400         BOOL found=False;
 401
 402         DEBUG(4,("Setting printer name=%s (len=%d)\n", handlename, strlen(handlename)));
 403
 404         if (Printer->printer_type==PRINTER_HANDLE_IS_PRINTSERVER) {
 405                 ZERO_STRUCT(Printer->dev.printerservername);
 406                 strncpy(Printer->dev.printerservername, handlename, strlen(handlename));
 407                 return True;
 408         }
 409
 410         if (Printer->printer_type!=PRINTER_HANDLE_IS_PRINTER)
 411                 return False;
 412
 413         if (*handlename=='\\') {
 414                 aprinter=strchr_m(handlename+2, '\\');
 415                 aprinter++;
 416         }
 417         else {
 418                 aprinter=handlename;
 419         }
 420
 421         DEBUGADD(5,("searching for [%s] (len=%d)\n", aprinter, strlen(aprinter)));
 422
 423         /*
 424          * store the Samba share name in it
 425          * in back we have the long printer name
 426          * need to iterate all the snum and do a
 427          * get_a_printer each time to find the printer
 428          * faster to do it here than later.
 429          */
 430
 431         for (snum=0;snum<n_services && found==False;snum++) {
 432                 char *printername;
 433
 434                 if ( !(lp_snum_ok(snum) && lp_print_ok(snum) ) )
 435                         continue;
 436
 437                 DEBUGADD(5,("share:%s\n",lp_servicename(snum)));
 438
 439                 if (!W_ERROR_IS_OK(get_a_printer(&printer, 2, lp_servicename(snum))))
 440                         continue;
 441
 442                 printername=strchr_m(printer->info_2->printername+2, '\\');
 443                 printername++;
 444
 445                 DEBUG(10,("set_printer_hnd_name: name [%s], aprinter [%s]\n",
 446                                 printer->info_2->printername, aprinter ));
 447
 448                 if ( strlen(printername) != strlen(aprinter) ) {
 449                         free_a_printer(&printer, 2);
 450                         continue;
 451                 }
 452
 453                 if ( strncasecmp(printername, aprinter, strlen(aprinter)))  {
 454                         free_a_printer(&printer, 2);
 455                         continue;
 456                 }
 457
 458                 found=True;
 459         }
 460
 461         /*
 462          * if we haven't found a printer with the given handlename
 463          * then it can be a share name as you can open both \\server\printer and
 464          * \\server\share
 465          */
 466
 467         /*
 468          * we still check if the printer description file exists as NT won't be happy
 469          * if we reply OK in the openprinter call and can't reply in the subsequent RPC calls
 470          */
 471
 472         if (found==False) {
 473                 DEBUGADD(5,("Printer not found, checking for share now\n"));
 474
 475                 for (snum=0;snum<n_services && found==False;snum++) {
 476
 477                         if ( !(lp_snum_ok(snum) && lp_print_ok(snum) ) )
 478                                 continue;
 479
 480                         DEBUGADD(5,("set_printer_hnd_name: share:%s\n",lp_servicename(snum)));
 481
 482                         if (!W_ERROR_IS_OK(get_a_printer(&printer, 2, lp_servicename(snum))))
 483                                 continue;
 484
 485                         DEBUG(10,("set_printer_hnd_name: printername [%s], aprinter [%s]\n",
 486                                         printer->info_2->printername, aprinter ));
 487
 488                         if ( strlen(lp_servicename(snum)) != strlen(aprinter) ) {
 489                                 free_a_printer(&printer, 2);
 490                                 continue;
 491                         }
 492
 493                         if ( strncasecmp(lp_servicename(snum), aprinter, strlen(aprinter)))  {
 494                                 free_a_printer(&printer, 2);
 495                                 continue;
 496                         }
 497
 498                         found=True;
 499                 }
 500         }
 501
 502         if (found==False) {
 503                 DEBUGADD(4,("Printer not found\n"));
 504                 return False;
 505         }
 506
 507         snum--;
 508         DEBUGADD(4,("set_printer_hnd_name: Printer found: %s -> %s[%x]\n",
 509                         printer->info_2->printername, lp_servicename(snum),snum));
 510
 511         ZERO_STRUCT(Printer->dev.handlename);
 512         strncpy(Printer->dev.handlename, lp_servicename(snum), strlen(lp_servicename(snum)));
 513
 514         free_a_printer(&printer, 2);
 515
 516         return True;
 517 }
 518
 519 /****************************************************************************
 520   find first available printer slot. creates a printer handle for you.
 521  ****************************************************************************/
 522
 523 static BOOL open_printer_hnd(pipes_struct *p, POLICY_HND *hnd, char *name)
 524 {
 525         Printer_entry *new_printer;
 526
 527         DEBUG(10,("open_printer_hnd: name [%s]\n", name));
 528
 529         if((new_printer=(Printer_entry *)malloc(sizeof(Printer_entry))) == NULL)
 530                 return False;
 531
 532         ZERO_STRUCTP(new_printer);
 533
 534         new_printer->notify.option=NULL;
 535
 536         if (!create_policy_hnd(p, hnd, free_printer_entry, new_printer)) {
 537                 SAFE_FREE(new_printer);
 538                 return False;
 539         }
 540
 541         if (!set_printer_hnd_printertype(new_printer, name)) {
 542                 close_printer_handle(p, hnd);
 543                 return False;
 544         }
 545
 546         if (!set_printer_hnd_name(new_printer, name)) {
 547                 close_printer_handle(p, hnd);
 548                 return False;
 549         }
 550
 551         DEBUG(5, ("%d printer handles active\n", (int)p->pipe_handles->count ));
 552
 553         return True;
 554 }
 555
 556 /********************************************************************
 557  Return True is the handle is a print server.
 558  ********************************************************************/
 559
 560 static BOOL handle_is_printserver(pipes_struct *p, POLICY_HND *handle)
 561 {
 562         Printer_entry *Printer=find_printer_index_by_hnd(p,handle);
 563
 564         if (!Printer)
 565                 return False;
 566
 567         if (Printer->printer_type != PRINTER_HANDLE_IS_PRINTSERVER)
 568                 return False;
 569
 570         return True;
 571 }
 572
 573 /****************************************************************************
 574  allocate more memory for a BUFFER.
 575 ****************************************************************************/
 576 static BOOL alloc_buffer_size(NEW_BUFFER *buffer, uint32 buffer_size)
 577 {
 578         prs_struct *ps;
 579         uint32 extra_space;
 580         uint32 old_offset;
 581
 582         ps= &buffer->prs;
 583
 584         /* damn, I'm doing the reverse operation of prs_grow() :) */
 585         if (buffer_size < prs_data_size(ps))
 586                 extra_space=0;
 587         else
 588                 extra_space = buffer_size - prs_data_size(ps);
 589
 590         /*
 591          * save the offset and move to the end of the buffer
 592          * prs_grow() checks the extra_space against the offset
 593          */
 594         old_offset=prs_offset(ps);
 595         prs_set_offset(ps, prs_data_size(ps));
 596
 597         if (!prs_grow(ps, extra_space))
 598                 return False;
 599
 600         prs_set_offset(ps, old_offset);
 601
 602         buffer->string_at_end=prs_data_size(ps);
 603
 604         return True;
 605 }
 606
 607 /***************************************************************************
 608  receive the notify message
 609 ****************************************************************************/
 610
 611 static void srv_spoolss_receive_message(int msg_type, pid_t src, void *buf, size_t len)
 612 {
 613         fstring printer;
 614         WERROR status;
 615         struct pipes_struct *p;
 616         struct policy *pol;
 617         struct handle_list *hl;
 618
 619         *printer = '\0';
 620         fstrcpy(printer,buf);
 621
 622         if (len == 0) {
 623                 DEBUG(0,("srv_spoolss_receive_message: got null message !\n"));
 624                 return;
 625         }
 626
 627         DEBUG(10,("srv_spoolss_receive_message: Got message about printer %s\n", printer ));
 628
 629         /*
 630          * We need to enumerate all printers. The handle list is shared
 631          * across pipes of the same name, so just find the first open
 632          * spoolss pipe.
 633          */
 634
 635         hl = NULL;
 636         for ( p = get_first_internal_pipe(); p; get_next_internal_pipe(p)) {
 637                 if (strequal(p->name, "spoolss")) {
 638                         hl = p->pipe_handles;
 639                         break;
 640                 }
 641         }
 642
 643         if (!hl) {
 644                 DEBUG(0,("srv_spoolss_receive_message: no handle list on spoolss pipe !\n"));
 645                 return;
 646         }
 647
 648         /* Iterate the printer list on this pipe. */
 649         for (pol = hl->Policy; pol; pol = pol->next ) {
 650                 Printer_entry *find_printer = (Printer_entry *)pol->data_ptr;
 651
 652                 if (!find_printer)
 653                         continue;
 654
 655                 /*
 656                  * if the entry is the given printer or if it's a printerserver
 657                  * we send the message
 658                  */
 659
 660                 if (find_printer->printer_type==PRINTER_HANDLE_IS_PRINTER)
 661                         if (strcmp(find_printer->dev.handlename, printer))
 662                                 continue;
 663
 664                 if (find_printer->notify.client_connected==True)
 665                         cli_spoolss_reply_rrpcn(&cli, &find_printer->notify.client_hnd, PRINTER_CHANGE_ALL, 0x0, &status);
 666         }
 667 }
 668
 669 /***************************************************************************
 670  send a notify event
 671 ****************************************************************************/
 672 static BOOL srv_spoolss_sendnotify(pipes_struct *p, POLICY_HND *handle)
 673 {
 674         fstring printer;
 675
 676         Printer_entry *Printer=find_printer_index_by_hnd(p, handle);
 677
 678         if (!Printer) {
 679                 DEBUG(0,("srv_spoolss_sendnotify: Invalid handle (%s).\n", OUR_HANDLE(handle)));
 680                 return False;
 681         }
 682
 683         if (Printer->printer_type==PRINTER_HANDLE_IS_PRINTER)
 684                 fstrcpy(printer, Printer->dev.handlename);
 685         else
 686                 fstrcpy(printer, "");
 687
 688         /*srv_spoolss_receive_message(printer);*/
 689         DEBUG(10,("srv_spoolss_sendnotify: Sending message about printer %s\n", printer ));
 690
 691         broadcast_printer_notify(printer);
 692
 693         return True;
 694 }
 695
 696 /********************************************************************
 697  * spoolss_open_printer
 698  *
 699  * called from the spoolss dispatcher
 700  ********************************************************************/
 701
 702 WERROR _spoolss_open_printer_ex( pipes_struct *p, SPOOL_Q_OPEN_PRINTER_EX *q_u, SPOOL_R_OPEN_PRINTER_EX *r_u)
 703 {
 704 #if 0
 705         WERROR result = WERR_OK;
 706 #endif
 707
 708         UNISTR2 *printername = NULL;
 709         PRINTER_DEFAULT *printer_default = &q_u->printer_default;
 710 /*      uint32 user_switch = q_u->user_switch; - notused */
 711 /*      SPOOL_USER_CTR user_ctr = q_u->user_ctr; - notused */
 712         POLICY_HND *handle = &r_u->handle;
 713
 714         fstring name;
 715         int snum;
 716         struct current_user user;
 717
 718         if (q_u->printername_ptr != 0)
 719                 printername = &q_u->printername;
 720
 721         if (printername == NULL)
 722                 return WERR_INVALID_PRINTER_NAME;
 723
 724         /* some sanity check because you can open a printer or a print server */
 725         /* aka: \\server\printer or \\server */
 726         unistr2_to_ascii(name, printername, sizeof(name)-1);
 727
 728         DEBUGADD(3,("checking name: %s\n",name));
 729
 730         if (!open_printer_hnd(p, handle, name))
 731                 return WERR_INVALID_PRINTER_NAME;
 732
 733 /*
 734         if (printer_default->datatype_ptr != NULL)
 735         {
 736                 unistr2_to_ascii(datatype, printer_default->datatype, sizeof(datatype)-1);
 737                 set_printer_hnd_datatype(handle, datatype);
 738         }
 739         else
 740                 set_printer_hnd_datatype(handle, "");
 741 */
 742
 743         if (!set_printer_hnd_accesstype(p, handle, printer_default->access_required)) {
 744                 close_printer_handle(p, handle);
 745                 return WERR_ACCESS_DENIED;
 746         }
 747
 748         /*
 749            First case: the user is opening the print server:
 750
 751            Disallow MS AddPrinterWizard if parameter disables it. A Win2k
 752            client 1st tries an OpenPrinterEx with access==0, MUST be allowed.
 753
 754            Then both Win2k and WinNT clients try an OpenPrinterEx with
 755            SERVER_ALL_ACCESS, which we allow only if the user is root (uid=0)
 756            or if the user is listed in the smb.conf printer admin parameter.
 757
 758            Then they try OpenPrinterEx with SERVER_READ which we allow. This lets the
 759            client view printer folder, but does not show the MSAPW.
 760
 761            Note: this test needs code to check access rights here too. Jeremy
 762            could you look at this?
 763
 764
 765            Second case: the user is opening a printer:
 766            NT doesn't let us connect to a printer if the connecting user
 767            doesn't have print permission.
 768
 769         */
 770
 771         get_current_user(&user, p);
 772
 773         if (handle_is_printserver(p, handle)) {
 774                 if (printer_default->access_required == 0) {
 775                         return WERR_OK;
 776                 }
 777                 else if ((printer_default->access_required & SERVER_ACCESS_ADMINISTER ) == SERVER_ACCESS_ADMINISTER) {
 778
 779                         /* Printserver handles use global struct... */
 780                         snum = -1;
 781
 782                         if (!lp_ms_add_printer_wizard()) {
 783                                 close_printer_handle(p, handle);
 784                                 return WERR_ACCESS_DENIED;
 785                         }
 786                         else if (user.uid == 0 || user_in_list(uidtoname(user.uid), lp_printer_admin(snum))) {
 787                                 return WERR_OK;
 788                         }
 789                         else {
 790                                 close_printer_handle(p, handle);
 791                                 return WERR_ACCESS_DENIED;
 792                         }
 793                 }
 794         }
 795         else
 796         {
 797                 /* NT doesn't let us connect to a printer if the connecting user
 798                    doesn't have print permission.  */
 799
 800                 if (!get_printer_snum(p, handle, &snum))
 801                         return WERR_BADFID;
 802
 803                 /* map an empty access mask to the minimum access mask */
 804                 if (printer_default->access_required == 0x0)
 805                         printer_default->access_required = PRINTER_ACCESS_USE;
 806
 807
 808                 /*
 809                  * If we are not serving the printer driver for this printer,
 810                  * map PRINTER_ACCESS_ADMINISTER to PRINTER_ACCESS_USE.  This
 811                  * will keep NT clients happy  --jerry
 812                  */
 813
 814                 if (lp_use_client_driver(snum)
 815                         && (printer_default->access_required & PRINTER_ACCESS_ADMINISTER))
 816                 {
 817                         printer_default->access_required = PRINTER_ACCESS_USE;
 818                 }
 819
 820                 if (!print_access_check(&user, snum, printer_default->access_required)) {
 821                         DEBUG(3, ("access DENIED for printer open\n"));
 822                         close_printer_handle(p, handle);
 823                         return WERR_ACCESS_DENIED;
 824                 }
 825
 826                 /*
 827                  * If we have a default device pointer in the
 828                  * printer_default struct, then we need to get
 829                  * the printer info from the tdb and if there is
 830                  * no default devicemode there then we do a *SET*
 831                  * here ! This is insanity.... JRA.
 832                  */
 833
 834                 /*
 835                  * If the openprinterex rpc call contains a devmode,
 836                  * it's a per-user one. This per-user devmode is derivated
 837                  * from the global devmode. Openprinterex() contains a per-user
 838                  * devmode for when you do EMF printing and spooling.
 839                  * In the EMF case, the NT workstation is only doing half the job
 840                  * of rendering the page. The other half is done by running the printer
 841                  * driver on the server.
 842                  * The EMF file doesn't contain the page description (paper size, orientation, ...).
 843                  * The EMF file only contains what is to be printed on the page.
 844                  * So in order for the server to know how to print, the NT client sends
 845                  * a devicemode attached to the openprinterex call.
 846                  * But this devicemode is short lived, it's only valid for the current print job.
 847                  *
 848                  * If Samba would have supported EMF spooling, this devicemode would
 849                  * have been attached to the handle, to sent it to the driver to correctly
 850                  * rasterize the EMF file.
 851                  *
 852                  * As Samba only supports RAW spooling, we only receive a ready-to-print file,
 853                  * we just act as a pass-thru between windows and the printer.
 854                  *
 855                  * In order to know that Samba supports only RAW spooling, NT has to call
 856                  * getprinter() at level 2 (attribute field) or NT has to call startdoc()
 857                  * and until NT sends a RAW job, we refuse it.
 858                  *
 859                  * But to call getprinter() or startdoc(), you first need a valid handle,
 860                  * and to get an handle you have to call openprintex(). Hence why you have
 861                  * a devicemode in the openprinterex() call.
 862                  *
 863                  *
 864                  * Differences between NT4 and NT 2000.
 865                  * NT4:
 866                  * ---
 867                  * On NT4, you only have a global devicemode. This global devicemode can be changed
 868                  * by the administrator (or by a user with enough privs). Everytime a user
 869                  * wants to print, the devicemode is resetted to the default. In Word, everytime
 870                  * you print, the printer's characteristics are always reset to the global devicemode.
 871                  *
 872                  * NT 2000:
 873                  * -------
 874                  * In W2K, there is the notion of per-user devicemode. The first time you use
 875                  * a printer, a per-user devicemode is build from the global devicemode.
 876                  * If you change your per-user devicemode, it is saved in the registry, under the
 877                  * H_KEY_CURRENT_KEY sub_tree. So that everytime you print, you have your default
 878                  * printer preferences available.
 879                  *
 880                  * To change the per-user devicemode: it's the "Printing Preferences ..." button
 881                  * on the General Tab of the printer properties windows.
 882                  *
 883                  * To change the global devicemode: it's the "Printing Defaults..." button
 884                  * on the Advanced Tab of the printer properties window.
 885                  *
 886                  * JFM.
 887                  */
 888
 889
 890
 891 #if 0
 892                 if (printer_default->devmode_cont.devmode != NULL) {
 893                         result = printer_write_default_dev( snum, printer_default);
 894                         if (result != 0) {
 895                                 close_printer_handle(p, handle);
 896                                 return result;
 897                         }
 898                 }
 899 #endif
 900         }
 901
 902         return WERR_OK;
 903 }
 904
 905 /****************************************************************************
 906 ****************************************************************************/
 907 static BOOL convert_printer_info(const SPOOL_PRINTER_INFO_LEVEL *uni,
 908                                 NT_PRINTER_INFO_LEVEL *printer, uint32 level)
 909 {
 910         BOOL ret = True;
 911
 912         switch (level) {
 913                 case 2:
 914                         ret = uni_2_asc_printer_info_2(uni->info_2, &printer->info_2);
 915                         break;
 916                 default:
 917                         break;
 918         }
 919
 920         return ret;
 921 }
 922
 923 static BOOL convert_printer_driver_info(const SPOOL_PRINTER_DRIVER_INFO_LEVEL *uni,
 924                                         NT_PRINTER_DRIVER_INFO_LEVEL *printer, uint32 level)
 925 {
 926         BOOL result = True;
 927
 928         switch (level) {
 929                 case 3:
 930                         printer->info_3=NULL;
 931                         if (!uni_2_asc_printer_driver_3(uni->info_3, &printer->info_3))
 932                                 result = False;
 933                         break;
 934                 case 6:
 935                         printer->info_6=NULL;
 936                         if (!uni_2_asc_printer_driver_6(uni->info_6, &printer->info_6))
 937                                 result = False;
 938                         break;
 939                 default:
 940                         break;
 941         }
 942
 943         return result;
 944 }
 945
 946 BOOL convert_devicemode(char *printername, const DEVICEMODE *devmode,
 947                                 NT_DEVICEMODE **pp_nt_devmode)
 948 {
 949         NT_DEVICEMODE *nt_devmode = *pp_nt_devmode;
 950
 951         /*
 952          * Ensure nt_devmode is a valid pointer
 953          * as we will be overwriting it.
 954          */
 955
 956         if (nt_devmode == NULL) {
 957                 DEBUG(5, ("convert_devicemode: allocating a generic devmode\n"));
 958                 if ((nt_devmode = construct_nt_devicemode(printername)) == NULL)
 959                         return False;
 960         }
 961
 962         rpcstr_pull(nt_devmode->devicename,devmode->devicename.buffer, 31, -1, 0);
 963         rpcstr_pull(nt_devmode->formname,devmode->formname.buffer, 31, -1, 0);
 964
 965         nt_devmode->specversion=devmode->specversion;
 966         nt_devmode->driverversion=devmode->driverversion;
 967         nt_devmode->size=devmode->size;
 968         nt_devmode->fields=devmode->fields;
 969         nt_devmode->orientation=devmode->orientation;
 970         nt_devmode->papersize=devmode->papersize;
 971         nt_devmode->paperlength=devmode->paperlength;
 972         nt_devmode->paperwidth=devmode->paperwidth;
 973         nt_devmode->scale=devmode->scale;
 974         nt_devmode->copies=devmode->copies;
 975         nt_devmode->defaultsource=devmode->defaultsource;
 976         nt_devmode->printquality=devmode->printquality;
 977         nt_devmode->color=devmode->color;
 978         nt_devmode->duplex=devmode->duplex;
 979         nt_devmode->yresolution=devmode->yresolution;
 980         nt_devmode->ttoption=devmode->ttoption;
 981         nt_devmode->collate=devmode->collate;
 982
 983         nt_devmode->logpixels=devmode->logpixels;
 984         nt_devmode->bitsperpel=devmode->bitsperpel;
 985         nt_devmode->pelswidth=devmode->pelswidth;
 986         nt_devmode->pelsheight=devmode->pelsheight;
 987         nt_devmode->displayflags=devmode->displayflags;
 988         nt_devmode->displayfrequency=devmode->displayfrequency;
 989         nt_devmode->icmmethod=devmode->icmmethod;
 990         nt_devmode->icmintent=devmode->icmintent;
 991         nt_devmode->mediatype=devmode->mediatype;
 992         nt_devmode->dithertype=devmode->dithertype;
 993         nt_devmode->reserved1=devmode->reserved1;
 994         nt_devmode->reserved2=devmode->reserved2;
 995         nt_devmode->panningwidth=devmode->panningwidth;
 996         nt_devmode->panningheight=devmode->panningheight;
 997
 998         /*
 999          * Only change private and driverextra if the incoming devmode
1000          * has a new one. JRA.
1001          */
1002
1003         if ((devmode->driverextra != 0) && (devmode->private != NULL)) {
1004                 SAFE_FREE(nt_devmode->private);
1005                 nt_devmode->driverextra=devmode->driverextra;
1006                 if((nt_devmode->private=(uint8 *)malloc(nt_devmode->driverextra * sizeof(uint8))) == NULL)
1007                         return False;
1008                 memcpy(nt_devmode->private, devmode->private, nt_devmode->driverextra);
1009         }
1010
1011         *pp_nt_devmode = nt_devmode;
1012
1013         return True;
1014 }
1015
1016 /********************************************************************
1017  * _spoolss_enddocprinter_internal.
1018  ********************************************************************/
1019
1020 static WERROR _spoolss_enddocprinter_internal(pipes_struct *p, POLICY_HND *handle)
1021 {
1022         Printer_entry *Printer=find_printer_index_by_hnd(p, handle);
1023
1024         if (!Printer) {
1025                 DEBUG(0,("_spoolss_enddocprinter_internal: Invalid handle (%s)\n", OUR_HANDLE(handle)));
1026                 return WERR_BADFID;
1027         }
1028
1029         Printer->document_started=False;
1030         print_job_end(Printer->jobid,True);
1031         /* error codes unhandled so far ... */
1032
1033         return WERR_OK;
1034 }
1035
1036 /********************************************************************
1037  * api_spoolss_closeprinter
1038  ********************************************************************/
1039
1040 WERROR _spoolss_closeprinter(pipes_struct *p, SPOOL_Q_CLOSEPRINTER *q_u, SPOOL_R_CLOSEPRINTER *r_u)
1041 {
1042         POLICY_HND *handle = &q_u->handle;
1043
1044         Printer_entry *Printer=find_printer_index_by_hnd(p, handle);
1045
1046         if (Printer && Printer->document_started)
1047                 _spoolss_enddocprinter_internal(p, handle);          /* print job was not closed */
1048
1049         memcpy(&r_u->handle, &q_u->handle, sizeof(r_u->handle));
1050
1051         if (!close_printer_handle(p, handle))
1052                 return WERR_BADFID;
1053
1054         return WERR_OK;
1055 }
1056
1057 /********************************************************************
1058  * api_spoolss_deleteprinter
1059
1060  ********************************************************************/
1061
1062 WERROR _spoolss_deleteprinter(pipes_struct *p, SPOOL_Q_DELETEPRINTER *q_u, SPOOL_R_DELETEPRINTER *r_u)
1063 {
1064         POLICY_HND *handle = &q_u->handle;
1065         Printer_entry *Printer=find_printer_index_by_hnd(p, handle);
1066         WERROR result;
1067
1068         if (Printer && Printer->document_started)
1069                 _spoolss_enddocprinter_internal(p, handle);  /* print job was not closed */
1070
1071         memcpy(&r_u->handle, &q_u->handle, sizeof(r_u->handle));
1072
1073         result = delete_printer_handle(p, handle);
1074
1075         if (W_ERROR_IS_OK(result)) {
1076                 srv_spoolss_sendnotify(p, handle);
1077         }
1078
1079         return result;
1080 }
1081
1082 /*******************************************************************
1083  * static function to lookup the version id corresponding to an
1084  * long architecture string
1085  ******************************************************************/
1086 static int get_version_id (char * arch)
1087 {
1088         int i;
1089         struct table_node archi_table[]= {
1090
1091                 {"Windows 4.0",          "WIN40",       0 },
1092                 {"Windows NT x86",       "W32X86",      2 },
1093                 {"Windows NT R4000",     "W32MIPS",     2 },
1094                 {"Windows NT Alpha_AXP", "W32ALPHA",    2 },
1095                 {"Windows NT PowerPC",   "W32PPC",      2 },
1096                 {NULL,                   "",            -1 }
1097         };
1098
1099         for (i=0; archi_table[i].long_archi != NULL; i++)
1100         {
1101                 if (strcmp(arch, archi_table[i].long_archi) == 0)
1102                         return (archi_table[i].version);
1103         }
1104
1105         return -1;
1106 }
1107
1108 /********************************************************************
1109  * _spoolss_deleteprinterdriver
1110  *
1111  * We currently delete the driver for the architecture only.
1112  * This can leave the driver for other archtectures.  However,
1113  * since every printer associates a "Windows NT x86" driver name
1114  * and we cannot delete that one while it is in use, **and** since
1115  * it is impossible to assign a driver to a Samba printer without
1116  * having the "Windows NT x86" driver installed,...
1117  *
1118  * ....we should not get into trouble here.
1119  *
1120  *                                                      --jerry
1121  ********************************************************************/
1122
1123 WERROR _spoolss_deleteprinterdriver(pipes_struct *p, SPOOL_Q_DELETEPRINTERDRIVER *q_u,
1124                                     SPOOL_R_DELETEPRINTERDRIVER *r_u)
1125 {
1126         fstring                         driver;
1127         fstring                         arch;
1128         NT_PRINTER_DRIVER_INFO_LEVEL    info;
1129         int                             version;
1130
1131         unistr2_to_ascii(driver, &q_u->driver, sizeof(driver)-1 );
1132         unistr2_to_ascii(arch,   &q_u->arch,   sizeof(arch)-1   );
1133
1134         /* check that we have a valid driver name first */
1135         if ((version=get_version_id(arch)) == -1) {
1136                 /* this is what NT returns */
1137                 return WERR_INVALID_ENVIRONMENT;
1138         }
1139
1140         ZERO_STRUCT(info);
1141         if (!W_ERROR_IS_OK(get_a_printer_driver(&info, 3, driver, arch, version))) {
1142                 return WERR_UNKNOWN_PRINTER_DRIVER;
1143         }
1144
1145
1146         if (printer_driver_in_use(arch, driver))
1147         {
1148                 return WERR_PRINTER_DRIVER_IN_USE;
1149         }
1150
1151         return delete_printer_driver(info.info_3);
1152 }
1153
1154
1155 /********************************************************************
1156  GetPrinterData on a printer server Handle.
1157 ********************************************************************/
1158 static BOOL getprinterdata_printer_server(TALLOC_CTX *ctx, fstring value, uint32 *type, uint8 **data, uint32 *needed, uint32 in_size)
1159 {
1160         int i;
1161
1162         DEBUG(8,("getprinterdata_printer_server:%s\n", value));
1163
1164         if (!strcmp(value, "BeepEnabled")) {
1165                 *type = 0x4;
1166                 if((*data = (uint8 *)talloc(ctx, 4*sizeof(uint8) )) == NULL)
1167                         return False;
1168                 SIVAL(*data, 0, 0x01);
1169                 *needed = 0x4;
1170                 return True;
1171         }
1172
1173         if (!strcmp(value, "EventLog")) {
1174                 *type = 0x4;
1175                 if((*data = (uint8 *)talloc(ctx, 4*sizeof(uint8) )) == NULL)
1176                         return False;
1177                 SIVAL(*data, 0, 0x1B);
1178                 *needed = 0x4;
1179                 return True;
1180         }
1181
1182         if (!strcmp(value, "NetPopup")) {
1183                 *type = 0x4;
1184                 if((*data = (uint8 *)talloc(ctx, 4*sizeof(uint8) )) == NULL)
1185                         return False;
1186                 SIVAL(*data, 0, 0x01);
1187                 *needed = 0x4;
1188                 return True;
1189         }
1190
1191         if (!strcmp(value, "MajorVersion")) {
1192                 *type = 0x4;
1193                 if((*data = (uint8 *)talloc(ctx, 4*sizeof(uint8) )) == NULL)
1194                         return False;
1195                 SIVAL(*data, 0, 0x02);
1196                 *needed = 0x4;
1197                 return True;
1198         }
1199
1200    if (!strcmp(value, "DefaultSpoolDirectory")) {
1201                 pstring string="You are using a Samba server";
1202                 *type = 0x1;
1203                 *needed = 2*(strlen(string)+1);
1204                 if((*data  = (uint8 *)talloc(ctx, ((*needed > in_size) ? *needed:in_size) *sizeof(uint8))) == NULL)
1205                         return False;
1206                 memset(*data, 0, (*needed > in_size) ? *needed:in_size);
1207
1208                 /* it's done by hand ready to go on the wire */
1209                 for (i=0; i<strlen(string); i++) {
1210                         (*data)[2*i]=string[i];
1211                         (*data)[2*i+1]='\0';
1212                 }
1213                 return True;
1214         }
1215
1216         if (!strcmp(value, "Architecture")) {
1217                 pstring string="Windows NT x86";
1218                 *type = 0x1;
1219                 *needed = 2*(strlen(string)+1);
1220                 if((*data  = (uint8 *)talloc(ctx, ((*needed > in_size) ? *needed:in_size) *sizeof(uint8))) == NULL)
1221                         return False;
1222                 memset(*data, 0, (*needed > in_size) ? *needed:in_size);
1223                 for (i=0; i<strlen(string); i++) {
1224                         (*data)[2*i]=string[i];
1225                         (*data)[2*i+1]='\0';
1226                 }
1227                 return True;
1228         }
1229
1230         return False;
1231 }
1232
1233 /********************************************************************
1234  GetPrinterData on a printer Handle.
1235 ********************************************************************/
1236 static BOOL getprinterdata_printer(pipes_struct *p, TALLOC_CTX *ctx, POLICY_HND *handle,
1237                                 fstring value, uint32 *type,
1238                                 uint8 **data, uint32 *needed, uint32 in_size )
1239 {
1240         NT_PRINTER_INFO_LEVEL *printer = NULL;
1241         int snum=0;
1242         uint8 *idata=NULL;
1243         uint32 len;
1244         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
1245
1246         DEBUG(5,("getprinterdata_printer\n"));
1247
1248         if (!Printer) {
1249                 DEBUG(0,("getprinterdata_printer: Invalid handle (%s).\n", OUR_HANDLE(handle)));
1250                 return False;
1251         }
1252
1253         if(!get_printer_snum(p, handle, &snum))
1254                 return False;
1255
1256         if (!W_ERROR_IS_OK(get_a_printer(&printer, 2, lp_servicename(snum))))
1257                 return False;
1258
1259         if (!get_specific_param(*printer, 2, value, &idata, type, &len)) {
1260                 free_a_printer(&printer, 2);
1261                 return False;
1262         }
1263
1264         free_a_printer(&printer, 2);
1265
1266         DEBUG(5,("getprinterdata_printer:allocating %d\n", in_size));
1267
1268         if (in_size) {
1269                 if((*data  = (uint8 *)talloc(ctx, in_size *sizeof(uint8) )) == NULL) {
1270                         return False;
1271                 }
1272
1273                 memset(*data, 0, in_size *sizeof(uint8));
1274                 /* copy the min(in_size, len) */
1275                 memcpy(*data, idata, (len>in_size)?in_size:len *sizeof(uint8));
1276         } else {
1277                 *data = NULL;
1278         }
1279
1280         *needed = len;
1281
1282         DEBUG(5,("getprinterdata_printer:copy done\n"));
1283
1284         SAFE_FREE(idata);
1285
1286         return True;
1287 }
1288
1289 /********************************************************************
1290  * spoolss_getprinterdata
1291  ********************************************************************/
1292
1293 WERROR _spoolss_getprinterdata(pipes_struct *p, SPOOL_Q_GETPRINTERDATA *q_u, SPOOL_R_GETPRINTERDATA *r_u)
1294 {
1295         POLICY_HND *handle = &q_u->handle;
1296         UNISTR2 *valuename = &q_u->valuename;
1297         uint32 in_size = q_u->size;
1298         uint32 *type = &r_u->type;
1299         uint32 *out_size = &r_u->size;
1300         uint8 **data = &r_u->data;
1301         uint32 *needed = &r_u->needed;
1302
1303         fstring value;
1304         BOOL found=False;
1305         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
1306
1307         /*
1308          * Reminder: when it's a string, the length is in BYTES
1309          * even if UNICODE is negociated.
1310          *
1311          * JFM, 4/19/1999
1312          */
1313
1314         *out_size=in_size;
1315
1316         /* in case of problem, return some default values */
1317         *needed=0;
1318         *type=0;
1319
1320         DEBUG(4,("_spoolss_getprinterdata\n"));
1321
1322         if (!Printer) {
1323                 if((*data=(uint8 *)talloc_zero(p->mem_ctx, 4*sizeof(uint8))) == NULL)
1324                         return WERR_NOMEM;
1325                 DEBUG(0,("_spoolss_getprinterdata: Invalid handle (%s).\n", OUR_HANDLE(handle)));
1326                 return WERR_BADFID;
1327         }
1328
1329         unistr2_to_ascii(value, valuename, sizeof(value)-1);
1330
1331         if (Printer->printer_type == PRINTER_HANDLE_IS_PRINTSERVER)
1332                 found=getprinterdata_printer_server(p->mem_ctx, value, type, data, needed, *out_size);
1333         else
1334                 found= getprinterdata_printer(p, p->mem_ctx, handle, value, type, data, needed, *out_size);
1335
1336         if (found==False) {
1337                 DEBUG(5, ("value not found, allocating %d\n", *out_size));
1338                 /* reply this param doesn't exist */
1339                 if (*out_size) {
1340                         if((*data=(uint8 *)talloc_zero(p->mem_ctx, *out_size*sizeof(uint8))) == NULL)
1341                                 return WERR_NOMEM;
1342                 } else {
1343                         *data = NULL;
1344                 }
1345
1346                 return WERR_INVALID_PARAM;
1347         }
1348
1349         if (*needed > *out_size)
1350                 return WERR_STATUS_MORE_ENTRIES;
1351         else
1352                 return WERR_OK;
1353 }
1354
1355 /***************************************************************************
1356  connect to the client
1357 ****************************************************************************/
1358 static BOOL srv_spoolss_replyopenprinter(char *printer, uint32 localprinter, uint32 type, POLICY_HND *handle)
1359 {
1360         WERROR status;
1361
1362         /*
1363          * If it's the first connection, contact the client
1364          * and connect to the IPC$ share anonumously
1365          */
1366         if (smb_connections==0) {
1367                 fstring unix_printer;
1368
1369                 fstrcpy(unix_printer, printer+2); /* the +2 is to strip the leading 2 backslashs */
1370
1371                 if(!spoolss_connect_to_client(&cli, unix_printer))
1372                         return False;
1373                 message_register(MSG_PRINTER_NOTIFY, srv_spoolss_receive_message);
1374
1375         }
1376
1377         smb_connections++;
1378
1379         if(!cli_spoolss_reply_open_printer(&cli, printer, localprinter, type, &status, handle))
1380                 return False;
1381
1382         return True;
1383 }
1384
1385 /********************************************************************
1386  * _spoolss_rffpcnex
1387  * ReplyFindFirstPrinterChangeNotifyEx
1388  *
1389  * jfmxxxx: before replying OK: status=0
1390  * should do a rpc call to the workstation asking ReplyOpenPrinter
1391  * have to code it, later.
1392  *
1393  * in fact ReplyOpenPrinter is the changenotify equivalent on the spoolss pipe
1394  * called from api_spoolss_rffpcnex
1395  ********************************************************************/
1396
1397 WERROR _spoolss_rffpcnex(pipes_struct *p, SPOOL_Q_RFFPCNEX *q_u, SPOOL_R_RFFPCNEX *r_u)
1398 {
1399         POLICY_HND *handle = &q_u->handle;
1400         uint32 flags = q_u->flags;
1401         uint32 options = q_u->options;
1402         UNISTR2 *localmachine = &q_u->localmachine;
1403         uint32 printerlocal = q_u->printerlocal;
1404         SPOOL_NOTIFY_OPTION *option = q_u->option;
1405
1406         /* store the notify value in the printer struct */
1407
1408         Printer_entry *Printer=find_printer_index_by_hnd(p, handle);
1409
1410         if (!Printer) {
1411                 DEBUG(0,("_spoolss_rffpcnex: Invalid handle (%s).\n", OUR_HANDLE(handle)));
1412                 return WERR_BADFID;
1413         }
1414
1415         Printer->notify.flags=flags;
1416         Printer->notify.options=options;
1417         Printer->notify.printerlocal=printerlocal;
1418
1419         if (Printer->notify.option)
1420                 free_spool_notify_option(&Printer->notify.option);
1421
1422         Printer->notify.option=dup_spool_notify_option(option);
1423
1424         unistr2_to_ascii(Printer->notify.localmachine, localmachine, sizeof(Printer->notify.localmachine)-1);
1425
1426         /* connect to the client machine and send a ReplyOpenPrinter */
1427         if(srv_spoolss_replyopenprinter(Printer->notify.localmachine,
1428                                         Printer->notify.printerlocal, 1,
1429                                         &Printer->notify.client_hnd))
1430                 Printer->notify.client_connected=True;
1431
1432         return WERR_OK;
1433 }
1434
1435 /*******************************************************************
1436  * fill a notify_info_data with the servername
1437  ********************************************************************/
1438
1439 static void spoolss_notify_server_name(int snum,
1440                                        SPOOL_NOTIFY_INFO_DATA *data,
1441                                        print_queue_struct *queue,
1442                                        NT_PRINTER_INFO_LEVEL *printer,
1443                                        TALLOC_CTX *mem_ctx)
1444 {
1445         pstring temp_name, temp;
1446         uint32 len;
1447
1448         slprintf(temp_name, sizeof(temp_name)-1, "\\\\%s", get_called_name());
1449
1450         len = rpcstr_push(temp, temp_name, sizeof(temp)-2, STR_TERMINATE);
1451
1452         data->notify_data.data.length = len / 2;
1453         data->notify_data.data.string = (uint16 *)talloc(mem_ctx, len);
1454
1455         if (!data->notify_data.data.string) {
1456                 data->notify_data.data.length = 0;
1457                 return;
1458         }
1459
1460         memcpy(data->notify_data.data.string, temp, len);
1461 }
1462
1463 /*******************************************************************
1464  * fill a notify_info_data with the printername (not including the servername).
1465  ********************************************************************/
1466 static void spoolss_notify_printer_name(int snum,
1467                                         SPOOL_NOTIFY_INFO_DATA *data,
1468                                         print_queue_struct *queue,
1469                                         NT_PRINTER_INFO_LEVEL *printer,
1470                                         TALLOC_CTX *mem_ctx)
1471 {
1472         pstring temp;
1473         uint32 len;
1474
1475         /* the notify name should not contain the \\server\ part */
1476         char *p = strrchr_m(printer->info_2->printername, '\\');
1477
1478         if (!p) {
1479                 p = printer->info_2->printername;
1480         } else {
1481                 p++;
1482         }
1483
1484         len = rpcstr_push(temp, p, sizeof(temp)-2, STR_TERMINATE);
1485         data->notify_data.data.length = len / 2;
1486         data->notify_data.data.string = (uint16 *)talloc(mem_ctx, len);
1487
1488         if (!data->notify_data.data.string) {
1489                 data->notify_data.data.length = 0;
1490                 return;
1491         }
1492
1493         memcpy(data->notify_data.data.string, temp, len);
1494 }
1495
1496 /*******************************************************************
1497  * fill a notify_info_data with the servicename
1498  ********************************************************************/
1499 static void spoolss_notify_share_name(int snum,
1500                                       SPOOL_NOTIFY_INFO_DATA *data,
1501                                       print_queue_struct *queue,
1502                                       NT_PRINTER_INFO_LEVEL *printer,
1503                                       TALLOC_CTX *mem_ctx)
1504 {
1505         pstring temp;
1506         uint32 len;
1507
1508         len = rpcstr_push(temp, lp_servicename(snum), sizeof(temp)-2, STR_TERMINATE);
1509
1510         data->notify_data.data.length = len / 2;
1511         data->notify_data.data.string = (uint16 *)talloc(mem_ctx, len);
1512
1513         if (!data->notify_data.data.string) {
1514                 data->notify_data.data.length = 0;
1515                 return;
1516         }
1517
1518         memcpy(data->notify_data.data.string, temp, len);
1519 }
1520
1521 /*******************************************************************
1522  * fill a notify_info_data with the port name
1523  ********************************************************************/
1524 static void spoolss_notify_port_name(int snum,
1525                                      SPOOL_NOTIFY_INFO_DATA *data,
1526                                      print_queue_struct *queue,
1527                                      NT_PRINTER_INFO_LEVEL *printer,
1528                                      TALLOC_CTX *mem_ctx)
1529 {
1530         pstring temp;
1531         uint32 len;
1532
1533         /* even if it's strange, that's consistant in all the code */
1534
1535         len = rpcstr_push(temp, printer->info_2->portname, sizeof(temp)-2, STR_TERMINATE);
1536
1537         data->notify_data.data.length = len / 2;
1538         data->notify_data.data.string = (uint16 *)talloc(mem_ctx, len);
1539
1540         if (!data->notify_data.data.string) {
1541                 data->notify_data.data.length = 0;
1542                 return;
1543         }
1544
1545         memcpy(data->notify_data.data.string, temp, len);
1546 }
1547
1548 /*******************************************************************
1549  * fill a notify_info_data with the printername
1550  * jfmxxxx: it's incorrect, should be lp_printerdrivername()
1551  * but it doesn't exist, have to see what to do
1552  ********************************************************************/
1553 static void spoolss_notify_driver_name(int snum,
1554                                        SPOOL_NOTIFY_INFO_DATA *data,
1555                                        print_queue_struct *queue,
1556                                        NT_PRINTER_INFO_LEVEL *printer,
1557                                        TALLOC_CTX *mem_ctx)
1558 {
1559         pstring temp;
1560         uint32 len;
1561
1562         len = rpcstr_push(temp, printer->info_2->drivername, sizeof(temp)-2, STR_TERMINATE);
1563         data->notify_data.data.length = len / 2;
1564         data->notify_data.data.string = (uint16 *)talloc(mem_ctx, len);
1565
1566         if (!data->notify_data.data.string) {
1567                 data->notify_data.data.length = 0;
1568                 return;
1569         }
1570
1571         memcpy(data->notify_data.data.string, temp, len);
1572 }
1573
1574 /*******************************************************************
1575  * fill a notify_info_data with the comment
1576  ********************************************************************/
1577 static void spoolss_notify_comment(int snum,
1578                                    SPOOL_NOTIFY_INFO_DATA *data,
1579                                    print_queue_struct *queue,
1580                                    NT_PRINTER_INFO_LEVEL *printer,
1581                                    TALLOC_CTX *mem_ctx)
1582 {
1583         pstring temp;
1584         uint32 len;
1585
1586         if (*printer->info_2->comment == '\0')
1587                 len = rpcstr_push(temp, lp_comment(snum), sizeof(temp)-2, STR_TERMINATE);
1588
1589         else
1590                 len = rpcstr_push(temp, printer->info_2->comment, sizeof(temp)-2, STR_TERMINATE);
1591
1592         data->notify_data.data.length = len / 2;
1593         data->notify_data.data.string = (uint16 *)talloc(mem_ctx, len);
1594
1595         if (!data->notify_data.data.string) {
1596                 data->notify_data.data.length = 0;
1597                 return;
1598         }
1599
1600         memcpy(data->notify_data.data.string, temp, len);
1601 }
1602
1603 /*******************************************************************
1604  * fill a notify_info_data with the comment
1605  * jfm:xxxx incorrect, have to create a new smb.conf option
1606  * location = "Room 1, floor 2, building 3"
1607  ********************************************************************/
1608 static void spoolss_notify_location(int snum,
1609                                     SPOOL_NOTIFY_INFO_DATA *data,
1610                                     print_queue_struct *queue,
1611                                     NT_PRINTER_INFO_LEVEL *printer,
1612                                     TALLOC_CTX *mem_ctx)
1613 {
1614         pstring temp;
1615         uint32 len;
1616
1617         len = rpcstr_push(temp, printer->info_2->location,sizeof(temp)-2, STR_TERMINATE);
1618
1619         data->notify_data.data.length = len / 2;
1620         data->notify_data.data.string = (uint16 *)talloc(mem_ctx, len);
1621
1622         if (!data->notify_data.data.string) {
1623                 data->notify_data.data.length = 0;
1624                 return;
1625         }
1626
1627         memcpy(data->notify_data.data.string, temp, len);
1628 }
1629
1630 /*******************************************************************
1631  * fill a notify_info_data with the device mode
1632  * jfm:xxxx don't to it for know but that's a real problem !!!
1633  ********************************************************************/
1634 static void spoolss_notify_devmode(int snum,
1635                                    SPOOL_NOTIFY_INFO_DATA *data,
1636                                    print_queue_struct *queue,
1637                                    NT_PRINTER_INFO_LEVEL *printer,
1638                                    TALLOC_CTX *mem_ctx)
1639 {
1640 }
1641
1642 /*******************************************************************
1643  * fill a notify_info_data with the separator file name
1644  * jfm:xxxx just return no file could add an option to smb.conf
1645  * separator file = "separator.txt"
1646  ********************************************************************/
1647 static void spoolss_notify_sepfile(int snum,
1648                                    SPOOL_NOTIFY_INFO_DATA *data,
1649                                    print_queue_struct *queue,
1650                                    NT_PRINTER_INFO_LEVEL *printer,
1651                                    TALLOC_CTX *mem_ctx)
1652 {
1653         pstring temp;
1654         uint32 len;
1655
1656         len = rpcstr_push(temp, printer->info_2->sepfile, sizeof(temp)-2, STR_TERMINATE);
1657
1658         data->notify_data.data.length = len / 2;
1659         data->notify_data.data.string = (uint16 *)talloc(mem_ctx, len);
1660
1661         if (!data->notify_data.data.string) {
1662                 data->notify_data.data.length = 0;
1663                 return;
1664         }
1665
1666         memcpy(data->notify_data.data.string, temp, len);
1667 }
1668
1669 /*******************************************************************
1670  * fill a notify_info_data with the print processor
1671  * jfm:xxxx return always winprint to indicate we don't do anything to it
1672  ********************************************************************/
1673 static void spoolss_notify_print_processor(int snum,
1674                                            SPOOL_NOTIFY_INFO_DATA *data,
1675                                            print_queue_struct *queue,
1676                                            NT_PRINTER_INFO_LEVEL *printer,
1677                                            TALLOC_CTX *mem_ctx)
1678 {
1679         pstring temp;
1680         uint32 len;
1681
1682         len = rpcstr_push(temp,  printer->info_2->printprocessor, sizeof(temp)-2, STR_TERMINATE);
1683
1684         data->notify_data.data.length = len / 2;
1685         data->notify_data.data.string = (uint16 *)talloc(mem_ctx, len);
1686
1687         if (!data->notify_data.data.string) {
1688                 data->notify_data.data.length = 0;
1689                 return;
1690         }
1691
1692         memcpy(data->notify_data.data.string, temp, len);
1693 }
1694
1695 /*******************************************************************
1696  * fill a notify_info_data with the print processor options
1697  * jfm:xxxx send an empty string
1698  ********************************************************************/
1699 static void spoolss_notify_parameters(int snum,
1700                                       SPOOL_NOTIFY_INFO_DATA *data,
1701                                       print_queue_struct *queue,
1702                                       NT_PRINTER_INFO_LEVEL *printer,
1703                                       TALLOC_CTX *mem_ctx)
1704 {
1705         pstring temp;
1706         uint32 len;
1707
1708         len = rpcstr_push(temp,  printer->info_2->parameters, sizeof(temp)-2, STR_TERMINATE);
1709
1710         data->notify_data.data.length = len / 2;
1711         data->notify_data.data.string = (uint16 *)talloc(mem_ctx, len);
1712
1713         if (!data->notify_data.data.string) {
1714                 data->notify_data.data.length = 0;
1715                 return;
1716         }
1717
1718         memcpy(data->notify_data.data.string, temp, len);
1719 }
1720
1721 /*******************************************************************
1722  * fill a notify_info_data with the data type
1723  * jfm:xxxx always send RAW as data type
1724  ********************************************************************/
1725 static void spoolss_notify_datatype(int snum,
1726                                     SPOOL_NOTIFY_INFO_DATA *data,
1727                                     print_queue_struct *queue,
1728                                     NT_PRINTER_INFO_LEVEL *printer,
1729                                     TALLOC_CTX *mem_ctx)
1730 {
1731         pstring temp;
1732         uint32 len;
1733
1734         len = rpcstr_push(temp, printer->info_2->datatype, sizeof(pstring)-2, STR_TERMINATE);
1735
1736         data->notify_data.data.length = len / 2;
1737         data->notify_data.data.string = (uint16 *)talloc(mem_ctx, len);
1738
1739         if (!data->notify_data.data.string) {
1740                 data->notify_data.data.length = 0;
1741                 return;
1742         }
1743
1744         memcpy(data->notify_data.data.string, temp, len);
1745 }
1746
1747 /*******************************************************************
1748  * fill a notify_info_data with the security descriptor
1749  * jfm:xxxx send an null pointer to say no security desc
1750  * have to implement security before !
1751  ********************************************************************/
1752 static void spoolss_notify_security_desc(int snum,
1753                                          SPOOL_NOTIFY_INFO_DATA *data,
1754                                          print_queue_struct *queue,
1755                                          NT_PRINTER_INFO_LEVEL *printer,
1756                                          TALLOC_CTX *mem_ctx)
1757 {
1758         data->notify_data.data.length=0;
1759         data->notify_data.data.string = NULL;
1760 }
1761
1762 /*******************************************************************
1763  * fill a notify_info_data with the attributes
1764  * jfm:xxxx a samba printer is always shared
1765  ********************************************************************/
1766 static void spoolss_notify_attributes(int snum,
1767                                       SPOOL_NOTIFY_INFO_DATA *data,
1768                                       print_queue_struct *queue,
1769                                       NT_PRINTER_INFO_LEVEL *printer,
1770                                       TALLOC_CTX *mem_ctx)
1771 {
1772         data->notify_data.value[0] = printer->info_2->attributes;
1773         data->notify_data.value[1] = 0;
1774 }
1775
1776 /*******************************************************************
1777  * fill a notify_info_data with the priority
1778  ********************************************************************/
1779 static void spoolss_notify_priority(int snum,
1780                                     SPOOL_NOTIFY_INFO_DATA *data,
1781                                     print_queue_struct *queue,
1782                                     NT_PRINTER_INFO_LEVEL *printer,
1783                                     TALLOC_CTX *mem_ctx)
1784 {
1785         data->notify_data.value[0] = printer->info_2->priority;
1786         data->notify_data.value[1] = 0;
1787 }
1788
1789 /*******************************************************************
1790  * fill a notify_info_data with the default priority
1791  ********************************************************************/
1792 static void spoolss_notify_default_priority(int snum,
1793                                             SPOOL_NOTIFY_INFO_DATA *data,
1794                                             print_queue_struct *queue,
1795                                             NT_PRINTER_INFO_LEVEL *printer,
1796                                             TALLOC_CTX *mem_ctx)
1797 {
1798         data->notify_data.value[0] = printer->info_2->default_priority;
1799         data->notify_data.value[1] = 0;
1800 }
1801
1802 /*******************************************************************
1803  * fill a notify_info_data with the start time
1804  ********************************************************************/
1805 static void spoolss_notify_start_time(int snum,
1806                                       SPOOL_NOTIFY_INFO_DATA *data,
1807                                       print_queue_struct *queue,
1808                                       NT_PRINTER_INFO_LEVEL *printer,
1809                                       TALLOC_CTX *mem_ctx)
1810 {
1811         data->notify_data.value[0] = printer->info_2->starttime;
1812         data->notify_data.value[1] = 0;
1813 }
1814
1815 /*******************************************************************
1816  * fill a notify_info_data with the until time
1817  ********************************************************************/
1818 static void spoolss_notify_until_time(int snum,
1819                                       SPOOL_NOTIFY_INFO_DATA *data,
1820                                       print_queue_struct *queue,
1821                                       NT_PRINTER_INFO_LEVEL *printer,
1822                                       TALLOC_CTX *mem_ctx)
1823 {
1824         data->notify_data.value[0] = printer->info_2->untiltime;
1825         data->notify_data.value[1] = 0;
1826 }
1827
1828 /*******************************************************************
1829  * fill a notify_info_data with the status
1830  ********************************************************************/
1831 static void spoolss_notify_status(int snum,
1832                                   SPOOL_NOTIFY_INFO_DATA *data,
1833                                   print_queue_struct *queue,
1834                                   NT_PRINTER_INFO_LEVEL *printer,
1835                                   TALLOC_CTX *mem_ctx)
1836 {
1837         print_status_struct status;
1838
1839         print_queue_length(snum, &status);
1840         data->notify_data.value[0]=(uint32) status.status;
1841         data->notify_data.value[1] = 0;
1842 }
1843
1844 /*******************************************************************
1845  * fill a notify_info_data with the number of jobs queued
1846  ********************************************************************/
1847 static void spoolss_notify_cjobs(int snum,
1848                                  SPOOL_NOTIFY_INFO_DATA *data,
1849                                  print_queue_struct *queue,
1850                                  NT_PRINTER_INFO_LEVEL *printer,
1851                                  TALLOC_CTX *mem_ctx)
1852 {
1853         data->notify_data.value[0] = print_queue_length(snum, NULL);
1854         data->notify_data.value[1] = 0;
1855 }
1856
1857 /*******************************************************************
1858  * fill a notify_info_data with the average ppm
1859  ********************************************************************/
1860 static void spoolss_notify_average_ppm(int snum,
1861                                        SPOOL_NOTIFY_INFO_DATA *data,
1862                                        print_queue_struct *queue,
1863                                        NT_PRINTER_INFO_LEVEL *printer,
1864                                        TALLOC_CTX *mem_ctx)
1865 {
1866         /* always respond 8 pages per minutes */
1867         /* a little hard ! */
1868         data->notify_data.value[0] = printer->info_2->averageppm;
1869         data->notify_data.value[1] = 0;
1870 }
1871
1872 /*******************************************************************
1873  * fill a notify_info_data with username
1874  ********************************************************************/
1875 static void spoolss_notify_username(int snum,
1876                                     SPOOL_NOTIFY_INFO_DATA *data,
1877                                     print_queue_struct *queue,
1878                                     NT_PRINTER_INFO_LEVEL *printer,
1879                                     TALLOC_CTX *mem_ctx)
1880 {
1881         pstring temp;
1882         uint32 len;
1883
1884         len = rpcstr_push(temp, queue->user, sizeof(temp)-2, STR_TERMINATE);
1885
1886
1887         data->notify_data.data.length = len / 2;
1888         data->notify_data.data.string = (uint16 *)talloc(mem_ctx, len);
1889
1890         if (!data->notify_data.data.string) {
1891                 data->notify_data.data.length = 0;
1892                 return;
1893         }
1894
1895         memcpy(data->notify_data.data.string, temp, len);
1896 }
1897
1898 /*******************************************************************
1899  * fill a notify_info_data with job status
1900  ********************************************************************/
1901 static void spoolss_notify_job_status(int snum,
1902                                       SPOOL_NOTIFY_INFO_DATA *data,
1903                                       print_queue_struct *queue,
1904                                       NT_PRINTER_INFO_LEVEL *printer,
1905                                       TALLOC_CTX *mem_ctx)
1906 {
1907         data->notify_data.value[0]=nt_printj_status(queue->status);
1908         data->notify_data.value[1] = 0;
1909 }
1910
1911 /*******************************************************************
1912  * fill a notify_info_data with job name
1913  ********************************************************************/
1914 static void spoolss_notify_job_name(int snum,
1915                                     SPOOL_NOTIFY_INFO_DATA *data,
1916                                     print_queue_struct *queue,
1917                                     NT_PRINTER_INFO_LEVEL *printer,
1918                                     TALLOC_CTX *mem_ctx)
1919 {
1920         pstring temp;
1921         uint32 len;
1922
1923         len = rpcstr_push(temp, queue->file, sizeof(temp)-2, STR_TERMINATE);
1924
1925         data->notify_data.data.length = len / 2;
1926         data->notify_data.data.string = (uint16 *)talloc(mem_ctx, len);
1927
1928         if (!data->notify_data.data.string) {
1929                 data->notify_data.data.length = 0;
1930                 return;
1931         }
1932
1933         memcpy(data->notify_data.data.string, temp, len);
1934 }
1935
1936 /*******************************************************************
1937  * fill a notify_info_data with job status
1938  ********************************************************************/
1939 static void spoolss_notify_job_status_string(int snum,
1940                                              SPOOL_NOTIFY_INFO_DATA *data,
1941                                              print_queue_struct *queue,
1942                                              NT_PRINTER_INFO_LEVEL *printer,
1943                                              TALLOC_CTX *mem_ctx)
1944 {
1945         /*
1946          * Now we're returning job status codes we just return a "" here. JRA.
1947          */
1948
1949         char *p = "";
1950         pstring temp;
1951         uint32 len;
1952
1953 #if 0 /* NO LONGER NEEDED - JRA. 02/22/2001 */
1954         p = "unknown";
1955
1956         switch (queue->status) {
1957         case LPQ_QUEUED:
1958                 p = "Queued";
1959                 break;
1960         case LPQ_PAUSED:
1961                 p = "";    /* NT provides the paused string */
1962                 break;
1963         case LPQ_SPOOLING:
1964                 p = "Spooling";
1965                 break;
1966         case LPQ_PRINTING:
1967                 p = "Printing";
1968                 break;
1969         }
1970 #endif /* NO LONGER NEEDED. */
1971
1972         len = rpcstr_push(temp, p, sizeof(temp) - 2, STR_TERMINATE);
1973
1974         data->notify_data.data.length = len / 2;
1975         data->notify_data.data.string = (uint16 *)talloc(mem_ctx, len);
1976
1977         if (!data->notify_data.data.string) {
1978                 data->notify_data.data.length = 0;
1979                 return;
1980         }
1981
1982         memcpy(data->notify_data.data.string, temp, len);
1983 }
1984
1985 /*******************************************************************
1986  * fill a notify_info_data with job time
1987  ********************************************************************/
1988 static void spoolss_notify_job_time(int snum,
1989                                     SPOOL_NOTIFY_INFO_DATA *data,
1990                                     print_queue_struct *queue,
1991                                     NT_PRINTER_INFO_LEVEL *printer,
1992                                     TALLOC_CTX *mem_ctx)
1993 {
1994         data->notify_data.value[0]=0x0;
1995         data->notify_data.value[1]=0;
1996 }
1997
1998 /*******************************************************************
1999  * fill a notify_info_data with job size
2000  ********************************************************************/
2001 static void spoolss_notify_job_size(int snum,
2002                                     SPOOL_NOTIFY_INFO_DATA *data,
2003                                     print_queue_struct *queue,
2004                                     NT_PRINTER_INFO_LEVEL *printer,
2005                                     TALLOC_CTX *mem_ctx)
2006 {
2007         data->notify_data.value[0]=queue->size;
2008         data->notify_data.value[1]=0;
2009 }
2010
2011 /*******************************************************************
2012  Fill a notify_info_data with job position.
2013  ********************************************************************/
2014
2015 static void spoolss_notify_job_position(int snum,
2016                                         SPOOL_NOTIFY_INFO_DATA *data,
2017                                         print_queue_struct *queue,
2018                                         NT_PRINTER_INFO_LEVEL *printer,
2019                                         TALLOC_CTX *mem_ctx)
2020 {
2021         data->notify_data.value[0]=queue->job;
2022         data->notify_data.value[1]=0;
2023 }
2024
2025 /*******************************************************************
2026  Fill a notify_info_data with submitted time.
2027  ********************************************************************/
2028
2029 static void spoolss_notify_submitted_time(int snum,
2030                                           SPOOL_NOTIFY_INFO_DATA *data,
2031                                           print_queue_struct *queue,
2032                                           NT_PRINTER_INFO_LEVEL *printer,
2033                                           TALLOC_CTX *mem_ctx)
2034 {
2035         struct tm *t;
2036         uint32 len;
2037         SYSTEMTIME st;
2038         char *p;
2039
2040         t=gmtime(&queue->time);
2041
2042         len = sizeof(SYSTEMTIME);
2043
2044         data->notify_data.data.length = len;
2045         data->notify_data.data.string = (uint16 *)talloc(mem_ctx, len);
2046
2047         if (!data->notify_data.data.string) {
2048                 data->notify_data.data.length = 0;
2049                 return;
2050         }
2051
2052         make_systemtime(&st, t);
2053
2054         /*
2055          * Systemtime must be linearized as a set of UINT16's.
2056          * Fix from Benjamin (Bj) Kuit bj@it.uts.edu.au
2057          */
2058
2059         p = (char *)data->notify_data.data.string;
2060         SSVAL(p, 0, st.year);
2061         SSVAL(p, 2, st.month);
2062         SSVAL(p, 4, st.dayofweek);
2063         SSVAL(p, 6, st.day);
2064         SSVAL(p, 8, st.hour);
2065         SSVAL(p, 10, st.minute);
2066         SSVAL(p, 12, st.second);
2067         SSVAL(p, 14, st.milliseconds);
2068 }
2069
2070 #define END 65535
2071
2072 struct s_notify_info_data_table
2073 {
2074         uint16 type;
2075         uint16 field;
2076         char *name;
2077         uint32 size;
2078         void (*fn) (int snum, SPOOL_NOTIFY_INFO_DATA *data,
2079                     print_queue_struct *queue,
2080                     NT_PRINTER_INFO_LEVEL *printer, TALLOC_CTX *mem_ctx);
2081 };
2082
2083 struct s_notify_info_data_table notify_info_data_table[] =
2084 {
2085 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_SERVER_NAME,         "PRINTER_NOTIFY_SERVER_NAME",         POINTER,   spoolss_notify_server_name },
2086 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_PRINTER_NAME,        "PRINTER_NOTIFY_PRINTER_NAME",        POINTER,   spoolss_notify_printer_name },
2087 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_SHARE_NAME,          "PRINTER_NOTIFY_SHARE_NAME",          POINTER,   spoolss_notify_share_name },
2088 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_PORT_NAME,           "PRINTER_NOTIFY_PORT_NAME",           POINTER,   spoolss_notify_port_name },
2089 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_DRIVER_NAME,         "PRINTER_NOTIFY_DRIVER_NAME",         POINTER,   spoolss_notify_driver_name },
2090 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_COMMENT,             "PRINTER_NOTIFY_COMMENT",             POINTER,   spoolss_notify_comment },
2091 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_LOCATION,            "PRINTER_NOTIFY_LOCATION",            POINTER,   spoolss_notify_location },
2092 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_DEVMODE,             "PRINTER_NOTIFY_DEVMODE",             POINTER,   spoolss_notify_devmode },
2093 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_SEPFILE,             "PRINTER_NOTIFY_SEPFILE",             POINTER,   spoolss_notify_sepfile },
2094 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_PRINT_PROCESSOR,     "PRINTER_NOTIFY_PRINT_PROCESSOR",     POINTER,   spoolss_notify_print_processor },
2095 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_PARAMETERS,          "PRINTER_NOTIFY_PARAMETERS",          POINTER,   spoolss_notify_parameters },
2096 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_DATATYPE,            "PRINTER_NOTIFY_DATATYPE",            POINTER,   spoolss_notify_datatype },
2097 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_SECURITY_DESCRIPTOR, "PRINTER_NOTIFY_SECURITY_DESCRIPTOR", POINTER,   spoolss_notify_security_desc },
2098 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_ATTRIBUTES,          "PRINTER_NOTIFY_ATTRIBUTES",          ONE_VALUE, spoolss_notify_attributes },
2099 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_PRIORITY,            "PRINTER_NOTIFY_PRIORITY",            ONE_VALUE, spoolss_notify_priority },
2100 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_DEFAULT_PRIORITY,    "PRINTER_NOTIFY_DEFAULT_PRIORITY",    ONE_VALUE, spoolss_notify_default_priority },
2101 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_START_TIME,          "PRINTER_NOTIFY_START_TIME",          ONE_VALUE, spoolss_notify_start_time },
2102 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_UNTIL_TIME,          "PRINTER_NOTIFY_UNTIL_TIME",          ONE_VALUE, spoolss_notify_until_time },
2103 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_STATUS,              "PRINTER_NOTIFY_STATUS",              ONE_VALUE, spoolss_notify_status },
2104 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_STATUS_STRING,       "PRINTER_NOTIFY_STATUS_STRING",       POINTER,   NULL },
2105 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_CJOBS,               "PRINTER_NOTIFY_CJOBS",               ONE_VALUE, spoolss_notify_cjobs },
2106 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_AVERAGE_PPM,         "PRINTER_NOTIFY_AVERAGE_PPM",         ONE_VALUE, spoolss_notify_average_ppm },
2107 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_TOTAL_PAGES,         "PRINTER_NOTIFY_TOTAL_PAGES",         POINTER,   NULL },
2108 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_PAGES_PRINTED,       "PRINTER_NOTIFY_PAGES_PRINTED",       POINTER,   NULL },
2109 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_TOTAL_BYTES,         "PRINTER_NOTIFY_TOTAL_BYTES",         POINTER,   NULL },
2110 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_BYTES_PRINTED,       "PRINTER_NOTIFY_BYTES_PRINTED",       POINTER,   NULL },
2111 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_PRINTER_NAME,            "JOB_NOTIFY_PRINTER_NAME",            POINTER,   spoolss_notify_printer_name },
2112 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_MACHINE_NAME,            "JOB_NOTIFY_MACHINE_NAME",            POINTER,   spoolss_notify_server_name },
2113 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_PORT_NAME,               "JOB_NOTIFY_PORT_NAME",               POINTER,   spoolss_notify_port_name },
2114 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_USER_NAME,               "JOB_NOTIFY_USER_NAME",               POINTER,   spoolss_notify_username },
2115 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_NOTIFY_NAME,             "JOB_NOTIFY_NOTIFY_NAME",             POINTER,   spoolss_notify_username },
2116 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_DATATYPE,                "JOB_NOTIFY_DATATYPE",                POINTER,   spoolss_notify_datatype },
2117 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_PRINT_PROCESSOR,         "JOB_NOTIFY_PRINT_PROCESSOR",         POINTER,   spoolss_notify_print_processor },
2118 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_PARAMETERS,              "JOB_NOTIFY_PARAMETERS",              POINTER,   spoolss_notify_parameters },
2119 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_DRIVER_NAME,             "JOB_NOTIFY_DRIVER_NAME",             POINTER,   spoolss_notify_driver_name },
2120 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_DEVMODE,                 "JOB_NOTIFY_DEVMODE",                 POINTER,   spoolss_notify_devmode },
2121 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_STATUS,                  "JOB_NOTIFY_STATUS",                  ONE_VALUE, spoolss_notify_job_status },
2122 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_STATUS_STRING,           "JOB_NOTIFY_STATUS_STRING",           POINTER,   spoolss_notify_job_status_string },
2123 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_SECURITY_DESCRIPTOR,     "JOB_NOTIFY_SECURITY_DESCRIPTOR",     POINTER,   NULL },
2124 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_DOCUMENT,                "JOB_NOTIFY_DOCUMENT",                POINTER,   spoolss_notify_job_name },
2125 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_PRIORITY,                "JOB_NOTIFY_PRIORITY",                ONE_VALUE, spoolss_notify_priority },
2126 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_POSITION,                "JOB_NOTIFY_POSITION",                ONE_VALUE, spoolss_notify_job_position },
2127 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_SUBMITTED,               "JOB_NOTIFY_SUBMITTED",               POINTER,   spoolss_notify_submitted_time },
2128 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_START_TIME,              "JOB_NOTIFY_START_TIME",              ONE_VALUE, spoolss_notify_start_time },
2129 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_UNTIL_TIME,              "JOB_NOTIFY_UNTIL_TIME",              ONE_VALUE, spoolss_notify_until_time },
2130 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_TIME,                    "JOB_NOTIFY_TIME",                    ONE_VALUE, spoolss_notify_job_time },
2131 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_TOTAL_PAGES,             "JOB_NOTIFY_TOTAL_PAGES",             ONE_VALUE, NULL },
2132 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_PAGES_PRINTED,           "JOB_NOTIFY_PAGES_PRINTED",           ONE_VALUE, NULL },
2133 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_TOTAL_BYTES,             "JOB_NOTIFY_TOTAL_BYTES",             ONE_VALUE, spoolss_notify_job_size },
2134 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_BYTES_PRINTED,           "JOB_NOTIFY_BYTES_PRINTED",           ONE_VALUE, NULL },
2135 { END,                 END,                                "",                                   END,       NULL }
2136 };
2137
2138 /*******************************************************************
2139 return the size of info_data structure
2140 ********************************************************************/
2141 static uint32 size_of_notify_info_data(uint16 type, uint16 field)
2142 {
2143         int i=0;
2144
2145         while (notify_info_data_table[i].type != END)
2146         {
2147                 if ( (notify_info_data_table[i].type == type ) &&
2148                      (notify_info_data_table[i].field == field ) )
2149                 {
2150                         return (notify_info_data_table[i].size);
2151                 }
2152                 i++;
2153         }
2154         return (65535);
2155 }
2156
2157 /*******************************************************************
2158 return the type of notify_info_data
2159 ********************************************************************/
2160 static BOOL type_of_notify_info_data(uint16 type, uint16 field)
2161 {
2162         int i=0;
2163
2164         while (notify_info_data_table[i].type != END)
2165         {
2166                 if ( (notify_info_data_table[i].type == type ) &&
2167                      (notify_info_data_table[i].field == field ) )
2168                 {
2169                         if (notify_info_data_table[i].size == POINTER)
2170                         {
2171                                 return (False);
2172                         }
2173                         else
2174                         {
2175                                 return (True);
2176                         }
2177                 }
2178                 i++;
2179         }
2180         return (False);
2181 }
2182
2183 /****************************************************************************
2184 ****************************************************************************/
2185 static int search_notify(uint16 type, uint16 field, int *value)
2186 {
2187         int j;
2188         BOOL found;
2189
2190         for (j=0, found=False; found==False && notify_info_data_table[j].type != END ; j++)
2191         {
2192                 if ( (notify_info_data_table[j].type  == type  ) &&
2193                      (notify_info_data_table[j].field == field ) )
2194                         found=True;
2195         }
2196         *value=--j;
2197
2198         if ( found && (notify_info_data_table[j].fn != NULL) )
2199                 return True;
2200         else
2201                 return False;
2202 }
2203
2204 /****************************************************************************
2205 ****************************************************************************/
2206 static void construct_info_data(SPOOL_NOTIFY_INFO_DATA *info_data, uint16 type, uint16 field, int id)
2207 {
2208         info_data->type     = type;
2209         info_data->field    = field;
2210         info_data->reserved = 0;
2211         info_data->id       = id;
2212         info_data->size     = size_of_notify_info_data(type, field);
2213         info_data->enc_type = type_of_notify_info_data(type, field);
2214 }
2215
2216
2217 /*******************************************************************
2218  *
2219  * fill a notify_info struct with info asked
2220  *
2221  ********************************************************************/
2222 static BOOL construct_notify_printer_info(SPOOL_NOTIFY_INFO *info, int
2223                                           snum, SPOOL_NOTIFY_OPTION_TYPE
2224                                           *option_type, uint32 id,
2225                                           TALLOC_CTX *mem_ctx)
2226 {
2227         int field_num,j;
2228         uint16 type;
2229         uint16 field;
2230
2231         SPOOL_NOTIFY_INFO_DATA *current_data, *tid;
2232         NT_PRINTER_INFO_LEVEL *printer = NULL;
2233         print_queue_struct *queue=NULL;
2234
2235         type=option_type->type;
2236
2237         DEBUG(4,("construct_notify_printer_info: Notify type: [%s], number of notify info: [%d] on printer: [%s]\n",
2238                 (option_type->type==PRINTER_NOTIFY_TYPE?"PRINTER_NOTIFY_TYPE":"JOB_NOTIFY_TYPE"),
2239                 option_type->count, lp_servicename(snum)));
2240
2241         if (!W_ERROR_IS_OK(get_a_printer(&printer, 2, lp_servicename(snum))))
2242                 return False;
2243
2244         for(field_num=0; field_num<option_type->count; field_num++) {
2245                 field = option_type->fields[field_num];
2246                 DEBUG(4,("construct_notify_printer_info: notify [%d]: type [%x], field [%x]\n", field_num, type, field));
2247
2248                 if (!search_notify(type, field, &j) )
2249                         continue;
2250
2251                 if((tid=(SPOOL_NOTIFY_INFO_DATA *)Realloc(info->data, (info->count+1)*sizeof(SPOOL_NOTIFY_INFO_DATA))) == NULL) {
2252                         DEBUG(0,("construct_notify_printer_info: failed to enlarge buffer info->data!\n"));
2253                         return False;
2254                 }
2255                 else info->data = tid;
2256
2257                 current_data=&info->data[info->count];
2258
2259                 construct_info_data(current_data, type, field, id);
2260
2261                 DEBUG(10,("construct_notify_printer_info: calling [%s]  snum=%d  printername=[%s])\n",
2262                                 notify_info_data_table[j].name, snum, printer->info_2->printername ));
2263
2264                 notify_info_data_table[j].fn(snum, current_data, queue,
2265                                              printer, mem_ctx);
2266
2267                 info->count++;
2268         }
2269
2270         free_a_printer(&printer, 2);
2271         return True;
2272 }
2273
2274 /*******************************************************************
2275  *
2276  * fill a notify_info struct with info asked
2277  *
2278  ********************************************************************/
2279 static BOOL construct_notify_jobs_info(print_queue_struct *queue,
2280                                        SPOOL_NOTIFY_INFO *info,
2281                                        NT_PRINTER_INFO_LEVEL *printer,
2282                                        int snum, SPOOL_NOTIFY_OPTION_TYPE
2283                                        *option_type, uint32 id,
2284                                        TALLOC_CTX *mem_ctx)
2285 {
2286         int field_num,j;
2287         uint16 type;
2288         uint16 field;
2289
2290         SPOOL_NOTIFY_INFO_DATA *current_data, *tid;
2291
2292         DEBUG(4,("construct_notify_jobs_info\n"));
2293
2294         type = option_type->type;
2295
2296         DEBUGADD(4,("Notify type: [%s], number of notify info: [%d]\n",
2297                 (option_type->type==PRINTER_NOTIFY_TYPE?"PRINTER_NOTIFY_TYPE":"JOB_NOTIFY_TYPE"),
2298                 option_type->count));
2299
2300         for(field_num=0; field_num<option_type->count; field_num++) {
2301                 field = option_type->fields[field_num];
2302
2303                 if (!search_notify(type, field, &j) )
2304                         continue;
2305
2306                 if((tid=Realloc(info->data, (info->count+1)*sizeof(SPOOL_NOTIFY_INFO_DATA))) == NULL) {
2307                         DEBUG(0,("construct_notify_jobs_info: failed to enlarg buffer info->data!\n"));
2308                         return False;
2309                 }
2310                 else info->data = tid;
2311
2312                 current_data=&(info->data[info->count]);
2313
2314                 construct_info_data(current_data, type, field, id);
2315                 notify_info_data_table[j].fn(snum, current_data, queue,
2316                                              printer, mem_ctx);
2317                 info->count++;
2318         }
2319
2320         return True;
2321 }
2322
2323 /*
2324  * JFM: The enumeration is not that simple, it's even non obvious.
2325  *
2326  * let's take an example: I want to monitor the PRINTER SERVER for
2327  * the printer's name and the number of jobs currently queued.
2328  * So in the NOTIFY_OPTION, I have one NOTIFY_OPTION_TYPE structure.
2329  * Its type is PRINTER_NOTIFY_TYPE and it has 2 fields NAME and CJOBS.
2330  *
2331  * I have 3 printers on the back of my server.
2332  *
2333  * Now the response is a NOTIFY_INFO structure, with 6 NOTIFY_INFO_DATA
2334  * structures.
2335  *   Number     Data                    Id
2336  *      1       printer 1 name          1
2337  *      2       printer 1 cjob          1
2338  *      3       printer 2 name          2
2339  *      4       printer 2 cjob          2
2340  *      5       printer 3 name          3
2341  *      6       printer 3 name          3
2342  *
2343  * that's the print server case, the printer case is even worse.
2344  */
2345
2346 /*******************************************************************
2347  *
2348  * enumerate all printers on the printserver
2349  * fill a notify_info struct with info asked
2350  *
2351  ********************************************************************/
2352
2353 static WERROR printserver_notify_info(pipes_struct *p, POLICY_HND *hnd,
2354                                       SPOOL_NOTIFY_INFO *info,
2355                                       TALLOC_CTX *mem_ctx)
2356 {
2357         int snum;
2358         Printer_entry *Printer=find_printer_index_by_hnd(p, hnd);
2359         int n_services=lp_numservices();
2360         int i;
2361         uint32 id;
2362         SPOOL_NOTIFY_OPTION *option;
2363         SPOOL_NOTIFY_OPTION_TYPE *option_type;
2364
2365         DEBUG(4,("printserver_notify_info\n"));
2366
2367         option=Printer->notify.option;
2368         id=1;
2369         info->version=2;
2370         info->data=NULL;
2371         info->count=0;
2372
2373         for (i=0; i<option->count; i++) {
2374                 option_type=&(option->ctr.type[i]);
2375
2376                 if (option_type->type!=PRINTER_NOTIFY_TYPE)
2377                         continue;
2378
2379                 for (snum=0; snum<n_services; snum++)
2380                         if ( lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum) )
2381                                 if (construct_notify_printer_info
2382                                     (info, snum, option_type, id, mem_ctx))
2383                                         id++;
2384         }
2385
2386         /*
2387          * Debugging information, don't delete.
2388          */
2389         /*
2390         DEBUG(1,("dumping the NOTIFY_INFO\n"));
2391         DEBUGADD(1,("info->version:[%d], info->flags:[%d], info->count:[%d]\n", info->version, info->flags, info->count));
2392         DEBUGADD(1,("num\ttype\tfield\tres\tid\tsize\tenc_type\n"));
2393
2394         for (i=0; i<info->count; i++) {
2395                 DEBUGADD(1,("[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\n",
2396                 i, info->data[i].type, info->data[i].field, info->data[i].reserved,
2397                 info->data[i].id, info->data[i].size, info->data[i].enc_type));
2398         }
2399         */
2400
2401         return WERR_OK;
2402 }
2403
2404 /*******************************************************************
2405  *
2406  * fill a notify_info struct with info asked
2407  *
2408  ********************************************************************/
2409 static WERROR printer_notify_info(pipes_struct *p, POLICY_HND *hnd, SPOOL_NOTIFY_INFO *info,
2410                                   TALLOC_CTX *mem_ctx)
2411 {
2412         int snum;
2413         Printer_entry *Printer=find_printer_index_by_hnd(p, hnd);
2414         int i;
2415         uint32 id;
2416         SPOOL_NOTIFY_OPTION *option;
2417         SPOOL_NOTIFY_OPTION_TYPE *option_type;
2418         int count,j;
2419         print_queue_struct *queue=NULL;
2420         print_status_struct status;
2421
2422         DEBUG(4,("printer_notify_info\n"));
2423
2424         option=Printer->notify.option;
2425         id=0xffffffff;
2426         info->version=2;
2427         info->data=NULL;
2428         info->count=0;
2429
2430         get_printer_snum(p, hnd, &snum);
2431
2432         for (i=0; i<option->count; i++) {
2433                 option_type=&option->ctr.type[i];
2434
2435                 switch ( option_type->type ) {
2436                 case PRINTER_NOTIFY_TYPE:
2437                         if(construct_notify_printer_info(info, snum,
2438                                                          option_type, id,
2439                                                          mem_ctx))
2440                                 id--;
2441                         break;
2442
2443                 case JOB_NOTIFY_TYPE: {
2444                         NT_PRINTER_INFO_LEVEL *printer = NULL;
2445
2446                         count = print_queue_status(snum, &queue, &status);
2447
2448                         if (!W_ERROR_IS_OK(get_a_printer(&printer, 2,
2449                                                          lp_servicename(snum))))
2450                                 goto done;
2451
2452                         for (j=0; j<count; j++) {
2453                                 construct_notify_jobs_info(&queue[j], info,
2454                                                            printer, snum,
2455                                                            option_type,
2456                                                            queue[j].job,
2457                                                            mem_ctx);
2458                         }
2459
2460                         free_a_printer(&printer, 2);
2461
2462                 done:
2463                         SAFE_FREE(queue);
2464                         break;
2465                 }
2466                 }
2467         }
2468
2469         /*
2470          * Debugging information, don't delete.
2471          */
2472         /*
2473         DEBUG(1,("dumping the NOTIFY_INFO\n"));
2474         DEBUGADD(1,("info->version:[%d], info->flags:[%d], info->count:[%d]\n", info->version, info->flags, info->count));
2475         DEBUGADD(1,("num\ttype\tfield\tres\tid\tsize\tenc_type\n"));
2476
2477         for (i=0; i<info->count; i++) {
2478                 DEBUGADD(1,("[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\n",
2479                 i, info->data[i].type, info->data[i].field, info->data[i].reserved,
2480                 info->data[i].id, info->data[i].size, info->data[i].enc_type));
2481         }
2482         */
2483         return WERR_OK;
2484 }
2485
2486 /********************************************************************
2487  * spoolss_rfnpcnex
2488  ********************************************************************/
2489
2490 WERROR _spoolss_rfnpcnex( pipes_struct *p, SPOOL_Q_RFNPCNEX *q_u, SPOOL_R_RFNPCNEX *r_u)
2491 {
2492         POLICY_HND *handle = &q_u->handle;
2493 /*      uint32 change = q_u->change; - notused. */
2494 /*      SPOOL_NOTIFY_OPTION *option = q_u->option; - notused. */
2495         SPOOL_NOTIFY_INFO *info = &r_u->info;
2496
2497         Printer_entry *Printer=find_printer_index_by_hnd(p, handle);
2498         WERROR result = WERR_BADFID;
2499
2500         /* we always have a NOTIFY_INFO struct */
2501         r_u->info_ptr=0x1;
2502
2503         if (!Printer) {
2504                 DEBUG(0,("_spoolss_rfnpcnex: Invalid handle (%s).\n",
2505                          OUR_HANDLE(handle)));
2506                 goto done;
2507         }
2508
2509         DEBUG(4,("Printer type %x\n",Printer->printer_type));
2510
2511         /* jfm: the change value isn't used right now.
2512          *      we will honour it when
2513          *      a) we'll be able to send notification to the client
2514          *      b) we'll have a way to communicate between the spoolss process.
2515          *
2516          *      same thing for option->flags
2517          *      I should check for PRINTER_NOTIFY_OPTIONS_REFRESH but as
2518          *      I don't have a global notification system, I'm sending back all the
2519          *      informations even when _NOTHING_ has changed.
2520          */
2521
2522         /* just ignore the SPOOL_NOTIFY_OPTION */
2523
2524         switch (Printer->printer_type) {
2525                 case PRINTER_HANDLE_IS_PRINTSERVER:
2526                         result = printserver_notify_info(p, handle, info, p->mem_ctx);
2527                         break;
2528
2529                 case PRINTER_HANDLE_IS_PRINTER:
2530                         result = printer_notify_info(p, handle, info, p->mem_ctx);
2531                         break;
2532         }
2533
2534  done:
2535         return result;
2536 }
2537
2538 /********************************************************************
2539  * construct_printer_info_0
2540  * fill a printer_info_0 struct
2541  ********************************************************************/
2542 static BOOL construct_printer_info_0(PRINTER_INFO_0 *printer, int snum)
2543 {
2544         pstring chaine;
2545         int count;
2546         NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
2547         counter_printer_0 *session_counter;
2548         uint32 global_counter;
2549         struct tm *t;
2550         time_t setuptime;
2551         print_status_struct status;
2552
2553         if (!W_ERROR_IS_OK(get_a_printer(&ntprinter, 2, lp_servicename(snum))))
2554                 return False;
2555
2556         count = print_queue_length(snum, &status);
2557
2558         /* check if we already have a counter for this printer */
2559         session_counter = (counter_printer_0 *)ubi_dlFirst(&counter_list);
2560
2561         for(; session_counter; session_counter = (counter_printer_0 *)ubi_dlNext(session_counter)) {
2562                 if (session_counter->snum == snum)
2563                         break;
2564         }
2565
2566         /* it's the first time, add it to the list */
2567         if (session_counter==NULL) {
2568                 if((session_counter=(counter_printer_0 *)malloc(sizeof(counter_printer_0))) == NULL) {
2569                         free_a_printer(&ntprinter, 2);
2570                         return False;
2571                 }
2572                 ZERO_STRUCTP(session_counter);
2573                 session_counter->snum=snum;
2574                 session_counter->counter=0;
2575                 ubi_dlAddHead( &counter_list, (ubi_dlNode *)session_counter);
2576         }
2577
2578         /* increment it */
2579         session_counter->counter++;
2580
2581         /* JFM:
2582          * the global_counter should be stored in a TDB as it's common to all the clients
2583          * and should be zeroed on samba startup
2584          */
2585         global_counter=session_counter->counter;
2586
2587         pstrcpy(chaine,ntprinter->info_2->printername);
2588
2589         init_unistr(&printer->printername, chaine);
2590
2591         slprintf(chaine,sizeof(chaine)-1,"\\\\%s", get_called_name());
2592         init_unistr(&printer->servername, chaine);
2593
2594         printer->cjobs = count;
2595         printer->total_jobs = 0;
2596         printer->total_bytes = 0;
2597
2598         setuptime = (time_t)ntprinter->info_2->setuptime;
2599         t=gmtime(&setuptime);
2600
2601         printer->year = t->tm_year+1900;
2602         printer->month = t->tm_mon+1;
2603         printer->dayofweek = t->tm_wday;
2604         printer->day = t->tm_mday;
2605         printer->hour = t->tm_hour;
2606         printer->minute = t->tm_min;
2607         printer->second = t->tm_sec;
2608         printer->milliseconds = 0;
2609
2610         printer->global_counter = global_counter;
2611         printer->total_pages = 0;
2612         printer->major_version = 0x0004;        /* NT 4 */
2613         printer->build_version = 0x0565;        /* build 1381 */
2614         printer->unknown7 = 0x1;
2615         printer->unknown8 = 0x0;
2616         printer->unknown9 = 0x0;
2617         printer->session_counter = session_counter->counter;
2618         printer->unknown11 = 0x0;
2619         printer->printer_errors = 0x0;          /* number of print failure */
2620         printer->unknown13 = 0x0;
2621         printer->unknown14 = 0x1;
2622         printer->unknown15 = 0x024a;            /* 586 Pentium ? */
2623         printer->unknown16 =  0x0;
2624         printer->change_id = ntprinter->info_2->changeid; /* ChangeID in milliseconds*/
2625         printer->unknown18 =  0x0;
2626         printer->status = nt_printq_status(status.status);
2627         printer->unknown20 =  0x0;
2628         printer->c_setprinter = ntprinter->info_2->c_setprinter; /* how many times setprinter has been called */
2629         printer->unknown22 = 0x0;
2630         printer->unknown23 = 0x6;               /* 6  ???*/
2631         printer->unknown24 = 0;                 /* unknown 24 to 26 are always 0 */
2632         printer->unknown25 = 0;
2633         printer->unknown26 = 0;
2634         printer->unknown27 = 0;
2635         printer->unknown28 = 0;
2636         printer->unknown29 = 0;
2637
2638         free_a_printer(&ntprinter,2);
2639         return (True);
2640 }
2641
2642 /********************************************************************
2643  * construct_printer_info_1
2644  * fill a printer_info_1 struct
2645  ********************************************************************/
2646 static BOOL construct_printer_info_1(uint32 flags, PRINTER_INFO_1 *printer, int snum)
2647 {
2648         pstring chaine;
2649         pstring chaine2;
2650         NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
2651
2652         if (!W_ERROR_IS_OK(get_a_printer(&ntprinter, 2, lp_servicename(snum))))
2653                 return False;
2654
2655         printer->flags=flags;
2656
2657         if (*ntprinter->info_2->comment == '\0') {
2658                 init_unistr(&printer->comment, lp_comment(snum));
2659                 slprintf(chaine,sizeof(chaine)-1,"%s%s,%s,%s",get_called_name(), ntprinter->info_2->printername,
2660                         ntprinter->info_2->drivername, lp_comment(snum));
2661         }
2662         else {
2663                 init_unistr(&printer->comment, ntprinter->info_2->comment); /* saved comment. */
2664                 slprintf(chaine,sizeof(chaine)-1,"%s%s,%s,%s",get_called_name(), ntprinter->info_2->printername,
2665                         ntprinter->info_2->drivername, ntprinter->info_2->comment);
2666         }
2667
2668         slprintf(chaine2,sizeof(chaine)-1,"%s", ntprinter->info_2->printername);
2669
2670         init_unistr(&printer->description, chaine);
2671         init_unistr(&printer->name, chaine2);
2672
2673         free_a_printer(&ntprinter,2);
2674
2675         return True;
2676 }
2677
2678 /****************************************************************************
2679  Free a DEVMODE struct.
2680 ****************************************************************************/
2681
2682 static void free_dev_mode(DEVICEMODE *dev)
2683 {
2684         if (dev == NULL)
2685                 return;
2686
2687         SAFE_FREE(dev->private);
2688         SAFE_FREE(dev);
2689 }
2690
2691 /****************************************************************************
2692  Create a DEVMODE struct. Returns malloced memory.
2693 ****************************************************************************/
2694
2695 static DEVICEMODE *construct_dev_mode(int snum)
2696 {
2697         char adevice[32];
2698         char aform[32];
2699         NT_PRINTER_INFO_LEVEL *printer = NULL;
2700         NT_DEVICEMODE *ntdevmode = NULL;
2701         DEVICEMODE *devmode = NULL;
2702
2703         DEBUG(7,("construct_dev_mode\n"));
2704
2705         DEBUGADD(8,("getting printer characteristics\n"));
2706
2707         if ((devmode = (DEVICEMODE *)malloc(sizeof(DEVICEMODE))) == NULL) {
2708                 DEBUG(0,("construct_dev_mode: malloc fail.\n"));
2709                 return NULL;
2710         }
2711
2712         ZERO_STRUCTP(devmode);
2713
2714         if (!W_ERROR_IS_OK(get_a_printer(&printer, 2, lp_servicename(snum))))
2715                 goto fail;
2716
2717         if (printer->info_2->devmode)
2718                 ntdevmode = dup_nt_devicemode(printer->info_2->devmode);
2719
2720         if (ntdevmode == NULL)
2721                 goto fail;
2722
2723         DEBUGADD(8,("loading DEVICEMODE\n"));
2724
2725         slprintf(adevice, sizeof(adevice)-1, printer->info_2->printername);
2726         init_unistr(&devmode->devicename, adevice);
2727
2728         slprintf(aform, sizeof(aform)-1, ntdevmode->formname);
2729         init_unistr(&devmode->formname, aform);
2730
2731         devmode->specversion      = ntdevmode->specversion;
2732         devmode->driverversion    = ntdevmode->driverversion;
2733         devmode->size             = ntdevmode->size;
2734         devmode->driverextra      = ntdevmode->driverextra;
2735         devmode->fields           = ntdevmode->fields;
2736
2737         devmode->orientation      = ntdevmode->orientation;
2738         devmode->papersize        = ntdevmode->papersize;
2739         devmode->paperlength      = ntdevmode->paperlength;
2740         devmode->paperwidth       = ntdevmode->paperwidth;
2741         devmode->scale            = ntdevmode->scale;
2742         devmode->copies           = ntdevmode->copies;
2743         devmode->defaultsource    = ntdevmode->defaultsource;
2744         devmode->printquality     = ntdevmode->printquality;
2745         devmode->color            = ntdevmode->color;
2746         devmode->duplex           = ntdevmode->duplex;
2747         devmode->yresolution      = ntdevmode->yresolution;
2748         devmode->ttoption         = ntdevmode->ttoption;
2749         devmode->collate          = ntdevmode->collate;
2750         devmode->icmmethod        = ntdevmode->icmmethod;
2751         devmode->icmintent        = ntdevmode->icmintent;
2752         devmode->mediatype        = ntdevmode->mediatype;
2753         devmode->dithertype       = ntdevmode->dithertype;
2754
2755         if (ntdevmode->private != NULL) {
2756                 if ((devmode->private=(uint8 *)memdup(ntdevmode->private, ntdevmode->driverextra)) == NULL)
2757                         goto fail;
2758         }
2759
2760         free_nt_devicemode(&ntdevmode);
2761         free_a_printer(&printer,2);
2762
2763         return devmode;
2764
2765   fail:
2766
2767         if (ntdevmode)
2768                 free_nt_devicemode(&ntdevmode);
2769         if (printer)
2770                 free_a_printer(&printer,2);
2771         free_dev_mode(devmode);
2772
2773         return NULL;
2774 }
2775
2776 /********************************************************************
2777  * construct_printer_info_2
2778  * fill a printer_info_2 struct
2779  ********************************************************************/
2780
2781 static BOOL construct_printer_info_2(PRINTER_INFO_2 *printer, int snum)
2782 {
2783         int count;
2784         NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
2785
2786         print_status_struct status;
2787
2788         if (!W_ERROR_IS_OK(get_a_printer(&ntprinter, 2, lp_servicename(snum))))
2789                 return False;
2790
2791         count = print_queue_length(snum, &status);
2792
2793         init_unistr(&printer->servername, ntprinter->info_2->servername); /* servername*/
2794         init_unistr(&printer->printername, ntprinter->info_2->printername);                             /* printername*/
2795         init_unistr(&printer->sharename, lp_servicename(snum));                 /* sharename */
2796         init_unistr(&printer->portname, ntprinter->info_2->portname);                   /* port */
2797         init_unistr(&printer->drivername, ntprinter->info_2->drivername);       /* drivername */
2798
2799         if (*ntprinter->info_2->comment == '\0')
2800                 init_unistr(&printer->comment, lp_comment(snum));                       /* comment */
2801         else
2802                 init_unistr(&printer->comment, ntprinter->info_2->comment); /* saved comment. */
2803
2804         init_unistr(&printer->location, ntprinter->info_2->location);           /* location */
2805         init_unistr(&printer->sepfile, ntprinter->info_2->sepfile);             /* separator file */
2806         init_unistr(&printer->printprocessor, ntprinter->info_2->printprocessor);/* print processor */
2807         init_unistr(&printer->datatype, ntprinter->info_2->datatype);           /* datatype */
2808         init_unistr(&printer->parameters, ntprinter->info_2->parameters);       /* parameters (of print processor) */
2809
2810         printer->attributes = ntprinter->info_2->attributes;
2811
2812         printer->priority = ntprinter->info_2->priority;                                /* priority */
2813         printer->defaultpriority = ntprinter->info_2->default_priority;         /* default priority */
2814         printer->starttime = ntprinter->info_2->starttime;                      /* starttime */
2815         printer->untiltime = ntprinter->info_2->untiltime;                      /* untiltime */
2816         printer->status = nt_printq_status(status.status);                      /* status */
2817         printer->cjobs = count;                                                 /* jobs */
2818         printer->averageppm = ntprinter->info_2->averageppm;                    /* average pages per minute */
2819
2820         if((printer->devmode = construct_dev_mode(snum)) == NULL) {
2821                 DEBUG(8, ("Returning NULL Devicemode!\n"));
2822         }
2823
2824         if (ntprinter->info_2->secdesc_buf && ntprinter->info_2->secdesc_buf->len != 0) {
2825                 /* steal the printer info sec_desc structure.  [badly done]. */
2826                 printer->secdesc = ntprinter->info_2->secdesc_buf->sec;
2827                 ntprinter->info_2->secdesc_buf->sec = NULL; /* Stolen memory. */
2828                 ntprinter->info_2->secdesc_buf->len = 0; /* Stolen memory. */
2829                 ntprinter->info_2->secdesc_buf->max_len = 0; /* Stolen memory. */
2830         }
2831         else {
2832                 printer->secdesc = NULL;
2833         }
2834
2835         free_a_printer(&ntprinter, 2);
2836         return True;
2837 }
2838
2839 /********************************************************************
2840  * construct_printer_info_3
2841  * fill a printer_info_3 struct
2842  ********************************************************************/
2843 static BOOL construct_printer_info_3(PRINTER_INFO_3 **pp_printer, int snum)
2844 {
2845         NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
2846         PRINTER_INFO_3 *printer = NULL;
2847
2848         if (!W_ERROR_IS_OK(get_a_printer(&ntprinter, 2, lp_servicename(snum))))
2849                 return False;
2850
2851         *pp_printer = NULL;
2852         if ((printer = (PRINTER_INFO_3 *)malloc(sizeof(PRINTER_INFO_3))) == NULL) {
2853                 DEBUG(0,("construct_printer_info_3: malloc fail.\n"));
2854                 return False;
2855         }
2856
2857         ZERO_STRUCTP(printer);
2858
2859         printer->flags = 4; /* These are the components of the SD we are returning. */
2860         if (ntprinter->info_2->secdesc_buf && ntprinter->info_2->secdesc_buf->len != 0) {
2861                 /* steal the printer info sec_desc structure.  [badly done]. */
2862                 printer->secdesc = ntprinter->info_2->secdesc_buf->sec;
2863
2864 #if 0
2865                 /*
2866                  * Set the flags for the components we are returning.
2867                  */
2868
2869                 if (printer->secdesc->owner_sid)
2870                         printer->flags |= OWNER_SECURITY_INFORMATION;
2871
2872                 if (printer->secdesc->grp_sid)
2873                         printer->flags |= GROUP_SECURITY_INFORMATION;
2874
2875                 if (printer->secdesc->dacl)
2876                         printer->flags |= DACL_SECURITY_INFORMATION;
2877
2878                 if (printer->secdesc->sacl)
2879                         printer->flags |= SACL_SECURITY_INFORMATION;
2880 #endif
2881
2882                 ntprinter->info_2->secdesc_buf->sec = NULL; /* Stolen the malloced memory. */
2883                 ntprinter->info_2->secdesc_buf->len = 0; /* Stolen the malloced memory. */
2884                 ntprinter->info_2->secdesc_buf->max_len = 0; /* Stolen the malloced memory. */
2885         }
2886
2887         free_a_printer(&ntprinter, 2);
2888
2889         *pp_printer = printer;
2890         return True;
2891 }
2892
2893 /********************************************************************
2894  * construct_printer_info_4
2895  * fill a printer_info_4 struct
2896  ********************************************************************/
2897
2898 static BOOL construct_printer_info_4(PRINTER_INFO_4 *printer, int snum)
2899 {
2900         NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
2901
2902         if (!W_ERROR_IS_OK(get_a_printer(&ntprinter, 2, lp_servicename(snum))))
2903                 return False;
2904
2905         init_unistr(&printer->printername, ntprinter->info_2->printername);                             /* printername*/
2906         init_unistr(&printer->servername, ntprinter->info_2->servername); /* servername*/
2907         printer->attributes = ntprinter->info_2->attributes;
2908
2909         free_a_printer(&ntprinter, 2);
2910         return True;
2911 }
2912
2913 /********************************************************************
2914  * construct_printer_info_5
2915  * fill a printer_info_5 struct
2916  ********************************************************************/
2917
2918 static BOOL construct_printer_info_5(PRINTER_INFO_5 *printer, int snum)
2919 {
2920         NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
2921
2922         if (!W_ERROR_IS_OK(get_a_printer(&ntprinter, 2, lp_servicename(snum))))
2923                 return False;
2924
2925         init_unistr(&printer->printername, ntprinter->info_2->printername);                             /* printername*/
2926         init_unistr(&printer->portname, ntprinter->info_2->portname); /* portname */
2927         printer->attributes = ntprinter->info_2->attributes;
2928         printer->device_not_selected_timeout = 0x3a98;
2929         printer->transmission_retry_timeout = 0xafc8;
2930
2931         free_a_printer(&ntprinter, 2);
2932         return True;
2933 }
2934
2935
2936 /********************************************************************
2937  Spoolss_enumprinters.
2938 ********************************************************************/
2939 static WERROR enum_all_printers_info_1(uint32 flags, NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
2940 {
2941         int snum;
2942         int i;
2943         int n_services=lp_numservices();
2944         PRINTER_INFO_1 *tp, *printers=NULL;
2945         PRINTER_INFO_1 current_prt;
2946
2947         DEBUG(4,("enum_all_printers_info_1\n"));
2948
2949         for (snum=0; snum<n_services; snum++) {
2950                 if (lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum) ) {
2951                         DEBUG(4,("Found a printer in smb.conf: %s[%x]\n", lp_servicename(snum), snum));
2952
2953                         if (construct_printer_info_1(flags, &current_prt, snum)) {
2954                                 if((tp=Realloc(printers, (*returned +1)*sizeof(PRINTER_INFO_1))) == NULL) {
2955                                         DEBUG(0,("enum_all_printers_info_1: failed to enlarge printers buffer!\n"));
2956                                         SAFE_FREE(printers);
2957                                         *returned=0;
2958                                         return WERR_NOMEM;
2959                                 }
2960                                 else printers = tp;
2961                                 DEBUG(4,("ReAlloced memory for [%d] PRINTER_INFO_1\n", *returned));
2962                                 memcpy(&printers[*returned], &current_prt, sizeof(PRINTER_INFO_1));
2963                                 (*returned)++;
2964                         }
2965                 }
2966         }
2967
2968         /* check the required size. */
2969         for (i=0; i<*returned; i++)
2970                 (*needed) += spoolss_size_printer_info_1(&printers[i]);
2971
2972         if (!alloc_buffer_size(buffer, *needed))
2973                 return WERR_INSUFFICIENT_BUFFER;
2974
2975         /* fill the buffer with the structures */
2976         for (i=0; i<*returned; i++)
2977                 smb_io_printer_info_1("", buffer, &printers[i], 0);
2978
2979         /* clear memory */
2980         SAFE_FREE(printers);
2981
2982         if (*needed > offered) {
2983                 *returned=0;
2984                 return WERR_INSUFFICIENT_BUFFER;
2985         }
2986         else
2987                 return WERR_OK;
2988 }
2989
2990 /********************************************************************
2991  enum_all_printers_info_1_local.
2992 *********************************************************************/
2993 static WERROR enum_all_printers_info_1_local(NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
2994 {
2995         DEBUG(4,("enum_all_printers_info_1_local\n"));
2996
2997         return enum_all_printers_info_1(PRINTER_ENUM_ICON8, buffer, offered, needed, returned);
2998 }
2999
3000 /********************************************************************
3001  enum_all_printers_info_1_name.
3002 *********************************************************************/
3003 static WERROR enum_all_printers_info_1_name(fstring name, NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
3004 {
3005         char *s = name;
3006
3007         DEBUG(4,("enum_all_printers_info_1_name\n"));
3008
3009         if ((name[0] == '\\') && (name[1] == '\\'))
3010                 s = name + 2;
3011
3012         if (is_myname_or_ipaddr(s)) {
3013                 return enum_all_printers_info_1(PRINTER_ENUM_ICON8, buffer, offered, needed, returned);
3014         }
3015         else
3016                 return WERR_INVALID_NAME;
3017 }
3018
3019 /********************************************************************
3020  enum_all_printers_info_1_remote.
3021 *********************************************************************/
3022 static WERROR enum_all_printers_info_1_remote(fstring name, NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
3023 {
3024         PRINTER_INFO_1 *printer;
3025         fstring printername;
3026         fstring desc;
3027         fstring comment;
3028         DEBUG(4,("enum_all_printers_info_1_remote\n"));
3029
3030         /* JFM: currently it's more a place holder than anything else.
3031          * In the spooler world there is a notion of server registration.
3032          * the print servers are registring (sp ?) on the PDC (in the same domain)
3033          *
3034          * We should have a TDB here. The registration is done thru an undocumented RPC call.
3035          */
3036
3037         if((printer=(PRINTER_INFO_1 *)malloc(sizeof(PRINTER_INFO_1))) == NULL)
3038                 return WERR_NOMEM;
3039
3040         *returned=1;
3041
3042         slprintf(printername, sizeof(printername)-1,"Windows NT Remote Printers!!\\\\%s", get_called_name());
3043         slprintf(desc, sizeof(desc)-1,"%s", get_called_name());
3044         slprintf(comment, sizeof(comment)-1, "Logged on Domain");
3045
3046         init_unistr(&printer->description, desc);
3047         init_unistr(&printer->name, printername);
3048         init_unistr(&printer->comment, comment);
3049         printer->flags=PRINTER_ENUM_ICON3|PRINTER_ENUM_CONTAINER;
3050
3051         /* check the required size. */
3052         *needed += spoolss_size_printer_info_1(printer);
3053
3054         if (!alloc_buffer_size(buffer, *needed)) {
3055                 SAFE_FREE(printer);
3056                 return WERR_INSUFFICIENT_BUFFER;
3057         }
3058
3059         /* fill the buffer with the structures */
3060         smb_io_printer_info_1("", buffer, printer, 0);
3061
3062         /* clear memory */
3063         SAFE_FREE(printer);
3064
3065         if (*needed > offered) {
3066                 *returned=0;
3067                 return WERR_INSUFFICIENT_BUFFER;
3068         }
3069         else
3070                 return WERR_OK;
3071 }
3072
3073 /********************************************************************
3074  enum_all_printers_info_1_network.
3075 *********************************************************************/
3076
3077 static WERROR enum_all_printers_info_1_network(NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
3078 {
3079         DEBUG(4,("enum_all_printers_info_1_network\n"));
3080
3081         return enum_all_printers_info_1(PRINTER_ENUM_UNKNOWN_8, buffer, offered, needed, returned);
3082 }
3083
3084 /********************************************************************
3085  * api_spoolss_enumprinters
3086  *
3087  * called from api_spoolss_enumprinters (see this to understand)
3088  ********************************************************************/
3089
3090 static WERROR enum_all_printers_info_2(NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
3091 {
3092         int snum;
3093         int i;
3094         int n_services=lp_numservices();
3095         PRINTER_INFO_2 *tp, *printers=NULL;
3096         PRINTER_INFO_2 current_prt;
3097
3098         for (snum=0; snum<n_services; snum++) {
3099                 if (lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum) ) {
3100                         DEBUG(4,("Found a printer in smb.conf: %s[%x]\n", lp_servicename(snum), snum));
3101
3102                         if (construct_printer_info_2(&current_prt, snum)) {
3103                                 if((tp=Realloc(printers, (*returned +1)*sizeof(PRINTER_INFO_2))) == NULL) {
3104                                         DEBUG(0,("enum_all_printers_info_2: failed to enlarge printers buffer!\n"));
3105                                         SAFE_FREE(printers);
3106                                         *returned = 0;
3107                                         return WERR_NOMEM;
3108                                 }
3109                                 else printers = tp;
3110                                 DEBUG(4,("ReAlloced memory for [%d] PRINTER_INFO_2\n", *returned));
3111                                 memcpy(&printers[*returned], &current_prt, sizeof(PRINTER_INFO_2));
3112                                 (*returned)++;
3113                         }
3114                 }
3115         }
3116
3117         /* check the required size. */
3118         for (i=0; i<*returned; i++)
3119                 (*needed) += spoolss_size_printer_info_2(&printers[i]);
3120
3121         if (!alloc_buffer_size(buffer, *needed)) {
3122                 for (i=0; i<*returned; i++) {
3123                         free_devmode(printers[i].devmode);
3124                 }
3125                 SAFE_FREE(printers);
3126                 return WERR_INSUFFICIENT_BUFFER;
3127         }
3128
3129         /* fill the buffer with the structures */
3130         for (i=0; i<*returned; i++)
3131                 smb_io_printer_info_2("", buffer, &(printers[i]), 0);
3132
3133         /* clear memory */
3134         for (i=0; i<*returned; i++) {
3135                 free_devmode(printers[i].devmode);
3136         }
3137         SAFE_FREE(printers);
3138
3139         if (*needed > offered) {
3140                 *returned=0;
3141                 return WERR_INSUFFICIENT_BUFFER;
3142         }
3143         else
3144                 return WERR_OK;
3145 }
3146
3147 /********************************************************************
3148  * handle enumeration of printers at level 1
3149  ********************************************************************/
3150 static WERROR enumprinters_level1( uint32 flags, fstring name,
3151                                  NEW_BUFFER *buffer, uint32 offered,
3152                                  uint32 *needed, uint32 *returned)
3153 {
3154         /* Not all the flags are equals */
3155
3156         if (flags & PRINTER_ENUM_LOCAL)
3157                 return enum_all_printers_info_1_local(buffer, offered, needed, returned);
3158
3159         if (flags & PRINTER_ENUM_NAME)
3160                 return enum_all_printers_info_1_name(name, buffer, offered, needed, returned);
3161
3162         if (flags & PRINTER_ENUM_REMOTE)
3163                 return enum_all_printers_info_1_remote(name, buffer, offered, needed, returned);
3164
3165         if (flags & PRINTER_ENUM_NETWORK)
3166                 return enum_all_printers_info_1_network(buffer, offered, needed, returned);
3167
3168         return WERR_OK; /* NT4sp5 does that */
3169 }
3170
3171 /********************************************************************
3172  * handle enumeration of printers at level 2
3173  ********************************************************************/
3174 static WERROR enumprinters_level2( uint32 flags, fstring servername,
3175                                  NEW_BUFFER *buffer, uint32 offered,
3176                                  uint32 *needed, uint32 *returned)
3177 {
3178         char *s = servername;
3179
3180         if (flags & PRINTER_ENUM_LOCAL) {
3181                         return enum_all_printers_info_2(buffer, offered, needed, returned);
3182         }
3183
3184         if (flags & PRINTER_ENUM_NAME) {
3185                 if ((servername[0] == '\\') && (servername[1] == '\\'))
3186                         s = servername + 2;
3187                 if (is_myname_or_ipaddr(s))
3188                         return enum_all_printers_info_2(buffer, offered, needed, returned);
3189                 else
3190                         return WERR_INVALID_NAME;
3191         }
3192
3193         if (flags & PRINTER_ENUM_REMOTE)
3194                 return WERR_UNKNOWN_LEVEL;
3195
3196         return WERR_OK;
3197 }
3198
3199 /********************************************************************
3200  * handle enumeration of printers at level 5
3201  ********************************************************************/
3202 static WERROR enumprinters_level5( uint32 flags, fstring servername,
3203                                  NEW_BUFFER *buffer, uint32 offered,
3204                                  uint32 *needed, uint32 *returned)
3205 {
3206 /*      return enum_all_printers_info_5(buffer, offered, needed, returned);*/
3207         return WERR_OK;
3208 }
3209
3210 /********************************************************************
3211  * api_spoolss_enumprinters
3212  *
3213  * called from api_spoolss_enumprinters (see this to understand)
3214  ********************************************************************/
3215
3216 WERROR _spoolss_enumprinters( pipes_struct *p, SPOOL_Q_ENUMPRINTERS *q_u, SPOOL_R_ENUMPRINTERS *r_u)
3217 {
3218         uint32 flags = q_u->flags;
3219         UNISTR2 *servername = &q_u->servername;
3220         uint32 level = q_u->level;
3221         NEW_BUFFER *buffer = NULL;
3222         uint32 offered = q_u->offered;
3223         uint32 *needed = &r_u->needed;
3224         uint32 *returned = &r_u->returned;
3225
3226         fstring name;
3227
3228         /* that's an [in out] buffer */
3229         spoolss_move_buffer(q_u->buffer, &r_u->buffer);
3230         buffer = r_u->buffer;
3231
3232         DEBUG(4,("_spoolss_enumprinters\n"));
3233
3234         *needed=0;
3235         *returned=0;
3236
3237         /*
3238          * Level 1:
3239          *          flags==PRINTER_ENUM_NAME
3240          *           if name=="" then enumerates all printers
3241          *           if name!="" then enumerate the printer
3242          *          flags==PRINTER_ENUM_REMOTE
3243          *          name is NULL, enumerate printers
3244          * Level 2: name!="" enumerates printers, name can't be NULL
3245          * Level 3: doesn't exist
3246          * Level 4: does a local registry lookup
3247          * Level 5: same as Level 2
3248          */
3249
3250         unistr2_to_ascii(name, servername, sizeof(name)-1);
3251         strupper(name);
3252
3253         switch (level) {
3254         case 1:
3255                 return enumprinters_level1(flags, name, buffer, offered, needed, returned);
3256         case 2:
3257                 return enumprinters_level2(flags, name, buffer, offered, needed, returned);
3258         case 5:
3259                 return enumprinters_level5(flags, name, buffer, offered, needed, returned);
3260         case 3:
3261         case 4:
3262                 break;
3263         }
3264         return WERR_UNKNOWN_LEVEL;
3265 }
3266
3267 /****************************************************************************
3268 ****************************************************************************/
3269 static WERROR getprinter_level_0(int snum, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
3270 {
3271         PRINTER_INFO_0 *printer=NULL;
3272
3273         if((printer=(PRINTER_INFO_0*)malloc(sizeof(PRINTER_INFO_0))) == NULL)
3274                 return WERR_NOMEM;
3275
3276         construct_printer_info_0(printer, snum);
3277
3278         /* check the required size. */
3279         *needed += spoolss_size_printer_info_0(printer);
3280
3281         if (!alloc_buffer_size(buffer, *needed)) {
3282                 SAFE_FREE(printer);
3283                 return WERR_INSUFFICIENT_BUFFER;
3284         }
3285
3286         /* fill the buffer with the structures */
3287         smb_io_printer_info_0("", buffer, printer, 0);
3288
3289         /* clear memory */
3290         SAFE_FREE(printer);
3291
3292         if (*needed > offered) {
3293                 return WERR_INSUFFICIENT_BUFFER;
3294         }
3295
3296         return WERR_OK;
3297 }
3298
3299 /****************************************************************************
3300 ****************************************************************************/
3301 static WERROR getprinter_level_1(int snum, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
3302 {
3303         PRINTER_INFO_1 *printer=NULL;
3304
3305         if((printer=(PRINTER_INFO_1*)malloc(sizeof(PRINTER_INFO_1))) == NULL)
3306                 return WERR_NOMEM;
3307
3308         construct_printer_info_1(PRINTER_ENUM_ICON8, printer, snum);
3309
3310         /* check the required size. */
3311         *needed += spoolss_size_printer_info_1(printer);
3312
3313         if (!alloc_buffer_size(buffer, *needed)) {
3314                 SAFE_FREE(printer);
3315                 return WERR_INSUFFICIENT_BUFFER;
3316         }
3317
3318         /* fill the buffer with the structures */
3319         smb_io_printer_info_1("", buffer, printer, 0);
3320
3321         /* clear memory */
3322         SAFE_FREE(printer);
3323
3324         if (*needed > offered) {
3325                 return WERR_INSUFFICIENT_BUFFER;
3326         }
3327
3328         return WERR_OK;
3329 }
3330
3331 /****************************************************************************
3332 ****************************************************************************/
3333 static WERROR getprinter_level_2(int snum, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
3334 {
3335         PRINTER_INFO_2 *printer=NULL;
3336
3337         if((printer=(PRINTER_INFO_2*)malloc(sizeof(PRINTER_INFO_2)))==NULL)
3338                 return WERR_NOMEM;
3339
3340         construct_printer_info_2(printer, snum);
3341
3342         /* check the required size. */
3343         *needed += spoolss_size_printer_info_2(printer);
3344
3345         if (!alloc_buffer_size(buffer, *needed)) {
3346                 free_printer_info_2(printer);
3347                 return WERR_INSUFFICIENT_BUFFER;
3348         }
3349
3350         /* fill the buffer with the structures */
3351         if (!smb_io_printer_info_2("", buffer, printer, 0)) {
3352                 free_printer_info_2(printer);
3353                 return WERR_NOMEM;
3354         }
3355
3356         /* clear memory */
3357         free_printer_info_2(printer);
3358
3359         if (*needed > offered) {
3360                 return WERR_INSUFFICIENT_BUFFER;
3361         }
3362
3363         return WERR_OK;
3364 }
3365
3366 /****************************************************************************
3367 ****************************************************************************/
3368 static WERROR getprinter_level_3(int snum, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
3369 {
3370         PRINTER_INFO_3 *printer=NULL;
3371
3372         if (!construct_printer_info_3(&printer, snum))
3373                 return WERR_NOMEM;
3374
3375         /* check the required size. */
3376         *needed += spoolss_size_printer_info_3(printer);
3377
3378         if (!alloc_buffer_size(buffer, *needed)) {
3379                 free_printer_info_3(printer);
3380                 return WERR_INSUFFICIENT_BUFFER;
3381         }
3382
3383         /* fill the buffer with the structures */
3384         smb_io_printer_info_3("", buffer, printer, 0);
3385
3386         /* clear memory */
3387         free_printer_info_3(printer);
3388
3389         if (*needed > offered) {
3390                 return WERR_INSUFFICIENT_BUFFER;
3391         }
3392
3393         return WERR_OK;
3394 }
3395
3396 /****************************************************************************
3397 ****************************************************************************/
3398 static WERROR getprinter_level_4(int snum, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
3399 {
3400         PRINTER_INFO_4 *printer=NULL;
3401
3402         if((printer=(PRINTER_INFO_4*)malloc(sizeof(PRINTER_INFO_4)))==NULL)
3403                 return WERR_NOMEM;
3404
3405         if (!construct_printer_info_4(printer, snum))
3406                 return WERR_NOMEM;
3407
3408         /* check the required size. */
3409         *needed += spoolss_size_printer_info_4(printer);
3410
3411         if (!alloc_buffer_size(buffer, *needed)) {
3412                 free_printer_info_4(printer);
3413                 return WERR_INSUFFICIENT_BUFFER;
3414         }
3415
3416         /* fill the buffer with the structures */
3417         smb_io_printer_info_4("", buffer, printer, 0);
3418
3419         /* clear memory */
3420         free_printer_info_4(printer);
3421
3422         if (*needed > offered) {
3423                 return WERR_INSUFFICIENT_BUFFER;
3424         }
3425
3426         return WERR_OK;
3427 }
3428
3429 /****************************************************************************
3430 ****************************************************************************/
3431 static WERROR getprinter_level_5(int snum, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
3432 {
3433         PRINTER_INFO_5 *printer=NULL;
3434
3435         if((printer=(PRINTER_INFO_5*)malloc(sizeof(PRINTER_INFO_5)))==NULL)
3436                 return WERR_NOMEM;
3437
3438         if (!construct_printer_info_5(printer, snum))
3439                 return WERR_NOMEM;
3440
3441         /* check the required size. */
3442         *needed += spoolss_size_printer_info_5(printer);
3443
3444         if (!alloc_buffer_size(buffer, *needed)) {
3445                 free_printer_info_5(printer);
3446                 return WERR_INSUFFICIENT_BUFFER;
3447         }
3448
3449         /* fill the buffer with the structures */
3450         smb_io_printer_info_5("", buffer, printer, 0);
3451
3452         /* clear memory */
3453         free_printer_info_5(printer);
3454
3455         if (*needed > offered) {
3456                 return WERR_INSUFFICIENT_BUFFER;
3457         }
3458
3459         return WERR_OK;
3460 }
3461
3462 /****************************************************************************
3463 ****************************************************************************/
3464
3465 WERROR _spoolss_getprinter(pipes_struct *p, SPOOL_Q_GETPRINTER *q_u, SPOOL_R_GETPRINTER *r_u)
3466 {
3467         POLICY_HND *handle = &q_u->handle;
3468         uint32 level = q_u->level;
3469         NEW_BUFFER *buffer = NULL;
3470         uint32 offered = q_u->offered;
3471         uint32 *needed = &r_u->needed;
3472
3473         int snum;
3474
3475         /* that's an [in out] buffer */
3476         spoolss_move_buffer(q_u->buffer, &r_u->buffer);
3477         buffer = r_u->buffer;
3478
3479         *needed=0;
3480
3481         if (!get_printer_snum(p, handle, &snum))
3482                 return WERR_BADFID;
3483
3484         switch (level) {
3485         case 0:
3486                 return getprinter_level_0(snum, buffer, offered, needed);
3487         case 1:
3488                 return getprinter_level_1(snum, buffer, offered, needed);
3489         case 2:
3490                 return getprinter_level_2(snum, buffer, offered, needed);
3491         case 3:
3492                 return getprinter_level_3(snum, buffer, offered, needed);
3493         case 4:
3494                 return getprinter_level_4(snum, buffer, offered, needed);
3495         case 5:
3496                 return getprinter_level_5(snum, buffer, offered, needed);
3497         }
3498         return WERR_UNKNOWN_LEVEL;
3499 }
3500
3501 /********************************************************************
3502  * fill a DRIVER_INFO_1 struct
3503  ********************************************************************/
3504 static void fill_printer_driver_info_1(DRIVER_INFO_1 *info, NT_PRINTER_DRIVER_INFO_LEVEL driver, fstring servername, fstring architecture)
3505 {
3506         init_unistr( &info->name, driver.info_3->name);
3507 }
3508
3509 /********************************************************************
3510  * construct_printer_driver_info_1
3511  ********************************************************************/
3512 static WERROR construct_printer_driver_info_1(DRIVER_INFO_1 *info, int snum, fstring servername, fstring architecture, uint32 version)
3513 {
3514         NT_PRINTER_INFO_LEVEL *printer = NULL;
3515         NT_PRINTER_DRIVER_INFO_LEVEL driver;
3516
3517         ZERO_STRUCT(driver);
3518
3519         if (!W_ERROR_IS_OK(get_a_printer(&printer, 2, lp_servicename(snum))))
3520                 return WERR_INVALID_PRINTER_NAME;
3521
3522         if (!W_ERROR_IS_OK(get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version)))
3523                 return WERR_UNKNOWN_PRINTER_DRIVER;
3524
3525         fill_printer_driver_info_1(info, driver, servername, architecture);
3526
3527         free_a_printer(&printer,2);
3528
3529         return WERR_OK;
3530 }
3531
3532 /********************************************************************
3533  * construct_printer_driver_info_2
3534  * fill a printer_info_2 struct
3535  ********************************************************************/
3536 static void fill_printer_driver_info_2(DRIVER_INFO_2 *info, NT_PRINTER_DRIVER_INFO_LEVEL driver, fstring servername)
3537 {
3538         pstring temp;
3539
3540         info->version=driver.info_3->cversion;
3541
3542         init_unistr( &info->name, driver.info_3->name );
3543         init_unistr( &info->architecture, driver.info_3->environment );
3544
3545
3546     if (strlen(driver.info_3->driverpath)) {
3547                 slprintf(temp, sizeof(temp)-1, "\\\\%s%s", servername, driver.info_3->driverpath);
3548                 init_unistr( &info->driverpath, temp );
3549     } else
3550         init_unistr( &info->driverpath, "" );
3551
3552         if (strlen(driver.info_3->datafile)) {
3553                 slprintf(temp, sizeof(temp)-1, "\\\\%s%s", servername, driver.info_3->datafile);
3554                 init_unistr( &info->datafile, temp );
3555         } else
3556                 init_unistr( &info->datafile, "" );
3557
3558         if (strlen(driver.info_3->configfile)) {
3559                 slprintf(temp, sizeof(temp)-1, "\\\\%s%s", servername, driver.info_3->configfile);
3560                 init_unistr( &info->configfile, temp );
3561         } else
3562                 init_unistr( &info->configfile, "" );
3563 }
3564
3565 /********************************************************************
3566  * construct_printer_driver_info_2
3567  * fill a printer_info_2 struct
3568  ********************************************************************/
3569 static WERROR construct_printer_driver_info_2(DRIVER_INFO_2 *info, int snum, fstring servername, fstring architecture, uint32 version)
3570 {
3571         NT_PRINTER_INFO_LEVEL *printer = NULL;
3572         NT_PRINTER_DRIVER_INFO_LEVEL driver;
3573
3574         ZERO_STRUCT(printer);
3575         ZERO_STRUCT(driver);
3576
3577         if (!W_ERROR_IS_OK(get_a_printer(&printer, 2, lp_servicename(snum))))
3578                 return WERR_INVALID_PRINTER_NAME;
3579
3580         if (!W_ERROR_IS_OK(get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version)))
3581                 return WERR_UNKNOWN_PRINTER_DRIVER;
3582
3583         fill_printer_driver_info_2(info, driver, servername);
3584
3585         free_a_printer(&printer,2);
3586
3587         return WERR_OK;
3588 }
3589
3590 /********************************************************************
3591  * copy a strings array and convert to UNICODE
3592  *
3593  * convert an array of ascii string to a UNICODE string
3594  ********************************************************************/
3595 static void init_unistr_array(uint16 **uni_array, fstring *char_array, char *servername)
3596 {
3597         int i=0;
3598         int j=0;
3599         char *v;
3600         pstring line;
3601         uint16 *tuary;
3602
3603         DEBUG(6,("init_unistr_array\n"));
3604         *uni_array=NULL;
3605
3606         while (1) {
3607                 if (char_array == NULL)
3608                         v = "";
3609                 else {
3610                         v = char_array[i];
3611                         if (!v) v = ""; /* hack to handle null lists */
3612                 }
3613                 if (strlen(v) == 0) break;
3614                 slprintf(line, sizeof(line)-1, "\\\\%s%s", servername, v);
3615                 DEBUGADD(6,("%d:%s:%d\n", i, line, strlen(line)));
3616                 if((tuary=Realloc(*uni_array, (j+strlen(line)+2)*sizeof(uint16))) == NULL) {
3617                         DEBUG(0,("init_unistr_array: Realloc error\n" ));
3618                         return;
3619                 }
3620                 else *uni_array = tuary;
3621                 j += (rpcstr_push((*uni_array+j), line, sizeof(uint16)*strlen(line)+2, 0)/ sizeof(uint16));
3622                 i++;
3623         }
3624
3625         if (*uni_array) {
3626                 (*uni_array)[j]=0x0000;
3627         }
3628
3629         DEBUGADD(6,("last one:done\n"));
3630 }
3631
3632 /********************************************************************
3633  * construct_printer_info_3
3634  * fill a printer_info_3 struct
3635  ********************************************************************/
3636 static void fill_printer_driver_info_3(DRIVER_INFO_3 *info, NT_PRINTER_DRIVER_INFO_LEVEL driver, fstring servername)
3637 {
3638         pstring temp;
3639
3640         ZERO_STRUCTP(info);
3641
3642         info->version=driver.info_3->cversion;
3643
3644         init_unistr( &info->name, driver.info_3->name );
3645         init_unistr( &info->architecture, driver.info_3->environment );
3646
3647     if (strlen(driver.info_3->driverpath)) {
3648         slprintf(temp, sizeof(temp)-1, "\\\\%s%s", servername, driver.info_3->driverpath);
3649         init_unistr( &info->driverpath, temp );
3650     } else
3651         init_unistr( &info->driverpath, "" );
3652
3653     if (strlen(driver.info_3->datafile)) {
3654         slprintf(temp, sizeof(temp)-1, "\\\\%s%s", servername, driver.info_3->datafile);
3655         init_unistr( &info->datafile, temp );
3656     } else
3657         init_unistr( &info->datafile, "" );
3658
3659     if (strlen(driver.info_3->configfile)) {
3660         slprintf(temp, sizeof(temp)-1, "\\\\%s%s", servername, driver.info_3->configfile);
3661         init_unistr( &info->configfile, temp );
3662     } else
3663         init_unistr( &info->configfile, "" );
3664
3665     if (strlen(driver.info_3->helpfile)) {
3666         slprintf(temp, sizeof(temp)-1, "\\\\%s%s", servername, driver.info_3->helpfile);
3667         init_unistr( &info->helpfile, temp );
3668     } else
3669         init_unistr( &info->helpfile, "" );
3670
3671         init_unistr( &info->monitorname, driver.info_3->monitorname );
3672         init_unistr( &info->defaultdatatype, driver.info_3->defaultdatatype );
3673
3674         info->dependentfiles=NULL;
3675         init_unistr_array(&info->dependentfiles, driver.info_3->dependentfiles, servername);
3676 }
3677
3678 /********************************************************************
3679  * construct_printer_info_3
3680  * fill a printer_info_3 struct
3681  ********************************************************************/
3682 static WERROR construct_printer_driver_info_3(DRIVER_INFO_3 *info, int snum, fstring servername, fstring architecture, uint32 version)
3683 {
3684         NT_PRINTER_INFO_LEVEL *printer = NULL;
3685         NT_PRINTER_DRIVER_INFO_LEVEL driver;
3686         WERROR status;
3687         ZERO_STRUCT(driver);
3688
3689         status=get_a_printer(&printer, 2, lp_servicename(snum) );
3690         DEBUG(8,("construct_printer_driver_info_3: status: %s\n", werror_str(status)));
3691         if (!W_ERROR_IS_OK(status))
3692                 return WERR_INVALID_PRINTER_NAME;
3693
3694         status=get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
3695         DEBUG(8,("construct_printer_driver_info_3: status: %s\n", werror_str(status)));
3696         if (!W_ERROR_IS_OK(status)) {
3697                 free_a_printer(&printer,2);
3698                 return WERR_UNKNOWN_PRINTER_DRIVER;
3699         }
3700
3701         fill_printer_driver_info_3(info, driver, servername);
3702
3703         free_a_printer(&printer,2);
3704
3705         return WERR_OK;
3706 }
3707
3708 /********************************************************************
3709  * construct_printer_info_6
3710  * fill a printer_info_6 struct - we know that driver is really level 3. This sucks. JRA.
3711  ********************************************************************/
3712
3713 static void fill_printer_driver_info_6(DRIVER_INFO_6 *info, NT_PRINTER_DRIVER_INFO_LEVEL driver, fstring servername)
3714 {
3715         pstring temp;
3716         fstring nullstr;
3717
3718         ZERO_STRUCTP(info);
3719         memset(&nullstr, '\0', sizeof(fstring));
3720
3721         info->version=driver.info_3->cversion;
3722
3723         init_unistr( &info->name, driver.info_3->name );
3724         init_unistr( &info->architecture, driver.info_3->environment );
3725
3726         if (strlen(driver.info_3->driverpath)) {
3727                 slprintf(temp, sizeof(temp)-1, "\\\\%s%s", servername, driver.info_3->driverpath);
3728                 init_unistr( &info->driverpath, temp );
3729         } else
3730                 init_unistr( &info->driverpath, "" );
3731
3732         if (strlen(driver.info_3->datafile)) {
3733                 slprintf(temp, sizeof(temp)-1, "\\\\%s%s", servername, driver.info_3->datafile);
3734                 init_unistr( &info->datafile, temp );
3735         } else
3736                 init_unistr( &info->datafile, "" );
3737
3738         if (strlen(driver.info_3->configfile)) {
3739                 slprintf(temp, sizeof(temp)-1, "\\\\%s%s", servername, driver.info_3->configfile);
3740                 init_unistr( &info->configfile, temp );
3741         } else
3742                 init_unistr( &info->configfile, "" );
3743
3744         if (strlen(driver.info_3->helpfile)) {
3745                 slprintf(temp, sizeof(temp)-1, "\\\\%s%s", servername, driver.info_3->helpfile);
3746                 init_unistr( &info->helpfile, temp );
3747         } else
3748                 init_unistr( &info->helpfile, "" );
3749
3750         init_unistr( &info->monitorname, driver.info_3->monitorname );
3751         init_unistr( &info->defaultdatatype, driver.info_3->defaultdatatype );
3752
3753         info->dependentfiles=NULL;
3754         init_unistr_array(&info->dependentfiles, driver.info_3->dependentfiles, servername);
3755
3756         info->previousdrivernames=NULL;
3757         init_unistr_array(&info->previousdrivernames, &nullstr, servername);
3758
3759         info->driver_date.low=0;
3760         info->driver_date.high=0;
3761
3762         info->padding=0;
3763         info->driver_version_low=0;
3764         info->driver_version_high=0;
3765
3766         init_unistr( &info->mfgname, "");
3767         init_unistr( &info->oem_url, "");
3768         init_unistr( &info->hardware_id, "");
3769         init_unistr( &info->provider, "");
3770 }
3771
3772 /********************************************************************
3773  * construct_printer_info_6
3774  * fill a printer_info_6 struct
3775  ********************************************************************/
3776 static WERROR construct_printer_driver_info_6(DRIVER_INFO_6 *info, int snum, fstring servername, fstring architecture, uint32 version)
3777 {
3778         NT_PRINTER_INFO_LEVEL *printer = NULL;
3779         NT_PRINTER_DRIVER_INFO_LEVEL driver;
3780         WERROR status;
3781         ZERO_STRUCT(driver);
3782
3783         status=get_a_printer(&printer, 2, lp_servicename(snum) );
3784         DEBUG(8,("construct_printer_driver_info_6: status: %s\n", werror_str(status)));
3785         if (!W_ERROR_IS_OK(status))
3786                 return WERR_INVALID_PRINTER_NAME;
3787
3788         status=get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
3789         DEBUG(8,("construct_printer_driver_info_6: status: %s\n", werror_str(status)));
3790         if (!W_ERROR_IS_OK(status)) {
3791                 /*
3792                  * Is this a W2k client ?
3793                  */
3794
3795                 if (version < 3) {
3796                         free_a_printer(&printer,2);
3797                         return WERR_UNKNOWN_PRINTER_DRIVER;
3798                 }
3799
3800                 /* Yes - try again with a WinNT driver. */
3801                 version = 2;
3802                 status=get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
3803                 DEBUG(8,("construct_printer_driver_info_6: status: %s\n", werror_str(status)));
3804                 if (!W_ERROR_IS_OK(status)) {
3805                         free_a_printer(&printer,2);
3806                         return WERR_UNKNOWN_PRINTER_DRIVER;
3807                 }
3808         }
3809
3810         fill_printer_driver_info_6(info, driver, servername);
3811
3812         free_a_printer(&printer,2);
3813
3814         return WERR_OK;
3815 }
3816
3817 /****************************************************************************
3818 ****************************************************************************/
3819
3820 static void free_printer_driver_info_3(DRIVER_INFO_3 *info)
3821 {
3822         SAFE_FREE(info->dependentfiles);
3823 }
3824
3825 /****************************************************************************
3826 ****************************************************************************/
3827
3828 static void free_printer_driver_info_6(DRIVER_INFO_6 *info)
3829 {
3830         SAFE_FREE(info->dependentfiles);
3831
3832 }
3833
3834 /****************************************************************************
3835 ****************************************************************************/
3836 static WERROR getprinterdriver2_level1(fstring servername, fstring architecture, uint32 version, int snum, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
3837 {
3838         DRIVER_INFO_1 *info=NULL;
3839         WERROR status;
3840
3841         if((info=(DRIVER_INFO_1 *)malloc(sizeof(DRIVER_INFO_1))) == NULL)
3842                 return WERR_NOMEM;
3843
3844         status=construct_printer_driver_info_1(info, snum, servername, architecture, version);
3845         if (!W_ERROR_IS_OK(status)) {
3846                 SAFE_FREE(info);
3847                 return status;
3848         }
3849
3850         /* check the required size. */
3851         *needed += spoolss_size_printer_driver_info_1(info);
3852
3853         if (!alloc_buffer_size(buffer, *needed)) {
3854                 SAFE_FREE(info);
3855                 return WERR_INSUFFICIENT_BUFFER;
3856         }
3857
3858         /* fill the buffer with the structures */
3859         smb_io_printer_driver_info_1("", buffer, info, 0);
3860
3861         /* clear memory */
3862         SAFE_FREE(info);
3863
3864         if (*needed > offered)
3865                 return WERR_INSUFFICIENT_BUFFER;
3866
3867         return WERR_OK;
3868 }
3869
3870 /****************************************************************************
3871 ****************************************************************************/
3872 static WERROR getprinterdriver2_level2(fstring servername, fstring architecture, uint32 version, int snum, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
3873 {
3874         DRIVER_INFO_2 *info=NULL;
3875         WERROR status;
3876
3877         if((info=(DRIVER_INFO_2 *)malloc(sizeof(DRIVER_INFO_2))) == NULL)
3878                 return WERR_NOMEM;
3879
3880         status=construct_printer_driver_info_2(info, snum, servername, architecture, version);
3881         if (!W_ERROR_IS_OK(status)) {
3882                 SAFE_FREE(info);
3883                 return status;
3884         }
3885
3886         /* check the required size. */
3887         *needed += spoolss_size_printer_driver_info_2(info);
3888
3889         if (!alloc_buffer_size(buffer, *needed)) {
3890                 SAFE_FREE(info);
3891                 return WERR_INSUFFICIENT_BUFFER;
3892         }
3893
3894         /* fill the buffer with the structures */
3895         smb_io_printer_driver_info_2("", buffer, info, 0);
3896
3897         /* clear memory */
3898         SAFE_FREE(info);
3899
3900         if (*needed > offered)
3901                 return WERR_INSUFFICIENT_BUFFER;
3902
3903         return WERR_OK;
3904 }
3905
3906 /****************************************************************************
3907 ****************************************************************************/
3908 static WERROR getprinterdriver2_level3(fstring servername, fstring architecture, uint32 version, int snum, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
3909 {
3910         DRIVER_INFO_3 info;
3911         WERROR status;
3912
3913         ZERO_STRUCT(info);
3914
3915         status=construct_printer_driver_info_3(&info, snum, servername, architecture, version);
3916         if (!W_ERROR_IS_OK(status)) {
3917                 return status;
3918         }
3919
3920         /* check the required size. */
3921         *needed += spoolss_size_printer_driver_info_3(&info);
3922
3923         if (!alloc_buffer_size(buffer, *needed)) {
3924                 free_printer_driver_info_3(&info);
3925                 return WERR_INSUFFICIENT_BUFFER;
3926         }
3927
3928         /* fill the buffer with the structures */
3929         smb_io_printer_driver_info_3("", buffer, &info, 0);
3930
3931         free_printer_driver_info_3(&info);
3932
3933         if (*needed > offered)
3934                 return WERR_INSUFFICIENT_BUFFER;
3935
3936         return WERR_OK;
3937 }
3938
3939 /****************************************************************************
3940 ****************************************************************************/
3941 static WERROR getprinterdriver2_level6(fstring servername, fstring architecture, uint32 version, int snum, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
3942 {
3943         DRIVER_INFO_6 info;
3944         WERROR status;
3945
3946         ZERO_STRUCT(info);
3947
3948         status=construct_printer_driver_info_6(&info, snum, servername, architecture, version);
3949         if (!W_ERROR_IS_OK(status)) {
3950                 return status;
3951         }
3952
3953         /* check the required size. */
3954         *needed += spoolss_size_printer_driver_info_6(&info);
3955
3956         if (!alloc_buffer_size(buffer, *needed)) {
3957                 free_printer_driver_info_6(&info);
3958                 return WERR_INSUFFICIENT_BUFFER;
3959         }
3960
3961         /* fill the buffer with the structures */
3962         smb_io_printer_driver_info_6("", buffer, &info, 0);
3963
3964         free_printer_driver_info_6(&info);
3965
3966         if (*needed > offered)
3967                 return WERR_INSUFFICIENT_BUFFER;
3968
3969         return WERR_OK;
3970 }
3971
3972 /****************************************************************************
3973 ****************************************************************************/
3974
3975 WERROR _spoolss_getprinterdriver2(pipes_struct *p, SPOOL_Q_GETPRINTERDRIVER2 *q_u, SPOOL_R_GETPRINTERDRIVER2 *r_u)
3976 {
3977         POLICY_HND *handle = &q_u->handle;
3978         UNISTR2 *uni_arch = &q_u->architecture;
3979         uint32 level = q_u->level;
3980         uint32 clientmajorversion = q_u->clientmajorversion;
3981 /*      uint32 clientminorversion = q_u->clientminorversion; - notused. */
3982         NEW_BUFFER *buffer = NULL;
3983         uint32 offered = q_u->offered;
3984         uint32 *needed = &r_u->needed;
3985         uint32 *servermajorversion = &r_u->servermajorversion;
3986         uint32 *serverminorversion = &r_u->serverminorversion;
3987
3988         fstring servername;
3989         fstring architecture;
3990         int snum;
3991
3992         /* that's an [in out] buffer */
3993         spoolss_move_buffer(q_u->buffer, &r_u->buffer);
3994         buffer = r_u->buffer;
3995
3996         DEBUG(4,("_spoolss_getprinterdriver2\n"));
3997
3998         *needed=0;
3999         *servermajorversion=0;
4000         *serverminorversion=0;
4001
4002         pstrcpy(servername, get_called_name());
4003         unistr2_to_ascii(architecture, uni_arch, sizeof(architecture)-1);
4004
4005         if (!get_printer_snum(p, handle, &snum))
4006                 return WERR_BADFID;
4007
4008         switch (level) {
4009         case 1:
4010                 return getprinterdriver2_level1(servername, architecture, clientmajorversion, snum, buffer, offered, needed);
4011         case 2:
4012                 return getprinterdriver2_level2(servername, architecture, clientmajorversion, snum, buffer, offered, needed);
4013         case 3:
4014                 return getprinterdriver2_level3(servername, architecture, clientmajorversion, snum, buffer, offered, needed);
4015         case 6:
4016                 return getprinterdriver2_level6(servername, architecture, clientmajorversion, snum, buffer, offered, needed);
4017         }
4018
4019         return WERR_UNKNOWN_LEVEL;
4020 }
4021
4022 /****************************************************************************
4023 ****************************************************************************/
4024
4025 WERROR _spoolss_startpageprinter(pipes_struct *p, SPOOL_Q_STARTPAGEPRINTER *q_u, SPOOL_R_STARTPAGEPRINTER *r_u)
4026 {
4027         POLICY_HND *handle = &q_u->handle;
4028
4029         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
4030
4031         if (!Printer) {
4032                 DEBUG(3,("Error in startpageprinter printer handle\n"));
4033                 return WERR_BADFID;
4034         }
4035
4036         Printer->page_started=True;
4037         return WERR_OK;
4038 }
4039
4040 /****************************************************************************
4041 ****************************************************************************/
4042
4043 WERROR _spoolss_endpageprinter(pipes_struct *p, SPOOL_Q_ENDPAGEPRINTER *q_u, SPOOL_R_ENDPAGEPRINTER *r_u)
4044 {
4045         POLICY_HND *handle = &q_u->handle;
4046
4047         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
4048
4049         if (!Printer) {
4050                 DEBUG(0,("_spoolss_endpageprinter: Invalid handle (%s).\n",OUR_HANDLE(handle)));
4051                 return WERR_BADFID;
4052         }
4053
4054         Printer->page_started=False;
4055
4056         return WERR_OK;
4057 }
4058
4059 /********************************************************************
4060  * api_spoolss_getprinter
4061  * called from the spoolss dispatcher
4062  *
4063  ********************************************************************/
4064
4065 WERROR _spoolss_startdocprinter(pipes_struct *p, SPOOL_Q_STARTDOCPRINTER *q_u, SPOOL_R_STARTDOCPRINTER *r_u)
4066 {
4067         POLICY_HND *handle = &q_u->handle;
4068 /*      uint32 level = q_u->doc_info_container.level; - notused. */
4069         DOC_INFO *docinfo = &q_u->doc_info_container.docinfo;
4070         uint32 *jobid = &r_u->jobid;
4071
4072         DOC_INFO_1 *info_1 = &docinfo->doc_info_1;
4073         int snum;
4074         pstring jobname;
4075         fstring datatype;
4076         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
4077         struct current_user user;
4078
4079         if (!Printer) {
4080                 DEBUG(0,("_spoolss_startdocprinter: Invalid handle (%s)\n", OUR_HANDLE(handle)));
4081                 return WERR_BADFID;
4082         }
4083
4084         get_current_user(&user, p);
4085
4086         /*
4087          * a nice thing with NT is it doesn't listen to what you tell it.
4088          * when asked to send _only_ RAW datas, it tries to send datas
4089          * in EMF format.
4090          *
4091          * So I add checks like in NT Server ...
4092          *
4093          * lkclXXXX jean-francois, i love this kind of thing.  oh, well,
4094          * there's a bug in NT client-side code, so we'll fix it in the
4095          * server-side code. *nnnnnggggh!*
4096          */
4097
4098         if (info_1->p_datatype != 0) {
4099                 unistr2_to_ascii(datatype, &info_1->datatype, sizeof(datatype));
4100                 if (strcmp(datatype, "RAW") != 0) {
4101                         (*jobid)=0;
4102                         return WERR_INVALID_DATATYPE;
4103                 }
4104         }
4105
4106         /* get the share number of the printer */
4107         if (!get_printer_snum(p, handle, &snum)) {
4108                 return WERR_BADFID;
4109         }
4110
4111         unistr2_to_ascii(jobname, &info_1->docname, sizeof(jobname));
4112
4113         Printer->jobid = print_job_start(&user, snum, jobname);
4114
4115         /* An error occured in print_job_start() so return an appropriate
4116            NT error code. */
4117
4118         if (Printer->jobid == -1) {
4119                 return map_werror_from_unix(errno);
4120         }
4121
4122         Printer->document_started=True;
4123         (*jobid) = Printer->jobid;
4124
4125         return WERR_OK;
4126 }
4127
4128 /********************************************************************
4129  * api_spoolss_getprinter
4130  * called from the spoolss dispatcher
4131  *
4132  ********************************************************************/
4133
4134 WERROR _spoolss_enddocprinter(pipes_struct *p, SPOOL_Q_ENDDOCPRINTER *q_u, SPOOL_R_ENDDOCPRINTER *r_u)
4135 {
4136         POLICY_HND *handle = &q_u->handle;
4137
4138         return _spoolss_enddocprinter_internal(p, handle);
4139 }
4140
4141 /****************************************************************************
4142 ****************************************************************************/
4143
4144 WERROR _spoolss_writeprinter(pipes_struct *p, SPOOL_Q_WRITEPRINTER *q_u, SPOOL_R_WRITEPRINTER *r_u)
4145 {
4146         POLICY_HND *handle = &q_u->handle;
4147         uint32 buffer_size = q_u->buffer_size;
4148         uint8 *buffer = q_u->buffer;
4149         uint32 *buffer_written = &q_u->buffer_size2;
4150
4151         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
4152
4153         if (!Printer) {
4154                 DEBUG(0,("_spoolss_writeprinter: Invalid handle (%s)\n",OUR_HANDLE(handle)));
4155                 r_u->buffer_written = q_u->buffer_size2;
4156                 return WERR_BADFID;
4157         }
4158
4159         (*buffer_written) = print_job_write(Printer->jobid, (char *)buffer, buffer_size);
4160
4161
4162         r_u->buffer_written = q_u->buffer_size2;
4163
4164         return WERR_OK;
4165 }
4166
4167 /********************************************************************
4168  * api_spoolss_getprinter
4169  * called from the spoolss dispatcher
4170  *
4171  ********************************************************************/
4172 static WERROR control_printer(POLICY_HND *handle, uint32 command,
4173                               pipes_struct *p)
4174 {
4175         struct current_user user;
4176         int snum;
4177         WERROR errcode = WERR_BADFUNC;
4178         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
4179
4180         get_current_user(&user, p);
4181
4182         if (!Printer) {
4183                 DEBUG(0,("control_printer: Invalid handle (%s)\n", OUR_HANDLE(handle)));
4184                 return WERR_BADFID;
4185         }
4186
4187         if (!get_printer_snum(p, handle, &snum))
4188                 return WERR_BADFID;
4189
4190         switch (command) {
4191         case PRINTER_CONTROL_PAUSE:
4192                 if (print_queue_pause(&user, snum, &errcode)) {
4193                         errcode = WERR_OK;
4194                 }
4195                 break;
4196         case PRINTER_CONTROL_RESUME:
4197         case PRINTER_CONTROL_UNPAUSE:
4198                 if (print_queue_resume(&user, snum, &errcode)) {
4199                         errcode = WERR_OK;
4200                 }
4201                 break;
4202         case PRINTER_CONTROL_PURGE:
4203                 if (print_queue_purge(&user, snum, &errcode)) {
4204                         errcode = WERR_OK;
4205                 }
4206                 break;
4207         default:
4208                 return WERR_UNKNOWN_LEVEL;
4209         }
4210
4211         return errcode;
4212 }
4213
4214 /********************************************************************
4215  * api_spoolss_abortprinter
4216  ********************************************************************/
4217
4218 WERROR _spoolss_abortprinter(pipes_struct *p, SPOOL_Q_ABORTPRINTER *q_u, SPOOL_R_ABORTPRINTER *r_u)
4219 {
4220         POLICY_HND *handle = &q_u->handle;
4221
4222         return control_printer(handle, PRINTER_CONTROL_PURGE, p);
4223 }
4224
4225 /********************************************************************
4226  * called by spoolss_api_setprinter
4227  * when updating a printer description
4228  ********************************************************************/
4229 static WERROR update_printer_sec(POLICY_HND *handle, uint32 level,
4230                                  const SPOOL_PRINTER_INFO_LEVEL *info,
4231                                  pipes_struct *p, SEC_DESC_BUF *secdesc_ctr)
4232 {
4233         SEC_DESC_BUF *new_secdesc_ctr = NULL, *old_secdesc_ctr = NULL;
4234         struct current_user user;
4235         WERROR result;
4236         int snum;
4237
4238         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
4239
4240         if (!Printer || !get_printer_snum(p, handle, &snum)) {
4241                 DEBUG(0,("update_printer_sec: Invalid handle (%s)\n",
4242                          OUR_HANDLE(handle)));
4243
4244                 result = WERR_BADFID;
4245                 goto done;
4246         }
4247
4248         /* NT seems to like setting the security descriptor even though
4249            nothing may have actually changed.  This causes annoying
4250            dialog boxes when the user doesn't have permission to change
4251            the security descriptor. */
4252
4253         nt_printing_getsec(p->mem_ctx, Printer->dev.handlename, &old_secdesc_ctr);
4254
4255         if (DEBUGLEVEL >= 10) {
4256                 SEC_ACL *the_acl;
4257                 int i;
4258
4259                 the_acl = old_secdesc_ctr->sec->dacl;
4260                 DEBUG(10, ("old_secdesc_ctr for %s has %d aces:\n",
4261                            PRINTERNAME(snum), the_acl->num_aces));
4262
4263                 for (i = 0; i < the_acl->num_aces; i++) {
4264                         fstring sid_str;
4265
4266                         sid_to_string(sid_str, &the_acl->ace[i].trustee);
4267
4268                         DEBUG(10, ("%s 0x%08x\n", sid_str,
4269                                   the_acl->ace[i].info.mask));
4270                 }
4271
4272                 the_acl = secdesc_ctr->sec->dacl;
4273
4274                 if (the_acl) {
4275                         DEBUG(10, ("secdesc_ctr for %s has %d aces:\n",
4276                                    PRINTERNAME(snum), the_acl->num_aces));
4277
4278                         for (i = 0; i < the_acl->num_aces; i++) {
4279                                 fstring sid_str;
4280
4281                                 sid_to_string(sid_str, &the_acl->ace[i].trustee);
4282
4283                                 DEBUG(10, ("%s 0x%08x\n", sid_str,
4284                                            the_acl->ace[i].info.mask));
4285                         }
4286                 } else {
4287                         DEBUG(10, ("dacl for secdesc_ctr is NULL\n"));
4288                 }
4289         }
4290
4291         new_secdesc_ctr = sec_desc_merge(p->mem_ctx, secdesc_ctr, old_secdesc_ctr);
4292
4293         if (sec_desc_equal(new_secdesc_ctr->sec, old_secdesc_ctr->sec)) {
4294                 result = WERR_OK;
4295                 goto done;
4296         }
4297
4298         /* Work out which user is performing the operation */
4299
4300         get_current_user(&user, p);
4301
4302         /* Check the user has permissions to change the security
4303            descriptor.  By experimentation with two NT machines, the user
4304            requires Full Access to the printer to change security
4305            information. */
4306
4307         if (!print_access_check(&user, snum, PRINTER_ACCESS_ADMINISTER)) {
4308                 result = WERR_ACCESS_DENIED;
4309                 goto done;
4310         }
4311
4312         result = nt_printing_setsec(Printer->dev.handlename, new_secdesc_ctr);
4313
4314  done:
4315
4316         return result;
4317 }
4318
4319 /********************************************************************
4320  Do Samba sanity checks on a printer info struct.
4321  this has changed purpose: it now "canonicalises" printer
4322  info from a client rather than just checking it is correct
4323  ********************************************************************/
4324
4325 static BOOL check_printer_ok(NT_PRINTER_INFO_LEVEL_2 *info, int snum)
4326 {
4327         DEBUG(5,("check_printer_ok: servername=%s printername=%s sharename=%s portname=%s drivername=%s comment=%s location=%s\n",
4328                  info->servername, info->printername, info->sharename, info->portname, info->drivername, info->comment, info->location));
4329
4330         /* we force some elements to "correct" values */
4331         slprintf(info->servername, sizeof(info->servername)-1, "\\\\%s", get_called_name());
4332         slprintf(info->printername, sizeof(info->printername)-1, "\\\\%s\\%s",
4333                  get_called_name(), lp_servicename(snum));
4334         fstrcpy(info->sharename, lp_servicename(snum));
4335         info->attributes = PRINTER_ATTRIBUTE_SHARED   \
4336                 | PRINTER_ATTRIBUTE_LOCAL  \
4337                 | PRINTER_ATTRIBUTE_RAW_ONLY \
4338                 | PRINTER_ATTRIBUTE_QUEUED ;
4339
4340         return True;
4341 }
4342
4343 /****************************************************************************
4344 ****************************************************************************/
4345 static BOOL add_printer_hook(NT_PRINTER_INFO_LEVEL *printer)
4346 {
4347         char *cmd = lp_addprinter_cmd();
4348         char **qlines;
4349         pstring command;
4350         pstring driverlocation;
4351         int numlines;
4352         int ret;
4353         int fd;
4354
4355         /* build driver path... only 9X architecture is needed for legacy reasons */
4356         slprintf(driverlocation, sizeof(driverlocation)-1, "\\\\%s\\print$\\WIN40\\0",
4357                         get_called_name());
4358         /* change \ to \\ for the shell */
4359         all_string_sub(driverlocation,"\\","\\\\",sizeof(pstring));
4360
4361         slprintf(command, sizeof(command)-1, "%s \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"",
4362                         cmd, printer->info_2->printername, printer->info_2->sharename,
4363                         printer->info_2->portname, printer->info_2->drivername,
4364                         printer->info_2->location, driverlocation);
4365
4366         DEBUG(10,("Running [%s]\n", command));
4367         ret = smbrun(command, &fd);
4368         DEBUGADD(10,("returned [%d]\n", ret));
4369
4370         if ( ret != 0 ) {
4371                 if (fd != -1)
4372                         close(fd);
4373                 return False;
4374         }
4375
4376         numlines = 0;
4377         /* Get lines and convert them back to dos-codepage */
4378         qlines = fd_lines_load(fd, &numlines);
4379         DEBUGADD(10,("Lines returned = [%d]\n", numlines));
4380         close(fd);
4381
4382         if(numlines) {
4383                 /* Set the portname to what the script says the portname should be. */
4384                 strncpy(printer->info_2->portname, qlines[0], sizeof(printer->info_2->portname));
4385                 DEBUGADD(6,("Line[0] = [%s]\n", qlines[0]));
4386
4387                 /* Send SIGHUP to process group... is there a better way? */
4388                 kill(0, SIGHUP);
4389                 add_all_printers();
4390         }
4391
4392         file_lines_free(qlines);
4393         return True;
4394 }
4395
4396 /* Return true if two devicemodes are equal */
4397
4398 #define DEVMODE_CHECK_INT(field) \
4399     if (d1->field != d2->field) { \
4400         DEBUG(10, ("nt_devicemode_equal(): " #field " not equal (%d != %d)\n", \
4401             d1->field, d2->field)); \
4402         return False; \
4403     }
4404
4405 static BOOL nt_devicemode_equal(NT_DEVICEMODE *d1, NT_DEVICEMODE *d2)
4406 {
4407         if (!d1 && !d2) goto equal;  /* if both are NULL they are equal */
4408
4409         if (!d1 ^ !d2) {
4410                 DEBUG(10, ("nt_devicemode_equal(): pointers not equal\n"));
4411                 return False; /* if either is exclusively NULL are not equal */
4412         }
4413
4414         if (!strequal(d1->devicename, d2->devicename)) {
4415                 DEBUG(10, ("nt_devicemode_equal(): device not equal (%s != %s)\n", d1->devicename, d2->devicename));
4416                 return False;
4417         }
4418
4419         if (!strequal(d1->formname, d2->formname)) {
4420                 DEBUG(10, ("nt_devicemode_equal(): formname not equal (%s != %s)\n", d1->formname, d2->formname));
4421                 return False;
4422         }
4423
4424         DEVMODE_CHECK_INT(specversion);
4425         DEVMODE_CHECK_INT(driverversion);
4426         DEVMODE_CHECK_INT(driverextra);
4427         DEVMODE_CHECK_INT(orientation);
4428         DEVMODE_CHECK_INT(papersize);
4429         DEVMODE_CHECK_INT(paperlength);
4430         DEVMODE_CHECK_INT(paperwidth);
4431         DEVMODE_CHECK_INT(scale);
4432         DEVMODE_CHECK_INT(copies);
4433         DEVMODE_CHECK_INT(defaultsource);
4434         DEVMODE_CHECK_INT(printquality);
4435         DEVMODE_CHECK_INT(color);
4436         DEVMODE_CHECK_INT(duplex);
4437         DEVMODE_CHECK_INT(yresolution);
4438         DEVMODE_CHECK_INT(ttoption);
4439         DEVMODE_CHECK_INT(collate);
4440         DEVMODE_CHECK_INT(logpixels);
4441
4442         DEVMODE_CHECK_INT(fields);
4443         DEVMODE_CHECK_INT(bitsperpel);
4444         DEVMODE_CHECK_INT(pelswidth);
4445         DEVMODE_CHECK_INT(pelsheight);
4446         DEVMODE_CHECK_INT(displayflags);
4447         DEVMODE_CHECK_INT(displayfrequency);
4448         DEVMODE_CHECK_INT(icmmethod);
4449         DEVMODE_CHECK_INT(icmintent);
4450         DEVMODE_CHECK_INT(mediatype);
4451         DEVMODE_CHECK_INT(dithertype);
4452         DEVMODE_CHECK_INT(reserved1);
4453         DEVMODE_CHECK_INT(reserved2);
4454         DEVMODE_CHECK_INT(panningwidth);
4455         DEVMODE_CHECK_INT(panningheight);
4456
4457         /* compare the private data if it exists */
4458         if (!d1->driverextra && !d2->driverextra) goto equal;
4459
4460
4461         DEVMODE_CHECK_INT(driverextra);
4462
4463         if (memcmp(d1->private, d2->private, d1->driverextra)) {
4464                 DEBUG(10, ("nt_devicemode_equal(): private data not equal\n"));
4465                 return False;
4466         }
4467
4468  equal:
4469         DEBUG(10, ("nt_devicemode_equal(): devicemodes identical\n"));
4470         return True;
4471 }
4472
4473 /* Return true if two NT_PRINTER_PARAM structures are equal */
4474
4475 static BOOL nt_printer_param_equal(NT_PRINTER_PARAM *p1,
4476                                    NT_PRINTER_PARAM *p2)
4477 {
4478         if (!p1 && !p2) goto equal;
4479
4480         if ((!p1 && p2) || (p1 && !p2)) {
4481                 DEBUG(10, ("nt_printer_param_equal(): pointers differ\n"));
4482                 return False;
4483         }
4484
4485         /* Compare lists of printer parameters */
4486
4487         while (p1) {
4488                 BOOL found = False;
4489                 NT_PRINTER_PARAM *q = p1;
4490
4491                 /* Find the parameter in the second structure */
4492
4493                 while(q) {
4494
4495                         if (strequal(p1->value, q->value)) {
4496
4497                                 if (p1->type != q->type) {
4498                                         DEBUG(10, ("nt_printer_param_equal():"
4499                                                    "types for %s differ (%d != %d)\n",
4500                                                    p1->value, p1->type,
4501                                                    q->type));
4502                                         break;
4503                                 }
4504
4505                                 if (p1->data_len != q->data_len) {
4506                                         DEBUG(10, ("nt_printer_param_equal():"
4507                                                    "len for %s differs (%d != %d)\n",
4508                                                    p1->value, p1->data_len,
4509                                                    q->data_len));
4510                                         break;
4511                                 }
4512
4513                                 if (memcmp(p1->data, q->data, p1->data_len) == 0) {
4514                                         found = True;
4515                                 } else {
4516                                         DEBUG(10, ("nt_printer_param_equal():"
4517                                                    "data for %s differs\n", p1->value));
4518                                 }
4519
4520                                 break;
4521                         }
4522
4523                         q = q->next;
4524                 }
4525
4526                 if (!found) {
4527                         DEBUG(10, ("nt_printer_param_equal(): param %s "
4528                                    "does not exist\n", p1->value));
4529                         return False;
4530                 }
4531
4532                 p1 = p1->next;
4533         }
4534
4535         equal:
4536
4537         DEBUG(10, ("nt_printer_param_equal(): printer params identical\n"));
4538         return True;
4539 }
4540
4541 /********************************************************************
4542  * Called by update_printer when trying to work out whether to
4543  * actually update printer info.
4544  ********************************************************************/
4545
4546 #define PI_CHECK_INT(field) \
4547     if (pi1->field != pi2->field) { \
4548         DEBUG(10, ("nt_printer_info_level_equal(): " #field " not equal (%d != %d)\n", \
4549             pi1->field, pi2->field)); \
4550         return False; \
4551     }
4552
4553 #define PI_CHECK_STR(field) \
4554     if (!strequal(pi1->field, pi2->field)) { \
4555         DEBUG(10, ("nt_printer_info_level_equal(): " #field " not equal (%s != %s)\n", \
4556             pi1->field, pi2->field)); \
4557         return False; \
4558     }
4559
4560 static BOOL nt_printer_info_level_equal(NT_PRINTER_INFO_LEVEL *p1,
4561                                         NT_PRINTER_INFO_LEVEL *p2)
4562 {
4563         NT_PRINTER_INFO_LEVEL_2 *pi1, *pi2;
4564
4565         /* Trivial conditions */
4566
4567         if ((!p1 && !p2) || (!p1->info_2 && !p2->info_2)) {
4568                 goto equal;
4569         }
4570
4571         if ((!p1 && p2) || (p1 && !p2) ||
4572             (!p1->info_2 && p2->info_2) ||
4573             (p1->info_2 && !p2->info_2)) {
4574                 DEBUG(10, ("nt_printer_info_level_equal(): info levels "
4575                            "differ\n"));
4576                 return False;
4577         }
4578
4579         /* Compare two nt_printer_info_level structures.  Don't compare
4580            status or cjobs as they seem to have something to do with the
4581            printer queue. */
4582
4583         pi1 = p1->info_2;
4584         pi2 = p2->info_2;
4585
4586         /* Don't check the attributes as we stomp on the value in
4587            check_printer_ok() anyway. */
4588
4589 #if 0
4590         PI_CHECK_INT(attributes);
4591 #endif
4592
4593         PI_CHECK_INT(priority);
4594         PI_CHECK_INT(default_priority);
4595         PI_CHECK_INT(starttime);
4596         PI_CHECK_INT(untiltime);
4597         PI_CHECK_INT(averageppm);
4598
4599         /* Yuck - don't check the printername or servername as the
4600            mod_a_printer() code plays games with them.  You can't
4601            change the printername or the sharename through this interface
4602            in Samba. */
4603
4604         PI_CHECK_STR(sharename);
4605         PI_CHECK_STR(portname);
4606         PI_CHECK_STR(drivername);
4607         PI_CHECK_STR(comment);
4608         PI_CHECK_STR(location);
4609
4610         if (!nt_devicemode_equal(pi1->devmode, pi2->devmode)) {
4611                 return False;
4612         }
4613
4614         PI_CHECK_STR(sepfile);
4615         PI_CHECK_STR(printprocessor);
4616         PI_CHECK_STR(datatype);
4617         PI_CHECK_STR(parameters);
4618
4619         if (!nt_printer_param_equal(pi1->specific, pi2->specific)) {
4620                 return False;
4621         }
4622
4623         if (!sec_desc_equal(pi1->secdesc_buf->sec, pi2->secdesc_buf->sec)) {
4624                 return False;
4625         }
4626
4627         PI_CHECK_INT(changeid);
4628         PI_CHECK_INT(c_setprinter);
4629         PI_CHECK_INT(setuptime);
4630
4631  equal:
4632         DEBUG(10, ("nt_printer_info_level_equal(): infos are identical\n"));
4633         return True;
4634 }
4635
4636 /********************************************************************
4637  * called by spoolss_api_setprinter
4638  * when updating a printer description
4639  ********************************************************************/
4640
4641 static WERROR update_printer(pipes_struct *p, POLICY_HND *handle, uint32 level,
4642                            const SPOOL_PRINTER_INFO_LEVEL *info,
4643                            DEVICEMODE *devmode)
4644 {
4645         int snum;
4646         NT_PRINTER_INFO_LEVEL *printer = NULL, *old_printer = NULL;
4647         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
4648         WERROR result;
4649
4650         DEBUG(8,("update_printer\n"));
4651
4652         result = WERR_OK;
4653
4654         if (level!=2) {
4655                 DEBUG(0,("Send a mail to samba@samba.org\n"));
4656                 DEBUGADD(0,("with the following message: update_printer: level!=2\n"));
4657                 result = WERR_UNKNOWN_LEVEL;
4658                 goto done;
4659         }
4660
4661         if (!Printer) {
4662                 result = WERR_BADFID;
4663                 goto done;
4664         }
4665
4666         if (!get_printer_snum(p, handle, &snum)) {
4667                 result = WERR_BADFID;
4668                 goto done;
4669         }
4670
4671         if (!W_ERROR_IS_OK(get_a_printer(&printer, 2, lp_servicename(snum))) ||
4672             (!W_ERROR_IS_OK(get_a_printer(&old_printer, 2, lp_servicename(snum))))) {
4673                 result = WERR_BADFID;
4674                 goto done;
4675         }
4676
4677         DEBUGADD(8,("Converting info_2 struct\n"));
4678
4679         /*
4680          * convert_printer_info converts the incoming
4681          * info from the client and overwrites the info
4682          * just read from the tdb in the pointer 'printer'.
4683          */
4684
4685         if (!convert_printer_info(info, printer, level)) {
4686                 result =  WERR_NOMEM;
4687                 goto done;
4688         }
4689
4690         if (info->info_2->devmode_ptr != 0) {
4691                 /* we have a valid devmode
4692                    convert it and link it*/
4693
4694                 DEBUGADD(8,("Converting the devicemode struct\n"));
4695                 if (!convert_devicemode(printer->info_2->printername, devmode,
4696                                 &printer->info_2->devmode)) {
4697                         result =  WERR_NOMEM;
4698                         goto done;
4699                 }
4700         }
4701
4702         /* Do sanity check on the requested changes for Samba */
4703
4704         if (!check_printer_ok(printer->info_2, snum)) {
4705                 result = WERR_INVALID_PARAM;
4706                 goto done;
4707         }
4708
4709         /* NT likes to call this function even though nothing has actually
4710            changed.  Check this so the user doesn't end up with an
4711            annoying permission denied dialog box. */
4712
4713         if (nt_printer_info_level_equal(printer, old_printer)) {
4714                 DEBUG(3, ("printer info has not changed\n"));
4715                 result = WERR_OK;
4716                 goto done;
4717         }
4718
4719         /* Check calling user has permission to update printer description */
4720
4721         if (!print_access_check(NULL, snum, PRINTER_ACCESS_ADMINISTER)) {
4722                 DEBUG(3, ("printer property change denied by security "
4723                           "descriptor\n"));
4724                 result = WERR_ACCESS_DENIED;
4725                 goto done;
4726         }
4727
4728         /* Call addprinter hook */
4729
4730         if (*lp_addprinter_cmd()) {
4731                 if (!add_printer_hook(printer)) {
4732                         result = WERR_ACCESS_DENIED;
4733                         goto done;
4734                 }
4735         }
4736
4737         /* Update printer info */
4738         result = mod_a_printer(*printer, 2);
4739
4740  done:
4741         free_a_printer(&printer, 2);
4742         free_a_printer(&old_printer, 2);
4743
4744         srv_spoolss_sendnotify(p, handle);
4745
4746         return result;
4747 }
4748
4749 /****************************************************************************
4750 ****************************************************************************/
4751
4752 WERROR _spoolss_setprinter(pipes_struct *p, SPOOL_Q_SETPRINTER *q_u, SPOOL_R_SETPRINTER *r_u)
4753 {
4754         POLICY_HND *handle = &q_u->handle;
4755         uint32 level = q_u->level;
4756         SPOOL_PRINTER_INFO_LEVEL *info = &q_u->info;
4757         DEVMODE_CTR devmode_ctr = q_u->devmode_ctr;
4758         SEC_DESC_BUF *secdesc_ctr = q_u->secdesc_ctr;
4759         uint32 command = q_u->command;
4760
4761         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
4762
4763         if (!Printer) {
4764                 DEBUG(0,("_spoolss_setprinter: Invalid handle (%s)\n", OUR_HANDLE(handle)));
4765                 return WERR_BADFID;
4766         }
4767
4768         /* check the level */
4769         switch (level) {
4770                 case 0:
4771                         return control_printer(handle, command, p);
4772                 case 2:
4773                         return update_printer(p, handle, level, info, devmode_ctr.devmode);
4774                 case 3:
4775                         return update_printer_sec(handle, level, info, p,
4776                                                   secdesc_ctr);
4777                 default:
4778                         return WERR_UNKNOWN_LEVEL;
4779         }
4780 }
4781
4782 /****************************************************************************
4783 ****************************************************************************/
4784
4785 WERROR _spoolss_fcpn(pipes_struct *p, SPOOL_Q_FCPN *q_u, SPOOL_R_FCPN *r_u)
4786 {
4787         POLICY_HND *handle = &q_u->handle;
4788
4789         Printer_entry *Printer= find_printer_index_by_hnd(p, handle);
4790
4791         if (!Printer) {
4792                 DEBUG(0,("_spoolss_fcpn: Invalid handle (%s)\n", OUR_HANDLE(handle)));
4793                 return WERR_BADFID;
4794         }
4795
4796         if (Printer->notify.client_connected==True)
4797                 srv_spoolss_replycloseprinter(&Printer->notify.client_hnd);
4798
4799         Printer->notify.flags=0;
4800         Printer->notify.options=0;
4801         Printer->notify.localmachine[0]='\0';
4802         Printer->notify.printerlocal=0;
4803         if (Printer->notify.option)
4804                 free_spool_notify_option(&Printer->notify.option);
4805         Printer->notify.client_connected=False;
4806
4807         return WERR_OK;
4808 }
4809
4810 /****************************************************************************
4811 ****************************************************************************/
4812
4813 WERROR _spoolss_addjob(pipes_struct *p, SPOOL_Q_ADDJOB *q_u, SPOOL_R_ADDJOB *r_u)
4814 {
4815         /* that's an [in out] buffer (despite appearences to the contrary) */
4816         spoolss_move_buffer(q_u->buffer, &r_u->buffer);
4817
4818         r_u->needed = 0;
4819         return WERR_INVALID_PARAM; /* this is what a NT server
4820                                            returns for AddJob. AddJob
4821                                            must fail on non-local
4822                                            printers */
4823 }
4824
4825 /****************************************************************************
4826 ****************************************************************************/
4827 static void fill_job_info_1(JOB_INFO_1 *job_info, print_queue_struct *queue,
4828                             int position, int snum)
4829 {
4830         pstring temp_name;
4831
4832         struct tm *t;
4833
4834         t=gmtime(&queue->time);
4835         slprintf(temp_name, sizeof(temp_name)-1, "\\\\%s", get_called_name());
4836
4837         job_info->jobid=queue->job;
4838         init_unistr(&job_info->printername, lp_servicename(snum));
4839         init_unistr(&job_info->machinename, temp_name);
4840         init_unistr(&job_info->username, queue->user);
4841         init_unistr(&job_info->document, queue->file);
4842         init_unistr(&job_info->datatype, "RAW");
4843         init_unistr(&job_info->text_status, "");
4844         job_info->status=nt_printj_status(queue->status);
4845         job_info->priority=queue->priority;
4846         job_info->position=position;
4847         job_info->totalpages=0;
4848         job_info->pagesprinted=0;
4849
4850         make_systemtime(&job_info->submitted, t);
4851 }
4852
4853 /****************************************************************************
4854 ****************************************************************************/
4855 static BOOL fill_job_info_2(JOB_INFO_2 *job_info, print_queue_struct *queue,
4856                             int position, int snum,
4857                             NT_PRINTER_INFO_LEVEL *ntprinter)
4858 {
4859         pstring temp_name;
4860         pstring chaine;
4861         struct tm *t;
4862
4863         t=gmtime(&queue->time);
4864         slprintf(temp_name, sizeof(temp_name)-1, "\\\\%s", get_called_name());
4865
4866         job_info->jobid=queue->job;
4867
4868         slprintf(chaine, sizeof(chaine)-1, "\\\\%s\\%s", get_called_name(), ntprinter->info_2->printername);
4869
4870         init_unistr(&job_info->printername, chaine);
4871
4872         init_unistr(&job_info->machinename, temp_name);
4873         init_unistr(&job_info->username, queue->user);
4874         init_unistr(&job_info->document, queue->file);
4875         init_unistr(&job_info->notifyname, queue->user);
4876         init_unistr(&job_info->datatype, "RAW");
4877         init_unistr(&job_info->printprocessor, "winprint");
4878         init_unistr(&job_info->parameters, "");
4879         init_unistr(&job_info->drivername, ntprinter->info_2->drivername);
4880         init_unistr(&job_info->text_status, "");
4881
4882 /* and here the security descriptor */
4883
4884         job_info->status=nt_printj_status(queue->status);
4885         job_info->priority=queue->priority;
4886         job_info->position=position;
4887         job_info->starttime=0;
4888         job_info->untiltime=0;
4889         job_info->totalpages=0;
4890         job_info->size=queue->size;
4891         make_systemtime(&(job_info->submitted), t);
4892         job_info->timeelapsed=0;
4893         job_info->pagesprinted=0;
4894
4895         if((job_info->devmode = construct_dev_mode(snum)) == NULL) {
4896                 return False;
4897         }
4898
4899         return (True);
4900 }
4901
4902 /****************************************************************************
4903  Enumjobs at level 1.
4904 ****************************************************************************/
4905 static WERROR enumjobs_level1(print_queue_struct *queue, int snum,
4906                               NEW_BUFFER *buffer, uint32 offered,
4907                               uint32 *needed, uint32 *returned)
4908 {
4909         JOB_INFO_1 *info;
4910         int i;
4911
4912         info=(JOB_INFO_1 *)malloc(*returned*sizeof(JOB_INFO_1));
4913         if (info==NULL) {
4914                 SAFE_FREE(queue);
4915                 *returned=0;
4916                 return WERR_NOMEM;
4917         }
4918
4919         for (i=0; i<*returned; i++)
4920                 fill_job_info_1(&info[i], &queue[i], i, snum);
4921
4922         SAFE_FREE(queue);
4923
4924         /* check the required size. */
4925         for (i=0; i<*returned; i++)
4926                 (*needed) += spoolss_size_job_info_1(&info[i]);
4927
4928         if (!alloc_buffer_size(buffer, *needed)) {
4929                 SAFE_FREE(info);
4930                 return WERR_INSUFFICIENT_BUFFER;
4931         }
4932
4933         /* fill the buffer with the structures */
4934         for (i=0; i<*returned; i++)
4935                 smb_io_job_info_1("", buffer, &info[i], 0);
4936
4937         /* clear memory */
4938         SAFE_FREE(info);
4939
4940         if (*needed > offered) {
4941                 *returned=0;
4942                 return WERR_INSUFFICIENT_BUFFER;
4943         }
4944
4945         return WERR_OK;
4946 }
4947
4948 /****************************************************************************
4949  Enumjobs at level 2.
4950 ****************************************************************************/
4951 static WERROR enumjobs_level2(print_queue_struct *queue, int snum,
4952                               NEW_BUFFER *buffer, uint32 offered,
4953                               uint32 *needed, uint32 *returned)
4954 {
4955         NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
4956         JOB_INFO_2 *info;
4957         int i;
4958         WERROR result;
4959
4960         info=(JOB_INFO_2 *)malloc(*returned*sizeof(JOB_INFO_2));
4961         if (info==NULL) {
4962                 *returned=0;
4963                 return WERR_NOMEM;
4964         }
4965
4966         result = get_a_printer(&ntprinter, 2, lp_servicename(snum));
4967         if (!W_ERROR_IS_OK(result)) {
4968                 *returned = 0;
4969                 return result;
4970         }
4971
4972         for (i=0; i<*returned; i++)
4973                 fill_job_info_2(&(info[i]), &queue[i], i, snum, ntprinter);
4974
4975         free_a_printer(&ntprinter, 2);
4976         SAFE_FREE(queue);
4977
4978         /* check the required size. */
4979         for (i=0; i<*returned; i++)
4980                 (*needed) += spoolss_size_job_info_2(&info[i]);
4981
4982         if (!alloc_buffer_size(buffer, *needed)) {
4983                 SAFE_FREE(info);
4984                 return WERR_INSUFFICIENT_BUFFER;
4985         }
4986
4987         /* fill the buffer with the structures */
4988         for (i=0; i<*returned; i++)
4989                 smb_io_job_info_2("", buffer, &info[i], 0);
4990
4991         /* clear memory */
4992         for (i = 0; i < *returned; i++)
4993                 free_job_info_2(&info[i]);
4994
4995         SAFE_FREE(info);
4996
4997         if (*needed > offered) {
4998                 *returned=0;
4999                 return WERR_INSUFFICIENT_BUFFER;
5000         }
5001
5002         return WERR_OK;
5003 }
5004
5005 /****************************************************************************
5006  Enumjobs.
5007 ****************************************************************************/
5008
5009 WERROR _spoolss_enumjobs( pipes_struct *p, SPOOL_Q_ENUMJOBS *q_u, SPOOL_R_ENUMJOBS *r_u)
5010 {
5011         POLICY_HND *handle = &q_u->handle;
5012 /*      uint32 firstjob = q_u->firstjob; - notused. */
5013 /*      uint32 numofjobs = q_u->numofjobs; - notused. */
5014         uint32 level = q_u->level;
5015         NEW_BUFFER *buffer = NULL;
5016         uint32 offered = q_u->offered;
5017         uint32 *needed = &r_u->needed;
5018         uint32 *returned = &r_u->returned;
5019
5020         int snum;
5021         print_status_struct prt_status;
5022         print_queue_struct *queue=NULL;
5023
5024         /* that's an [in out] buffer */
5025         spoolss_move_buffer(q_u->buffer, &r_u->buffer);
5026         buffer = r_u->buffer;
5027
5028         DEBUG(4,("_spoolss_enumjobs\n"));
5029
5030         *needed=0;
5031         *returned=0;
5032
5033         if (!get_printer_snum(p, handle, &snum))
5034                 return WERR_BADFID;
5035
5036         *returned = print_queue_status(snum, &queue, &prt_status);
5037         DEBUGADD(4,("count:[%d], status:[%d], [%s]\n", *returned, prt_status.status, prt_status.message));
5038
5039         if (*returned == 0) {
5040                 SAFE_FREE(queue);
5041                 return WERR_OK;
5042         }
5043
5044         switch (level) {
5045         case 1:
5046                 return enumjobs_level1(queue, snum, buffer, offered, needed, returned);
5047         case 2:
5048                 return enumjobs_level2(queue, snum, buffer, offered, needed, returned);
5049         default:
5050                 SAFE_FREE(queue);
5051                 *returned=0;
5052                 return WERR_UNKNOWN_LEVEL;
5053         }
5054 }
5055
5056 /****************************************************************************
5057 ****************************************************************************/
5058
5059 WERROR _spoolss_schedulejob( pipes_struct *p, SPOOL_Q_SCHEDULEJOB *q_u, SPOOL_R_SCHEDULEJOB *r_u)
5060 {
5061         return WERR_OK;
5062 }
5063
5064 /****************************************************************************
5065 ****************************************************************************/
5066
5067 WERROR _spoolss_setjob(pipes_struct *p, SPOOL_Q_SETJOB *q_u, SPOOL_R_SETJOB *r_u)
5068 {
5069         POLICY_HND *handle = &q_u->handle;
5070         uint32 jobid = q_u->jobid;
5071 /*      uint32 level = q_u->level; - notused. */
5072 /*      JOB_INFO *ctr = &q_u->ctr; - notused. */
5073         uint32 command = q_u->command;
5074
5075         struct current_user user;
5076         int snum;
5077         WERROR errcode = WERR_BADFUNC;
5078
5079         if (!get_printer_snum(p, handle, &snum)) {
5080                 return WERR_BADFID;
5081         }
5082
5083         if (!print_job_exists(jobid)) {
5084                 return WERR_INVALID_PRINTER_NAME;
5085         }
5086
5087         get_current_user(&user, p);
5088
5089         switch (command) {
5090         case JOB_CONTROL_CANCEL:
5091         case JOB_CONTROL_DELETE:
5092                 if (print_job_delete(&user, jobid, &errcode)) {
5093                         errcode = WERR_OK;
5094                 }
5095                 break;
5096         case JOB_CONTROL_PAUSE:
5097                 if (print_job_pause(&user, jobid, &errcode)) {
5098                         errcode = WERR_OK;
5099                 }
5100                 break;
5101         case JOB_CONTROL_RESTART:
5102         case JOB_CONTROL_RESUME:
5103                 if (print_job_resume(&user, jobid, &errcode)) {
5104                         errcode = WERR_OK;
5105                 }
5106                 break;
5107         default:
5108                 return WERR_UNKNOWN_LEVEL;
5109         }
5110
5111         return errcode;
5112 }
5113
5114 /****************************************************************************
5115  Enumerates all printer drivers at level 1.
5116 ****************************************************************************/
5117 static WERROR enumprinterdrivers_level1(fstring servername, fstring architecture, NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
5118 {
5119         int i;
5120         int ndrivers;
5121         uint32 version;
5122         fstring *list = NULL;
5123
5124         NT_PRINTER_DRIVER_INFO_LEVEL driver;
5125         DRIVER_INFO_1 *tdi1, *driver_info_1=NULL;
5126
5127         *returned=0;
5128
5129 #define MAX_VERSION 4
5130
5131         for (version=0; version<MAX_VERSION; version++) {
5132                 list=NULL;
5133                 ndrivers=get_ntdrivers(&list, architecture, version);
5134                 DEBUGADD(4,("we have:[%d] drivers in environment [%s] and version [%d]\n", ndrivers, architecture, version));
5135
5136                 if(ndrivers == -1)
5137                         return WERR_NOMEM;
5138
5139                 if(ndrivers != 0) {
5140                         if((tdi1=(DRIVER_INFO_1 *)Realloc(driver_info_1, (*returned+ndrivers) * sizeof(DRIVER_INFO_1))) == NULL) {
5141                                 DEBUG(0,("enumprinterdrivers_level1: failed to enlarge driver info buffer!\n"));
5142                                 SAFE_FREE(driver_info_1);
5143                                 SAFE_FREE(list);
5144                                 return WERR_NOMEM;
5145                         }
5146                         else driver_info_1 = tdi1;
5147                 }
5148
5149                 for (i=0; i<ndrivers; i++) {
5150                         WERROR status;
5151                         DEBUGADD(5,("\tdriver: [%s]\n", list[i]));
5152                         ZERO_STRUCT(driver);
5153                         status = get_a_printer_driver(&driver, 3, list[i],
5154                                                       architecture, version);
5155                         if (!W_ERROR_IS_OK(status)) {
5156                                 SAFE_FREE(list);
5157                                 return status;
5158                         }
5159                         fill_printer_driver_info_1(&driver_info_1[*returned+i], driver, servername, architecture );
5160                         free_a_printer_driver(driver, 3);
5161                 }
5162
5163                 *returned+=ndrivers;
5164                 SAFE_FREE(list);
5165         }
5166
5167         /* check the required size. */
5168         for (i=0; i<*returned; i++) {
5169                 DEBUGADD(6,("adding driver [%d]'s size\n",i));
5170                 *needed += spoolss_size_printer_driver_info_1(&driver_info_1[i]);
5171         }
5172
5173         if (!alloc_buffer_size(buffer, *needed)) {
5174                 SAFE_FREE(driver_info_1);
5175                 return WERR_INSUFFICIENT_BUFFER;
5176         }
5177
5178         /* fill the buffer with the driver structures */
5179         for (i=0; i<*returned; i++) {
5180                 DEBUGADD(6,("adding driver [%d] to buffer\n",i));
5181                 smb_io_printer_driver_info_1("", buffer, &driver_info_1[i], 0);
5182         }
5183
5184         SAFE_FREE(driver_info_1);
5185
5186         if (*needed > offered) {
5187                 *returned=0;
5188                 return WERR_INSUFFICIENT_BUFFER;
5189         }
5190
5191         return WERR_OK;
5192 }
5193
5194 /****************************************************************************
5195  Enumerates all printer drivers at level 2.
5196 ****************************************************************************/
5197 static WERROR enumprinterdrivers_level2(fstring servername, fstring architecture, NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
5198 {
5199         int i;
5200         int ndrivers;
5201         uint32 version;
5202         fstring *list = NULL;
5203
5204         NT_PRINTER_DRIVER_INFO_LEVEL driver;
5205         DRIVER_INFO_2 *tdi2, *driver_info_2=NULL;
5206
5207         *returned=0;
5208
5209 #define MAX_VERSION 4
5210
5211         for (version=0; version<MAX_VERSION; version++) {
5212                 list=NULL;
5213                 ndrivers=get_ntdrivers(&list, architecture, version);
5214                 DEBUGADD(4,("we have:[%d] drivers in environment [%s] and version [%d]\n", ndrivers, architecture, version));
5215
5216                 if(ndrivers == -1)
5217                         return WERR_NOMEM;
5218
5219                 if(ndrivers != 0) {
5220                         if((tdi2=(DRIVER_INFO_2 *)Realloc(driver_info_2, (*returned+ndrivers) * sizeof(DRIVER_INFO_2))) == NULL) {
5221                                 DEBUG(0,("enumprinterdrivers_level2: failed to enlarge driver info buffer!\n"));
5222                                 SAFE_FREE(driver_info_2);
5223                                 SAFE_FREE(list);
5224                                 return WERR_NOMEM;
5225                         }
5226                         else driver_info_2 = tdi2;
5227                 }
5228
5229                 for (i=0; i<ndrivers; i++) {
5230                         WERROR status;
5231
5232                         DEBUGADD(5,("\tdriver: [%s]\n", list[i]));
5233                         ZERO_STRUCT(driver);
5234                         status = get_a_printer_driver(&driver, 3, list[i],
5235                                                       architecture, version);
5236                         if (!W_ERROR_IS_OK(status)) {
5237                                 SAFE_FREE(list);
5238                                 return status;
5239                         }
5240                         fill_printer_driver_info_2(&driver_info_2[*returned+i], driver, servername);
5241                         free_a_printer_driver(driver, 3);
5242                 }
5243
5244                 *returned+=ndrivers;
5245                 SAFE_FREE(list);
5246         }
5247
5248         /* check the required size. */
5249         for (i=0; i<*returned; i++) {
5250                 DEBUGADD(6,("adding driver [%d]'s size\n",i));
5251                 *needed += spoolss_size_printer_driver_info_2(&(driver_info_2[i]));
5252         }
5253
5254         if (!alloc_buffer_size(buffer, *needed)) {
5255                 SAFE_FREE(driver_info_2);
5256                 return WERR_INSUFFICIENT_BUFFER;
5257         }
5258
5259         /* fill the buffer with the form structures */
5260         for (i=0; i<*returned; i++) {
5261                 DEBUGADD(6,("adding driver [%d] to buffer\n",i));
5262                 smb_io_printer_driver_info_2("", buffer, &(driver_info_2[i]), 0);
5263         }
5264
5265         SAFE_FREE(driver_info_2);
5266
5267         if (*needed > offered) {
5268                 *returned=0;
5269                 return WERR_INSUFFICIENT_BUFFER;
5270         }
5271
5272         return WERR_OK;
5273 }
5274
5275 /****************************************************************************
5276  Enumerates all printer drivers at level 3.
5277 ****************************************************************************/
5278 static WERROR enumprinterdrivers_level3(fstring servername, fstring architecture, NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
5279 {
5280         int i;
5281         int ndrivers;
5282         uint32 version;
5283         fstring *list = NULL;
5284
5285         NT_PRINTER_DRIVER_INFO_LEVEL driver;
5286         DRIVER_INFO_3 *tdi3, *driver_info_3=NULL;
5287
5288         *returned=0;
5289
5290 #define MAX_VERSION 4
5291
5292         for (version=0; version<MAX_VERSION; version++) {
5293                 list=NULL;
5294                 ndrivers=get_ntdrivers(&list, architecture, version);
5295                 DEBUGADD(4,("we have:[%d] drivers in environment [%s] and version [%d]\n", ndrivers, architecture, version));
5296
5297                 if(ndrivers == -1)
5298                         return WERR_NOMEM;
5299
5300                 if(ndrivers != 0) {
5301                         if((tdi3=(DRIVER_INFO_3 *)Realloc(driver_info_3, (*returned+ndrivers) * sizeof(DRIVER_INFO_3))) == NULL) {
5302                                 DEBUG(0,("enumprinterdrivers_level3: failed to enlarge driver info buffer!\n"));
5303                                 SAFE_FREE(driver_info_3);
5304                                 SAFE_FREE(list);
5305                                 return WERR_NOMEM;
5306                         }
5307                         else driver_info_3 = tdi3;
5308                 }
5309
5310                 for (i=0; i<ndrivers; i++) {
5311                         WERROR status;
5312
5313                         DEBUGADD(5,("\tdriver: [%s]\n", list[i]));
5314                         ZERO_STRUCT(driver);
5315                         status = get_a_printer_driver(&driver, 3, list[i],
5316                                                       architecture, version);
5317                         if (!W_ERROR_IS_OK(status)) {
5318                                 SAFE_FREE(list);
5319                                 return status;
5320                         }
5321                         fill_printer_driver_info_3(&driver_info_3[*returned+i], driver, servername);
5322                         free_a_printer_driver(driver, 3);
5323                 }
5324
5325                 *returned+=ndrivers;
5326                 SAFE_FREE(list);
5327         }
5328
5329         /* check the required size. */
5330         for (i=0; i<*returned; i++) {
5331                 DEBUGADD(6,("adding driver [%d]'s size\n",i));
5332                 *needed += spoolss_size_printer_driver_info_3(&driver_info_3[i]);
5333         }
5334
5335         if (!alloc_buffer_size(buffer, *needed)) {
5336                 SAFE_FREE(driver_info_3);
5337                 return WERR_INSUFFICIENT_BUFFER;
5338         }
5339
5340         /* fill the buffer with the driver structures */
5341         for (i=0; i<*returned; i++) {
5342                 DEBUGADD(6,("adding driver [%d] to buffer\n",i));
5343                 smb_io_printer_driver_info_3("", buffer, &driver_info_3[i], 0);
5344         }
5345
5346         for (i=0; i<*returned; i++)
5347                 SAFE_FREE(driver_info_3[i].dependentfiles);
5348
5349         SAFE_FREE(driver_info_3);
5350
5351         if (*needed > offered) {
5352                 *returned=0;
5353                 return WERR_INSUFFICIENT_BUFFER;
5354         }
5355
5356         return WERR_OK;
5357 }
5358
5359 /****************************************************************************
5360  Enumerates all printer drivers.
5361 ****************************************************************************/
5362
5363 WERROR _spoolss_enumprinterdrivers( pipes_struct *p, SPOOL_Q_ENUMPRINTERDRIVERS *q_u, SPOOL_R_ENUMPRINTERDRIVERS *r_u)
5364 {
5365 /*      UNISTR2 *name = &q_u->name; - notused. */
5366         UNISTR2 *environment = &q_u->environment;
5367         uint32 level = q_u->level;
5368         NEW_BUFFER *buffer = NULL;
5369         uint32 offered = q_u->offered;
5370         uint32 *needed = &r_u->needed;
5371         uint32 *returned = &r_u->returned;
5372
5373         fstring *list = NULL;
5374         fstring servername;
5375         fstring architecture;
5376
5377         /* that's an [in out] buffer */
5378         spoolss_move_buffer(q_u->buffer, &r_u->buffer);
5379         buffer = r_u->buffer;
5380
5381         DEBUG(4,("_spoolss_enumprinterdrivers\n"));
5382         fstrcpy(servername, get_called_name());
5383         *needed=0;
5384         *returned=0;
5385
5386         unistr2_to_ascii(architecture, environment, sizeof(architecture)-1);
5387
5388         switch (level) {
5389         case 1:
5390                 return enumprinterdrivers_level1(servername, architecture, buffer, offered, needed, returned);
5391         case 2:
5392                 return enumprinterdrivers_level2(servername, architecture, buffer, offered, needed, returned);
5393         case 3:
5394                 return enumprinterdrivers_level3(servername, architecture, buffer, offered, needed, returned);
5395         default:
5396                 *returned=0;
5397                 SAFE_FREE(list);
5398                 return WERR_UNKNOWN_LEVEL;
5399         }
5400 }
5401
5402 /****************************************************************************
5403 ****************************************************************************/
5404
5405 static void fill_form_1(FORM_1 *form, nt_forms_struct *list)
5406 {
5407         form->flag=list->flag;
5408         init_unistr(&form->name, list->name);
5409         form->width=list->width;
5410         form->length=list->length;
5411         form->left=list->left;
5412         form->top=list->top;
5413         form->right=list->right;
5414         form->bottom=list->bottom;
5415 }
5416
5417 /****************************************************************************
5418 ****************************************************************************/
5419
5420 WERROR _spoolss_enumforms(pipes_struct *p, SPOOL_Q_ENUMFORMS *q_u, SPOOL_R_ENUMFORMS *r_u)
5421 {
5422 /*      POLICY_HND *handle = &q_u->handle; - notused. */
5423         uint32 level = q_u->level;
5424         NEW_BUFFER *buffer = NULL;
5425         uint32 offered = q_u->offered;
5426         uint32 *needed = &r_u->needed;
5427         uint32 *numofforms = &r_u->numofforms;
5428         uint32 numbuiltinforms;
5429
5430         nt_forms_struct *list=NULL;
5431         nt_forms_struct *builtinlist=NULL;
5432         FORM_1 *forms_1;
5433         int buffer_size=0;
5434         int i;
5435
5436         /* that's an [in out] buffer */
5437         spoolss_move_buffer(q_u->buffer, &r_u->buffer);
5438         buffer = r_u->buffer;
5439
5440         DEBUG(4,("_spoolss_enumforms\n"));
5441         DEBUGADD(5,("Offered buffer size [%d]\n", offered));
5442         DEBUGADD(5,("Info level [%d]\n",          level));
5443
5444         numbuiltinforms = get_builtin_ntforms(&builtinlist);
5445         DEBUGADD(5,("Number of builtin forms [%d]\n",     numbuiltinforms));
5446         *numofforms = get_ntforms(&list);
5447         DEBUGADD(5,("Number of user forms [%d]\n",     *numofforms));
5448         *numofforms += numbuiltinforms;
5449
5450         if (*numofforms == 0) return WERR_NO_MORE_ITEMS;
5451
5452         switch (level) {
5453         case 1:
5454                 if ((forms_1=(FORM_1 *)malloc(*numofforms * sizeof(FORM_1))) == NULL) {
5455                         *numofforms=0;
5456                         return WERR_NOMEM;
5457                 }
5458
5459                 /* construct the list of form structures */
5460                 for (i=0; i<numbuiltinforms; i++) {
5461                         DEBUGADD(6,("Filling form number [%d]\n",i));
5462                         fill_form_1(&forms_1[i], &builtinlist[i]);
5463                 }
5464
5465                 SAFE_FREE(builtinlist);
5466
5467                 for (; i<*numofforms; i++) {
5468                         DEBUGADD(6,("Filling form number [%d]\n",i));
5469                         fill_form_1(&forms_1[i], &list[i-numbuiltinforms]);
5470                 }
5471
5472                 SAFE_FREE(list);
5473
5474                 /* check the required size. */
5475                 for (i=0; i<numbuiltinforms; i++) {
5476                         DEBUGADD(6,("adding form [%d]'s size\n",i));
5477                         buffer_size += spoolss_size_form_1(&forms_1[i]);
5478                 }
5479                 for (; i<*numofforms; i++) {
5480                         DEBUGADD(6,("adding form [%d]'s size\n",i));
5481                         buffer_size += spoolss_size_form_1(&forms_1[i]);
5482                 }
5483
5484                 *needed=buffer_size;
5485
5486                 if (!alloc_buffer_size(buffer, buffer_size)){
5487                         SAFE_FREE(forms_1);
5488                         return WERR_INSUFFICIENT_BUFFER;
5489                 }
5490
5491                 /* fill the buffer with the form structures */
5492                 for (i=0; i<numbuiltinforms; i++) {
5493                         DEBUGADD(6,("adding form [%d] to buffer\n",i));
5494                         smb_io_form_1("", buffer, &forms_1[i], 0);
5495                 }
5496                 for (; i<*numofforms; i++) {
5497                         DEBUGADD(6,("adding form [%d] to buffer\n",i));
5498                         smb_io_form_1("", buffer, &forms_1[i], 0);
5499                 }
5500
5501                 SAFE_FREE(forms_1);
5502
5503                 if (*needed > offered) {
5504                         *numofforms=0;
5505                         return WERR_INSUFFICIENT_BUFFER;
5506                 }
5507                 else
5508                         return WERR_OK;
5509
5510         default:
5511                 SAFE_FREE(list);
5512                 SAFE_FREE(builtinlist);
5513                 return WERR_UNKNOWN_LEVEL;
5514         }
5515
5516 }
5517
5518 /****************************************************************************
5519 ****************************************************************************/
5520
5521 WERROR _spoolss_getform(pipes_struct *p, SPOOL_Q_GETFORM *q_u, SPOOL_R_GETFORM *r_u)
5522 {
5523 /*      POLICY_HND *handle = &q_u->handle; - notused. */
5524         uint32 level = q_u->level;
5525         UNISTR2 *uni_formname = &q_u->formname;
5526         NEW_BUFFER *buffer = NULL;
5527         uint32 offered = q_u->offered;
5528         uint32 *needed = &r_u->needed;
5529
5530         nt_forms_struct *list=NULL;
5531         nt_forms_struct builtin_form;
5532         BOOL foundBuiltin;
5533         FORM_1 form_1;
5534         fstring form_name;
5535         int buffer_size=0;
5536         int numofforms=0, i=0;
5537
5538         /* that's an [in out] buffer */
5539         spoolss_move_buffer(q_u->buffer, &r_u->buffer);
5540         buffer = r_u->buffer;
5541
5542         unistr2_to_ascii(form_name, uni_formname, sizeof(form_name)-1);
5543
5544         DEBUG(4,("_spoolss_getform\n"));
5545         DEBUGADD(5,("Offered buffer size [%d]\n", offered));
5546         DEBUGADD(5,("Info level [%d]\n",          level));
5547
5548         foundBuiltin = get_a_builtin_ntform(uni_formname,&builtin_form);
5549         if (!foundBuiltin) {
5550                 numofforms = get_ntforms(&list);
5551                 DEBUGADD(5,("Number of forms [%d]\n",     numofforms));
5552
5553                 if (numofforms == 0)
5554                         return WERR_BADFID;
5555         }
5556
5557         switch (level) {
5558         case 1:
5559                 if (foundBuiltin) {
5560                         fill_form_1(&form_1, &builtin_form);
5561                 } else {
5562
5563                         /* Check if the requested name is in the list of form structures */
5564                         for (i=0; i<numofforms; i++) {
5565
5566                                 DEBUG(4,("_spoolss_getform: checking form %s (want %s)\n", list[i].name, form_name));
5567
5568                                 if (strequal(form_name, list[i].name)) {
5569                                         DEBUGADD(6,("Found form %s number [%d]\n", form_name, i));
5570                                         fill_form_1(&form_1, &list[i]);
5571                                         break;
5572                                 }
5573                         }
5574
5575                         SAFE_FREE(list);
5576                         if (i == numofforms) {
5577                                 return WERR_BADFID;
5578                         }
5579                 }
5580                 /* check the required size. */
5581
5582                 *needed=spoolss_size_form_1(&form_1);
5583
5584                 if (!alloc_buffer_size(buffer, buffer_size)){
5585                         return WERR_INSUFFICIENT_BUFFER;
5586                 }
5587
5588                 if (*needed > offered) {
5589                         return WERR_INSUFFICIENT_BUFFER;
5590                 }
5591
5592                 /* fill the buffer with the form structures */
5593                 DEBUGADD(6,("adding form %s [%d] to buffer\n", form_name, i));
5594                 smb_io_form_1("", buffer, &form_1, 0);
5595
5596                 return WERR_OK;
5597
5598         default:
5599                 SAFE_FREE(list);
5600                 return WERR_UNKNOWN_LEVEL;
5601         }
5602 }
5603
5604 /****************************************************************************
5605 ****************************************************************************/
5606 static void fill_port_1(PORT_INFO_1 *port, char *name)
5607 {
5608         init_unistr(&port->port_name, name);
5609 }
5610
5611 /****************************************************************************
5612 ****************************************************************************/
5613 static void fill_port_2(PORT_INFO_2 *port, char *name)
5614 {
5615         init_unistr(&port->port_name, name);
5616         init_unistr(&port->monitor_name, "Local Monitor");
5617         init_unistr(&port->description, "Local Port");
5618 #define PORT_TYPE_WRITE 1
5619         port->port_type=PORT_TYPE_WRITE;
5620         port->reserved=0x0;
5621 }
5622
5623 /****************************************************************************
5624  enumports level 1.
5625 ****************************************************************************/
5626 static WERROR enumports_level_1(NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
5627 {
5628         PORT_INFO_1 *ports=NULL;
5629         int i=0;
5630
5631         if (*lp_enumports_cmd()) {
5632                 char *cmd = lp_enumports_cmd();
5633                 char **qlines;
5634                 pstring command;
5635                 int numlines;
5636                 int ret;
5637                 int fd;
5638
5639                 slprintf(command, sizeof(command)-1, "%s \"%d\"", cmd, 1);
5640
5641                 DEBUG(10,("Running [%s]\n", command));
5642                 ret = smbrun(command, &fd);
5643                 DEBUG(10,("Returned [%d]\n", ret));
5644                 if (ret != 0) {
5645                         if (fd != -1)
5646                                 close(fd);
5647                         /* Is this the best error to return here? */
5648                         return WERR_ACCESS_DENIED;
5649                 }
5650
5651                 numlines = 0;
5652                 qlines = fd_lines_load(fd, &numlines);
5653                 DEBUGADD(10,("Lines returned = [%d]\n", numlines));
5654                 close(fd);
5655
5656                 if(numlines) {
5657                         if((ports=(PORT_INFO_1 *)malloc( numlines * sizeof(PORT_INFO_1) )) == NULL) {
5658                                 DEBUG(10,("Returning WERR_NOMEM [%s]\n",
5659                                           werror_str(WERR_NOMEM)));
5660                                 file_lines_free(qlines);
5661                                 return WERR_NOMEM;
5662                         }
5663
5664                         for (i=0; i<numlines; i++) {
5665                                 DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
5666                                 fill_port_1(&ports[i], qlines[i]);
5667                         }
5668
5669                         file_lines_free(qlines);
5670                 }
5671
5672                 *returned = numlines;
5673
5674         } else {
5675                 *returned = 1; /* Sole Samba port returned. */
5676
5677                 if((ports=(PORT_INFO_1 *)malloc( sizeof(PORT_INFO_1) )) == NULL)
5678                         return WERR_NOMEM;
5679
5680                 DEBUG(10,("enumports_level_1: port name %s\n", SAMBA_PRINTER_PORT_NAME));
5681
5682                 fill_port_1(&ports[0], SAMBA_PRINTER_PORT_NAME);
5683         }
5684
5685         /* check the required size. */
5686         for (i=0; i<*returned; i++) {
5687                 DEBUGADD(6,("adding port [%d]'s size\n", i));
5688                 *needed += spoolss_size_port_info_1(&ports[i]);
5689         }
5690
5691         if (!alloc_buffer_size(buffer, *needed)) {
5692                 SAFE_FREE(ports);
5693                 return WERR_INSUFFICIENT_BUFFER;
5694         }
5695
5696         /* fill the buffer with the ports structures */
5697         for (i=0; i<*returned; i++) {
5698                 DEBUGADD(6,("adding port [%d] to buffer\n", i));
5699                 smb_io_port_1("", buffer, &ports[i], 0);
5700         }
5701
5702         SAFE_FREE(ports);
5703
5704         if (*needed > offered) {
5705                 *returned=0;
5706                 return WERR_INSUFFICIENT_BUFFER;
5707         }
5708
5709         return WERR_OK;
5710 }
5711
5712 /****************************************************************************
5713  enumports level 2.
5714 ****************************************************************************/
5715
5716 static WERROR enumports_level_2(NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
5717 {
5718         PORT_INFO_2 *ports=NULL;
5719         int i=0;
5720
5721         if (*lp_enumports_cmd()) {
5722                 char *cmd = lp_enumports_cmd();
5723                 char *path;
5724                 char **qlines;
5725                 pstring tmp_file;
5726                 pstring command;
5727                 int numlines;
5728                 int ret;
5729                 int fd;
5730
5731                 if (*lp_pathname(lp_servicenumber(PRINTERS_NAME)))
5732                         path = lp_pathname(lp_servicenumber(PRINTERS_NAME));
5733                 else
5734                         path = lp_lockdir();
5735
5736                 slprintf(tmp_file, sizeof(tmp_file)-1, "%s/smbcmd.%u.", path, (unsigned int)sys_getpid());
5737                 slprintf(command, sizeof(command)-1, "%s \"%d\"", cmd, 2);
5738
5739                 unlink(tmp_file);
5740                 DEBUG(10,("Running [%s > %s]\n", command,tmp_file));
5741                 ret = smbrun(command, &fd);
5742                 DEBUGADD(10,("returned [%d]\n", ret));
5743                 if (ret != 0) {
5744                         if (fd != -1)
5745                                 close(fd);
5746                         /* Is this the best error to return here? */
5747                         return WERR_ACCESS_DENIED;
5748                 }
5749
5750                 numlines = 0;
5751                 qlines = fd_lines_load(fd, &numlines);
5752                 DEBUGADD(10,("Lines returned = [%d]\n", numlines));
5753                 close(fd);
5754
5755                 if(numlines) {
5756                         if((ports=(PORT_INFO_2 *)malloc( numlines * sizeof(PORT_INFO_2) )) == NULL) {
5757                                 file_lines_free(qlines);
5758                                 return WERR_NOMEM;
5759                         }
5760
5761                         for (i=0; i<numlines; i++) {
5762                                 DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
5763                                 fill_port_2(&(ports[i]), qlines[i]);
5764                         }
5765
5766                         file_lines_free(qlines);
5767                 }
5768
5769                 *returned = numlines;
5770
5771         } else {
5772
5773                 *returned = 1;
5774
5775                 if((ports=(PORT_INFO_2 *)malloc( sizeof(PORT_INFO_2) )) == NULL)
5776                         return WERR_NOMEM;
5777
5778                 DEBUG(10,("enumports_level_2: port name %s\n", SAMBA_PRINTER_PORT_NAME));
5779
5780                 fill_port_2(&ports[0], SAMBA_PRINTER_PORT_NAME);
5781         }
5782
5783         /* check the required size. */
5784         for (i=0; i<*returned; i++) {
5785                 DEBUGADD(6,("adding port [%d]'s size\n", i));
5786                 *needed += spoolss_size_port_info_2(&ports[i]);
5787         }
5788
5789         if (!alloc_buffer_size(buffer, *needed)) {
5790                 SAFE_FREE(ports);
5791                 return WERR_INSUFFICIENT_BUFFER;
5792         }
5793
5794         /* fill the buffer with the ports structures */
5795         for (i=0; i<*returned; i++) {
5796                 DEBUGADD(6,("adding port [%d] to buffer\n", i));
5797                 smb_io_port_2("", buffer, &ports[i], 0);
5798         }
5799
5800         SAFE_FREE(ports);
5801
5802         if (*needed > offered) {
5803                 *returned=0;
5804                 return WERR_INSUFFICIENT_BUFFER;
5805         }
5806
5807         return WERR_OK;
5808 }
5809
5810 /****************************************************************************
5811  enumports.
5812 ****************************************************************************/
5813
5814 WERROR _spoolss_enumports( pipes_struct *p, SPOOL_Q_ENUMPORTS *q_u, SPOOL_R_ENUMPORTS *r_u)
5815 {
5816 /*      UNISTR2 *name = &q_u->name; - notused. */
5817         uint32 level = q_u->level;
5818         NEW_BUFFER *buffer = NULL;
5819         uint32 offered = q_u->offered;
5820         uint32 *needed = &r_u->needed;
5821         uint32 *returned = &r_u->returned;
5822
5823         /* that's an [in out] buffer */
5824         spoolss_move_buffer(q_u->buffer, &r_u->buffer);
5825         buffer = r_u->buffer;
5826
5827         DEBUG(4,("_spoolss_enumports\n"));
5828
5829         *returned=0;
5830         *needed=0;
5831
5832         switch (level) {
5833         case 1:
5834                 return enumports_level_1(buffer, offered, needed, returned);
5835         case 2:
5836                 return enumports_level_2(buffer, offered, needed, returned);
5837         default:
5838                 return WERR_UNKNOWN_LEVEL;
5839         }
5840 }
5841
5842 /****************************************************************************
5843 ****************************************************************************/
5844 static WERROR spoolss_addprinterex_level_2( pipes_struct *p, const UNISTR2 *uni_srv_name,
5845                                 const SPOOL_PRINTER_INFO_LEVEL *info,
5846                                 DEVICEMODE *devmode, SEC_DESC_BUF *sec_desc_buf,
5847                                 uint32 user_switch, const SPOOL_USER_CTR *user,
5848                                 POLICY_HND *handle)
5849 {
5850         NT_PRINTER_INFO_LEVEL *printer = NULL;
5851         fstring name;
5852         int     snum;
5853         WERROR err = WERR_OK;
5854
5855         if ((printer = (NT_PRINTER_INFO_LEVEL *)malloc(sizeof(NT_PRINTER_INFO_LEVEL))) == NULL) {
5856                 DEBUG(0,("spoolss_addprinterex_level_2: malloc fail.\n"));
5857                 return WERR_NOMEM;
5858         }
5859
5860         ZERO_STRUCTP(printer);
5861
5862         /* convert from UNICODE to ASCII - this allocates the info_2 struct inside *printer.*/
5863         if (!convert_printer_info(info, printer, 2)) {
5864                 free_a_printer(&printer, 2);
5865                 return WERR_NOMEM;
5866         }
5867
5868         /* check to see if the printer already exists */
5869
5870         if ((snum = print_queue_snum(printer->info_2->sharename)) != -1) {
5871                 DEBUG(5, ("_spoolss_addprinterex: Attempted to add a printer named [%s] when one already existed!\n",
5872                         printer->info_2->sharename));
5873                 free_a_printer(&printer, 2);
5874                 return WERR_PRINTER_ALREADY_EXISTS;
5875         }
5876
5877         if (*lp_addprinter_cmd() )
5878                 if ( !add_printer_hook(printer) ) {
5879                         free_a_printer(&printer,2);
5880                         return WERR_ACCESS_DENIED;
5881         }
5882
5883         slprintf(name, sizeof(name)-1, "\\\\%s\\%s", get_called_name(),
5884              printer->info_2->sharename);
5885
5886         if ((snum = print_queue_snum(printer->info_2->sharename)) == -1) {
5887                 free_a_printer(&printer,2);
5888                 return WERR_ACCESS_DENIED;
5889         }
5890
5891         /* you must be a printer admin to add a new printer */
5892         if (!print_access_check(NULL, snum, PRINTER_ACCESS_ADMINISTER)) {
5893                 free_a_printer(&printer,2);
5894                 return WERR_ACCESS_DENIED;
5895         }
5896
5897         /*
5898          * Do sanity check on the requested changes for Samba.
5899          */
5900
5901         if (!check_printer_ok(printer->info_2, snum)) {
5902                 free_a_printer(&printer,2);
5903                 return WERR_INVALID_PARAM;
5904         }
5905
5906     /*
5907          * When a printer is created, the drivername bound to the printer is used
5908          * to lookup previously saved driver initialization info, which is then
5909          * bound to the new printer, simulating what happens in the Windows arch.
5910          */
5911         set_driver_init(printer, 2);
5912
5913         /* write the ASCII on disk */
5914         err = mod_a_printer(*printer, 2);
5915         if (!W_ERROR_IS_OK(err)) {
5916                 free_a_printer(&printer,2);
5917                 return err;
5918         }
5919
5920         if (!open_printer_hnd(p, handle, name)) {
5921                 /* Handle open failed - remove addition. */
5922                 del_a_printer(printer->info_2->sharename);
5923                 free_a_printer(&printer,2);
5924                 return WERR_ACCESS_DENIED;
5925         }
5926
5927         free_a_printer(&printer,2);
5928
5929         srv_spoolss_sendnotify(p, handle);
5930
5931         return WERR_OK;
5932 }
5933
5934 /****************************************************************************
5935 ****************************************************************************/
5936
5937 WERROR _spoolss_addprinterex( pipes_struct *p, SPOOL_Q_ADDPRINTEREX *q_u, SPOOL_R_ADDPRINTEREX *r_u)
5938 {
5939         UNISTR2 *uni_srv_name = &q_u->server_name;
5940         uint32 level = q_u->level;
5941         SPOOL_PRINTER_INFO_LEVEL *info = &q_u->info;
5942         DEVICEMODE *devmode = q_u->devmode_ctr.devmode;
5943         SEC_DESC_BUF *sdb = q_u->secdesc_ctr;
5944         uint32 user_switch = q_u->user_switch;
5945         SPOOL_USER_CTR *user = &q_u->user_ctr;
5946         POLICY_HND *handle = &r_u->handle;
5947
5948         switch (level) {
5949                 case 1:
5950                         /* we don't handle yet */
5951                         /* but I know what to do ... */
5952                         return WERR_UNKNOWN_LEVEL;
5953                 case 2:
5954                         return spoolss_addprinterex_level_2(p, uni_srv_name, info,
5955                                                             devmode, sdb,
5956                                                             user_switch, user, handle);
5957                 default:
5958                         return WERR_UNKNOWN_LEVEL;
5959         }
5960 }
5961
5962 /****************************************************************************
5963 ****************************************************************************/
5964
5965 WERROR _spoolss_addprinterdriver(pipes_struct *p, SPOOL_Q_ADDPRINTERDRIVER *q_u, SPOOL_R_ADDPRINTERDRIVER *r_u)
5966 {
5967 /*      UNISTR2 *server_name = &q_u->server_name; - notused. */
5968         uint32 level = q_u->level;
5969         SPOOL_PRINTER_DRIVER_INFO_LEVEL *info = &q_u->info;
5970         WERROR err = WERR_OK;
5971         NT_PRINTER_DRIVER_INFO_LEVEL driver;
5972         struct current_user user;
5973
5974         ZERO_STRUCT(driver);
5975
5976         get_current_user(&user, p);
5977
5978         if (!convert_printer_driver_info(info, &driver, level)) {
5979                 err = WERR_NOMEM;
5980                 goto done;
5981         }
5982
5983         DEBUG(5,("Cleaning driver's information\n"));
5984         err = clean_up_driver_struct(driver, level, &user);
5985         if (!W_ERROR_IS_OK(err))
5986                 goto done;
5987
5988         DEBUG(5,("Moving driver to final destination\n"));
5989         if(!move_driver_to_download_area(driver, level, &user, &err)) {
5990                 if (W_ERROR_IS_OK(err))
5991                         err = WERR_ACCESS_DENIED;
5992                 goto done;
5993         }
5994
5995         if (add_a_printer_driver(driver, level)!=0) {
5996                 err = WERR_ACCESS_DENIED;
5997                 goto done;
5998         }
5999
6000  done:
6001         free_a_printer_driver(driver, level);
6002         return err;
6003 }
6004
6005 /****************************************************************************
6006 ****************************************************************************/
6007 static void fill_driverdir_1(DRIVER_DIRECTORY_1 *info, char *name)
6008 {
6009         init_unistr(&info->name, name);
6010 }
6011
6012 /****************************************************************************
6013 ****************************************************************************/
6014 static WERROR getprinterdriverdir_level_1(UNISTR2 *name, UNISTR2 *uni_environment, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
6015 {
6016         pstring path;
6017         pstring long_archi;
6018         pstring short_archi;
6019         DRIVER_DIRECTORY_1 *info=NULL;
6020
6021         unistr2_to_ascii(long_archi, uni_environment, sizeof(long_archi)-1);
6022
6023         if (get_short_archi(short_archi, long_archi)==False)
6024                 return WERR_INVALID_ENVIRONMENT;
6025
6026         if((info=(DRIVER_DIRECTORY_1 *)malloc(sizeof(DRIVER_DIRECTORY_1))) == NULL)
6027                 return WERR_NOMEM;
6028
6029         slprintf(path, sizeof(path)-1, "\\\\%s\\print$\\%s", get_called_name(), short_archi);
6030
6031         DEBUG(4,("printer driver directory: [%s]\n", path));
6032
6033         fill_driverdir_1(info, path);
6034
6035         *needed += spoolss_size_driverdir_info_1(info);
6036
6037         if (!alloc_buffer_size(buffer, *needed)) {
6038                 SAFE_FREE(info);
6039                 return WERR_INSUFFICIENT_BUFFER;
6040         }
6041
6042         smb_io_driverdir_1("", buffer, info, 0);
6043
6044         SAFE_FREE(info);
6045
6046         if (*needed > offered)
6047                 return WERR_INSUFFICIENT_BUFFER;
6048
6049         return WERR_OK;
6050 }
6051
6052 /****************************************************************************
6053 ****************************************************************************/
6054
6055 WERROR _spoolss_getprinterdriverdirectory(pipes_struct *p, SPOOL_Q_GETPRINTERDRIVERDIR *q_u, SPOOL_R_GETPRINTERDRIVERDIR *r_u)
6056 {
6057         UNISTR2 *name = &q_u->name;
6058         UNISTR2 *uni_environment = &q_u->environment;
6059         uint32 level = q_u->level;
6060         NEW_BUFFER *buffer = NULL;
6061         uint32 offered = q_u->offered;
6062         uint32 *needed = &r_u->needed;
6063
6064         /* that's an [in out] buffer */
6065         spoolss_move_buffer(q_u->buffer, &r_u->buffer);
6066         buffer = r_u->buffer;
6067
6068         DEBUG(4,("_spoolss_getprinterdriverdirectory\n"));
6069
6070         *needed=0;
6071
6072         switch(level) {
6073         case 1:
6074                 return getprinterdriverdir_level_1(name, uni_environment, buffer, offered, needed);
6075         default:
6076                 return WERR_UNKNOWN_LEVEL;
6077         }
6078 }
6079
6080 /****************************************************************************
6081 ****************************************************************************/
6082
6083 WERROR _spoolss_enumprinterdata(pipes_struct *p, SPOOL_Q_ENUMPRINTERDATA *q_u, SPOOL_R_ENUMPRINTERDATA *r_u)
6084 {
6085         POLICY_HND *handle = &q_u->handle;
6086         uint32 idx = q_u->index;
6087         uint32 in_value_len = q_u->valuesize;
6088         uint32 in_data_len = q_u->datasize;
6089         uint32 *out_max_value_len = &r_u->valuesize;
6090         uint16 **out_value = &r_u->value;
6091         uint32 *out_value_len = &r_u->realvaluesize;
6092         uint32 *out_type = &r_u->type;
6093         uint32 *out_max_data_len = &r_u->datasize;
6094         uint8  **data_out = &r_u->data;
6095         uint32 *out_data_len = &r_u->realdatasize;
6096
6097         NT_PRINTER_INFO_LEVEL *printer = NULL;
6098
6099         fstring value;
6100
6101         uint32 param_index;
6102         uint32 biggest_valuesize;
6103         uint32 biggest_datasize;
6104         uint32 data_len;
6105         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
6106         int snum;
6107         uint8 *data=NULL;
6108         uint32 type;
6109         WERROR result;
6110
6111         ZERO_STRUCT(printer);
6112
6113         *out_type=0;
6114
6115         *out_max_data_len=0;
6116         *data_out=NULL;
6117         *out_data_len=0;
6118
6119         DEBUG(5,("spoolss_enumprinterdata\n"));
6120
6121         if (!Printer) {
6122                 DEBUG(0,("_spoolss_enumprinterdata: Invalid handle (%s).\n", OUR_HANDLE(handle)));
6123                 return WERR_BADFID;
6124         }
6125
6126         if (!get_printer_snum(p,handle, &snum))
6127                 return WERR_BADFID;
6128
6129         result = get_a_printer(&printer, 2, lp_servicename(snum));
6130         if (!W_ERROR_IS_OK(result))
6131                 return result;
6132
6133         /*
6134          * The NT machine wants to know the biggest size of value and data
6135          *
6136          * cf: MSDN EnumPrinterData remark section
6137          */
6138         if ( (in_value_len==0) && (in_data_len==0) ) {
6139                 DEBUGADD(6,("Activating NT mega-hack to find sizes\n"));
6140
6141 #if 0
6142                 /*
6143                  * NT can ask for a specific parameter size - we need to return NO_MORE_ITEMS
6144                  * if this parameter size doesn't exist.
6145                  * Ok - my opinion here is that the client is not asking for the greatest
6146                  * possible size of all the parameters, but is asking specifically for the size needed
6147                  * for this specific parameter. In that case we can remove the loop below and
6148                  * simplify this lookup code considerably. JF - comments welcome. JRA.
6149                  */
6150
6151                 if (!get_specific_param_by_index(*printer, 2, idx, value, &data, &type, &data_len)) {
6152                         SAFE_FREE(data);
6153                         free_a_printer(&printer, 2);
6154                         return WERR_NO_MORE_ITEMS;
6155                 }
6156 #endif
6157
6158                 SAFE_FREE(data);
6159
6160                 param_index=0;
6161                 biggest_valuesize=0;
6162                 biggest_datasize=0;
6163
6164                 while (get_specific_param_by_index(*printer, 2, param_index, value, &data, &type, &data_len)) {
6165                         if (strlen(value) > biggest_valuesize) biggest_valuesize=strlen(value);
6166                         if (data_len > biggest_datasize) biggest_datasize=data_len;
6167
6168                         DEBUG(6,("current values: [%d], [%d]\n", biggest_valuesize, biggest_datasize));
6169
6170                         SAFE_FREE(data);
6171                         param_index++;
6172                 }
6173
6174                 /* the value is an UNICODE string but realvaluesize is the length in bytes including the leading 0 */
6175                 *out_value_len=2*(1+biggest_valuesize);
6176                 *out_data_len=biggest_datasize;
6177
6178                 DEBUG(6,("final values: [%d], [%d]\n", *out_value_len, *out_data_len));
6179
6180                 free_a_printer(&printer, 2);
6181                 return WERR_OK;
6182         }
6183
6184         /*
6185          * the value len is wrong in NT sp3
6186          * that's the number of bytes not the number of unicode chars
6187          */
6188
6189         if (!get_specific_param_by_index(*printer, 2, idx, value, &data, &type, &data_len)) {
6190
6191                 SAFE_FREE(data);
6192                 free_a_printer(&printer, 2);
6193
6194                 /* out_value should default to "" or else NT4 has
6195                    problems unmarshalling the response */
6196
6197                 *out_max_value_len=(in_value_len/sizeof(uint16));
6198                 if((*out_value=(uint16 *)malloc(in_value_len*sizeof(uint8))) == NULL)
6199                         return WERR_NOMEM;
6200
6201                 ZERO_STRUCTP(*out_value);
6202                 *out_value_len = rpcstr_push((char *)*out_value, "", in_value_len, 0);
6203
6204                 /* the data is counted in bytes */
6205                 *out_max_data_len = in_data_len;
6206                 *out_data_len = in_data_len;
6207                 if((*data_out=(uint8 *)malloc(in_data_len*sizeof(uint8))) == NULL)
6208                         return WERR_NOMEM;
6209
6210                 memset(*data_out,'\0',in_data_len);
6211
6212                 return WERR_NO_MORE_ITEMS;
6213         }
6214
6215         free_a_printer(&printer, 2);
6216
6217         /*
6218          * the value is:
6219          * - counted in bytes in the request
6220          * - counted in UNICODE chars in the max reply
6221          * - counted in bytes in the real size
6222          *
6223          * take a pause *before* coding not *during* coding
6224          */
6225
6226         *out_max_value_len=(in_value_len/sizeof(uint16));
6227         if((*out_value=(uint16 *)talloc_zero(p->mem_ctx,in_value_len*sizeof(uint8))) == NULL) {
6228                 SAFE_FREE(data);
6229                 return WERR_NOMEM;
6230         }
6231
6232         *out_value_len = rpcstr_push((char *)*out_value,value, in_value_len, 0);
6233
6234         *out_type=type;
6235
6236         /* the data is counted in bytes */
6237         *out_max_data_len=in_data_len;
6238         if((*data_out=(uint8 *)talloc_zero(p->mem_ctx, in_data_len*sizeof(uint8))) == NULL) {
6239                 SAFE_FREE(data);
6240                 return WERR_NOMEM;
6241         }
6242
6243         memcpy(*data_out, data, (size_t)data_len);
6244         *out_data_len=data_len;
6245
6246         SAFE_FREE(data);
6247
6248         return WERR_OK;
6249 }
6250
6251 /****************************************************************************
6252 ****************************************************************************/
6253
6254 WERROR _spoolss_setprinterdata( pipes_struct *p, SPOOL_Q_SETPRINTERDATA *q_u, SPOOL_R_SETPRINTERDATA *r_u)
6255 {
6256         POLICY_HND *handle = &q_u->handle;
6257         UNISTR2 *value = &q_u->value;
6258         uint32 type = q_u->type;
6259 /*      uint32 max_len = q_u->max_len; - notused. */
6260         uint8 *data = q_u->data;
6261         uint32 real_len = q_u->real_len;
6262 /*      uint32 numeric_data = q_u->numeric_data; - notused. */
6263
6264         NT_PRINTER_INFO_LEVEL *printer = NULL;
6265         NT_PRINTER_PARAM *param = NULL, old_param;
6266         int snum=0;
6267         WERROR status = WERR_OK;
6268         Printer_entry *Printer=find_printer_index_by_hnd(p, handle);
6269
6270         DEBUG(5,("spoolss_setprinterdata\n"));
6271
6272         if (!Printer) {
6273                 DEBUG(0,("_spoolss_setprinterdata: Invalid handle (%s).\n", OUR_HANDLE(handle)));
6274                 return WERR_BADFID;
6275         }
6276
6277         if (!get_printer_snum(p,handle, &snum))
6278                 return WERR_BADFID;
6279
6280         ZERO_STRUCT(old_param);
6281
6282         /*
6283          * Access check : NT returns "access denied" if you make a
6284          * SetPrinterData call without the necessary privildge.
6285          * we were originally returning OK if nothing changed
6286          * which made Win2k issue **a lot** of SetPrinterData
6287          * when connecting to a printer  --jerry
6288          */
6289
6290         if (!print_access_check(NULL, snum, PRINTER_ACCESS_ADMINISTER)) {
6291                 DEBUG(3, ("security descriptor change denied by existing "
6292                           "security descriptor\n"));
6293                 status = WERR_ACCESS_DENIED;
6294                 goto done;
6295         }
6296
6297         /* Check if we are making any changes or not.  Return true if
6298            nothing is actually changing.  This is not needed anymore but
6299            has been left in as an optimization to keep from from
6300            writing to disk as often  --jerry  */
6301
6302         status = get_a_printer(&printer, 2, lp_servicename(snum));
6303         if (!W_ERROR_IS_OK(status))
6304                 return status;
6305
6306         convert_specific_param(&param, value , type, data, real_len);
6307
6308 #if 0
6309         if (get_specific_param(*printer, 2, param->value, &old_param.data,
6310                                &old_param.type, (uint32 *)&old_param.data_len)) {
6311
6312                 if (param->type == old_param.type &&
6313                     param->data_len == old_param.data_len &&
6314                     memcmp(param->data, old_param.data,
6315                            old_param.data_len) == 0) {
6316
6317                         DEBUG(3, ("setprinterdata hasn't changed\n"));
6318                         status = WERR_OK;
6319                         goto done;
6320                 }
6321         }
6322 #endif
6323
6324         unlink_specific_param_if_exist(printer->info_2, param);
6325
6326         /*
6327          * When client side code sets a magic printer data key, detect it and save
6328          * the current printer data and the magic key's data (its the DEVMODE) for
6329          * future printer/driver initializations.
6330          */
6331         if (param->type==3 && !strcmp( param->value, PHANTOM_DEVMODE_KEY)) {
6332                 /*
6333                  * Set devmode and printer initialization info
6334                  */
6335                 status = save_driver_init(printer, 2, param);
6336         }
6337         else {
6338                 add_a_specific_param(printer->info_2, &param);
6339                 status = mod_a_printer(*printer, 2);
6340         }
6341
6342  done:
6343         free_a_printer(&printer, 2);
6344         if (param)
6345                 free_nt_printer_param(&param);
6346         SAFE_FREE(old_param.data);
6347
6348         return status;
6349 }
6350
6351 /****************************************************************************
6352 ****************************************************************************/
6353
6354 WERROR _spoolss_deleteprinterdata(pipes_struct *p, SPOOL_Q_DELETEPRINTERDATA *q_u, SPOOL_R_DELETEPRINTERDATA *r_u)
6355 {
6356         POLICY_HND *handle = &q_u->handle;
6357         UNISTR2 *value = &q_u->valuename;
6358
6359         NT_PRINTER_INFO_LEVEL *printer = NULL;
6360         NT_PRINTER_PARAM param;
6361         int snum=0;
6362         WERROR status = WERR_OK;
6363         Printer_entry *Printer=find_printer_index_by_hnd(p, handle);
6364
6365         DEBUG(5,("spoolss_deleteprinterdata\n"));
6366
6367         if (!Printer) {
6368                 DEBUG(0,("_spoolss_deleteprinterdata: Invalid handle (%s).\n", OUR_HANDLE(handle)));
6369                 return WERR_BADFID;
6370         }
6371
6372         if (!get_printer_snum(p, handle, &snum))
6373                 return WERR_BADFID;
6374
6375         if (!print_access_check(NULL, snum, PRINTER_ACCESS_ADMINISTER)) {
6376                 DEBUG(3, ("_spoolss_deleteprinterdata: printer properties "
6377                           "change denied by existing security descriptor\n"));
6378                 return WERR_ACCESS_DENIED;
6379         }
6380
6381         status = get_a_printer(&printer, 2, lp_servicename(snum));
6382         if (!W_ERROR_IS_OK(status))
6383                 return status;
6384
6385         ZERO_STRUCTP(&param);
6386         unistr2_to_ascii(param.value, value, sizeof(param.value)-1);
6387
6388         if(!unlink_specific_param_if_exist(printer->info_2, &param))
6389                 status = WERR_INVALID_PARAM;
6390         else
6391                 status = mod_a_printer(*printer, 2);
6392
6393         free_a_printer(&printer, 2);
6394         return status;
6395 }
6396
6397 /****************************************************************************
6398 ****************************************************************************/
6399
6400 WERROR _spoolss_addform( pipes_struct *p, SPOOL_Q_ADDFORM *q_u, SPOOL_R_ADDFORM *r_u)
6401 {
6402         POLICY_HND *handle = &q_u->handle;
6403 /*      uint32 level = q_u->level; - notused. */
6404         FORM *form = &q_u->form;
6405         nt_forms_struct tmpForm;
6406
6407         int count=0;
6408         nt_forms_struct *list=NULL;
6409         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
6410
6411         DEBUG(5,("spoolss_addform\n"));
6412
6413         if (!Printer) {
6414                 DEBUG(0,("_spoolss_addform: Invalid handle (%s).\n", OUR_HANDLE(handle)));
6415                 return WERR_BADFID;
6416         }
6417
6418         /*
6419          * FIXME!!  Feels like there should be an access check here, but haven't
6420          * had time to verify.  --jerry
6421          */
6422
6423         /* can't add if builtin */
6424         if (get_a_builtin_ntform(&form->name,&tmpForm)) {
6425                 return WERR_INVALID_PARAM;
6426         }
6427
6428         count=get_ntforms(&list);
6429         if(!add_a_form(&list, form, &count))
6430                 return WERR_NOMEM;
6431         write_ntforms(&list, count);
6432
6433         SAFE_FREE(list);
6434
6435         return WERR_OK;
6436 }
6437
6438 /****************************************************************************
6439 ****************************************************************************/
6440
6441 WERROR _spoolss_deleteform( pipes_struct *p, SPOOL_Q_DELETEFORM *q_u, SPOOL_R_DELETEFORM *r_u)
6442 {
6443         POLICY_HND *handle = &q_u->handle;
6444         UNISTR2 *form_name = &q_u->name;
6445         nt_forms_struct tmpForm;
6446         int count=0;
6447         WERROR ret = WERR_OK;
6448         nt_forms_struct *list=NULL;
6449         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
6450
6451         DEBUG(5,("spoolss_deleteform\n"));
6452
6453         if (!Printer) {
6454                 DEBUG(0,("_spoolss_deleteform: Invalid handle (%s).\n", OUR_HANDLE(handle)));
6455                 return WERR_BADFID;
6456         }
6457
6458         /* can't delete if builtin */
6459         if (get_a_builtin_ntform(form_name,&tmpForm)) {
6460                 return WERR_INVALID_PARAM;
6461         }
6462
6463         count = get_ntforms(&list);
6464         if(!delete_a_form(&list, form_name, &count, &ret))
6465                 return WERR_INVALID_PARAM;
6466
6467         SAFE_FREE(list);
6468
6469         return ret;
6470 }
6471
6472 /****************************************************************************
6473 ****************************************************************************/
6474
6475 WERROR _spoolss_setform(pipes_struct *p, SPOOL_Q_SETFORM *q_u, SPOOL_R_SETFORM *r_u)
6476 {
6477         POLICY_HND *handle = &q_u->handle;
6478 /*      UNISTR2 *uni_name = &q_u->name; - notused. */
6479 /*      uint32 level = q_u->level; - notused. */
6480         FORM *form = &q_u->form;
6481         nt_forms_struct tmpForm;
6482
6483         int count=0;
6484         nt_forms_struct *list=NULL;
6485         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
6486
6487         DEBUG(5,("spoolss_setform\n"));
6488
6489         if (!Printer) {
6490                 DEBUG(0,("_spoolss_setform: Invalid handle (%s).\n", OUR_HANDLE(handle)));
6491                 return WERR_BADFID;
6492         }
6493         /* can't set if builtin */
6494         if (get_a_builtin_ntform(&form->name,&tmpForm)) {
6495                 return WERR_INVALID_PARAM;
6496         }
6497
6498         count=get_ntforms(&list);
6499         update_a_form(&list, form, count);
6500         write_ntforms(&list, count);
6501
6502         SAFE_FREE(list);
6503
6504         return WERR_OK;
6505 }
6506
6507 /****************************************************************************
6508  enumprintprocessors level 1.
6509 ****************************************************************************/
6510 static WERROR enumprintprocessors_level_1(NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
6511 {
6512         PRINTPROCESSOR_1 *info_1=NULL;
6513
6514         if((info_1 = (PRINTPROCESSOR_1 *)malloc(sizeof(PRINTPROCESSOR_1))) == NULL)
6515                 return WERR_NOMEM;
6516
6517         (*returned) = 0x1;
6518
6519         init_unistr(&info_1->name, "winprint");
6520
6521         *needed += spoolss_size_printprocessor_info_1(info_1);
6522
6523         if (!alloc_buffer_size(buffer, *needed))
6524                 return WERR_INSUFFICIENT_BUFFER;
6525
6526         smb_io_printprocessor_info_1("", buffer, info_1, 0);
6527
6528         SAFE_FREE(info_1);
6529
6530         if (*needed > offered) {
6531                 *returned=0;
6532                 return WERR_INSUFFICIENT_BUFFER;
6533         }
6534
6535         return WERR_OK;
6536 }
6537
6538 /****************************************************************************
6539 ****************************************************************************/
6540
6541 WERROR _spoolss_enumprintprocessors(pipes_struct *p, SPOOL_Q_ENUMPRINTPROCESSORS *q_u, SPOOL_R_ENUMPRINTPROCESSORS *r_u)
6542 {
6543 /*      UNISTR2 *name = &q_u->name; - notused. */
6544 /*      UNISTR2 *environment = &q_u->environment; - notused. */
6545         uint32 level = q_u->level;
6546     NEW_BUFFER *buffer = NULL;
6547         uint32 offered = q_u->offered;
6548     uint32 *needed = &r_u->needed;
6549         uint32 *returned = &r_u->returned;
6550
6551         /* that's an [in out] buffer */
6552         spoolss_move_buffer(q_u->buffer, &r_u->buffer);
6553         buffer = r_u->buffer;
6554
6555         DEBUG(5,("spoolss_enumprintprocessors\n"));
6556
6557         /*
6558          * Enumerate the print processors ...
6559          *
6560          * Just reply with "winprint", to keep NT happy
6561          * and I can use my nice printer checker.
6562          */
6563
6564         *returned=0;
6565         *needed=0;
6566
6567         switch (level) {
6568         case 1:
6569                 return enumprintprocessors_level_1(buffer, offered, needed, returned);
6570         default:
6571                 return WERR_UNKNOWN_LEVEL;
6572         }
6573 }
6574
6575 /****************************************************************************
6576  enumprintprocdatatypes level 1.
6577 ****************************************************************************/
6578 static WERROR enumprintprocdatatypes_level_1(NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
6579 {
6580         PRINTPROCDATATYPE_1 *info_1=NULL;
6581
6582         if((info_1 = (PRINTPROCDATATYPE_1 *)malloc(sizeof(PRINTPROCDATATYPE_1))) == NULL)
6583                 return WERR_NOMEM;
6584
6585         (*returned) = 0x1;
6586
6587         init_unistr(&info_1->name, "RAW");
6588
6589         *needed += spoolss_size_printprocdatatype_info_1(info_1);
6590
6591         if (!alloc_buffer_size(buffer, *needed))
6592                 return WERR_INSUFFICIENT_BUFFER;
6593
6594         smb_io_printprocdatatype_info_1("", buffer, info_1, 0);
6595
6596         SAFE_FREE(info_1);
6597
6598         if (*needed > offered) {
6599                 *returned=0;
6600                 return WERR_INSUFFICIENT_BUFFER;
6601         }
6602
6603         return WERR_OK;
6604 }
6605
6606 /****************************************************************************
6607 ****************************************************************************/
6608
6609 WERROR _spoolss_enumprintprocdatatypes(pipes_struct *p, SPOOL_Q_ENUMPRINTPROCDATATYPES *q_u, SPOOL_R_ENUMPRINTPROCDATATYPES *r_u)
6610 {
6611 /*      UNISTR2 *name = &q_u->name; - notused. */
6612 /*      UNISTR2 *processor = &q_u->processor; - notused. */
6613         uint32 level = q_u->level;
6614         NEW_BUFFER *buffer = NULL;
6615         uint32 offered = q_u->offered;
6616         uint32 *needed = &r_u->needed;
6617         uint32 *returned = &r_u->returned;
6618
6619         /* that's an [in out] buffer */
6620         spoolss_move_buffer(q_u->buffer, &r_u->buffer);
6621         buffer = r_u->buffer;
6622
6623         DEBUG(5,("_spoolss_enumprintprocdatatypes\n"));
6624
6625         *returned=0;
6626         *needed=0;
6627
6628         switch (level) {
6629         case 1:
6630                 return enumprintprocdatatypes_level_1(buffer, offered, needed, returned);
6631         default:
6632                 return WERR_UNKNOWN_LEVEL;
6633         }
6634 }
6635
6636 /****************************************************************************
6637  enumprintmonitors level 1.
6638 ****************************************************************************/
6639
6640 static WERROR enumprintmonitors_level_1(NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
6641 {
6642         PRINTMONITOR_1 *info_1=NULL;
6643
6644         if((info_1 = (PRINTMONITOR_1 *)malloc(sizeof(PRINTMONITOR_1))) == NULL)
6645                 return WERR_NOMEM;
6646
6647         (*returned) = 0x1;
6648
6649         init_unistr(&info_1->name, "Local Port");
6650
6651         *needed += spoolss_size_printmonitor_info_1(info_1);
6652
6653         if (!alloc_buffer_size(buffer, *needed))
6654                 return WERR_INSUFFICIENT_BUFFER;
6655
6656         smb_io_printmonitor_info_1("", buffer, info_1, 0);
6657
6658         SAFE_FREE(info_1);
6659
6660         if (*needed > offered) {
6661                 *returned=0;
6662                 return WERR_INSUFFICIENT_BUFFER;
6663         }
6664
6665         return WERR_OK;
6666 }
6667
6668 /****************************************************************************
6669  enumprintmonitors level 2.
6670 ****************************************************************************/
6671 static WERROR enumprintmonitors_level_2(NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
6672 {
6673         PRINTMONITOR_2 *info_2=NULL;
6674
6675         if((info_2 = (PRINTMONITOR_2 *)malloc(sizeof(PRINTMONITOR_2))) == NULL)
6676                 return WERR_NOMEM;
6677
6678         (*returned) = 0x1;
6679
6680         init_unistr(&info_2->name, "Local Port");
6681         init_unistr(&info_2->environment, "Windows NT X86");
6682         init_unistr(&info_2->dll_name, "localmon.dll");
6683
6684         *needed += spoolss_size_printmonitor_info_2(info_2);
6685
6686         if (!alloc_buffer_size(buffer, *needed))
6687                 return WERR_INSUFFICIENT_BUFFER;
6688
6689         smb_io_printmonitor_info_2("", buffer, info_2, 0);
6690
6691         SAFE_FREE(info_2);
6692
6693         if (*needed > offered) {
6694                 *returned=0;
6695                 return WERR_INSUFFICIENT_BUFFER;
6696         }
6697
6698         return WERR_OK;
6699 }
6700
6701 /****************************************************************************
6702 ****************************************************************************/
6703
6704 WERROR _spoolss_enumprintmonitors(pipes_struct *p, SPOOL_Q_ENUMPRINTMONITORS *q_u, SPOOL_R_ENUMPRINTMONITORS *r_u)
6705 {
6706 /*      UNISTR2 *name = &q_u->name; - notused. */
6707         uint32 level = q_u->level;
6708     NEW_BUFFER *buffer = NULL;
6709         uint32 offered = q_u->offered;
6710     uint32 *needed = &r_u->needed;
6711         uint32 *returned = &r_u->returned;
6712
6713         /* that's an [in out] buffer */
6714         spoolss_move_buffer(q_u->buffer, &r_u->buffer);
6715         buffer = r_u->buffer;
6716
6717         DEBUG(5,("spoolss_enumprintmonitors\n"));
6718
6719         /*
6720          * Enumerate the print monitors ...
6721          *
6722          * Just reply with "Local Port", to keep NT happy
6723          * and I can use my nice printer checker.
6724          */
6725
6726         *returned=0;
6727         *needed=0;
6728
6729         switch (level) {
6730         case 1:
6731                 return enumprintmonitors_level_1(buffer, offered, needed, returned);
6732         case 2:
6733                 return enumprintmonitors_level_2(buffer, offered, needed, returned);
6734         default:
6735                 return WERR_UNKNOWN_LEVEL;
6736         }
6737 }
6738
6739 /****************************************************************************
6740 ****************************************************************************/
6741 static WERROR getjob_level_1(print_queue_struct *queue, int count, int snum, uint32 jobid, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
6742 {
6743         int i=0;
6744         BOOL found=False;
6745         JOB_INFO_1 *info_1=NULL;
6746
6747         info_1=(JOB_INFO_1 *)malloc(sizeof(JOB_INFO_1));
6748
6749         if (info_1 == NULL) {
6750                 SAFE_FREE(queue);
6751                 return WERR_NOMEM;
6752         }
6753
6754         for (i=0; i<count && found==False; i++) {
6755                 if (queue[i].job==(int)jobid)
6756                         found=True;
6757         }
6758
6759         if (found==False) {
6760                 SAFE_FREE(queue);
6761                 SAFE_FREE(info_1);
6762                 /* NT treats not found as bad param... yet another bad choice */
6763                 return WERR_INVALID_PARAM;
6764         }
6765
6766         fill_job_info_1(info_1, &(queue[i-1]), i, snum);
6767
6768         SAFE_FREE(queue);
6769
6770         *needed += spoolss_size_job_info_1(info_1);
6771
6772         if (!alloc_buffer_size(buffer, *needed)) {
6773                 SAFE_FREE(info_1);
6774                 return WERR_INSUFFICIENT_BUFFER;
6775         }
6776
6777         smb_io_job_info_1("", buffer, info_1, 0);
6778
6779         SAFE_FREE(info_1);
6780
6781         if (*needed > offered)
6782                 return WERR_INSUFFICIENT_BUFFER;
6783
6784         return WERR_OK;
6785 }
6786
6787
6788 /****************************************************************************
6789 ****************************************************************************/
6790 static WERROR getjob_level_2(print_queue_struct *queue, int count, int snum, uint32 jobid, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
6791 {
6792         int i=0;
6793         BOOL found=False;
6794         JOB_INFO_2 *info_2;
6795         NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
6796         WERROR ret;
6797
6798         info_2=(JOB_INFO_2 *)malloc(sizeof(JOB_INFO_2));
6799
6800         ZERO_STRUCTP(info_2);
6801
6802         if (info_2 == NULL) {
6803                 SAFE_FREE(queue);
6804                 return WERR_NOMEM;
6805         }
6806
6807         for (i=0; i<count && found==False; i++) {
6808                 if (queue[i].job==(int)jobid)
6809                         found=True;
6810         }
6811
6812         if (found==False) {
6813                 SAFE_FREE(queue);
6814                 SAFE_FREE(info_2);
6815                 /* NT treats not found as bad param... yet another bad choice */
6816                 return WERR_INVALID_PARAM;
6817         }
6818
6819         ret = get_a_printer(&ntprinter, 2, lp_servicename(snum));
6820         if (!W_ERROR_IS_OK(ret)) {
6821                 SAFE_FREE(queue);
6822                 return ret;
6823         }
6824
6825         fill_job_info_2(info_2, &(queue[i-1]), i, snum, ntprinter);
6826
6827         free_a_printer(&ntprinter, 2);
6828         SAFE_FREE(queue);
6829
6830         *needed += spoolss_size_job_info_2(info_2);
6831
6832         if (!alloc_buffer_size(buffer, *needed)) {
6833                 SAFE_FREE(info_2);
6834                 return WERR_INSUFFICIENT_BUFFER;
6835         }
6836
6837         smb_io_job_info_2("", buffer, info_2, 0);
6838
6839         free_job_info_2(info_2);
6840         SAFE_FREE(info_2);
6841
6842         if (*needed > offered)
6843                 return WERR_INSUFFICIENT_BUFFER;
6844
6845         return WERR_OK;
6846 }
6847
6848 /****************************************************************************
6849 ****************************************************************************/
6850
6851 WERROR _spoolss_getjob( pipes_struct *p, SPOOL_Q_GETJOB *q_u, SPOOL_R_GETJOB *r_u)
6852 {
6853         POLICY_HND *handle = &q_u->handle;
6854         uint32 jobid = q_u->jobid;
6855         uint32 level = q_u->level;
6856         NEW_BUFFER *buffer = NULL;
6857         uint32 offered = q_u->offered;
6858         uint32 *needed = &r_u->needed;
6859
6860         int snum;
6861         int count;
6862         print_queue_struct *queue=NULL;
6863         print_status_struct prt_status;
6864
6865         /* that's an [in out] buffer */
6866         spoolss_move_buffer(q_u->buffer, &r_u->buffer);
6867         buffer = r_u->buffer;
6868
6869         DEBUG(5,("spoolss_getjob\n"));
6870
6871         *needed=0;
6872
6873         if (!get_printer_snum(p, handle, &snum))
6874                 return WERR_BADFID;
6875
6876         count = print_queue_status(snum, &queue, &prt_status);
6877
6878         DEBUGADD(4,("count:[%d], prt_status:[%d], [%s]\n",
6879                      count, prt_status.status, prt_status.message));
6880
6881         switch (level) {
6882         case 1:
6883                 return getjob_level_1(queue, count, snum, jobid, buffer, offered, needed);
6884         case 2:
6885                 return getjob_level_2(queue, count, snum, jobid, buffer, offered, needed);
6886         default:
6887                 SAFE_FREE(queue);
6888                 return WERR_UNKNOWN_LEVEL;
6889         }
6890 }
6891
6892 /********************************************************************
6893  * spoolss_getprinterdataex
6894  ********************************************************************/
6895
6896 WERROR _spoolss_getprinterdataex(pipes_struct *p, SPOOL_Q_GETPRINTERDATAEX *q_u, SPOOL_R_GETPRINTERDATAEX *r_u)
6897 {
6898         POLICY_HND      *handle = &q_u->handle;
6899         uint32          in_size = q_u->size;
6900         uint32          *type = &r_u->type;
6901         uint32          *out_size = &r_u->size;
6902         uint8           **data = &r_u->data;
6903         uint32          *needed = &r_u->needed;
6904
6905         fstring         key, value;
6906         Printer_entry   *Printer = find_printer_index_by_hnd(p, handle);
6907         BOOL            found = False;
6908
6909         DEBUG(4,("_spoolss_getprinterdataex\n"));
6910
6911         unistr2_to_ascii(key, &q_u->keyname, sizeof(key) - 1);
6912         unistr2_to_ascii(value, &q_u->valuename, sizeof(value) - 1);
6913
6914         /* in case of problem, return some default values */
6915         *needed=0;
6916         *type=0;
6917         *out_size=0;
6918
6919
6920         if (!Printer) {
6921                 if((*data=(uint8 *)talloc_zero(p->mem_ctx, 4*sizeof(uint8))) == NULL)
6922                         return WERR_NOMEM;
6923                 DEBUG(0,("_spoolss_getprinterdata: Invalid handle (%s).\n", OUR_HANDLE(handle)));
6924                 return WERR_BADFID;
6925         }
6926
6927
6928         /* Is the handle to a printer or to the server? */
6929
6930         if (Printer->printer_type == PRINTER_HANDLE_IS_PRINTSERVER)
6931         {
6932                 DEBUG(10,("_spoolss_getprinterdatex: Not implemented for server handles yet\n"));
6933                 return WERR_INVALID_PARAM;
6934         }
6935         else
6936         {
6937                 /*
6938                  * From MSDN documentation of GetPrinterDataEx: pass request
6939                  * to GetPrinterData if key is "PrinterDriverData". This is
6940                  * the only key we really support. Other keys to implement:
6941                  * (a) DsDriver
6942                  * (b) DsSpooler
6943                  * (c) PnPData
6944                  */
6945
6946                 if (strcmp(key, "PrinterDriverData") != 0)
6947                         return WERR_INVALID_PARAM;
6948
6949                 DEBUG(10, ("_spoolss_getprinterdataex: pass me to getprinterdata\n"));
6950                 found = getprinterdata_printer(p, p->mem_ctx, handle, value,
6951                         type, data, needed, in_size);
6952
6953         }
6954
6955         if (!found) {
6956                 DEBUG(5, ("value not found, allocating %d\n", *out_size));
6957
6958                 /* reply this param doesn't exist */
6959                 if (*out_size) {
6960                         if((*data=(uint8 *)talloc_zero(p->mem_ctx, *out_size*sizeof(uint8))) == NULL)
6961                                 return WERR_NOMEM;
6962                 } else {
6963                         *data = NULL;
6964                 }
6965
6966                 return WERR_INVALID_PARAM;
6967         }
6968
6969         if (*needed > *out_size)
6970                 return WERR_MORE_DATA;
6971         else
6972                 return WERR_OK;
6973 }
6974
6975 /********************************************************************
6976  * spoolss_setprinterdata
6977  ********************************************************************/
6978
6979 WERROR _spoolss_setprinterdataex(pipes_struct *p, SPOOL_Q_SETPRINTERDATAEX *q_u, SPOOL_R_SETPRINTERDATAEX *r_u)
6980 {
6981         SPOOL_Q_SETPRINTERDATA q_u_local;
6982         SPOOL_R_SETPRINTERDATA r_u_local;
6983         fstring key;
6984
6985         DEBUG(4,("_spoolss_setprinterdataex\n"));
6986
6987         /* From MSDN documentation of SetPrinterDataEx: pass request to
6988            SetPrinterData if key is "PrinterDriverData" */
6989
6990         unistr2_to_ascii(key, &q_u->key, sizeof(key) - 1);
6991
6992         if (strcmp(key, "PrinterDriverData") == 0)
6993                 return WERR_INVALID_PARAM;
6994
6995         ZERO_STRUCT(q_u_local);
6996         ZERO_STRUCT(r_u_local);
6997
6998         /* make a copy to call _spoolss_setprinterdata() */
6999
7000         memcpy(&q_u_local.handle, &q_u->handle, sizeof(POLICY_HND));
7001         copy_unistr2(&q_u_local.value, &q_u->value);
7002         q_u_local.type = q_u->type;
7003         q_u_local.max_len = q_u->max_len;
7004         q_u_local.data = q_u->data;
7005         q_u_local.real_len = q_u->real_len;
7006         q_u_local.numeric_data = q_u->numeric_data;
7007
7008         return _spoolss_setprinterdata(p, &q_u_local, &r_u_local);
7009 }
7010
7011 /********************************************************************
7012  * spoolss_enumprinterkey
7013  ********************************************************************/
7014
7015 /* constants for EnumPrinterKey() */
7016 #define ENUMERATED_KEY_SIZE     19
7017
7018 WERROR _spoolss_enumprinterkey(pipes_struct *p, SPOOL_Q_ENUMPRINTERKEY *q_u, SPOOL_R_ENUMPRINTERKEY *r_u)
7019 {
7020         fstring key;
7021         uint16  enumkeys[ENUMERATED_KEY_SIZE+1];
7022         char*   ptr = NULL;
7023         int     i;
7024         char    *PrinterKey = "PrinterDriverData";
7025
7026         DEBUG(4,("_spoolss_enumprinterkey\n"));
7027
7028         unistr2_to_ascii(key, &q_u->key, sizeof(key) - 1);
7029
7030         /*
7031          * we only support enumating all keys (key == "")
7032          * Of course, the only key we support is the "PrinterDriverData"
7033          * key
7034          */
7035         if (strlen(key) == 0)
7036         {
7037                 r_u->needed = ENUMERATED_KEY_SIZE *2;
7038                 if (q_u->size < r_u->needed)
7039                         return WERR_MORE_DATA;
7040
7041                 ptr = PrinterKey;
7042                 for (i=0; i<ENUMERATED_KEY_SIZE-2; i++)
7043                 {
7044                         enumkeys[i] = (uint16)(*ptr);
7045                         ptr++;
7046                 }
7047
7048                 /* tag of with 2 '\0's */
7049                 enumkeys[i++] = '\0';
7050                 enumkeys[i] = '\0';
7051
7052                 if (!make_spoolss_buffer5(p->mem_ctx, &r_u->keys, ENUMERATED_KEY_SIZE, enumkeys))
7053                         return WERR_BADFILE;
7054
7055                 return WERR_OK;
7056         }
7057
7058         /* The "PrinterDriverData" key should have no subkeys */
7059         if (strcmp(key, PrinterKey) == 0)
7060         {
7061                 r_u-> needed = 2;
7062                 if (q_u->size < r_u->needed)
7063                         return WERR_MORE_DATA;
7064                 enumkeys[0] = 0x0;
7065                 if (!make_spoolss_buffer5(p->mem_ctx, &r_u->keys, 1, enumkeys))
7066                         return WERR_BADFILE;
7067
7068                 return WERR_OK;
7069         }
7070
7071
7072         /* The return value for an unknown key is documented in MSDN
7073            EnumPrinterKey description */
7074         return WERR_BADFILE;
7075 }
7076
7077 /********************************************************************
7078  * spoolss_enumprinterdataex
7079  ********************************************************************/
7080
7081 WERROR _spoolss_enumprinterdataex(pipes_struct *p, SPOOL_Q_ENUMPRINTERDATAEX *q_u, SPOOL_R_ENUMPRINTERDATAEX *r_u)
7082 {
7083         POLICY_HND      *handle = &q_u->handle;
7084         uint32          in_size = q_u->size;
7085         uint32          num_entries,
7086                         needed;
7087         NT_PRINTER_INFO_LEVEL   *printer = NULL;
7088         PRINTER_ENUM_VALUES     *enum_values = NULL;
7089         fstring         key, value;
7090         Printer_entry   *Printer = find_printer_index_by_hnd(p, handle);
7091         int             snum;
7092         uint32          param_index,
7093                         data_len,
7094                         type;
7095         WERROR          result;
7096         uint8           *data=NULL;
7097
7098
7099         DEBUG(4,("_spoolss_enumprinterdataex\n"));
7100
7101         if (!Printer) {
7102                 DEBUG(0,("_spoolss_enumprinterdata: Invalid handle (%s).\n", OUR_HANDLE(handle)));
7103                 return WERR_BADFID;
7104         }
7105
7106
7107         /*
7108          * The only key we support is "PrinterDriverData". This should return
7109          > an array of all the key/value pairs returned by EnumPrinterDataSee
7110          * _spoolss_getprinterdataex() for details    --jerry
7111          */
7112
7113         unistr2_to_ascii(key, &q_u->key, sizeof(key) - 1);
7114         if (strcmp(key, "PrinterDriverData") != 0)
7115         {
7116                 DEBUG(10,("_spoolss_enumprinterdataex: Unknown keyname [%s]\n", key));
7117                 return WERR_INVALID_PARAM;
7118         }
7119
7120
7121         if (!get_printer_snum(p,handle, &snum))
7122                 return WERR_BADFID;
7123
7124         ZERO_STRUCT(printer);
7125         result = get_a_printer(&printer, 2, lp_servicename(snum));
7126         if (!W_ERROR_IS_OK(result))
7127                 return result;
7128
7129
7130         /*
7131          * loop through all params and build the array to pass
7132          * back to the  client
7133          */
7134         result = WERR_OK;
7135         param_index             = 0;
7136         needed                  = 0;
7137         num_entries             = 0;
7138
7139         while (get_specific_param_by_index(*printer, 2, param_index, value, &data, &type, &data_len))
7140         {
7141                 PRINTER_ENUM_VALUES     *ptr;
7142                 uint32                  add_len = 0;
7143
7144                 DEBUG(10,("retrieved value number [%d] [%s]\n", num_entries, value));
7145
7146                 if ((ptr=talloc_realloc(p->mem_ctx, enum_values, (num_entries+1) * sizeof(PRINTER_ENUM_VALUES))) == NULL)
7147                 {
7148                         DEBUG(0,("talloc_realloc failed to allocate more memory!\n"));
7149                         result = WERR_NOMEM;
7150                         goto done;
7151                 }
7152                 enum_values = ptr;
7153
7154                 /* copy the data */
7155                 init_unistr(&enum_values[num_entries].valuename, value);
7156                 enum_values[num_entries].value_len = (strlen(value)+1) * 2;
7157                 enum_values[num_entries].type      = type;
7158
7159                 /*
7160                  * NULL terminate REG_SZ
7161                  * FIXME!!!  We should not be correctly problems in the way
7162                  * we store PrinterData here.  Need to investogate
7163                  * SetPrinterData[Ex]   --jerry
7164                  */
7165
7166                 if (type == REG_SZ) {
7167                         /* fix alignment if the string was stored
7168                            in a bizarre fashion */
7169                         if ((data_len % 2) == 0)
7170                                 add_len = 2;
7171                         else
7172                                 add_len = data_len % 2;
7173                 }
7174
7175                 if (!(enum_values[num_entries].data=talloc_zero(p->mem_ctx, data_len+add_len))) {
7176                         DEBUG(0,("talloc_realloc failed to allocate more memory for data!\n"));
7177                         result = WERR_NOMEM;
7178                         goto done;
7179                 }
7180                 memcpy(enum_values[num_entries].data, data, data_len);
7181                 enum_values[num_entries].data_len = data_len + add_len;
7182
7183                 /* keep track of the size of the array in bytes */
7184
7185                 needed += spoolss_size_printer_enum_values(&enum_values[num_entries]);
7186
7187                 num_entries++;
7188                 param_index++;
7189         }
7190
7191         r_u->needed             = needed;
7192         r_u->returned           = num_entries;
7193
7194         if (needed > in_size) {
7195                 result = WERR_MORE_DATA;
7196                 goto done;
7197         }
7198
7199         /* copy data into the reply */
7200
7201         r_u->ctr.size           = r_u->needed;
7202         r_u->ctr.size_of_array  = r_u->returned;
7203         r_u->ctr.values         = enum_values;
7204
7205
7206
7207 done:
7208         free_a_printer(&printer, 2);
7209
7210         return result;
7211 }
7212
7213 /****************************************************************************
7214 ****************************************************************************/
7215
7216 /* Disabled because it doesn't fix the bug I am looking at but it would be
7217    a shame to throw away the code. -tpot */
7218
7219 #if 0
7220
7221 static void fill_printprocessordirectory_1(PRINTPROCESSOR_DIRECTORY_1 *info, char *name)
7222 {
7223         init_unistr(&info->name, name);
7224 }
7225
7226 static WERROR getprintprocessordirectory_level_1(UNISTR2 *name,
7227                                                  UNISTR2 *environment,
7228                                                  NEW_BUFFER *buffer,
7229                                                  uint32 offered,
7230                                                  uint32 *needed)
7231 {
7232         pstring path;
7233         pstring long_archi;
7234         pstring short_archi;
7235         PRINTPROCESSOR_DIRECTORY_1 *info=NULL;
7236
7237         unistr2_to_ascii(long_archi, environment, sizeof(long_archi)-1);
7238
7239         if (get_short_archi(short_archi, long_archi)==False)
7240                 return WERR_INVALID_ENVIRONMENT;
7241
7242         if((info=(PRINTPROCESSOR_DIRECTORY_1 *)malloc(sizeof(PRINTPROCESSOR_DIRECTORY_1))) == NULL)
7243                 return WERR_NOMEM;
7244
7245         /* Not sure what to return here - are UNC names valid here?.
7246            Windows returns the string: C:\WINNT\System32\spool\PRTPROCS\W32X86
7247            which is pretty bogus for a RPC. */
7248
7249         slprintf(path, sizeof(path)-1, "\\\\%s\\print$\\%s", get_called_name(), short_archi);
7250
7251         DEBUG(4,("print processor directory: [%s]\n", path));
7252
7253         fill_printprocessordirectory_1(info, path);
7254
7255         *needed += spoolss_size_printprocessordirectory_info_1(info);
7256
7257         if (!alloc_buffer_size(buffer, *needed)) {
7258                 safe_free(info);
7259                 return WERR_INSUFFICIENT_BUFFER;
7260         }
7261
7262         smb_io_printprocessordirectory_1("", buffer, info, 0);
7263
7264         safe_free(info);
7265
7266         if (*needed > offered)
7267                 return WERR_INSUFFICIENT_BUFFER;
7268         else
7269                 return WERR_OK;
7270 }
7271
7272 WERROR _spoolss_getprintprocessordirectory(pipes_struct *p, SPOOL_Q_GETPRINTPROCESSORDIRECTORY *q_u, SPOOL_R_GETPRINTPROCESSORDIRECTORY *r_u)
7273 {
7274         uint32 level = q_u->level;
7275         NEW_BUFFER *buffer = NULL;
7276         uint32 offered = q_u->offered;
7277         uint32 *needed = &r_u->needed;
7278
7279         /* that's an [in out] buffer */
7280         spoolss_move_buffer(q_u->buffer, &r_u->buffer);
7281         buffer = r_u->buffer;
7282
7283         DEBUG(5,("_spoolss_getprintprocessordirectory\n"));
7284
7285         *needed=0;
7286
7287         switch(level) {
7288         case 1:
7289                 return getprintprocessordirectory_level_1
7290                   (&q_u->name, &q_u->environment, buffer, offered, needed);
7291         default:
7292                 return WERR_UNKNOWN_LEVEL;
7293         }
7294
7295         return WERR_ACCESS_DENIED;
7296 }
7297
7298 #endif