source/rpc_server/srv_spoolss_nt.c

   1 #define OLD_NTDOMAIN 1
   2 /*
   3  *  Unix SMB/Netbios implementation.
   4  *  Version 1.9.
   5  *  RPC Pipe client / server routines
   6  *  Copyright (C) Andrew Tridgell              1992-2000,
   7  *  Copyright (C) Luke Kenneth Casson Leighton 1996-2000,
   8  *  Copyright (C) Jean François Micouleau      1998-2000.
   9  *
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License as published by
  12  *  the Free Software Foundation; either version 2 of the License, or
  13  *  (at your option) any later version.
  14  *
  15  *  This program is distributed in the hope that it will be useful,
  16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  *  GNU General Public License for more details.
  19  *
  20  *  You should have received a copy of the GNU General Public License
  21  *  along with this program; if not, write to the Free Software
  22  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23  */
  24
  25
  26 #include "includes.h"
  27
  28 #ifndef MANGLE_DRIVER_PATH
  29 #define MANGLE_DRIVER_PATH 0
  30 #endif
  31
  32 extern int DEBUGLEVEL;
  33 extern pstring global_myname;
  34
  35 #ifndef MAX_OPEN_PRINTER_EXS
  36 #define MAX_OPEN_PRINTER_EXS 50
  37 #endif
  38
  39 #define PRINTER_HANDLE_IS_PRINTER       0
  40 #define PRINTER_HANDLE_IS_PRINTSERVER   1
  41
  42 /* structure to store the printer handles */
  43 /* and a reference to what it's pointing to */
  44 /* and the notify info asked about */
  45 /* that's the central struct */
  46 typedef struct _Printer{
  47         ubi_dlNode Next;
  48         ubi_dlNode Prev;
  49
  50         BOOL open;
  51         BOOL document_started;
  52         BOOL page_started;
  53         int jobid; /* jobid in printing backend */
  54         POLICY_HND printer_hnd;
  55         BOOL printer_type;
  56         union {
  57                 fstring printername;
  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         } notify;
  69         struct {
  70                 fstring machine;
  71                 fstring user;
  72         } client;
  73 } Printer_entry;
  74
  75 typedef struct _counter_printer_0 {
  76         ubi_dlNode Next;
  77         ubi_dlNode Prev;
  78
  79         int snum;
  80         uint32 counter;
  81 } counter_printer_0;
  82
  83 static ubi_dlList Printer_list;
  84 static ubi_dlList counter_list;
  85
  86
  87 #define OPEN_HANDLE(pnum)    ((pnum!=NULL) && (pnum->open!=False))
  88
  89 /* translate between internal status numbers and NT status numbers */
  90 static int nt_printj_status(int v)
  91 {
  92         switch (v) {
  93         case LPQ_PAUSED:
  94                 return PRINTER_STATUS_PAUSED;
  95         case LPQ_QUEUED:
  96         case LPQ_SPOOLING:
  97         case LPQ_PRINTING:
  98                 return 0;
  99         }
 100         return 0;
 101 }
 102
 103 static int nt_printq_status(int v)
 104 {
 105         switch (v) {
 106         case LPQ_PAUSED:
 107                 return PRINTER_STATUS_ERROR;
 108         case LPQ_QUEUED:
 109         case LPQ_SPOOLING:
 110         case LPQ_PRINTING:
 111                 return 0;
 112         }
 113         return 0;
 114 }
 115
 116 /****************************************************************************
 117   initialise printer handle states...
 118 ****************************************************************************/
 119 void init_printer_hnd(void)
 120 {
 121         ubi_dlInitList(&Printer_list);
 122         ubi_dlInitList(&counter_list);
 123 }
 124
 125 /****************************************************************************
 126   create a unique printer handle
 127 ****************************************************************************/
 128 static void create_printer_hnd(POLICY_HND *hnd)
 129 {
 130         static uint32 prt_hnd_low  = 0;
 131         static uint32 prt_hnd_high = 0;
 132
 133         if (hnd == NULL) return;
 134
 135         /* i severely doubt that prt_hnd_high will ever be non-zero... */
 136         prt_hnd_low++;
 137         if (prt_hnd_low == 0) prt_hnd_high++;
 138
 139         SIVAL(hnd->data, 0 , 0x0);          /* first bit must be null */
 140         SIVAL(hnd->data, 4 , prt_hnd_low ); /* second bit is incrementing */
 141         SIVAL(hnd->data, 8 , prt_hnd_high); /* second bit is incrementing */
 142         SIVAL(hnd->data, 12, time(NULL));   /* something random */
 143         SIVAL(hnd->data, 16, sys_getpid());     /* something more random */
 144 }
 145
 146 /****************************************************************************
 147   find printer index by handle
 148 ****************************************************************************/
 149 static Printer_entry *find_printer_index_by_hnd(const POLICY_HND *hnd)
 150 {
 151         Printer_entry *find_printer;
 152
 153         find_printer = (Printer_entry *)ubi_dlFirst(&Printer_list);
 154
 155         for(; find_printer; find_printer = (Printer_entry *)ubi_dlNext(find_printer)) {
 156
 157                 if (memcmp(&(find_printer->printer_hnd), hnd, sizeof(*hnd)) == 0) {
 158                         DEBUG(4,("Found printer handle \n"));
 159                         /*dump_data(4, hnd->data, sizeof(hnd->data));*/
 160                         return find_printer;
 161                 }
 162         }
 163
 164         DEBUG(3,("Whoops, Printer handle not found: "));
 165         /*dump_data(4, hnd->data, sizeof(hnd->data));*/
 166         return NULL;
 167 }
 168
 169 /****************************************************************************
 170   clear an handle
 171 ****************************************************************************/
 172 static void clear_handle(POLICY_HND *hnd)
 173 {
 174         ZERO_STRUCTP(hnd);
 175 }
 176
 177 /****************************************************************************
 178   close printer index by handle
 179 ****************************************************************************/
 180 static BOOL close_printer_handle(POLICY_HND *hnd)
 181 {
 182         Printer_entry *Printer = find_printer_index_by_hnd(hnd);
 183
 184         if (!OPEN_HANDLE(Printer)) {
 185                 DEBUG(3,("Error closing printer handle\n"));
 186                 return False;
 187         }
 188
 189         Printer->open=False;
 190         Printer->notify.flags=0;
 191         Printer->notify.options=0;
 192         Printer->notify.localmachine[0]='\0';
 193         Printer->notify.printerlocal=0;
 194         safe_free(Printer->notify.option);
 195         Printer->notify.option=NULL;
 196
 197         clear_handle(hnd);
 198
 199         ubi_dlRemThis(&Printer_list, Printer);
 200
 201         safe_free(Printer);
 202
 203         return True;
 204 }
 205
 206 /****************************************************************************
 207   delete a printer given a handle
 208 ****************************************************************************/
 209 static BOOL delete_printer_handle(POLICY_HND *hnd)
 210 {
 211         Printer_entry *Printer = find_printer_index_by_hnd(hnd);
 212
 213         if (!OPEN_HANDLE(Printer)) {
 214                 DEBUG(3,("Error closing printer handle\n"));
 215                 return False;
 216         }
 217
 218         if (del_a_printer(Printer->dev.printername) != 0) {
 219                 DEBUG(3,("Error deleting printer %s\n", Printer->dev.printername));
 220                 return False;
 221         }
 222
 223         return True;
 224 }
 225
 226 /****************************************************************************
 227   return the snum of a printer corresponding to an handle
 228 ****************************************************************************/
 229 static BOOL get_printer_snum(const POLICY_HND *hnd, int *number)
 230 {
 231         Printer_entry *Printer = find_printer_index_by_hnd(hnd);
 232
 233         if (!OPEN_HANDLE(Printer)) {
 234                 DEBUG(3,("Error getting printer - take a nap quickly !\n"));
 235                 return False;
 236         }
 237
 238         switch (Printer->printer_type) {
 239         case PRINTER_HANDLE_IS_PRINTER:
 240                 DEBUG(4,("short name:%s\n", Printer->dev.printername));
 241                 *number = print_queue_snum(Printer->dev.printername);
 242                 return (*number != -1);
 243         case PRINTER_HANDLE_IS_PRINTSERVER:
 244                 return False;
 245                 break;
 246         default:
 247                 return False;
 248                 break;
 249         }
 250 }
 251
 252 /****************************************************************************
 253   find first available printer slot. creates a printer handle for you.
 254  ****************************************************************************/
 255 static BOOL open_printer_hnd(POLICY_HND *hnd)
 256 {
 257         Printer_entry *new_printer;
 258
 259         if((new_printer=(Printer_entry *)malloc(sizeof(Printer_entry))) == NULL)
 260                 return False;
 261
 262         ZERO_STRUCTP(new_printer);
 263
 264         new_printer->open = True;
 265         new_printer->notify.option=NULL;
 266
 267         memcpy(&new_printer->printer_hnd, hnd, sizeof(*hnd));
 268
 269         ubi_dlAddHead( &Printer_list, (ubi_dlNode *)new_printer);
 270
 271         return True;
 272 }
 273
 274 /****************************************************************************
 275   set printer handle type.
 276 ****************************************************************************/
 277 static BOOL set_printer_hnd_accesstype(POLICY_HND *hnd, uint32 access_required)
 278 {
 279         Printer_entry *Printer = find_printer_index_by_hnd(hnd);
 280
 281         if (!OPEN_HANDLE(Printer)) {
 282                 DEBUG(4,("Error setting printer type=%x", access_required));
 283                 return False;
 284         }
 285
 286         DEBUG(4,("Setting printer access=%x\n", access_required));
 287         Printer->access = access_required;
 288         return True;
 289 }
 290
 291 /****************************************************************************
 292   set printer handle type.
 293   check if it's \\server or \\server\printer
 294 ****************************************************************************/
 295 static BOOL set_printer_hnd_printertype(POLICY_HND *hnd, char *printername)
 296 {
 297         Printer_entry *Printer = find_printer_index_by_hnd(hnd);
 298
 299         if (!OPEN_HANDLE(Printer)) {
 300                 DEBUGADD(4,("Error setting printer name %s", printername));
 301                 return False;
 302         }
 303
 304         DEBUG(3,("Setting printer type=%s\n", printername));
 305
 306         if ( strlen(printername) < 3 ) {
 307                 DEBUGADD(4,("A print server must have at least 1 char ! %s\n", printername));
 308                 return False;
 309         }
 310
 311         /* it's a print server */
 312         if (!strchr(printername+2, '\\')) {
 313                 DEBUGADD(4,("Printer is a print server\n"));
 314                 Printer->printer_type = PRINTER_HANDLE_IS_PRINTSERVER;
 315                 return True;
 316         }
 317         /* it's a printer */
 318         else {
 319                 DEBUGADD(4,("Printer is a printer\n"));
 320                 Printer->printer_type = PRINTER_HANDLE_IS_PRINTER;
 321                 return True;
 322         }
 323
 324         return False;
 325 }
 326
 327 /****************************************************************************
 328   set printer handle printername.
 329 ****************************************************************************/
 330 static BOOL set_printer_hnd_printername(POLICY_HND *hnd, char *printername)
 331 {
 332         Printer_entry *Printer = find_printer_index_by_hnd(hnd);
 333         NT_PRINTER_INFO_LEVEL *printer = NULL;
 334         int snum;
 335         int n_services=lp_numservices();
 336         char *aprinter;
 337         BOOL found=False;
 338
 339         if (!OPEN_HANDLE(Printer)) {
 340                 DEBUG(0,("Error setting printer name=%s\n", printername));
 341                 return False;
 342         }
 343
 344         DEBUG(4,("Setting printer name=%s (len=%d)\n", printername, strlen(printername)));
 345
 346         if (Printer->printer_type==PRINTER_HANDLE_IS_PRINTSERVER) {
 347                 ZERO_STRUCT(Printer->dev.printerservername);
 348                 strncpy(Printer->dev.printerservername, printername, strlen(printername));
 349                 return True;
 350         }
 351
 352         if (Printer->printer_type!=PRINTER_HANDLE_IS_PRINTER)
 353                 return False;
 354
 355         aprinter=strchr(printername+2, '\\');
 356         aprinter++;
 357
 358         DEBUGADD(5,("searching for [%s] (len=%d)\n", aprinter, strlen(aprinter)));
 359
 360         /*
 361          * store the Samba share name in it
 362          * in back we have the long printer name
 363          * need to iterate all the snum and do a
 364          * get_a_printer each time to find the printer
 365          * faster to do it here than later.
 366          */
 367
 368         for (snum=0;snum<n_services && found==False;snum++) {
 369
 370                 if ( !(lp_snum_ok(snum) && lp_print_ok(snum) ) )
 371                         continue;
 372
 373                 DEBUGADD(5,("share:%s\n",lp_servicename(snum)));
 374
 375                 if (get_a_printer(&printer, 2, lp_servicename(snum))!=0)
 376                         continue;
 377
 378                 DEBUG(10,("set_printer_hnd_printername: printername [%s], aprinter [%s]\n",
 379                                 printer->info_2->printername, aprinter ));
 380
 381                 if ( strlen(printer->info_2->printername) != strlen(aprinter) ) {
 382                         free_a_printer(&printer, 2);
 383                         continue;
 384                 }
 385
 386                 if ( strncasecmp(printer->info_2->printername, aprinter, strlen(aprinter)))  {
 387                         free_a_printer(&printer, 2);
 388                         continue;
 389                 }
 390
 391                 found=True;
 392         }
 393
 394         /*
 395          * if we haven't found a printer with the given printername
 396          * then it can be a share name as you can open both \\server\printer and
 397          * \\server\share
 398          */
 399
 400         /*
 401          * we still check if the printer description file exists as NT won't be happy
 402          * if we reply OK in the openprinter call and can't reply in the subsequent RPC calls
 403          */
 404
 405         if (found==False) {
 406                 DEBUGADD(5,("Printer not found, checking for share now\n"));
 407
 408                 for (snum=0;snum<n_services && found==False;snum++) {
 409
 410                         if ( !(lp_snum_ok(snum) && lp_print_ok(snum) ) )
 411                                 continue;
 412
 413                         DEBUGADD(5,("set_printer_hnd_printername: share:%s\n",lp_servicename(snum)));
 414
 415                         if (get_a_printer(&printer, 2, lp_servicename(snum))!=0)
 416                                 continue;
 417
 418                         DEBUG(10,("set_printer_hnd_printername: printername [%s], aprinter [%s]\n",
 419                                         printer->info_2->printername, aprinter ));
 420
 421                         if ( strlen(lp_servicename(snum)) != strlen(aprinter) ) {
 422                                 free_a_printer(&printer, 2);
 423                                 continue;
 424                         }
 425
 426                         if ( strncasecmp(lp_servicename(snum), aprinter, strlen(aprinter)))  {
 427                                 free_a_printer(&printer, 2);
 428                                 continue;
 429                         }
 430
 431                         found=True;
 432                 }
 433         }
 434
 435         if (found==False) {
 436                 DEBUGADD(4,("Printer not found\n"));
 437                 return False;
 438         }
 439
 440         snum--;
 441         DEBUGADD(4,("set_printer_hnd_printername: Printer found: %s -> %s[%x]\n",
 442                         printer->info_2->printername, lp_servicename(snum),snum));
 443
 444         ZERO_STRUCT(Printer->dev.printername);
 445         strncpy(Printer->dev.printername, lp_servicename(snum), strlen(lp_servicename(snum)));
 446
 447         free_a_printer(&printer, 2);
 448
 449         return True;
 450 }
 451
 452 /********************************************************************
 453  Return True is the handle is a print server.
 454  ********************************************************************/
 455 static BOOL handle_is_printserver(const POLICY_HND *handle)
 456 {
 457         Printer_entry *Printer=find_printer_index_by_hnd(handle);
 458
 459         if (!OPEN_HANDLE(Printer))
 460                 return False;
 461
 462         if (Printer->printer_type != PRINTER_HANDLE_IS_PRINTSERVER)
 463                 return False;
 464
 465         return True;
 466 }
 467
 468 /****************************************************************************
 469  allocate more memory for a BUFFER.
 470 ****************************************************************************/
 471 static BOOL alloc_buffer_size(NEW_BUFFER *buffer, uint32 buffer_size)
 472 {
 473         prs_struct *ps;
 474         uint32 extra_space;
 475         uint32 old_offset;
 476
 477         ps= &buffer->prs;
 478
 479         /* damn, I'm doing the reverse operation of prs_grow() :) */
 480         if (buffer_size < prs_data_size(ps))
 481                 extra_space=0;
 482         else
 483                 extra_space = buffer_size - prs_data_size(ps);
 484
 485         /*
 486          * save the offset and move to the end of the buffer
 487          * prs_grow() checks the extra_space against the offset
 488          */
 489         old_offset=prs_offset(ps);
 490         prs_set_offset(ps, prs_data_size(ps));
 491
 492         if (!prs_grow(ps, extra_space))
 493                 return False;
 494
 495         prs_set_offset(ps, old_offset);
 496
 497         buffer->string_at_end=prs_data_size(ps);
 498
 499         return True;
 500 }
 501
 502 /********************************************************************
 503  * spoolss_open_printer
 504  *
 505  * called from the spoolss dispatcher
 506  ********************************************************************/
 507 uint32 _spoolss_open_printer_ex( const UNISTR2 *printername,
 508                                  const PRINTER_DEFAULT *printer_default,
 509                                  uint32  user_switch, SPOOL_USER_CTR user_ctr,
 510                                  POLICY_HND *handle)
 511 {
 512         fstring name;
 513
 514         clear_handle(handle);
 515
 516         if (printername == NULL)
 517                 return ERROR_INVALID_PRINTER_NAME;
 518
 519         /* some sanity check because you can open a printer or a print server */
 520         /* aka: \\server\printer or \\server */
 521         unistr2_to_ascii(name, printername, sizeof(name)-1);
 522
 523         DEBUGADD(3,("checking name: %s\n",name));
 524
 525         create_printer_hnd(handle);
 526
 527         open_printer_hnd(handle);
 528
 529         if (!set_printer_hnd_printertype(handle, name)) {
 530                 close_printer_handle(handle);
 531                 return ERROR_INVALID_PRINTER_NAME;
 532         }
 533
 534         if (!set_printer_hnd_printername(handle, name)) {
 535                 close_printer_handle(handle);
 536                 return ERROR_INVALID_PRINTER_NAME;
 537         }
 538
 539 /*
 540         if (printer_default->datatype_ptr != NULL)
 541         {
 542                 unistr2_to_ascii(datatype, printer_default->datatype, sizeof(datatype)-1);
 543                 set_printer_hnd_datatype(handle, datatype);
 544         }
 545         else
 546                 set_printer_hnd_datatype(handle, "");
 547 */
 548
 549         if (!set_printer_hnd_accesstype(handle, printer_default->access_required)) {
 550                 close_printer_handle(handle);
 551                 return ERROR_ACCESS_DENIED;
 552         }
 553
 554         return NT_STATUS_NO_PROBLEMO;
 555 }
 556
 557 /****************************************************************************
 558 ****************************************************************************/
 559 static BOOL convert_printer_info(const SPOOL_PRINTER_INFO_LEVEL *uni,
 560                                 NT_PRINTER_INFO_LEVEL *printer, uint32 level)
 561 {
 562         switch (level) {
 563                 case 2:
 564                         uni_2_asc_printer_info_2(uni->info_2, &printer->info_2);
 565                         break;
 566                 default:
 567                         break;
 568         }
 569
 570         return True;
 571 }
 572
 573 static BOOL convert_printer_driver_info(const SPOOL_PRINTER_DRIVER_INFO_LEVEL *uni,
 574                                         NT_PRINTER_DRIVER_INFO_LEVEL *printer, uint32 level)
 575 {
 576         switch (level) {
 577                 case 3:
 578                         printer->info_3=NULL;
 579                         uni_2_asc_printer_driver_3(uni->info_3, &printer->info_3);
 580                         break;
 581                 case 6:
 582                         printer->info_6=NULL;
 583                         uni_2_asc_printer_driver_6(uni->info_6, &printer->info_6);
 584                         break;
 585                 default:
 586                         break;
 587         }
 588
 589         return True;
 590 }
 591
 592 static BOOL convert_devicemode(const DEVICEMODE *devmode, NT_DEVICEMODE *nt_devmode)
 593 {
 594         unistr_to_dos(nt_devmode->devicename, (const char *)devmode->devicename.buffer, 31);
 595         unistr_to_dos(nt_devmode->formname, (const char *)devmode->formname.buffer, 31);
 596
 597         nt_devmode->specversion=devmode->specversion;
 598         nt_devmode->driverversion=devmode->driverversion;
 599         nt_devmode->size=devmode->size;
 600         nt_devmode->driverextra=devmode->driverextra;
 601         nt_devmode->fields=devmode->fields;
 602         nt_devmode->orientation=devmode->orientation;
 603         nt_devmode->papersize=devmode->papersize;
 604         nt_devmode->paperlength=devmode->paperlength;
 605         nt_devmode->paperwidth=devmode->paperwidth;
 606         nt_devmode->scale=devmode->scale;
 607         nt_devmode->copies=devmode->copies;
 608         nt_devmode->defaultsource=devmode->defaultsource;
 609         nt_devmode->printquality=devmode->printquality;
 610         nt_devmode->color=devmode->color;
 611         nt_devmode->duplex=devmode->duplex;
 612         nt_devmode->yresolution=devmode->yresolution;
 613         nt_devmode->ttoption=devmode->ttoption;
 614         nt_devmode->collate=devmode->collate;
 615
 616         nt_devmode->logpixels=devmode->logpixels;
 617         nt_devmode->bitsperpel=devmode->bitsperpel;
 618         nt_devmode->pelswidth=devmode->pelswidth;
 619         nt_devmode->pelsheight=devmode->pelsheight;
 620         nt_devmode->displayflags=devmode->displayflags;
 621         nt_devmode->displayfrequency=devmode->displayfrequency;
 622         nt_devmode->icmmethod=devmode->icmmethod;
 623         nt_devmode->icmintent=devmode->icmintent;
 624         nt_devmode->mediatype=devmode->mediatype;
 625         nt_devmode->dithertype=devmode->dithertype;
 626         nt_devmode->reserved1=devmode->reserved1;
 627         nt_devmode->reserved2=devmode->reserved2;
 628         nt_devmode->panningwidth=devmode->panningwidth;
 629         nt_devmode->panningheight=devmode->panningheight;
 630
 631         if (nt_devmode->driverextra != 0) {
 632                 /* if we had a previous private delete it and make a new one */
 633                 safe_free(nt_devmode->private);
 634                 if((nt_devmode->private=(uint8 *)malloc(nt_devmode->driverextra * sizeof(uint8))) == NULL)
 635                         return False;
 636                 memcpy(nt_devmode->private, devmode->private, nt_devmode->driverextra);
 637         }
 638
 639         return True;
 640 }
 641
 642 /********************************************************************
 643  * api_spoolss_closeprinter
 644  ********************************************************************/
 645 uint32 _spoolss_closeprinter(POLICY_HND *handle)
 646 {
 647         if (!close_printer_handle(handle))
 648                 return ERROR_INVALID_HANDLE;
 649
 650         return NT_STATUS_NO_PROBLEMO;
 651 }
 652
 653 /********************************************************************
 654  * api_spoolss_deleteprinter
 655  ********************************************************************/
 656 uint32 _spoolss_deleteprinter(POLICY_HND *handle)
 657 {
 658         if (!delete_printer_handle(handle))
 659                 return ERROR_INVALID_HANDLE;
 660
 661         return NT_STATUS_NO_PROBLEMO;
 662 }
 663
 664 /********************************************************************
 665  GetPrinterData on a printer server Handle.
 666 ********************************************************************/
 667 static BOOL getprinterdata_printer_server(fstring value, uint32 *type, uint8 **data, uint32 *needed, uint32 in_size)
 668 {
 669         int i;
 670
 671         DEBUG(8,("getprinterdata_printer_server:%s\n", value));
 672
 673         if (!strcmp(value, "BeepEnabled")) {
 674                 *type = 0x4;
 675                 if((*data = (uint8 *)malloc( 4*sizeof(uint8) )) == NULL)
 676                         return False;
 677                 SIVAL(*data, 0, 0x01);
 678                 *needed = 0x4;
 679                 return True;
 680         }
 681
 682         if (!strcmp(value, "EventLog")) {
 683                 *type = 0x4;
 684                 if((*data = (uint8 *)malloc( 4*sizeof(uint8) )) == NULL)
 685                         return False;
 686                 SIVAL(*data, 0, 0x1B);
 687                 *needed = 0x4;
 688                 return True;
 689         }
 690
 691         if (!strcmp(value, "NetPopup")) {
 692                 *type = 0x4;
 693                 if((*data = (uint8 *)malloc( 4*sizeof(uint8) )) == NULL)
 694                         return False;
 695                 SIVAL(*data, 0, 0x01);
 696                 *needed = 0x4;
 697                 return True;
 698         }
 699
 700         if (!strcmp(value, "MajorVersion")) {
 701                 *type = 0x4;
 702                 if((*data = (uint8 *)malloc( 4*sizeof(uint8) )) == NULL)
 703                         return False;
 704                 SIVAL(*data, 0, 0x02);
 705                 *needed = 0x4;
 706                 return True;
 707         }
 708
 709         if (!strcmp(value, "DefaultSpoolDirectory")) {
 710                 pstring string="You are using a Samba server";
 711                 *type = 0x1;
 712                 *needed = 2*(strlen(string)+1);
 713                 if((*data  = (uint8 *)malloc( ((*needed > in_size) ? *needed:in_size) *sizeof(uint8))) == NULL)
 714                         return False;
 715                 memset(*data, 0, (*needed > in_size) ? *needed:in_size);
 716
 717                 /* it's done by hand ready to go on the wire */
 718                 for (i=0; i<strlen(string); i++) {
 719                         (*data)[2*i]=string[i];
 720                         (*data)[2*i+1]='\0';
 721                 }
 722                 return True;
 723         }
 724
 725         if (!strcmp(value, "Architecture")) {
 726                 pstring string="Windows NT x86";
 727                 *type = 0x1;
 728                 *needed = 2*(strlen(string)+1);
 729                 if((*data  = (uint8 *)malloc( ((*needed > in_size) ? *needed:in_size) *sizeof(uint8))) == NULL)
 730                         return False;
 731                 memset(*data, 0, (*needed > in_size) ? *needed:in_size);
 732                 for (i=0; i<strlen(string); i++) {
 733                         (*data)[2*i]=string[i];
 734                         (*data)[2*i+1]='\0';
 735                 }
 736                 return True;
 737         }
 738
 739         return False;
 740 }
 741
 742 /********************************************************************
 743  GetPrinterData on a printer Handle.
 744 ********************************************************************/
 745 static BOOL getprinterdata_printer(const POLICY_HND *handle,
 746                                 fstring value, uint32 *type,
 747                                 uint8 **data, uint32 *needed, uint32 in_size )
 748 {
 749         NT_PRINTER_INFO_LEVEL *printer = NULL;
 750         int snum=0;
 751         uint8 *idata=NULL;
 752         uint32 len;
 753         Printer_entry *Printer = find_printer_index_by_hnd(handle);
 754
 755         DEBUG(5,("getprinterdata_printer\n"));
 756
 757         if (!OPEN_HANDLE(Printer))
 758                 return False;
 759
 760         if(!get_printer_snum(handle, &snum))
 761                 return False;
 762
 763         if(get_a_printer(&printer, 2, lp_servicename(snum)) != 0)
 764                 return False;
 765
 766         if (!get_specific_param(*printer, 2, value, &idata, type, &len)) {
 767                 free_a_printer(&printer, 2);
 768                 return False;
 769         }
 770
 771         free_a_printer(&printer, 2);
 772
 773         DEBUG(5,("getprinterdata_printer:allocating %d\n", in_size));
 774
 775         if (in_size) {
 776                 if((*data  = (uint8 *)malloc( in_size *sizeof(uint8) )) == NULL) {
 777                         return False;
 778                 }
 779
 780                 memset(*data, 0, in_size *sizeof(uint8));
 781                 /* copy the min(in_size, len) */
 782                 memcpy(*data, idata, (len>in_size)?in_size:len *sizeof(uint8));
 783         } else {
 784                 *data = NULL;
 785         }
 786
 787         *needed = len;
 788
 789         DEBUG(5,("getprinterdata_printer:copy done\n"));
 790
 791         safe_free(idata);
 792
 793         return True;
 794 }
 795
 796 /********************************************************************
 797  * spoolss_getprinterdata
 798  ********************************************************************/
 799 uint32 _spoolss_getprinterdata(const POLICY_HND *handle, UNISTR2 *valuename,
 800                                 uint32 in_size,
 801                                 uint32 *type,
 802                                 uint32 *out_size,
 803                                 uint8 **data,
 804                                 uint32 *needed)
 805 {
 806         fstring value;
 807         BOOL found=False;
 808         Printer_entry *Printer = find_printer_index_by_hnd(handle);
 809
 810         /*
 811          * Reminder: when it's a string, the length is in BYTES
 812          * even if UNICODE is negociated.
 813          *
 814          * JFM, 4/19/1999
 815          */
 816
 817         *out_size=in_size;
 818
 819         /* in case of problem, return some default values */
 820         *needed=0;
 821         *type=0;
 822
 823         DEBUG(4,("_spoolss_getprinterdata\n"));
 824
 825         if (!OPEN_HANDLE(Printer)) {
 826                 if((*data=(uint8 *)malloc(4*sizeof(uint8))) == NULL)
 827                         return ERROR_NOT_ENOUGH_MEMORY;
 828                 return ERROR_INVALID_HANDLE;
 829         }
 830
 831         unistr2_to_ascii(value, valuename, sizeof(value)-1);
 832
 833         if (handle_is_printserver(handle))
 834                 found=getprinterdata_printer_server(value, type, data, needed, *out_size);
 835         else
 836                 found=getprinterdata_printer(handle, value, type, data, needed, *out_size);
 837
 838         if (found==False) {
 839                 DEBUG(5, ("value not found, allocating %d\n", *out_size));
 840                 /* reply this param doesn't exist */
 841                 if (*out_size) {
 842                         if((*data=(uint8 *)malloc(*out_size*sizeof(uint8))) == NULL)
 843                                 return ERROR_NOT_ENOUGH_MEMORY;
 844                         memset(*data, '\0', *out_size*sizeof(uint8));
 845                 } else {
 846                         *data = NULL;
 847                 }
 848
 849                 return ERROR_INVALID_PARAMETER;
 850         }
 851
 852         if (*needed > *out_size)
 853                 return ERROR_INSUFFICIENT_BUFFER;
 854         else
 855                 return NT_STATUS_NO_PROBLEMO;
 856 }
 857
 858 /********************************************************************
 859  * _spoolss_rffpcnex
 860  * ReplyFindFirstPrinterChangeNotifyEx
 861  *
 862  * jfmxxxx: before replying OK: status=0
 863  * should do a rpc call to the workstation asking ReplyOpenPrinter
 864  * have to code it, later.
 865  *
 866  * in fact ReplyOpenPrinter is the changenotify equivalent on the spoolss pipe
 867  * called from api_spoolss_rffpcnex
 868  ********************************************************************/
 869 uint32 _spoolss_rffpcnex(const POLICY_HND *handle, uint32 flags, uint32 options,
 870                          const UNISTR2 *localmachine, uint32 printerlocal,
 871                          SPOOL_NOTIFY_OPTION *option)
 872 {
 873         /* store the notify value in the printer struct */
 874
 875         Printer_entry *Printer=find_printer_index_by_hnd(handle);
 876
 877         if (!OPEN_HANDLE(Printer))
 878                 return ERROR_INVALID_HANDLE;
 879
 880         Printer->notify.flags=flags;
 881         Printer->notify.options=options;
 882         Printer->notify.printerlocal=printerlocal;
 883         Printer->notify.option=option;
 884         unistr2_to_ascii(Printer->notify.localmachine, localmachine, sizeof(Printer->notify.localmachine)-1);
 885
 886         return NT_STATUS_NO_PROBLEMO;
 887 }
 888
 889 /*******************************************************************
 890  * fill a notify_info_data with the servername
 891  ********************************************************************/
 892 static void spoolss_notify_server_name(int snum, SPOOL_NOTIFY_INFO_DATA *data, print_queue_struct *queue,
 893                                                                                 NT_PRINTER_INFO_LEVEL *printer)
 894 {
 895         pstring temp_name;
 896
 897         snprintf(temp_name, sizeof(temp_name)-1, "\\\\%s", global_myname);
 898
 899         data->notify_data.data.length= (uint32)((dos_PutUniCode((char *)data->notify_data.data.string,
 900                                         temp_name, sizeof(data->notify_data.data.string), True) - sizeof(uint16))/sizeof(uint16));
 901 }
 902
 903 /*******************************************************************
 904  * fill a notify_info_data with the servicename
 905  * jfmxxxx: it's incorrect should be long_printername
 906  ********************************************************************/
 907 static void spoolss_notify_printer_name(int snum, SPOOL_NOTIFY_INFO_DATA *data, print_queue_struct *queue,
 908                                                                                 NT_PRINTER_INFO_LEVEL *printer)
 909 {
 910 /*
 911         data->notify_data.data.length=strlen(lp_servicename(snum));
 912         dos_PutUniCode(data->notify_data.data.string, lp_servicename(snum), sizeof(data->notify_data.data.string), True);
 913 */
 914         data->notify_data.data.length=(uint32)((dos_PutUniCode((char *)data->notify_data.data.string,
 915                                 printer->info_2->printername, sizeof(data->notify_data.data.string), True) - sizeof(uint16))/sizeof(uint16));
 916 }
 917
 918 /*******************************************************************
 919  * fill a notify_info_data with the servicename
 920  ********************************************************************/
 921 static void spoolss_notify_share_name(int snum, SPOOL_NOTIFY_INFO_DATA *data, print_queue_struct *queue, NT_PRINTER_INFO_LEVEL *printer)
 922 {
 923         data->notify_data.data.length=(uint32)((dos_PutUniCode((char *)data->notify_data.data.string,
 924                         lp_servicename(snum), sizeof(data->notify_data.data.string),True) - sizeof(uint16))/sizeof(uint16));
 925 }
 926
 927 /*******************************************************************
 928  * fill a notify_info_data with the port name
 929  ********************************************************************/
 930 static void spoolss_notify_port_name(int snum, SPOOL_NOTIFY_INFO_DATA *data, print_queue_struct *queue, NT_PRINTER_INFO_LEVEL *printer)
 931 {
 932         /* even if it's strange, that's consistant in all the code */
 933
 934         data->notify_data.data.length=(uint32)((dos_PutUniCode((char *)data->notify_data.data.string,
 935                 lp_servicename(snum), sizeof(data->notify_data.data.string), True)  - sizeof(uint16))/sizeof(uint16));
 936 }
 937
 938 /*******************************************************************
 939  * fill a notify_info_data with the printername
 940  * jfmxxxx: it's incorrect, should be lp_printerdrivername()
 941  * but it doesn't exist, have to see what to do
 942  ********************************************************************/
 943 static void spoolss_notify_driver_name(int snum, SPOOL_NOTIFY_INFO_DATA *data, print_queue_struct *queue, NT_PRINTER_INFO_LEVEL *printer)
 944 {
 945         data->notify_data.data.length=(uint32)((dos_PutUniCode((char *)data->notify_data.data.string,
 946                         printer->info_2->drivername, sizeof(data->notify_data.data.string)-1, True)  - sizeof(uint16))/sizeof(uint16));
 947 }
 948
 949 /*******************************************************************
 950  * fill a notify_info_data with the comment
 951  ********************************************************************/
 952 static void spoolss_notify_comment(int snum, SPOOL_NOTIFY_INFO_DATA *data, print_queue_struct *queue, NT_PRINTER_INFO_LEVEL *printer)
 953 {
 954         data->notify_data.data.length=(uint32)((dos_PutUniCode((char *)data->notify_data.data.string,
 955                         lp_comment(snum), sizeof(data->notify_data.data.string)-1, True)  - sizeof(uint16))/sizeof(uint16));
 956 }
 957
 958 /*******************************************************************
 959  * fill a notify_info_data with the comment
 960  * jfm:xxxx incorrect, have to create a new smb.conf option
 961  * location = "Room 1, floor 2, building 3"
 962  ********************************************************************/
 963 static void spoolss_notify_location(int snum, SPOOL_NOTIFY_INFO_DATA *data, print_queue_struct *queue, NT_PRINTER_INFO_LEVEL *printer)
 964 {
 965         data->notify_data.data.length=(uint32)((dos_PutUniCode((char *)data->notify_data.data.string,
 966                         printer->info_2->location, sizeof(data->notify_data.data.string)-1, True)  - sizeof(uint16))/sizeof(uint16));
 967 }
 968
 969 /*******************************************************************
 970  * fill a notify_info_data with the device mode
 971  * jfm:xxxx don't to it for know but that's a real problem !!!
 972  ********************************************************************/
 973 static void spoolss_notify_devmode(int snum, SPOOL_NOTIFY_INFO_DATA *data, print_queue_struct *queue, NT_PRINTER_INFO_LEVEL *printer)
 974 {
 975 }
 976
 977 /*******************************************************************
 978  * fill a notify_info_data with the separator file name
 979  * jfm:xxxx just return no file could add an option to smb.conf
 980  * separator file = "separator.txt"
 981  ********************************************************************/
 982 static void spoolss_notify_sepfile(int snum, SPOOL_NOTIFY_INFO_DATA *data, print_queue_struct *queue, NT_PRINTER_INFO_LEVEL *printer)
 983 {
 984         data->notify_data.data.length=(uint32)((dos_PutUniCode((char *)data->notify_data.data.string,
 985                         printer->info_2->sepfile, sizeof(data->notify_data.data.string)-1,True)  - sizeof(uint16))/sizeof(uint16));
 986 }
 987
 988 /*******************************************************************
 989  * fill a notify_info_data with the print processor
 990  * jfm:xxxx return always winprint to indicate we don't do anything to it
 991  ********************************************************************/
 992 static void spoolss_notify_print_processor(int snum, SPOOL_NOTIFY_INFO_DATA *data, print_queue_struct *queue, NT_PRINTER_INFO_LEVEL *printer)
 993 {
 994         data->notify_data.data.length=(uint32)((dos_PutUniCode((char *)data->notify_data.data.string,
 995                         printer->info_2->printprocessor, sizeof(data->notify_data.data.string)-1, True)  - sizeof(uint16))/sizeof(uint16));
 996 }
 997
 998 /*******************************************************************
 999  * fill a notify_info_data with the print processor options
1000  * jfm:xxxx send an empty string
1001  ********************************************************************/
1002 static void spoolss_notify_parameters(int snum, SPOOL_NOTIFY_INFO_DATA *data, print_queue_struct *queue, NT_PRINTER_INFO_LEVEL *printer)
1003 {
1004         data->notify_data.data.length=(uint32)((dos_PutUniCode((char *)data->notify_data.data.string,
1005                         printer->info_2->parameters, sizeof(data->notify_data.data.string)-1, True)  - sizeof(uint16))/sizeof(uint16));
1006 }
1007
1008 /*******************************************************************
1009  * fill a notify_info_data with the data type
1010  * jfm:xxxx always send RAW as data type
1011  ********************************************************************/
1012 static void spoolss_notify_datatype(int snum, SPOOL_NOTIFY_INFO_DATA *data, print_queue_struct *queue, NT_PRINTER_INFO_LEVEL *printer)
1013 {
1014         data->notify_data.data.length=(uint32)((dos_PutUniCode((char *)data->notify_data.data.string,
1015                         printer->info_2->datatype, sizeof(data->notify_data.data.string)-1, True)  - sizeof(uint16))/sizeof(uint16));
1016 }
1017
1018 /*******************************************************************
1019  * fill a notify_info_data with the security descriptor
1020  * jfm:xxxx send an null pointer to say no security desc
1021  * have to implement security before !
1022  ********************************************************************/
1023 static void spoolss_notify_security_desc(int snum, SPOOL_NOTIFY_INFO_DATA *data, print_queue_struct *queue, NT_PRINTER_INFO_LEVEL *printer)
1024 {
1025         data->notify_data.data.length=0;
1026         data->notify_data.data.string[0]=0x00;
1027 }
1028
1029 /*******************************************************************
1030  * fill a notify_info_data with the attributes
1031  * jfm:xxxx a samba printer is always shared
1032  ********************************************************************/
1033 static void spoolss_notify_attributes(int snum, SPOOL_NOTIFY_INFO_DATA *data, print_queue_struct *queue, NT_PRINTER_INFO_LEVEL *printer)
1034 {
1035         data->notify_data.value[0] =   PRINTER_ATTRIBUTE_SHARED   \
1036                                      | PRINTER_ATTRIBUTE_LOCAL  \
1037                                      | PRINTER_ATTRIBUTE_RAW_ONLY ;
1038 }
1039
1040 /*******************************************************************
1041  * fill a notify_info_data with the priority
1042  ********************************************************************/
1043 static void spoolss_notify_priority(int snum, SPOOL_NOTIFY_INFO_DATA *data, print_queue_struct *queue, NT_PRINTER_INFO_LEVEL *printer)
1044 {
1045         data->notify_data.value[0] = printer->info_2->priority;
1046 }
1047
1048 /*******************************************************************
1049  * fill a notify_info_data with the default priority
1050  ********************************************************************/
1051 static void spoolss_notify_default_priority(int snum, SPOOL_NOTIFY_INFO_DATA *data, print_queue_struct *queue, NT_PRINTER_INFO_LEVEL *printer)
1052 {
1053         data->notify_data.value[0] = printer->info_2->default_priority;
1054 }
1055
1056 /*******************************************************************
1057  * fill a notify_info_data with the start time
1058  ********************************************************************/
1059 static void spoolss_notify_start_time(int snum, SPOOL_NOTIFY_INFO_DATA *data, print_queue_struct *queue, NT_PRINTER_INFO_LEVEL *printer)
1060 {
1061         data->notify_data.value[0] = printer->info_2->starttime;
1062 }
1063
1064 /*******************************************************************
1065  * fill a notify_info_data with the until time
1066  ********************************************************************/
1067 static void spoolss_notify_until_time(int snum, SPOOL_NOTIFY_INFO_DATA *data, print_queue_struct *queue, NT_PRINTER_INFO_LEVEL *printer)
1068 {
1069         data->notify_data.value[0] = printer->info_2->untiltime;
1070 }
1071
1072 /*******************************************************************
1073  * fill a notify_info_data with the status
1074  ********************************************************************/
1075 static void spoolss_notify_status(int snum, SPOOL_NOTIFY_INFO_DATA *data, print_queue_struct *queue, NT_PRINTER_INFO_LEVEL *printer)
1076 {
1077         int count;
1078         print_queue_struct *q=NULL;
1079         print_status_struct status;
1080
1081         memset(&status, 0, sizeof(status));
1082         count = print_queue_status(snum, &q, &status);
1083         data->notify_data.value[0]=(uint32) status.status;
1084         safe_free(q);
1085 }
1086
1087 /*******************************************************************
1088  * fill a notify_info_data with the number of jobs queued
1089  ********************************************************************/
1090 static void spoolss_notify_cjobs(int snum, SPOOL_NOTIFY_INFO_DATA *data, print_queue_struct *queue, NT_PRINTER_INFO_LEVEL *printer)
1091 {
1092         print_queue_struct *q=NULL;
1093         print_status_struct status;
1094
1095         memset(&status, 0, sizeof(status));
1096         data->notify_data.value[0] = print_queue_status(snum, &q, &status);
1097         safe_free(q);
1098 }
1099
1100 /*******************************************************************
1101  * fill a notify_info_data with the average ppm
1102  ********************************************************************/
1103 static void spoolss_notify_average_ppm(int snum, SPOOL_NOTIFY_INFO_DATA *data, print_queue_struct *queue, NT_PRINTER_INFO_LEVEL *printer)
1104 {
1105         /* always respond 8 pages per minutes */
1106         /* a little hard ! */
1107         data->notify_data.value[0] = printer->info_2->averageppm;
1108 }
1109
1110 /*******************************************************************
1111  * fill a notify_info_data with
1112  ********************************************************************/
1113 static void spoolss_notify_username(int snum, SPOOL_NOTIFY_INFO_DATA *data, print_queue_struct *queue, NT_PRINTER_INFO_LEVEL *printer)
1114 {
1115         data->notify_data.data.length=(uint32)((dos_PutUniCode((char *)data->notify_data.data.string,
1116                         queue->user, sizeof(data->notify_data.data.string)-1, True)  - sizeof(uint16))/sizeof(uint16));
1117 }
1118
1119 /*******************************************************************
1120  * fill a notify_info_data with
1121  ********************************************************************/
1122 static void spoolss_notify_job_status(int snum, SPOOL_NOTIFY_INFO_DATA *data, print_queue_struct *queue, NT_PRINTER_INFO_LEVEL *printer)
1123 {
1124         data->notify_data.value[0]=nt_printj_status(queue->status);
1125 }
1126
1127 /*******************************************************************
1128  * fill a notify_info_data with
1129  ********************************************************************/
1130 static void spoolss_notify_job_name(int snum, SPOOL_NOTIFY_INFO_DATA *data, print_queue_struct *queue, NT_PRINTER_INFO_LEVEL *printer)
1131 {
1132         data->notify_data.data.length=(uint32)((dos_PutUniCode((char *)data->notify_data.data.string,
1133                         queue->file, sizeof(data->notify_data.data.string)-1, True)  - sizeof(uint16))/sizeof(uint16));
1134 }
1135
1136 /*******************************************************************
1137  * fill a notify_info_data with
1138  ********************************************************************/
1139 static void spoolss_notify_job_status_string(int snum, SPOOL_NOTIFY_INFO_DATA *data, print_queue_struct *queue, NT_PRINTER_INFO_LEVEL *printer)
1140 {
1141         char *p = "unknown";
1142         switch (queue->status) {
1143         case LPQ_QUEUED:
1144                 p = "QUEUED";
1145                 break;
1146         case LPQ_PAUSED:
1147                 p = "PAUSED";
1148                 break;
1149         case LPQ_SPOOLING:
1150                 p = "SPOOLING";
1151                 break;
1152         case LPQ_PRINTING:
1153                 p = "PRINTING";
1154                 break;
1155         }
1156         data->notify_data.data.length=(uint32)((dos_PutUniCode((char *)data->notify_data.data.string,
1157                                 p, sizeof(data->notify_data.data.string)-1, True)  - sizeof(uint16))/sizeof(uint16));
1158 }
1159
1160 /*******************************************************************
1161  * fill a notify_info_data with
1162  ********************************************************************/
1163 static void spoolss_notify_job_time(int snum, SPOOL_NOTIFY_INFO_DATA *data, print_queue_struct *queue, NT_PRINTER_INFO_LEVEL *printer)
1164 {
1165         data->notify_data.value[0]=0x0;
1166 }
1167
1168 /*******************************************************************
1169  * fill a notify_info_data with
1170  ********************************************************************/
1171 static void spoolss_notify_job_size(int snum, SPOOL_NOTIFY_INFO_DATA *data, print_queue_struct *queue, NT_PRINTER_INFO_LEVEL *printer)
1172 {
1173         data->notify_data.value[0]=queue->size;
1174 }
1175
1176 /*******************************************************************
1177  * fill a notify_info_data with
1178  ********************************************************************/
1179 static void spoolss_notify_job_position(int snum, SPOOL_NOTIFY_INFO_DATA *data, print_queue_struct *queue, NT_PRINTER_INFO_LEVEL *printer)
1180 {
1181         data->notify_data.value[0]=queue->job;
1182 }
1183
1184 #define END 65535
1185
1186 struct s_notify_info_data_table
1187 {
1188         uint16 type;
1189         uint16 field;
1190         char *name;
1191         uint32 size;
1192         void (*fn) (int snum, SPOOL_NOTIFY_INFO_DATA *data,
1193                     print_queue_struct *queue,
1194                     NT_PRINTER_INFO_LEVEL *printer);
1195 };
1196
1197 struct s_notify_info_data_table notify_info_data_table[] =
1198 {
1199 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_SERVER_NAME,         "PRINTER_NOTIFY_SERVER_NAME",         POINTER,   spoolss_notify_server_name },
1200 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_PRINTER_NAME,        "PRINTER_NOTIFY_PRINTER_NAME",        POINTER,   spoolss_notify_printer_name },
1201 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_SHARE_NAME,          "PRINTER_NOTIFY_SHARE_NAME",          POINTER,   spoolss_notify_share_name },
1202 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_PORT_NAME,           "PRINTER_NOTIFY_PORT_NAME",           POINTER,   spoolss_notify_port_name },
1203 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_DRIVER_NAME,         "PRINTER_NOTIFY_DRIVER_NAME",         POINTER,   spoolss_notify_driver_name },
1204 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_COMMENT,             "PRINTER_NOTIFY_COMMENT",             POINTER,   spoolss_notify_comment },
1205 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_LOCATION,            "PRINTER_NOTIFY_LOCATION",            POINTER,   spoolss_notify_location },
1206 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_DEVMODE,             "PRINTER_NOTIFY_DEVMODE",             POINTER,   spoolss_notify_devmode },
1207 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_SEPFILE,             "PRINTER_NOTIFY_SEPFILE",             POINTER,   spoolss_notify_sepfile },
1208 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_PRINT_PROCESSOR,     "PRINTER_NOTIFY_PRINT_PROCESSOR",     POINTER,   spoolss_notify_print_processor },
1209 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_PARAMETERS,          "PRINTER_NOTIFY_PARAMETERS",          POINTER,   spoolss_notify_parameters },
1210 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_DATATYPE,            "PRINTER_NOTIFY_DATATYPE",            POINTER,   spoolss_notify_datatype },
1211 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_SECURITY_DESCRIPTOR, "PRINTER_NOTIFY_SECURITY_DESCRIPTOR", POINTER,   spoolss_notify_security_desc },
1212 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_ATTRIBUTES,          "PRINTER_NOTIFY_ATTRIBUTES",          ONE_VALUE, spoolss_notify_attributes },
1213 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_PRIORITY,            "PRINTER_NOTIFY_PRIORITY",            ONE_VALUE, spoolss_notify_priority },
1214 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_DEFAULT_PRIORITY,    "PRINTER_NOTIFY_DEFAULT_PRIORITY",    ONE_VALUE, spoolss_notify_default_priority },
1215 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_START_TIME,          "PRINTER_NOTIFY_START_TIME",          ONE_VALUE, spoolss_notify_start_time },
1216 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_UNTIL_TIME,          "PRINTER_NOTIFY_UNTIL_TIME",          ONE_VALUE, spoolss_notify_until_time },
1217 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_STATUS,              "PRINTER_NOTIFY_STATUS",              ONE_VALUE, spoolss_notify_status },
1218 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_STATUS_STRING,       "PRINTER_NOTIFY_STATUS_STRING",       POINTER,   NULL },
1219 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_CJOBS,               "PRINTER_NOTIFY_CJOBS",               ONE_VALUE, spoolss_notify_cjobs },
1220 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_AVERAGE_PPM,         "PRINTER_NOTIFY_AVERAGE_PPM",         ONE_VALUE, spoolss_notify_average_ppm },
1221 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_TOTAL_PAGES,         "PRINTER_NOTIFY_TOTAL_PAGES",         POINTER,   NULL },
1222 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_PAGES_PRINTED,       "PRINTER_NOTIFY_PAGES_PRINTED",       POINTER,   NULL },
1223 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_TOTAL_BYTES,         "PRINTER_NOTIFY_TOTAL_BYTES",         POINTER,   NULL },
1224 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_BYTES_PRINTED,       "PRINTER_NOTIFY_BYTES_PRINTED",       POINTER,   NULL },
1225 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_PRINTER_NAME,            "JOB_NOTIFY_PRINTER_NAME",            POINTER,   spoolss_notify_printer_name },
1226 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_MACHINE_NAME,            "JOB_NOTIFY_MACHINE_NAME",            POINTER,   spoolss_notify_server_name },
1227 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_PORT_NAME,               "JOB_NOTIFY_PORT_NAME",               POINTER,   spoolss_notify_port_name },
1228 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_USER_NAME,               "JOB_NOTIFY_USER_NAME",               POINTER,   spoolss_notify_username },
1229 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_NOTIFY_NAME,             "JOB_NOTIFY_NOTIFY_NAME",             POINTER,   spoolss_notify_username },
1230 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_DATATYPE,                "JOB_NOTIFY_DATATYPE",                POINTER,   spoolss_notify_datatype },
1231 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_PRINT_PROCESSOR,         "JOB_NOTIFY_PRINT_PROCESSOR",         POINTER,   spoolss_notify_print_processor },
1232 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_PARAMETERS,              "JOB_NOTIFY_PARAMETERS",              POINTER,   spoolss_notify_parameters },
1233 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_DRIVER_NAME,             "JOB_NOTIFY_DRIVER_NAME",             POINTER,   spoolss_notify_driver_name },
1234 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_DEVMODE,                 "JOB_NOTIFY_DEVMODE",                 POINTER,   spoolss_notify_devmode },
1235 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_STATUS,                  "JOB_NOTIFY_STATUS",                  ONE_VALUE, spoolss_notify_job_status },
1236 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_STATUS_STRING,           "JOB_NOTIFY_STATUS_STRING",           POINTER,   spoolss_notify_job_status_string },
1237 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_SECURITY_DESCRIPTOR,     "JOB_NOTIFY_SECURITY_DESCRIPTOR",     POINTER,   NULL },
1238 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_DOCUMENT,                "JOB_NOTIFY_DOCUMENT",                POINTER,   spoolss_notify_job_name },
1239 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_PRIORITY,                "JOB_NOTIFY_PRIORITY",                ONE_VALUE, spoolss_notify_priority },
1240 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_POSITION,                "JOB_NOTIFY_POSITION",                ONE_VALUE, spoolss_notify_job_position },
1241 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_SUBMITTED,               "JOB_NOTIFY_SUBMITTED",               POINTER,   NULL },
1242 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_START_TIME,              "JOB_NOTIFY_START_TIME",              ONE_VALUE, spoolss_notify_start_time },
1243 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_UNTIL_TIME,              "JOB_NOTIFY_UNTIL_TIME",              ONE_VALUE, spoolss_notify_until_time },
1244 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_TIME,                    "JOB_NOTIFY_TIME",                    ONE_VALUE, spoolss_notify_job_time },
1245 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_TOTAL_PAGES,             "JOB_NOTIFY_TOTAL_PAGES",             ONE_VALUE, NULL },
1246 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_PAGES_PRINTED,           "JOB_NOTIFY_PAGES_PRINTED",           ONE_VALUE, NULL },
1247 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_TOTAL_BYTES,             "JOB_NOTIFY_TOTAL_BYTES",             ONE_VALUE, spoolss_notify_job_size },
1248 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_BYTES_PRINTED,           "JOB_NOTIFY_BYTES_PRINTED",           ONE_VALUE, NULL },
1249 { END,                 END,                                "",                                   END,       NULL }
1250 };
1251
1252 /*******************************************************************
1253 return the size of info_data structure
1254 ********************************************************************/
1255 static uint32 size_of_notify_info_data(uint16 type, uint16 field)
1256 {
1257         int i=0;
1258
1259         while (notify_info_data_table[i].type != END)
1260         {
1261                 if ( (notify_info_data_table[i].type == type ) &&
1262                      (notify_info_data_table[i].field == field ) )
1263                 {
1264                         return (notify_info_data_table[i].size);
1265                         continue;
1266                 }
1267                 i++;
1268         }
1269         return (65535);
1270 }
1271
1272 /*******************************************************************
1273 return the type of notify_info_data
1274 ********************************************************************/
1275 static BOOL type_of_notify_info_data(uint16 type, uint16 field)
1276 {
1277         int i=0;
1278
1279         while (notify_info_data_table[i].type != END)
1280         {
1281                 if ( (notify_info_data_table[i].type == type ) &&
1282                      (notify_info_data_table[i].field == field ) )
1283                 {
1284                         if (notify_info_data_table[i].size == POINTER)
1285                         {
1286                                 return (False);
1287                         }
1288                         else
1289                         {
1290                                 return (True);
1291                         }
1292                         continue;
1293                 }
1294                 i++;
1295         }
1296         return (False);
1297 }
1298
1299 /****************************************************************************
1300 ****************************************************************************/
1301 static int search_notify(uint16 type, uint16 field, int *value)
1302 {
1303         int j;
1304         BOOL found;
1305
1306         for (j=0, found=False; found==False && notify_info_data_table[j].type != END ; j++)
1307         {
1308                 if ( (notify_info_data_table[j].type  == type  ) &&
1309                      (notify_info_data_table[j].field == field ) )
1310                         found=True;
1311         }
1312         *value=--j;
1313
1314         if ( found && (notify_info_data_table[j].fn != NULL) )
1315                 return True;
1316         else
1317                 return False;
1318 }
1319
1320 /****************************************************************************
1321 ****************************************************************************/
1322 static void construct_info_data(SPOOL_NOTIFY_INFO_DATA *info_data, uint16 type, uint16 field, int id)
1323 {
1324         info_data->type     = type;
1325         info_data->field    = field;
1326         info_data->reserved = 0;
1327         info_data->id       = id;
1328         info_data->size     = size_of_notify_info_data(type, field);
1329         info_data->enc_type = type_of_notify_info_data(type, field);
1330 }
1331
1332
1333 /*******************************************************************
1334  *
1335  * fill a notify_info struct with info asked
1336  *
1337  ********************************************************************/
1338 static BOOL construct_notify_printer_info(SPOOL_NOTIFY_INFO *info, int snum, SPOOL_NOTIFY_OPTION_TYPE *option_type, uint32 id)
1339 {
1340         int field_num,j;
1341         uint16 type;
1342         uint16 field;
1343
1344         SPOOL_NOTIFY_INFO_DATA *current_data;
1345         NT_PRINTER_INFO_LEVEL *printer = NULL;
1346         print_queue_struct *queue=NULL;
1347
1348         DEBUG(4,("construct_notify_printer_info\n"));
1349
1350         type=option_type->type;
1351
1352         DEBUGADD(4,("Notify type: [%s], number of notify info: [%d] on printer: [%s]\n",
1353                 (option_type->type==PRINTER_NOTIFY_TYPE?"PRINTER_NOTIFY_TYPE":"JOB_NOTIFY_TYPE"),
1354                 option_type->count, lp_servicename(snum)));
1355
1356         if (get_a_printer(&printer, 2, lp_servicename(snum))!=0)
1357                 return False;
1358
1359         for(field_num=0; field_num<option_type->count; field_num++) {
1360                 field = option_type->fields[field_num];
1361                 DEBUGADD(4,("notify [%d]: type [%x], field [%x]\n", field_num, type, field));
1362
1363                 if (!search_notify(type, field, &j) )
1364                         continue;
1365
1366                 if((info->data=Realloc(info->data, (info->count+1)*sizeof(SPOOL_NOTIFY_INFO_DATA))) == NULL) {
1367                         return False;
1368                 }
1369                 current_data=&info->data[info->count];
1370
1371                 construct_info_data(current_data, type, field, id);
1372                 notify_info_data_table[j].fn(snum, current_data, queue, printer);
1373
1374                 info->count++;
1375         }
1376
1377         free_a_printer(&printer, 2);
1378         return True;
1379 }
1380
1381 /*******************************************************************
1382  *
1383  * fill a notify_info struct with info asked
1384  *
1385  ********************************************************************/
1386 static BOOL construct_notify_jobs_info(print_queue_struct *queue, SPOOL_NOTIFY_INFO *info, int snum, SPOOL_NOTIFY_OPTION_TYPE *option_type, uint32 id)
1387 {
1388         int field_num,j;
1389         uint16 type;
1390         uint16 field;
1391
1392         SPOOL_NOTIFY_INFO_DATA *current_data;
1393         NT_PRINTER_INFO_LEVEL *printer = NULL;
1394
1395         DEBUG(4,("construct_notify_jobs_info\n"));
1396
1397         type = option_type->type;
1398
1399         DEBUGADD(4,("Notify type: [%s], number of notify info: [%d]\n",
1400                 (option_type->type==PRINTER_NOTIFY_TYPE?"PRINTER_NOTIFY_TYPE":"JOB_NOTIFY_TYPE"),
1401                 option_type->count));
1402
1403         if (get_a_printer(&printer, 2, lp_servicename(snum))!=0)
1404                 return False;
1405
1406         for(field_num=0; field_num<option_type->count; field_num++) {
1407                 field = option_type->fields[field_num];
1408
1409                 if (!search_notify(type, field, &j) )
1410                         continue;
1411
1412                 if((info->data=Realloc(info->data, (info->count+1)*sizeof(SPOOL_NOTIFY_INFO_DATA))) == NULL) {
1413                         return False;
1414                 }
1415
1416                 current_data=&(info->data[info->count]);
1417
1418                 construct_info_data(current_data, type, field, id);
1419                 notify_info_data_table[j].fn(snum, current_data, queue, printer);
1420                 info->count++;
1421         }
1422
1423         free_a_printer(&printer, 2);
1424         return True;
1425 }
1426
1427 /*
1428  * JFM: The enumeration is not that simple, it's even non obvious.
1429  *
1430  * let's take an example: I want to monitor the PRINTER SERVER for
1431  * the printer's name and the number of jobs currently queued.
1432  * So in the NOTIFY_OPTION, I have one NOTIFY_OPTION_TYPE structure.
1433  * Its type is PRINTER_NOTIFY_TYPE and it has 2 fields NAME and CJOBS.
1434  *
1435  * I have 3 printers on the back of my server.
1436  *
1437  * Now the response is a NOTIFY_INFO structure, with 6 NOTIFY_INFO_DATA
1438  * structures.
1439  *   Number     Data                    Id
1440  *      1       printer 1 name          1
1441  *      2       printer 1 cjob          1
1442  *      3       printer 2 name          2
1443  *      4       printer 2 cjob          2
1444  *      5       printer 3 name          3
1445  *      6       printer 3 name          3
1446  *
1447  * that's the print server case, the printer case is even worse.
1448  */
1449
1450
1451
1452 /*******************************************************************
1453  *
1454  * enumerate all printers on the printserver
1455  * fill a notify_info struct with info asked
1456  *
1457  ********************************************************************/
1458 static uint32 printserver_notify_info(const POLICY_HND *hnd, SPOOL_NOTIFY_INFO *info)
1459 {
1460         int snum;
1461         Printer_entry *Printer=find_printer_index_by_hnd(hnd);
1462         int n_services=lp_numservices();
1463         int i;
1464         uint32 id;
1465         SPOOL_NOTIFY_OPTION *option;
1466         SPOOL_NOTIFY_OPTION_TYPE *option_type;
1467
1468         DEBUG(4,("printserver_notify_info\n"));
1469
1470         option=Printer->notify.option;
1471         id=1;
1472         info->version=2;
1473         info->data=NULL;
1474         info->count=0;
1475
1476         for (i=0; i<option->count; i++) {
1477                 option_type=&(option->ctr.type[i]);
1478
1479                 if (option_type->type!=PRINTER_NOTIFY_TYPE)
1480                         continue;
1481
1482                 for (snum=0; snum<n_services; snum++)
1483                         if ( lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum) )
1484                                 if (construct_notify_printer_info(info, snum, option_type, id))
1485                                         id++;
1486         }
1487
1488         /*
1489          * Debugging information, don't delete.
1490          */
1491         /*
1492         DEBUG(1,("dumping the NOTIFY_INFO\n"));
1493         DEBUGADD(1,("info->version:[%d], info->flags:[%d], info->count:[%d]\n", info->version, info->flags, info->count));
1494         DEBUGADD(1,("num\ttype\tfield\tres\tid\tsize\tenc_type\n"));
1495
1496         for (i=0; i<info->count; i++) {
1497                 DEBUGADD(1,("[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\n",
1498                 i, info->data[i].type, info->data[i].field, info->data[i].reserved,
1499                 info->data[i].id, info->data[i].size, info->data[i].enc_type));
1500         }
1501         */
1502
1503         return NT_STATUS_NO_PROBLEMO;
1504 }
1505
1506 /*******************************************************************
1507  *
1508  * fill a notify_info struct with info asked
1509  *
1510  ********************************************************************/
1511 static uint32 printer_notify_info(const POLICY_HND *hnd, SPOOL_NOTIFY_INFO *info)
1512 {
1513         int snum;
1514         Printer_entry *Printer=find_printer_index_by_hnd(hnd);
1515         int i;
1516         uint32 id;
1517         SPOOL_NOTIFY_OPTION *option;
1518         SPOOL_NOTIFY_OPTION_TYPE *option_type;
1519         int count,j;
1520         print_queue_struct *queue=NULL;
1521         print_status_struct status;
1522
1523         DEBUG(4,("printer_notify_info\n"));
1524
1525         option=Printer->notify.option;
1526         id=0xffffffff;
1527         info->version=2;
1528         info->data=NULL;
1529         info->count=0;
1530
1531         get_printer_snum(hnd, &snum);
1532
1533         for (i=0; i<option->count; i++) {
1534                 option_type=&option->ctr.type[i];
1535
1536                 switch ( option_type->type ) {
1537                 case PRINTER_NOTIFY_TYPE:
1538                         if(construct_notify_printer_info(info, snum, option_type, id))
1539                                 id--;
1540                         break;
1541
1542                 case JOB_NOTIFY_TYPE:
1543                         memset(&status, 0, sizeof(status));
1544                         count = print_queue_status(snum, &queue, &status);
1545                         for (j=0; j<count; j++)
1546                                 construct_notify_jobs_info(&queue[j], info, snum, option_type, queue[j].job);
1547                         safe_free(queue);
1548                         break;
1549                 }
1550         }
1551
1552         /*
1553          * Debugging information, don't delete.
1554          */
1555         /*
1556         DEBUG(1,("dumping the NOTIFY_INFO\n"));
1557         DEBUGADD(1,("info->version:[%d], info->flags:[%d], info->count:[%d]\n", info->version, info->flags, info->count));
1558         DEBUGADD(1,("num\ttype\tfield\tres\tid\tsize\tenc_type\n"));
1559
1560         for (i=0; i<info->count; i++) {
1561                 DEBUGADD(1,("[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\n",
1562                 i, info->data[i].type, info->data[i].field, info->data[i].reserved,
1563                 info->data[i].id, info->data[i].size, info->data[i].enc_type));
1564         }
1565         */
1566         return NT_STATUS_NO_PROBLEMO;
1567 }
1568
1569 /********************************************************************
1570  * spoolss_rfnpcnex
1571  ********************************************************************/
1572 uint32 _spoolss_rfnpcnex( const POLICY_HND *handle, uint32 change,
1573                           SPOOL_NOTIFY_OPTION *option, SPOOL_NOTIFY_INFO *info)
1574 {
1575         Printer_entry *Printer=find_printer_index_by_hnd(handle);
1576
1577         if (!OPEN_HANDLE(Printer))
1578                 return ERROR_INVALID_HANDLE;
1579
1580         DEBUG(4,("Printer type %x\n",Printer->printer_type));
1581
1582         /* jfm: the change value isn't used right now.
1583          *      we will honour it when
1584          *      a) we'll be able to send notification to the client
1585          *      b) we'll have a way to communicate between the spoolss process.
1586          *
1587          *      same thing for option->flags
1588          *      I should check for PRINTER_NOTIFY_OPTIONS_REFRESH but as
1589          *      I don't have a global notification system, I'm sending back all the
1590          *      informations even when _NOTHING_ has changed.
1591          */
1592
1593         /* just discard the SPOOL_NOTIFY_OPTION */
1594         if (option!=NULL)
1595                 safe_free(option->ctr.type);
1596
1597         switch (Printer->printer_type) {
1598                 case PRINTER_HANDLE_IS_PRINTSERVER:
1599                         return printserver_notify_info(handle, info);
1600                         break;
1601                 case PRINTER_HANDLE_IS_PRINTER:
1602                         return printer_notify_info(handle, info);
1603                         break;
1604         }
1605
1606         return ERROR_INVALID_HANDLE;
1607 }
1608
1609 /********************************************************************
1610  * construct_printer_info_0
1611  * fill a printer_info_1 struct
1612  ********************************************************************/
1613 static BOOL construct_printer_info_0(PRINTER_INFO_0 *printer, int snum, fstring servername)
1614 {
1615         pstring chaine;
1616         int count;
1617         NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
1618         counter_printer_0 *session_counter;
1619         uint32 global_counter;
1620         struct tm *t;
1621         time_t setup_time = time(NULL);
1622
1623         print_queue_struct *queue=NULL;
1624         print_status_struct status;
1625
1626         memset(&status, 0, sizeof(status));
1627
1628         if (get_a_printer(&ntprinter, 2, lp_servicename(snum)) != 0)
1629                 return False;
1630
1631         count = print_queue_status(snum, &queue, &status);
1632
1633         /* check if we already have a counter for this printer */
1634         session_counter = (counter_printer_0 *)ubi_dlFirst(&counter_list);
1635
1636         for(; session_counter; session_counter = (counter_printer_0 *)ubi_dlNext(session_counter)) {
1637                 if (session_counter->snum == snum)
1638                         break;
1639         }
1640
1641         /* it's the first time, add it to the list */
1642         if (session_counter==NULL) {
1643                 if((session_counter=(counter_printer_0 *)malloc(sizeof(counter_printer_0))) == NULL) {
1644                         free_a_printer(&ntprinter, 2);
1645                         return False;
1646                 }
1647                 ZERO_STRUCTP(session_counter);
1648                 session_counter->snum=snum;
1649                 session_counter->counter=0;
1650                 ubi_dlAddHead( &counter_list, (ubi_dlNode *)session_counter);
1651         }
1652
1653         /* increment it */
1654         session_counter->counter++;
1655
1656         /* JFM:
1657          * the global_counter should be stored in a TDB as it's common to all the clients
1658          * and should be zeroed on samba startup
1659          */
1660         global_counter=session_counter->counter;
1661
1662         /* the description and the name are of the form \\server\share */
1663         slprintf(chaine,sizeof(chaine)-1,"\\\\%s\\%s",servername, ntprinter->info_2->printername);
1664
1665         init_unistr(&printer->printername, chaine);
1666
1667         slprintf(chaine,sizeof(chaine)-1,"\\\\%s", servername);
1668         init_unistr(&printer->servername, chaine);
1669
1670         printer->cjobs = count;
1671         printer->total_jobs = 0;
1672         printer->total_bytes = 0;
1673
1674         t=gmtime(&setup_time);
1675         ntprinter->info_2->setuptime = (uint32)setup_time; /* FIXME !! */
1676
1677         printer->year = t->tm_year+1900;
1678         printer->month = t->tm_mon+1;
1679         printer->dayofweek = t->tm_wday;
1680         printer->day = t->tm_mday;
1681         printer->hour = t->tm_hour;
1682         printer->minute = t->tm_min;
1683         printer->second = t->tm_sec;
1684         printer->milliseconds = 0;
1685
1686         printer->global_counter = global_counter;
1687         printer->total_pages = 0;
1688         printer->major_version = 0x0004;        /* NT 4 */
1689         printer->build_version = 0x0565;        /* build 1381 */
1690         printer->unknown7 = 0x1;
1691         printer->unknown8 = 0x0;
1692         printer->unknown9 = 0x0;
1693         printer->session_counter = session_counter->counter;
1694         printer->unknown11 = 0x0;
1695         printer->printer_errors = 0x0;          /* number of print failure */
1696         printer->unknown13 = 0x0;
1697         printer->unknown14 = 0x1;
1698         printer->unknown15 = 0x024a;            /* 586 Pentium ? */
1699         printer->unknown16 = 0x0;
1700         printer->change_id = ntprinter->info_2->changeid; /* ChangeID in milliseconds*/
1701         printer->unknown18 = 0x0;
1702         printer->status = nt_printq_status(status.status);
1703         printer->unknown20 = 0x0;
1704         printer->c_setprinter = ntprinter->info_2->c_setprinter; /* how many times setprinter has been called */
1705         printer->unknown22 = 0x0;
1706         printer->unknown23 = 0x6;               /* 6  ???*/
1707         printer->unknown24 = 0;                 /* unknown 24 to 26 are always 0 */
1708         printer->unknown25 = 0;
1709         printer->unknown26 = 0;
1710         printer->unknown27 = 0;
1711         printer->unknown28 = 0;
1712         printer->unknown29 = 0;
1713
1714         safe_free(queue);
1715         free_a_printer(&ntprinter,2);
1716         return (True);
1717 }
1718
1719 /********************************************************************
1720  * construct_printer_info_1
1721  * fill a printer_info_1 struct
1722  ********************************************************************/
1723 static BOOL construct_printer_info_1(fstring server, uint32 flags, PRINTER_INFO_1 *printer, int snum)
1724 {
1725         pstring chaine;
1726         pstring chaine2;
1727         NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
1728
1729         if (get_a_printer(&ntprinter, 2, lp_servicename(snum)) != 0)
1730                 return False;
1731
1732         printer->flags=flags;
1733
1734         snprintf(chaine,sizeof(chaine)-1,"%s%s,%s,%s",server, ntprinter->info_2->printername,
1735                 ntprinter->info_2->drivername, lp_comment(snum));
1736
1737         snprintf(chaine2,sizeof(chaine)-1,"%s%s", server, ntprinter->info_2->printername);
1738
1739         init_unistr(&printer->description, chaine);
1740         init_unistr(&printer->name, chaine2);
1741         init_unistr(&printer->comment, lp_comment(snum));
1742
1743         free_a_printer(&ntprinter,2);
1744
1745         return True;
1746 }
1747
1748 /****************************************************************************
1749  Free a DEVMODE struct.
1750 ****************************************************************************/
1751
1752 static void free_dev_mode(DEVICEMODE *dev)
1753 {
1754         if (dev == NULL)
1755                 return;
1756
1757         if (dev->private)
1758                 safe_free(dev->private);
1759
1760         safe_free(dev);
1761 }
1762
1763 /****************************************************************************
1764  Create a DEVMODE struct. Returns malloced memory.
1765 ****************************************************************************/
1766
1767 static DEVICEMODE *construct_dev_mode(int snum, char *servername)
1768 {
1769         char adevice[32];
1770         char aform[32];
1771         NT_PRINTER_INFO_LEVEL *printer = NULL;
1772         NT_DEVICEMODE *ntdevmode = NULL;
1773         DEVICEMODE *devmode = NULL;
1774
1775         DEBUG(7,("construct_dev_mode\n"));
1776
1777         DEBUGADD(8,("getting printer characteristics\n"));
1778
1779         if ((devmode = (DEVICEMODE *)malloc(sizeof(DEVICEMODE))) == NULL) {
1780                 DEBUG(0,("construct_dev_mode: malloc fail.\n"));
1781                 return NULL;
1782         }
1783
1784         ZERO_STRUCTP(devmode);
1785
1786         if(get_a_printer(&printer, 2, lp_servicename(snum)) != 0)
1787                 goto fail;
1788
1789         if (printer->info_2->devmode)
1790                 ntdevmode = dup_nt_devicemode(printer->info_2->devmode);
1791         else
1792                 ntdevmode = construct_nt_devicemode(printer->info_2->printername);
1793
1794         if (ntdevmode == NULL)
1795                 goto fail;
1796
1797         DEBUGADD(8,("loading DEVICEMODE\n"));
1798
1799 #if 0 /* JRATEST */
1800         snprintf(adevice, sizeof(adevice), "\\\\%s\\%s", global_myname, ntdevmode->devicename);
1801 #else /* JRATEST */
1802         snprintf(adevice, sizeof(adevice), "\\\\%s\\%s", global_myname, printer->info_2->printername);
1803 #endif /* JRATEST */
1804         init_unistr(&devmode->devicename, adevice);
1805
1806         snprintf(aform, sizeof(aform), ntdevmode->formname);
1807         init_unistr(&devmode->formname, aform);
1808
1809         devmode->specversion      = ntdevmode->specversion;
1810         devmode->driverversion    = ntdevmode->driverversion;
1811         devmode->size             = ntdevmode->size;
1812         devmode->driverextra      = ntdevmode->driverextra;
1813         devmode->fields           = ntdevmode->fields;
1814
1815         devmode->orientation      = ntdevmode->orientation;
1816         devmode->papersize        = ntdevmode->papersize;
1817         devmode->paperlength      = ntdevmode->paperlength;
1818         devmode->paperwidth       = ntdevmode->paperwidth;
1819         devmode->scale            = ntdevmode->scale;
1820         devmode->copies           = ntdevmode->copies;
1821         devmode->defaultsource    = ntdevmode->defaultsource;
1822         devmode->printquality     = ntdevmode->printquality;
1823         devmode->color            = ntdevmode->color;
1824         devmode->duplex           = ntdevmode->duplex;
1825         devmode->yresolution      = ntdevmode->yresolution;
1826         devmode->ttoption         = ntdevmode->ttoption;
1827         devmode->collate          = ntdevmode->collate;
1828         devmode->icmmethod        = ntdevmode->icmmethod;
1829         devmode->icmintent        = ntdevmode->icmintent;
1830         devmode->mediatype        = ntdevmode->mediatype;
1831         devmode->dithertype       = ntdevmode->dithertype;
1832
1833         if (ntdevmode->private != NULL) {
1834                 if ((devmode->private=(uint8 *)memdup(ntdevmode->private, ntdevmode->driverextra)) == NULL)
1835                         goto fail;
1836         }
1837
1838         free_nt_devicemode(&ntdevmode);
1839         free_a_printer(&printer,2);
1840
1841         return devmode;
1842
1843   fail:
1844
1845         if (ntdevmode)
1846                 free_nt_devicemode(&ntdevmode);
1847         if (printer)
1848                 free_a_printer(&printer,2);
1849         free_dev_mode(devmode);
1850
1851         return NULL;
1852 }
1853
1854 /********************************************************************
1855  * construct_printer_info_2
1856  * fill a printer_info_2 struct
1857  ********************************************************************/
1858
1859 static BOOL construct_printer_info_2(fstring servername, PRINTER_INFO_2 *printer, int snum)
1860 {
1861         pstring chaine;
1862         pstring chaine2;
1863         pstring sl;
1864         int count;
1865         NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
1866
1867         print_queue_struct *queue=NULL;
1868         print_status_struct status;
1869         memset(&status, 0, sizeof(status));
1870
1871         if (get_a_printer(&ntprinter, 2, lp_servicename(snum)) !=0 )
1872                 return False;
1873
1874         memset(&status, 0, sizeof(status));
1875         count = print_queue_status(snum, &queue, &status);
1876
1877         snprintf(chaine, sizeof(chaine)-1, "%s", servername);
1878
1879         if (strlen(servername)!=0)
1880                 fstrcpy(sl, "\\");
1881         else
1882                 fstrcpy(sl, '\0');
1883
1884         snprintf(chaine2, sizeof(chaine)-1, "%s%s%s", servername, sl, ntprinter->info_2->printername);
1885
1886         init_unistr(&printer->servername, chaine);                              /* servername*/
1887         init_unistr(&printer->printername, chaine2);                            /* printername*/
1888         init_unistr(&printer->sharename, lp_servicename(snum));                 /* sharename */
1889         init_unistr(&printer->portname, lp_servicename(snum));                  /* port */
1890         init_unistr(&printer->drivername, ntprinter->info_2->drivername);       /* drivername */
1891         init_unistr(&printer->comment, lp_comment(snum));                       /* comment */
1892         init_unistr(&printer->location, ntprinter->info_2->location);           /* location */
1893         init_unistr(&printer->sepfile, ntprinter->info_2->sepfile);             /* separator file */
1894         init_unistr(&printer->printprocessor, ntprinter->info_2->printprocessor);/* print processor */
1895         init_unistr(&printer->datatype, ntprinter->info_2->datatype);           /* datatype */
1896         init_unistr(&printer->parameters, ntprinter->info_2->parameters);       /* parameters (of print processor) */
1897
1898         printer->attributes = ntprinter->info_2->attributes;
1899
1900         printer->priority = ntprinter->info_2->priority;                                /* priority */
1901         printer->defaultpriority = ntprinter->info_2->default_priority;         /* default priority */
1902         printer->starttime = ntprinter->info_2->starttime;                      /* starttime */
1903         printer->untiltime = ntprinter->info_2->untiltime;                      /* untiltime */
1904         printer->status = nt_printq_status(status.status);                      /* status */
1905         printer->cjobs = count;                                                 /* jobs */
1906         printer->averageppm = ntprinter->info_2->averageppm;                    /* average pages per minute */
1907
1908         if((printer->devmode = construct_dev_mode(snum, servername)) == NULL)
1909                 goto err;
1910
1911         if (ntprinter->info_2->secdesc_buf && ntprinter->info_2->secdesc_buf->len != 0) {
1912                 /* steal the printer info sec_desc structure.  [badly done]. */
1913                 printer->secdesc = ntprinter->info_2->secdesc_buf->sec;
1914                 ntprinter->info_2->secdesc_buf->sec = NULL; /* Stolen memory. */
1915                 ntprinter->info_2->secdesc_buf->len = 0; /* Stolen memory. */
1916                 ntprinter->info_2->secdesc_buf->max_len = 0; /* Stolen memory. */
1917         }
1918         else {
1919                 printer->secdesc = NULL;
1920         }
1921
1922         free_a_printer(&ntprinter, 2);
1923         safe_free(queue);
1924         return True;
1925
1926   err:
1927
1928         if (ntprinter)
1929                 free_a_printer(&ntprinter, 2);
1930         safe_free(queue);
1931         return False;
1932 }
1933
1934 /********************************************************************
1935  * construct_printer_info_3
1936  * fill a printer_info_3 struct
1937  ********************************************************************/
1938 static BOOL construct_printer_info_3(fstring servername,
1939                         PRINTER_INFO_3 **pp_printer, int snum)
1940 {
1941         NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
1942         PRINTER_INFO_3 *printer = NULL;
1943
1944         if (get_a_printer(&ntprinter, 2, lp_servicename(snum)) !=0 )
1945                 return False;
1946
1947         *pp_printer = NULL;
1948         if ((printer = (PRINTER_INFO_3 *)malloc(sizeof(PRINTER_INFO_3))) == NULL) {
1949                 DEBUG(0,("construct_printer_info_3: malloc fail.\n"));
1950                 return False;
1951         }
1952
1953         ZERO_STRUCTP(printer);
1954
1955         printer->flags = 4; /* This is the offset to the SEC_DESC. */
1956         if (ntprinter->info_2->secdesc_buf && ntprinter->info_2->secdesc_buf->len != 0) {
1957                 /* steal the printer info sec_desc structure.  [badly done]. */
1958                 printer->secdesc = ntprinter->info_2->secdesc_buf->sec;
1959                 ntprinter->info_2->secdesc_buf->sec = NULL; /* Stolen the malloced memory. */
1960                 ntprinter->info_2->secdesc_buf->len = 0; /* Stolen the malloced memory. */
1961                 ntprinter->info_2->secdesc_buf->max_len = 0; /* Stolen the malloced memory. */
1962         }
1963
1964         free_a_printer(&ntprinter, 2);
1965
1966         *pp_printer = printer;
1967         return True;
1968 }
1969
1970 /********************************************************************
1971  Spoolss_enumprinters.
1972 ********************************************************************/
1973 static BOOL enum_all_printers_info_1(fstring server, uint32 flags, NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
1974 {
1975         int snum;
1976         int i;
1977         int n_services=lp_numservices();
1978         PRINTER_INFO_1 *printers=NULL;
1979         PRINTER_INFO_1 current_prt;
1980
1981         DEBUG(4,("enum_all_printers_info_1\n"));
1982
1983         for (snum=0; snum<n_services; snum++) {
1984                 if (lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum) ) {
1985                         DEBUG(4,("Found a printer in smb.conf: %s[%x]\n", lp_servicename(snum), snum));
1986
1987                         if (construct_printer_info_1(server, flags, &current_prt, snum)) {
1988                                 if((printers=Realloc(printers, (*returned +1)*sizeof(PRINTER_INFO_1))) == NULL) {
1989                                         *returned=0;
1990                                         return ERROR_NOT_ENOUGH_MEMORY;
1991                                 }
1992                                 DEBUG(4,("ReAlloced memory for [%d] PRINTER_INFO_1\n", *returned));
1993                                 memcpy(&(printers[*returned]), &current_prt, sizeof(PRINTER_INFO_1));
1994                                 (*returned)++;
1995                         }
1996                 }
1997         }
1998
1999         /* check the required size. */
2000         for (i=0; i<*returned; i++)
2001                 (*needed) += spoolss_size_printer_info_1(&(printers[i]));
2002
2003         if (!alloc_buffer_size(buffer, *needed))
2004                 return ERROR_INSUFFICIENT_BUFFER;
2005
2006         /* fill the buffer with the structures */
2007         for (i=0; i<*returned; i++)
2008                 new_smb_io_printer_info_1("", buffer, &(printers[i]), 0);
2009
2010         /* clear memory */
2011         safe_free(printers);
2012
2013         if (*needed > offered) {
2014                 *returned=0;
2015                 return ERROR_INSUFFICIENT_BUFFER;
2016         }
2017         else
2018                 return NT_STATUS_NO_PROBLEMO;
2019 }
2020
2021 /********************************************************************
2022  enum_all_printers_info_1_local.
2023 *********************************************************************/
2024 static BOOL enum_all_printers_info_1_local(fstring name, NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
2025 {
2026         fstring temp;
2027         DEBUG(4,("enum_all_printers_info_1_local\n"));
2028
2029         fstrcpy(temp, "\\\\");
2030         fstrcat(temp, global_myname);
2031
2032         if (!strcmp(name, temp)) {
2033                 fstrcat(temp, "\\");
2034                 return enum_all_printers_info_1(temp, PRINTER_ENUM_ICON8, buffer, offered, needed, returned);
2035         }
2036         else
2037                 return enum_all_printers_info_1("", PRINTER_ENUM_ICON8, buffer, offered, needed, returned);
2038 }
2039
2040 /********************************************************************
2041  enum_all_printers_info_1_name.
2042 *********************************************************************/
2043 static BOOL enum_all_printers_info_1_name(fstring name, NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
2044 {
2045         fstring temp;
2046         DEBUG(4,("enum_all_printers_info_1_name\n"));
2047
2048         fstrcpy(temp, "\\\\");
2049         fstrcat(temp, global_myname);
2050
2051         if (!strcmp(name, temp)) {
2052                 fstrcat(temp, "\\");
2053                 return enum_all_printers_info_1(temp, PRINTER_ENUM_ICON8, buffer, offered, needed, returned);
2054         }
2055         else
2056                 return ERROR_INVALID_NAME;
2057 }
2058
2059 /********************************************************************
2060  enum_all_printers_info_1_remote.
2061 *********************************************************************/
2062 static BOOL enum_all_printers_info_1_remote(fstring name, NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
2063 {
2064         PRINTER_INFO_1 *printer;
2065         fstring printername;
2066         fstring desc;
2067         fstring comment;
2068         DEBUG(4,("enum_all_printers_info_1_remote\n"));
2069
2070         /* JFM: currently it's more a place holder than anything else.
2071          * In the spooler world there is a notion of server registration.
2072          * the print servers are registring (sp ?) on the PDC (in the same domain)
2073          *
2074          * We should have a TDB here. The registration is done thru an undocumented RPC call.
2075          */
2076
2077         if((printer=(PRINTER_INFO_1 *)malloc(sizeof(PRINTER_INFO_1))) == NULL)
2078                 return ERROR_NOT_ENOUGH_MEMORY;
2079
2080         *returned=1;
2081
2082         snprintf(printername, sizeof(printername)-1,"Windows NT Remote Printers!!\\\\%s", global_myname);
2083         snprintf(desc, sizeof(desc)-1,"%s", global_myname);
2084         snprintf(comment, sizeof(comment)-1, "Logged on Domain");
2085
2086         init_unistr(&printer->description, desc);
2087         init_unistr(&printer->name, printername);
2088         init_unistr(&printer->comment, comment);
2089         printer->flags=PRINTER_ENUM_ICON3|PRINTER_ENUM_CONTAINER;
2090
2091         /* check the required size. */
2092         *needed += spoolss_size_printer_info_1(printer);
2093
2094         if (!alloc_buffer_size(buffer, *needed)) {
2095                 safe_free(printer);
2096                 return ERROR_INSUFFICIENT_BUFFER;
2097         }
2098
2099         /* fill the buffer with the structures */
2100         new_smb_io_printer_info_1("", buffer, printer, 0);
2101
2102         /* clear memory */
2103         safe_free(printer);
2104
2105         if (*needed > offered) {
2106                 *returned=0;
2107                 return ERROR_INSUFFICIENT_BUFFER;
2108         }
2109         else
2110                 return NT_STATUS_NO_PROBLEMO;
2111 }
2112
2113 /********************************************************************
2114  enum_all_printers_info_1_network.
2115 *********************************************************************/
2116 static BOOL enum_all_printers_info_1_network(fstring name, NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
2117 {
2118         fstring temp;
2119         DEBUG(4,("enum_all_printers_info_1_network\n"));
2120
2121         fstrcpy(temp, "\\\\");
2122         fstrcat(temp, global_myname);
2123         fstrcat(temp, "\\");
2124         return enum_all_printers_info_1(temp, PRINTER_ENUM_UNKNOWN_8, buffer, offered, needed, returned);
2125 }
2126
2127 /********************************************************************
2128  * api_spoolss_enumprinters
2129  *
2130  * called from api_spoolss_enumprinters (see this to understand)
2131  ********************************************************************/
2132 static BOOL enum_all_printers_info_2(fstring servername, NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
2133 {
2134         int snum;
2135         int i;
2136         int n_services=lp_numservices();
2137         PRINTER_INFO_2 *printers=NULL;
2138         PRINTER_INFO_2 current_prt;
2139
2140         for (snum=0; snum<n_services; snum++) {
2141                 if (lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum) ) {
2142                         DEBUG(4,("Found a printer in smb.conf: %s[%x]\n", lp_servicename(snum), snum));
2143
2144                         if (construct_printer_info_2(servername, &current_prt, snum)) {
2145                                 if((printers=Realloc(printers, (*returned +1)*sizeof(PRINTER_INFO_2))) == NULL)
2146                                         return ERROR_NOT_ENOUGH_MEMORY;
2147                                 DEBUG(4,("ReAlloced memory for [%d] PRINTER_INFO_2\n", *returned));
2148                                 memcpy(&printers[*returned], &current_prt, sizeof(PRINTER_INFO_2));
2149                                 (*returned)++;
2150                         }
2151                 }
2152         }
2153
2154         /* check the required size. */
2155         for (i=0; i<*returned; i++)
2156                 (*needed) += spoolss_size_printer_info_2(&printers[i]);
2157
2158         if (!alloc_buffer_size(buffer, *needed)) {
2159                 for (i=0; i<*returned; i++) {
2160                         free_devmode(printers[i].devmode);
2161                         free_sec_desc(&printers[i].secdesc);
2162                 }
2163                 safe_free(printers);
2164                 return ERROR_INSUFFICIENT_BUFFER;
2165         }
2166
2167         /* fill the buffer with the structures */
2168         for (i=0; i<*returned; i++)
2169                 new_smb_io_printer_info_2("", buffer, &(printers[i]), 0);
2170
2171         /* clear memory */
2172         for (i=0; i<*returned; i++) {
2173                 free_devmode(printers[i].devmode);
2174                 free_sec_desc(&printers[i].secdesc);
2175         }
2176         safe_free(printers);
2177
2178         if (*needed > offered) {
2179                 *returned=0;
2180                 return ERROR_INSUFFICIENT_BUFFER;
2181         }
2182         else
2183                 return NT_STATUS_NO_PROBLEMO;
2184 }
2185
2186 /********************************************************************
2187  * handle enumeration of printers at level 1
2188  ********************************************************************/
2189 static uint32 enumprinters_level1( uint32 flags, fstring name,
2190                                  NEW_BUFFER *buffer, uint32 offered,
2191                                  uint32 *needed, uint32 *returned)
2192 {
2193         /* Not all the flags are equals */
2194
2195         if (flags & PRINTER_ENUM_LOCAL)
2196                 return enum_all_printers_info_1_local(name, buffer, offered, needed, returned);
2197
2198         if (flags & PRINTER_ENUM_NAME)
2199                 return enum_all_printers_info_1_name(name, buffer, offered, needed, returned);
2200
2201         if (flags & PRINTER_ENUM_REMOTE)
2202                 return enum_all_printers_info_1_remote(name, buffer, offered, needed, returned);
2203
2204         if (flags & PRINTER_ENUM_NETWORK)
2205                 return enum_all_printers_info_1_network(name, buffer, offered, needed, returned);
2206
2207         return NT_STATUS_NO_PROBLEMO; /* NT4sp5 does that */
2208 }
2209
2210 /********************************************************************
2211  * handle enumeration of printers at level 2
2212  ********************************************************************/
2213 static uint32 enumprinters_level2( uint32 flags, fstring servername,
2214                                  NEW_BUFFER *buffer, uint32 offered,
2215                                  uint32 *needed, uint32 *returned)
2216 {
2217         fstring temp;
2218
2219         fstrcpy(temp, "\\\\");
2220         fstrcat(temp, global_myname);
2221
2222         if (flags & PRINTER_ENUM_LOCAL) {
2223                 if (!strcmp(servername, temp))
2224                         return enum_all_printers_info_2(temp, buffer, offered, needed, returned);
2225                 else
2226                         return enum_all_printers_info_2("", buffer, offered, needed, returned);
2227         }
2228
2229         if (flags & PRINTER_ENUM_NAME) {
2230                 if (!strcmp(servername, temp))
2231                         return enum_all_printers_info_2(temp, buffer, offered, needed, returned);
2232                 else
2233                         return ERROR_INVALID_NAME;
2234         }
2235
2236         if (flags & PRINTER_ENUM_REMOTE)
2237                 return ERROR_INVALID_LEVEL;
2238
2239         return NT_STATUS_NO_PROBLEMO;
2240 }
2241
2242 /********************************************************************
2243  * handle enumeration of printers at level 5
2244  ********************************************************************/
2245 static uint32 enumprinters_level5( uint32 flags, fstring servername,
2246                                  NEW_BUFFER *buffer, uint32 offered,
2247                                  uint32 *needed, uint32 *returned)
2248 {
2249 /*      return enum_all_printers_info_5(buffer, offered, needed, returned);*/
2250         return NT_STATUS_NO_PROBLEMO;
2251 }
2252
2253 /********************************************************************
2254  * api_spoolss_enumprinters
2255  *
2256  * called from api_spoolss_enumprinters (see this to understand)
2257  ********************************************************************/
2258 uint32 _spoolss_enumprinters( uint32 flags, const UNISTR2 *servername, uint32 level,
2259                               NEW_BUFFER *buffer, uint32 offered,
2260                               uint32 *needed, uint32 *returned)
2261 {
2262         fstring name;
2263
2264         DEBUG(4,("_spoolss_enumprinters\n"));
2265
2266         *needed=0;
2267         *returned=0;
2268
2269         /*
2270          * Level 1:
2271          *          flags==PRINTER_ENUM_NAME
2272          *           if name=="" then enumerates all printers
2273          *           if name!="" then enumerate the printer
2274          *          flags==PRINTER_ENUM_REMOTE
2275          *          name is NULL, enumerate printers
2276          * Level 2: name!="" enumerates printers, name can't be NULL
2277          * Level 3: doesn't exist
2278          * Level 4: does a local registry lookup
2279          * Level 5: same as Level 2
2280          */
2281
2282         unistr2_to_ascii(name, servername, sizeof(name)-1);
2283         strupper(name);
2284
2285         switch (level) {
2286         case 1:
2287                 return enumprinters_level1(flags, name, buffer, offered, needed, returned);
2288                 break;
2289         case 2:
2290                 return enumprinters_level2(flags, name, buffer, offered, needed, returned);
2291                 break;
2292         case 5:
2293                 return enumprinters_level5(flags, name, buffer, offered, needed, returned);
2294                 break;
2295         case 3:
2296         case 4:
2297         default:
2298                 return ERROR_INVALID_LEVEL;
2299                 break;
2300         }
2301 }
2302
2303 /****************************************************************************
2304 ****************************************************************************/
2305 static uint32 getprinter_level_0(fstring servername, int snum, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
2306 {
2307         PRINTER_INFO_0 *printer=NULL;
2308
2309         if((printer=(PRINTER_INFO_0*)malloc(sizeof(PRINTER_INFO_0))) == NULL)
2310                 return ERROR_NOT_ENOUGH_MEMORY;
2311
2312         construct_printer_info_0(printer, snum, servername);
2313
2314         /* check the required size. */
2315         *needed += spoolss_size_printer_info_0(printer);
2316
2317         if (!alloc_buffer_size(buffer, *needed)) {
2318                 safe_free(printer);
2319                 return ERROR_INSUFFICIENT_BUFFER;
2320         }
2321
2322         /* fill the buffer with the structures */
2323         new_smb_io_printer_info_0("", buffer, printer, 0);
2324
2325         /* clear memory */
2326         safe_free(printer);
2327
2328         if (*needed > offered) {
2329                 return ERROR_INSUFFICIENT_BUFFER;
2330         }
2331         else
2332                 return NT_STATUS_NO_PROBLEMO;
2333 }
2334
2335 /****************************************************************************
2336 ****************************************************************************/
2337 static uint32 getprinter_level_1(fstring servername, int snum, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
2338 {
2339         PRINTER_INFO_1 *printer=NULL;
2340
2341         if((printer=(PRINTER_INFO_1*)malloc(sizeof(PRINTER_INFO_1))) == NULL)
2342                 return ERROR_NOT_ENOUGH_MEMORY;
2343
2344         construct_printer_info_1(servername, PRINTER_ENUM_ICON8, printer, snum);
2345
2346         /* check the required size. */
2347         *needed += spoolss_size_printer_info_1(printer);
2348
2349         if (!alloc_buffer_size(buffer, *needed)) {
2350                 safe_free(printer);
2351                 return ERROR_INSUFFICIENT_BUFFER;
2352         }
2353
2354         /* fill the buffer with the structures */
2355         new_smb_io_printer_info_1("", buffer, printer, 0);
2356
2357         /* clear memory */
2358         safe_free(printer);
2359
2360         if (*needed > offered) {
2361                 return ERROR_INSUFFICIENT_BUFFER;
2362         }
2363         else
2364                 return NT_STATUS_NO_PROBLEMO;
2365 }
2366
2367 /****************************************************************************
2368 ****************************************************************************/
2369 static uint32 getprinter_level_2(fstring servername, int snum, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
2370 {
2371         PRINTER_INFO_2 *printer=NULL;
2372         fstring temp;
2373
2374         if((printer=(PRINTER_INFO_2*)malloc(sizeof(PRINTER_INFO_2)))==NULL)
2375                 return ERROR_NOT_ENOUGH_MEMORY;
2376
2377         fstrcpy(temp, "\\\\");
2378         fstrcat(temp, servername);
2379         construct_printer_info_2(temp, printer, snum);
2380
2381         /* check the required size. */
2382         *needed += spoolss_size_printer_info_2(printer);
2383
2384         if (!alloc_buffer_size(buffer, *needed)) {
2385                 free_printer_info_2(printer);
2386                 return ERROR_INSUFFICIENT_BUFFER;
2387         }
2388
2389         /* fill the buffer with the structures */
2390         if (!new_smb_io_printer_info_2("", buffer, printer, 0)) {
2391                 free_printer_info_2(printer);
2392                 return ERROR_NOT_ENOUGH_MEMORY;
2393         }
2394
2395         /* clear memory */
2396         free_printer_info_2(printer);
2397
2398         if (*needed > offered) {
2399                 return ERROR_INSUFFICIENT_BUFFER;
2400         }
2401         else
2402                 return NT_STATUS_NO_PROBLEMO;
2403 }
2404
2405 /****************************************************************************
2406 ****************************************************************************/
2407 static uint32 getprinter_level_3(fstring servername, int snum, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
2408 {
2409         PRINTER_INFO_3 *printer=NULL;
2410         fstring temp;
2411
2412         fstrcpy(temp, "\\\\");
2413         fstrcat(temp, servername);
2414         if (!construct_printer_info_3(temp, &printer, snum))
2415                 return ERROR_NOT_ENOUGH_MEMORY;
2416
2417         /* check the required size. */
2418         *needed += spoolss_size_printer_info_3(printer);
2419
2420         if (!alloc_buffer_size(buffer, *needed)) {
2421                 free_printer_info_3(printer);
2422                 return ERROR_INSUFFICIENT_BUFFER;
2423         }
2424
2425         /* fill the buffer with the structures */
2426         new_smb_io_printer_info_3("", buffer, printer, 0);
2427
2428         /* clear memory */
2429         free_printer_info_3(printer);
2430
2431         if (*needed > offered) {
2432                 return ERROR_INSUFFICIENT_BUFFER;
2433         }
2434         else
2435                 return NT_STATUS_NO_PROBLEMO;
2436 }
2437
2438 /****************************************************************************
2439 ****************************************************************************/
2440 uint32 _spoolss_getprinter(POLICY_HND *handle, uint32 level,
2441                            NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
2442 {
2443         int snum;
2444         fstring servername;
2445
2446         *needed=0;
2447
2448         pstrcpy(servername, global_myname);
2449
2450         if (!get_printer_snum(handle, &snum))
2451                 return ERROR_INVALID_HANDLE;
2452
2453         switch (level) {
2454         case 0:
2455                 return getprinter_level_0(servername, snum, buffer, offered, needed);
2456         case 1:
2457                 return getprinter_level_1(servername,snum, buffer, offered, needed);
2458         case 2:
2459                 return getprinter_level_2(servername,snum, buffer, offered, needed);
2460         case 3:
2461                 return getprinter_level_3(servername,snum, buffer, offered, needed);
2462         default:
2463                 return ERROR_INVALID_LEVEL;
2464                 break;
2465         }
2466 }
2467
2468 /********************************************************************
2469  * construct_printer_driver_info_1
2470  * fill a construct_printer_driver_info_1 struct
2471  ********************************************************************/
2472 static void fill_printer_driver_info_1(DRIVER_INFO_1 *info,
2473                                        NT_PRINTER_DRIVER_INFO_LEVEL driver,
2474                                        fstring servername, fstring architecture)
2475 {
2476         init_unistr( &(info->name), driver.info_3->name);
2477 }
2478
2479 static void construct_printer_driver_info_1(DRIVER_INFO_1 *info, int snum,
2480                                             fstring servername, fstring architecture)
2481 {
2482         NT_PRINTER_INFO_LEVEL *printer = NULL;
2483         NT_PRINTER_DRIVER_INFO_LEVEL driver;
2484
2485         ZERO_STRUCT(driver);
2486
2487         get_a_printer(&printer, 2, lp_servicename(snum) );
2488         get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture);
2489
2490         fill_printer_driver_info_1(info, driver, servername, architecture);
2491
2492         free_a_printer(&printer,2);
2493 }
2494
2495 /********************************************************************
2496  * construct_printer_driver_info_2
2497  * fill a printer_info_2 struct
2498  ********************************************************************/
2499 static void fill_printer_driver_info_2(DRIVER_INFO_2 *info,
2500                                        NT_PRINTER_DRIVER_INFO_LEVEL driver,
2501                                        fstring servername, fstring architecture)
2502 {
2503         pstring where;
2504         pstring temp_driverpath;
2505         pstring temp_datafile;
2506         pstring temp_configfile;
2507         fstring short_archi;
2508
2509         get_short_archi(short_archi,architecture);
2510
2511         snprintf(where,sizeof(where)-1,"\\\\%s\\print$\\%s\\%s\\", servername, short_archi, driver.info_3->name);
2512
2513         info->version=driver.info_3->cversion;
2514
2515         init_unistr( &(info->name),         driver.info_3->name );
2516         init_unistr( &(info->architecture), architecture );
2517
2518         snprintf(temp_driverpath, sizeof(temp_driverpath)-1, "%s%s", where,
2519                  driver.info_3->driverpath);
2520         init_unistr( &(info->driverpath),   temp_driverpath );
2521
2522         snprintf(temp_datafile,   sizeof(temp_datafile)-1, "%s%s", where,
2523                  driver.info_3->datafile);
2524         init_unistr( &(info->datafile),     temp_datafile );
2525
2526         snprintf(temp_configfile, sizeof(temp_configfile)-1, "%s%s", where,
2527                  driver.info_3->configfile);
2528         init_unistr( &(info->configfile),   temp_configfile );
2529 }
2530
2531 /********************************************************************
2532  * construct_printer_driver_info_2
2533  * fill a printer_info_2 struct
2534  ********************************************************************/
2535 static void construct_printer_driver_info_2(DRIVER_INFO_2 *info, int snum, fstring servername, fstring architecture)
2536 {
2537         NT_PRINTER_INFO_LEVEL *printer = NULL;
2538         NT_PRINTER_DRIVER_INFO_LEVEL driver;
2539
2540         ZERO_STRUCT(printer);
2541         ZERO_STRUCT(driver);
2542
2543         get_a_printer(&printer, 2, lp_servicename(snum) );
2544         get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture);
2545
2546         fill_printer_driver_info_2(info, driver, servername, architecture);
2547
2548         free_a_printer(&printer,2);
2549 }
2550
2551 /********************************************************************
2552  * copy a strings array and convert to UNICODE
2553  *
2554  * convert an array of ascii string to a UNICODE string
2555  ********************************************************************/
2556 static void init_unistr_array(uint16 **uni_array, fstring *char_array, char *where)
2557 {
2558         int i=0;
2559         int j=0;
2560         char *v;
2561         pstring line;
2562
2563         DEBUG(6,("init_unistr_array\n"));
2564         *uni_array=NULL;
2565
2566         while (1) {
2567                 if (char_array == NULL)
2568                         v = "";
2569                 else {
2570                         v = char_array[i];
2571                         if (!v) v = ""; /* hack to handle null lists */
2572                 }
2573                 if (strlen(v) == 0) break;
2574                 snprintf(line, sizeof(line)-1, "%s%s", where, v);
2575                 DEBUGADD(6,("%d:%s:%d\n", i, line, strlen(line)));
2576                 if((*uni_array=Realloc(*uni_array, (j+strlen(line)+2)*sizeof(uint16))) == NULL) {
2577                         DEBUG(0,("init_unistr_array: Realloc error\n" ));
2578                         return;
2579                 }
2580                 j += (dos_PutUniCode((char *)(*uni_array+j), line , sizeof(uint16)*strlen(line), True) / sizeof(uint16) );
2581                 i++;
2582         }
2583
2584         if (*uni_array) {
2585                 (*uni_array)[j]=0x0000;
2586         }
2587
2588         DEBUGADD(6,("last one:done\n"));
2589 }
2590
2591 /********************************************************************
2592  * construct_printer_info_3
2593  * fill a printer_info_3 struct
2594  ********************************************************************/
2595 static void fill_printer_driver_info_3(DRIVER_INFO_3 *info,
2596                                        NT_PRINTER_DRIVER_INFO_LEVEL driver,
2597                                        fstring servername, fstring architecture)
2598 {
2599         pstring where;
2600         pstring temp_driverpath;
2601         pstring temp_datafile;
2602         pstring temp_configfile;
2603         pstring temp_helpfile;
2604         fstring short_archi;
2605
2606         get_short_archi(short_archi, architecture);
2607
2608 #if MANGLE_DRIVER_PATH
2609         snprintf(where,sizeof(where)-1,"\\\\%s\\print$\\%s\\%s\\", servername, short_archi, driver.info_3->name);
2610 #else
2611         snprintf(where,sizeof(where)-1,"\\\\%s\\print$\\%s\\", servername, short_archi);
2612 #endif
2613
2614         info->version=driver.info_3->cversion;
2615
2616         init_unistr( &info->name,         driver.info_3->name );
2617         init_unistr( &info->architecture, architecture );
2618
2619         snprintf(temp_driverpath, sizeof(temp_driverpath)-1, "%s%s", where, driver.info_3->driverpath);
2620         init_unistr( &info->driverpath, temp_driverpath );
2621
2622         snprintf(temp_datafile,   sizeof(temp_datafile)-1,   "%s%s", where, driver.info_3->datafile);
2623         init_unistr( &info->datafile, temp_datafile );
2624
2625         snprintf(temp_configfile, sizeof(temp_configfile)-1, "%s%s", where, driver.info_3->configfile);
2626         init_unistr( &info->configfile, temp_configfile );
2627
2628         snprintf(temp_helpfile,   sizeof(temp_helpfile)-1,   "%s%s", where, driver.info_3->helpfile);
2629         init_unistr( &info->helpfile, temp_helpfile );
2630
2631         init_unistr( &info->monitorname, driver.info_3->monitorname );
2632         init_unistr( &info->defaultdatatype, driver.info_3->defaultdatatype );
2633
2634         info->dependentfiles=NULL;
2635         init_unistr_array(&info->dependentfiles, driver.info_3->dependentfiles, where);
2636 }
2637
2638 /********************************************************************
2639  * construct_printer_info_3
2640  * fill a printer_info_3 struct
2641  ********************************************************************/
2642 static void construct_printer_driver_info_3(DRIVER_INFO_3 *info, int snum,
2643                                             fstring servername, fstring architecture)
2644 {
2645         NT_PRINTER_INFO_LEVEL *printer = NULL;
2646         NT_PRINTER_DRIVER_INFO_LEVEL driver;
2647
2648         ZERO_STRUCT(driver);
2649
2650         get_a_printer(&printer, 2, lp_servicename(snum) );
2651         get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture);
2652
2653         fill_printer_driver_info_3(info, driver, servername, architecture);
2654
2655         free_a_printer(&printer,2);
2656 }
2657
2658 /****************************************************************************
2659 ****************************************************************************/
2660
2661 static void free_printer_driver_info_3(DRIVER_INFO_3 *info)
2662 {
2663         safe_free(info->dependentfiles);
2664 }
2665
2666 /****************************************************************************
2667 ****************************************************************************/
2668 static uint32 getprinterdriver2_level1(fstring servername, fstring architecture, int snum, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
2669 {
2670         DRIVER_INFO_1 *info=NULL;
2671
2672         if((info=(DRIVER_INFO_1 *)malloc(sizeof(DRIVER_INFO_1))) == NULL)
2673                 return ERROR_NOT_ENOUGH_MEMORY;
2674
2675         construct_printer_driver_info_1(info, snum, servername, architecture);
2676
2677         /* check the required size. */
2678         *needed += spoolss_size_printer_driver_info_1(info);
2679
2680         if (!alloc_buffer_size(buffer, *needed)) {
2681                 safe_free(info);
2682                 return ERROR_INSUFFICIENT_BUFFER;
2683         }
2684
2685         /* fill the buffer with the structures */
2686         new_smb_io_printer_driver_info_1("", buffer, info, 0);
2687
2688         /* clear memory */
2689         safe_free(info);
2690
2691         if (*needed > offered)
2692                 return ERROR_INSUFFICIENT_BUFFER;
2693         else
2694                 return NT_STATUS_NO_PROBLEMO;
2695 }
2696
2697 /****************************************************************************
2698 ****************************************************************************/
2699 static uint32 getprinterdriver2_level2(fstring servername, fstring architecture, int snum, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
2700 {
2701         DRIVER_INFO_2 *info=NULL;
2702
2703         if((info=(DRIVER_INFO_2 *)malloc(sizeof(DRIVER_INFO_2))) == NULL)
2704                 return ERROR_NOT_ENOUGH_MEMORY;
2705
2706         construct_printer_driver_info_2(info, snum, servername, architecture);
2707
2708         /* check the required size. */
2709         *needed += spoolss_size_printer_driver_info_2(info);
2710
2711         if (!alloc_buffer_size(buffer, *needed)) {
2712                 safe_free(info);
2713                 return ERROR_INSUFFICIENT_BUFFER;
2714         }
2715
2716         /* fill the buffer with the structures */
2717         new_smb_io_printer_driver_info_2("", buffer, info, 0);
2718
2719         /* clear memory */
2720         safe_free(info);
2721
2722         if (*needed > offered)
2723                 return ERROR_INSUFFICIENT_BUFFER;
2724         else
2725                 return NT_STATUS_NO_PROBLEMO;
2726 }
2727
2728 /****************************************************************************
2729 ****************************************************************************/
2730 static uint32 getprinterdriver2_level3(fstring servername, fstring architecture, int snum, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
2731 {
2732         DRIVER_INFO_3 info;
2733
2734         ZERO_STRUCT(info);
2735
2736         construct_printer_driver_info_3(&info, snum, servername, architecture);
2737
2738         /* check the required size. */
2739         *needed += spoolss_size_printer_driver_info_3(&info);
2740
2741         if (!alloc_buffer_size(buffer, *needed)) {
2742                 free_printer_driver_info_3(&info);
2743                 return ERROR_INSUFFICIENT_BUFFER;
2744         }
2745
2746         /* fill the buffer with the structures */
2747         new_smb_io_printer_driver_info_3("", buffer, &info, 0);
2748
2749         free_printer_driver_info_3(&info);
2750
2751         if (*needed > offered)
2752                 return ERROR_INSUFFICIENT_BUFFER;
2753         else
2754                 return NT_STATUS_NO_PROBLEMO;
2755 }
2756
2757 /****************************************************************************
2758 ****************************************************************************/
2759 uint32 _spoolss_getprinterdriver2(const POLICY_HND *handle, const UNISTR2 *uni_arch, uint32 level,
2760                                 uint32 clientmajorversion, uint32 clientminorversion,
2761                                 NEW_BUFFER *buffer, uint32 offered,
2762                                 uint32 *needed, uint32 *servermajorversion, uint32 *serverminorversion)
2763 {
2764         fstring servername;
2765         fstring architecture;
2766         int snum;
2767
2768         DEBUG(4,("_spoolss_getprinterdriver2\n"));
2769
2770         *needed=0;
2771         *servermajorversion=0;
2772         *serverminorversion=0;
2773
2774         pstrcpy(servername, global_myname);
2775         unistr2_to_ascii(architecture, uni_arch, sizeof(architecture)-1);
2776
2777         if (!get_printer_snum(handle, &snum))
2778                 return ERROR_INVALID_HANDLE;
2779
2780         switch (level) {
2781         case 1:
2782                 return getprinterdriver2_level1(servername, architecture, snum, buffer, offered, needed);
2783                 break;
2784         case 2:
2785                 return getprinterdriver2_level2(servername, architecture, snum, buffer, offered, needed);
2786                 break;
2787         case 3:
2788                 return getprinterdriver2_level3(servername, architecture, snum, buffer, offered, needed);
2789                 break;
2790         default:
2791                 return ERROR_INVALID_LEVEL;
2792                 break;
2793         }
2794 }
2795
2796 /****************************************************************************
2797 ****************************************************************************/
2798 uint32 _spoolss_startpageprinter(const POLICY_HND *handle)
2799 {
2800         Printer_entry *Printer = find_printer_index_by_hnd(handle);
2801
2802         if (OPEN_HANDLE(Printer))
2803         {
2804                 Printer->page_started=True;
2805                 return 0x0;
2806         }
2807
2808         DEBUG(3,("Error in startpageprinter printer handle\n"));
2809         return ERROR_INVALID_HANDLE;
2810 }
2811
2812 /****************************************************************************
2813 ****************************************************************************/
2814 uint32 _spoolss_endpageprinter(const POLICY_HND *handle)
2815 {
2816         Printer_entry *Printer = find_printer_index_by_hnd(handle);
2817
2818         if (!OPEN_HANDLE(Printer))
2819         {
2820                 DEBUG(3,("Error in endpageprinter printer handle\n"));
2821                 return ERROR_INVALID_HANDLE;
2822         }
2823
2824         Printer->page_started=False;
2825
2826         return NT_STATUS_NO_PROBLEMO;
2827 }
2828
2829
2830 /********************************************************************
2831  * api_spoolss_getprinter
2832  * called from the spoolss dispatcher
2833  *
2834  ********************************************************************/
2835 uint32 _spoolss_startdocprinter(const POLICY_HND *handle, uint32 level,
2836                                 pipes_struct *p, DOC_INFO *docinfo,
2837                                 uint32 *jobid)
2838 {
2839         DOC_INFO_1 *info_1 = &docinfo->doc_info_1;
2840         int snum;
2841         pstring jobname;
2842         fstring datatype;
2843         Printer_entry *Printer = find_printer_index_by_hnd(handle);
2844         struct current_user user;
2845
2846         if (!OPEN_HANDLE(Printer))
2847         {
2848                 return ERROR_INVALID_HANDLE;
2849         }
2850
2851         if (p->ntlmssp_auth_validated) {
2852                 memcpy(&user, &p->pipe_user, sizeof(user));
2853         } else {
2854                 extern struct current_user current_user;
2855                 memcpy(&user, &current_user, sizeof(user));
2856         }
2857
2858         /*
2859          * a nice thing with NT is it doesn't listen to what you tell it.
2860          * when asked to send _only_ RAW datas, it tries to send datas
2861          * in EMF format.
2862          *
2863          * So I add checks like in NT Server ...
2864          *
2865          * lkclXXXX jean-francois, i love this kind of thing.  oh, well,
2866          * there's a bug in NT client-side code, so we'll fix it in the
2867          * server-side code. *nnnnnggggh!*
2868          */
2869
2870         if (info_1->p_datatype != 0)
2871         {
2872                 unistr2_to_ascii(datatype, &(info_1->docname), sizeof(datatype));
2873                 if (strcmp(datatype, "RAW") != 0)
2874                 {
2875                         (*jobid)=0;
2876                         return ERROR_INVALID_DATATYPE;
2877                 }
2878         }
2879
2880         /* get the share number of the printer */
2881         if (!get_printer_snum(handle, &snum))
2882         {
2883                 return ERROR_INVALID_HANDLE;
2884         }
2885
2886         unistr2_to_ascii(jobname, &info_1->docname, sizeof(jobname));
2887
2888         Printer->jobid = print_job_start(&user, snum, jobname);
2889
2890         /* need to map error codes properly - for now give out of
2891            memory as I don't know the correct codes (tridge) */
2892         if (Printer->jobid == -1) {
2893                 return ERROR_NOT_ENOUGH_MEMORY;
2894         }
2895
2896         Printer->document_started=True;
2897         (*jobid) = Printer->jobid;
2898
2899         return 0x0;
2900 }
2901
2902 /********************************************************************
2903  * api_spoolss_getprinter
2904  * called from the spoolss dispatcher
2905  *
2906  ********************************************************************/
2907 uint32 _spoolss_enddocprinter(const POLICY_HND *handle)
2908 {
2909         Printer_entry *Printer=find_printer_index_by_hnd(handle);
2910
2911         if (!OPEN_HANDLE(Printer))
2912         {
2913                 DEBUG(3,("Error in enddocprinter handle\n"));
2914                 return ERROR_INVALID_HANDLE;
2915         }
2916
2917         Printer->document_started=False;
2918         print_job_end(Printer->jobid);
2919         /* error codes unhandled so far ... */
2920
2921         return 0x0;
2922 }
2923
2924 /****************************************************************************
2925 ****************************************************************************/
2926 uint32 _spoolss_writeprinter( const POLICY_HND *handle,
2927                                 uint32 buffer_size,
2928                                 const uint8 *buffer,
2929                                 uint32 *buffer_written)
2930 {
2931         Printer_entry *Printer = find_printer_index_by_hnd(handle);
2932
2933         if (!OPEN_HANDLE(Printer))
2934         {
2935                 DEBUG(3,("Error in writeprinter handle\n"));
2936                 return ERROR_INVALID_HANDLE;
2937         }
2938
2939         (*buffer_written) = print_job_write(Printer->jobid, buffer, buffer_size);
2940
2941         return 0x0;
2942 }
2943
2944 /********************************************************************
2945  * api_spoolss_getprinter
2946  * called from the spoolss dispatcher
2947  *
2948  ********************************************************************/
2949 static uint32 control_printer(const POLICY_HND *handle, uint32 command,
2950                               pipes_struct *p)
2951 {
2952         struct current_user user;
2953         int snum;
2954         Printer_entry *Printer = find_printer_index_by_hnd(handle);
2955
2956         if (p->ntlmssp_auth_validated) {
2957                 memcpy(&user, &p->pipe_user, sizeof(user));
2958         } else {
2959                 extern struct current_user current_user;
2960                 memcpy(&user, &current_user, sizeof(user));
2961         }
2962
2963         if (!OPEN_HANDLE(Printer))
2964                 return ERROR_INVALID_HANDLE;
2965
2966         if (!get_printer_snum(handle, &snum) )
2967                 return ERROR_INVALID_HANDLE;
2968
2969         switch (command) {
2970         case PRINTER_CONTROL_PAUSE:
2971                 if (print_queue_pause(&user, snum)) {
2972                         return 0;
2973                 }
2974                 break;
2975         case PRINTER_CONTROL_RESUME:
2976         case PRINTER_CONTROL_UNPAUSE:
2977                 if (print_queue_resume(&user, snum)) {
2978                         return 0;
2979                 }
2980                 break;
2981         case PRINTER_CONTROL_PURGE:
2982                 if (print_queue_purge(&user, snum)) {
2983                         return 0;
2984                 }
2985                 break;
2986         }
2987
2988         return ERROR_INVALID_FUNCTION;
2989 }
2990
2991 /********************************************************************
2992  * called by spoolss_api_setprinter
2993  * when updating a printer description
2994  ********************************************************************/
2995 static uint32 update_printer_sec(const POLICY_HND *handle, uint32 level,
2996                                  const SPOOL_PRINTER_INFO_LEVEL *info,
2997                                  SEC_DESC_BUF *secdesc_ctr)
2998 {
2999         Printer_entry *Printer = find_printer_index_by_hnd(handle);
3000
3001         if (!OPEN_HANDLE(Printer))
3002                 return ERROR_INVALID_HANDLE;
3003
3004         return nt_printing_setsec(Printer->dev.printername, secdesc_ctr);
3005 }
3006
3007 /********************************************************************
3008  * called by spoolss_api_setprinter
3009  * when updating a printer description
3010  ********************************************************************/
3011
3012 static uint32 update_printer(const POLICY_HND *handle, uint32 level,
3013                            const SPOOL_PRINTER_INFO_LEVEL *info,
3014                            DEVICEMODE *devmode)
3015 {
3016         int snum;
3017         NT_PRINTER_INFO_LEVEL *printer = NULL;
3018         Printer_entry *Printer = find_printer_index_by_hnd(handle);
3019
3020         DEBUG(8,("update_printer\n"));
3021
3022         if (level!=2) {
3023                 DEBUG(0,("Send a mail to samba@samba.org\n"));
3024                 DEBUGADD(0,("with the following message: update_printer: level!=2\n"));
3025                 return ERROR_INVALID_LEVEL;
3026         }
3027
3028         if (!OPEN_HANDLE(Printer))
3029                 return ERROR_INVALID_HANDLE;
3030
3031         if (!get_printer_snum(handle, &snum) )
3032                 return ERROR_INVALID_HANDLE;
3033
3034         if(get_a_printer(&printer, 2, lp_servicename(snum)) != 0)
3035                 return ERROR_INVALID_HANDLE;
3036
3037         DEBUGADD(8,("Converting info_2 struct\n"));
3038
3039         /*
3040          * convert_printer_info converts the incoming
3041          * info from the client and overwrites the info
3042          * just read from the tdb in the pointer 'printer'.
3043          */
3044
3045         convert_printer_info(info, printer, level);
3046
3047         if (info->info_2->devmode_ptr != 0) {
3048                 /* we have a valid devmode
3049                    convert it and link it*/
3050
3051                 /*
3052                  * Ensure printer->info_2->devmode is a valid pointer
3053                  * as we will be overwriting it in convert_devicemode().
3054                  */
3055
3056                 if (printer->info_2->devmode == NULL)
3057                         printer->info_2->devmode = construct_nt_devicemode(printer->info_2->printername);
3058
3059                 DEBUGADD(8,("Converting the devicemode struct\n"));
3060                 convert_devicemode(devmode, printer->info_2->devmode);
3061
3062         } else {
3063                 if (printer->info_2->devmode != NULL)
3064                         free_nt_devicemode(&printer->info_2->devmode);
3065                 printer->info_2->devmode=NULL;
3066         }
3067
3068         if (add_a_printer(*printer, 2)!=0) {
3069                 /* I don't really know what to return here !!! */
3070                 free_a_printer(&printer, 2);
3071                 return ERROR_ACCESS_DENIED;
3072         }
3073
3074         free_a_printer(&printer, 2);
3075
3076         return NT_STATUS_NO_PROBLEMO;
3077 }
3078
3079 /****************************************************************************
3080 ****************************************************************************/
3081 uint32 _spoolss_setprinter(const POLICY_HND *handle, uint32 level,
3082                            const SPOOL_PRINTER_INFO_LEVEL *info,
3083                            DEVMODE_CTR devmode_ctr,
3084                            SEC_DESC_BUF *secdesc_ctr,
3085                            uint32 command, pipes_struct *p)
3086 {
3087         Printer_entry *Printer = find_printer_index_by_hnd(handle);
3088
3089         if (!OPEN_HANDLE(Printer))
3090                 return ERROR_INVALID_HANDLE;
3091
3092         /* check the level */
3093         switch (level) {
3094                 case 0:
3095                         return control_printer(handle, command, p);
3096                         break;
3097                 case 2:
3098                         return update_printer(handle, level, info, devmode_ctr.devmode);
3099                         break;
3100                 case 3:
3101                         return update_printer_sec(handle, level, info, secdesc_ctr);
3102                         break;
3103                 default:
3104                         return ERROR_INVALID_LEVEL;
3105                         break;
3106         }
3107 }
3108
3109 /****************************************************************************
3110 ****************************************************************************/
3111 uint32 _spoolss_fcpn(const POLICY_HND *handle)
3112 {
3113         Printer_entry *Printer= find_printer_index_by_hnd(handle);
3114
3115         if (!OPEN_HANDLE(Printer))
3116                 return ERROR_INVALID_HANDLE;
3117
3118         Printer->notify.flags=0;
3119         Printer->notify.options=0;
3120         Printer->notify.localmachine[0]='\0';
3121         Printer->notify.printerlocal=0;
3122         if (Printer->notify.option)
3123                 safe_free(Printer->notify.option->ctr.type);
3124         safe_free(Printer->notify.option);
3125         Printer->notify.option=NULL;
3126
3127         return NT_STATUS_NO_PROBLEMO;
3128 }
3129
3130 /****************************************************************************
3131 ****************************************************************************/
3132 uint32 _spoolss_addjob(const POLICY_HND *handle, uint32 level,
3133                         NEW_BUFFER *buffer, uint32 offered)
3134 {
3135         return NT_STATUS_NO_PROBLEMO;
3136 }
3137
3138 /****************************************************************************
3139 ****************************************************************************/
3140 static void fill_job_info_1(JOB_INFO_1 *job_info, print_queue_struct *queue,
3141                             int position, int snum)
3142 {
3143         pstring temp_name;
3144
3145         struct tm *t;
3146         time_t unixdate = time(NULL);
3147
3148         t=gmtime(&unixdate);
3149         snprintf(temp_name, sizeof(temp_name), "\\\\%s", global_myname);
3150
3151         job_info->jobid=queue->job;
3152         init_unistr(&(job_info->printername), lp_servicename(snum));
3153         init_unistr(&(job_info->machinename), temp_name);
3154         init_unistr(&(job_info->username), queue->user);
3155         init_unistr(&(job_info->document), queue->file);
3156         init_unistr(&(job_info->datatype), "RAW");
3157         init_unistr(&(job_info->text_status), "");
3158         job_info->status=nt_printj_status(queue->status);
3159         job_info->priority=queue->priority;
3160         job_info->position=position;
3161         job_info->totalpages=0;
3162         job_info->pagesprinted=0;
3163
3164         make_systemtime(&(job_info->submitted), t);
3165 }
3166
3167 /****************************************************************************
3168 ****************************************************************************/
3169 static BOOL fill_job_info_2(JOB_INFO_2 *job_info, print_queue_struct *queue,
3170                             int position, int snum)
3171 {
3172         pstring temp_name;
3173         NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
3174         pstring chaine;
3175
3176         struct tm *t;
3177         time_t unixdate = time(NULL);
3178
3179         if (get_a_printer(&ntprinter, 2, lp_servicename(snum)) !=0 )
3180                 return False;
3181
3182         t=gmtime(&unixdate);
3183         snprintf(temp_name, sizeof(temp_name), "\\\\%s", global_myname);
3184
3185         job_info->jobid=queue->job;
3186
3187         snprintf(chaine, sizeof(chaine)-1, "\\\\%s\\%s", global_myname, ntprinter->info_2->printername);
3188
3189         init_unistr(&(job_info->printername), chaine);
3190
3191         init_unistr(&(job_info->machinename), temp_name);
3192         init_unistr(&(job_info->username), queue->user);
3193         init_unistr(&(job_info->document), queue->file);
3194         init_unistr(&(job_info->notifyname), queue->user);
3195         init_unistr(&(job_info->datatype), "RAW");
3196         init_unistr(&(job_info->printprocessor), "winprint");
3197         init_unistr(&(job_info->parameters), "");
3198         init_unistr(&(job_info->text_status), "");
3199
3200 /* and here the security descriptor */
3201
3202         job_info->status=nt_printj_status(queue->status);
3203         job_info->priority=queue->priority;
3204         job_info->position=position;
3205         job_info->starttime=0;
3206         job_info->untiltime=0;
3207         job_info->totalpages=0;
3208         job_info->size=queue->size;
3209         make_systemtime(&(job_info->submitted), t);
3210         job_info->timeelapsed=0;
3211         job_info->pagesprinted=0;
3212
3213         if((job_info->devmode = construct_dev_mode(snum, global_myname)) == NULL) {
3214                 free_a_printer(&ntprinter, 2);
3215                 return False;
3216         }
3217
3218         free_a_printer(&ntprinter, 2);
3219         return (True);
3220 }
3221
3222 /****************************************************************************
3223  Enumjobs at level 1.
3224 ****************************************************************************/
3225 static uint32 enumjobs_level1(print_queue_struct *queue, int snum,
3226                               NEW_BUFFER *buffer, uint32 offered,
3227                               uint32 *needed, uint32 *returned)
3228 {
3229         JOB_INFO_1 *info;
3230         int i;
3231
3232         info=(JOB_INFO_1 *)malloc(*returned*sizeof(JOB_INFO_1));
3233         if (info==NULL) {
3234                 safe_free(queue);
3235                 *returned=0;
3236                 return ERROR_NOT_ENOUGH_MEMORY;
3237         }
3238
3239         for (i=0; i<*returned; i++)
3240                 fill_job_info_1(&(info[i]), &(queue[i]), i, snum);
3241
3242         safe_free(queue);
3243
3244         /* check the required size. */
3245         for (i=0; i<*returned; i++)
3246                 (*needed) += spoolss_size_job_info_1(&(info[i]));
3247
3248         if (!alloc_buffer_size(buffer, *needed)) {
3249                 safe_free(info);
3250                 return ERROR_INSUFFICIENT_BUFFER;
3251         }
3252
3253         /* fill the buffer with the structures */
3254         for (i=0; i<*returned; i++)
3255                 new_smb_io_job_info_1("", buffer, &(info[i]), 0);
3256
3257         /* clear memory */
3258         safe_free(info);
3259
3260         if (*needed > offered) {
3261                 *returned=0;
3262                 return ERROR_INSUFFICIENT_BUFFER;
3263         }
3264         else
3265                 return NT_STATUS_NO_PROBLEMO;
3266 }
3267
3268 /****************************************************************************
3269  Enumjobs at level 2.
3270 ****************************************************************************/
3271 static uint32 enumjobs_level2(print_queue_struct *queue, int snum,
3272                               NEW_BUFFER *buffer, uint32 offered,
3273                               uint32 *needed, uint32 *returned)
3274 {
3275         JOB_INFO_2 *info;
3276         int i;
3277
3278         info=(JOB_INFO_2 *)malloc(*returned*sizeof(JOB_INFO_2));
3279         if (info==NULL) {
3280                 safe_free(queue);
3281                 *returned=0;
3282                 return ERROR_NOT_ENOUGH_MEMORY;
3283         }
3284
3285         for (i=0; i<*returned; i++)
3286                 fill_job_info_2(&(info[i]), &(queue[i]), i, snum);
3287
3288         safe_free(queue);
3289
3290         /* check the required size. */
3291         for (i=0; i<*returned; i++)
3292                 (*needed) += spoolss_size_job_info_2(&(info[i]));
3293
3294         if (!alloc_buffer_size(buffer, *needed)) {
3295                 safe_free(info);
3296                 return ERROR_INSUFFICIENT_BUFFER;
3297         }
3298
3299         /* fill the buffer with the structures */
3300         for (i=0; i<*returned; i++)
3301                 new_smb_io_job_info_2("", buffer, &(info[i]), 0);
3302
3303         /* clear memory */
3304         safe_free(info);
3305
3306         if (*needed > offered) {
3307                 *returned=0;
3308                 return ERROR_INSUFFICIENT_BUFFER;
3309         }
3310         else
3311                 return NT_STATUS_NO_PROBLEMO;
3312 }
3313
3314 /****************************************************************************
3315  Enumjobs.
3316 ****************************************************************************/
3317 uint32 _spoolss_enumjobs( POLICY_HND *handle, uint32 firstjob, uint32 numofjobs, uint32 level,
3318                           NEW_BUFFER *buffer, uint32 offered,
3319                           uint32 *needed, uint32 *returned)
3320 {
3321         int snum;
3322         print_queue_struct *queue=NULL;
3323         print_status_struct prt_status;
3324
3325         DEBUG(4,("_spoolss_enumjobs\n"));
3326
3327         ZERO_STRUCT(prt_status);
3328
3329         *needed=0;
3330         *returned=0;
3331
3332         if (!get_printer_snum(handle, &snum))
3333                 return ERROR_INVALID_HANDLE;
3334
3335         *returned = print_queue_status(snum, &queue, &prt_status);
3336         DEBUGADD(4,("count:[%d], status:[%d], [%s]\n", *returned, prt_status.status, prt_status.message));
3337
3338         switch (level) {
3339         case 1:
3340                 return enumjobs_level1(queue, snum, buffer, offered, needed, returned);
3341                 break;
3342         case 2:
3343                 return enumjobs_level2(queue, snum, buffer, offered, needed, returned);
3344                 break;
3345         default:
3346                 safe_free(queue);
3347                 *returned=0;
3348                 return ERROR_INVALID_LEVEL;
3349                 break;
3350         }
3351 }
3352
3353
3354 /****************************************************************************
3355 ****************************************************************************/
3356 uint32 _spoolss_schedulejob( const POLICY_HND *handle, uint32 jobid)
3357 {
3358         return 0x0;
3359 }
3360
3361 /****************************************************************************
3362 ****************************************************************************/
3363 uint32 _spoolss_setjob( const POLICY_HND *handle,
3364                                 uint32 jobid,
3365                                 uint32 level,
3366                                 pipes_struct *p,
3367                                 JOB_INFO *ctr,
3368                                 uint32 command)
3369
3370 {
3371         struct current_user user;
3372         int snum;
3373         print_status_struct prt_status;
3374
3375         memset(&prt_status, 0, sizeof(prt_status));
3376
3377         if (!get_printer_snum(handle, &snum)) {
3378                 return ERROR_INVALID_HANDLE;
3379         }
3380
3381         if (!print_job_exists(jobid)) {
3382                 return ERROR_INVALID_PRINTER_NAME;
3383         }
3384
3385         if (p->ntlmssp_auth_validated) {
3386                 memcpy(&user, &p->pipe_user, sizeof(user));
3387         } else {
3388                 extern struct current_user current_user;
3389                 memcpy(&user, &current_user, sizeof(user));
3390         }
3391
3392         switch (command) {
3393         case JOB_CONTROL_CANCEL:
3394         case JOB_CONTROL_DELETE:
3395                 if (print_job_delete(&user, jobid)) return 0x0;
3396                 break;
3397         case JOB_CONTROL_PAUSE:
3398                 if (print_job_pause(&user, jobid)) return 0x0;
3399                 break;
3400         case JOB_CONTROL_RESUME:
3401                 if (print_job_resume(&user, jobid)) return 0x0;
3402                 break;
3403         default:
3404                 return ERROR_INVALID_LEVEL;
3405         }
3406
3407         return ERROR_INVALID_HANDLE;
3408 }
3409
3410 /****************************************************************************
3411  Enumerates all printer drivers at level 1.
3412 ****************************************************************************/
3413 static uint32 enumprinterdrivers_level1(fstring *list, fstring servername, fstring architecture, NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
3414 {
3415         int i;
3416         NT_PRINTER_DRIVER_INFO_LEVEL driver;
3417         DRIVER_INFO_1 *driver_info_1=NULL;
3418
3419         ZERO_STRUCT(driver);
3420
3421         if((driver_info_1=(DRIVER_INFO_1 *)malloc(*returned * sizeof(DRIVER_INFO_1))) == NULL)
3422                 return ERROR_NOT_ENOUGH_MEMORY;
3423
3424         for (i=0; i<*returned; i++) {
3425                 get_a_printer_driver(&driver, 3, list[i], architecture);
3426                 fill_printer_driver_info_1(&(driver_info_1[i]), driver, servername, architecture );
3427         }
3428
3429         safe_free(list);
3430
3431         /* check the required size. */
3432         for (i=0; i<*returned; i++) {
3433                 DEBUGADD(6,("adding driver [%d]'s size\n",i));
3434                 *needed += spoolss_size_printer_driver_info_1(&(driver_info_1[i]));
3435         }
3436
3437         if (!alloc_buffer_size(buffer, *needed)) {
3438                 safe_free(driver_info_1);
3439                 return ERROR_INSUFFICIENT_BUFFER;
3440         }
3441
3442         /* fill the buffer with the form structures */
3443         for (i=0; i<*returned; i++) {
3444                 DEBUGADD(6,("adding driver [%d] to buffer\n",i));
3445                 new_smb_io_printer_driver_info_1("", buffer, &(driver_info_1[i]), 0);
3446         }
3447
3448         safe_free(driver_info_1);
3449
3450         if (*needed > offered) {
3451                 *returned=0;
3452                 return ERROR_INSUFFICIENT_BUFFER;
3453         }
3454         else
3455                 return NT_STATUS_NO_PROBLEMO;
3456 }
3457
3458 /****************************************************************************
3459  Enumerates all printer drivers at level 2.
3460 ****************************************************************************/
3461 static uint32 enumprinterdrivers_level2(fstring *list, fstring servername, fstring architecture, NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
3462 {
3463         int i;
3464         DRIVER_INFO_2 *driver_info_2=NULL;
3465
3466         if (*returned > 0 &&
3467             !(driver_info_2=(DRIVER_INFO_2 *)malloc(*returned * sizeof(DRIVER_INFO_2))))
3468                 return ERROR_NOT_ENOUGH_MEMORY;
3469
3470         for (i=0; i<*returned; i++) {
3471                 NT_PRINTER_DRIVER_INFO_LEVEL driver;
3472                 ZERO_STRUCT(driver);
3473                 if (get_a_printer_driver(&driver, 3, list[i], architecture)
3474                     != 0) {
3475                         *returned = i;
3476                         break;
3477                 }
3478                 fill_printer_driver_info_2(&(driver_info_2[i]), driver, servername, architecture );
3479         }
3480
3481         safe_free(list);
3482
3483         /* check the required size. */
3484         for (i=0; i<*returned; i++) {
3485                 DEBUGADD(6,("adding driver [%d]'s size\n",i));
3486                 *needed += spoolss_size_printer_driver_info_2(&(driver_info_2[i]));
3487         }
3488
3489         if (!alloc_buffer_size(buffer, *needed)) {
3490                 safe_free(driver_info_2);
3491                 return ERROR_INSUFFICIENT_BUFFER;
3492         }
3493
3494         /* fill the buffer with the form structures */
3495         for (i=0; i<*returned; i++) {
3496                 DEBUGADD(6,("adding driver [%d] to buffer\n",i));
3497                 new_smb_io_printer_driver_info_2("", buffer, &(driver_info_2[i]), 0);
3498         }
3499
3500         safe_free(driver_info_2);
3501
3502         if (*needed > offered) {
3503                 *returned=0;
3504                 return ERROR_INSUFFICIENT_BUFFER;
3505         }
3506         else
3507                 return NT_STATUS_NO_PROBLEMO;
3508 }
3509
3510 /****************************************************************************
3511  Enumerates all printer drivers at level 3.
3512 ****************************************************************************/
3513 static uint32 enumprinterdrivers_level3(fstring *list, fstring servername, fstring architecture, NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
3514 {
3515         int i;
3516         NT_PRINTER_DRIVER_INFO_LEVEL driver;
3517         DRIVER_INFO_3 *driver_info_3=NULL;
3518
3519         ZERO_STRUCT(driver);
3520
3521         if((driver_info_3=(DRIVER_INFO_3 *)malloc((*returned)*sizeof(DRIVER_INFO_3))) == NULL)
3522                 return ERROR_NOT_ENOUGH_MEMORY;
3523
3524         for (i=0; i<*returned; i++) {
3525                 get_a_printer_driver(&driver, 3, list[i], architecture);
3526                 fill_printer_driver_info_3(&(driver_info_3[i]), driver, servername, architecture );
3527         }
3528
3529         safe_free(list);
3530
3531         /* check the required size. */
3532         for (i=0; i<*returned; i++) {
3533                 DEBUGADD(6,("adding driver [%d]'s size\n",i));
3534                 *needed += spoolss_size_printer_driver_info_3(&driver_info_3[i]);
3535         }
3536
3537         if (!alloc_buffer_size(buffer, *needed)) {
3538                 safe_free(driver_info_3);
3539                 return ERROR_INSUFFICIENT_BUFFER;
3540         }
3541
3542         /* fill the buffer with the form structures */
3543         for (i=0; i<*returned; i++) {
3544                 DEBUGADD(6,("adding form [%d] to buffer\n",i));
3545                 new_smb_io_printer_driver_info_3("", buffer, &driver_info_3[i], 0);
3546         }
3547
3548         for (i=0; i<*returned; i++)
3549                 safe_free(driver_info_3[i].dependentfiles);
3550
3551         safe_free(driver_info_3);
3552
3553         if (*needed > offered) {
3554                 *returned=0;
3555                 return ERROR_INSUFFICIENT_BUFFER;
3556         }
3557         else
3558                 return NT_STATUS_NO_PROBLEMO;
3559 }
3560
3561 /****************************************************************************
3562  Enumerates all printer drivers.
3563 ****************************************************************************/
3564 uint32 _spoolss_enumprinterdrivers( UNISTR2 *name, UNISTR2 *environment, uint32 level,
3565                                     NEW_BUFFER *buffer, uint32 offered,
3566                                     uint32 *needed, uint32 *returned)
3567 {
3568         int i;
3569         fstring *list = NULL;
3570         fstring servername;
3571         fstring architecture;
3572
3573         DEBUG(4,("_spoolss_enumprinterdrivers\n"));
3574         fstrcpy(servername, global_myname);
3575         *needed=0;
3576         *returned=0;
3577
3578         unistr2_to_ascii(architecture, environment, sizeof(architecture)-1);
3579         *returned=get_ntdrivers(&list, architecture);
3580
3581         DEBUGADD(4,("we have: [%d] drivers in environment [%s]\n", *returned, architecture));
3582         if(*returned == -1)
3583                 return ERROR_NOT_ENOUGH_MEMORY;
3584
3585         for (i=0; i<*returned; i++)
3586                 DEBUGADD(5,("driver: [%s]\n", list[i]));
3587
3588         switch (level) {
3589         case 1:
3590                 return enumprinterdrivers_level1(list, servername, architecture, buffer, offered, needed, returned);
3591                 break;
3592         case 2:
3593                 return enumprinterdrivers_level2(list, servername, architecture, buffer, offered, needed, returned);
3594                 break;
3595         case 3:
3596                 return enumprinterdrivers_level3(list, servername, architecture, buffer, offered, needed, returned);
3597                 break;
3598         default:
3599                 return ERROR_INVALID_LEVEL;
3600                 break;
3601         }
3602 }
3603
3604 /****************************************************************************
3605 ****************************************************************************/
3606 static void fill_form_1(FORM_1 *form, nt_forms_struct *list, int position)
3607 {
3608         form->flag=list->flag;
3609         init_unistr(&(form->name), list->name);
3610         form->width=list->width;
3611         form->length=list->length;
3612         form->left=list->left;
3613         form->top=list->top;
3614         form->right=list->right;
3615         form->bottom=list->bottom;
3616 }
3617
3618 /****************************************************************************
3619 ****************************************************************************/
3620 uint32 _new_spoolss_enumforms( const POLICY_HND *handle, uint32 level,
3621                                NEW_BUFFER *buffer, uint32 offered,
3622                                uint32 *needed, uint32 *numofforms)
3623 {
3624         nt_forms_struct *list=NULL;
3625         FORM_1 *forms_1;
3626         int buffer_size=0;
3627         int i;
3628
3629         DEBUG(4,("_new_spoolss_enumforms\n"));
3630         DEBUGADD(5,("Offered buffer size [%d]\n", offered));
3631         DEBUGADD(5,("Info level [%d]\n",          level));
3632
3633         *numofforms = get_ntforms(&list);
3634         DEBUGADD(5,("Number of forms [%d]\n",     *numofforms));
3635
3636         if (*numofforms == 0) return ERROR_NO_MORE_ITEMS;
3637
3638         switch (level) {
3639         case 1:
3640                 if ((forms_1=(FORM_1 *)malloc(*numofforms * sizeof(FORM_1))) == NULL) {
3641                         *numofforms=0;
3642                         return ERROR_NOT_ENOUGH_MEMORY;
3643                 }
3644
3645                 /* construct the list of form structures */
3646                 for (i=0; i<*numofforms; i++) {
3647                         DEBUGADD(6,("Filling form number [%d]\n",i));
3648                         fill_form_1(&(forms_1[i]), &(list[i]), i);
3649                 }
3650
3651                 safe_free(list);
3652
3653                 /* check the required size. */
3654                 for (i=0; i<*numofforms; i++) {
3655                         DEBUGADD(6,("adding form [%d]'s size\n",i));
3656                         buffer_size += spoolss_size_form_1(&(forms_1[i]));
3657                 }
3658
3659                 *needed=buffer_size;
3660
3661                 if (!alloc_buffer_size(buffer, buffer_size)){
3662                         safe_free(forms_1);
3663                         return ERROR_INSUFFICIENT_BUFFER;
3664                 }
3665
3666                 /* fill the buffer with the form structures */
3667                 for (i=0; i<*numofforms; i++) {
3668                         DEBUGADD(6,("adding form [%d] to buffer\n",i));
3669                         new_smb_io_form_1("", buffer, &(forms_1[i]), 0);
3670                 }
3671
3672                 safe_free(forms_1);
3673
3674                 if (*needed > offered) {
3675                         *numofforms=0;
3676                         return ERROR_INSUFFICIENT_BUFFER;
3677                 }
3678                 else
3679                         return NT_STATUS_NO_PROBLEMO;
3680
3681         default:
3682                 safe_free(list);
3683                 return ERROR_INVALID_LEVEL;
3684         }
3685
3686 }
3687
3688 /****************************************************************************
3689 ****************************************************************************/
3690 static void fill_port_1(PORT_INFO_1 *port, char *name)
3691 {
3692         init_unistr(&port->port_name, name);
3693 }
3694
3695 /****************************************************************************
3696 ****************************************************************************/
3697 static void fill_port_2(PORT_INFO_2 *port, char *name)
3698 {
3699         init_unistr(&port->port_name, name);
3700         init_unistr(&port->monitor_name, "Local Monitor");
3701         init_unistr(&port->description, "Local Port");
3702 #define PORT_TYPE_WRITE 1
3703         port->port_type=PORT_TYPE_WRITE;
3704         port->reserved=0x0;
3705 }
3706
3707 /****************************************************************************
3708  enumports level 1.
3709 ****************************************************************************/
3710 static uint32 enumports_level_1(NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
3711 {
3712         int n_services=lp_numservices();
3713         int snum;
3714         int i=0;
3715
3716         PORT_INFO_1 *ports=NULL;
3717
3718         for (snum=0; snum<n_services; snum++)
3719                 if ( lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum) )
3720                         (*returned)++;
3721
3722         if((ports=(PORT_INFO_1 *)malloc( (*returned+1) * sizeof(PORT_INFO_1) )) == NULL)
3723                 return ERROR_NOT_ENOUGH_MEMORY;
3724
3725         for (snum=0; snum<n_services; snum++) {
3726                 if ( lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum) ) {
3727                         /*
3728                          * Ensure this port name is unique.
3729                          */
3730                         int j;
3731
3732                         DEBUG(10,("enumports_level_1: port name %s\n", PRINTERNAME(snum)));
3733
3734                         for(j = 0; j < i; j++) {
3735                                 fstring port_name;
3736                                 unistr_to_dos(port_name, (const char *)&ports[j].port_name.buffer[0], sizeof(port_name));
3737
3738                                 if (strequal(port_name, PRINTERNAME(snum)))
3739                                         break;
3740                         }
3741
3742                         if (j < i)
3743                                 continue;
3744
3745                         DEBUGADD(6,("Filling port number [%d]\n", i));
3746                         fill_port_1(&ports[i], PRINTERNAME(snum));
3747                         i++;
3748                 }
3749         }
3750
3751         *returned = i;
3752
3753         /* check the required size. */
3754         for (i=0; i<*returned; i++) {
3755                 DEBUGADD(6,("adding port [%d]'s size\n", i));
3756                 *needed += spoolss_size_port_info_1(&ports[i]);
3757         }
3758
3759         if (!alloc_buffer_size(buffer, *needed)) {
3760                 safe_free(ports);
3761                 return ERROR_INSUFFICIENT_BUFFER;
3762         }
3763
3764         /* fill the buffer with the ports structures */
3765         for (i=0; i<*returned; i++) {
3766                 DEBUGADD(6,("adding port [%d] to buffer\n", i));
3767                 new_smb_io_port_1("", buffer, &ports[i], 0);
3768         }
3769
3770         safe_free(ports);
3771
3772         if (*needed > offered) {
3773                 *returned=0;
3774                 return ERROR_INSUFFICIENT_BUFFER;
3775         }
3776         else
3777                 return NT_STATUS_NO_PROBLEMO;
3778 }
3779
3780 /****************************************************************************
3781  enumports level 2.
3782 ****************************************************************************/
3783
3784 static uint32 enumports_level_2(NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
3785 {
3786         int n_services=lp_numservices();
3787         int snum;
3788         int i=0;
3789
3790         PORT_INFO_2 *ports=NULL;
3791
3792         for (snum=0; snum<n_services; snum++)
3793                 if ( lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum) )
3794                         (*returned)++;
3795
3796         if((ports=(PORT_INFO_2 *)malloc( (*returned+1) * sizeof(PORT_INFO_2) )) == NULL)
3797                 return ERROR_NOT_ENOUGH_MEMORY;
3798
3799         for (snum=0; snum<n_services; snum++) {
3800                 if ( lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum) ) {
3801                         /*
3802                          * Ensure this port name is unique.
3803                          */
3804                         int j;
3805
3806                         DEBUG(10,("enumports_level_2: port name %s\n", PRINTERNAME(snum)));
3807
3808                         for(j = 0; j < i; j++) {
3809                                 fstring port_name;
3810                                 unistr_to_dos(port_name, (const char *)&ports[j].port_name.buffer[0], sizeof(port_name));
3811
3812                                 if (strequal(port_name, PRINTERNAME(snum)))
3813                                         break;
3814                         }
3815
3816                         if (j < i)
3817                                 continue;
3818
3819                         DEBUGADD(6,("Filling port number [%d]\n", i));
3820                         fill_port_2(&ports[i], PRINTERNAME(snum));
3821                         i++;
3822                 }
3823         }
3824
3825         *returned = i;
3826
3827         /* check the required size. */
3828         for (i=0; i<*returned; i++) {
3829                 DEBUGADD(6,("adding port [%d]'s size\n", i));
3830                 *needed += spoolss_size_port_info_2(&ports[i]);
3831         }
3832
3833         if (!alloc_buffer_size(buffer, *needed)) {
3834                 safe_free(ports);
3835                 return ERROR_INSUFFICIENT_BUFFER;
3836         }
3837
3838         /* fill the buffer with the ports structures */
3839         for (i=0; i<*returned; i++) {
3840                 DEBUGADD(6,("adding port [%d] to buffer\n", i));
3841                 new_smb_io_port_2("", buffer, &ports[i], 0);
3842         }
3843
3844         safe_free(ports);
3845
3846         if (*needed > offered) {
3847                 *returned=0;
3848                 return ERROR_INSUFFICIENT_BUFFER;
3849         }
3850         else
3851                 return NT_STATUS_NO_PROBLEMO;
3852 }
3853
3854 /****************************************************************************
3855  enumports.
3856 ****************************************************************************/
3857 uint32 _spoolss_enumports( UNISTR2 *name, uint32 level,
3858                            NEW_BUFFER *buffer, uint32 offered,
3859                            uint32 *needed, uint32 *returned)
3860 {
3861         DEBUG(4,("_spoolss_enumports\n"));
3862
3863         *returned=0;
3864         *needed=0;
3865
3866         switch (level) {
3867         case 1:
3868                 return enumports_level_1(buffer, offered, needed, returned);
3869                 break;
3870         case 2:
3871                 return enumports_level_2(buffer, offered, needed, returned);
3872                 break;
3873         default:
3874                 return ERROR_INVALID_LEVEL;
3875                 break;
3876         }
3877 }
3878
3879 /****************************************************************************
3880 ****************************************************************************/
3881 static uint32 spoolss_addprinterex_level_2( const UNISTR2 *uni_srv_name,
3882                                 const SPOOL_PRINTER_INFO_LEVEL *info,
3883                                 uint32 unk0, uint32 unk1, uint32 unk2, uint32 unk3,
3884                                 uint32 user_switch, const SPOOL_USER_CTR *user,
3885                                 POLICY_HND *handle)
3886 {
3887         NT_PRINTER_INFO_LEVEL *printer = NULL;
3888         fstring name;
3889         fstring share_name;
3890
3891         if ((printer = (NT_PRINTER_INFO_LEVEL *)malloc(sizeof(NT_PRINTER_INFO_LEVEL))) == NULL) {
3892                 DEBUG(0,("spoolss_addprinterex_level_2: malloc fail.\n"));
3893                 return ERROR_NOT_ENOUGH_MEMORY;
3894         }
3895
3896         ZERO_STRUCTP(printer);
3897
3898         clear_handle(handle);
3899
3900         /* convert from UNICODE to ASCII - this allocates the info_2 struct inside *printer.*/
3901         convert_printer_info(info, printer, 2);
3902
3903         unistr2_to_ascii(share_name, &info->info_2->printername, sizeof(share_name)-1);
3904
3905         slprintf(name, sizeof(name)-1, "\\\\%s\\%s", global_myname, share_name);
3906
3907         /* write the ASCII on disk */
3908         if (add_a_printer(*printer, 2) != 0) {
3909                 free_a_printer(&printer,2);
3910                 return ERROR_ACCESS_DENIED;
3911         }
3912
3913         create_printer_hnd(handle);
3914
3915         open_printer_hnd(handle);
3916
3917         if (!set_printer_hnd_printertype(handle, name)) {
3918                 free_a_printer(&printer,2);
3919                 close_printer_handle(handle);
3920                 return ERROR_ACCESS_DENIED;
3921         }
3922
3923         if (!set_printer_hnd_printername(handle, name)) {
3924                 free_a_printer(&printer,2);
3925                 close_printer_handle(handle);
3926                 return ERROR_ACCESS_DENIED;
3927         }
3928
3929         free_a_printer(&printer,2);
3930         return NT_STATUS_NO_PROBLEMO;
3931 }
3932
3933 /****************************************************************************
3934 ****************************************************************************/
3935 uint32 _spoolss_addprinterex( const UNISTR2 *uni_srv_name, uint32 level,
3936                                 const SPOOL_PRINTER_INFO_LEVEL *info,
3937                                 uint32 unk0, uint32 unk1, uint32 unk2, uint32 unk3,
3938                                 uint32 user_switch, const SPOOL_USER_CTR *user,
3939                                 POLICY_HND *handle)
3940 {
3941         switch (level) {
3942                 case 1:
3943                         /* we don't handle yet */
3944                         /* but I know what to do ... */
3945                         return ERROR_INVALID_LEVEL;
3946                         break;
3947                 case 2:
3948                         return spoolss_addprinterex_level_2(uni_srv_name, info,
3949                                                             unk0, unk1, unk2, unk3,
3950                                                             user_switch, user, handle);
3951                         break;
3952                 default:
3953                         return ERROR_INVALID_LEVEL;
3954                         break;
3955         }
3956 }
3957
3958 /****************************************************************************
3959  Modify internal driver heirarchy.
3960 ****************************************************************************/
3961
3962 #if MANGLE_DRIVER_PATH
3963 static uint32 modify_driver_heirarchy(NT_PRINTER_DRIVER_INFO_LEVEL *driver, uint32 level)
3964 {
3965         pstring path_old;
3966         pstring path_new;
3967         pstring short_archi;
3968         pstring model_name;
3969
3970         /* find_service is an smbd-specific function call */
3971         int snum = find_service("print$");
3972         char *model = NULL;
3973
3974         *short_archi = '\0';
3975         switch (level) {
3976                 case 3:
3977                         get_short_archi(short_archi, driver->info_3->environment);
3978                         model = driver->info_3->name;
3979                         break;
3980                 case 6:
3981                         get_short_archi(short_archi, driver->info_6->environment);
3982                         model = driver->info_6->name;
3983                         break;
3984                 default:
3985                         DEBUG(0,("modify_driver_heirarchy: unknown info level (%d)\n", level));
3986                         return ERROR_INVALID_LEVEL;
3987                         break;
3988         }
3989
3990         slprintf(path_old, sizeof(path_old)-1, "%s/%s/TMP_%s", lp_pathname(snum), short_archi,
3991                 client_addr());
3992
3993         /* Clean up any '/' and other characters in the model name. */
3994         alpha_strcpy(model_name, model, sizeof(pstring));
3995
3996         slprintf(path_new, sizeof(path_new)-1, "%s/%s/%s", lp_pathname(snum), short_archi, model_name);
3997
3998         DEBUG(10,("modify_driver_heirarchy: old_path=%s, new_path=%s\n",
3999                         path_old, path_new ));
4000         if (dos_rename(path_old, path_new) == -1) {
4001                 DEBUG(0,("modify_driver_heirarchy: rename from %s to %s failed (%s)\n",
4002                         path_old, path_new, strerror(errno) ));
4003                 /* We need to clean up here.... - how ? */
4004                 return ERROR_ACCESS_DENIED; /* We need a generic mapping from NT errors here... */
4005         }
4006
4007         return NT_STATUS_NO_PROBLEMO;
4008 }
4009 #endif
4010
4011 /****************************************************************************
4012 ****************************************************************************/
4013 uint32 _spoolss_addprinterdriver( const UNISTR2 *server_name,
4014                                 uint32 level,
4015                                 const SPOOL_PRINTER_DRIVER_INFO_LEVEL *info)
4016 {
4017         uint32 err = NT_STATUS_NO_PROBLEMO;
4018         NT_PRINTER_DRIVER_INFO_LEVEL driver;
4019         ZERO_STRUCT(driver);
4020
4021         convert_printer_driver_info(info, &driver, level);
4022
4023         if (add_a_printer_driver(driver, level)!=0)
4024                 return ERROR_ACCESS_DENIED;
4025
4026 #if MANGLE_DRIVER_PATH
4027         err = modify_driver_heirarchy(&driver, level);
4028 #endif
4029
4030         free_a_printer_driver(driver, level);
4031
4032         return err;
4033 }
4034
4035 /****************************************************************************
4036 ****************************************************************************/
4037 static void fill_driverdir_1(DRIVER_DIRECTORY_1 *info, char *name)
4038 {
4039         init_unistr(&(info->name), name);
4040 }
4041
4042 /****************************************************************************
4043 ****************************************************************************/
4044 static uint32 getprinterdriverdir_level_1(UNISTR2 *name, UNISTR2 *uni_environment, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
4045 {
4046         pstring path;
4047         pstring long_archi;
4048         pstring short_archi;
4049         DRIVER_DIRECTORY_1 *info=NULL;
4050
4051         if((info=(DRIVER_DIRECTORY_1 *)malloc(sizeof(DRIVER_DIRECTORY_1))) == NULL)
4052                 return ERROR_NOT_ENOUGH_MEMORY;
4053
4054         unistr2_to_ascii(long_archi, uni_environment, sizeof(long_archi)-1);
4055         get_short_archi(short_archi, long_archi);
4056
4057 #if MANGLE_DRIVER_PATH
4058         slprintf(path, sizeof(path)-1, "\\\\%s\\print$\\%s\\TMP_%s", global_myname, short_archi,
4059                 client_addr());
4060 #else
4061         slprintf(path, sizeof(path)-1, "\\\\%s\\print$\\%s",
4062                         global_myname, short_archi);
4063 #endif
4064         DEBUG(4,("printer driver directory: [%s]\n", path));
4065
4066         fill_driverdir_1(info, path);
4067
4068         *needed += spoolss_size_driverdir_info_1(info);
4069
4070         if (!alloc_buffer_size(buffer, *needed)) {
4071                 safe_free(info);
4072                 return ERROR_INSUFFICIENT_BUFFER;
4073         }
4074
4075         new_smb_io_driverdir_1("", buffer, info, 0);
4076
4077         safe_free(info);
4078
4079         if (*needed > offered)
4080                 return ERROR_INSUFFICIENT_BUFFER;
4081         else
4082                 return NT_STATUS_NO_PROBLEMO;
4083 }
4084
4085 /****************************************************************************
4086 ****************************************************************************/
4087 uint32 _spoolss_getprinterdriverdirectory(UNISTR2 *name, UNISTR2 *uni_environment, uint32 level,
4088                                         NEW_BUFFER *buffer, uint32 offered,
4089                                         uint32 *needed)
4090 {
4091         DEBUG(4,("_spoolss_getprinterdriverdirectory\n"));
4092
4093         *needed=0;
4094
4095         switch(level) {
4096         case 1:
4097                 return getprinterdriverdir_level_1(name, uni_environment, buffer, offered, needed);
4098                 break;
4099         default:
4100                 return ERROR_INVALID_LEVEL;
4101                 break;
4102         }
4103 }
4104
4105 /****************************************************************************
4106 ****************************************************************************/
4107 uint32 _spoolss_enumprinterdata(const POLICY_HND *handle, uint32 idx,
4108                                 uint32 in_value_len, uint32 in_data_len,
4109                                 uint32 *out_max_value_len, uint16 **out_value, uint32 *out_value_len,
4110                                 uint32 *out_type,
4111                                 uint32 *out_max_data_len, uint8  **data_out, uint32 *out_data_len)
4112 {
4113         NT_PRINTER_INFO_LEVEL *printer = NULL;
4114
4115         fstring value;
4116
4117         uint32 param_index;
4118         uint32 biggest_valuesize;
4119         uint32 biggest_datasize;
4120         uint32 data_len;
4121         Printer_entry *Printer = find_printer_index_by_hnd(handle);
4122         int snum;
4123         uint8 *data=NULL;
4124         uint32 type;
4125
4126         ZERO_STRUCT(printer);
4127
4128         *out_max_value_len=0;
4129         *out_value=NULL;
4130         *out_value_len=0;
4131
4132         *out_type=0;
4133
4134         *out_max_data_len=0;
4135         *data_out=NULL;
4136         *out_data_len=0;
4137
4138         DEBUG(5,("spoolss_enumprinterdata\n"));
4139
4140         if (!OPEN_HANDLE(Printer))
4141                 return ERROR_INVALID_HANDLE;
4142
4143         if (!get_printer_snum(handle, &snum))
4144                 return ERROR_INVALID_HANDLE;
4145
4146         if (get_a_printer(&printer, 2, lp_servicename(snum)) != 0)
4147                 return ERROR_INVALID_HANDLE;
4148
4149         /*
4150          * The NT machine wants to know the biggest size of value and data
4151          *
4152          * cf: MSDN EnumPrinterData remark section
4153          */
4154         if ( (in_value_len==0) && (in_data_len==0) ) {
4155                 DEBUGADD(6,("Activating NT mega-hack to find sizes\n"));
4156
4157                 param_index=0;
4158                 biggest_valuesize=0;
4159                 biggest_datasize=0;
4160
4161                 while (get_specific_param_by_index(*printer, 2, param_index, value, &data, &type, &data_len)) {
4162                         if (strlen(value) > biggest_valuesize) biggest_valuesize=strlen(value);
4163                         if (data_len > biggest_datasize) biggest_datasize=data_len;
4164
4165                         DEBUG(6,("current values: [%d], [%d]\n", biggest_valuesize, biggest_datasize));
4166
4167                         safe_free(data);
4168                         param_index++;
4169                 }
4170
4171                 /* the value is an UNICODE string but realvaluesize is the length in bytes including the leading 0 */
4172                 *out_value_len=2*(1+biggest_valuesize);
4173                 *out_data_len=biggest_datasize;
4174
4175                 DEBUG(6,("final values: [%d], [%d]\n", *out_value_len, *out_data_len));
4176
4177                 free_a_printer(&printer, 2);
4178                 return NT_STATUS_NO_PROBLEMO;
4179         }
4180
4181         /*
4182          * the value len is wrong in NT sp3
4183          * that's the number of bytes not the number of unicode chars
4184          */
4185
4186         if (!get_specific_param_by_index(*printer, 2, idx, value, &data, &type, &data_len)) {
4187                 safe_free(data);
4188                 free_a_printer(&printer, 2);
4189                 return ERROR_NO_MORE_ITEMS;
4190         }
4191
4192         free_a_printer(&printer, 2);
4193
4194         /*
4195          * the value is:
4196          * - counted in bytes in the request
4197          * - counted in UNICODE chars in the max reply
4198          * - counted in bytes in the real size
4199          *
4200          * take a pause *before* coding not *during* coding
4201          */
4202
4203         *out_max_value_len=(in_value_len/sizeof(uint16));
4204         if((*out_value=(uint16 *)malloc(in_value_len*sizeof(uint8))) == NULL) {
4205                 safe_free(data);
4206                 return ERROR_NOT_ENOUGH_MEMORY;
4207         }
4208         *out_value_len = (uint32)dos_PutUniCode((char *)*out_value, value, in_value_len, True);
4209 #if 0 /* JRATEST */
4210         *out_max_value_len=(*out_value_len/sizeof(uint16));
4211 #endif /* JRATEST */
4212
4213         *out_type=type;
4214
4215         /* the data is counted in bytes */
4216         *out_max_data_len=in_data_len;
4217         if((*data_out=(uint8 *)malloc(in_data_len*sizeof(uint8))) == NULL) {
4218                 safe_free(data);
4219                 return ERROR_NOT_ENOUGH_MEMORY;
4220         }
4221         memcpy(*data_out, data, (size_t)data_len);
4222         *out_data_len=data_len;
4223 #if 0 /* JRATEST */
4224         *out_max_data_len=data_len;
4225 #endif /* JRATEST */
4226
4227         safe_free(data);
4228
4229         return NT_STATUS_NO_PROBLEMO;
4230 }
4231
4232 /****************************************************************************
4233 ****************************************************************************/
4234 uint32 _spoolss_setprinterdata( const POLICY_HND *handle,
4235                                 const UNISTR2 *value,
4236                                 uint32 type,
4237                                 uint32 max_len,
4238                                 const uint8 *data,
4239                                 uint32 real_len,
4240                                 uint32 numeric_data)
4241 {
4242         NT_PRINTER_INFO_LEVEL *printer = NULL;
4243         NT_PRINTER_PARAM *param = NULL;
4244
4245         int snum=0;
4246         uint32 status = 0x0;
4247         Printer_entry *Printer=find_printer_index_by_hnd(handle);
4248
4249         DEBUG(5,("spoolss_setprinterdata\n"));
4250
4251
4252         if (!OPEN_HANDLE(Printer))
4253                 return ERROR_INVALID_HANDLE;
4254
4255         if (!get_printer_snum(handle, &snum))
4256                 return ERROR_INVALID_HANDLE;
4257
4258         status = get_a_printer(&printer, 2, lp_servicename(snum));
4259         if (status != 0x0)
4260                 return ERROR_INVALID_NAME;
4261
4262         convert_specific_param(&param, value , type, data, real_len);
4263         unlink_specific_param_if_exist(printer->info_2, param);
4264
4265         if (!add_a_specific_param(printer->info_2, param))
4266                 status = ERROR_INVALID_PARAMETER;
4267         else
4268                 status = add_a_printer(*printer, 2);
4269
4270         free_a_printer(&printer, 2);
4271         return status;
4272 }
4273
4274 /****************************************************************************
4275 ****************************************************************************/
4276 uint32 _spoolss_addform( const POLICY_HND *handle,
4277                                 uint32 level,
4278                                 const FORM *form)
4279 {
4280         int count=0;
4281         nt_forms_struct *list=NULL;
4282         Printer_entry *Printer = find_printer_index_by_hnd(handle);
4283
4284         DEBUG(5,("spoolss_addform\n"));
4285
4286         if (!OPEN_HANDLE(Printer))
4287                 return ERROR_INVALID_HANDLE;
4288
4289         count=get_ntforms(&list);
4290         if(!add_a_form(&list, form, &count))
4291                 return ERROR_NOT_ENOUGH_MEMORY;
4292         write_ntforms(&list, count);
4293
4294         safe_free(list);
4295
4296         return 0x0;
4297 }
4298
4299 /****************************************************************************
4300 ****************************************************************************/
4301 uint32 _spoolss_setform( const POLICY_HND *handle,
4302                                 const UNISTR2 *uni_name,
4303                                 uint32 level,
4304                                 const FORM *form)
4305 {
4306         int count=0;
4307         nt_forms_struct *list=NULL;
4308         Printer_entry *Printer = find_printer_index_by_hnd(handle);
4309
4310         DEBUG(5,("spoolss_setform\n"));
4311
4312         if (!OPEN_HANDLE(Printer))
4313         {
4314                 return ERROR_INVALID_HANDLE;
4315         }
4316         count=get_ntforms(&list);
4317         update_a_form(&list, form, count);
4318         write_ntforms(&list, count);
4319
4320         safe_free(list);
4321
4322         return 0x0;
4323 }
4324
4325 /****************************************************************************
4326  enumprintprocessors level 1.
4327 ****************************************************************************/
4328 static uint32 enumprintprocessors_level_1(NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
4329 {
4330         PRINTPROCESSOR_1 *info_1=NULL;
4331
4332         if((info_1 = (PRINTPROCESSOR_1 *)malloc(sizeof(PRINTPROCESSOR_1))) == NULL)
4333                 return ERROR_NOT_ENOUGH_MEMORY;
4334
4335         (*returned) = 0x1;
4336
4337         init_unistr(&(info_1->name), "winprint");
4338
4339         *needed += spoolss_size_printprocessor_info_1(info_1);
4340
4341         if (!alloc_buffer_size(buffer, *needed))
4342                 return ERROR_INSUFFICIENT_BUFFER;
4343
4344         smb_io_printprocessor_info_1("", buffer, info_1, 0);
4345
4346         safe_free(info_1);
4347
4348         if (*needed > offered) {
4349                 *returned=0;
4350                 return ERROR_INSUFFICIENT_BUFFER;
4351         }
4352         else
4353                 return NT_STATUS_NO_PROBLEMO;
4354 }
4355
4356 /****************************************************************************
4357 ****************************************************************************/
4358 uint32 _spoolss_enumprintprocessors(UNISTR2 *name, UNISTR2 *environment, uint32 level,
4359                                     NEW_BUFFER *buffer, uint32 offered,
4360                                     uint32 *needed, uint32 *returned)
4361 {
4362         DEBUG(5,("spoolss_enumprintprocessors\n"));
4363
4364         /*
4365          * Enumerate the print processors ...
4366          *
4367          * Just reply with "winprint", to keep NT happy
4368          * and I can use my nice printer checker.
4369          */
4370
4371         *returned=0;
4372         *needed=0;
4373
4374         switch (level) {
4375         case 1:
4376                 return enumprintprocessors_level_1(buffer, offered, needed, returned);
4377                 break;
4378         default:
4379                 return ERROR_INVALID_LEVEL;
4380                 break;
4381         }
4382 }
4383
4384 /****************************************************************************
4385  enumprintprocdatatypes level 1.
4386 ****************************************************************************/
4387 static uint32 enumprintprocdatatypes_level_1(NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
4388 {
4389         PRINTPROCDATATYPE_1 *info_1=NULL;
4390
4391         if((info_1 = (PRINTPROCDATATYPE_1 *)malloc(sizeof(PRINTPROCDATATYPE_1))) == NULL)
4392                 return ERROR_NOT_ENOUGH_MEMORY;
4393
4394         (*returned) = 0x1;
4395
4396         init_unistr(&(info_1->name), "RAW");
4397
4398         *needed += spoolss_size_printprocdatatype_info_1(info_1);
4399
4400         if (!alloc_buffer_size(buffer, *needed))
4401                 return ERROR_INSUFFICIENT_BUFFER;
4402
4403         smb_io_printprocdatatype_info_1("", buffer, info_1, 0);
4404
4405         safe_free(info_1);
4406
4407         if (*needed > offered) {
4408                 *returned=0;
4409                 return ERROR_INSUFFICIENT_BUFFER;
4410         }
4411         else
4412                 return NT_STATUS_NO_PROBLEMO;
4413 }
4414
4415 /****************************************************************************
4416 ****************************************************************************/
4417 uint32 _spoolss_enumprintprocdatatypes(UNISTR2 *name, UNISTR2 *processor, uint32 level,
4418                                         NEW_BUFFER *buffer, uint32 offered,
4419                                         uint32 *needed, uint32 *returned)
4420 {
4421         DEBUG(5,("_spoolss_enumprintprocdatatypes\n"));
4422
4423         *returned=0;
4424         *needed=0;
4425
4426         switch (level) {
4427         case 1:
4428                 return enumprintprocdatatypes_level_1(buffer, offered, needed, returned);
4429                 break;
4430         default:
4431                 return ERROR_INVALID_LEVEL;
4432                 break;
4433         }
4434 }
4435
4436 /****************************************************************************
4437  enumprintmonitors level 1.
4438 ****************************************************************************/
4439 static uint32 enumprintmonitors_level_1(NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
4440 {
4441         PRINTMONITOR_1 *info_1=NULL;
4442
4443         if((info_1 = (PRINTMONITOR_1 *)malloc(sizeof(PRINTMONITOR_1))) == NULL)
4444                 return ERROR_NOT_ENOUGH_MEMORY;
4445
4446         (*returned) = 0x1;
4447
4448         init_unistr(&(info_1->name), "Local Port");
4449
4450         *needed += spoolss_size_printmonitor_info_1(info_1);
4451
4452         if (!alloc_buffer_size(buffer, *needed))
4453                 return ERROR_INSUFFICIENT_BUFFER;
4454
4455         smb_io_printmonitor_info_1("", buffer, info_1, 0);
4456
4457         safe_free(info_1);
4458
4459         if (*needed > offered) {
4460                 *returned=0;
4461                 return ERROR_INSUFFICIENT_BUFFER;
4462         }
4463         else
4464                 return NT_STATUS_NO_PROBLEMO;
4465 }
4466
4467 /****************************************************************************
4468  enumprintmonitors level 2.
4469 ****************************************************************************/
4470 static uint32 enumprintmonitors_level_2(NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
4471 {
4472         PRINTMONITOR_2 *info_2=NULL;
4473
4474         if((info_2 = (PRINTMONITOR_2 *)malloc(sizeof(PRINTMONITOR_2))) == NULL)
4475                 return ERROR_NOT_ENOUGH_MEMORY;
4476
4477         (*returned) = 0x1;
4478
4479         init_unistr(&(info_2->name), "Local Port");
4480         init_unistr(&(info_2->environment), "Windows NT X86");
4481         init_unistr(&(info_2->dll_name), "localmon.dll");
4482
4483         *needed += spoolss_size_printmonitor_info_2(info_2);
4484
4485         if (!alloc_buffer_size(buffer, *needed))
4486                 return ERROR_INSUFFICIENT_BUFFER;
4487
4488         smb_io_printmonitor_info_2("", buffer, info_2, 0);
4489
4490         safe_free(info_2);
4491
4492         if (*needed > offered) {
4493                 *returned=0;
4494                 return ERROR_INSUFFICIENT_BUFFER;
4495         }
4496         else
4497                 return NT_STATUS_NO_PROBLEMO;
4498 }
4499
4500 /****************************************************************************
4501 ****************************************************************************/
4502 uint32 _spoolss_enumprintmonitors(UNISTR2 *name,uint32 level,
4503                                     NEW_BUFFER *buffer, uint32 offered,
4504                                     uint32 *needed, uint32 *returned)
4505 {
4506         DEBUG(5,("spoolss_enumprintmonitors\n"));
4507
4508         /*
4509          * Enumerate the print monitors ...
4510          *
4511          * Just reply with "Local Port", to keep NT happy
4512          * and I can use my nice printer checker.
4513          */
4514
4515         *returned=0;
4516         *needed=0;
4517
4518         switch (level) {
4519         case 1:
4520                 return enumprintmonitors_level_1(buffer, offered, needed, returned);
4521                 break;
4522         case 2:
4523                 return enumprintmonitors_level_2(buffer, offered, needed, returned);
4524                 break;
4525         default:
4526                 return ERROR_INVALID_LEVEL;
4527                 break;
4528         }
4529 }
4530
4531 /****************************************************************************
4532 ****************************************************************************/
4533 static uint32 getjob_level_1(print_queue_struct *queue, int count, int snum, uint32 jobid, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
4534 {
4535         int i=0;
4536         BOOL found=False;
4537         JOB_INFO_1 *info_1=NULL;
4538
4539         info_1=(JOB_INFO_1 *)malloc(sizeof(JOB_INFO_1));
4540
4541         if (info_1 == NULL) {
4542                 safe_free(queue);
4543                 return ERROR_NOT_ENOUGH_MEMORY;
4544         }
4545
4546         for (i=0; i<count && found==False; i++) {
4547                 if (queue[i].job==(int)jobid)
4548                         found=True;
4549         }
4550
4551         if (found==False) {
4552                 safe_free(queue);
4553                 safe_free(info_1);
4554                 /* I shoud reply something else ... I can't find the good one */
4555                 return NT_STATUS_NO_PROBLEMO;
4556         }
4557
4558         fill_job_info_1(info_1, &(queue[i-1]), i, snum);
4559
4560         safe_free(queue);
4561
4562         *needed += spoolss_size_job_info_1(info_1);
4563
4564         if (!alloc_buffer_size(buffer, *needed)) {
4565                 safe_free(info_1);
4566                 return ERROR_INSUFFICIENT_BUFFER;
4567         }
4568
4569         new_smb_io_job_info_1("", buffer, info_1, 0);
4570
4571         safe_free(info_1);
4572
4573         if (*needed > offered)
4574                 return ERROR_INSUFFICIENT_BUFFER;
4575         else
4576                 return NT_STATUS_NO_PROBLEMO;
4577 }
4578
4579
4580 /****************************************************************************
4581 ****************************************************************************/
4582 static uint32 getjob_level_2(print_queue_struct *queue, int count, int snum, uint32 jobid, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
4583 {
4584         int i=0;
4585         BOOL found=False;
4586         JOB_INFO_2 *info_2;
4587         info_2=(JOB_INFO_2 *)malloc(sizeof(JOB_INFO_2));
4588
4589         ZERO_STRUCTP(info_2);
4590
4591         if (info_2 == NULL) {
4592                 safe_free(queue);
4593                 return ERROR_NOT_ENOUGH_MEMORY;
4594         }
4595
4596         for (i=0; i<count && found==False; i++) {
4597                 if (queue[i].job==(int)jobid)
4598                         found=True;
4599         }
4600
4601         if (found==False) {
4602                 safe_free(queue);
4603                 safe_free(info_2);
4604                 /* I shoud reply something else ... I can't find the good one */
4605                 return NT_STATUS_NO_PROBLEMO;
4606         }
4607
4608         fill_job_info_2(info_2, &(queue[i-1]), i, snum);
4609
4610         safe_free(queue);
4611
4612         *needed += spoolss_size_job_info_2(info_2);
4613
4614         if (!alloc_buffer_size(buffer, *needed)) {
4615                 safe_free(info_2);
4616                 return ERROR_INSUFFICIENT_BUFFER;
4617         }
4618
4619         new_smb_io_job_info_2("", buffer, info_2, 0);
4620
4621         free_dev_mode(info_2->devmode);
4622         safe_free(info_2);
4623
4624         if (*needed > offered)
4625                 return ERROR_INSUFFICIENT_BUFFER;
4626         else
4627                 return NT_STATUS_NO_PROBLEMO;
4628 }
4629
4630 /****************************************************************************
4631 ****************************************************************************/
4632 uint32 _spoolss_getjob( POLICY_HND *handle, uint32 jobid, uint32 level,
4633                         NEW_BUFFER *buffer, uint32 offered,
4634                         uint32 *needed)
4635 {
4636         int snum;
4637         int count;
4638         print_queue_struct *queue=NULL;
4639         print_status_struct prt_status;
4640
4641         DEBUG(5,("spoolss_getjob\n"));
4642
4643         memset(&prt_status, 0, sizeof(prt_status));
4644
4645         *needed=0;
4646
4647         if (!get_printer_snum(handle, &snum))
4648                 return ERROR_INVALID_HANDLE;
4649
4650         count = print_queue_status(snum, &queue, &prt_status);
4651
4652         DEBUGADD(4,("count:[%d], prt_status:[%d], [%s]\n",
4653                      count, prt_status.status, prt_status.message));
4654
4655         switch (level) {
4656         case 1:
4657                 return getjob_level_1(queue, count, snum, jobid, buffer, offered, needed);
4658                 break;
4659         case 2:
4660                 return getjob_level_2(queue, count, snum, jobid, buffer, offered, needed);
4661                 break;
4662         default:
4663                 safe_free(queue);
4664                 return ERROR_INVALID_LEVEL;
4665                 break;
4666         }
4667 }
4668 #undef OLD_NTDOMAIN