source3/rpc_server/srv_spoolss_nt.c

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