source3/rpc_server/srv_spoolss_nt.c

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