source/rpc_server/srv_spoolss_nt.c

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