source/rpc_server/srv_spoolss_nt.c

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