source3/rpc_server/srv_spoolss_nt.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *  RPC Pipe client / server routines
   4  *  Copyright (C) Andrew Tridgell              1992-2000,
   5  *  Copyright (C) Luke Kenneth Casson Leighton 1996-2000,
   6  *  Copyright (C) Jean François Micouleau      1998-2000,
   7  *  Copyright (C) Jeremy Allison               2001-2002,
   8  *  Copyright (C) Gerald Carter                2000-2004,
   9  *  Copyright (C) Tim Potter                   2001-2002.
  10  *
  11  *  This program is free software; you can redistribute it and/or modify
  12  *  it under the terms of the GNU General Public License as published by
  13  *  the Free Software Foundation; either version 3 of the License, or
  14  *  (at your option) any later version.
  15  *
  16  *  This program is distributed in the hope that it will be useful,
  17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  *  GNU General Public License for more details.
  20  *
  21  *  You should have received a copy of the GNU General Public License
  22  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
  23  */
  24
  25 /* Since the SPOOLSS rpc routines are basically DOS 16-bit calls wrapped
  26    up, all the errors returned are DOS errors, not NT status codes. */
  27
  28 #include "includes.h"
  29
  30 extern userdom_struct current_user_info;
  31
  32 #undef DBGC_CLASS
  33 #define DBGC_CLASS DBGC_RPC_SRV
  34
  35 #ifndef MAX_OPEN_PRINTER_EXS
  36 #define MAX_OPEN_PRINTER_EXS 50
  37 #endif
  38
  39 #define MAGIC_DISPLAY_FREQUENCY 0xfade2bad
  40 #define PHANTOM_DEVMODE_KEY "_p_f_a_n_t_0_m_"
  41
  42 struct table_node {
  43         const char    *long_archi;
  44         const char    *short_archi;
  45         int     version;
  46 };
  47
  48 static Printer_entry *printers_list;
  49
  50 typedef struct _counter_printer_0 {
  51         struct _counter_printer_0 *next;
  52         struct _counter_printer_0 *prev;
  53
  54         int snum;
  55         uint32 counter;
  56 } counter_printer_0;
  57
  58 static counter_printer_0 *counter_list;
  59
  60 static struct rpc_pipe_client *notify_cli_pipe; /* print notify back-channel pipe handle*/
  61 static uint32 smb_connections=0;
  62
  63
  64 /* in printing/nt_printing.c */
  65
  66 extern struct standard_mapping printer_std_mapping, printserver_std_mapping;
  67
  68 /* API table for Xcv Monitor functions */
  69
  70 struct xcv_api_table {
  71         const char *name;
  72         WERROR(*fn) (TALLOC_CTX *mem_ctx, NT_USER_TOKEN *token, DATA_BLOB *in, DATA_BLOB *out, uint32_t *needed);
  73 };
  74
  75 /********************************************************************
  76  * Canonicalize servername.
  77  ********************************************************************/
  78
  79 static const char *canon_servername(const char *servername)
  80 {
  81         const char *pservername = servername;
  82         while (*pservername == '\\') {
  83                 pservername++;
  84         }
  85         return pservername;
  86 }
  87
  88 /* translate between internal status numbers and NT status numbers */
  89 static int nt_printj_status(int v)
  90 {
  91         switch (v) {
  92         case LPQ_QUEUED:
  93                 return 0;
  94         case LPQ_PAUSED:
  95                 return JOB_STATUS_PAUSED;
  96         case LPQ_SPOOLING:
  97                 return JOB_STATUS_SPOOLING;
  98         case LPQ_PRINTING:
  99                 return JOB_STATUS_PRINTING;
 100         case LPQ_ERROR:
 101                 return JOB_STATUS_ERROR;
 102         case LPQ_DELETING:
 103                 return JOB_STATUS_DELETING;
 104         case LPQ_OFFLINE:
 105                 return JOB_STATUS_OFFLINE;
 106         case LPQ_PAPEROUT:
 107                 return JOB_STATUS_PAPEROUT;
 108         case LPQ_PRINTED:
 109                 return JOB_STATUS_PRINTED;
 110         case LPQ_DELETED:
 111                 return JOB_STATUS_DELETED;
 112         case LPQ_BLOCKED:
 113                 return JOB_STATUS_BLOCKED;
 114         case LPQ_USER_INTERVENTION:
 115                 return JOB_STATUS_USER_INTERVENTION;
 116         }
 117         return 0;
 118 }
 119
 120 static int nt_printq_status(int v)
 121 {
 122         switch (v) {
 123         case LPQ_PAUSED:
 124                 return PRINTER_STATUS_PAUSED;
 125         case LPQ_QUEUED:
 126         case LPQ_SPOOLING:
 127         case LPQ_PRINTING:
 128                 return 0;
 129         }
 130         return 0;
 131 }
 132
 133 /***************************************************************************
 134  Disconnect from the client
 135 ****************************************************************************/
 136
 137 static void srv_spoolss_replycloseprinter(int snum, POLICY_HND *handle)
 138 {
 139         WERROR result;
 140         NTSTATUS status;
 141
 142         /*
 143          * Tell the specific printing tdb we no longer want messages for this printer
 144          * by deregistering our PID.
 145          */
 146
 147         if (!print_notify_deregister_pid(snum))
 148                 DEBUG(0,("print_notify_register_pid: Failed to register our pid for printer %s\n", lp_const_servicename(snum) ));
 149
 150         /* weird if the test succeds !!! */
 151         if (smb_connections==0) {
 152                 DEBUG(0,("srv_spoolss_replycloseprinter:Trying to close non-existant notify backchannel !\n"));
 153                 return;
 154         }
 155
 156         status = rpccli_spoolss_ReplyClosePrinter(notify_cli_pipe, talloc_tos(),
 157                                                   handle,
 158                                                   &result);
 159         if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result))
 160                 DEBUG(0,("srv_spoolss_replycloseprinter: reply_close_printer failed [%s].\n",
 161                         win_errstr(result)));
 162
 163         /* if it's the last connection, deconnect the IPC$ share */
 164         if (smb_connections==1) {
 165
 166                 cli_shutdown( rpc_pipe_np_smb_conn(notify_cli_pipe) );
 167                 notify_cli_pipe = NULL; /* The above call shuts downn the pipe also. */
 168
 169                 messaging_deregister(smbd_messaging_context(),
 170                                      MSG_PRINTER_NOTIFY2, NULL);
 171
 172                 /* Tell the connections db we're no longer interested in
 173                  * printer notify messages. */
 174
 175                 register_message_flags( False, FLAG_MSG_PRINT_NOTIFY );
 176         }
 177
 178         smb_connections--;
 179 }
 180
 181 /****************************************************************************
 182  Functions to free a printer entry datastruct.
 183 ****************************************************************************/
 184
 185 static int printer_entry_destructor(Printer_entry *Printer)
 186 {
 187         if (Printer->notify.client_connected==True) {
 188                 int snum = -1;
 189
 190                 if ( Printer->printer_type == SPLHND_SERVER) {
 191                         snum = -1;
 192                         srv_spoolss_replycloseprinter(snum, &Printer->notify.client_hnd);
 193                 } else if (Printer->printer_type == SPLHND_PRINTER) {
 194                         snum = print_queue_snum(Printer->sharename);
 195                         if (snum != -1)
 196                                 srv_spoolss_replycloseprinter(snum,
 197                                                 &Printer->notify.client_hnd);
 198                 }
 199         }
 200
 201         Printer->notify.flags=0;
 202         Printer->notify.options=0;
 203         Printer->notify.localmachine[0]='\0';
 204         Printer->notify.printerlocal=0;
 205         TALLOC_FREE(Printer->notify.option);
 206         Printer->notify.client_connected=False;
 207
 208         free_nt_devicemode( &Printer->nt_devmode );
 209         free_a_printer( &Printer->printer_info, 2 );
 210
 211         /* Remove from the internal list. */
 212         DLIST_REMOVE(printers_list, Printer);
 213         return 0;
 214 }
 215
 216 /****************************************************************************
 217   find printer index by handle
 218 ****************************************************************************/
 219
 220 static Printer_entry *find_printer_index_by_hnd(pipes_struct *p, POLICY_HND *hnd)
 221 {
 222         Printer_entry *find_printer = NULL;
 223
 224         if(!find_policy_by_hnd(p,hnd,(void **)(void *)&find_printer)) {
 225                 DEBUG(2,("find_printer_index_by_hnd: Printer handle not found: "));
 226                 return NULL;
 227         }
 228
 229         return find_printer;
 230 }
 231
 232 /****************************************************************************
 233  Close printer index by handle.
 234 ****************************************************************************/
 235
 236 static bool close_printer_handle(pipes_struct *p, POLICY_HND *hnd)
 237 {
 238         Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
 239
 240         if (!Printer) {
 241                 DEBUG(2,("close_printer_handle: Invalid handle (%s:%u:%u)\n", OUR_HANDLE(hnd)));
 242                 return False;
 243         }
 244
 245         close_policy_hnd(p, hnd);
 246
 247         return True;
 248 }
 249
 250 /****************************************************************************
 251  Delete a printer given a handle.
 252 ****************************************************************************/
 253
 254 WERROR delete_printer_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, const char *sharename )
 255 {
 256         char *cmd = lp_deleteprinter_cmd();
 257         char *command = NULL;
 258         int ret;
 259         SE_PRIV se_printop = SE_PRINT_OPERATOR;
 260         bool is_print_op = False;
 261
 262         /* can't fail if we don't try */
 263
 264         if ( !*cmd )
 265                 return WERR_OK;
 266
 267         command = talloc_asprintf(ctx,
 268                         "%s \"%s\"",
 269                         cmd, sharename);
 270         if (!command) {
 271                 return WERR_NOMEM;
 272         }
 273         if ( token )
 274                 is_print_op = user_has_privileges( token, &se_printop );
 275
 276         DEBUG(10,("Running [%s]\n", command));
 277
 278         /********** BEGIN SePrintOperatorPrivlege BLOCK **********/
 279
 280         if ( is_print_op )
 281                 become_root();
 282
 283         if ( (ret = smbrun(command, NULL)) == 0 ) {
 284                 /* Tell everyone we updated smb.conf. */
 285                 message_send_all(smbd_messaging_context(),
 286                                  MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
 287         }
 288
 289         if ( is_print_op )
 290                 unbecome_root();
 291
 292         /********** END SePrintOperatorPrivlege BLOCK **********/
 293
 294         DEBUGADD(10,("returned [%d]\n", ret));
 295
 296         TALLOC_FREE(command);
 297
 298         if (ret != 0)
 299                 return WERR_BADFID; /* What to return here? */
 300
 301         /* go ahead and re-read the services immediately */
 302         reload_services( False );
 303
 304         if ( lp_servicenumber( sharename )  < 0 )
 305                 return WERR_ACCESS_DENIED;
 306
 307         return WERR_OK;
 308 }
 309
 310 /****************************************************************************
 311  Delete a printer given a handle.
 312 ****************************************************************************/
 313
 314 static WERROR delete_printer_handle(pipes_struct *p, POLICY_HND *hnd)
 315 {
 316         Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
 317
 318         if (!Printer) {
 319                 DEBUG(2,("delete_printer_handle: Invalid handle (%s:%u:%u)\n", OUR_HANDLE(hnd)));
 320                 return WERR_BADFID;
 321         }
 322
 323         /*
 324          * It turns out that Windows allows delete printer on a handle
 325          * opened by an admin user, then used on a pipe handle created
 326          * by an anonymous user..... but they're working on security.... riiight !
 327          * JRA.
 328          */
 329
 330         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
 331                 DEBUG(3, ("delete_printer_handle: denied by handle\n"));
 332                 return WERR_ACCESS_DENIED;
 333         }
 334
 335         /* this does not need a become root since the access check has been
 336            done on the handle already */
 337
 338         if (del_a_printer( Printer->sharename ) != 0) {
 339                 DEBUG(3,("Error deleting printer %s\n", Printer->sharename));
 340                 return WERR_BADFID;
 341         }
 342
 343         return delete_printer_hook(p->mem_ctx, p->server_info->ptok,
 344                                    Printer->sharename );
 345 }
 346
 347 /****************************************************************************
 348  Return the snum of a printer corresponding to an handle.
 349 ****************************************************************************/
 350
 351 static bool get_printer_snum(pipes_struct *p, POLICY_HND *hnd, int *number,
 352                              struct share_params **params)
 353 {
 354         Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
 355
 356         if (!Printer) {
 357                 DEBUG(2,("get_printer_snum: Invalid handle (%s:%u:%u)\n", OUR_HANDLE(hnd)));
 358                 return False;
 359         }
 360
 361         switch (Printer->printer_type) {
 362                 case SPLHND_PRINTER:
 363                         DEBUG(4,("short name:%s\n", Printer->sharename));
 364                         *number = print_queue_snum(Printer->sharename);
 365                         return (*number != -1);
 366                 case SPLHND_SERVER:
 367                         return False;
 368                 default:
 369                         return False;
 370         }
 371 }
 372
 373 /****************************************************************************
 374  Set printer handle type.
 375  Check if it's \\server or \\server\printer
 376 ****************************************************************************/
 377
 378 static bool set_printer_hnd_printertype(Printer_entry *Printer, char *handlename)
 379 {
 380         DEBUG(3,("Setting printer type=%s\n", handlename));
 381
 382         if ( strlen(handlename) < 3 ) {
 383                 DEBUGADD(4,("A print server must have at least 1 char ! %s\n", handlename));
 384                 return False;
 385         }
 386
 387         /* it's a print server */
 388         if (*handlename=='\\' && *(handlename+1)=='\\' && !strchr_m(handlename+2, '\\')) {
 389                 DEBUGADD(4,("Printer is a print server\n"));
 390                 Printer->printer_type = SPLHND_SERVER;
 391         }
 392         /* it's a printer (set_printer_hnd_name() will handle port monitors */
 393         else {
 394                 DEBUGADD(4,("Printer is a printer\n"));
 395                 Printer->printer_type = SPLHND_PRINTER;
 396         }
 397
 398         return True;
 399 }
 400
 401 /****************************************************************************
 402  Set printer handle name..  Accept names like \\server, \\server\printer,
 403  \\server\SHARE, & "\\server\,XcvMonitor Standard TCP/IP Port"    See
 404  the MSDN docs regarding OpenPrinter() for details on the XcvData() and
 405  XcvDataPort() interface.
 406 ****************************************************************************/
 407
 408 static bool set_printer_hnd_name(Printer_entry *Printer, char *handlename)
 409 {
 410         int snum;
 411         int n_services=lp_numservices();
 412         char *aprinter, *printername;
 413         const char *servername;
 414         fstring sname;
 415         bool found=False;
 416         NT_PRINTER_INFO_LEVEL *printer = NULL;
 417         WERROR result;
 418
 419         DEBUG(4,("Setting printer name=%s (len=%lu)\n", handlename, (unsigned long)strlen(handlename)));
 420
 421         aprinter = handlename;
 422         if ( *handlename == '\\' ) {
 423                 servername = canon_servername(handlename);
 424                 if ( (aprinter = strchr_m( servername, '\\' )) != NULL ) {
 425                         *aprinter = '\0';
 426                         aprinter++;
 427                 }
 428         } else {
 429                 servername = "";
 430         }
 431
 432         /* save the servername to fill in replies on this handle */
 433
 434         if ( !is_myname_or_ipaddr( servername ) )
 435                 return False;
 436
 437         fstrcpy( Printer->servername, servername );
 438
 439         if ( Printer->printer_type == SPLHND_SERVER )
 440                 return True;
 441
 442         if ( Printer->printer_type != SPLHND_PRINTER )
 443                 return False;
 444
 445         DEBUGADD(5, ("searching for [%s]\n", aprinter ));
 446
 447         /* check for the Port Monitor Interface */
 448
 449         if ( strequal( aprinter, SPL_XCV_MONITOR_TCPMON ) ) {
 450                 Printer->printer_type = SPLHND_PORTMON_TCP;
 451                 fstrcpy(sname, SPL_XCV_MONITOR_TCPMON);
 452                 found = True;
 453         }
 454         else if ( strequal( aprinter, SPL_XCV_MONITOR_LOCALMON ) ) {
 455                 Printer->printer_type = SPLHND_PORTMON_LOCAL;
 456                 fstrcpy(sname, SPL_XCV_MONITOR_LOCALMON);
 457                 found = True;
 458         }
 459
 460         /* Search all sharenames first as this is easier than pulling
 461            the printer_info_2 off of disk. Don't use find_service() since
 462            that calls out to map_username() */
 463
 464         /* do another loop to look for printernames */
 465
 466         for (snum=0; !found && snum<n_services; snum++) {
 467
 468                 /* no point going on if this is not a printer */
 469
 470                 if ( !(lp_snum_ok(snum) && lp_print_ok(snum)) )
 471                         continue;
 472
 473                 fstrcpy(sname, lp_servicename(snum));
 474                 if ( strequal( aprinter, sname ) ) {
 475                         found = True;
 476                         break;
 477                 }
 478
 479                 /* no point looking up the printer object if
 480                    we aren't allowing printername != sharename */
 481
 482                 if ( lp_force_printername(snum) )
 483                         continue;
 484
 485                 fstrcpy(sname, lp_servicename(snum));
 486
 487                 printer = NULL;
 488
 489                 /* This call doesn't fill in the location or comment from
 490                  * a CUPS server for efficiency with large numbers of printers.
 491                  * JRA.
 492                  */
 493
 494                 result = get_a_printer_search( NULL, &printer, 2, sname );
 495                 if ( !W_ERROR_IS_OK(result) ) {
 496                         DEBUG(0,("set_printer_hnd_name: failed to lookup printer [%s] -- result [%s]\n",
 497                                 sname, win_errstr(result)));
 498                         continue;
 499                 }
 500
 501                 /* printername is always returned as \\server\printername */
 502                 if ( !(printername = strchr_m(&printer->info_2->printername[2], '\\')) ) {
 503                         DEBUG(0,("set_printer_hnd_name: info2->printername in wrong format! [%s]\n",
 504                                 printer->info_2->printername));
 505                         free_a_printer( &printer, 2);
 506                         continue;
 507                 }
 508
 509                 printername++;
 510
 511                 if ( strequal(printername, aprinter) ) {
 512                         free_a_printer( &printer, 2);
 513                         found = True;
 514                         break;
 515                 }
 516
 517                 DEBUGADD(10, ("printername: %s\n", printername));
 518
 519                 free_a_printer( &printer, 2);
 520         }
 521
 522         free_a_printer( &printer, 2);
 523
 524         if ( !found ) {
 525                 DEBUGADD(4,("Printer not found\n"));
 526                 return False;
 527         }
 528
 529         DEBUGADD(4,("set_printer_hnd_name: Printer found: %s -> %s\n", aprinter, sname));
 530
 531         fstrcpy(Printer->sharename, sname);
 532
 533         return True;
 534 }
 535
 536 /****************************************************************************
 537  Find first available printer slot. creates a printer handle for you.
 538  ****************************************************************************/
 539
 540 static bool open_printer_hnd(pipes_struct *p, POLICY_HND *hnd, char *name, uint32 access_granted)
 541 {
 542         Printer_entry *new_printer;
 543
 544         DEBUG(10,("open_printer_hnd: name [%s]\n", name));
 545
 546         new_printer = TALLOC_ZERO_P(NULL, Printer_entry);
 547         if (new_printer == NULL) {
 548                 return false;
 549         }
 550         talloc_set_destructor(new_printer, printer_entry_destructor);
 551
 552         if (!create_policy_hnd(p, hnd, new_printer)) {
 553                 TALLOC_FREE(new_printer);
 554                 return False;
 555         }
 556
 557         /* Add to the internal list. */
 558         DLIST_ADD(printers_list, new_printer);
 559
 560         new_printer->notify.option=NULL;
 561
 562         if (!set_printer_hnd_printertype(new_printer, name)) {
 563                 close_printer_handle(p, hnd);
 564                 return False;
 565         }
 566
 567         if (!set_printer_hnd_name(new_printer, name)) {
 568                 close_printer_handle(p, hnd);
 569                 return False;
 570         }
 571
 572         new_printer->access_granted = access_granted;
 573
 574         DEBUG(5, ("%d printer handles active\n", (int)p->pipe_handles->count ));
 575
 576         return True;
 577 }
 578
 579 /***************************************************************************
 580  check to see if the client motify handle is monitoring the notification
 581  given by (notify_type, notify_field).
 582  **************************************************************************/
 583
 584 static bool is_monitoring_event_flags(uint32 flags, uint16 notify_type,
 585                                       uint16 notify_field)
 586 {
 587         return True;
 588 }
 589
 590 static bool is_monitoring_event(Printer_entry *p, uint16 notify_type,
 591                                 uint16 notify_field)
 592 {
 593         struct spoolss_NotifyOption *option = p->notify.option;
 594         uint32 i, j;
 595
 596         /*
 597          * Flags should always be zero when the change notify
 598          * is registered by the client's spooler.  A user Win32 app
 599          * might use the flags though instead of the NOTIFY_OPTION_INFO
 600          * --jerry
 601          */
 602
 603         if (!option) {
 604                 return False;
 605         }
 606
 607         if (p->notify.flags)
 608                 return is_monitoring_event_flags(
 609                         p->notify.flags, notify_type, notify_field);
 610
 611         for (i = 0; i < option->count; i++) {
 612
 613                 /* Check match for notify_type */
 614
 615                 if (option->types[i].type != notify_type)
 616                         continue;
 617
 618                 /* Check match for field */
 619
 620                 for (j = 0; j < option->types[i].count; j++) {
 621                         if (option->types[i].fields[j] == notify_field) {
 622                                 return True;
 623                         }
 624                 }
 625         }
 626
 627         DEBUG(10, ("Open handle for \\\\%s\\%s is not monitoring 0x%02x/0x%02x\n",
 628                    p->servername, p->sharename, notify_type, notify_field));
 629
 630         return False;
 631 }
 632
 633 #define SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(_data, _integer) \
 634         _data->data.integer[0] = _integer; \
 635         _data->data.integer[1] = 0;
 636
 637
 638 #define SETUP_SPOOLSS_NOTIFY_DATA_STRING(_data, _p) \
 639         _data->data.string.string = talloc_strdup(mem_ctx, _p); \
 640         if (!_data->data.string.string) {\
 641                 _data->data.string.size = 0; \
 642         } \
 643         _data->data.string.size = strlen_m_term(_p) * 2;
 644
 645 #define SETUP_SPOOLSS_NOTIFY_DATA_DEVMODE(_data, _devmode) \
 646         _data->data.devmode.devmode = _devmode;
 647
 648 #define SETUP_SPOOLSS_NOTIFY_DATA_SECDESC(_data, _size, _sd) \
 649         _data->data.sd.sd = dup_sec_desc(mem_ctx, _sd); \
 650         if (!_data->data.sd.sd) { \
 651                 _data->data.sd.sd_size = 0; \
 652         } \
 653         _data->data.sd.sd_size = _size;
 654
 655 static void init_systemtime_buffer(TALLOC_CTX *mem_ctx,
 656                                    struct tm *t,
 657                                    const char **pp,
 658                                    uint32_t *plen)
 659 {
 660         struct spoolss_Time st;
 661         uint32_t len = 16;
 662         char *p;
 663
 664         if (!init_systemtime(&st, t)) {
 665                 return;
 666         }
 667
 668         p = talloc_array(mem_ctx, char, len);
 669         if (!p) {
 670                 return;
 671         }
 672
 673         /*
 674          * Systemtime must be linearized as a set of UINT16's.
 675          * Fix from Benjamin (Bj) Kuit bj@it.uts.edu.au
 676          */
 677
 678         SSVAL(p, 0, st.year);
 679         SSVAL(p, 2, st.month);
 680         SSVAL(p, 4, st.day_of_week);
 681         SSVAL(p, 6, st.day);
 682         SSVAL(p, 8, st.hour);
 683         SSVAL(p, 10, st.minute);
 684         SSVAL(p, 12, st.second);
 685         SSVAL(p, 14, st.millisecond);
 686
 687         *pp = p;
 688         *plen = len;
 689 }
 690
 691 /* Convert a notification message to a struct spoolss_Notify */
 692
 693 static void notify_one_value(struct spoolss_notify_msg *msg,
 694                              struct spoolss_Notify *data,
 695                              TALLOC_CTX *mem_ctx)
 696 {
 697         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, msg->notify.value[0]);
 698 }
 699
 700 static void notify_string(struct spoolss_notify_msg *msg,
 701                           struct spoolss_Notify *data,
 702                           TALLOC_CTX *mem_ctx)
 703 {
 704         /* The length of the message includes the trailing \0 */
 705
 706         data->data.string.size = msg->len * 2;
 707         data->data.string.string = talloc_strdup(mem_ctx, msg->notify.data);
 708         if (!data->data.string.string) {
 709                 data->data.string.size = 0;
 710                 return;
 711         }
 712 }
 713
 714 static void notify_system_time(struct spoolss_notify_msg *msg,
 715                                struct spoolss_Notify *data,
 716                                TALLOC_CTX *mem_ctx)
 717 {
 718         data->data.string.string = NULL;
 719         data->data.string.size = 0;
 720
 721         if (msg->len != sizeof(time_t)) {
 722                 DEBUG(5, ("notify_system_time: received wrong sized message (%d)\n",
 723                           msg->len));
 724                 return;
 725         }
 726
 727         init_systemtime_buffer(mem_ctx, gmtime((time_t *)msg->notify.data),
 728                                &data->data.string.string,
 729                                &data->data.string.size);
 730 }
 731
 732 struct notify2_message_table {
 733         const char *name;
 734         void (*fn)(struct spoolss_notify_msg *msg,
 735                    struct spoolss_Notify *data, TALLOC_CTX *mem_ctx);
 736 };
 737
 738 static struct notify2_message_table printer_notify_table[] = {
 739         /* 0x00 */ { "PRINTER_NOTIFY_SERVER_NAME", notify_string },
 740         /* 0x01 */ { "PRINTER_NOTIFY_PRINTER_NAME", notify_string },
 741         /* 0x02 */ { "PRINTER_NOTIFY_SHARE_NAME", notify_string },
 742         /* 0x03 */ { "PRINTER_NOTIFY_PORT_NAME", notify_string },
 743         /* 0x04 */ { "PRINTER_NOTIFY_DRIVER_NAME", notify_string },
 744         /* 0x05 */ { "PRINTER_NOTIFY_COMMENT", notify_string },
 745         /* 0x06 */ { "PRINTER_NOTIFY_LOCATION", notify_string },
 746         /* 0x07 */ { "PRINTER_NOTIFY_DEVMODE", NULL },
 747         /* 0x08 */ { "PRINTER_NOTIFY_SEPFILE", notify_string },
 748         /* 0x09 */ { "PRINTER_NOTIFY_PRINT_PROCESSOR", notify_string },
 749         /* 0x0a */ { "PRINTER_NOTIFY_PARAMETERS", NULL },
 750         /* 0x0b */ { "PRINTER_NOTIFY_DATATYPE", notify_string },
 751         /* 0x0c */ { "PRINTER_NOTIFY_SECURITY_DESCRIPTOR", NULL },
 752         /* 0x0d */ { "PRINTER_NOTIFY_ATTRIBUTES", notify_one_value },
 753         /* 0x0e */ { "PRINTER_NOTIFY_PRIORITY", notify_one_value },
 754         /* 0x0f */ { "PRINTER_NOTIFY_DEFAULT_PRIORITY", NULL },
 755         /* 0x10 */ { "PRINTER_NOTIFY_START_TIME", NULL },
 756         /* 0x11 */ { "PRINTER_NOTIFY_UNTIL_TIME", NULL },
 757         /* 0x12 */ { "PRINTER_NOTIFY_STATUS", notify_one_value },
 758 };
 759
 760 static struct notify2_message_table job_notify_table[] = {
 761         /* 0x00 */ { "JOB_NOTIFY_PRINTER_NAME", NULL },
 762         /* 0x01 */ { "JOB_NOTIFY_MACHINE_NAME", NULL },
 763         /* 0x02 */ { "JOB_NOTIFY_PORT_NAME", NULL },
 764         /* 0x03 */ { "JOB_NOTIFY_USER_NAME", notify_string },
 765         /* 0x04 */ { "JOB_NOTIFY_NOTIFY_NAME", NULL },
 766         /* 0x05 */ { "JOB_NOTIFY_DATATYPE", NULL },
 767         /* 0x06 */ { "JOB_NOTIFY_PRINT_PROCESSOR", NULL },
 768         /* 0x07 */ { "JOB_NOTIFY_PARAMETERS", NULL },
 769         /* 0x08 */ { "JOB_NOTIFY_DRIVER_NAME", NULL },
 770         /* 0x09 */ { "JOB_NOTIFY_DEVMODE", NULL },
 771         /* 0x0a */ { "JOB_NOTIFY_STATUS", notify_one_value },
 772         /* 0x0b */ { "JOB_NOTIFY_STATUS_STRING", NULL },
 773         /* 0x0c */ { "JOB_NOTIFY_SECURITY_DESCRIPTOR", NULL },
 774         /* 0x0d */ { "JOB_NOTIFY_DOCUMENT", notify_string },
 775         /* 0x0e */ { "JOB_NOTIFY_PRIORITY", NULL },
 776         /* 0x0f */ { "JOB_NOTIFY_POSITION", NULL },
 777         /* 0x10 */ { "JOB_NOTIFY_SUBMITTED", notify_system_time },
 778         /* 0x11 */ { "JOB_NOTIFY_START_TIME", NULL },
 779         /* 0x12 */ { "JOB_NOTIFY_UNTIL_TIME", NULL },
 780         /* 0x13 */ { "JOB_NOTIFY_TIME", NULL },
 781         /* 0x14 */ { "JOB_NOTIFY_TOTAL_PAGES", notify_one_value },
 782         /* 0x15 */ { "JOB_NOTIFY_PAGES_PRINTED", NULL },
 783         /* 0x16 */ { "JOB_NOTIFY_TOTAL_BYTES", notify_one_value },
 784         /* 0x17 */ { "JOB_NOTIFY_BYTES_PRINTED", NULL },
 785 };
 786
 787
 788 /***********************************************************************
 789  Allocate talloc context for container object
 790  **********************************************************************/
 791
 792 static void notify_msg_ctr_init( SPOOLSS_NOTIFY_MSG_CTR *ctr )
 793 {
 794         if ( !ctr )
 795                 return;
 796
 797         ctr->ctx = talloc_init("notify_msg_ctr_init %p", ctr);
 798
 799         return;
 800 }
 801
 802 /***********************************************************************
 803  release all allocated memory and zero out structure
 804  **********************************************************************/
 805
 806 static void notify_msg_ctr_destroy( SPOOLSS_NOTIFY_MSG_CTR *ctr )
 807 {
 808         if ( !ctr )
 809                 return;
 810
 811         if ( ctr->ctx )
 812                 talloc_destroy(ctr->ctx);
 813
 814         ZERO_STRUCTP(ctr);
 815
 816         return;
 817 }
 818
 819 /***********************************************************************
 820  **********************************************************************/
 821
 822 static TALLOC_CTX* notify_ctr_getctx( SPOOLSS_NOTIFY_MSG_CTR *ctr )
 823 {
 824         if ( !ctr )
 825                 return NULL;
 826
 827         return ctr->ctx;
 828 }
 829
 830 /***********************************************************************
 831  **********************************************************************/
 832
 833 static SPOOLSS_NOTIFY_MSG_GROUP* notify_ctr_getgroup( SPOOLSS_NOTIFY_MSG_CTR *ctr, uint32 idx )
 834 {
 835         if ( !ctr || !ctr->msg_groups )
 836                 return NULL;
 837
 838         if ( idx >= ctr->num_groups )
 839                 return NULL;
 840
 841         return &ctr->msg_groups[idx];
 842
 843 }
 844
 845 /***********************************************************************
 846  How many groups of change messages do we have ?
 847  **********************************************************************/
 848
 849 static int notify_msg_ctr_numgroups( SPOOLSS_NOTIFY_MSG_CTR *ctr )
 850 {
 851         if ( !ctr )
 852                 return 0;
 853
 854         return ctr->num_groups;
 855 }
 856
 857 /***********************************************************************
 858  Add a SPOOLSS_NOTIFY_MSG_CTR to the correct group
 859  **********************************************************************/
 860
 861 static int notify_msg_ctr_addmsg( SPOOLSS_NOTIFY_MSG_CTR *ctr, SPOOLSS_NOTIFY_MSG *msg )
 862 {
 863         SPOOLSS_NOTIFY_MSG_GROUP        *groups = NULL;
 864         SPOOLSS_NOTIFY_MSG_GROUP        *msg_grp = NULL;
 865         SPOOLSS_NOTIFY_MSG              *msg_list = NULL;
 866         int                             i, new_slot;
 867
 868         if ( !ctr || !msg )
 869                 return 0;
 870
 871         /* loop over all groups looking for a matching printer name */
 872
 873         for ( i=0; i<ctr->num_groups; i++ ) {
 874                 if ( strcmp(ctr->msg_groups[i].printername, msg->printer) == 0 )
 875                         break;
 876         }
 877
 878         /* add a new group? */
 879
 880         if ( i == ctr->num_groups ) {
 881                 ctr->num_groups++;
 882
 883                 if ( !(groups = TALLOC_REALLOC_ARRAY( ctr->ctx, ctr->msg_groups, SPOOLSS_NOTIFY_MSG_GROUP, ctr->num_groups)) ) {
 884                         DEBUG(0,("notify_msg_ctr_addmsg: talloc_realloc() failed!\n"));
 885                         return 0;
 886                 }
 887                 ctr->msg_groups = groups;
 888
 889                 /* clear the new entry and set the printer name */
 890
 891                 ZERO_STRUCT( ctr->msg_groups[ctr->num_groups-1] );
 892                 fstrcpy( ctr->msg_groups[ctr->num_groups-1].printername, msg->printer );
 893         }
 894
 895         /* add the change messages; 'i' is the correct index now regardless */
 896
 897         msg_grp = &ctr->msg_groups[i];
 898
 899         msg_grp->num_msgs++;
 900
 901         if ( !(msg_list = TALLOC_REALLOC_ARRAY( ctr->ctx, msg_grp->msgs, SPOOLSS_NOTIFY_MSG, msg_grp->num_msgs )) ) {
 902                 DEBUG(0,("notify_msg_ctr_addmsg: talloc_realloc() failed for new message [%d]!\n", msg_grp->num_msgs));
 903                 return 0;
 904         }
 905         msg_grp->msgs = msg_list;
 906
 907         new_slot = msg_grp->num_msgs-1;
 908         memcpy( &msg_grp->msgs[new_slot], msg, sizeof(SPOOLSS_NOTIFY_MSG) );
 909
 910         /* need to allocate own copy of data */
 911
 912         if ( msg->len != 0 )
 913                 msg_grp->msgs[new_slot].notify.data = (char *)
 914                         TALLOC_MEMDUP( ctr->ctx, msg->notify.data, msg->len );
 915
 916         return ctr->num_groups;
 917 }
 918
 919 /***********************************************************************
 920  Send a change notication message on all handles which have a call
 921  back registered
 922  **********************************************************************/
 923
 924 static void send_notify2_changes( SPOOLSS_NOTIFY_MSG_CTR *ctr, uint32 idx )
 925 {
 926         Printer_entry            *p;
 927         TALLOC_CTX               *mem_ctx = notify_ctr_getctx( ctr );
 928         SPOOLSS_NOTIFY_MSG_GROUP *msg_group = notify_ctr_getgroup( ctr, idx );
 929         SPOOLSS_NOTIFY_MSG       *messages;
 930         int                      sending_msg_count;
 931
 932         if ( !msg_group ) {
 933                 DEBUG(5,("send_notify2_changes() called with no msg group!\n"));
 934                 return;
 935         }
 936
 937         messages = msg_group->msgs;
 938
 939         if ( !messages ) {
 940                 DEBUG(5,("send_notify2_changes() called with no messages!\n"));
 941                 return;
 942         }
 943
 944         DEBUG(8,("send_notify2_changes: Enter...[%s]\n", msg_group->printername));
 945
 946         /* loop over all printers */
 947
 948         for (p = printers_list; p; p = p->next) {
 949                 struct spoolss_Notify *notifies;
 950                 uint32_t count = 0;
 951                 uint32_t id;
 952                 int     i;
 953
 954                 /* Is there notification on this handle? */
 955
 956                 if ( !p->notify.client_connected )
 957                         continue;
 958
 959                 DEBUG(10,("Client connected! [\\\\%s\\%s]\n", p->servername, p->sharename));
 960
 961                 /* For this printer?  Print servers always receive
 962                    notifications. */
 963
 964                 if ( ( p->printer_type == SPLHND_PRINTER )  &&
 965                     ( !strequal(msg_group->printername, p->sharename) ) )
 966                         continue;
 967
 968                 DEBUG(10,("Our printer\n"));
 969
 970                 /* allocate the max entries possible */
 971
 972                 notifies = TALLOC_ZERO_ARRAY(mem_ctx, struct spoolss_Notify, msg_group->num_msgs);
 973                 if (!notifies) {
 974                         return;
 975                 }
 976
 977                 /* build the array of change notifications */
 978
 979                 sending_msg_count = 0;
 980
 981                 for ( i=0; i<msg_group->num_msgs; i++ ) {
 982                         SPOOLSS_NOTIFY_MSG      *msg = &messages[i];
 983
 984                         /* Are we monitoring this event? */
 985
 986                         if (!is_monitoring_event(p, msg->type, msg->field))
 987                                 continue;
 988
 989                         sending_msg_count++;
 990
 991
 992                         DEBUG(10,("process_notify2_message: Sending message type [0x%x] field [0x%2x] for printer [%s]\n",
 993                                 msg->type, msg->field, p->sharename));
 994
 995                         /*
 996                          * if the is a printer notification handle and not a job notification
 997                          * type, then set the id to 0.  Other wise just use what was specified
 998                          * in the message.
 999                          *
1000                          * When registering change notification on a print server handle
1001                          * we always need to send back the id (snum) matching the printer
1002                          * for which the change took place.  For change notify registered
1003                          * on a printer handle, this does not matter and the id should be 0.
1004                          *
1005                          * --jerry
1006                          */
1007
1008                         if ( ( p->printer_type == SPLHND_PRINTER ) && ( msg->type == PRINTER_NOTIFY_TYPE ) )
1009                                 id = 0;
1010                         else
1011                                 id = msg->id;
1012
1013
1014                         /* Convert unix jobid to smb jobid */
1015
1016                         if (msg->flags & SPOOLSS_NOTIFY_MSG_UNIX_JOBID) {
1017                                 id = sysjob_to_jobid(msg->id);
1018
1019                                 if (id == -1) {
1020                                         DEBUG(3, ("no such unix jobid %d\n", msg->id));
1021                                         goto done;
1022                                 }
1023                         }
1024
1025                         construct_info_data( &notifies[count], msg->type, msg->field, id );
1026
1027                         switch(msg->type) {
1028                         case PRINTER_NOTIFY_TYPE:
1029                                 if ( printer_notify_table[msg->field].fn )
1030                                         printer_notify_table[msg->field].fn(msg, &notifies[count], mem_ctx);
1031                                 break;
1032
1033                         case JOB_NOTIFY_TYPE:
1034                                 if ( job_notify_table[msg->field].fn )
1035                                         job_notify_table[msg->field].fn(msg, &notifies[count], mem_ctx);
1036                                 break;
1037
1038                         default:
1039                                 DEBUG(5, ("Unknown notification type %d\n", msg->type));
1040                                 goto done;
1041                         }
1042
1043                         count++;
1044                 }
1045
1046                 if ( sending_msg_count ) {
1047                         NTSTATUS status;
1048                         WERROR werr;
1049                         union spoolss_ReplyPrinterInfo info;
1050                         struct spoolss_NotifyInfo info0;
1051                         uint32_t reply_result;
1052
1053                         info0.version   = 0x2;
1054                         info0.flags     = count ? 0x00020000 /* ??? */ : PRINTER_NOTIFY_INFO_DISCARDED;
1055                         info0.count     = count;
1056                         info0.notifies  = notifies;
1057
1058                         info.info0 = &info0;
1059
1060                         status = rpccli_spoolss_RouterReplyPrinterEx(notify_cli_pipe, mem_ctx,
1061                                                                      &p->notify.client_hnd,
1062                                                                      p->notify.change, /* color */
1063                                                                      p->notify.flags,
1064                                                                      &reply_result,
1065                                                                      0, /* reply_type, must be 0 */
1066                                                                      info,
1067                                                                      &werr);
1068                         if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(werr)) {
1069                                 DEBUG(1,("RouterReplyPrinterEx to client: %s failed: %s\n",
1070                                         notify_cli_pipe->srv_name_slash,
1071                                         win_errstr(werr)));
1072                         }
1073                         switch (reply_result) {
1074                                 case 0:
1075                                         break;
1076                                 case PRINTER_NOTIFY_INFO_DISCARDED:
1077                                 case PRINTER_NOTIFY_INFO_DISCARDNOTED:
1078                                 case PRINTER_NOTIFY_INFO_COLOR_MISMATCH:
1079                                         break;
1080                                 default:
1081                                         break;
1082                         }
1083                 }
1084         }
1085
1086 done:
1087         DEBUG(8,("send_notify2_changes: Exit...\n"));
1088         return;
1089 }
1090
1091 /***********************************************************************
1092  **********************************************************************/
1093
1094 static bool notify2_unpack_msg( SPOOLSS_NOTIFY_MSG *msg, struct timeval *tv, void *buf, size_t len )
1095 {
1096
1097         uint32 tv_sec, tv_usec;
1098         size_t offset = 0;
1099
1100         /* Unpack message */
1101
1102         offset += tdb_unpack((uint8 *)buf + offset, len - offset, "f",
1103                              msg->printer);
1104
1105         offset += tdb_unpack((uint8 *)buf + offset, len - offset, "ddddddd",
1106                                 &tv_sec, &tv_usec,
1107                                 &msg->type, &msg->field, &msg->id, &msg->len, &msg->flags);
1108
1109         if (msg->len == 0)
1110                 tdb_unpack((uint8 *)buf + offset, len - offset, "dd",
1111                            &msg->notify.value[0], &msg->notify.value[1]);
1112         else
1113                 tdb_unpack((uint8 *)buf + offset, len - offset, "B",
1114                            &msg->len, &msg->notify.data);
1115
1116         DEBUG(3, ("notify2_unpack_msg: got NOTIFY2 message for printer %s, jobid %u type %d, field 0x%02x, flags 0x%04x\n",
1117                   msg->printer, (unsigned int)msg->id, msg->type, msg->field, msg->flags));
1118
1119         tv->tv_sec = tv_sec;
1120         tv->tv_usec = tv_usec;
1121
1122         if (msg->len == 0)
1123                 DEBUG(3, ("notify2_unpack_msg: value1 = %d, value2 = %d\n", msg->notify.value[0],
1124                           msg->notify.value[1]));
1125         else
1126                 dump_data(3, (uint8 *)msg->notify.data, msg->len);
1127
1128         return True;
1129 }
1130
1131 /********************************************************************
1132  Receive a notify2 message list
1133  ********************************************************************/
1134
1135 static void receive_notify2_message_list(struct messaging_context *msg,
1136                                          void *private_data,
1137                                          uint32_t msg_type,
1138                                          struct server_id server_id,
1139                                          DATA_BLOB *data)
1140 {
1141         size_t                  msg_count, i;
1142         char                    *buf = (char *)data->data;
1143         char                    *msg_ptr;
1144         size_t                  msg_len;
1145         SPOOLSS_NOTIFY_MSG      notify;
1146         SPOOLSS_NOTIFY_MSG_CTR  messages;
1147         int                     num_groups;
1148
1149         if (data->length < 4) {
1150                 DEBUG(0,("receive_notify2_message_list: bad message format (len < 4)!\n"));
1151                 return;
1152         }
1153
1154         msg_count = IVAL(buf, 0);
1155         msg_ptr = buf + 4;
1156
1157         DEBUG(5, ("receive_notify2_message_list: got %lu messages in list\n", (unsigned long)msg_count));
1158
1159         if (msg_count == 0) {
1160                 DEBUG(0,("receive_notify2_message_list: bad message format (msg_count == 0) !\n"));
1161                 return;
1162         }
1163
1164         /* initialize the container */
1165
1166         ZERO_STRUCT( messages );
1167         notify_msg_ctr_init( &messages );
1168
1169         /*
1170          * build message groups for each printer identified
1171          * in a change_notify msg.  Remember that a PCN message
1172          * includes the handle returned for the srv_spoolss_replyopenprinter()
1173          * call.  Therefore messages are grouped according to printer handle.
1174          */
1175
1176         for ( i=0; i<msg_count; i++ ) {
1177                 struct timeval msg_tv;
1178
1179                 if (msg_ptr + 4 - buf > data->length) {
1180                         DEBUG(0,("receive_notify2_message_list: bad message format (len > buf_size) !\n"));
1181                         return;
1182                 }
1183
1184                 msg_len = IVAL(msg_ptr,0);
1185                 msg_ptr += 4;
1186
1187                 if (msg_ptr + msg_len - buf > data->length) {
1188                         DEBUG(0,("receive_notify2_message_list: bad message format (bad len) !\n"));
1189                         return;
1190                 }
1191
1192                 /* unpack messages */
1193
1194                 ZERO_STRUCT( notify );
1195                 notify2_unpack_msg( &notify, &msg_tv, msg_ptr, msg_len );
1196                 msg_ptr += msg_len;
1197
1198                 /* add to correct list in container */
1199
1200                 notify_msg_ctr_addmsg( &messages, &notify );
1201
1202                 /* free memory that might have been allocated by notify2_unpack_msg() */
1203
1204                 if ( notify.len != 0 )
1205                         SAFE_FREE( notify.notify.data );
1206         }
1207
1208         /* process each group of messages */
1209
1210         num_groups = notify_msg_ctr_numgroups( &messages );
1211         for ( i=0; i<num_groups; i++ )
1212                 send_notify2_changes( &messages, i );
1213
1214
1215         /* cleanup */
1216
1217         DEBUG(10,("receive_notify2_message_list: processed %u messages\n", (uint32)msg_count ));
1218
1219         notify_msg_ctr_destroy( &messages );
1220
1221         return;
1222 }
1223
1224 /********************************************************************
1225  Send a message to ourself about new driver being installed
1226  so we can upgrade the information for each printer bound to this
1227  driver
1228  ********************************************************************/
1229
1230 static bool srv_spoolss_drv_upgrade_printer(char* drivername)
1231 {
1232         int len = strlen(drivername);
1233
1234         if (!len)
1235                 return False;
1236
1237         DEBUG(10,("srv_spoolss_drv_upgrade_printer: Sending message about driver upgrade [%s]\n",
1238                 drivername));
1239
1240         messaging_send_buf(smbd_messaging_context(), procid_self(),
1241                            MSG_PRINTER_DRVUPGRADE,
1242                            (uint8 *)drivername, len+1);
1243
1244         return True;
1245 }
1246
1247 /**********************************************************************
1248  callback to receive a MSG_PRINTER_DRVUPGRADE message and interate
1249  over all printers, upgrading ones as necessary
1250  **********************************************************************/
1251
1252 void do_drv_upgrade_printer(struct messaging_context *msg,
1253                             void *private_data,
1254                             uint32_t msg_type,
1255                             struct server_id server_id,
1256                             DATA_BLOB *data)
1257 {
1258         fstring drivername;
1259         int snum;
1260         int n_services = lp_numservices();
1261         size_t len;
1262
1263         len = MIN(data->length,sizeof(drivername)-1);
1264         strncpy(drivername, (const char *)data->data, len);
1265
1266         DEBUG(10,("do_drv_upgrade_printer: Got message for new driver [%s]\n", drivername ));
1267
1268         /* Iterate the printer list */
1269
1270         for (snum=0; snum<n_services; snum++)
1271         {
1272                 if (lp_snum_ok(snum) && lp_print_ok(snum) )
1273                 {
1274                         WERROR result;
1275                         NT_PRINTER_INFO_LEVEL *printer = NULL;
1276
1277                         result = get_a_printer(NULL, &printer, 2, lp_const_servicename(snum));
1278                         if (!W_ERROR_IS_OK(result))
1279                                 continue;
1280
1281                         if (printer && printer->info_2 && !strcmp(drivername, printer->info_2->drivername))
1282                         {
1283                                 DEBUG(6,("Updating printer [%s]\n", printer->info_2->printername));
1284
1285                                 /* all we care about currently is the change_id */
1286
1287                                 result = mod_a_printer(printer, 2);
1288                                 if (!W_ERROR_IS_OK(result)) {
1289                                         DEBUG(3,("do_drv_upgrade_printer: mod_a_printer() failed with status [%s]\n",
1290                                                 win_errstr(result)));
1291                                 }
1292                         }
1293
1294                         free_a_printer(&printer, 2);
1295                 }
1296         }
1297
1298         /* all done */
1299 }
1300
1301 /********************************************************************
1302  Update the cache for all printq's with a registered client
1303  connection
1304  ********************************************************************/
1305
1306 void update_monitored_printq_cache( void )
1307 {
1308         Printer_entry *printer = printers_list;
1309         int snum;
1310
1311         /* loop through all printers and update the cache where
1312            client_connected == True */
1313         while ( printer )
1314         {
1315                 if ( (printer->printer_type == SPLHND_PRINTER)
1316                         && printer->notify.client_connected )
1317                 {
1318                         snum = print_queue_snum(printer->sharename);
1319                         print_queue_status( snum, NULL, NULL );
1320                 }
1321
1322                 printer = printer->next;
1323         }
1324
1325         return;
1326 }
1327 /********************************************************************
1328  Send a message to ourself about new driver being installed
1329  so we can upgrade the information for each printer bound to this
1330  driver
1331  ********************************************************************/
1332
1333 static bool srv_spoolss_reset_printerdata(char* drivername)
1334 {
1335         int len = strlen(drivername);
1336
1337         if (!len)
1338                 return False;
1339
1340         DEBUG(10,("srv_spoolss_reset_printerdata: Sending message about resetting printerdata [%s]\n",
1341                 drivername));
1342
1343         messaging_send_buf(smbd_messaging_context(), procid_self(),
1344                            MSG_PRINTERDATA_INIT_RESET,
1345                            (uint8 *)drivername, len+1);
1346
1347         return True;
1348 }
1349
1350 /**********************************************************************
1351  callback to receive a MSG_PRINTERDATA_INIT_RESET message and interate
1352  over all printers, resetting printer data as neessary
1353  **********************************************************************/
1354
1355 void reset_all_printerdata(struct messaging_context *msg,
1356                            void *private_data,
1357                            uint32_t msg_type,
1358                            struct server_id server_id,
1359                            DATA_BLOB *data)
1360 {
1361         fstring drivername;
1362         int snum;
1363         int n_services = lp_numservices();
1364         size_t len;
1365
1366         len = MIN( data->length, sizeof(drivername)-1 );
1367         strncpy( drivername, (const char *)data->data, len );
1368
1369         DEBUG(10,("reset_all_printerdata: Got message for new driver [%s]\n", drivername ));
1370
1371         /* Iterate the printer list */
1372
1373         for ( snum=0; snum<n_services; snum++ )
1374         {
1375                 if ( lp_snum_ok(snum) && lp_print_ok(snum) )
1376                 {
1377                         WERROR result;
1378                         NT_PRINTER_INFO_LEVEL *printer = NULL;
1379
1380                         result = get_a_printer( NULL, &printer, 2, lp_const_servicename(snum) );
1381                         if ( !W_ERROR_IS_OK(result) )
1382                                 continue;
1383
1384                         /*
1385                          * if the printer is bound to the driver,
1386                          * then reset to the new driver initdata
1387                          */
1388
1389                         if ( printer && printer->info_2 && !strcmp(drivername, printer->info_2->drivername) )
1390                         {
1391                                 DEBUG(6,("reset_all_printerdata: Updating printer [%s]\n", printer->info_2->printername));
1392
1393                                 if ( !set_driver_init(printer, 2) ) {
1394                                         DEBUG(5,("reset_all_printerdata: Error resetting printer data for printer [%s], driver [%s]!\n",
1395                                                 printer->info_2->printername, printer->info_2->drivername));
1396                                 }
1397
1398                                 result = mod_a_printer( printer, 2 );
1399                                 if ( !W_ERROR_IS_OK(result) ) {
1400                                         DEBUG(3,("reset_all_printerdata: mod_a_printer() failed!  (%s)\n",
1401                                                 get_dos_error_msg(result)));
1402                                 }
1403                         }
1404
1405                         free_a_printer( &printer, 2 );
1406                 }
1407         }
1408
1409         /* all done */
1410
1411         return;
1412 }
1413
1414 /****************************************************************
1415  _spoolss_OpenPrinter
1416 ****************************************************************/
1417
1418 WERROR _spoolss_OpenPrinter(pipes_struct *p,
1419                             struct spoolss_OpenPrinter *r)
1420 {
1421         struct spoolss_OpenPrinterEx e;
1422         WERROR werr;
1423
1424         ZERO_STRUCT(e.in.userlevel);
1425
1426         e.in.printername        = r->in.printername;
1427         e.in.datatype           = r->in.datatype;
1428         e.in.devmode_ctr        = r->in.devmode_ctr;
1429         e.in.access_mask        = r->in.access_mask;
1430         e.in.level              = 0;
1431
1432         e.out.handle            = r->out.handle;
1433
1434         werr = _spoolss_OpenPrinterEx(p, &e);
1435
1436         if (W_ERROR_EQUAL(werr, WERR_INVALID_PARAM)) {
1437                 /* OpenPrinterEx returns this for a bad
1438                  * printer name. We must return WERR_INVALID_PRINTER_NAME
1439                  * instead.
1440                  */
1441                 werr = WERR_INVALID_PRINTER_NAME;
1442         }
1443
1444         return werr;
1445 }
1446
1447 /********************************************************************
1448  FIXME: temporary convert_devicemode_new function
1449  ********************************************************************/
1450
1451 static bool convert_devicemode_new(const char *printername,
1452                                    struct spoolss_DeviceMode *devmode,
1453                                    NT_DEVICEMODE **pp_nt_devmode)
1454 {
1455         NT_DEVICEMODE *nt_devmode = *pp_nt_devmode;
1456
1457         /*
1458          * Ensure nt_devmode is a valid pointer
1459          * as we will be overwriting it.
1460          */
1461
1462         if (nt_devmode == NULL) {
1463                 DEBUG(5, ("convert_devicemode_new: allocating a generic devmode\n"));
1464                 if ((nt_devmode = construct_nt_devicemode(printername)) == NULL)
1465                         return false;
1466         }
1467
1468         rpcstr_push(nt_devmode->devicename, devmode->devicename, 31, 0);
1469         rpcstr_push(nt_devmode->formname, devmode->formname, 31, 0);
1470
1471         nt_devmode->specversion         = devmode->specversion;
1472         nt_devmode->driverversion       = devmode->driverversion;
1473         nt_devmode->size                = devmode->size;
1474         nt_devmode->fields              = devmode->fields;
1475         nt_devmode->orientation         = devmode->orientation;
1476         nt_devmode->papersize           = devmode->papersize;
1477         nt_devmode->paperlength         = devmode->paperlength;
1478         nt_devmode->paperwidth          = devmode->paperwidth;
1479         nt_devmode->scale               = devmode->scale;
1480         nt_devmode->copies              = devmode->copies;
1481         nt_devmode->defaultsource       = devmode->defaultsource;
1482         nt_devmode->printquality        = devmode->printquality;
1483         nt_devmode->color               = devmode->color;
1484         nt_devmode->duplex              = devmode->duplex;
1485         nt_devmode->yresolution         = devmode->yresolution;
1486         nt_devmode->ttoption            = devmode->ttoption;
1487         nt_devmode->collate             = devmode->collate;
1488
1489         nt_devmode->logpixels           = devmode->logpixels;
1490         nt_devmode->bitsperpel          = devmode->bitsperpel;
1491         nt_devmode->pelswidth           = devmode->pelswidth;
1492         nt_devmode->pelsheight          = devmode->pelsheight;
1493         nt_devmode->displayflags        = devmode->displayflags;
1494         nt_devmode->displayfrequency    = devmode->displayfrequency;
1495         nt_devmode->icmmethod           = devmode->icmmethod;
1496         nt_devmode->icmintent           = devmode->icmintent;
1497         nt_devmode->mediatype           = devmode->mediatype;
1498         nt_devmode->dithertype          = devmode->dithertype;
1499         nt_devmode->reserved1           = devmode->reserved1;
1500         nt_devmode->reserved2           = devmode->reserved2;
1501         nt_devmode->panningwidth        = devmode->panningwidth;
1502         nt_devmode->panningheight       = devmode->panningheight;
1503
1504         /*
1505          * Only change private and driverextra if the incoming devmode
1506          * has a new one. JRA.
1507          */
1508
1509         if ((devmode->__driverextra_length != 0) && (devmode->driverextra_data.data != NULL)) {
1510                 SAFE_FREE(nt_devmode->nt_dev_private);
1511                 nt_devmode->driverextra = devmode->__driverextra_length;
1512                 if((nt_devmode->nt_dev_private=SMB_MALLOC_ARRAY(uint8, nt_devmode->driverextra)) == NULL)
1513                         return false;
1514                 memcpy(nt_devmode->nt_dev_private, devmode->driverextra_data.data, nt_devmode->driverextra);
1515         }
1516
1517         *pp_nt_devmode = nt_devmode;
1518
1519         return true;
1520 }
1521
1522 /****************************************************************
1523  _spoolss_OpenPrinterEx
1524 ****************************************************************/
1525
1526 WERROR _spoolss_OpenPrinterEx(pipes_struct *p,
1527                               struct spoolss_OpenPrinterEx *r)
1528 {
1529         POLICY_HND              *handle = r->out.handle;
1530         char *name = CONST_DISCARD(char *, r->in.printername);
1531         int snum;
1532         Printer_entry *Printer=NULL;
1533
1534         if (!name) {
1535                 return WERR_INVALID_PARAM;
1536         }
1537
1538         /* some sanity check because you can open a printer or a print server */
1539         /* aka: \\server\printer or \\server */
1540
1541         DEBUGADD(3,("checking name: %s\n",name));
1542
1543         if (!open_printer_hnd(p, handle, name, 0)) {
1544                 ZERO_STRUCTP(r->out.handle);
1545                 return WERR_INVALID_PARAM;
1546         }
1547
1548         Printer=find_printer_index_by_hnd(p, handle);
1549         if ( !Printer ) {
1550                 DEBUG(0,("_spoolss_OpenPrinterEx: logic error.  Can't find printer "
1551                         "handle we created for printer %s\n", name ));
1552                 close_printer_handle(p,handle);
1553                 ZERO_STRUCTP(r->out.handle);
1554                 return WERR_INVALID_PARAM;
1555         }
1556
1557         /*
1558          * First case: the user is opening the print server:
1559          *
1560          * Disallow MS AddPrinterWizard if parameter disables it. A Win2k
1561          * client 1st tries an OpenPrinterEx with access==0, MUST be allowed.
1562          *
1563          * Then both Win2k and WinNT clients try an OpenPrinterEx with
1564          * SERVER_ALL_ACCESS, which we allow only if the user is root (uid=0)
1565          * or if the user is listed in the smb.conf printer admin parameter.
1566          *
1567          * Then they try OpenPrinterEx with SERVER_READ which we allow. This lets the
1568          * client view printer folder, but does not show the MSAPW.
1569          *
1570          * Note: this test needs code to check access rights here too. Jeremy
1571          * could you look at this?
1572          *
1573          * Second case: the user is opening a printer:
1574          * NT doesn't let us connect to a printer if the connecting user
1575          * doesn't have print permission.
1576          *
1577          * Third case: user is opening a Port Monitor
1578          * access checks same as opening a handle to the print server.
1579          */
1580
1581         switch (Printer->printer_type )
1582         {
1583         case SPLHND_SERVER:
1584         case SPLHND_PORTMON_TCP:
1585         case SPLHND_PORTMON_LOCAL:
1586                 /* Printserver handles use global struct... */
1587
1588                 snum = -1;
1589
1590                 /* Map standard access rights to object specific access rights */
1591
1592                 se_map_standard(&r->in.access_mask,
1593                                 &printserver_std_mapping);
1594
1595                 /* Deny any object specific bits that don't apply to print
1596                    servers (i.e printer and job specific bits) */
1597
1598                 r->in.access_mask &= SPECIFIC_RIGHTS_MASK;
1599
1600                 if (r->in.access_mask &
1601                     ~(SERVER_ACCESS_ADMINISTER | SERVER_ACCESS_ENUMERATE)) {
1602                         DEBUG(3, ("access DENIED for non-printserver bits\n"));
1603                         close_printer_handle(p, handle);
1604                         ZERO_STRUCTP(r->out.handle);
1605                         return WERR_ACCESS_DENIED;
1606                 }
1607
1608                 /* Allow admin access */
1609
1610                 if ( r->in.access_mask & SERVER_ACCESS_ADMINISTER )
1611                 {
1612                         SE_PRIV se_printop = SE_PRINT_OPERATOR;
1613
1614                         if (!lp_ms_add_printer_wizard()) {
1615                                 close_printer_handle(p, handle);
1616                                 ZERO_STRUCTP(r->out.handle);
1617                                 return WERR_ACCESS_DENIED;
1618                         }
1619
1620                         /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
1621                            and not a printer admin, then fail */
1622
1623                         if ((p->server_info->utok.uid != 0) &&
1624                             !user_has_privileges(p->server_info->ptok,
1625                                                  &se_printop ) &&
1626                             !token_contains_name_in_list(
1627                                     uidtoname(p->server_info->utok.uid),
1628                                     NULL, NULL,
1629                                     p->server_info->ptok,
1630                                     lp_printer_admin(snum))) {
1631                                 close_printer_handle(p, handle);
1632                                 ZERO_STRUCTP(r->out.handle);
1633                                 return WERR_ACCESS_DENIED;
1634                         }
1635
1636                         r->in.access_mask = SERVER_ACCESS_ADMINISTER;
1637                 }
1638                 else
1639                 {
1640                         r->in.access_mask = SERVER_ACCESS_ENUMERATE;
1641                 }
1642
1643                 DEBUG(4,("Setting print server access = %s\n", (r->in.access_mask == SERVER_ACCESS_ADMINISTER)
1644                         ? "SERVER_ACCESS_ADMINISTER" : "SERVER_ACCESS_ENUMERATE" ));
1645
1646                 /* We fall through to return WERR_OK */
1647                 break;
1648
1649         case SPLHND_PRINTER:
1650                 /* NT doesn't let us connect to a printer if the connecting user
1651                    doesn't have print permission.  */
1652
1653                 if (!get_printer_snum(p, handle, &snum, NULL)) {
1654                         close_printer_handle(p, handle);
1655                         ZERO_STRUCTP(r->out.handle);
1656                         return WERR_BADFID;
1657                 }
1658
1659                 se_map_standard(&r->in.access_mask, &printer_std_mapping);
1660
1661                 /* map an empty access mask to the minimum access mask */
1662                 if (r->in.access_mask == 0x0)
1663                         r->in.access_mask = PRINTER_ACCESS_USE;
1664
1665                 /*
1666                  * If we are not serving the printer driver for this printer,
1667                  * map PRINTER_ACCESS_ADMINISTER to PRINTER_ACCESS_USE.  This
1668                  * will keep NT clients happy  --jerry
1669                  */
1670
1671                 if (lp_use_client_driver(snum)
1672                         && (r->in.access_mask & PRINTER_ACCESS_ADMINISTER))
1673                 {
1674                         r->in.access_mask = PRINTER_ACCESS_USE;
1675                 }
1676
1677                 /* check smb.conf parameters and the the sec_desc */
1678
1679                 if ( !check_access(get_client_fd(), lp_hostsallow(snum), lp_hostsdeny(snum)) ) {
1680                         DEBUG(3, ("access DENIED (hosts allow/deny) for printer open\n"));
1681                         ZERO_STRUCTP(r->out.handle);
1682                         return WERR_ACCESS_DENIED;
1683                 }
1684
1685                 if (!user_ok_token(uidtoname(p->server_info->utok.uid), NULL,
1686                                    p->server_info->ptok, snum) ||
1687                     !print_access_check(p->server_info, snum,
1688                                         r->in.access_mask)) {
1689                         DEBUG(3, ("access DENIED for printer open\n"));
1690                         close_printer_handle(p, handle);
1691                         ZERO_STRUCTP(r->out.handle);
1692                         return WERR_ACCESS_DENIED;
1693                 }
1694
1695                 if ((r->in.access_mask & SPECIFIC_RIGHTS_MASK)& ~(PRINTER_ACCESS_ADMINISTER|PRINTER_ACCESS_USE)) {
1696                         DEBUG(3, ("access DENIED for printer open - unknown bits\n"));
1697                         close_printer_handle(p, handle);
1698                         ZERO_STRUCTP(r->out.handle);
1699                         return WERR_ACCESS_DENIED;
1700                 }
1701
1702                 if (r->in.access_mask & PRINTER_ACCESS_ADMINISTER)
1703                         r->in.access_mask = PRINTER_ACCESS_ADMINISTER;
1704                 else
1705                         r->in.access_mask = PRINTER_ACCESS_USE;
1706
1707                 DEBUG(4,("Setting printer access = %s\n", (r->in.access_mask == PRINTER_ACCESS_ADMINISTER)
1708                         ? "PRINTER_ACCESS_ADMINISTER" : "PRINTER_ACCESS_USE" ));
1709
1710                 break;
1711
1712         default:
1713                 /* sanity check to prevent programmer error */
1714                 ZERO_STRUCTP(r->out.handle);
1715                 return WERR_BADFID;
1716         }
1717
1718         Printer->access_granted = r->in.access_mask;
1719
1720         /*
1721          * If the client sent a devmode in the OpenPrinter() call, then
1722          * save it here in case we get a job submission on this handle
1723          */
1724
1725          if ( (Printer->printer_type != SPLHND_SERVER)
1726                 && r->in.devmode_ctr.devmode )
1727          {
1728                 convert_devicemode_new(Printer->sharename,
1729                                        r->in.devmode_ctr.devmode,
1730                                        &Printer->nt_devmode);
1731          }
1732
1733 #if 0   /* JERRY -- I'm doubtful this is really effective */
1734         /* HACK ALERT!!! Sleep for 1/3 of a second to try trigger a LAN/WAN
1735            optimization in Windows 2000 clients  --jerry */
1736
1737         if ( (r->in.access_mask == PRINTER_ACCESS_ADMINISTER)
1738                 && (RA_WIN2K == get_remote_arch()) )
1739         {
1740                 DEBUG(10,("_spoolss_OpenPrinterEx: Enabling LAN/WAN hack for Win2k clients.\n"));
1741                 sys_usleep( 500000 );
1742         }
1743 #endif
1744
1745         return WERR_OK;
1746 }
1747
1748 /****************************************************************************
1749 ****************************************************************************/
1750
1751 static bool printer_info2_to_nt_printer_info2(struct spoolss_SetPrinterInfo2 *r,
1752                                               NT_PRINTER_INFO_LEVEL_2 *d)
1753 {
1754         DEBUG(7,("printer_info2_to_nt_printer_info2\n"));
1755
1756         if (!r || !d) {
1757                 return false;
1758         }
1759
1760         d->attributes           = r->attributes;
1761         d->priority             = r->priority;
1762         d->default_priority     = r->defaultpriority;
1763         d->starttime            = r->starttime;
1764         d->untiltime            = r->untiltime;
1765         d->status               = r->status;
1766         d->cjobs                = r->cjobs;
1767
1768         fstrcpy(d->servername,  r->servername);
1769         fstrcpy(d->printername, r->printername);
1770         fstrcpy(d->sharename,   r->sharename);
1771         fstrcpy(d->portname,    r->portname);
1772         fstrcpy(d->drivername,  r->drivername);
1773         slprintf(d->comment, sizeof(d->comment)-1, "%s", r->comment);
1774         fstrcpy(d->location,    r->location);
1775         fstrcpy(d->sepfile,     r->sepfile);
1776         fstrcpy(d->printprocessor, r->printprocessor);
1777         fstrcpy(d->datatype,    r->datatype);
1778         fstrcpy(d->parameters,  r->parameters);
1779
1780         return true;
1781 }
1782
1783 /****************************************************************************
1784 ****************************************************************************/
1785
1786 static bool convert_printer_info_new(struct spoolss_SetPrinterInfoCtr *info_ctr,
1787                                      NT_PRINTER_INFO_LEVEL *printer)
1788 {
1789         bool ret;
1790
1791         switch (info_ctr->level) {
1792         case 2:
1793                 /* allocate memory if needed.  Messy because
1794                    convert_printer_info is used to update an existing
1795                    printer or build a new one */
1796
1797                 if (!printer->info_2) {
1798                         printer->info_2 = TALLOC_ZERO_P(printer, NT_PRINTER_INFO_LEVEL_2);
1799                         if (!printer->info_2) {
1800                                 DEBUG(0,("convert_printer_info_new: "
1801                                         "talloc() failed!\n"));
1802                                 return false;
1803                         }
1804                 }
1805
1806                 ret = printer_info2_to_nt_printer_info2(info_ctr->info.info2,
1807                                                         printer->info_2);
1808                 printer->info_2->setuptime = time(NULL);
1809                 return ret;
1810         }
1811
1812         return false;
1813 }
1814
1815 /*******************************************************************
1816 ********************************************************************/
1817
1818 static bool string_array_to_fstring_array(const char **sarray, fstring **farray)
1819 {
1820         int i;
1821
1822         if (!sarray) {
1823                 *farray = NULL;
1824                 return true;
1825         }
1826
1827         *farray = SMB_MALLOC_ARRAY(fstring, 1);
1828         if (!*farray) {
1829                 return false;
1830         }
1831
1832         for (i=0; sarray[i] != NULL; i++) {
1833                 *farray = SMB_REALLOC_ARRAY(*farray, fstring, i+2);
1834                 if (!*farray) {
1835                         return false;
1836                 }
1837                 fstrcpy((*farray)[i], sarray[i]);
1838         }
1839
1840         fstrcpy((*farray)[i], "");
1841
1842         return true;
1843 }
1844
1845 /*******************************************************************
1846 ********************************************************************/
1847
1848 static bool driver_info3_to_nt_driver_info3(struct spoolss_AddDriverInfo3 *r,
1849                                             NT_PRINTER_DRIVER_INFO_LEVEL_3 **p)
1850 {
1851         NT_PRINTER_DRIVER_INFO_LEVEL_3 *d;
1852
1853         DEBUG(7,("driver_info3_to_nt_driver_info3: Converting from UNICODE to ASCII\n"));
1854
1855         if (*p == NULL) {
1856                 *p = SMB_MALLOC_P(NT_PRINTER_DRIVER_INFO_LEVEL_3);
1857                 if (*p == NULL) {
1858                         return false;
1859                 }
1860                 ZERO_STRUCTP(*p);
1861         }
1862
1863         d = *p;
1864
1865         d->cversion =                   r->version;
1866
1867         fstrcpy(d->name,                r->driver_name);
1868         fstrcpy(d->environment,         r->architecture);
1869         fstrcpy(d->driverpath,          r->driver_path);
1870         fstrcpy(d->datafile,            r->data_file);
1871         fstrcpy(d->configfile,          r->config_file);
1872         fstrcpy(d->helpfile,            r->help_file);
1873         fstrcpy(d->monitorname,         r->monitor_name);
1874         fstrcpy(d->defaultdatatype,     r->default_datatype);
1875
1876         DEBUGADD(8,( "version:         %d\n", d->cversion));
1877         DEBUGADD(8,( "name:            %s\n", d->name));
1878         DEBUGADD(8,( "environment:     %s\n", d->environment));
1879         DEBUGADD(8,( "driverpath:      %s\n", d->driverpath));
1880         DEBUGADD(8,( "datafile:        %s\n", d->datafile));
1881         DEBUGADD(8,( "configfile:      %s\n", d->configfile));
1882         DEBUGADD(8,( "helpfile:        %s\n", d->helpfile));
1883         DEBUGADD(8,( "monitorname:     %s\n", d->monitorname));
1884         DEBUGADD(8,( "defaultdatatype: %s\n", d->defaultdatatype));
1885
1886         if (r->dependent_files) {
1887                 if (!string_array_to_fstring_array(r->dependent_files->string,
1888                                                    &d->dependentfiles)) {
1889                         SAFE_FREE(*p);
1890                         return false;
1891                 }
1892         }
1893
1894         return true;
1895 }
1896
1897 /*******************************************************************
1898 ********************************************************************/
1899
1900 static bool driver_info6_to_nt_driver_info6(struct spoolss_AddDriverInfo6 *r,
1901                                             NT_PRINTER_DRIVER_INFO_LEVEL_6 **p)
1902 {
1903         NT_PRINTER_DRIVER_INFO_LEVEL_6 *d;
1904
1905         DEBUG(7,("driver_info6_to_nt_driver_info6: Converting from UNICODE to ASCII\n"));
1906
1907         if (*p == NULL) {
1908                 *p = SMB_MALLOC_P(NT_PRINTER_DRIVER_INFO_LEVEL_6);
1909                 if (*p == NULL) {
1910                         return false;
1911                 }
1912                 ZERO_STRUCTP(*p);
1913         }
1914
1915         d = *p;
1916
1917         d->version =                    r->version;
1918
1919         fstrcpy(d->name,                r->driver_name);
1920         fstrcpy(d->environment,         r->architecture);
1921         fstrcpy(d->driverpath,          r->driver_path);
1922         fstrcpy(d->datafile,            r->data_file);
1923         fstrcpy(d->configfile,          r->config_file);
1924         fstrcpy(d->helpfile,            r->help_file);
1925         fstrcpy(d->monitorname,         r->monitor_name);
1926         fstrcpy(d->defaultdatatype,     r->default_datatype);
1927
1928         DEBUGADD(8,( "version:         %d\n", d->version));
1929         DEBUGADD(8,( "name:            %s\n", d->name));
1930         DEBUGADD(8,( "environment:     %s\n", d->environment));
1931         DEBUGADD(8,( "driverpath:      %s\n", d->driverpath));
1932         DEBUGADD(8,( "datafile:        %s\n", d->datafile));
1933         DEBUGADD(8,( "configfile:      %s\n", d->configfile));
1934         DEBUGADD(8,( "helpfile:        %s\n", d->helpfile));
1935         DEBUGADD(8,( "monitorname:     %s\n", d->monitorname));
1936         DEBUGADD(8,( "defaultdatatype: %s\n", d->defaultdatatype));
1937
1938         if (r->dependent_files) {
1939                 if (!string_array_to_fstring_array(r->dependent_files->string,
1940                                                    &d->dependentfiles)) {
1941                         goto error;
1942                 }
1943         }
1944
1945         if (r->previous_names) {
1946                 if (!string_array_to_fstring_array(r->previous_names->string,
1947                                                    &d->previousnames)) {
1948                         goto error;
1949                 }
1950         }
1951
1952         return true;
1953
1954  error:
1955         SAFE_FREE(*p);
1956         return false;
1957 }
1958
1959 /********************************************************************
1960  ********************************************************************/
1961
1962 static bool convert_printer_driver_info(const struct spoolss_AddDriverInfoCtr *r,
1963                                         NT_PRINTER_DRIVER_INFO_LEVEL *printer,
1964                                         uint32_t level)
1965 {
1966         switch (level) {
1967         case 3:
1968                 printer->info_3 = NULL;
1969                 if (!driver_info3_to_nt_driver_info3(r->info.info3, &printer->info_3)) {
1970                         return false;
1971                 }
1972                 break;
1973         case 6:
1974                 printer->info_6 = NULL;
1975                 if (!driver_info6_to_nt_driver_info6(r->info.info6, &printer->info_6)) {
1976                         return false;
1977                 }
1978                 break;
1979         default:
1980                 return false;
1981         }
1982
1983         return true;
1984 }
1985
1986 bool convert_devicemode(const char *printername, const DEVICEMODE *devmode,
1987                                 NT_DEVICEMODE **pp_nt_devmode)
1988 {
1989         NT_DEVICEMODE *nt_devmode = *pp_nt_devmode;
1990
1991         /*
1992          * Ensure nt_devmode is a valid pointer
1993          * as we will be overwriting it.
1994          */
1995
1996         if (nt_devmode == NULL) {
1997                 DEBUG(5, ("convert_devicemode: allocating a generic devmode\n"));
1998                 if ((nt_devmode = construct_nt_devicemode(printername)) == NULL)
1999                         return False;
2000         }
2001
2002         rpcstr_pull(nt_devmode->devicename,devmode->devicename.buffer, 31, -1, 0);
2003         rpcstr_pull(nt_devmode->formname,devmode->formname.buffer, 31, -1, 0);
2004
2005         nt_devmode->specversion=devmode->specversion;
2006         nt_devmode->driverversion=devmode->driverversion;
2007         nt_devmode->size=devmode->size;
2008         nt_devmode->fields=devmode->fields;
2009         nt_devmode->orientation=devmode->orientation;
2010         nt_devmode->papersize=devmode->papersize;
2011         nt_devmode->paperlength=devmode->paperlength;
2012         nt_devmode->paperwidth=devmode->paperwidth;
2013         nt_devmode->scale=devmode->scale;
2014         nt_devmode->copies=devmode->copies;
2015         nt_devmode->defaultsource=devmode->defaultsource;
2016         nt_devmode->printquality=devmode->printquality;
2017         nt_devmode->color=devmode->color;
2018         nt_devmode->duplex=devmode->duplex;
2019         nt_devmode->yresolution=devmode->yresolution;
2020         nt_devmode->ttoption=devmode->ttoption;
2021         nt_devmode->collate=devmode->collate;
2022
2023         nt_devmode->logpixels=devmode->logpixels;
2024         nt_devmode->bitsperpel=devmode->bitsperpel;
2025         nt_devmode->pelswidth=devmode->pelswidth;
2026         nt_devmode->pelsheight=devmode->pelsheight;
2027         nt_devmode->displayflags=devmode->displayflags;
2028         nt_devmode->displayfrequency=devmode->displayfrequency;
2029         nt_devmode->icmmethod=devmode->icmmethod;
2030         nt_devmode->icmintent=devmode->icmintent;
2031         nt_devmode->mediatype=devmode->mediatype;
2032         nt_devmode->dithertype=devmode->dithertype;
2033         nt_devmode->reserved1=devmode->reserved1;
2034         nt_devmode->reserved2=devmode->reserved2;
2035         nt_devmode->panningwidth=devmode->panningwidth;
2036         nt_devmode->panningheight=devmode->panningheight;
2037
2038         /*
2039          * Only change private and driverextra if the incoming devmode
2040          * has a new one. JRA.
2041          */
2042
2043         if ((devmode->driverextra != 0) && (devmode->dev_private != NULL)) {
2044                 SAFE_FREE(nt_devmode->nt_dev_private);
2045                 nt_devmode->driverextra=devmode->driverextra;
2046                 if((nt_devmode->nt_dev_private=SMB_MALLOC_ARRAY(uint8, nt_devmode->driverextra)) == NULL)
2047                         return False;
2048                 memcpy(nt_devmode->nt_dev_private, devmode->dev_private, nt_devmode->driverextra);
2049         }
2050
2051         *pp_nt_devmode = nt_devmode;
2052
2053         return True;
2054 }
2055
2056 /********************************************************************
2057  * _spoolss_enddocprinter_internal.
2058  ********************************************************************/
2059
2060 static WERROR _spoolss_enddocprinter_internal(pipes_struct *p, POLICY_HND *handle)
2061 {
2062         Printer_entry *Printer=find_printer_index_by_hnd(p, handle);
2063         int snum;
2064
2065         if (!Printer) {
2066                 DEBUG(2,("_spoolss_enddocprinter_internal: Invalid handle (%s:%u:%u)\n", OUR_HANDLE(handle)));
2067                 return WERR_BADFID;
2068         }
2069
2070         if (!get_printer_snum(p, handle, &snum, NULL))
2071                 return WERR_BADFID;
2072
2073         Printer->document_started=False;
2074         print_job_end(snum, Printer->jobid,NORMAL_CLOSE);
2075         /* error codes unhandled so far ... */
2076
2077         return WERR_OK;
2078 }
2079
2080 /****************************************************************
2081  _spoolss_ClosePrinter
2082 ****************************************************************/
2083
2084 WERROR _spoolss_ClosePrinter(pipes_struct *p,
2085                              struct spoolss_ClosePrinter *r)
2086 {
2087         POLICY_HND *handle = r->in.handle;
2088
2089         Printer_entry *Printer=find_printer_index_by_hnd(p, handle);
2090
2091         if (Printer && Printer->document_started)
2092                 _spoolss_enddocprinter_internal(p, handle);          /* print job was not closed */
2093
2094         if (!close_printer_handle(p, handle))
2095                 return WERR_BADFID;
2096
2097         /* clear the returned printer handle.  Observed behavior
2098            from Win2k server.  Don't think this really matters.
2099            Previous code just copied the value of the closed
2100            handle.    --jerry */
2101
2102         ZERO_STRUCTP(r->out.handle);
2103
2104         return WERR_OK;
2105 }
2106
2107 /****************************************************************
2108  _spoolss_DeletePrinter
2109 ****************************************************************/
2110
2111 WERROR _spoolss_DeletePrinter(pipes_struct *p,
2112                               struct spoolss_DeletePrinter *r)
2113 {
2114         POLICY_HND *handle = r->in.handle;
2115         Printer_entry *Printer=find_printer_index_by_hnd(p, handle);
2116         WERROR result;
2117
2118         if (Printer && Printer->document_started)
2119                 _spoolss_enddocprinter_internal(p, handle);  /* print job was not closed */
2120
2121         result = delete_printer_handle(p, handle);
2122
2123         update_c_setprinter(False);
2124
2125         return result;
2126 }
2127
2128 /*******************************************************************
2129  * static function to lookup the version id corresponding to an
2130  * long architecture string
2131  ******************************************************************/
2132
2133 static int get_version_id (char * arch)
2134 {
2135         int i;
2136         struct table_node archi_table[]= {
2137
2138                 {"Windows 4.0",          "WIN40",       0 },
2139                 {"Windows NT x86",       "W32X86",      2 },
2140                 {"Windows NT R4000",     "W32MIPS",     2 },
2141                 {"Windows NT Alpha_AXP", "W32ALPHA",    2 },
2142                 {"Windows NT PowerPC",   "W32PPC",      2 },
2143                 {"Windows IA64",         "IA64",        3 },
2144                 {"Windows x64",          "x64",         3 },
2145                 {NULL,                   "",            -1 }
2146         };
2147
2148         for (i=0; archi_table[i].long_archi != NULL; i++)
2149         {
2150                 if (strcmp(arch, archi_table[i].long_archi) == 0)
2151                         return (archi_table[i].version);
2152         }
2153
2154         return -1;
2155 }
2156
2157 /****************************************************************
2158  _spoolss_DeletePrinterDriver
2159 ****************************************************************/
2160
2161 WERROR _spoolss_DeletePrinterDriver(pipes_struct *p,
2162                                     struct spoolss_DeletePrinterDriver *r)
2163 {
2164         char *driver;
2165         char *arch;
2166         NT_PRINTER_DRIVER_INFO_LEVEL    info;
2167         NT_PRINTER_DRIVER_INFO_LEVEL    info_win2k;
2168         int                             version;
2169         WERROR                          status;
2170         WERROR                          status_win2k = WERR_ACCESS_DENIED;
2171         SE_PRIV                         se_printop = SE_PRINT_OPERATOR;
2172
2173         /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
2174            and not a printer admin, then fail */
2175
2176         if ( (p->server_info->utok.uid != 0)
2177                 && !user_has_privileges(p->server_info->ptok, &se_printop )
2178                 && !token_contains_name_in_list(
2179                         uidtoname(p->server_info->utok.uid), NULL,
2180                         NULL, p->server_info->ptok,
2181                         lp_printer_admin(-1)) )
2182         {
2183                 return WERR_ACCESS_DENIED;
2184         }
2185
2186         driver = CONST_DISCARD(char *, r->in.driver);
2187         arch   = CONST_DISCARD(char *, r->in.architecture);
2188
2189         /* check that we have a valid driver name first */
2190
2191         if ((version=get_version_id(arch)) == -1)
2192                 return WERR_INVALID_ENVIRONMENT;
2193
2194         ZERO_STRUCT(info);
2195         ZERO_STRUCT(info_win2k);
2196
2197         if (!W_ERROR_IS_OK(get_a_printer_driver(&info, 3, driver, arch, version)))
2198         {
2199                 /* try for Win2k driver if "Windows NT x86" */
2200
2201                 if ( version == 2 ) {
2202                         version = 3;
2203                         if (!W_ERROR_IS_OK(get_a_printer_driver(&info, 3, driver, arch, version))) {
2204                                 status = WERR_UNKNOWN_PRINTER_DRIVER;
2205                                 goto done;
2206                         }
2207                 }
2208                 /* otherwise it was a failure */
2209                 else {
2210                         status = WERR_UNKNOWN_PRINTER_DRIVER;
2211                         goto done;
2212                 }
2213
2214         }
2215
2216         if (printer_driver_in_use(info.info_3)) {
2217                 status = WERR_PRINTER_DRIVER_IN_USE;
2218                 goto done;
2219         }
2220
2221         if ( version == 2 )
2222         {
2223                 if (W_ERROR_IS_OK(get_a_printer_driver(&info_win2k, 3, driver, arch, 3)))
2224                 {
2225                         /* if we get to here, we now have 2 driver info structures to remove */
2226                         /* remove the Win2k driver first*/
2227
2228                         status_win2k = delete_printer_driver(
2229                                 p, info_win2k.info_3, 3, False );
2230                         free_a_printer_driver( info_win2k, 3 );
2231
2232                         /* this should not have failed---if it did, report to client */
2233                         if ( !W_ERROR_IS_OK(status_win2k) )
2234                         {
2235                                 status = status_win2k;
2236                                 goto done;
2237                         }
2238                 }
2239         }
2240
2241         status = delete_printer_driver(p, info.info_3, version, False);
2242
2243         /* if at least one of the deletes succeeded return OK */
2244
2245         if ( W_ERROR_IS_OK(status) || W_ERROR_IS_OK(status_win2k) )
2246                 status = WERR_OK;
2247
2248 done:
2249         free_a_printer_driver( info, 3 );
2250
2251         return status;
2252 }
2253
2254 /****************************************************************
2255  _spoolss_DeletePrinterDriverEx
2256 ****************************************************************/
2257
2258 WERROR _spoolss_DeletePrinterDriverEx(pipes_struct *p,
2259                                       struct spoolss_DeletePrinterDriverEx *r)
2260 {
2261         char *driver;
2262         char *arch;
2263         NT_PRINTER_DRIVER_INFO_LEVEL    info;
2264         NT_PRINTER_DRIVER_INFO_LEVEL    info_win2k;
2265         int                             version;
2266         uint32_t                        flags = r->in.delete_flags;
2267         bool                            delete_files;
2268         WERROR                          status;
2269         WERROR                          status_win2k = WERR_ACCESS_DENIED;
2270         SE_PRIV                         se_printop = SE_PRINT_OPERATOR;
2271
2272         /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
2273            and not a printer admin, then fail */
2274
2275         if ( (p->server_info->utok.uid != 0)
2276                 && !user_has_privileges(p->server_info->ptok, &se_printop )
2277                 && !token_contains_name_in_list(
2278                         uidtoname(p->server_info->utok.uid), NULL, NULL,
2279                         p->server_info->ptok, lp_printer_admin(-1)) )
2280         {
2281                 return WERR_ACCESS_DENIED;
2282         }
2283
2284         driver = CONST_DISCARD(char *, r->in.driver);
2285         arch   = CONST_DISCARD(char *, r->in.architecture);
2286
2287         /* check that we have a valid driver name first */
2288         if ((version=get_version_id(arch)) == -1) {
2289                 /* this is what NT returns */
2290                 return WERR_INVALID_ENVIRONMENT;
2291         }
2292
2293         if ( flags & DPD_DELETE_SPECIFIC_VERSION )
2294                 version = r->in.version;
2295
2296         ZERO_STRUCT(info);
2297         ZERO_STRUCT(info_win2k);
2298
2299         status = get_a_printer_driver(&info, 3, driver, arch, version);
2300
2301         if ( !W_ERROR_IS_OK(status) )
2302         {
2303                 /*
2304                  * if the client asked for a specific version,
2305                  * or this is something other than Windows NT x86,
2306                  * then we've failed
2307                  */
2308
2309                 if ( (flags&DPD_DELETE_SPECIFIC_VERSION) || (version !=2) )
2310                         goto done;
2311
2312                 /* try for Win2k driver if "Windows NT x86" */
2313
2314                 version = 3;
2315                 if (!W_ERROR_IS_OK(get_a_printer_driver(&info, 3, driver, arch, version))) {
2316                         status = WERR_UNKNOWN_PRINTER_DRIVER;
2317                         goto done;
2318                 }
2319         }
2320
2321         if ( printer_driver_in_use(info.info_3) ) {
2322                 status = WERR_PRINTER_DRIVER_IN_USE;
2323                 goto done;
2324         }
2325
2326         /*
2327          * we have a couple of cases to consider.
2328          * (1) Are any files in use?  If so and DPD_DELTE_ALL_FILE is set,
2329          *     then the delete should fail if **any** files overlap with
2330          *     other drivers
2331          * (2) If DPD_DELTE_UNUSED_FILES is sert, then delete all
2332          *     non-overlapping files
2333          * (3) If neither DPD_DELTE_ALL_FILE nor DPD_DELTE_ALL_FILES
2334          *     is set, the do not delete any files
2335          * Refer to MSDN docs on DeletePrinterDriverEx() for details.
2336          */
2337
2338         delete_files = flags & (DPD_DELETE_ALL_FILES|DPD_DELETE_UNUSED_FILES);
2339
2340         /* fail if any files are in use and DPD_DELETE_ALL_FILES is set */
2341
2342         if ( delete_files && printer_driver_files_in_use(info.info_3) & (flags&DPD_DELETE_ALL_FILES) ) {
2343                 /* no idea of the correct error here */
2344                 status = WERR_ACCESS_DENIED;
2345                 goto done;
2346         }
2347
2348
2349         /* also check for W32X86/3 if necessary; maybe we already have? */
2350
2351         if ( (version == 2) && ((flags&DPD_DELETE_SPECIFIC_VERSION) != DPD_DELETE_SPECIFIC_VERSION)  ) {
2352                 if (W_ERROR_IS_OK(get_a_printer_driver(&info_win2k, 3, driver, arch, 3)))
2353                 {
2354
2355                         if ( delete_files && printer_driver_files_in_use(info_win2k.info_3) & (flags&DPD_DELETE_ALL_FILES) ) {
2356                                 /* no idea of the correct error here */
2357                                 free_a_printer_driver( info_win2k, 3 );
2358                                 status = WERR_ACCESS_DENIED;
2359                                 goto done;
2360                         }
2361
2362                         /* if we get to here, we now have 2 driver info structures to remove */
2363                         /* remove the Win2k driver first*/
2364
2365                         status_win2k = delete_printer_driver(
2366                                 p, info_win2k.info_3, 3, delete_files);
2367                         free_a_printer_driver( info_win2k, 3 );
2368
2369                         /* this should not have failed---if it did, report to client */
2370
2371                         if ( !W_ERROR_IS_OK(status_win2k) )
2372                                 goto done;
2373                 }
2374         }
2375
2376         status = delete_printer_driver(p, info.info_3, version, delete_files);
2377
2378         if ( W_ERROR_IS_OK(status) || W_ERROR_IS_OK(status_win2k) )
2379                 status = WERR_OK;
2380 done:
2381         free_a_printer_driver( info, 3 );
2382
2383         return status;
2384 }
2385
2386
2387 /****************************************************************************
2388  Internal routine for retreiving printerdata
2389  ***************************************************************************/
2390
2391 static WERROR get_printer_dataex( TALLOC_CTX *ctx, NT_PRINTER_INFO_LEVEL *printer,
2392                                   const char *key, const char *value, uint32 *type, uint8 **data,
2393                                   uint32 *needed, uint32 in_size  )
2394 {
2395         REGISTRY_VALUE          *val;
2396         uint32                  size;
2397         int                     data_len;
2398
2399         if ( !(val = get_printer_data( printer->info_2, key, value)) )
2400                 return WERR_BADFILE;
2401
2402         *type = regval_type( val );
2403
2404         DEBUG(5,("get_printer_dataex: allocating %d\n", in_size));
2405
2406         size = regval_size( val );
2407
2408         /* copy the min(in_size, len) */
2409
2410         if ( in_size ) {
2411                 data_len = (size > in_size) ? in_size : size*sizeof(uint8);
2412
2413                 /* special case for 0 length values */
2414                 if ( data_len ) {
2415                         if ( (*data  = (uint8 *)TALLOC_MEMDUP(ctx, regval_data_p(val), data_len)) == NULL )
2416                                 return WERR_NOMEM;
2417                 }
2418                 else {
2419                         if ( (*data  = (uint8 *)TALLOC_ZERO(ctx, in_size)) == NULL )
2420                                 return WERR_NOMEM;
2421                 }
2422         }
2423         else
2424                 *data = NULL;
2425
2426         *needed = size;
2427
2428         DEBUG(5,("get_printer_dataex: copy done\n"));
2429
2430         return WERR_OK;
2431 }
2432
2433 /****************************************************************************
2434  Internal routine for removing printerdata
2435  ***************************************************************************/
2436
2437 static WERROR delete_printer_dataex( NT_PRINTER_INFO_LEVEL *printer, const char *key, const char *value )
2438 {
2439         return delete_printer_data( printer->info_2, key, value );
2440 }
2441
2442 /****************************************************************************
2443  Internal routine for storing printerdata
2444  ***************************************************************************/
2445
2446 WERROR set_printer_dataex( NT_PRINTER_INFO_LEVEL *printer, const char *key, const char *value,
2447                                   uint32 type, uint8 *data, int real_len  )
2448 {
2449         /* the registry objects enforce uniqueness based on value name */
2450
2451         return add_printer_data( printer->info_2, key, value, type, data, real_len );
2452 }
2453
2454 /********************************************************************
2455  GetPrinterData on a printer server Handle.
2456 ********************************************************************/
2457
2458 static WERROR getprinterdata_printer_server(TALLOC_CTX *ctx, fstring value, uint32 *type, uint8 **data, uint32 *needed, uint32 in_size)
2459 {
2460         int i;
2461
2462         DEBUG(8,("getprinterdata_printer_server:%s\n", value));
2463
2464         if (!StrCaseCmp(value, "W3SvcInstalled")) {
2465                 *type = REG_DWORD;
2466                 if ( !(*data = TALLOC_ARRAY(ctx, uint8, sizeof(uint32) )) )
2467                         return WERR_NOMEM;
2468                 SIVAL(*data, 0, 0x00);
2469                 *needed = 0x4;
2470                 return WERR_OK;
2471         }
2472
2473         if (!StrCaseCmp(value, "BeepEnabled")) {
2474                 *type = REG_DWORD;
2475                 if ( !(*data = TALLOC_ARRAY(ctx, uint8, sizeof(uint32) )) )
2476                         return WERR_NOMEM;
2477                 SIVAL(*data, 0, 0x00);
2478                 *needed = 0x4;
2479                 return WERR_OK;
2480         }
2481
2482         if (!StrCaseCmp(value, "EventLog")) {
2483                 *type = REG_DWORD;
2484                 if ( !(*data = TALLOC_ARRAY(ctx, uint8, sizeof(uint32) )) )
2485                         return WERR_NOMEM;
2486                 /* formally was 0x1b */
2487                 SIVAL(*data, 0, 0x0);
2488                 *needed = 0x4;
2489                 return WERR_OK;
2490         }
2491
2492         if (!StrCaseCmp(value, "NetPopup")) {
2493                 *type = REG_DWORD;
2494                 if ( !(*data = TALLOC_ARRAY(ctx, uint8, sizeof(uint32) )) )
2495                         return WERR_NOMEM;
2496                 SIVAL(*data, 0, 0x00);
2497                 *needed = 0x4;
2498                 return WERR_OK;
2499         }
2500
2501         if (!StrCaseCmp(value, "MajorVersion")) {
2502                 *type = REG_DWORD;
2503                 if ( !(*data = TALLOC_ARRAY(ctx, uint8, sizeof(uint32) )) )
2504                         return WERR_NOMEM;
2505
2506                 /* Windows NT 4.0 seems to not allow uploading of drivers
2507                    to a server that reports 0x3 as the MajorVersion.
2508                    need to investigate more how Win2k gets around this .
2509                    -- jerry */
2510
2511                 if ( RA_WINNT == get_remote_arch() )
2512                         SIVAL(*data, 0, 2);
2513                 else
2514                         SIVAL(*data, 0, 3);
2515
2516                 *needed = 0x4;
2517                 return WERR_OK;
2518         }
2519
2520         if (!StrCaseCmp(value, "MinorVersion")) {
2521                 *type = REG_DWORD;
2522                 if ( !(*data = TALLOC_ARRAY(ctx, uint8, sizeof(uint32) )) )
2523                         return WERR_NOMEM;
2524                 SIVAL(*data, 0, 0);
2525                 *needed = 0x4;
2526                 return WERR_OK;
2527         }
2528
2529         /* REG_BINARY
2530          *  uint32 size          = 0x114
2531          *  uint32 major         = 5
2532          *  uint32 minor         = [0|1]
2533          *  uint32 build         = [2195|2600]
2534          *  extra unicode string = e.g. "Service Pack 3"
2535          */
2536         if (!StrCaseCmp(value, "OSVersion")) {
2537                 *type = REG_BINARY;
2538                 *needed = 0x114;
2539
2540                 if ( !(*data = TALLOC_ZERO_ARRAY(ctx, uint8, (*needed > in_size) ? *needed:in_size )) )
2541                         return WERR_NOMEM;
2542
2543                 SIVAL(*data, 0, *needed);       /* size */
2544                 SIVAL(*data, 4, 5);             /* Windows 2000 == 5.0 */
2545                 SIVAL(*data, 8, 0);
2546                 SIVAL(*data, 12, 2195);         /* build */
2547
2548                 /* leave extra string empty */
2549
2550                 return WERR_OK;
2551         }
2552
2553
2554         if (!StrCaseCmp(value, "DefaultSpoolDirectory")) {
2555                 const char *string="C:\\PRINTERS";
2556                 *type = REG_SZ;
2557                 *needed = 2*(strlen(string)+1);
2558                 if((*data  = (uint8 *)TALLOC(ctx, (*needed > in_size) ? *needed:in_size )) == NULL)
2559                         return WERR_NOMEM;
2560                 memset(*data, 0, (*needed > in_size) ? *needed:in_size);
2561
2562                 /* it's done by hand ready to go on the wire */
2563                 for (i=0; i<strlen(string); i++) {
2564                         (*data)[2*i]=string[i];
2565                         (*data)[2*i+1]='\0';
2566                 }
2567                 return WERR_OK;
2568         }
2569
2570         if (!StrCaseCmp(value, "Architecture")) {
2571                 const char *string="Windows NT x86";
2572                 *type = REG_SZ;
2573                 *needed = 2*(strlen(string)+1);
2574                 if((*data  = (uint8 *)TALLOC(ctx, (*needed > in_size) ? *needed:in_size )) == NULL)
2575                         return WERR_NOMEM;
2576                 memset(*data, 0, (*needed > in_size) ? *needed:in_size);
2577                 for (i=0; i<strlen(string); i++) {
2578                         (*data)[2*i]=string[i];
2579                         (*data)[2*i+1]='\0';
2580                 }
2581                 return WERR_OK;
2582         }
2583
2584         if (!StrCaseCmp(value, "DsPresent")) {
2585                 *type = REG_DWORD;
2586                 if ( !(*data = TALLOC_ARRAY(ctx, uint8, sizeof(uint32) )) )
2587                         return WERR_NOMEM;
2588
2589                 /* only show the publish check box if we are a
2590                    memeber of a AD domain */
2591
2592                 if ( lp_security() == SEC_ADS )
2593                         SIVAL(*data, 0, 0x01);
2594                 else
2595                         SIVAL(*data, 0, 0x00);
2596
2597                 *needed = 0x4;
2598                 return WERR_OK;
2599         }
2600
2601         if (!StrCaseCmp(value, "DNSMachineName")) {
2602                 const char *hostname = get_mydnsfullname();
2603
2604                 if (!hostname)
2605                         return WERR_BADFILE;
2606                 *type = REG_SZ;
2607                 *needed = 2*(strlen(hostname)+1);
2608                 if((*data  = (uint8 *)TALLOC(ctx, (*needed > in_size) ? *needed:in_size )) == NULL)
2609                         return WERR_NOMEM;
2610                 memset(*data, 0, (*needed > in_size) ? *needed:in_size);
2611                 for (i=0; i<strlen(hostname); i++) {
2612                         (*data)[2*i]=hostname[i];
2613                         (*data)[2*i+1]='\0';
2614                 }
2615                 return WERR_OK;
2616         }
2617
2618
2619         return WERR_BADFILE;
2620 }
2621
2622 /********************************************************************
2623  * spoolss_getprinterdata
2624  ********************************************************************/
2625
2626 WERROR _spoolss_getprinterdata(pipes_struct *p, SPOOL_Q_GETPRINTERDATA *q_u, SPOOL_R_GETPRINTERDATA *r_u)
2627 {
2628         POLICY_HND      *handle = &q_u->handle;
2629         UNISTR2         *valuename = &q_u->valuename;
2630         uint32          in_size = q_u->size;
2631         uint32          *type = &r_u->type;
2632         uint32          *out_size = &r_u->size;
2633         uint8           **data = &r_u->data;
2634         uint32          *needed = &r_u->needed;
2635         WERROR          status;
2636         fstring         value;
2637         Printer_entry   *Printer = find_printer_index_by_hnd(p, handle);
2638         NT_PRINTER_INFO_LEVEL   *printer = NULL;
2639         int             snum = 0;
2640
2641         /*
2642          * Reminder: when it's a string, the length is in BYTES
2643          * even if UNICODE is negociated.
2644          *
2645          * JFM, 4/19/1999
2646          */
2647
2648         *out_size = in_size;
2649
2650         /* in case of problem, return some default values */
2651
2652         *needed = 0;
2653         *type   = 0;
2654
2655         DEBUG(4,("_spoolss_getprinterdata\n"));
2656
2657         if ( !Printer ) {
2658                 DEBUG(2,("_spoolss_getprinterdata: Invalid handle (%s:%u:%u).\n", OUR_HANDLE(handle)));
2659                 status = WERR_BADFID;
2660                 goto done;
2661         }
2662
2663         unistr2_to_ascii(value, valuename, sizeof(value));
2664
2665         if ( Printer->printer_type == SPLHND_SERVER )
2666                 status = getprinterdata_printer_server( p->mem_ctx, value, type, data, needed, *out_size );
2667         else
2668         {
2669                 if ( !get_printer_snum(p,handle, &snum, NULL) ) {
2670                         status = WERR_BADFID;
2671                         goto done;
2672                 }
2673
2674                 status = get_a_printer(Printer, &printer, 2, lp_servicename(snum));
2675                 if ( !W_ERROR_IS_OK(status) )
2676                         goto done;
2677
2678                 /* XP sends this and wants to change id value from the PRINTER_INFO_0 */
2679
2680                 if ( strequal(value, "ChangeId") ) {
2681                         *type = REG_DWORD;
2682                         *needed = sizeof(uint32);
2683                         if ( (*data = (uint8*)TALLOC(p->mem_ctx, sizeof(uint32))) == NULL) {
2684                                 status = WERR_NOMEM;
2685                                 goto done;
2686                         }
2687                         SIVAL( *data, 0, printer->info_2->changeid );
2688                         status = WERR_OK;
2689                 }
2690                 else
2691                         status = get_printer_dataex( p->mem_ctx, printer, SPOOL_PRINTERDATA_KEY, value, type, data, needed, *out_size );
2692         }
2693
2694         if (*needed > *out_size)
2695                 status = WERR_MORE_DATA;
2696
2697 done:
2698         if ( !W_ERROR_IS_OK(status) )
2699         {
2700                 DEBUG(5, ("error %d: allocating %d\n", W_ERROR_V(status),*out_size));
2701
2702                 /* reply this param doesn't exist */
2703
2704                 if ( *out_size ) {
2705                         if((*data=(uint8 *)TALLOC_ZERO_ARRAY(p->mem_ctx, uint8, *out_size)) == NULL) {
2706                                 if ( printer )
2707                                         free_a_printer( &printer, 2 );
2708                                 return WERR_NOMEM;
2709                         }
2710                 } else {
2711                         *data = NULL;
2712                 }
2713         }
2714
2715         /* cleanup & exit */
2716
2717         if ( printer )
2718                 free_a_printer( &printer, 2 );
2719
2720         return status;
2721 }
2722
2723 /*********************************************************
2724  Connect to the client machine.
2725 **********************************************************/
2726
2727 static bool spoolss_connect_to_client(struct rpc_pipe_client **pp_pipe,
2728                         struct sockaddr_storage *client_ss, const char *remote_machine)
2729 {
2730         NTSTATUS ret;
2731         struct cli_state *the_cli;
2732         struct sockaddr_storage rm_addr;
2733
2734         if ( is_zero_addr((struct sockaddr *)client_ss) ) {
2735                 if ( !resolve_name( remote_machine, &rm_addr, 0x20) ) {
2736                         DEBUG(2,("spoolss_connect_to_client: Can't resolve address for %s\n", remote_machine));
2737                         return False;
2738                 }
2739
2740                 if (ismyaddr((struct sockaddr *)&rm_addr)) {
2741                         DEBUG(0,("spoolss_connect_to_client: Machine %s is one of our addresses. Cannot add to ourselves.\n", remote_machine));
2742                         return False;
2743                 }
2744         } else {
2745                 char addr[INET6_ADDRSTRLEN];
2746                 rm_addr = *client_ss;
2747                 print_sockaddr(addr, sizeof(addr), &rm_addr);
2748                 DEBUG(5,("spoolss_connect_to_client: Using address %s (no name resolution necessary)\n",
2749                         addr));
2750         }
2751
2752         /* setup the connection */
2753
2754         ret = cli_full_connection( &the_cli, global_myname(), remote_machine,
2755                 &rm_addr, 0, "IPC$", "IPC",
2756                 "", /* username */
2757                 "", /* domain */
2758                 "", /* password */
2759                 0, lp_client_signing(), NULL );
2760
2761         if ( !NT_STATUS_IS_OK( ret ) ) {
2762                 DEBUG(2,("spoolss_connect_to_client: connection to [%s] failed!\n",
2763                         remote_machine ));
2764                 return False;
2765         }
2766
2767         if ( the_cli->protocol != PROTOCOL_NT1 ) {
2768                 DEBUG(0,("spoolss_connect_to_client: machine %s didn't negotiate NT protocol.\n", remote_machine));
2769                 cli_shutdown(the_cli);
2770                 return False;
2771         }
2772
2773         /*
2774          * Ok - we have an anonymous connection to the IPC$ share.
2775          * Now start the NT Domain stuff :-).
2776          */
2777
2778         ret = cli_rpc_pipe_open_noauth(the_cli, &syntax_spoolss, pp_pipe);
2779         if (!NT_STATUS_IS_OK(ret)) {
2780                 DEBUG(2,("spoolss_connect_to_client: unable to open the spoolss pipe on machine %s. Error was : %s.\n",
2781                         remote_machine, nt_errstr(ret)));
2782                 cli_shutdown(the_cli);
2783                 return False;
2784         }
2785
2786         return True;
2787 }
2788
2789 /***************************************************************************
2790  Connect to the client.
2791 ****************************************************************************/
2792
2793 static bool srv_spoolss_replyopenprinter(int snum, const char *printer,
2794                                         uint32 localprinter, uint32 type,
2795                                         POLICY_HND *handle, struct sockaddr_storage *client_ss)
2796 {
2797         WERROR result;
2798         NTSTATUS status;
2799
2800         /*
2801          * If it's the first connection, contact the client
2802          * and connect to the IPC$ share anonymously
2803          */
2804         if (smb_connections==0) {
2805                 fstring unix_printer;
2806
2807                 fstrcpy(unix_printer, printer+2); /* the +2 is to strip the leading 2 backslashs */
2808
2809                 if ( !spoolss_connect_to_client( &notify_cli_pipe, client_ss, unix_printer ))
2810                         return False;
2811
2812                 messaging_register(smbd_messaging_context(), NULL,
2813                                    MSG_PRINTER_NOTIFY2,
2814                                    receive_notify2_message_list);
2815                 /* Tell the connections db we're now interested in printer
2816                  * notify messages. */
2817                 register_message_flags( True, FLAG_MSG_PRINT_NOTIFY );
2818         }
2819
2820         /*
2821          * Tell the specific printing tdb we want messages for this printer
2822          * by registering our PID.
2823          */
2824
2825         if (!print_notify_register_pid(snum))
2826                 DEBUG(0,("print_notify_register_pid: Failed to register our pid for printer %s\n", printer ));
2827
2828         smb_connections++;
2829
2830         status = rpccli_spoolss_ReplyOpenPrinter(notify_cli_pipe, talloc_tos(),
2831                                                  printer,
2832                                                  localprinter,
2833                                                  type,
2834                                                  0,
2835                                                  NULL,
2836                                                  handle,
2837                                                  &result);
2838         if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result))
2839                 DEBUG(5,("srv_spoolss_reply_open_printer: Client RPC returned [%s]\n",
2840                         win_errstr(result)));
2841
2842         return (W_ERROR_IS_OK(result));
2843 }
2844
2845 /****************************************************************
2846  ****************************************************************/
2847
2848 static struct spoolss_NotifyOption *dup_spoolss_NotifyOption(TALLOC_CTX *mem_ctx,
2849                                                              const struct spoolss_NotifyOption *r)
2850 {
2851         struct spoolss_NotifyOption *option;
2852         uint32_t i,k;
2853
2854         if (!r) {
2855                 return NULL;
2856         }
2857
2858         option = talloc_zero(mem_ctx, struct spoolss_NotifyOption);
2859         if (!option) {
2860                 return NULL;
2861         }
2862
2863         *option = *r;
2864
2865         if (!option->count) {
2866                 return option;
2867         }
2868
2869         option->types = talloc_zero_array(option,
2870                 struct spoolss_NotifyOptionType, option->count);
2871         if (!option->types) {
2872                 talloc_free(option);
2873                 return NULL;
2874         }
2875
2876         for (i=0; i < option->count; i++) {
2877                 option->types[i] = r->types[i];
2878
2879                 if (option->types[i].count) {
2880                         option->types[i].fields = talloc_zero_array(option,
2881                                 enum spoolss_Field, option->types[i].count);
2882                         if (!option->types[i].fields) {
2883                                 talloc_free(option);
2884                                 return NULL;
2885                         }
2886                         for (k=0; k<option->types[i].count; k++) {
2887                                 option->types[i].fields[k] =
2888                                         r->types[i].fields[k];
2889                         }
2890                 }
2891         }
2892
2893         return option;
2894 }
2895
2896 /****************************************************************
2897  * _spoolss_RemoteFindFirstPrinterChangeNotifyEx
2898  *
2899  * before replying OK: status=0 a rpc call is made to the workstation
2900  * asking ReplyOpenPrinter
2901  *
2902  * in fact ReplyOpenPrinter is the changenotify equivalent on the spoolss pipe
2903  * called from api_spoolss_rffpcnex
2904 ****************************************************************/
2905
2906 WERROR _spoolss_RemoteFindFirstPrinterChangeNotifyEx(pipes_struct *p,
2907                                                      struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
2908 {
2909         POLICY_HND *handle = r->in.handle;
2910         int snum = -1;
2911         struct spoolss_NotifyOption *option = r->in.notify_options;
2912         struct sockaddr_storage client_ss;
2913
2914         /* store the notify value in the printer struct */
2915
2916         Printer_entry *Printer=find_printer_index_by_hnd(p, handle);
2917
2918         if (!Printer) {
2919                 DEBUG(2,("_spoolss_RemoteFindFirstPrinterChangeNotifyEx: "
2920                         "Invalid handle (%s:%u:%u).\n", OUR_HANDLE(handle)));
2921                 return WERR_BADFID;
2922         }
2923
2924         Printer->notify.flags           = r->in.flags;
2925         Printer->notify.options         = r->in.options;
2926         Printer->notify.printerlocal    = r->in.printer_local;
2927
2928         TALLOC_FREE(Printer->notify.option);
2929         Printer->notify.option = dup_spoolss_NotifyOption(Printer, option);
2930
2931         fstrcpy(Printer->notify.localmachine, r->in.local_machine);
2932
2933         /* Connect to the client machine and send a ReplyOpenPrinter */
2934
2935         if ( Printer->printer_type == SPLHND_SERVER)
2936                 snum = -1;
2937         else if ( (Printer->printer_type == SPLHND_PRINTER) &&
2938                         !get_printer_snum(p, handle, &snum, NULL) )
2939                 return WERR_BADFID;
2940
2941         if (!interpret_string_addr(&client_ss, p->client_address,
2942                                    AI_NUMERICHOST)) {
2943                 return WERR_SERVER_UNAVAILABLE;
2944         }
2945
2946         if(!srv_spoolss_replyopenprinter(snum, Printer->notify.localmachine,
2947                                         Printer->notify.printerlocal, 1,
2948                                         &Printer->notify.client_hnd, &client_ss))
2949                 return WERR_SERVER_UNAVAILABLE;
2950
2951         Printer->notify.client_connected=True;
2952
2953         return WERR_OK;
2954 }
2955
2956 /*******************************************************************
2957  * fill a notify_info_data with the servername
2958  ********************************************************************/
2959
2960 void spoolss_notify_server_name(int snum,
2961                                        struct spoolss_Notify *data,
2962                                        print_queue_struct *queue,
2963                                        NT_PRINTER_INFO_LEVEL *printer,
2964                                        TALLOC_CTX *mem_ctx)
2965 {
2966         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->servername);
2967 }
2968
2969 /*******************************************************************
2970  * fill a notify_info_data with the printername (not including the servername).
2971  ********************************************************************/
2972
2973 void spoolss_notify_printer_name(int snum,
2974                                         struct spoolss_Notify *data,
2975                                         print_queue_struct *queue,
2976                                         NT_PRINTER_INFO_LEVEL *printer,
2977                                         TALLOC_CTX *mem_ctx)
2978 {
2979         /* the notify name should not contain the \\server\ part */
2980         char *p = strrchr(printer->info_2->printername, '\\');
2981
2982         if (!p) {
2983                 p = printer->info_2->printername;
2984         } else {
2985                 p++;
2986         }
2987
2988         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, p);
2989 }
2990
2991 /*******************************************************************
2992  * fill a notify_info_data with the servicename
2993  ********************************************************************/
2994
2995 void spoolss_notify_share_name(int snum,
2996                                       struct spoolss_Notify *data,
2997                                       print_queue_struct *queue,
2998                                       NT_PRINTER_INFO_LEVEL *printer,
2999                                       TALLOC_CTX *mem_ctx)
3000 {
3001         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, lp_servicename(snum));
3002 }
3003
3004 /*******************************************************************
3005  * fill a notify_info_data with the port name
3006  ********************************************************************/
3007
3008 void spoolss_notify_port_name(int snum,
3009                                      struct spoolss_Notify *data,
3010                                      print_queue_struct *queue,
3011                                      NT_PRINTER_INFO_LEVEL *printer,
3012                                      TALLOC_CTX *mem_ctx)
3013 {
3014         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->portname);
3015 }
3016
3017 /*******************************************************************
3018  * fill a notify_info_data with the printername
3019  * but it doesn't exist, have to see what to do
3020  ********************************************************************/
3021
3022 void spoolss_notify_driver_name(int snum,
3023                                        struct spoolss_Notify *data,
3024                                        print_queue_struct *queue,
3025                                        NT_PRINTER_INFO_LEVEL *printer,
3026                                        TALLOC_CTX *mem_ctx)
3027 {
3028         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->drivername);
3029 }
3030
3031 /*******************************************************************
3032  * fill a notify_info_data with the comment
3033  ********************************************************************/
3034
3035 void spoolss_notify_comment(int snum,
3036                                    struct spoolss_Notify *data,
3037                                    print_queue_struct *queue,
3038                                    NT_PRINTER_INFO_LEVEL *printer,
3039                                    TALLOC_CTX *mem_ctx)
3040 {
3041         char *p;
3042
3043         if (*printer->info_2->comment == '\0') {
3044                 p = lp_comment(snum);
3045         } else {
3046                 p = printer->info_2->comment;
3047         }
3048
3049         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->comment);
3050 }
3051
3052 /*******************************************************************
3053  * fill a notify_info_data with the comment
3054  * location = "Room 1, floor 2, building 3"
3055  ********************************************************************/
3056
3057 void spoolss_notify_location(int snum,
3058                                     struct spoolss_Notify *data,
3059                                     print_queue_struct *queue,
3060                                     NT_PRINTER_INFO_LEVEL *printer,
3061                                     TALLOC_CTX *mem_ctx)
3062 {
3063         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->location);
3064 }
3065
3066 /*******************************************************************
3067  * fill a notify_info_data with the device mode
3068  * jfm:xxxx don't to it for know but that's a real problem !!!
3069  ********************************************************************/
3070
3071 static void spoolss_notify_devmode(int snum,
3072                                    struct spoolss_Notify *data,
3073                                    print_queue_struct *queue,
3074                                    NT_PRINTER_INFO_LEVEL *printer,
3075                                    TALLOC_CTX *mem_ctx)
3076 {
3077         /* for a dummy implementation we have to zero the fields */
3078         SETUP_SPOOLSS_NOTIFY_DATA_DEVMODE(data, NULL);
3079 }
3080
3081 /*******************************************************************
3082  * fill a notify_info_data with the separator file name
3083  ********************************************************************/
3084
3085 void spoolss_notify_sepfile(int snum,
3086                                    struct spoolss_Notify *data,
3087                                    print_queue_struct *queue,
3088                                    NT_PRINTER_INFO_LEVEL *printer,
3089                                    TALLOC_CTX *mem_ctx)
3090 {
3091         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->sepfile);
3092 }
3093
3094 /*******************************************************************
3095  * fill a notify_info_data with the print processor
3096  * jfm:xxxx return always winprint to indicate we don't do anything to it
3097  ********************************************************************/
3098
3099 void spoolss_notify_print_processor(int snum,
3100                                            struct spoolss_Notify *data,
3101                                            print_queue_struct *queue,
3102                                            NT_PRINTER_INFO_LEVEL *printer,
3103                                            TALLOC_CTX *mem_ctx)
3104 {
3105         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->printprocessor);
3106 }
3107
3108 /*******************************************************************
3109  * fill a notify_info_data with the print processor options
3110  * jfm:xxxx send an empty string
3111  ********************************************************************/
3112
3113 void spoolss_notify_parameters(int snum,
3114                                       struct spoolss_Notify *data,
3115                                       print_queue_struct *queue,
3116                                       NT_PRINTER_INFO_LEVEL *printer,
3117                                       TALLOC_CTX *mem_ctx)
3118 {
3119         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->parameters);
3120 }
3121
3122 /*******************************************************************
3123  * fill a notify_info_data with the data type
3124  * jfm:xxxx always send RAW as data type
3125  ********************************************************************/
3126
3127 void spoolss_notify_datatype(int snum,
3128                                     struct spoolss_Notify *data,
3129                                     print_queue_struct *queue,
3130                                     NT_PRINTER_INFO_LEVEL *printer,
3131                                     TALLOC_CTX *mem_ctx)
3132 {
3133         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->datatype);
3134 }
3135
3136 /*******************************************************************
3137  * fill a notify_info_data with the security descriptor
3138  * jfm:xxxx send an null pointer to say no security desc
3139  * have to implement security before !
3140  ********************************************************************/
3141
3142 static void spoolss_notify_security_desc(int snum,
3143                                          struct spoolss_Notify *data,
3144                                          print_queue_struct *queue,
3145                                          NT_PRINTER_INFO_LEVEL *printer,
3146                                          TALLOC_CTX *mem_ctx)
3147 {
3148         SETUP_SPOOLSS_NOTIFY_DATA_SECDESC(data,
3149                                           printer->info_2->secdesc_buf->sd_size,
3150                                           printer->info_2->secdesc_buf->sd);
3151 }
3152
3153 /*******************************************************************
3154  * fill a notify_info_data with the attributes
3155  * jfm:xxxx a samba printer is always shared
3156  ********************************************************************/
3157
3158 void spoolss_notify_attributes(int snum,
3159                                       struct spoolss_Notify *data,
3160                                       print_queue_struct *queue,
3161                                       NT_PRINTER_INFO_LEVEL *printer,
3162                                       TALLOC_CTX *mem_ctx)
3163 {
3164         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->attributes);
3165 }
3166
3167 /*******************************************************************
3168  * fill a notify_info_data with the priority
3169  ********************************************************************/
3170
3171 static void spoolss_notify_priority(int snum,
3172                                     struct spoolss_Notify *data,
3173                                     print_queue_struct *queue,
3174                                     NT_PRINTER_INFO_LEVEL *printer,
3175                                     TALLOC_CTX *mem_ctx)
3176 {
3177         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->priority);
3178 }
3179
3180 /*******************************************************************
3181  * fill a notify_info_data with the default priority
3182  ********************************************************************/
3183
3184 static void spoolss_notify_default_priority(int snum,
3185                                             struct spoolss_Notify *data,
3186                                             print_queue_struct *queue,
3187                                             NT_PRINTER_INFO_LEVEL *printer,
3188                                             TALLOC_CTX *mem_ctx)
3189 {
3190         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->default_priority);
3191 }
3192
3193 /*******************************************************************
3194  * fill a notify_info_data with the start time
3195  ********************************************************************/
3196
3197 static void spoolss_notify_start_time(int snum,
3198                                       struct spoolss_Notify *data,
3199                                       print_queue_struct *queue,
3200                                       NT_PRINTER_INFO_LEVEL *printer,
3201                                       TALLOC_CTX *mem_ctx)
3202 {
3203         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->starttime);
3204 }
3205
3206 /*******************************************************************
3207  * fill a notify_info_data with the until time
3208  ********************************************************************/
3209
3210 static void spoolss_notify_until_time(int snum,
3211                                       struct spoolss_Notify *data,
3212                                       print_queue_struct *queue,
3213                                       NT_PRINTER_INFO_LEVEL *printer,
3214                                       TALLOC_CTX *mem_ctx)
3215 {
3216         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->untiltime);
3217 }
3218
3219 /*******************************************************************
3220  * fill a notify_info_data with the status
3221  ********************************************************************/
3222
3223 static void spoolss_notify_status(int snum,
3224                                   struct spoolss_Notify *data,
3225                                   print_queue_struct *queue,
3226                                   NT_PRINTER_INFO_LEVEL *printer,
3227                                   TALLOC_CTX *mem_ctx)
3228 {
3229         print_status_struct status;
3230
3231         print_queue_length(snum, &status);
3232         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, status.status);
3233 }
3234
3235 /*******************************************************************
3236  * fill a notify_info_data with the number of jobs queued
3237  ********************************************************************/
3238
3239 void spoolss_notify_cjobs(int snum,
3240                                  struct spoolss_Notify *data,
3241                                  print_queue_struct *queue,
3242                                  NT_PRINTER_INFO_LEVEL *printer,
3243                                  TALLOC_CTX *mem_ctx)
3244 {
3245         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, print_queue_length(snum, NULL));
3246 }
3247
3248 /*******************************************************************
3249  * fill a notify_info_data with the average ppm
3250  ********************************************************************/
3251
3252 static void spoolss_notify_average_ppm(int snum,
3253                                        struct spoolss_Notify *data,
3254                                        print_queue_struct *queue,
3255                                        NT_PRINTER_INFO_LEVEL *printer,
3256                                        TALLOC_CTX *mem_ctx)
3257 {
3258         /* always respond 8 pages per minutes */
3259         /* a little hard ! */
3260         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->averageppm);
3261 }
3262
3263 /*******************************************************************
3264  * fill a notify_info_data with username
3265  ********************************************************************/
3266
3267 static void spoolss_notify_username(int snum,
3268                                     struct spoolss_Notify *data,
3269                                     print_queue_struct *queue,
3270                                     NT_PRINTER_INFO_LEVEL *printer,
3271                                     TALLOC_CTX *mem_ctx)
3272 {
3273         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, queue->fs_user);
3274 }
3275
3276 /*******************************************************************
3277  * fill a notify_info_data with job status
3278  ********************************************************************/
3279
3280 static void spoolss_notify_job_status(int snum,
3281                                       struct spoolss_Notify *data,
3282                                       print_queue_struct *queue,
3283                                       NT_PRINTER_INFO_LEVEL *printer,
3284                                       TALLOC_CTX *mem_ctx)
3285 {
3286         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, nt_printj_status(queue->status));
3287 }
3288
3289 /*******************************************************************
3290  * fill a notify_info_data with job name
3291  ********************************************************************/
3292
3293 static void spoolss_notify_job_name(int snum,
3294                                     struct spoolss_Notify *data,
3295                                     print_queue_struct *queue,
3296                                     NT_PRINTER_INFO_LEVEL *printer,
3297                                     TALLOC_CTX *mem_ctx)
3298 {
3299         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, queue->fs_file);
3300 }
3301
3302 /*******************************************************************
3303  * fill a notify_info_data with job status
3304  ********************************************************************/
3305
3306 static void spoolss_notify_job_status_string(int snum,
3307                                              struct spoolss_Notify *data,
3308                                              print_queue_struct *queue,
3309                                              NT_PRINTER_INFO_LEVEL *printer,
3310                                              TALLOC_CTX *mem_ctx)
3311 {
3312         /*
3313          * Now we're returning job status codes we just return a "" here. JRA.
3314          */
3315
3316         const char *p = "";
3317
3318 #if 0 /* NO LONGER NEEDED - JRA. 02/22/2001 */
3319         p = "unknown";
3320
3321         switch (queue->status) {
3322         case LPQ_QUEUED:
3323                 p = "Queued";
3324                 break;
3325         case LPQ_PAUSED:
3326                 p = "";    /* NT provides the paused string */
3327                 break;
3328         case LPQ_SPOOLING:
3329                 p = "Spooling";
3330                 break;
3331         case LPQ_PRINTING:
3332                 p = "Printing";
3333                 break;
3334         }
3335 #endif /* NO LONGER NEEDED. */
3336
3337         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, p);
3338 }
3339
3340 /*******************************************************************
3341  * fill a notify_info_data with job time
3342  ********************************************************************/
3343
3344 static void spoolss_notify_job_time(int snum,
3345                                     struct spoolss_Notify *data,
3346                                     print_queue_struct *queue,
3347                                     NT_PRINTER_INFO_LEVEL *printer,
3348                                     TALLOC_CTX *mem_ctx)
3349 {
3350         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, 0);
3351 }
3352
3353 /*******************************************************************
3354  * fill a notify_info_data with job size
3355  ********************************************************************/
3356
3357 static void spoolss_notify_job_size(int snum,
3358                                     struct spoolss_Notify *data,
3359                                     print_queue_struct *queue,
3360                                     NT_PRINTER_INFO_LEVEL *printer,
3361                                     TALLOC_CTX *mem_ctx)
3362 {
3363         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->size);
3364 }
3365
3366 /*******************************************************************
3367  * fill a notify_info_data with page info
3368  ********************************************************************/
3369 static void spoolss_notify_total_pages(int snum,
3370                                 struct spoolss_Notify *data,
3371                                 print_queue_struct *queue,
3372                                 NT_PRINTER_INFO_LEVEL *printer,
3373                                 TALLOC_CTX *mem_ctx)
3374 {
3375         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->page_count);
3376 }
3377
3378 /*******************************************************************
3379  * fill a notify_info_data with pages printed info.
3380  ********************************************************************/
3381 static void spoolss_notify_pages_printed(int snum,
3382                                 struct spoolss_Notify *data,
3383                                 print_queue_struct *queue,
3384                                 NT_PRINTER_INFO_LEVEL *printer,
3385                                 TALLOC_CTX *mem_ctx)
3386 {
3387         /* Add code when back-end tracks this */
3388         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, 0);
3389 }
3390
3391 /*******************************************************************
3392  Fill a notify_info_data with job position.
3393  ********************************************************************/
3394
3395 static void spoolss_notify_job_position(int snum,
3396                                         struct spoolss_Notify *data,
3397                                         print_queue_struct *queue,
3398                                         NT_PRINTER_INFO_LEVEL *printer,
3399                                         TALLOC_CTX *mem_ctx)
3400 {
3401         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->job);
3402 }
3403
3404 /*******************************************************************
3405  Fill a notify_info_data with submitted time.
3406  ********************************************************************/
3407
3408 static void spoolss_notify_submitted_time(int snum,
3409                                           struct spoolss_Notify *data,
3410                                           print_queue_struct *queue,
3411                                           NT_PRINTER_INFO_LEVEL *printer,
3412                                           TALLOC_CTX *mem_ctx)
3413 {
3414         data->data.string.string = NULL;
3415         data->data.string.size = 0;
3416
3417         init_systemtime_buffer(mem_ctx, gmtime(&queue->time),
3418                                &data->data.string.string,
3419                                &data->data.string.size);
3420
3421 }
3422
3423 struct s_notify_info_data_table
3424 {
3425         enum spoolss_NotifyType type;
3426         enum spoolss_Field field;
3427         const char *name;
3428         enum spoolss_NotifyTable variable_type;
3429         void (*fn) (int snum, struct spoolss_Notify *data,
3430                     print_queue_struct *queue,
3431                     NT_PRINTER_INFO_LEVEL *printer, TALLOC_CTX *mem_ctx);
3432 };
3433
3434 /* A table describing the various print notification constants and
3435    whether the notification data is a pointer to a variable sized
3436    buffer, a one value uint32 or a two value uint32. */
3437
3438 static const struct s_notify_info_data_table notify_info_data_table[] =
3439 {
3440 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_SERVER_NAME,         "PRINTER_NOTIFY_SERVER_NAME",         NOTIFY_TABLE_STRING,   spoolss_notify_server_name },
3441 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_PRINTER_NAME,        "PRINTER_NOTIFY_PRINTER_NAME",        NOTIFY_TABLE_STRING,   spoolss_notify_printer_name },
3442 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_SHARE_NAME,          "PRINTER_NOTIFY_SHARE_NAME",          NOTIFY_TABLE_STRING,   spoolss_notify_share_name },
3443 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_PORT_NAME,           "PRINTER_NOTIFY_PORT_NAME",           NOTIFY_TABLE_STRING,   spoolss_notify_port_name },
3444 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_DRIVER_NAME,         "PRINTER_NOTIFY_DRIVER_NAME",         NOTIFY_TABLE_STRING,   spoolss_notify_driver_name },
3445 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_COMMENT,             "PRINTER_NOTIFY_COMMENT",             NOTIFY_TABLE_STRING,   spoolss_notify_comment },
3446 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_LOCATION,            "PRINTER_NOTIFY_LOCATION",            NOTIFY_TABLE_STRING,   spoolss_notify_location },
3447 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_DEVMODE,             "PRINTER_NOTIFY_DEVMODE",             NOTIFY_TABLE_DEVMODE,  spoolss_notify_devmode },
3448 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_SEPFILE,             "PRINTER_NOTIFY_SEPFILE",             NOTIFY_TABLE_STRING,   spoolss_notify_sepfile },
3449 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_PRINT_PROCESSOR,     "PRINTER_NOTIFY_PRINT_PROCESSOR",     NOTIFY_TABLE_STRING,   spoolss_notify_print_processor },
3450 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_PARAMETERS,          "PRINTER_NOTIFY_PARAMETERS",          NOTIFY_TABLE_STRING,   spoolss_notify_parameters },
3451 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_DATATYPE,            "PRINTER_NOTIFY_DATATYPE",            NOTIFY_TABLE_STRING,   spoolss_notify_datatype },
3452 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_SECURITY_DESCRIPTOR, "PRINTER_NOTIFY_SECURITY_DESCRIPTOR", NOTIFY_TABLE_SECURITYDESCRIPTOR,   spoolss_notify_security_desc },
3453 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_ATTRIBUTES,          "PRINTER_NOTIFY_ATTRIBUTES",          NOTIFY_TABLE_DWORD,    spoolss_notify_attributes },
3454 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_PRIORITY,            "PRINTER_NOTIFY_PRIORITY",            NOTIFY_TABLE_DWORD,    spoolss_notify_priority },
3455 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_DEFAULT_PRIORITY,    "PRINTER_NOTIFY_DEFAULT_PRIORITY",    NOTIFY_TABLE_DWORD,    spoolss_notify_default_priority },
3456 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_START_TIME,          "PRINTER_NOTIFY_START_TIME",          NOTIFY_TABLE_DWORD,    spoolss_notify_start_time },
3457 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_UNTIL_TIME,          "PRINTER_NOTIFY_UNTIL_TIME",          NOTIFY_TABLE_DWORD,    spoolss_notify_until_time },
3458 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_STATUS,              "PRINTER_NOTIFY_STATUS",              NOTIFY_TABLE_DWORD,    spoolss_notify_status },
3459 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_STATUS_STRING,       "PRINTER_NOTIFY_STATUS_STRING",       NOTIFY_TABLE_STRING,   NULL },
3460 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_CJOBS,               "PRINTER_NOTIFY_CJOBS",               NOTIFY_TABLE_DWORD,    spoolss_notify_cjobs },
3461 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_AVERAGE_PPM,         "PRINTER_NOTIFY_AVERAGE_PPM",         NOTIFY_TABLE_DWORD,    spoolss_notify_average_ppm },
3462 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_TOTAL_PAGES,         "PRINTER_NOTIFY_TOTAL_PAGES",         NOTIFY_TABLE_DWORD,    NULL },
3463 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_PAGES_PRINTED,       "PRINTER_NOTIFY_PAGES_PRINTED",       NOTIFY_TABLE_DWORD,    NULL },
3464 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_TOTAL_BYTES,         "PRINTER_NOTIFY_TOTAL_BYTES",         NOTIFY_TABLE_DWORD,    NULL },
3465 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_BYTES_PRINTED,       "PRINTER_NOTIFY_BYTES_PRINTED",       NOTIFY_TABLE_DWORD,    NULL },
3466 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_PRINTER_NAME,            "JOB_NOTIFY_PRINTER_NAME",            NOTIFY_TABLE_STRING,   spoolss_notify_printer_name },
3467 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_MACHINE_NAME,            "JOB_NOTIFY_MACHINE_NAME",            NOTIFY_TABLE_STRING,   spoolss_notify_server_name },
3468 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_PORT_NAME,               "JOB_NOTIFY_PORT_NAME",               NOTIFY_TABLE_STRING,   spoolss_notify_port_name },
3469 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_USER_NAME,               "JOB_NOTIFY_USER_NAME",               NOTIFY_TABLE_STRING,   spoolss_notify_username },
3470 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_NOTIFY_NAME,             "JOB_NOTIFY_NOTIFY_NAME",             NOTIFY_TABLE_STRING,   spoolss_notify_username },
3471 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_DATATYPE,                "JOB_NOTIFY_DATATYPE",                NOTIFY_TABLE_STRING,   spoolss_notify_datatype },
3472 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_PRINT_PROCESSOR,         "JOB_NOTIFY_PRINT_PROCESSOR",         NOTIFY_TABLE_STRING,   spoolss_notify_print_processor },
3473 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_PARAMETERS,              "JOB_NOTIFY_PARAMETERS",              NOTIFY_TABLE_STRING,   spoolss_notify_parameters },
3474 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_DRIVER_NAME,             "JOB_NOTIFY_DRIVER_NAME",             NOTIFY_TABLE_STRING,   spoolss_notify_driver_name },
3475 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_DEVMODE,                 "JOB_NOTIFY_DEVMODE",                 NOTIFY_TABLE_DEVMODE,  spoolss_notify_devmode },
3476 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_STATUS,                  "JOB_NOTIFY_STATUS",                  NOTIFY_TABLE_DWORD,    spoolss_notify_job_status },
3477 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_STATUS_STRING,           "JOB_NOTIFY_STATUS_STRING",           NOTIFY_TABLE_STRING,   spoolss_notify_job_status_string },
3478 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_SECURITY_DESCRIPTOR,     "JOB_NOTIFY_SECURITY_DESCRIPTOR",     NOTIFY_TABLE_SECURITYDESCRIPTOR,   NULL },
3479 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_DOCUMENT,                "JOB_NOTIFY_DOCUMENT",                NOTIFY_TABLE_STRING,   spoolss_notify_job_name },
3480 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_PRIORITY,                "JOB_NOTIFY_PRIORITY",                NOTIFY_TABLE_DWORD,    spoolss_notify_priority },
3481 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_POSITION,                "JOB_NOTIFY_POSITION",                NOTIFY_TABLE_DWORD,    spoolss_notify_job_position },
3482 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_SUBMITTED,               "JOB_NOTIFY_SUBMITTED",               NOTIFY_TABLE_TIME,     spoolss_notify_submitted_time },
3483 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_START_TIME,              "JOB_NOTIFY_START_TIME",              NOTIFY_TABLE_DWORD,    spoolss_notify_start_time },
3484 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_UNTIL_TIME,              "JOB_NOTIFY_UNTIL_TIME",              NOTIFY_TABLE_DWORD,    spoolss_notify_until_time },
3485 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_TIME,                    "JOB_NOTIFY_TIME",                    NOTIFY_TABLE_DWORD,    spoolss_notify_job_time },
3486 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_TOTAL_PAGES,             "JOB_NOTIFY_TOTAL_PAGES",             NOTIFY_TABLE_DWORD,    spoolss_notify_total_pages },
3487 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_PAGES_PRINTED,           "JOB_NOTIFY_PAGES_PRINTED",           NOTIFY_TABLE_DWORD,    spoolss_notify_pages_printed },
3488 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_TOTAL_BYTES,             "JOB_NOTIFY_TOTAL_BYTES",             NOTIFY_TABLE_DWORD,    spoolss_notify_job_size },
3489 { PRINT_TABLE_END, 0x0, NULL, 0x0, NULL },
3490 };
3491
3492 /*******************************************************************
3493  Return the variable_type of info_data structure.
3494 ********************************************************************/
3495
3496 static uint32_t variable_type_of_notify_info_data(enum spoolss_NotifyType type,
3497                                                   enum spoolss_Field field)
3498 {
3499         int i=0;
3500
3501         for (i = 0; i < ARRAY_SIZE(notify_info_data_table); i++) {
3502                 if ( (notify_info_data_table[i].type == type) &&
3503                      (notify_info_data_table[i].field == field) ) {
3504                         return notify_info_data_table[i].variable_type;
3505                 }
3506         }
3507
3508         DEBUG(5, ("invalid notify data type %d/%d\n", type, field));
3509
3510         return 0;
3511 }
3512
3513 /****************************************************************************
3514 ****************************************************************************/
3515
3516 static bool search_notify(enum spoolss_NotifyType type,
3517                           enum spoolss_Field field,
3518                           int *value)
3519 {
3520         int i;
3521
3522         for (i = 0; notify_info_data_table[i].type != PRINT_TABLE_END; i++) {
3523                 if (notify_info_data_table[i].type == type &&
3524                     notify_info_data_table[i].field == field &&
3525                     notify_info_data_table[i].fn != NULL) {
3526                         *value = i;
3527                         return True;
3528                 }
3529         }
3530
3531         return False;
3532 }
3533
3534 /****************************************************************************
3535 ****************************************************************************/
3536
3537 void construct_info_data(struct spoolss_Notify *info_data,
3538                          enum spoolss_NotifyType type,
3539                          enum spoolss_Field field,
3540                          int id)
3541 {
3542         info_data->type                 = type;
3543         info_data->field                = field;
3544         info_data->variable_type        = variable_type_of_notify_info_data(type, field);
3545         info_data->job_id               = id;
3546 }
3547
3548 /*******************************************************************
3549  *
3550  * fill a notify_info struct with info asked
3551  *
3552  ********************************************************************/
3553
3554 static bool construct_notify_printer_info(Printer_entry *print_hnd,
3555                                           struct spoolss_NotifyInfo *info,
3556                                           int snum,
3557                                           const struct spoolss_NotifyOptionType *option_type,
3558                                           uint32_t id,
3559                                           TALLOC_CTX *mem_ctx)
3560 {
3561         int field_num,j;
3562         enum spoolss_NotifyType type;
3563         enum spoolss_Field field;
3564
3565         struct spoolss_Notify *current_data;
3566         NT_PRINTER_INFO_LEVEL *printer = NULL;
3567         print_queue_struct *queue=NULL;
3568
3569         type = option_type->type;
3570
3571         DEBUG(4,("construct_notify_printer_info: Notify type: [%s], number of notify info: [%d] on printer: [%s]\n",
3572                 (type == PRINTER_NOTIFY_TYPE ? "PRINTER_NOTIFY_TYPE" : "JOB_NOTIFY_TYPE"),
3573                 option_type->count, lp_servicename(snum)));
3574
3575         if (!W_ERROR_IS_OK(get_a_printer(print_hnd, &printer, 2, lp_const_servicename(snum))))
3576                 return False;
3577
3578         for(field_num=0; field_num < option_type->count; field_num++) {
3579                 field = option_type->fields[field_num];
3580
3581                 DEBUG(4,("construct_notify_printer_info: notify [%d]: type [%x], field [%x]\n", field_num, type, field));
3582
3583                 if (!search_notify(type, field, &j) )
3584                         continue;
3585
3586                 info->notifies = TALLOC_REALLOC_ARRAY(info, info->notifies,
3587                                                       struct spoolss_Notify,
3588                                                       info->count + 1);
3589                 if (info->notifies == NULL) {
3590                         DEBUG(2,("construct_notify_printer_info: failed to enlarge buffer info->data!\n"));
3591                         free_a_printer(&printer, 2);
3592                         return False;
3593                 }
3594
3595                 current_data = &info->notifies[info->count];
3596
3597                 construct_info_data(current_data, type, field, id);
3598
3599                 DEBUG(10,("construct_notify_printer_info: calling [%s]  snum=%d  printername=[%s])\n",
3600                                 notify_info_data_table[j].name, snum, printer->info_2->printername ));
3601
3602                 notify_info_data_table[j].fn(snum, current_data, queue,
3603                                              printer, mem_ctx);
3604
3605                 info->count++;
3606         }
3607
3608         free_a_printer(&printer, 2);
3609         return True;
3610 }
3611
3612 /*******************************************************************
3613  *
3614  * fill a notify_info struct with info asked
3615  *
3616  ********************************************************************/
3617
3618 static bool construct_notify_jobs_info(print_queue_struct *queue,
3619                                        struct spoolss_NotifyInfo *info,
3620                                        NT_PRINTER_INFO_LEVEL *printer,
3621                                        int snum,
3622                                        const struct spoolss_NotifyOptionType *option_type,
3623                                        uint32_t id,
3624                                        TALLOC_CTX *mem_ctx)
3625 {
3626         int field_num,j;
3627         enum spoolss_NotifyType type;
3628         enum spoolss_Field field;
3629         struct spoolss_Notify *current_data;
3630
3631         DEBUG(4,("construct_notify_jobs_info\n"));
3632
3633         type = option_type->type;
3634
3635         DEBUGADD(4,("Notify type: [%s], number of notify info: [%d]\n",
3636                 (type == PRINTER_NOTIFY_TYPE ? "PRINTER_NOTIFY_TYPE" : "JOB_NOTIFY_TYPE"),
3637                 option_type->count));
3638
3639         for(field_num=0; field_num<option_type->count; field_num++) {
3640                 field = option_type->fields[field_num];
3641
3642                 if (!search_notify(type, field, &j) )
3643                         continue;
3644
3645                 info->notifies = TALLOC_REALLOC_ARRAY(info, info->notifies,
3646                                                       struct spoolss_Notify,
3647                                                       info->count + 1);
3648                 if (info->notifies == NULL) {
3649                         DEBUG(2,("construct_notify_jobs_info: failed to enlarg buffer info->data!\n"));
3650                         return False;
3651                 }
3652
3653                 current_data=&(info->notifies[info->count]);
3654
3655                 construct_info_data(current_data, type, field, id);
3656                 notify_info_data_table[j].fn(snum, current_data, queue,
3657                                              printer, mem_ctx);
3658                 info->count++;
3659         }
3660
3661         return True;
3662 }
3663
3664 /*
3665  * JFM: The enumeration is not that simple, it's even non obvious.
3666  *
3667  * let's take an example: I want to monitor the PRINTER SERVER for
3668  * the printer's name and the number of jobs currently queued.
3669  * So in the NOTIFY_OPTION, I have one NOTIFY_OPTION_TYPE structure.
3670  * Its type is PRINTER_NOTIFY_TYPE and it has 2 fields NAME and CJOBS.
3671  *
3672  * I have 3 printers on the back of my server.
3673  *
3674  * Now the response is a NOTIFY_INFO structure, with 6 NOTIFY_INFO_DATA
3675  * structures.
3676  *   Number     Data                    Id
3677  *      1       printer 1 name          1
3678  *      2       printer 1 cjob          1
3679  *      3       printer 2 name          2
3680  *      4       printer 2 cjob          2
3681  *      5       printer 3 name          3
3682  *      6       printer 3 name          3
3683  *
3684  * that's the print server case, the printer case is even worse.
3685  */
3686
3687 /*******************************************************************
3688  *
3689  * enumerate all printers on the printserver
3690  * fill a notify_info struct with info asked
3691  *
3692  ********************************************************************/
3693
3694 static WERROR printserver_notify_info(pipes_struct *p, POLICY_HND *hnd,
3695                                       struct spoolss_NotifyInfo *info,
3696                                       TALLOC_CTX *mem_ctx)
3697 {
3698         int snum;
3699         Printer_entry *Printer=find_printer_index_by_hnd(p, hnd);
3700         int n_services=lp_numservices();
3701         int i;
3702         struct spoolss_NotifyOption *option;
3703         struct spoolss_NotifyOptionType option_type;
3704
3705         DEBUG(4,("printserver_notify_info\n"));
3706
3707         if (!Printer)
3708                 return WERR_BADFID;
3709
3710         option = Printer->notify.option;
3711
3712         info->version   = 2;
3713         info->notifies  = NULL;
3714         info->count     = 0;
3715
3716         /* a bug in xp sp2 rc2 causes it to send a fnpcn request without
3717            sending a ffpcn() request first */
3718
3719         if ( !option )
3720                 return WERR_BADFID;
3721
3722         for (i=0; i<option->count; i++) {
3723                 option_type = option->types[i];
3724
3725                 if (option_type.type != PRINTER_NOTIFY_TYPE)
3726                         continue;
3727
3728                 for (snum=0; snum<n_services; snum++)
3729                 {
3730                         if ( lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum) )
3731                                 construct_notify_printer_info ( Printer, info, snum, &option_type, snum, mem_ctx );
3732                 }
3733         }
3734
3735 #if 0
3736         /*
3737          * Debugging information, don't delete.
3738          */
3739
3740         DEBUG(1,("dumping the NOTIFY_INFO\n"));
3741         DEBUGADD(1,("info->version:[%d], info->flags:[%d], info->count:[%d]\n", info->version, info->flags, info->count));
3742         DEBUGADD(1,("num\ttype\tfield\tres\tid\tsize\tenc_type\n"));
3743
3744         for (i=0; i<info->count; i++) {
3745                 DEBUGADD(1,("[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\n",
3746                 i, info->data[i].type, info->data[i].field, info->data[i].reserved,
3747                 info->data[i].id, info->data[i].size, info->data[i].enc_type));
3748         }
3749 #endif
3750
3751         return WERR_OK;
3752 }
3753
3754 /*******************************************************************
3755  *
3756  * fill a notify_info struct with info asked
3757  *
3758  ********************************************************************/
3759
3760 static WERROR printer_notify_info(pipes_struct *p, POLICY_HND *hnd, struct spoolss_NotifyInfo *info,
3761                                   TALLOC_CTX *mem_ctx)
3762 {
3763         int snum;
3764         Printer_entry *Printer=find_printer_index_by_hnd(p, hnd);
3765         int i;
3766         uint32 id;
3767         struct spoolss_NotifyOption *option;
3768         struct spoolss_NotifyOptionType option_type;
3769         int count,j;
3770         print_queue_struct *queue=NULL;
3771         print_status_struct status;
3772
3773         DEBUG(4,("printer_notify_info\n"));
3774
3775         if (!Printer)
3776                 return WERR_BADFID;
3777
3778         option = Printer->notify.option;
3779         id = 0x0;
3780
3781         info->version   = 2;
3782         info->notifies  = NULL;
3783         info->count     = 0;
3784
3785         /* a bug in xp sp2 rc2 causes it to send a fnpcn request without
3786            sending a ffpcn() request first */
3787
3788         if ( !option )
3789                 return WERR_BADFID;
3790
3791         get_printer_snum(p, hnd, &snum, NULL);
3792
3793         for (i=0; i<option->count; i++) {
3794                 option_type = option->types[i];
3795
3796                 switch (option_type.type) {
3797                 case PRINTER_NOTIFY_TYPE:
3798                         if(construct_notify_printer_info(Printer, info, snum,
3799                                                          &option_type, id,
3800                                                          mem_ctx))
3801                                 id--;
3802                         break;
3803
3804                 case JOB_NOTIFY_TYPE: {
3805                         NT_PRINTER_INFO_LEVEL *printer = NULL;
3806
3807                         count = print_queue_status(snum, &queue, &status);
3808
3809                         if (!W_ERROR_IS_OK(get_a_printer(Printer, &printer, 2, lp_const_servicename(snum))))
3810                                 goto done;
3811
3812                         for (j=0; j<count; j++) {
3813                                 construct_notify_jobs_info(&queue[j], info,
3814                                                            printer, snum,
3815                                                            &option_type,
3816                                                            queue[j].job,
3817                                                            mem_ctx);
3818                         }
3819
3820                         free_a_printer(&printer, 2);
3821
3822                 done:
3823                         SAFE_FREE(queue);
3824                         break;
3825                 }
3826                 }
3827         }
3828
3829         /*
3830          * Debugging information, don't delete.
3831          */
3832         /*
3833         DEBUG(1,("dumping the NOTIFY_INFO\n"));
3834         DEBUGADD(1,("info->version:[%d], info->flags:[%d], info->count:[%d]\n", info->version, info->flags, info->count));
3835         DEBUGADD(1,("num\ttype\tfield\tres\tid\tsize\tenc_type\n"));
3836
3837         for (i=0; i<info->count; i++) {
3838                 DEBUGADD(1,("[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\n",
3839                 i, info->data[i].type, info->data[i].field, info->data[i].reserved,
3840                 info->data[i].id, info->data[i].size, info->data[i].enc_type));
3841         }
3842         */
3843         return WERR_OK;
3844 }
3845
3846 /****************************************************************
3847  _spoolss_RouterRefreshPrinterChangeNotify
3848 ****************************************************************/
3849
3850 WERROR _spoolss_RouterRefreshPrinterChangeNotify(pipes_struct *p,
3851                                                  struct spoolss_RouterRefreshPrinterChangeNotify *r)
3852 {
3853         POLICY_HND *handle = r->in.handle;
3854         struct spoolss_NotifyInfo *info;
3855
3856         Printer_entry *Printer=find_printer_index_by_hnd(p, handle);
3857         WERROR result = WERR_BADFID;
3858
3859         /* we always have a spoolss_NotifyInfo struct */
3860         info = talloc_zero(p->mem_ctx, struct spoolss_NotifyInfo);
3861         if (!info) {
3862                 result = WERR_NOMEM;
3863                 goto done;
3864         }
3865
3866         *r->out.info = info;
3867
3868         if (!Printer) {
3869                 DEBUG(2,("_spoolss_RouterRefreshPrinterChangeNotify: "
3870                         "Invalid handle (%s:%u:%u).\n", OUR_HANDLE(handle)));
3871                 goto done;
3872         }
3873
3874         DEBUG(4,("Printer type %x\n",Printer->printer_type));
3875
3876         /*
3877          *      We are now using the change value, and
3878          *      I should check for PRINTER_NOTIFY_OPTIONS_REFRESH but as
3879          *      I don't have a global notification system, I'm sending back all the
3880          *      informations even when _NOTHING_ has changed.
3881          */
3882
3883         /* We need to keep track of the change value to send back in
3884            RRPCN replies otherwise our updates are ignored. */
3885
3886         Printer->notify.fnpcn = True;
3887
3888         if (Printer->notify.client_connected) {
3889                 DEBUG(10,("_spoolss_RouterRefreshPrinterChangeNotify: "
3890                         "Saving change value in request [%x]\n",
3891                         r->in.change_low));
3892                 Printer->notify.change = r->in.change_low;
3893         }
3894
3895         /* just ignore the spoolss_NotifyOption */
3896
3897         switch (Printer->printer_type) {
3898                 case SPLHND_SERVER:
3899                         result = printserver_notify_info(p, handle, info, p->mem_ctx);
3900                         break;
3901
3902                 case SPLHND_PRINTER:
3903                         result = printer_notify_info(p, handle, info, p->mem_ctx);
3904                         break;
3905         }
3906
3907         Printer->notify.fnpcn = False;
3908
3909 done:
3910         return result;
3911 }
3912
3913 /********************************************************************
3914  * construct_printer_info_0
3915  * fill a printer_info_0 struct
3916  ********************************************************************/
3917
3918 static bool construct_printer_info_0(Printer_entry *print_hnd, PRINTER_INFO_0 *printer, int snum)
3919 {
3920         char *chaine = NULL;
3921         int count;
3922         NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
3923         counter_printer_0 *session_counter;
3924         uint32 global_counter;
3925         struct tm *t;
3926         time_t setuptime;
3927         print_status_struct status;
3928         TALLOC_CTX *ctx = talloc_tos();
3929
3930         if (!W_ERROR_IS_OK(get_a_printer(print_hnd, &ntprinter, 2, lp_const_servicename(snum))))
3931                 return False;
3932
3933         init_unistr(&printer->printername, ntprinter->info_2->printername);
3934
3935         chaine = talloc_asprintf(ctx, "\\\\%s", get_server_name(print_hnd));
3936         if (!chaine) {
3937                 free_a_printer(&ntprinter,2);
3938                 return false;
3939         }
3940
3941         count = print_queue_length(snum, &status);
3942
3943         /* check if we already have a counter for this printer */
3944         for(session_counter = counter_list; session_counter; session_counter = session_counter->next) {
3945                 if (session_counter->snum == snum)
3946                         break;
3947         }
3948
3949         init_unistr(&printer->servername, chaine);
3950
3951         /* it's the first time, add it to the list */
3952         if (session_counter==NULL) {
3953                 if((session_counter=SMB_MALLOC_P(counter_printer_0)) == NULL) {
3954                         free_a_printer(&ntprinter, 2);
3955                         return False;
3956                 }
3957                 ZERO_STRUCTP(session_counter);
3958                 session_counter->snum=snum;
3959                 session_counter->counter=0;
3960                 DLIST_ADD(counter_list, session_counter);
3961         }
3962
3963         /* increment it */
3964         session_counter->counter++;
3965
3966         /* JFM:
3967          * the global_counter should be stored in a TDB as it's common to all the clients
3968          * and should be zeroed on samba startup
3969          */
3970         global_counter=session_counter->counter;
3971         printer->cjobs = count;
3972         printer->total_jobs = 0;
3973         printer->total_bytes = 0;
3974
3975         setuptime = (time_t)ntprinter->info_2->setuptime;
3976         t=gmtime(&setuptime);
3977
3978         printer->year = t->tm_year+1900;
3979         printer->month = t->tm_mon+1;
3980         printer->dayofweek = t->tm_wday;
3981         printer->day = t->tm_mday;
3982         printer->hour = t->tm_hour;
3983         printer->minute = t->tm_min;
3984         printer->second = t->tm_sec;
3985         printer->milliseconds = 0;
3986
3987         printer->global_counter = global_counter;
3988         printer->total_pages = 0;
3989
3990         /* in 2.2 we reported ourselves as 0x0004 and 0x0565 */
3991         printer->major_version = 0x0005;        /* NT 5 */
3992         printer->build_version = 0x0893;        /* build 2195 */
3993
3994         printer->unknown7 = 0x1;
3995         printer->unknown8 = 0x0;
3996         printer->unknown9 = 0x0;
3997         printer->session_counter = session_counter->counter;
3998         printer->unknown11 = 0x0;
3999         printer->printer_errors = 0x0;          /* number of print failure */
4000         printer->unknown13 = 0x0;
4001         printer->unknown14 = 0x1;
4002         printer->unknown15 = 0x024a;            /* 586 Pentium ? */
4003         printer->unknown16 =  0x0;
4004         printer->change_id = ntprinter->info_2->changeid; /* ChangeID in milliseconds*/
4005         printer->unknown18 =  0x0;
4006         printer->status = nt_printq_status(status.status);
4007         printer->unknown20 =  0x0;
4008         printer->c_setprinter = get_c_setprinter(); /* monotonically increasing sum of delta printer counts */
4009         printer->unknown22 = 0x0;
4010         printer->unknown23 = 0x6;               /* 6  ???*/
4011         printer->unknown24 = 0;                 /* unknown 24 to 26 are always 0 */
4012         printer->unknown25 = 0;
4013         printer->unknown26 = 0;
4014         printer->unknown27 = 0;
4015         printer->unknown28 = 0;
4016         printer->unknown29 = 0;
4017
4018         free_a_printer(&ntprinter,2);
4019         return (True);
4020 }
4021
4022 /********************************************************************
4023  * construct_printer_info_1
4024  * fill a printer_info_1 struct
4025  ********************************************************************/
4026 static bool construct_printer_info_1(Printer_entry *print_hnd, uint32 flags, PRINTER_INFO_1 *printer, int snum)
4027 {
4028         char *chaine = NULL;
4029         NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
4030         TALLOC_CTX *ctx = talloc_tos();
4031
4032         if (!W_ERROR_IS_OK(get_a_printer(print_hnd, &ntprinter, 2, lp_const_servicename(snum))))
4033                 return false;
4034
4035         printer->flags=flags;
4036
4037         if (*ntprinter->info_2->comment == '\0') {
4038                 init_unistr(&printer->comment, lp_comment(snum));
4039                 chaine = talloc_asprintf(ctx,
4040                                 "%s,%s,%s", ntprinter->info_2->printername,
4041                                 ntprinter->info_2->drivername, lp_comment(snum));
4042         }
4043         else {
4044                 init_unistr(&printer->comment, ntprinter->info_2->comment); /* saved comment. */
4045                 chaine = talloc_asprintf(ctx,
4046                                 "%s,%s,%s", ntprinter->info_2->printername,
4047                                 ntprinter->info_2->drivername, ntprinter->info_2->comment);
4048         }
4049
4050         if (!chaine) {
4051                 free_a_printer(&ntprinter,2);
4052                 return false;
4053         }
4054
4055         init_unistr(&printer->description, chaine);
4056         init_unistr(&printer->name, ntprinter->info_2->printername);
4057
4058         free_a_printer(&ntprinter,2);
4059
4060         return True;
4061 }
4062
4063 /****************************************************************************
4064  Free a DEVMODE struct.
4065 ****************************************************************************/
4066
4067 static void free_dev_mode(DEVICEMODE *dev)
4068 {
4069         if (dev == NULL)
4070                 return;
4071
4072         SAFE_FREE(dev->dev_private);
4073         SAFE_FREE(dev);
4074 }
4075
4076
4077 /****************************************************************************
4078  Convert an NT_DEVICEMODE to a DEVICEMODE structure.  Both pointers
4079  should be valid upon entry
4080 ****************************************************************************/
4081
4082 static bool convert_nt_devicemode( DEVICEMODE *devmode, NT_DEVICEMODE *ntdevmode )
4083 {
4084         if ( !devmode || !ntdevmode )
4085                 return False;
4086
4087         init_unistr(&devmode->devicename, ntdevmode->devicename);
4088
4089         init_unistr(&devmode->formname, ntdevmode->formname);
4090
4091         devmode->specversion      = ntdevmode->specversion;
4092         devmode->driverversion    = ntdevmode->driverversion;
4093         devmode->size             = ntdevmode->size;
4094         devmode->driverextra      = ntdevmode->driverextra;
4095         devmode->fields           = ntdevmode->fields;
4096
4097         devmode->orientation      = ntdevmode->orientation;
4098         devmode->papersize        = ntdevmode->papersize;
4099         devmode->paperlength      = ntdevmode->paperlength;
4100         devmode->paperwidth       = ntdevmode->paperwidth;
4101         devmode->scale            = ntdevmode->scale;
4102         devmode->copies           = ntdevmode->copies;
4103         devmode->defaultsource    = ntdevmode->defaultsource;
4104         devmode->printquality     = ntdevmode->printquality;
4105         devmode->color            = ntdevmode->color;
4106         devmode->duplex           = ntdevmode->duplex;
4107         devmode->yresolution      = ntdevmode->yresolution;
4108         devmode->ttoption         = ntdevmode->ttoption;
4109         devmode->collate          = ntdevmode->collate;
4110         devmode->icmmethod        = ntdevmode->icmmethod;
4111         devmode->icmintent        = ntdevmode->icmintent;
4112         devmode->mediatype        = ntdevmode->mediatype;
4113         devmode->dithertype       = ntdevmode->dithertype;
4114
4115         if (ntdevmode->nt_dev_private != NULL) {
4116                 if ((devmode->dev_private=(uint8 *)memdup(ntdevmode->nt_dev_private, ntdevmode->driverextra)) == NULL)
4117                         return False;
4118         }
4119
4120         return True;
4121 }
4122
4123 /****************************************************************************
4124  Create a DEVMODE struct. Returns malloced memory.
4125 ****************************************************************************/
4126
4127 DEVICEMODE *construct_dev_mode(const char *servicename)
4128 {
4129         NT_PRINTER_INFO_LEVEL   *printer = NULL;
4130         DEVICEMODE              *devmode = NULL;
4131
4132         DEBUG(7,("construct_dev_mode\n"));
4133
4134         DEBUGADD(8,("getting printer characteristics\n"));
4135
4136         if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, servicename)))
4137                 return NULL;
4138
4139         if ( !printer->info_2->devmode ) {
4140                 DEBUG(5, ("BONG! There was no device mode!\n"));
4141                 goto done;
4142         }
4143
4144         if ((devmode = SMB_MALLOC_P(DEVICEMODE)) == NULL) {
4145                 DEBUG(2,("construct_dev_mode: malloc fail.\n"));
4146                 goto done;
4147         }
4148
4149         ZERO_STRUCTP(devmode);
4150
4151         DEBUGADD(8,("loading DEVICEMODE\n"));
4152
4153         if ( !convert_nt_devicemode( devmode, printer->info_2->devmode ) ) {
4154                 free_dev_mode( devmode );
4155                 devmode = NULL;
4156         }
4157
4158 done:
4159         free_a_printer(&printer,2);
4160
4161         return devmode;
4162 }
4163
4164 /********************************************************************
4165  * construct_printer_info_2
4166  * fill a printer_info_2 struct
4167  ********************************************************************/
4168
4169 static bool construct_printer_info_2(Printer_entry *print_hnd, PRINTER_INFO_2 *printer, int snum)
4170 {
4171         int count;
4172         NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
4173
4174         print_status_struct status;
4175
4176         if (!W_ERROR_IS_OK(get_a_printer(print_hnd, &ntprinter, 2, lp_const_servicename(snum))))
4177                 return False;
4178
4179         count = print_queue_length(snum, &status);
4180
4181         init_unistr(&printer->servername, ntprinter->info_2->servername); /* servername*/
4182         init_unistr(&printer->printername, ntprinter->info_2->printername);                             /* printername*/
4183         init_unistr(&printer->sharename, lp_servicename(snum));                 /* sharename */
4184         init_unistr(&printer->portname, ntprinter->info_2->portname);                   /* port */
4185         init_unistr(&printer->drivername, ntprinter->info_2->drivername);       /* drivername */
4186
4187         if (*ntprinter->info_2->comment == '\0')
4188                 init_unistr(&printer->comment, lp_comment(snum));                       /* comment */
4189         else
4190                 init_unistr(&printer->comment, ntprinter->info_2->comment); /* saved comment. */
4191
4192         init_unistr(&printer->location, ntprinter->info_2->location);           /* location */
4193         init_unistr(&printer->sepfile, ntprinter->info_2->sepfile);             /* separator file */
4194         init_unistr(&printer->printprocessor, ntprinter->info_2->printprocessor);/* print processor */
4195         init_unistr(&printer->datatype, ntprinter->info_2->datatype);           /* datatype */
4196         init_unistr(&printer->parameters, ntprinter->info_2->parameters);       /* parameters (of print processor) */
4197
4198         printer->attributes = ntprinter->info_2->attributes;
4199
4200         printer->priority = ntprinter->info_2->priority;                                /* priority */
4201         printer->defaultpriority = ntprinter->info_2->default_priority;         /* default priority */
4202         printer->starttime = ntprinter->info_2->starttime;                      /* starttime */
4203         printer->untiltime = ntprinter->info_2->untiltime;                      /* untiltime */
4204         printer->status = nt_printq_status(status.status);                      /* status */
4205         printer->cjobs = count;                                                 /* jobs */
4206         printer->averageppm = ntprinter->info_2->averageppm;                    /* average pages per minute */
4207
4208         if ( !(printer->devmode = construct_dev_mode(
4209                        lp_const_servicename(snum))) )
4210                 DEBUG(8, ("Returning NULL Devicemode!\n"));
4211
4212         printer->secdesc = NULL;
4213
4214         if ( ntprinter->info_2->secdesc_buf
4215                 && ntprinter->info_2->secdesc_buf->sd_size != 0 )
4216         {
4217                 /* don't use talloc_steal() here unless you do a deep steal of all
4218                    the SEC_DESC members */
4219
4220                 printer->secdesc = dup_sec_desc( talloc_tos(),
4221                         ntprinter->info_2->secdesc_buf->sd );
4222         }
4223
4224         free_a_printer(&ntprinter, 2);
4225
4226         return True;
4227 }
4228
4229 /********************************************************************
4230  * construct_printer_info_3
4231  * fill a printer_info_3 struct
4232  ********************************************************************/
4233
4234 static bool construct_printer_info_3(Printer_entry *print_hnd, PRINTER_INFO_3 **pp_printer, int snum)
4235 {
4236         NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
4237         PRINTER_INFO_3 *printer = NULL;
4238
4239         if (!W_ERROR_IS_OK(get_a_printer(print_hnd, &ntprinter, 2, lp_const_servicename(snum))))
4240                 return False;
4241
4242         *pp_printer = NULL;
4243         if ((printer = SMB_MALLOC_P(PRINTER_INFO_3)) == NULL) {
4244                 DEBUG(2,("construct_printer_info_3: malloc fail.\n"));
4245                 free_a_printer(&ntprinter, 2);
4246                 return False;
4247         }
4248
4249         ZERO_STRUCTP(printer);
4250
4251         /* These are the components of the SD we are returning. */
4252
4253         if (ntprinter->info_2->secdesc_buf && ntprinter->info_2->secdesc_buf->sd_size != 0) {
4254                 /* don't use talloc_steal() here unless you do a deep steal of all
4255                    the SEC_DESC members */
4256
4257                 printer->secdesc = dup_sec_desc( talloc_tos(),
4258                         ntprinter->info_2->secdesc_buf->sd );
4259         }
4260
4261         free_a_printer(&ntprinter, 2);
4262
4263         *pp_printer = printer;
4264         return True;
4265 }
4266
4267 /********************************************************************
4268  * construct_printer_info_4
4269  * fill a printer_info_4 struct
4270  ********************************************************************/
4271
4272 static bool construct_printer_info_4(Printer_entry *print_hnd, PRINTER_INFO_4 *printer, int snum)
4273 {
4274         NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
4275
4276         if (!W_ERROR_IS_OK(get_a_printer(print_hnd, &ntprinter, 2, lp_const_servicename(snum))))
4277                 return False;
4278
4279         init_unistr(&printer->printername, ntprinter->info_2->printername);                             /* printername*/
4280         init_unistr(&printer->servername, ntprinter->info_2->servername); /* servername*/
4281         printer->attributes = ntprinter->info_2->attributes;
4282
4283         free_a_printer(&ntprinter, 2);
4284         return True;
4285 }
4286
4287 /********************************************************************
4288  * construct_printer_info_5
4289  * fill a printer_info_5 struct
4290  ********************************************************************/
4291
4292 static bool construct_printer_info_5(Printer_entry *print_hnd, PRINTER_INFO_5 *printer, int snum)
4293 {
4294         NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
4295
4296         if (!W_ERROR_IS_OK(get_a_printer(print_hnd, &ntprinter, 2, lp_const_servicename(snum))))
4297                 return False;
4298
4299         init_unistr(&printer->printername, ntprinter->info_2->printername);
4300         init_unistr(&printer->portname, ntprinter->info_2->portname);
4301         printer->attributes = ntprinter->info_2->attributes;
4302
4303         /* these two are not used by NT+ according to MSDN */
4304
4305         printer->device_not_selected_timeout = 0x0;  /* have seen 0x3a98 */
4306         printer->transmission_retry_timeout  = 0x0;  /* have seen 0xafc8 */
4307
4308         free_a_printer(&ntprinter, 2);
4309
4310         return True;
4311 }
4312
4313 /********************************************************************
4314  * construct_printer_info_6
4315  * fill a printer_info_6 struct
4316  ********************************************************************/
4317
4318 static bool construct_printer_info_6(Printer_entry *print_hnd,
4319                                      PRINTER_INFO_6 *printer,
4320                                      int snum)
4321 {
4322         NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
4323         int count;
4324         print_status_struct status;
4325
4326         if (!W_ERROR_IS_OK(get_a_printer(print_hnd, &ntprinter, 2,
4327                                          lp_const_servicename(snum))))
4328                 return False;
4329
4330         count = print_queue_length(snum, &status);
4331
4332         printer->status = nt_printq_status(status.status);
4333
4334         free_a_printer(&ntprinter, 2);
4335
4336         return True;
4337 }
4338
4339 /********************************************************************
4340  * construct_printer_info_7
4341  * fill a printer_info_7 struct
4342  ********************************************************************/
4343
4344 static bool construct_printer_info_7(Printer_entry *print_hnd, PRINTER_INFO_7 *printer, int snum)
4345 {
4346         char *guid_str = NULL;
4347         struct GUID guid;
4348
4349         if (is_printer_published(print_hnd, snum, &guid)) {
4350                 if (asprintf(&guid_str, "{%s}",
4351                              GUID_string(talloc_tos(), &guid)) == -1) {
4352                         return false;
4353                 }
4354                 strupper_m(guid_str);
4355                 init_unistr(&printer->guid, guid_str);
4356                 SAFE_FREE(guid_str);
4357                 printer->action = SPOOL_DS_PUBLISH;
4358         } else {
4359                 init_unistr(&printer->guid, "");
4360                 printer->action = SPOOL_DS_UNPUBLISH;
4361         }
4362
4363         return True;
4364 }
4365
4366 /********************************************************************
4367  Spoolss_enumprinters.
4368 ********************************************************************/
4369
4370 static WERROR enum_all_printers_info_1(uint32 flags, RPC_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
4371 {
4372         int snum;
4373         int i;
4374         int n_services=lp_numservices();
4375         PRINTER_INFO_1 *printers=NULL;
4376         PRINTER_INFO_1 current_prt;
4377         WERROR result = WERR_OK;
4378
4379         DEBUG(4,("enum_all_printers_info_1\n"));
4380
4381         for (snum=0; snum<n_services; snum++) {
4382                 if (lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum) ) {
4383                         DEBUG(4,("Found a printer in smb.conf: %s[%x]\n", lp_servicename(snum), snum));
4384
4385                         if (construct_printer_info_1(NULL, flags, &current_prt, snum)) {
4386                                 if((printers=SMB_REALLOC_ARRAY(printers, PRINTER_INFO_1, *returned +1)) == NULL) {
4387                                         DEBUG(2,("enum_all_printers_info_1: failed to enlarge printers buffer!\n"));
4388                                         *returned=0;
4389                                         return WERR_NOMEM;
4390                                 }
4391                                 DEBUG(4,("ReAlloced memory for [%d] PRINTER_INFO_1\n", *returned));
4392
4393                                 memcpy(&printers[*returned], &current_prt, sizeof(PRINTER_INFO_1));
4394                                 (*returned)++;
4395                         }
4396                 }
4397         }
4398
4399         /* check the required size. */
4400         for (i=0; i<*returned; i++)
4401                 (*needed) += spoolss_size_printer_info_1(&printers[i]);
4402
4403         if (*needed > offered) {
4404                 result = WERR_INSUFFICIENT_BUFFER;
4405                 goto out;
4406         }
4407
4408         if (!rpcbuf_alloc_size(buffer, *needed)) {
4409                 result = WERR_NOMEM;
4410                 goto out;
4411         }
4412
4413         /* fill the buffer with the structures */
4414         for (i=0; i<*returned; i++)
4415                 smb_io_printer_info_1("", buffer, &printers[i], 0);
4416
4417 out:
4418         /* clear memory */
4419
4420         SAFE_FREE(printers);
4421
4422         if ( !W_ERROR_IS_OK(result) )
4423                 *returned = 0;
4424
4425         return result;
4426 }
4427
4428 /********************************************************************
4429  enum_all_printers_info_1_local.
4430 *********************************************************************/
4431
4432 static WERROR enum_all_printers_info_1_local(RPC_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
4433 {
4434         DEBUG(4,("enum_all_printers_info_1_local\n"));
4435
4436         return enum_all_printers_info_1(PRINTER_ENUM_ICON8, buffer, offered, needed, returned);
4437 }
4438
4439 /********************************************************************
4440  enum_all_printers_info_1_name.
4441 *********************************************************************/
4442
4443 static WERROR enum_all_printers_info_1_name(fstring name, RPC_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
4444 {
4445         char *s = name;
4446
4447         DEBUG(4,("enum_all_printers_info_1_name\n"));
4448
4449         if ((name[0] == '\\') && (name[1] == '\\'))
4450                 s = name + 2;
4451
4452         if (is_myname_or_ipaddr(s)) {
4453                 return enum_all_printers_info_1(PRINTER_ENUM_ICON8, buffer, offered, needed, returned);
4454         }
4455         else
4456                 return WERR_INVALID_NAME;
4457 }
4458
4459 #if 0   /* JERRY -- disabled for now.  Don't think this is used, tested, or correct */
4460 /********************************************************************
4461  enum_all_printers_info_1_remote.
4462 *********************************************************************/
4463
4464 static WERROR enum_all_printers_info_1_remote(fstring name, RPC_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
4465 {
4466         PRINTER_INFO_1 *printer;
4467         fstring printername;
4468         fstring desc;
4469         fstring comment;
4470         DEBUG(4,("enum_all_printers_info_1_remote\n"));
4471         WERROR result = WERR_OK;
4472
4473         /* JFM: currently it's more a place holder than anything else.
4474          * In the spooler world there is a notion of server registration.
4475          * the print servers are registered on the PDC (in the same domain)
4476          *
4477          * We should have a TDB here. The registration is done thru an
4478          * undocumented RPC call.
4479          */
4480
4481         if((printer=SMB_MALLOC_P(PRINTER_INFO_1)) == NULL)
4482                 return WERR_NOMEM;
4483
4484         *returned=1;
4485
4486         slprintf(printername, sizeof(printername)-1,"Windows NT Remote Printers!!\\\\%s", name);
4487         slprintf(desc, sizeof(desc)-1,"%s", name);
4488         slprintf(comment, sizeof(comment)-1, "Logged on Domain");
4489
4490         init_unistr(&printer->description, desc);
4491         init_unistr(&printer->name, printername);
4492         init_unistr(&printer->comment, comment);
4493         printer->flags=PRINTER_ENUM_ICON3|PRINTER_ENUM_CONTAINER;
4494
4495         /* check the required size. */
4496         *needed += spoolss_size_printer_info_1(printer);
4497
4498         if (*needed > offered) {
4499                 result = WERR_INSUFFICIENT_BUFFER;
4500                 goto out;
4501         }
4502
4503         if (!rpcbuf_alloc_size(buffer, *needed)) {
4504                 result = WERR_NOMEM;
4505                 goto out;
4506         }
4507
4508         /* fill the buffer with the structures */
4509         smb_io_printer_info_1("", buffer, printer, 0);
4510
4511 out:
4512         /* clear memory */
4513         SAFE_FREE(printer);
4514
4515         if ( !W_ERROR_IS_OK(result) )
4516                 *returned = 0;
4517
4518         return result;
4519 }
4520
4521 #endif
4522
4523 /********************************************************************
4524  enum_all_printers_info_1_network.
4525 *********************************************************************/
4526
4527 static WERROR enum_all_printers_info_1_network(fstring name, RPC_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
4528 {
4529         char *s = name;
4530
4531         DEBUG(4,("enum_all_printers_info_1_network\n"));
4532
4533         /* If we respond to a enum_printers level 1 on our name with flags
4534            set to PRINTER_ENUM_REMOTE with a list of printers then these
4535            printers incorrectly appear in the APW browse list.
4536            Specifically the printers for the server appear at the workgroup
4537            level where all the other servers in the domain are
4538            listed. Windows responds to this call with a
4539            WERR_CAN_NOT_COMPLETE so we should do the same. */
4540
4541         if (name[0] == '\\' && name[1] == '\\')
4542                  s = name + 2;
4543
4544         if (is_myname_or_ipaddr(s))
4545                  return WERR_CAN_NOT_COMPLETE;
4546
4547         return enum_all_printers_info_1(PRINTER_ENUM_NAME, buffer, offered, needed, returned);
4548 }
4549
4550 /********************************************************************
4551  * api_spoolss_enumprinters
4552  *
4553  * called from api_spoolss_enumprinters (see this to understand)
4554  ********************************************************************/
4555
4556 static WERROR enum_all_printers_info_2(RPC_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
4557 {
4558         int snum;
4559         int i;
4560         int n_services=lp_numservices();
4561         PRINTER_INFO_2 *printers=NULL;
4562         PRINTER_INFO_2 current_prt;
4563         WERROR result = WERR_OK;
4564
4565         *returned = 0;
4566
4567         for (snum=0; snum<n_services; snum++) {
4568                 if (lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum) ) {
4569                         DEBUG(4,("Found a printer in smb.conf: %s[%x]\n", lp_servicename(snum), snum));
4570
4571                         if (construct_printer_info_2(NULL, &current_prt, snum)) {
4572                                 if ( !(printers=SMB_REALLOC_ARRAY(printers, PRINTER_INFO_2, *returned +1)) ) {
4573                                         DEBUG(2,("enum_all_printers_info_2: failed to enlarge printers buffer!\n"));
4574                                         *returned = 0;
4575                                         return WERR_NOMEM;
4576                                 }
4577
4578                                 DEBUG(4,("ReAlloced memory for [%d] PRINTER_INFO_2\n", *returned + 1));
4579
4580                                 memcpy(&printers[*returned], &current_prt, sizeof(PRINTER_INFO_2));
4581
4582                                 (*returned)++;
4583                         }
4584                 }
4585         }
4586
4587         /* check the required size. */
4588         for (i=0; i<*returned; i++)
4589                 (*needed) += spoolss_size_printer_info_2(&printers[i]);
4590
4591         if (*needed > offered) {
4592                 result = WERR_INSUFFICIENT_BUFFER;
4593                 goto out;
4594         }
4595
4596         if (!rpcbuf_alloc_size(buffer, *needed)) {
4597                 result = WERR_NOMEM;
4598                 goto out;
4599         }
4600
4601         /* fill the buffer with the structures */
4602         for (i=0; i<*returned; i++)
4603                 smb_io_printer_info_2("", buffer, &(printers[i]), 0);
4604
4605 out:
4606         /* clear memory */
4607
4608         for (i=0; i<*returned; i++)
4609                 free_devmode(printers[i].devmode);
4610
4611         SAFE_FREE(printers);
4612
4613         if ( !W_ERROR_IS_OK(result) )
4614                 *returned = 0;
4615
4616         return result;
4617 }
4618
4619 /********************************************************************
4620  * handle enumeration of printers at level 1
4621  ********************************************************************/
4622
4623 static WERROR enumprinters_level1( uint32 flags, fstring name,
4624                                  RPC_BUFFER *buffer, uint32 offered,
4625                                  uint32 *needed, uint32 *returned)
4626 {
4627         /* Not all the flags are equals */
4628
4629         if (flags & PRINTER_ENUM_LOCAL)
4630                 return enum_all_printers_info_1_local(buffer, offered, needed, returned);
4631
4632         if (flags & PRINTER_ENUM_NAME)
4633                 return enum_all_printers_info_1_name(name, buffer, offered, needed, returned);
4634
4635 #if 0   /* JERRY - disabled for now */
4636         if (flags & PRINTER_ENUM_REMOTE)
4637                 return enum_all_printers_info_1_remote(name, buffer, offered, needed, returned);
4638 #endif
4639
4640         if (flags & PRINTER_ENUM_NETWORK)
4641                 return enum_all_printers_info_1_network(name, buffer, offered, needed, returned);
4642
4643         return WERR_OK; /* NT4sp5 does that */
4644 }
4645
4646 /********************************************************************
4647  * handle enumeration of printers at level 2
4648  ********************************************************************/
4649
4650 static WERROR enumprinters_level2( uint32 flags, const char *servername,
4651                                  RPC_BUFFER *buffer, uint32 offered,
4652                                  uint32 *needed, uint32 *returned)
4653 {
4654         if (flags & PRINTER_ENUM_LOCAL) {
4655                         return enum_all_printers_info_2(buffer, offered, needed, returned);
4656         }
4657
4658         if (flags & PRINTER_ENUM_NAME) {
4659                 if (is_myname_or_ipaddr(canon_servername(servername)))
4660                         return enum_all_printers_info_2(buffer, offered, needed, returned);
4661                 else
4662                         return WERR_INVALID_NAME;
4663         }
4664
4665         if (flags & PRINTER_ENUM_REMOTE)
4666                 return WERR_UNKNOWN_LEVEL;
4667
4668         return WERR_OK;
4669 }
4670
4671 /********************************************************************
4672  * handle enumeration of printers at level 5
4673  ********************************************************************/
4674
4675 static WERROR enumprinters_level5( uint32 flags, const char *servername,
4676                                  RPC_BUFFER *buffer, uint32 offered,
4677                                  uint32 *needed, uint32 *returned)
4678 {
4679 /*      return enum_all_printers_info_5(buffer, offered, needed, returned);*/
4680         return WERR_OK;
4681 }
4682
4683 /********************************************************************
4684  * api_spoolss_enumprinters
4685  *
4686  * called from api_spoolss_enumprinters (see this to understand)
4687  ********************************************************************/
4688
4689 WERROR _spoolss_enumprinters( pipes_struct *p, SPOOL_Q_ENUMPRINTERS *q_u, SPOOL_R_ENUMPRINTERS *r_u)
4690 {
4691         uint32 flags = q_u->flags;
4692         UNISTR2 *servername = &q_u->servername;
4693         uint32 level = q_u->level;
4694         RPC_BUFFER *buffer = NULL;
4695         uint32 offered = q_u->offered;
4696         uint32 *needed = &r_u->needed;
4697         uint32 *returned = &r_u->returned;
4698
4699         fstring name;
4700
4701         /* that's an [in out] buffer */
4702
4703         if (!q_u->buffer && (offered!=0)) {
4704                 return WERR_INVALID_PARAM;
4705         }
4706
4707         if (offered > MAX_RPC_DATA_SIZE) {
4708                 return WERR_INVALID_PARAM;
4709         }
4710
4711         rpcbuf_move(q_u->buffer, &r_u->buffer);
4712         buffer = r_u->buffer;
4713
4714         DEBUG(4,("_spoolss_enumprinters\n"));
4715
4716         *needed=0;
4717         *returned=0;
4718
4719         /*
4720          * Level 1:
4721          *          flags==PRINTER_ENUM_NAME
4722          *           if name=="" then enumerates all printers
4723          *           if name!="" then enumerate the printer
4724          *          flags==PRINTER_ENUM_REMOTE
4725          *          name is NULL, enumerate printers
4726          * Level 2: name!="" enumerates printers, name can't be NULL
4727          * Level 3: doesn't exist
4728          * Level 4: does a local registry lookup
4729          * Level 5: same as Level 2
4730          */
4731
4732         unistr2_to_ascii(name, servername, sizeof(name));
4733         strupper_m(name);
4734
4735         switch (level) {
4736         case 1:
4737                 return enumprinters_level1(flags, name, buffer, offered, needed, returned);
4738         case 2:
4739                 return enumprinters_level2(flags, name, buffer, offered, needed, returned);
4740         case 5:
4741                 return enumprinters_level5(flags, name, buffer, offered, needed, returned);
4742         case 3:
4743         case 4:
4744                 break;
4745         }
4746         return WERR_UNKNOWN_LEVEL;
4747 }
4748
4749 /****************************************************************************
4750 ****************************************************************************/
4751
4752 static WERROR getprinter_level_0(Printer_entry *print_hnd, int snum, RPC_BUFFER *buffer, uint32 offered, uint32 *needed)
4753 {
4754         PRINTER_INFO_0 *printer=NULL;
4755         WERROR result = WERR_OK;
4756
4757         if((printer=SMB_MALLOC_P(PRINTER_INFO_0)) == NULL)
4758                 return WERR_NOMEM;
4759
4760         construct_printer_info_0(print_hnd, printer, snum);
4761
4762         /* check the required size. */
4763         *needed += spoolss_size_printer_info_0(printer);
4764
4765         if (*needed > offered) {
4766                 result = WERR_INSUFFICIENT_BUFFER;
4767                 goto out;
4768         }
4769
4770         if (!rpcbuf_alloc_size(buffer, *needed)) {
4771                 result = WERR_NOMEM;
4772                 goto out;
4773         }
4774
4775         /* fill the buffer with the structures */
4776         smb_io_printer_info_0("", buffer, printer, 0);
4777
4778 out:
4779         /* clear memory */
4780
4781         SAFE_FREE(printer);
4782
4783         return result;
4784 }
4785
4786 /****************************************************************************
4787 ****************************************************************************/
4788
4789 static WERROR getprinter_level_1(Printer_entry *print_hnd, int snum, RPC_BUFFER *buffer, uint32 offered, uint32 *needed)
4790 {
4791         PRINTER_INFO_1 *printer=NULL;
4792         WERROR result = WERR_OK;
4793
4794         if((printer=SMB_MALLOC_P(PRINTER_INFO_1)) == NULL)
4795                 return WERR_NOMEM;
4796
4797         construct_printer_info_1(print_hnd, PRINTER_ENUM_ICON8, printer, snum);
4798
4799         /* check the required size. */
4800         *needed += spoolss_size_printer_info_1(printer);
4801
4802         if (*needed > offered) {
4803                 result = WERR_INSUFFICIENT_BUFFER;
4804                 goto out;
4805         }
4806
4807         if (!rpcbuf_alloc_size(buffer, *needed)) {
4808                 result = WERR_NOMEM;
4809                 goto out;
4810         }
4811
4812         /* fill the buffer with the structures */
4813         smb_io_printer_info_1("", buffer, printer, 0);
4814
4815 out:
4816         /* clear memory */
4817         SAFE_FREE(printer);
4818
4819         return result;
4820 }
4821
4822 /****************************************************************************
4823 ****************************************************************************/
4824
4825 static WERROR getprinter_level_2(Printer_entry *print_hnd, int snum, RPC_BUFFER *buffer, uint32 offered, uint32 *needed)
4826 {
4827         PRINTER_INFO_2 *printer=NULL;
4828         WERROR result = WERR_OK;
4829
4830         if((printer=SMB_MALLOC_P(PRINTER_INFO_2))==NULL)
4831                 return WERR_NOMEM;
4832
4833         construct_printer_info_2(print_hnd, printer, snum);
4834
4835         /* check the required size. */
4836         *needed += spoolss_size_printer_info_2(printer);
4837
4838         if (*needed > offered) {
4839                 result = WERR_INSUFFICIENT_BUFFER;
4840                 goto out;
4841         }
4842
4843         if (!rpcbuf_alloc_size(buffer, *needed)) {
4844                 result = WERR_NOMEM;
4845                 goto out;
4846         }
4847
4848         /* fill the buffer with the structures */
4849         if (!smb_io_printer_info_2("", buffer, printer, 0))
4850                 result = WERR_NOMEM;
4851
4852 out:
4853         /* clear memory */
4854         free_printer_info_2(printer);
4855
4856         return result;
4857 }
4858
4859 /****************************************************************************
4860 ****************************************************************************/
4861
4862 static WERROR getprinter_level_3(Printer_entry *print_hnd, int snum, RPC_BUFFER *buffer, uint32 offered, uint32 *needed)
4863 {
4864         PRINTER_INFO_3 *printer=NULL;
4865         WERROR result = WERR_OK;
4866
4867         if (!construct_printer_info_3(print_hnd, &printer, snum))
4868                 return WERR_NOMEM;
4869
4870         /* check the required size. */
4871         *needed += spoolss_size_printer_info_3(printer);
4872
4873         if (*needed > offered) {
4874                 result = WERR_INSUFFICIENT_BUFFER;
4875                 goto out;
4876         }
4877
4878         if (!rpcbuf_alloc_size(buffer, *needed)) {
4879                 result = WERR_NOMEM;
4880                 goto out;
4881         }
4882
4883         /* fill the buffer with the structures */
4884         smb_io_printer_info_3("", buffer, printer, 0);
4885
4886 out:
4887         /* clear memory */
4888         free_printer_info_3(printer);
4889
4890         return result;
4891 }
4892
4893 /****************************************************************************
4894 ****************************************************************************/
4895
4896 static WERROR getprinter_level_4(Printer_entry *print_hnd, int snum, RPC_BUFFER *buffer, uint32 offered, uint32 *needed)
4897 {
4898         PRINTER_INFO_4 *printer=NULL;
4899         WERROR result = WERR_OK;
4900
4901         if((printer=SMB_MALLOC_P(PRINTER_INFO_4))==NULL)
4902                 return WERR_NOMEM;
4903
4904         if (!construct_printer_info_4(print_hnd, printer, snum)) {
4905                 SAFE_FREE(printer);
4906                 return WERR_NOMEM;
4907         }
4908
4909         /* check the required size. */
4910         *needed += spoolss_size_printer_info_4(printer);
4911
4912         if (*needed > offered) {
4913                 result = WERR_INSUFFICIENT_BUFFER;
4914                 goto out;
4915         }
4916
4917         if (!rpcbuf_alloc_size(buffer, *needed)) {
4918                 result = WERR_NOMEM;
4919                 goto out;
4920         }
4921
4922         /* fill the buffer with the structures */
4923         smb_io_printer_info_4("", buffer, printer, 0);
4924
4925 out:
4926         /* clear memory */
4927         free_printer_info_4(printer);
4928
4929         return result;
4930 }
4931
4932 /****************************************************************************
4933 ****************************************************************************/
4934
4935 static WERROR getprinter_level_5(Printer_entry *print_hnd, int snum, RPC_BUFFER *buffer, uint32 offered, uint32 *needed)
4936 {
4937         PRINTER_INFO_5 *printer=NULL;
4938         WERROR result = WERR_OK;
4939
4940         if((printer=SMB_MALLOC_P(PRINTER_INFO_5))==NULL)
4941                 return WERR_NOMEM;
4942
4943         if (!construct_printer_info_5(print_hnd, printer, snum)) {
4944                 free_printer_info_5(printer);
4945                 return WERR_NOMEM;
4946         }
4947
4948         /* check the required size. */
4949         *needed += spoolss_size_printer_info_5(printer);
4950
4951         if (*needed > offered) {
4952                 result = WERR_INSUFFICIENT_BUFFER;
4953                 goto out;
4954         }
4955
4956         if (!rpcbuf_alloc_size(buffer, *needed)) {
4957                 result = WERR_NOMEM;
4958                 goto out;
4959         }
4960
4961         /* fill the buffer with the structures */
4962         smb_io_printer_info_5("", buffer, printer, 0);
4963
4964 out:
4965         /* clear memory */
4966         free_printer_info_5(printer);
4967
4968         return result;
4969 }
4970
4971 static WERROR getprinter_level_6(Printer_entry *print_hnd,
4972                                  int snum,
4973                                  RPC_BUFFER *buffer, uint32 offered,
4974                                  uint32 *needed)
4975 {
4976         PRINTER_INFO_6 *printer;
4977         WERROR result = WERR_OK;
4978
4979         if ((printer = SMB_MALLOC_P(PRINTER_INFO_6)) == NULL) {
4980                 return WERR_NOMEM;
4981         }
4982
4983         if (!construct_printer_info_6(print_hnd, printer, snum)) {
4984                 free_printer_info_6(printer);
4985                 return WERR_NOMEM;
4986         }
4987
4988         /* check the required size. */
4989         *needed += spoolss_size_printer_info_6(printer);
4990
4991         if (*needed > offered) {
4992                 result = WERR_INSUFFICIENT_BUFFER;
4993                 goto out;
4994         }
4995
4996         if (!rpcbuf_alloc_size(buffer, *needed)) {
4997                 result = WERR_NOMEM;
4998                 goto out;
4999         }
5000
5001         /* fill the buffer with the structures */
5002         smb_io_printer_info_6("", buffer, printer, 0);
5003
5004 out:
5005         /* clear memory */
5006         free_printer_info_6(printer);
5007
5008         return result;
5009 }
5010
5011 static WERROR getprinter_level_7(Printer_entry *print_hnd, int snum, RPC_BUFFER *buffer, uint32 offered, uint32 *needed)
5012 {
5013         PRINTER_INFO_7 *printer=NULL;
5014         WERROR result = WERR_OK;
5015
5016         if((printer=SMB_MALLOC_P(PRINTER_INFO_7))==NULL)
5017                 return WERR_NOMEM;
5018
5019         if (!construct_printer_info_7(print_hnd, printer, snum)) {
5020                 result = WERR_NOMEM;
5021                 goto out;
5022         }
5023
5024         /* check the required size. */
5025         *needed += spoolss_size_printer_info_7(printer);
5026
5027         if (*needed > offered) {
5028                 result = WERR_INSUFFICIENT_BUFFER;
5029                 goto out;
5030         }
5031
5032         if (!rpcbuf_alloc_size(buffer, *needed)) {
5033                 result = WERR_NOMEM;
5034                 goto out;
5035
5036         }
5037
5038         /* fill the buffer with the structures */
5039         smb_io_printer_info_7("", buffer, printer, 0);
5040
5041 out:
5042         /* clear memory */
5043         free_printer_info_7(printer);
5044
5045         return result;
5046 }
5047
5048 /****************************************************************************
5049 ****************************************************************************/
5050
5051 WERROR _spoolss_getprinter(pipes_struct *p, SPOOL_Q_GETPRINTER *q_u, SPOOL_R_GETPRINTER *r_u)
5052 {
5053         POLICY_HND *handle = &q_u->handle;
5054         uint32 level = q_u->level;
5055         RPC_BUFFER *buffer = NULL;
5056         uint32 offered = q_u->offered;
5057         uint32 *needed = &r_u->needed;
5058         Printer_entry *Printer=find_printer_index_by_hnd(p, handle);
5059
5060         int snum;
5061
5062         /* that's an [in out] buffer */
5063
5064         if (!q_u->buffer && (offered!=0)) {
5065                 return WERR_INVALID_PARAM;
5066         }
5067
5068         if (offered > MAX_RPC_DATA_SIZE) {
5069                 return WERR_INVALID_PARAM;
5070         }
5071
5072         rpcbuf_move(q_u->buffer, &r_u->buffer);
5073         buffer = r_u->buffer;
5074
5075         *needed=0;
5076
5077         if (!get_printer_snum(p, handle, &snum, NULL))
5078                 return WERR_BADFID;
5079
5080         switch (level) {
5081         case 0:
5082                 return getprinter_level_0(Printer, snum, buffer, offered, needed);
5083         case 1:
5084                 return getprinter_level_1(Printer, snum, buffer, offered, needed);
5085         case 2:
5086                 return getprinter_level_2(Printer, snum, buffer, offered, needed);
5087         case 3:
5088                 return getprinter_level_3(Printer, snum, buffer, offered, needed);
5089         case 4:
5090                 return getprinter_level_4(Printer, snum, buffer, offered, needed);
5091         case 5:
5092                 return getprinter_level_5(Printer, snum, buffer, offered, needed);
5093         case 6:
5094                 return getprinter_level_6(Printer, snum, buffer, offered, needed);
5095         case 7:
5096                 return getprinter_level_7(Printer, snum, buffer, offered, needed);
5097         }
5098         return WERR_UNKNOWN_LEVEL;
5099 }
5100
5101 /********************************************************************
5102  * fill a DRIVER_INFO_1 struct
5103  ********************************************************************/
5104
5105 static void fill_printer_driver_info_1(DRIVER_INFO_1 *info, NT_PRINTER_DRIVER_INFO_LEVEL driver, const char *servername, fstring architecture)
5106 {
5107         init_unistr( &info->name, driver.info_3->name);
5108 }
5109
5110 /********************************************************************
5111  * construct_printer_driver_info_1
5112  ********************************************************************/
5113
5114 static WERROR construct_printer_driver_info_1(DRIVER_INFO_1 *info, int snum, const char *servername, fstring architecture, uint32 version)
5115 {
5116         NT_PRINTER_INFO_LEVEL *printer = NULL;
5117         NT_PRINTER_DRIVER_INFO_LEVEL driver;
5118
5119         ZERO_STRUCT(driver);
5120
5121         if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, lp_const_servicename(snum))))
5122                 return WERR_INVALID_PRINTER_NAME;
5123
5124         if (!W_ERROR_IS_OK(get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version))) {
5125                 free_a_printer(&printer, 2);
5126                 return WERR_UNKNOWN_PRINTER_DRIVER;
5127         }
5128
5129         fill_printer_driver_info_1(info, driver, servername, architecture);
5130
5131         free_a_printer(&printer,2);
5132
5133         return WERR_OK;
5134 }
5135
5136 /********************************************************************
5137  * construct_printer_driver_info_2
5138  * fill a printer_info_2 struct
5139  ********************************************************************/
5140
5141 static void fill_printer_driver_info_2(DRIVER_INFO_2 *info, NT_PRINTER_DRIVER_INFO_LEVEL driver, const char *servername)
5142 {
5143         TALLOC_CTX *ctx = talloc_tos();
5144         char *temp = NULL;
5145         const char *cservername = canon_servername(servername);
5146
5147         info->version=driver.info_3->cversion;
5148
5149         init_unistr( &info->name, driver.info_3->name );
5150         init_unistr( &info->architecture, driver.info_3->environment );
5151
5152         if (strlen(driver.info_3->driverpath)) {
5153                 temp = talloc_asprintf(ctx,
5154                                 "\\\\%s%s",
5155                                 cservername,
5156                                 driver.info_3->driverpath);
5157                 init_unistr( &info->driverpath, temp );
5158         } else {
5159                 init_unistr( &info->driverpath, "" );
5160         }
5161
5162         TALLOC_FREE(temp);
5163         if (strlen(driver.info_3->datafile)) {
5164                 temp = talloc_asprintf(ctx,
5165                                 "\\\\%s%s",
5166                                 cservername,
5167                                 driver.info_3->datafile);
5168                 init_unistr( &info->datafile, temp );
5169         } else
5170                 init_unistr( &info->datafile, "" );
5171
5172         TALLOC_FREE(temp);
5173         if (strlen(driver.info_3->configfile)) {
5174                 temp = talloc_asprintf(ctx,
5175                                 "\\\\%s%s",
5176                                 cservername,
5177                                 driver.info_3->configfile);
5178                 init_unistr( &info->configfile, temp );
5179         } else
5180                 init_unistr( &info->configfile, "" );
5181 }
5182
5183 /********************************************************************
5184  * construct_printer_driver_info_2
5185  * fill a printer_info_2 struct
5186  ********************************************************************/
5187
5188 static WERROR construct_printer_driver_info_2(DRIVER_INFO_2 *info, int snum, const char *servername, fstring architecture, uint32 version)
5189 {
5190         NT_PRINTER_INFO_LEVEL *printer = NULL;
5191         NT_PRINTER_DRIVER_INFO_LEVEL driver;
5192
5193         ZERO_STRUCT(printer);
5194         ZERO_STRUCT(driver);
5195
5196         if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, lp_const_servicename(snum))))
5197                 return WERR_INVALID_PRINTER_NAME;
5198
5199         if (!W_ERROR_IS_OK(get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version))) {
5200                 free_a_printer(&printer, 2);
5201                 return WERR_UNKNOWN_PRINTER_DRIVER;
5202         }
5203
5204         fill_printer_driver_info_2(info, driver, servername);
5205
5206         free_a_printer(&printer,2);
5207
5208         return WERR_OK;
5209 }
5210
5211 /********************************************************************
5212  * copy a strings array and convert to UNICODE
5213  *
5214  * convert an array of ascii string to a UNICODE string
5215  ********************************************************************/
5216
5217 static uint32 init_unistr_array(uint16 **uni_array, fstring *char_array, const char *servername)
5218 {
5219         int i=0;
5220         int j=0;
5221         const char *v;
5222         char *line = NULL;
5223         TALLOC_CTX *ctx = talloc_tos();
5224
5225         DEBUG(6,("init_unistr_array\n"));
5226         *uni_array=NULL;
5227
5228         while (true) {
5229                 if ( !char_array ) {
5230                         v = "";
5231                 } else {
5232                         v = char_array[i];
5233                         if (!v)
5234                                 v = ""; /* hack to handle null lists */
5235                 }
5236
5237                 /* hack to allow this to be used in places other than when generating
5238                    the list of dependent files */
5239
5240                 TALLOC_FREE(line);
5241                 if ( servername ) {
5242                         line = talloc_asprintf(ctx,
5243                                         "\\\\%s%s",
5244                                         canon_servername(servername),
5245                                         v);
5246                 } else {
5247                         line = talloc_strdup(ctx, v);
5248                 }
5249
5250                 if (!line) {
5251                         SAFE_FREE(*uni_array);
5252                         return 0;
5253                 }
5254                 DEBUGADD(6,("%d:%s:%lu\n", i, line, (unsigned long)strlen(line)));
5255
5256                 /* add one extra unit16 for the second terminating NULL */
5257
5258                 if ( (*uni_array=SMB_REALLOC_ARRAY(*uni_array, uint16, j+1+strlen(line)+2)) == NULL ) {
5259                         DEBUG(2,("init_unistr_array: Realloc error\n" ));
5260                         return 0;
5261                 }
5262
5263                 if ( !strlen(v) )
5264                         break;
5265
5266                 j += (rpcstr_push((*uni_array+j), line, sizeof(uint16)*strlen(line)+2, STR_TERMINATE) / sizeof(uint16));
5267                 i++;
5268         }
5269
5270         if (*uni_array) {
5271                 /* special case for ""; we need to add both NULL's here */
5272                 if (!j)
5273                         (*uni_array)[j++]=0x0000;
5274                 (*uni_array)[j]=0x0000;
5275         }
5276
5277         DEBUGADD(6,("last one:done\n"));
5278
5279         /* return size of array in uint16's */
5280
5281         return j+1;
5282 }
5283
5284 /********************************************************************
5285  * construct_printer_info_3
5286  * fill a printer_info_3 struct
5287  ********************************************************************/
5288
5289 static void fill_printer_driver_info_3(DRIVER_INFO_3 *info, NT_PRINTER_DRIVER_INFO_LEVEL driver, const char *servername)
5290 {
5291         char *temp = NULL;
5292         TALLOC_CTX *ctx = talloc_tos();
5293         const char *cservername = canon_servername(servername);
5294
5295         ZERO_STRUCTP(info);
5296
5297         info->version=driver.info_3->cversion;
5298
5299         init_unistr( &info->name, driver.info_3->name );
5300         init_unistr( &info->architecture, driver.info_3->environment );
5301
5302         if (strlen(driver.info_3->driverpath)) {
5303                 temp = talloc_asprintf(ctx,
5304                                 "\\\\%s%s",
5305                                 cservername,
5306                                 driver.info_3->driverpath);
5307                 init_unistr( &info->driverpath, temp );
5308         } else
5309                 init_unistr( &info->driverpath, "" );
5310
5311         TALLOC_FREE(temp);
5312         if (strlen(driver.info_3->datafile)) {
5313                 temp = talloc_asprintf(ctx,
5314                                 "\\\\%s%s",
5315                                 cservername,
5316                                 driver.info_3->datafile);
5317                 init_unistr( &info->datafile, temp );
5318         } else
5319                 init_unistr( &info->datafile, "" );
5320
5321         TALLOC_FREE(temp);
5322         if (strlen(driver.info_3->configfile)) {
5323                 temp = talloc_asprintf(ctx,
5324                                 "\\\\%s%s",
5325                                 cservername,
5326                                 driver.info_3->configfile);
5327                 init_unistr( &info->configfile, temp );
5328         } else
5329                 init_unistr( &info->configfile, "" );
5330
5331         TALLOC_FREE(temp);
5332         if (strlen(driver.info_3->helpfile)) {
5333                 temp = talloc_asprintf(ctx,
5334                                 "\\\\%s%s",
5335                                 cservername,
5336                                 driver.info_3->helpfile);
5337                 init_unistr( &info->helpfile, temp );
5338         } else
5339                 init_unistr( &info->helpfile, "" );
5340
5341         TALLOC_FREE(temp);
5342         init_unistr( &info->monitorname, driver.info_3->monitorname );
5343         init_unistr( &info->defaultdatatype, driver.info_3->defaultdatatype );
5344
5345         info->dependentfiles=NULL;
5346         init_unistr_array(&info->dependentfiles, driver.info_3->dependentfiles, cservername);
5347 }
5348
5349 /********************************************************************
5350  * construct_printer_info_3
5351  * fill a printer_info_3 struct
5352  ********************************************************************/
5353
5354 static WERROR construct_printer_driver_info_3(DRIVER_INFO_3 *info, int snum, const char *servername, fstring architecture, uint32 version)
5355 {
5356         NT_PRINTER_INFO_LEVEL *printer = NULL;
5357         NT_PRINTER_DRIVER_INFO_LEVEL driver;
5358         WERROR status;
5359         ZERO_STRUCT(driver);
5360
5361         status=get_a_printer(NULL, &printer, 2, lp_const_servicename(snum) );
5362         DEBUG(8,("construct_printer_driver_info_3: status: %s\n", win_errstr(status)));
5363         if (!W_ERROR_IS_OK(status))
5364                 return WERR_INVALID_PRINTER_NAME;
5365
5366         status=get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
5367         DEBUG(8,("construct_printer_driver_info_3: status: %s\n", win_errstr(status)));
5368
5369 #if 0   /* JERRY */
5370
5371         /*
5372          * I put this code in during testing.  Helpful when commenting out the
5373          * support for DRIVER_INFO_6 in regards to win2k.  Not needed in general
5374          * as win2k always queries the driver using an infor level of 6.
5375          * I've left it in (but ifdef'd out) because I'll probably
5376          * use it in experimentation again in the future.   --jerry 22/01/2002
5377          */
5378
5379         if (!W_ERROR_IS_OK(status)) {
5380                 /*
5381                  * Is this a W2k client ?
5382                  */
5383                 if (version == 3) {
5384                         /* Yes - try again with a WinNT driver. */
5385                         version = 2;
5386                         status=get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
5387                         DEBUG(8,("construct_printer_driver_info_3: status: %s\n", win_errstr(status)));
5388                 }
5389 #endif
5390
5391                 if (!W_ERROR_IS_OK(status)) {
5392                         free_a_printer(&printer,2);
5393                         return WERR_UNKNOWN_PRINTER_DRIVER;
5394                 }
5395
5396 #if 0   /* JERRY */
5397         }
5398 #endif
5399
5400
5401         fill_printer_driver_info_3(info, driver, servername);
5402
5403         free_a_printer(&printer,2);
5404
5405         return WERR_OK;
5406 }
5407
5408 /********************************************************************
5409  * construct_printer_info_6
5410  * fill a printer_info_6 struct - we know that driver is really level 3. This sucks. JRA.
5411  ********************************************************************/
5412
5413 static void fill_printer_driver_info_6(DRIVER_INFO_6 *info, NT_PRINTER_DRIVER_INFO_LEVEL driver, const char *servername)
5414 {
5415         char *temp = NULL;
5416         fstring nullstr;
5417         TALLOC_CTX *ctx = talloc_tos();
5418         const char *cservername = canon_servername(servername);
5419
5420         ZERO_STRUCTP(info);
5421         memset(&nullstr, '\0', sizeof(fstring));
5422
5423         info->version=driver.info_3->cversion;
5424
5425         init_unistr( &info->name, driver.info_3->name );
5426         init_unistr( &info->architecture, driver.info_3->environment );
5427
5428         if (strlen(driver.info_3->driverpath)) {
5429                 temp = talloc_asprintf(ctx,
5430                                 "\\\\%s%s",
5431                                 cservername,
5432                                 driver.info_3->driverpath);
5433                 init_unistr( &info->driverpath, temp );
5434         } else
5435                 init_unistr( &info->driverpath, "" );
5436
5437         TALLOC_FREE(temp);
5438         if (strlen(driver.info_3->datafile)) {
5439                 temp = talloc_asprintf(ctx,
5440                                 "\\\\%s%s",
5441                                 cservername,
5442                                 driver.info_3->datafile);
5443                 init_unistr( &info->datafile, temp );
5444         } else
5445                 init_unistr( &info->datafile, "" );
5446
5447         TALLOC_FREE(temp);
5448         if (strlen(driver.info_3->configfile)) {
5449                 temp = talloc_asprintf(ctx,
5450                                 "\\\\%s%s",
5451                                 cservername,
5452                                 driver.info_3->configfile);
5453                 init_unistr( &info->configfile, temp );
5454         } else
5455                 init_unistr( &info->configfile, "" );
5456
5457         TALLOC_FREE(temp);
5458         if (strlen(driver.info_3->helpfile)) {
5459                 temp = talloc_asprintf(ctx,
5460                                 "\\\\%s%s",
5461                                 cservername,
5462                                 driver.info_3->helpfile);
5463                 init_unistr( &info->helpfile, temp );
5464         } else
5465                 init_unistr( &info->helpfile, "" );
5466
5467         TALLOC_FREE(temp);
5468         init_unistr( &info->monitorname, driver.info_3->monitorname );
5469         init_unistr( &info->defaultdatatype, driver.info_3->defaultdatatype );
5470
5471         info->dependentfiles = NULL;
5472         init_unistr_array( &info->dependentfiles, driver.info_3->dependentfiles, servername );
5473
5474         info->previousdrivernames=NULL;
5475         init_unistr_array(&info->previousdrivernames, &nullstr, servername);
5476
5477         info->driver_date=0;
5478
5479         info->padding=0;
5480         info->driver_version_low=0;
5481         info->driver_version_high=0;
5482
5483         init_unistr( &info->mfgname, "");
5484         init_unistr( &info->oem_url, "");
5485         init_unistr( &info->hardware_id, "");
5486         init_unistr( &info->provider, "");
5487 }
5488
5489 /********************************************************************
5490  * construct_printer_info_6
5491  * fill a printer_info_6 struct
5492  ********************************************************************/
5493
5494 static WERROR construct_printer_driver_info_6(DRIVER_INFO_6 *info, int snum,
5495               const char *servername, fstring architecture, uint32 version)
5496 {
5497         NT_PRINTER_INFO_LEVEL           *printer = NULL;
5498         NT_PRINTER_DRIVER_INFO_LEVEL    driver;
5499         WERROR                          status;
5500
5501         ZERO_STRUCT(driver);
5502
5503         status=get_a_printer(NULL, &printer, 2, lp_const_servicename(snum) );
5504
5505         DEBUG(8,("construct_printer_driver_info_6: status: %s\n", win_errstr(status)));
5506
5507         if (!W_ERROR_IS_OK(status))
5508                 return WERR_INVALID_PRINTER_NAME;
5509
5510         status = get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
5511
5512         DEBUG(8,("construct_printer_driver_info_6: status: %s\n", win_errstr(status)));
5513
5514         if (!W_ERROR_IS_OK(status))
5515         {
5516                 /*
5517                  * Is this a W2k client ?
5518                  */
5519
5520                 if (version < 3) {
5521                         free_a_printer(&printer,2);
5522                         return WERR_UNKNOWN_PRINTER_DRIVER;
5523                 }
5524
5525                 /* Yes - try again with a WinNT driver. */
5526                 version = 2;
5527                 status=get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
5528                 DEBUG(8,("construct_printer_driver_info_6: status: %s\n", win_errstr(status)));
5529                 if (!W_ERROR_IS_OK(status)) {
5530                         free_a_printer(&printer,2);
5531                         return WERR_UNKNOWN_PRINTER_DRIVER;
5532                 }
5533         }
5534
5535         fill_printer_driver_info_6(info, driver, servername);
5536
5537         free_a_printer(&printer,2);
5538         free_a_printer_driver(driver, 3);
5539
5540         return WERR_OK;
5541 }
5542
5543 /****************************************************************************
5544 ****************************************************************************/
5545
5546 static void free_printer_driver_info_3(DRIVER_INFO_3 *info)
5547 {
5548         SAFE_FREE(info->dependentfiles);
5549 }
5550
5551 /****************************************************************************
5552 ****************************************************************************/
5553
5554 static void free_printer_driver_info_6(DRIVER_INFO_6 *info)
5555 {
5556         SAFE_FREE(info->dependentfiles);
5557 }
5558
5559 /****************************************************************************
5560 ****************************************************************************/
5561
5562 static WERROR getprinterdriver2_level1(const char *servername, fstring architecture, uint32 version, int snum, RPC_BUFFER *buffer, uint32 offered, uint32 *needed)
5563 {
5564         DRIVER_INFO_1 *info=NULL;
5565         WERROR result;
5566
5567         if((info=SMB_MALLOC_P(DRIVER_INFO_1)) == NULL)
5568                 return WERR_NOMEM;
5569
5570         result = construct_printer_driver_info_1(info, snum, servername, architecture, version);
5571         if (!W_ERROR_IS_OK(result))
5572                 goto out;
5573
5574         /* check the required size. */
5575         *needed += spoolss_size_printer_driver_info_1(info);
5576
5577         if (*needed > offered) {
5578                 result = WERR_INSUFFICIENT_BUFFER;
5579                 goto out;
5580         }
5581
5582         if (!rpcbuf_alloc_size(buffer, *needed)) {
5583                 result = WERR_NOMEM;
5584                 goto out;
5585         }
5586
5587         /* fill the buffer with the structures */
5588         smb_io_printer_driver_info_1("", buffer, info, 0);
5589
5590 out:
5591         /* clear memory */
5592         SAFE_FREE(info);
5593
5594         return result;
5595 }
5596
5597 /****************************************************************************
5598 ****************************************************************************/
5599
5600 static WERROR getprinterdriver2_level2(const char *servername, fstring architecture, uint32 version, int snum, RPC_BUFFER *buffer, uint32 offered, uint32 *needed)
5601 {
5602         DRIVER_INFO_2 *info=NULL;
5603         WERROR result;
5604
5605         if((info=SMB_MALLOC_P(DRIVER_INFO_2)) == NULL)
5606                 return WERR_NOMEM;
5607
5608         result = construct_printer_driver_info_2(info, snum, servername, architecture, version);
5609         if (!W_ERROR_IS_OK(result))
5610                 goto out;
5611
5612         /* check the required size. */
5613         *needed += spoolss_size_printer_driver_info_2(info);
5614
5615         if (*needed > offered) {
5616                 result = WERR_INSUFFICIENT_BUFFER;
5617                 goto out;
5618         }
5619
5620         if (!rpcbuf_alloc_size(buffer, *needed)) {
5621                 result = WERR_NOMEM;
5622                 goto out;
5623         }
5624
5625         /* fill the buffer with the structures */
5626         smb_io_printer_driver_info_2("", buffer, info, 0);
5627
5628 out:
5629         /* clear memory */
5630         SAFE_FREE(info);
5631
5632         return result;
5633 }
5634
5635 /****************************************************************************
5636 ****************************************************************************/
5637
5638 static WERROR getprinterdriver2_level3(const char *servername, fstring architecture, uint32 version, int snum, RPC_BUFFER *buffer, uint32 offered, uint32 *needed)
5639 {
5640         DRIVER_INFO_3 info;
5641         WERROR result;
5642
5643         ZERO_STRUCT(info);
5644
5645         result = construct_printer_driver_info_3(&info, snum, servername, architecture, version);
5646         if (!W_ERROR_IS_OK(result))
5647                 goto out;
5648
5649         /* check the required size. */
5650         *needed += spoolss_size_printer_driver_info_3(&info);
5651
5652         if (*needed > offered) {
5653                 result = WERR_INSUFFICIENT_BUFFER;
5654                 goto out;
5655         }
5656
5657         if (!rpcbuf_alloc_size(buffer, *needed)) {
5658                 result = WERR_NOMEM;
5659                 goto out;
5660         }
5661
5662         /* fill the buffer with the structures */
5663         smb_io_printer_driver_info_3("", buffer, &info, 0);
5664
5665 out:
5666         free_printer_driver_info_3(&info);
5667
5668         return result;
5669 }
5670
5671 /****************************************************************************
5672 ****************************************************************************/
5673
5674 static WERROR getprinterdriver2_level6(const char *servername, fstring architecture, uint32 version, int snum, RPC_BUFFER *buffer, uint32 offered, uint32 *needed)
5675 {
5676         DRIVER_INFO_6 info;
5677         WERROR result;
5678
5679         ZERO_STRUCT(info);
5680
5681         result = construct_printer_driver_info_6(&info, snum, servername, architecture, version);
5682         if (!W_ERROR_IS_OK(result))
5683                 goto out;
5684
5685         /* check the required size. */
5686         *needed += spoolss_size_printer_driver_info_6(&info);
5687
5688         if (*needed > offered) {
5689                 result = WERR_INSUFFICIENT_BUFFER;
5690                 goto out;
5691         }
5692
5693         if (!rpcbuf_alloc_size(buffer, *needed)) {
5694                 result = WERR_NOMEM;
5695                 goto out;
5696         }
5697
5698         /* fill the buffer with the structures */
5699         smb_io_printer_driver_info_6("", buffer, &info, 0);
5700
5701 out:
5702         free_printer_driver_info_6(&info);
5703
5704         return result;
5705 }
5706
5707 /****************************************************************************
5708 ****************************************************************************/
5709
5710 WERROR _spoolss_getprinterdriver2(pipes_struct *p, SPOOL_Q_GETPRINTERDRIVER2 *q_u, SPOOL_R_GETPRINTERDRIVER2 *r_u)
5711 {
5712         POLICY_HND *handle = &q_u->handle;
5713         UNISTR2 *uni_arch = &q_u->architecture;
5714         uint32 level = q_u->level;
5715         uint32 clientmajorversion = q_u->clientmajorversion;
5716         RPC_BUFFER *buffer = NULL;
5717         uint32 offered = q_u->offered;
5718         uint32 *needed = &r_u->needed;
5719         uint32 *servermajorversion = &r_u->servermajorversion;
5720         uint32 *serverminorversion = &r_u->serverminorversion;
5721         Printer_entry *printer;
5722
5723         fstring servername;
5724         fstring architecture;
5725         int snum;
5726
5727         /* that's an [in out] buffer */
5728
5729         if (!q_u->buffer && (offered!=0)) {
5730                 return WERR_INVALID_PARAM;
5731         }
5732
5733         if (offered > MAX_RPC_DATA_SIZE) {
5734                 return WERR_INVALID_PARAM;
5735         }
5736
5737         rpcbuf_move(q_u->buffer, &r_u->buffer);
5738         buffer = r_u->buffer;
5739
5740         DEBUG(4,("_spoolss_getprinterdriver2\n"));
5741
5742         if ( !(printer = find_printer_index_by_hnd( p, handle )) ) {
5743                 DEBUG(0,("_spoolss_getprinterdriver2: invalid printer handle!\n"));
5744                 return WERR_INVALID_PRINTER_NAME;
5745         }
5746
5747         *needed = 0;
5748         *servermajorversion = 0;
5749         *serverminorversion = 0;
5750
5751         fstrcpy(servername, get_server_name( printer ));
5752         unistr2_to_ascii(architecture, uni_arch, sizeof(architecture));
5753
5754         if (!get_printer_snum(p, handle, &snum, NULL))
5755                 return WERR_BADFID;
5756
5757         switch (level) {
5758         case 1:
5759                 return getprinterdriver2_level1(servername, architecture, clientmajorversion, snum, buffer, offered, needed);
5760         case 2:
5761                 return getprinterdriver2_level2(servername, architecture, clientmajorversion, snum, buffer, offered, needed);
5762         case 3:
5763                 return getprinterdriver2_level3(servername, architecture, clientmajorversion, snum, buffer, offered, needed);
5764         case 6:
5765                 return getprinterdriver2_level6(servername, architecture, clientmajorversion, snum, buffer, offered, needed);
5766 #if 0   /* JERRY */
5767         case 101:
5768                 /* apparently this call is the equivalent of
5769                    EnumPrinterDataEx() for the DsDriver key */
5770                 break;
5771 #endif
5772         }
5773
5774         return WERR_UNKNOWN_LEVEL;
5775 }
5776
5777
5778 /****************************************************************
5779  _spoolss_StartPagePrinter
5780 ****************************************************************/
5781
5782 WERROR _spoolss_StartPagePrinter(pipes_struct *p,
5783                                  struct spoolss_StartPagePrinter *r)
5784 {
5785         POLICY_HND *handle = r->in.handle;
5786
5787         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5788
5789         if (!Printer) {
5790                 DEBUG(3,("_spoolss_StartPagePrinter: "
5791                         "Error in startpageprinter printer handle\n"));
5792                 return WERR_BADFID;
5793         }
5794
5795         Printer->page_started=True;
5796         return WERR_OK;
5797 }
5798
5799 /****************************************************************
5800  _spoolss_EndPagePrinter
5801 ****************************************************************/
5802
5803 WERROR _spoolss_EndPagePrinter(pipes_struct *p,
5804                                struct spoolss_EndPagePrinter *r)
5805 {
5806         POLICY_HND *handle = r->in.handle;
5807         int snum;
5808
5809         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5810
5811         if (!Printer) {
5812                 DEBUG(2,("_spoolss_EndPagePrinter: Invalid handle (%s:%u:%u).\n",
5813                         OUR_HANDLE(handle)));
5814                 return WERR_BADFID;
5815         }
5816
5817         if (!get_printer_snum(p, handle, &snum, NULL))
5818                 return WERR_BADFID;
5819
5820         Printer->page_started=False;
5821         print_job_endpage(snum, Printer->jobid);
5822
5823         return WERR_OK;
5824 }
5825
5826 /****************************************************************
5827  _spoolss_StartDocPrinter
5828 ****************************************************************/
5829
5830 WERROR _spoolss_StartDocPrinter(pipes_struct *p,
5831                                 struct spoolss_StartDocPrinter *r)
5832 {
5833         POLICY_HND *handle = r->in.handle;
5834         uint32_t *jobid = r->out.job_id;
5835         struct spoolss_DocumentInfo1 *info_1;
5836         int snum;
5837         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5838
5839         if (!Printer) {
5840                 DEBUG(2,("_spoolss_StartDocPrinter: "
5841                         "Invalid handle (%s:%u:%u)\n", OUR_HANDLE(handle)));
5842                 return WERR_BADFID;
5843         }
5844
5845         if (r->in.level != 1) {
5846                 return WERR_UNKNOWN_LEVEL;
5847         }
5848
5849         info_1 = r->in.info.info1;
5850
5851         /*
5852          * a nice thing with NT is it doesn't listen to what you tell it.
5853          * when asked to send _only_ RAW datas, it tries to send datas
5854          * in EMF format.
5855          *
5856          * So I add checks like in NT Server ...
5857          */
5858
5859         if (info_1->datatype) {
5860                 if (strcmp(info_1->datatype, "RAW") != 0) {
5861                         (*jobid)=0;
5862                         return WERR_INVALID_DATATYPE;
5863                 }
5864         }
5865
5866         /* get the share number of the printer */
5867         if (!get_printer_snum(p, handle, &snum, NULL)) {
5868                 return WERR_BADFID;
5869         }
5870
5871         Printer->jobid = print_job_start(p->server_info, snum,
5872                                          CONST_DISCARD(char *,info_1->document_name),
5873                                          Printer->nt_devmode);
5874
5875         /* An error occured in print_job_start() so return an appropriate
5876            NT error code. */
5877
5878         if (Printer->jobid == -1) {
5879                 return map_werror_from_unix(errno);
5880         }
5881
5882         Printer->document_started=True;
5883         (*jobid) = Printer->jobid;
5884
5885         return WERR_OK;
5886 }
5887
5888 /****************************************************************
5889  _spoolss_EndDocPrinter
5890 ****************************************************************/
5891
5892 WERROR _spoolss_EndDocPrinter(pipes_struct *p,
5893                               struct spoolss_EndDocPrinter *r)
5894 {
5895         POLICY_HND *handle = r->in.handle;
5896
5897         return _spoolss_enddocprinter_internal(p, handle);
5898 }
5899
5900 /****************************************************************
5901  _spoolss_WritePrinter
5902 ****************************************************************/
5903
5904 WERROR _spoolss_WritePrinter(pipes_struct *p,
5905                              struct spoolss_WritePrinter *r)
5906 {
5907         POLICY_HND *handle = r->in.handle;
5908         uint32 buffer_size = r->in._data_size;
5909         uint8 *buffer = r->in.data.data;
5910         uint32 *buffer_written = &r->in._data_size;
5911         int snum;
5912         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5913
5914         if (!Printer) {
5915                 DEBUG(2,("_spoolss_WritePrinter: Invalid handle (%s:%u:%u)\n",
5916                         OUR_HANDLE(handle)));
5917                 *r->out.num_written = r->in._data_size;
5918                 return WERR_BADFID;
5919         }
5920
5921         if (!get_printer_snum(p, handle, &snum, NULL))
5922                 return WERR_BADFID;
5923
5924         (*buffer_written) = (uint32)print_job_write(snum, Printer->jobid, (const char *)buffer,
5925                                         (SMB_OFF_T)-1, (size_t)buffer_size);
5926         if (*buffer_written == (uint32)-1) {
5927                 *r->out.num_written = 0;
5928                 if (errno == ENOSPC)
5929                         return WERR_NO_SPOOL_SPACE;
5930                 else
5931                         return WERR_ACCESS_DENIED;
5932         }
5933
5934         *r->out.num_written = r->in._data_size;
5935
5936         return WERR_OK;
5937 }
5938
5939 /********************************************************************
5940  * api_spoolss_getprinter
5941  * called from the spoolss dispatcher
5942  *
5943  ********************************************************************/
5944
5945 static WERROR control_printer(POLICY_HND *handle, uint32 command,
5946                               pipes_struct *p)
5947 {
5948         int snum;
5949         WERROR errcode = WERR_BADFUNC;
5950         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5951
5952         if (!Printer) {
5953                 DEBUG(2,("control_printer: Invalid handle (%s:%u:%u)\n", OUR_HANDLE(handle)));
5954                 return WERR_BADFID;
5955         }
5956
5957         if (!get_printer_snum(p, handle, &snum, NULL))
5958                 return WERR_BADFID;
5959
5960         switch (command) {
5961         case SPOOLSS_PRINTER_CONTROL_PAUSE:
5962                 if (print_queue_pause(p->server_info, snum, &errcode)) {
5963                         errcode = WERR_OK;
5964                 }
5965                 break;
5966         case SPOOLSS_PRINTER_CONTROL_RESUME:
5967         case SPOOLSS_PRINTER_CONTROL_UNPAUSE:
5968                 if (print_queue_resume(p->server_info, snum, &errcode)) {
5969                         errcode = WERR_OK;
5970                 }
5971                 break;
5972         case SPOOLSS_PRINTER_CONTROL_PURGE:
5973                 if (print_queue_purge(p->server_info, snum, &errcode)) {
5974                         errcode = WERR_OK;
5975                 }
5976                 break;
5977         default:
5978                 return WERR_UNKNOWN_LEVEL;
5979         }
5980
5981         return errcode;
5982 }
5983
5984
5985 /****************************************************************
5986  _spoolss_AbortPrinter
5987  * From MSDN: "Deletes printer's spool file if printer is configured
5988  * for spooling"
5989 ****************************************************************/
5990
5991 WERROR _spoolss_AbortPrinter(pipes_struct *p,
5992                              struct spoolss_AbortPrinter *r)
5993 {
5994         POLICY_HND      *handle = r->in.handle;
5995         Printer_entry   *Printer = find_printer_index_by_hnd(p, handle);
5996         int             snum;
5997         WERROR          errcode = WERR_OK;
5998
5999         if (!Printer) {
6000                 DEBUG(2,("_spoolss_AbortPrinter: Invalid handle (%s:%u:%u)\n",
6001                         OUR_HANDLE(handle)));
6002                 return WERR_BADFID;
6003         }
6004
6005         if (!get_printer_snum(p, handle, &snum, NULL))
6006                 return WERR_BADFID;
6007
6008         print_job_delete(p->server_info, snum, Printer->jobid, &errcode );
6009
6010         return errcode;
6011 }
6012
6013 /********************************************************************
6014  * called by spoolss_api_setprinter
6015  * when updating a printer description
6016  ********************************************************************/
6017
6018 static WERROR update_printer_sec(POLICY_HND *handle,
6019                                  pipes_struct *p, SEC_DESC_BUF *secdesc_ctr)
6020 {
6021         SEC_DESC_BUF *new_secdesc_ctr = NULL, *old_secdesc_ctr = NULL;
6022         WERROR result;
6023         int snum;
6024
6025         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
6026
6027         if (!Printer || !get_printer_snum(p, handle, &snum, NULL)) {
6028                 DEBUG(2,("update_printer_sec: Invalid handle (%s:%u:%u)\n",
6029                          OUR_HANDLE(handle)));
6030
6031                 result = WERR_BADFID;
6032                 goto done;
6033         }
6034
6035         if (!secdesc_ctr) {
6036                 DEBUG(10,("update_printer_sec: secdesc_ctr is NULL !\n"));
6037                 result = WERR_INVALID_PARAM;
6038                 goto done;
6039         }
6040
6041         /* Check the user has permissions to change the security
6042            descriptor.  By experimentation with two NT machines, the user
6043            requires Full Access to the printer to change security
6044            information. */
6045
6046         if ( Printer->access_granted != PRINTER_ACCESS_ADMINISTER ) {
6047                 DEBUG(4,("update_printer_sec: updated denied by printer permissions\n"));
6048                 result = WERR_ACCESS_DENIED;
6049                 goto done;
6050         }
6051
6052         /* NT seems to like setting the security descriptor even though
6053            nothing may have actually changed. */
6054
6055         if ( !nt_printing_getsec(p->mem_ctx, Printer->sharename, &old_secdesc_ctr)) {
6056                 DEBUG(2,("update_printer_sec: nt_printing_getsec() failed\n"));
6057                 result = WERR_BADFID;
6058                 goto done;
6059         }
6060
6061         if (DEBUGLEVEL >= 10) {
6062                 SEC_ACL *the_acl;
6063                 int i;
6064
6065                 the_acl = old_secdesc_ctr->sd->dacl;
6066                 DEBUG(10, ("old_secdesc_ctr for %s has %d aces:\n",
6067                            PRINTERNAME(snum), the_acl->num_aces));
6068
6069                 for (i = 0; i < the_acl->num_aces; i++) {
6070                         DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
6071                                            &the_acl->aces[i].trustee),
6072                                   the_acl->aces[i].access_mask));
6073                 }
6074
6075                 the_acl = secdesc_ctr->sd->dacl;
6076
6077                 if (the_acl) {
6078                         DEBUG(10, ("secdesc_ctr for %s has %d aces:\n",
6079                                    PRINTERNAME(snum), the_acl->num_aces));
6080
6081                         for (i = 0; i < the_acl->num_aces; i++) {
6082                                 DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
6083                                                    &the_acl->aces[i].trustee),
6084                                            the_acl->aces[i].access_mask));
6085                         }
6086                 } else {
6087                         DEBUG(10, ("dacl for secdesc_ctr is NULL\n"));
6088                 }
6089         }
6090
6091         new_secdesc_ctr = sec_desc_merge(p->mem_ctx, secdesc_ctr, old_secdesc_ctr);
6092         if (!new_secdesc_ctr) {
6093                 result = WERR_NOMEM;
6094                 goto done;
6095         }
6096
6097         if (sec_desc_equal(new_secdesc_ctr->sd, old_secdesc_ctr->sd)) {
6098                 result = WERR_OK;
6099                 goto done;
6100         }
6101
6102         result = nt_printing_setsec(Printer->sharename, new_secdesc_ctr);
6103
6104  done:
6105
6106         return result;
6107 }
6108
6109 /********************************************************************
6110  Canonicalize printer info from a client
6111
6112  ATTN: It does not matter what we set the servername to hear
6113  since we do the necessary work in get_a_printer() to set it to
6114  the correct value based on what the client sent in the
6115  _spoolss_open_printer_ex().
6116  ********************************************************************/
6117
6118 static bool check_printer_ok(NT_PRINTER_INFO_LEVEL_2 *info, int snum)
6119 {
6120         fstring printername;
6121         const char *p;
6122
6123         DEBUG(5,("check_printer_ok: servername=%s printername=%s sharename=%s "
6124                 "portname=%s drivername=%s comment=%s location=%s\n",
6125                 info->servername, info->printername, info->sharename,
6126                 info->portname, info->drivername, info->comment, info->location));
6127
6128         /* we force some elements to "correct" values */
6129         slprintf(info->servername, sizeof(info->servername)-1, "\\\\%s", global_myname());
6130         fstrcpy(info->sharename, lp_servicename(snum));
6131
6132         /* check to see if we allow printername != sharename */
6133
6134         if ( lp_force_printername(snum) ) {
6135                 slprintf(info->printername, sizeof(info->printername)-1, "\\\\%s\\%s",
6136                         global_myname(), info->sharename );
6137         } else {
6138
6139                 /* make sure printername is in \\server\printername format */
6140
6141                 fstrcpy( printername, info->printername );
6142                 p = printername;
6143                 if ( printername[0] == '\\' && printername[1] == '\\' ) {
6144                         if ( (p = strchr_m( &printername[2], '\\' )) != NULL )
6145                                 p++;
6146                 }
6147
6148                 slprintf(info->printername, sizeof(info->printername)-1, "\\\\%s\\%s",
6149                          global_myname(), p );
6150         }
6151
6152         info->attributes |= PRINTER_ATTRIBUTE_SAMBA;
6153         info->attributes &= ~PRINTER_ATTRIBUTE_NOT_SAMBA;
6154
6155
6156
6157         return True;
6158 }
6159
6160 /****************************************************************************
6161 ****************************************************************************/
6162
6163 WERROR add_port_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, const char *portname, const char *uri )
6164 {
6165         char *cmd = lp_addport_cmd();
6166         char *command = NULL;
6167         int ret;
6168         SE_PRIV se_printop = SE_PRINT_OPERATOR;
6169         bool is_print_op = False;
6170
6171         if ( !*cmd ) {
6172                 return WERR_ACCESS_DENIED;
6173         }
6174
6175         command = talloc_asprintf(ctx,
6176                         "%s \"%s\" \"%s\"", cmd, portname, uri );
6177         if (!command) {
6178                 return WERR_NOMEM;
6179         }
6180
6181         if ( token )
6182                 is_print_op = user_has_privileges( token, &se_printop );
6183
6184         DEBUG(10,("Running [%s]\n", command));
6185
6186         /********* BEGIN SePrintOperatorPrivilege **********/
6187
6188         if ( is_print_op )
6189                 become_root();
6190
6191         ret = smbrun(command, NULL);
6192
6193         if ( is_print_op )
6194                 unbecome_root();
6195
6196         /********* END SePrintOperatorPrivilege **********/
6197
6198         DEBUGADD(10,("returned [%d]\n", ret));
6199
6200         TALLOC_FREE(command);
6201
6202         if ( ret != 0 ) {
6203                 return WERR_ACCESS_DENIED;
6204         }
6205
6206         return WERR_OK;
6207 }
6208
6209 /****************************************************************************
6210 ****************************************************************************/
6211
6212 bool add_printer_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, NT_PRINTER_INFO_LEVEL *printer)
6213 {
6214         char *cmd = lp_addprinter_cmd();
6215         char **qlines;
6216         char *command = NULL;
6217         int numlines;
6218         int ret;
6219         int fd;
6220         SE_PRIV se_printop = SE_PRINT_OPERATOR;
6221         bool is_print_op = False;
6222         char *remote_machine = talloc_strdup(ctx, "%m");
6223
6224         if (!remote_machine) {
6225                 return false;
6226         }
6227         remote_machine = talloc_sub_basic(ctx,
6228                                 current_user_info.smb_name,
6229                                 current_user_info.domain,
6230                                 remote_machine);
6231         if (!remote_machine) {
6232                 return false;
6233         }
6234
6235         command = talloc_asprintf(ctx,
6236                         "%s \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"",
6237                         cmd, printer->info_2->printername, printer->info_2->sharename,
6238                         printer->info_2->portname, printer->info_2->drivername,
6239                         printer->info_2->location, printer->info_2->comment, remote_machine);
6240         if (!command) {
6241                 return false;
6242         }
6243
6244         if ( token )
6245                 is_print_op = user_has_privileges( token, &se_printop );
6246
6247         DEBUG(10,("Running [%s]\n", command));
6248
6249         /********* BEGIN SePrintOperatorPrivilege **********/
6250
6251         if ( is_print_op )
6252                 become_root();
6253
6254         if ( (ret = smbrun(command, &fd)) == 0 ) {
6255                 /* Tell everyone we updated smb.conf. */
6256                 message_send_all(smbd_messaging_context(),
6257                                  MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
6258         }
6259
6260         if ( is_print_op )
6261                 unbecome_root();
6262
6263         /********* END SePrintOperatorPrivilege **********/
6264
6265         DEBUGADD(10,("returned [%d]\n", ret));
6266
6267         TALLOC_FREE(command);
6268         TALLOC_FREE(remote_machine);
6269
6270         if ( ret != 0 ) {
6271                 if (fd != -1)
6272                         close(fd);
6273                 return False;
6274         }
6275
6276         /* reload our services immediately */
6277         reload_services( False );
6278
6279         numlines = 0;
6280         /* Get lines and convert them back to dos-codepage */
6281         qlines = fd_lines_load(fd, &numlines, 0, NULL);
6282         DEBUGADD(10,("Lines returned = [%d]\n", numlines));
6283         close(fd);
6284
6285         /* Set the portname to what the script says the portname should be. */
6286         /* but don't require anything to be return from the script exit a good error code */
6287
6288         if (numlines) {
6289                 /* Set the portname to what the script says the portname should be. */
6290                 strncpy(printer->info_2->portname, qlines[0], sizeof(printer->info_2->portname));
6291                 DEBUGADD(6,("Line[0] = [%s]\n", qlines[0]));
6292         }
6293
6294         TALLOC_FREE(qlines);
6295         return True;
6296 }
6297
6298
6299 /********************************************************************
6300  * Called by spoolss_api_setprinter
6301  * when updating a printer description.
6302  ********************************************************************/
6303
6304 static WERROR update_printer(pipes_struct *p, POLICY_HND *handle,
6305                              struct spoolss_SetPrinterInfoCtr *info_ctr,
6306                              struct spoolss_DeviceMode *devmode)
6307 {
6308         int snum;
6309         NT_PRINTER_INFO_LEVEL *printer = NULL, *old_printer = NULL;
6310         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
6311         WERROR result;
6312         UNISTR2 buffer;
6313         fstring asc_buffer;
6314
6315         DEBUG(8,("update_printer\n"));
6316
6317         result = WERR_OK;
6318
6319         if (!Printer) {
6320                 result = WERR_BADFID;
6321                 goto done;
6322         }
6323
6324         if (!get_printer_snum(p, handle, &snum, NULL)) {
6325                 result = WERR_BADFID;
6326                 goto done;
6327         }
6328
6329         if (!W_ERROR_IS_OK(get_a_printer(Printer, &printer, 2, lp_const_servicename(snum))) ||
6330             (!W_ERROR_IS_OK(get_a_printer(Printer, &old_printer, 2, lp_const_servicename(snum))))) {
6331                 result = WERR_BADFID;
6332                 goto done;
6333         }
6334
6335         DEBUGADD(8,("Converting info_2 struct\n"));
6336
6337         /*
6338          * convert_printer_info converts the incoming
6339          * info from the client and overwrites the info
6340          * just read from the tdb in the pointer 'printer'.
6341          */
6342
6343         if (!convert_printer_info_new(info_ctr, printer)) {
6344                 result =  WERR_NOMEM;
6345                 goto done;
6346         }
6347
6348         if (devmode) {
6349                 /* we have a valid devmode
6350                    convert it and link it*/
6351
6352                 DEBUGADD(8,("update_printer: Converting the devicemode struct\n"));
6353                 if (!convert_devicemode_new(printer->info_2->printername,
6354                                             devmode,
6355                                             &printer->info_2->devmode)) {
6356                         result =  WERR_NOMEM;
6357                         goto done;
6358                 }
6359         }
6360
6361         /* Do sanity check on the requested changes for Samba */
6362
6363         if (!check_printer_ok(printer->info_2, snum)) {
6364                 result = WERR_INVALID_PARAM;
6365                 goto done;
6366         }
6367
6368         /* FIXME!!! If the driver has changed we really should verify that
6369            it is installed before doing much else   --jerry */
6370
6371         /* Check calling user has permission to update printer description */
6372
6373         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
6374                 DEBUG(3, ("update_printer: printer property change denied by handle\n"));
6375                 result = WERR_ACCESS_DENIED;
6376                 goto done;
6377         }
6378
6379         /* Call addprinter hook */
6380         /* Check changes to see if this is really needed */
6381
6382         if ( *lp_addprinter_cmd()
6383                 && (!strequal(printer->info_2->drivername, old_printer->info_2->drivername)
6384                         || !strequal(printer->info_2->comment, old_printer->info_2->comment)
6385                         || !strequal(printer->info_2->portname, old_printer->info_2->portname)
6386                         || !strequal(printer->info_2->location, old_printer->info_2->location)) )
6387         {
6388                 /* add_printer_hook() will call reload_services() */
6389
6390                 if ( !add_printer_hook(p->mem_ctx, p->server_info->ptok,
6391                                        printer) ) {
6392                         result = WERR_ACCESS_DENIED;
6393                         goto done;
6394                 }
6395         }
6396
6397         /*
6398          * When a *new* driver is bound to a printer, the drivername is used to
6399          * lookup previously saved driver initialization info, which is then
6400          * bound to the printer, simulating what happens in the Windows arch.
6401          */
6402         if (!strequal(printer->info_2->drivername, old_printer->info_2->drivername))
6403         {
6404                 if (!set_driver_init(printer, 2))
6405                 {
6406                         DEBUG(5,("update_printer: Error restoring driver initialization data for driver [%s]!\n",
6407                                 printer->info_2->drivername));
6408                 }
6409
6410                 DEBUG(10,("update_printer: changing driver [%s]!  Sending event!\n",
6411                         printer->info_2->drivername));
6412
6413                 notify_printer_driver(snum, printer->info_2->drivername);
6414         }
6415
6416         /*
6417          * flag which changes actually occured.  This is a small subset of
6418          * all the possible changes.  We also have to update things in the
6419          * DsSpooler key.
6420          */
6421
6422         if (!strequal(printer->info_2->comment, old_printer->info_2->comment)) {
6423                 init_unistr2( &buffer, printer->info_2->comment, UNI_STR_TERMINATE);
6424                 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "description",
6425                         REG_SZ, (uint8*)buffer.buffer, buffer.uni_str_len*2 );
6426
6427                 notify_printer_comment(snum, printer->info_2->comment);
6428         }
6429
6430         if (!strequal(printer->info_2->sharename, old_printer->info_2->sharename)) {
6431                 init_unistr2( &buffer, printer->info_2->sharename, UNI_STR_TERMINATE);
6432                 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "shareName",
6433                         REG_SZ, (uint8*)buffer.buffer, buffer.uni_str_len*2 );
6434
6435                 notify_printer_sharename(snum, printer->info_2->sharename);
6436         }
6437
6438         if (!strequal(printer->info_2->printername, old_printer->info_2->printername)) {
6439                 char *pname;
6440
6441                 if ( (pname = strchr_m( printer->info_2->printername+2, '\\' )) != NULL )
6442                         pname++;
6443                 else
6444                         pname = printer->info_2->printername;
6445
6446
6447                 init_unistr2( &buffer, pname, UNI_STR_TERMINATE);
6448                 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "printerName",
6449                         REG_SZ, (uint8*)buffer.buffer, buffer.uni_str_len*2 );
6450
6451                 notify_printer_printername( snum, pname );
6452         }
6453
6454         if (!strequal(printer->info_2->portname, old_printer->info_2->portname)) {
6455                 init_unistr2( &buffer, printer->info_2->portname, UNI_STR_TERMINATE);
6456                 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "portName",
6457                         REG_SZ, (uint8*)buffer.buffer, buffer.uni_str_len*2 );
6458
6459                 notify_printer_port(snum, printer->info_2->portname);
6460         }
6461
6462         if (!strequal(printer->info_2->location, old_printer->info_2->location)) {
6463                 init_unistr2( &buffer, printer->info_2->location, UNI_STR_TERMINATE);
6464                 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "location",
6465                         REG_SZ, (uint8*)buffer.buffer, buffer.uni_str_len*2 );
6466
6467                 notify_printer_location(snum, printer->info_2->location);
6468         }
6469
6470         /* here we need to update some more DsSpooler keys */
6471         /* uNCName, serverName, shortServerName */
6472
6473         init_unistr2( &buffer, global_myname(), UNI_STR_TERMINATE);
6474         set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "serverName",
6475                 REG_SZ, (uint8*)buffer.buffer, buffer.uni_str_len*2 );
6476         set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "shortServerName",
6477                 REG_SZ, (uint8*)buffer.buffer, buffer.uni_str_len*2 );
6478
6479         slprintf( asc_buffer, sizeof(asc_buffer)-1, "\\\\%s\\%s",
6480                  global_myname(), printer->info_2->sharename );
6481         init_unistr2( &buffer, asc_buffer, UNI_STR_TERMINATE);
6482         set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "uNCName",
6483                 REG_SZ, (uint8*)buffer.buffer, buffer.uni_str_len*2 );
6484
6485         /* Update printer info */
6486         result = mod_a_printer(printer, 2);
6487
6488 done:
6489         free_a_printer(&printer, 2);
6490         free_a_printer(&old_printer, 2);
6491
6492
6493         return result;
6494 }
6495
6496 /****************************************************************************
6497 ****************************************************************************/
6498 static WERROR publish_or_unpublish_printer(pipes_struct *p, POLICY_HND *handle,
6499                                            struct spoolss_SetPrinterInfo7 *info7)
6500 {
6501 #ifdef HAVE_ADS
6502         int snum;
6503         Printer_entry *Printer;
6504
6505         if ( lp_security() != SEC_ADS ) {
6506                 return WERR_UNKNOWN_LEVEL;
6507         }
6508
6509         Printer = find_printer_index_by_hnd(p, handle);
6510
6511         DEBUG(5,("publish_or_unpublish_printer, action = %d\n",info7->action));
6512
6513         if (!Printer)
6514                 return WERR_BADFID;
6515
6516         if (!get_printer_snum(p, handle, &snum, NULL))
6517                 return WERR_BADFID;
6518
6519         nt_printer_publish(Printer, snum, info7->action);
6520
6521         return WERR_OK;
6522 #else
6523         return WERR_UNKNOWN_LEVEL;
6524 #endif
6525 }
6526
6527 /****************************************************************
6528  _spoolss_SetPrinter
6529 ****************************************************************/
6530
6531 WERROR _spoolss_SetPrinter(pipes_struct *p,
6532                            struct spoolss_SetPrinter *r)
6533 {
6534         POLICY_HND *handle = r->in.handle;
6535         WERROR result;
6536
6537         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
6538
6539         if (!Printer) {
6540                 DEBUG(2,("_spoolss_SetPrinter: Invalid handle (%s:%u:%u)\n",
6541                         OUR_HANDLE(handle)));
6542                 return WERR_BADFID;
6543         }
6544
6545         /* check the level */
6546         switch (r->in.info_ctr->level) {
6547                 case 0:
6548                         return control_printer(handle, r->in.command, p);
6549                 case 2:
6550                         result = update_printer(p, handle,
6551                                                 r->in.info_ctr,
6552                                                 r->in.devmode_ctr->devmode);
6553                         if (!W_ERROR_IS_OK(result))
6554                                 return result;
6555                         if (r->in.secdesc_ctr->sd)
6556                                 result = update_printer_sec(handle, p,
6557                                                             r->in.secdesc_ctr);
6558                         return result;
6559                 case 3:
6560                         return update_printer_sec(handle, p,
6561                                                   r->in.secdesc_ctr);
6562                 case 7:
6563                         return publish_or_unpublish_printer(p, handle,
6564                                                             r->in.info_ctr->info.info7);
6565                 default:
6566                         return WERR_UNKNOWN_LEVEL;
6567         }
6568 }
6569
6570 /****************************************************************
6571  _spoolss_FindClosePrinterNotify
6572 ****************************************************************/
6573
6574 WERROR _spoolss_FindClosePrinterNotify(pipes_struct *p,
6575                                        struct spoolss_FindClosePrinterNotify *r)
6576 {
6577         POLICY_HND *handle = r->in.handle;
6578         Printer_entry *Printer= find_printer_index_by_hnd(p, handle);
6579
6580         if (!Printer) {
6581                 DEBUG(2,("_spoolss_FindClosePrinterNotify: "
6582                         "Invalid handle (%s:%u:%u)\n", OUR_HANDLE(handle)));
6583                 return WERR_BADFID;
6584         }
6585
6586         if (Printer->notify.client_connected==True) {
6587                 int snum = -1;
6588
6589                 if ( Printer->printer_type == SPLHND_SERVER)
6590                         snum = -1;
6591                 else if ( (Printer->printer_type == SPLHND_PRINTER) &&
6592                                 !get_printer_snum(p, handle, &snum, NULL) )
6593                         return WERR_BADFID;
6594
6595                 srv_spoolss_replycloseprinter(snum, &Printer->notify.client_hnd);
6596         }
6597
6598         Printer->notify.flags=0;
6599         Printer->notify.options=0;
6600         Printer->notify.localmachine[0]='\0';
6601         Printer->notify.printerlocal=0;
6602         TALLOC_FREE(Printer->notify.option);
6603         Printer->notify.client_connected=False;
6604
6605         return WERR_OK;
6606 }
6607
6608 /****************************************************************
6609  _spoolss_AddJob
6610 ****************************************************************/
6611
6612 WERROR _spoolss_AddJob(pipes_struct *p,
6613                        struct spoolss_AddJob *r)
6614 {
6615         if (!r->in.buffer && (r->in.offered != 0)) {
6616                 return WERR_INVALID_PARAM;
6617         }
6618
6619         /* this is what a NT server returns for AddJob. AddJob must fail on
6620          * non-local printers */
6621
6622         return WERR_INVALID_PARAM;
6623 }
6624
6625 /****************************************************************************
6626 ****************************************************************************/
6627
6628 static void fill_job_info_1(JOB_INFO_1 *job_info, const print_queue_struct *queue,
6629                             int position, int snum,
6630                             const NT_PRINTER_INFO_LEVEL *ntprinter)
6631 {
6632         struct tm *t;
6633
6634         t=gmtime(&queue->time);
6635
6636         job_info->jobid=queue->job;
6637         init_unistr(&job_info->printername, lp_servicename(snum));
6638         init_unistr(&job_info->machinename, ntprinter->info_2->servername);
6639         init_unistr(&job_info->username, queue->fs_user);
6640         init_unistr(&job_info->document, queue->fs_file);
6641         init_unistr(&job_info->datatype, "RAW");
6642         init_unistr(&job_info->text_status, "");
6643         job_info->status=nt_printj_status(queue->status);
6644         job_info->priority=queue->priority;
6645         job_info->position=position;
6646         job_info->totalpages=queue->page_count;
6647         job_info->pagesprinted=0;
6648
6649         make_systemtime(&job_info->submitted, t);
6650 }
6651
6652 /****************************************************************************
6653 ****************************************************************************/
6654
6655 static bool fill_job_info_2(JOB_INFO_2 *job_info, const print_queue_struct *queue,
6656                             int position, int snum,
6657                             const NT_PRINTER_INFO_LEVEL *ntprinter,
6658                             DEVICEMODE *devmode)
6659 {
6660         struct tm *t;
6661
6662         t=gmtime(&queue->time);
6663
6664         job_info->jobid=queue->job;
6665
6666         init_unistr(&job_info->printername, ntprinter->info_2->printername);
6667
6668         init_unistr(&job_info->machinename, ntprinter->info_2->servername);
6669         init_unistr(&job_info->username, queue->fs_user);
6670         init_unistr(&job_info->document, queue->fs_file);
6671         init_unistr(&job_info->notifyname, queue->fs_user);
6672         init_unistr(&job_info->datatype, "RAW");
6673         init_unistr(&job_info->printprocessor, "winprint");
6674         init_unistr(&job_info->parameters, "");
6675         init_unistr(&job_info->drivername, ntprinter->info_2->drivername);
6676         init_unistr(&job_info->text_status, "");
6677
6678 /* and here the security descriptor */
6679
6680         job_info->status=nt_printj_status(queue->status);
6681         job_info->priority=queue->priority;
6682         job_info->position=position;
6683         job_info->starttime=0;
6684         job_info->untiltime=0;
6685         job_info->totalpages=queue->page_count;
6686         job_info->size=queue->size;
6687         make_systemtime(&(job_info->submitted), t);
6688         job_info->timeelapsed=0;
6689         job_info->pagesprinted=0;
6690
6691         job_info->devmode = devmode;
6692
6693         return (True);
6694 }
6695
6696 /****************************************************************************
6697  Enumjobs at level 1.
6698 ****************************************************************************/
6699
6700 static WERROR enumjobs_level1(const print_queue_struct *queue, int snum,
6701                               const NT_PRINTER_INFO_LEVEL *ntprinter,
6702                               RPC_BUFFER *buffer, uint32 offered,
6703                               uint32 *needed, uint32 *returned)
6704 {
6705         JOB_INFO_1 *info;
6706         int i;
6707         WERROR result = WERR_OK;
6708
6709         info=SMB_MALLOC_ARRAY(JOB_INFO_1,*returned);
6710         if (info==NULL) {
6711                 *returned=0;
6712                 return WERR_NOMEM;
6713         }
6714
6715         for (i=0; i<*returned; i++)
6716                 fill_job_info_1( &info[i], &queue[i], i, snum, ntprinter );
6717
6718         /* check the required size. */
6719         for (i=0; i<*returned; i++)
6720                 (*needed) += spoolss_size_job_info_1(&info[i]);
6721
6722         if (*needed > offered) {
6723                 result = WERR_INSUFFICIENT_BUFFER;
6724                 goto out;
6725         }
6726
6727         if (!rpcbuf_alloc_size(buffer, *needed)) {
6728                 result = WERR_NOMEM;
6729                 goto out;
6730         }
6731
6732         /* fill the buffer with the structures */
6733         for (i=0; i<*returned; i++)
6734                 smb_io_job_info_1("", buffer, &info[i], 0);
6735
6736 out:
6737         /* clear memory */
6738         SAFE_FREE(info);
6739
6740         if ( !W_ERROR_IS_OK(result) )
6741                 *returned = 0;
6742
6743         return result;
6744 }
6745
6746 /****************************************************************************
6747  Enumjobs at level 2.
6748 ****************************************************************************/
6749
6750 static WERROR enumjobs_level2(const print_queue_struct *queue, int snum,
6751                               const NT_PRINTER_INFO_LEVEL *ntprinter,
6752                               RPC_BUFFER *buffer, uint32 offered,
6753                               uint32 *needed, uint32 *returned)
6754 {
6755         JOB_INFO_2 *info = NULL;
6756         int i;
6757         WERROR result = WERR_OK;
6758         DEVICEMODE *devmode = NULL;
6759
6760         if ( !(info = SMB_MALLOC_ARRAY(JOB_INFO_2,*returned)) ) {
6761                 *returned=0;
6762                 return WERR_NOMEM;
6763         }
6764
6765         /* this should not be a failure condition if the devmode is NULL */
6766
6767         devmode = construct_dev_mode(lp_const_servicename(snum));
6768
6769         for (i=0; i<*returned; i++)
6770                 fill_job_info_2(&(info[i]), &queue[i], i, snum, ntprinter, devmode);
6771
6772         /* check the required size. */
6773         for (i=0; i<*returned; i++)
6774                 (*needed) += spoolss_size_job_info_2(&info[i]);
6775
6776         if (*needed > offered) {
6777                 result = WERR_INSUFFICIENT_BUFFER;
6778                 goto out;
6779         }
6780
6781         if (!rpcbuf_alloc_size(buffer, *needed)) {
6782                 result = WERR_NOMEM;
6783                 goto out;
6784         }
6785
6786         /* fill the buffer with the structures */
6787         for (i=0; i<*returned; i++)
6788                 smb_io_job_info_2("", buffer, &info[i], 0);
6789
6790 out:
6791         free_devmode(devmode);
6792         SAFE_FREE(info);
6793
6794         if ( !W_ERROR_IS_OK(result) )
6795                 *returned = 0;
6796
6797         return result;
6798
6799 }
6800
6801 /****************************************************************************
6802  Enumjobs.
6803 ****************************************************************************/
6804
6805 WERROR _spoolss_enumjobs( pipes_struct *p, SPOOL_Q_ENUMJOBS *q_u, SPOOL_R_ENUMJOBS *r_u)
6806 {
6807         POLICY_HND *handle = &q_u->handle;
6808         uint32 level = q_u->level;
6809         RPC_BUFFER *buffer = NULL;
6810         uint32 offered = q_u->offered;
6811         uint32 *needed = &r_u->needed;
6812         uint32 *returned = &r_u->returned;
6813         WERROR wret;
6814         NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
6815         int snum;
6816         print_status_struct prt_status;
6817         print_queue_struct *queue=NULL;
6818
6819         /* that's an [in out] buffer */
6820
6821         if (!q_u->buffer && (offered!=0)) {
6822                 return WERR_INVALID_PARAM;
6823         }
6824
6825         if (offered > MAX_RPC_DATA_SIZE) {
6826                 return WERR_INVALID_PARAM;
6827         }
6828
6829         rpcbuf_move(q_u->buffer, &r_u->buffer);
6830         buffer = r_u->buffer;
6831
6832         DEBUG(4,("_spoolss_enumjobs\n"));
6833
6834         *needed=0;
6835         *returned=0;
6836
6837         /* lookup the printer snum and tdb entry */
6838
6839         if (!get_printer_snum(p, handle, &snum, NULL))
6840                 return WERR_BADFID;
6841
6842         wret = get_a_printer(NULL, &ntprinter, 2, lp_servicename(snum));
6843         if ( !W_ERROR_IS_OK(wret) )
6844                 return wret;
6845
6846         *returned = print_queue_status(snum, &queue, &prt_status);
6847         DEBUGADD(4,("count:[%d], status:[%d], [%s]\n", *returned, prt_status.status, prt_status.message));
6848
6849         if (*returned == 0) {
6850                 SAFE_FREE(queue);
6851                 free_a_printer(&ntprinter, 2);
6852                 return WERR_OK;
6853         }
6854
6855         switch (level) {
6856         case 1:
6857                 wret = enumjobs_level1(queue, snum, ntprinter, buffer, offered, needed, returned);
6858                 break;
6859         case 2:
6860                 wret = enumjobs_level2(queue, snum, ntprinter, buffer, offered, needed, returned);
6861                 break;
6862         default:
6863                 *returned=0;
6864                 wret = WERR_UNKNOWN_LEVEL;
6865                 break;
6866         }
6867
6868         SAFE_FREE(queue);
6869         free_a_printer( &ntprinter, 2 );
6870         return wret;
6871 }
6872
6873 /****************************************************************
6874  _spoolss_ScheduleJob
6875 ****************************************************************/
6876
6877 WERROR _spoolss_ScheduleJob(pipes_struct *p,
6878                             struct spoolss_ScheduleJob *r)
6879 {
6880         return WERR_OK;
6881 }
6882
6883 /****************************************************************
6884  _spoolss_SetJob
6885 ****************************************************************/
6886
6887 WERROR _spoolss_SetJob(pipes_struct *p,
6888                        struct spoolss_SetJob *r)
6889 {
6890         POLICY_HND *handle = r->in.handle;
6891         uint32 jobid = r->in.job_id;
6892         uint32 command = r->in.command;
6893
6894         int snum;
6895         WERROR errcode = WERR_BADFUNC;
6896
6897         if (!get_printer_snum(p, handle, &snum, NULL)) {
6898                 return WERR_BADFID;
6899         }
6900
6901         if (!print_job_exists(lp_const_servicename(snum), jobid)) {
6902                 return WERR_INVALID_PRINTER_NAME;
6903         }
6904
6905         switch (command) {
6906         case SPOOLSS_JOB_CONTROL_CANCEL:
6907         case SPOOLSS_JOB_CONTROL_DELETE:
6908                 if (print_job_delete(p->server_info, snum, jobid, &errcode)) {
6909                         errcode = WERR_OK;
6910                 }
6911                 break;
6912         case SPOOLSS_JOB_CONTROL_PAUSE:
6913                 if (print_job_pause(p->server_info, snum, jobid, &errcode)) {
6914                         errcode = WERR_OK;
6915                 }
6916                 break;
6917         case SPOOLSS_JOB_CONTROL_RESTART:
6918         case SPOOLSS_JOB_CONTROL_RESUME:
6919                 if (print_job_resume(p->server_info, snum, jobid, &errcode)) {
6920                         errcode = WERR_OK;
6921                 }
6922                 break;
6923         default:
6924                 return WERR_UNKNOWN_LEVEL;
6925         }
6926
6927         return errcode;
6928 }
6929
6930 /****************************************************************************
6931  Enumerates all printer drivers at level 1.
6932 ****************************************************************************/
6933
6934 static WERROR enumprinterdrivers_level1(const char *servername, fstring architecture, RPC_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
6935 {
6936         int i;
6937         int ndrivers;
6938         uint32 version;
6939         fstring *list = NULL;
6940         NT_PRINTER_DRIVER_INFO_LEVEL driver;
6941         DRIVER_INFO_1 *driver_info_1=NULL;
6942         WERROR result = WERR_OK;
6943
6944         *returned=0;
6945
6946         for (version=0; version<DRIVER_MAX_VERSION; version++) {
6947                 list=NULL;
6948                 ndrivers=get_ntdrivers(&list, architecture, version);
6949                 DEBUGADD(4,("we have:[%d] drivers in environment [%s] and version [%d]\n", ndrivers, architecture, version));
6950
6951                 if(ndrivers == -1) {
6952                         SAFE_FREE(driver_info_1);
6953                         return WERR_NOMEM;
6954                 }
6955
6956                 if(ndrivers != 0) {
6957                         if((driver_info_1=SMB_REALLOC_ARRAY(driver_info_1, DRIVER_INFO_1, *returned+ndrivers )) == NULL) {
6958                                 DEBUG(0,("enumprinterdrivers_level1: failed to enlarge driver info buffer!\n"));
6959                                 SAFE_FREE(list);
6960                                 return WERR_NOMEM;
6961                         }
6962                 }
6963
6964                 for (i=0; i<ndrivers; i++) {
6965                         WERROR status;
6966                         DEBUGADD(5,("\tdriver: [%s]\n", list[i]));
6967                         ZERO_STRUCT(driver);
6968                         status = get_a_printer_driver(&driver, 3, list[i],
6969                                                       architecture, version);
6970                         if (!W_ERROR_IS_OK(status)) {
6971                                 SAFE_FREE(list);
6972                                 SAFE_FREE(driver_info_1);
6973                                 return status;
6974                         }
6975                         fill_printer_driver_info_1(&driver_info_1[*returned+i], driver, servername, architecture );
6976                         free_a_printer_driver(driver, 3);
6977                 }
6978
6979                 *returned+=ndrivers;
6980                 SAFE_FREE(list);
6981         }
6982
6983         /* check the required size. */
6984         for (i=0; i<*returned; i++) {
6985                 DEBUGADD(6,("adding driver [%d]'s size\n",i));
6986                 *needed += spoolss_size_printer_driver_info_1(&driver_info_1[i]);
6987         }
6988
6989         if (*needed > offered) {
6990                 result = WERR_INSUFFICIENT_BUFFER;
6991                 goto out;
6992         }
6993
6994         if (!rpcbuf_alloc_size(buffer, *needed)) {
6995                 result = WERR_NOMEM;
6996                 goto out;
6997         }
6998
6999         /* fill the buffer with the driver structures */
7000         for (i=0; i<*returned; i++) {
7001                 DEBUGADD(6,("adding driver [%d] to buffer\n",i));
7002                 smb_io_printer_driver_info_1("", buffer, &driver_info_1[i], 0);
7003         }
7004
7005 out:
7006         SAFE_FREE(driver_info_1);
7007
7008         if ( !W_ERROR_IS_OK(result) )
7009                 *returned = 0;
7010
7011         return result;
7012 }
7013
7014 /****************************************************************************
7015  Enumerates all printer drivers at level 2.
7016 ****************************************************************************/
7017
7018 static WERROR enumprinterdrivers_level2(const char *servername, fstring architecture, RPC_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
7019 {
7020         int i;
7021         int ndrivers;
7022         uint32 version;
7023         fstring *list = NULL;
7024         NT_PRINTER_DRIVER_INFO_LEVEL driver;
7025         DRIVER_INFO_2 *driver_info_2=NULL;
7026         WERROR result = WERR_OK;
7027
7028         *returned=0;
7029
7030         for (version=0; version<DRIVER_MAX_VERSION; version++) {
7031                 list=NULL;
7032                 ndrivers=get_ntdrivers(&list, architecture, version);
7033                 DEBUGADD(4,("we have:[%d] drivers in environment [%s] and version [%d]\n", ndrivers, architecture, version));
7034
7035                 if(ndrivers == -1) {
7036                         SAFE_FREE(driver_info_2);
7037                         return WERR_NOMEM;
7038                 }
7039
7040                 if(ndrivers != 0) {
7041                         if((driver_info_2=SMB_REALLOC_ARRAY(driver_info_2, DRIVER_INFO_2, *returned+ndrivers )) == NULL) {
7042                                 DEBUG(0,("enumprinterdrivers_level2: failed to enlarge driver info buffer!\n"));
7043                                 SAFE_FREE(list);
7044                                 return WERR_NOMEM;
7045                         }
7046                 }
7047
7048                 for (i=0; i<ndrivers; i++) {
7049                         WERROR status;
7050
7051                         DEBUGADD(5,("\tdriver: [%s]\n", list[i]));
7052                         ZERO_STRUCT(driver);
7053                         status = get_a_printer_driver(&driver, 3, list[i],
7054                                                       architecture, version);
7055                         if (!W_ERROR_IS_OK(status)) {
7056                                 SAFE_FREE(list);
7057                                 SAFE_FREE(driver_info_2);
7058                                 return status;
7059                         }
7060                         fill_printer_driver_info_2(&driver_info_2[*returned+i], driver, servername);
7061                         free_a_printer_driver(driver, 3);
7062                 }
7063
7064                 *returned+=ndrivers;
7065                 SAFE_FREE(list);
7066         }
7067
7068         /* check the required size. */
7069         for (i=0; i<*returned; i++) {
7070                 DEBUGADD(6,("adding driver [%d]'s size\n",i));
7071                 *needed += spoolss_size_printer_driver_info_2(&(driver_info_2[i]));
7072         }
7073
7074         if (*needed > offered) {
7075                 result = WERR_INSUFFICIENT_BUFFER;
7076                 goto out;
7077         }
7078
7079         if (!rpcbuf_alloc_size(buffer, *needed)) {
7080                 result = WERR_NOMEM;
7081                 goto out;
7082         }
7083
7084         /* fill the buffer with the form structures */
7085         for (i=0; i<*returned; i++) {
7086                 DEBUGADD(6,("adding driver [%d] to buffer\n",i));
7087                 smb_io_printer_driver_info_2("", buffer, &(driver_info_2[i]), 0);
7088         }
7089
7090 out:
7091         SAFE_FREE(driver_info_2);
7092
7093         if ( !W_ERROR_IS_OK(result) )
7094                 *returned = 0;
7095
7096         return result;
7097 }
7098
7099 /****************************************************************************
7100  Enumerates all printer drivers at level 3.
7101 ****************************************************************************/
7102
7103 static WERROR enumprinterdrivers_level3(const char *servername, fstring architecture, RPC_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
7104 {
7105         int i;
7106         int ndrivers;
7107         uint32 version;
7108         fstring *list = NULL;
7109         DRIVER_INFO_3 *driver_info_3=NULL;
7110         NT_PRINTER_DRIVER_INFO_LEVEL driver;
7111         WERROR result = WERR_OK;
7112
7113         *returned=0;
7114
7115         for (version=0; version<DRIVER_MAX_VERSION; version++) {
7116                 list=NULL;
7117                 ndrivers=get_ntdrivers(&list, architecture, version);
7118                 DEBUGADD(4,("we have:[%d] drivers in environment [%s] and version [%d]\n", ndrivers, architecture, version));
7119
7120                 if(ndrivers == -1) {
7121                         SAFE_FREE(driver_info_3);
7122                         return WERR_NOMEM;
7123                 }
7124
7125                 if(ndrivers != 0) {
7126                         if((driver_info_3=SMB_REALLOC_ARRAY(driver_info_3, DRIVER_INFO_3, *returned+ndrivers )) == NULL) {
7127                                 DEBUG(0,("enumprinterdrivers_level3: failed to enlarge driver info buffer!\n"));
7128                                 SAFE_FREE(list);
7129                                 return WERR_NOMEM;
7130                         }
7131                 }
7132
7133                 for (i=0; i<ndrivers; i++) {
7134                         WERROR status;
7135
7136                         DEBUGADD(5,("\tdriver: [%s]\n", list[i]));
7137                         ZERO_STRUCT(driver);
7138                         status = get_a_printer_driver(&driver, 3, list[i],
7139                                                       architecture, version);
7140                         if (!W_ERROR_IS_OK(status)) {
7141                                 SAFE_FREE(list);
7142                                 SAFE_FREE(driver_info_3);
7143                                 return status;
7144                         }
7145                         fill_printer_driver_info_3(&driver_info_3[*returned+i], driver, servername);
7146                         free_a_printer_driver(driver, 3);
7147                 }
7148
7149                 *returned+=ndrivers;
7150                 SAFE_FREE(list);
7151         }
7152
7153         /* check the required size. */
7154         for (i=0; i<*returned; i++) {
7155                 DEBUGADD(6,("adding driver [%d]'s size\n",i));
7156                 *needed += spoolss_size_printer_driver_info_3(&driver_info_3[i]);
7157         }
7158
7159         if (*needed > offered) {
7160                 result = WERR_INSUFFICIENT_BUFFER;
7161                 goto out;
7162         }
7163
7164         if (!rpcbuf_alloc_size(buffer, *needed)) {
7165                 result = WERR_NOMEM;
7166                 goto out;
7167         }
7168
7169         /* fill the buffer with the driver structures */
7170         for (i=0; i<*returned; i++) {
7171                 DEBUGADD(6,("adding driver [%d] to buffer\n",i));
7172                 smb_io_printer_driver_info_3("", buffer, &driver_info_3[i], 0);
7173         }
7174
7175 out:
7176         for (i=0; i<*returned; i++) {
7177                 SAFE_FREE(driver_info_3[i].dependentfiles);
7178         }
7179
7180         SAFE_FREE(driver_info_3);
7181
7182         if ( !W_ERROR_IS_OK(result) )
7183                 *returned = 0;
7184
7185         return result;
7186 }
7187
7188 /****************************************************************************
7189  Enumerates all printer drivers.
7190 ****************************************************************************/
7191
7192 WERROR _spoolss_enumprinterdrivers( pipes_struct *p, SPOOL_Q_ENUMPRINTERDRIVERS *q_u, SPOOL_R_ENUMPRINTERDRIVERS *r_u)
7193 {
7194         uint32 level = q_u->level;
7195         RPC_BUFFER *buffer = NULL;
7196         uint32 offered = q_u->offered;
7197         uint32 *needed = &r_u->needed;
7198         uint32 *returned = &r_u->returned;
7199         const char *cservername;
7200         fstring servername;
7201         fstring architecture;
7202
7203         /* that's an [in out] buffer */
7204
7205         if (!q_u->buffer && (offered!=0)) {
7206                 return WERR_INVALID_PARAM;
7207         }
7208
7209         if (offered > MAX_RPC_DATA_SIZE) {
7210                 return WERR_INVALID_PARAM;
7211         }
7212
7213         rpcbuf_move(q_u->buffer, &r_u->buffer);
7214         buffer = r_u->buffer;
7215
7216         DEBUG(4,("_spoolss_enumprinterdrivers\n"));
7217
7218         *needed   = 0;
7219         *returned = 0;
7220
7221         unistr2_to_ascii(architecture, &q_u->environment, sizeof(architecture));
7222         unistr2_to_ascii(servername, &q_u->name, sizeof(servername));
7223
7224         cservername = canon_servername(servername);
7225
7226         if (!is_myname_or_ipaddr(cservername))
7227                 return WERR_UNKNOWN_PRINTER_DRIVER;
7228
7229         switch (level) {
7230         case 1:
7231                 return enumprinterdrivers_level1(cservername, architecture, buffer, offered, needed, returned);
7232         case 2:
7233                 return enumprinterdrivers_level2(cservername, architecture, buffer, offered, needed, returned);
7234         case 3:
7235                 return enumprinterdrivers_level3(cservername, architecture, buffer, offered, needed, returned);
7236         default:
7237                 return WERR_UNKNOWN_LEVEL;
7238         }
7239 }
7240
7241 /****************************************************************************
7242 ****************************************************************************/
7243
7244 static void fill_form_1(FORM_1 *form, nt_forms_struct *list)
7245 {
7246         form->flag=list->flag;
7247         init_unistr(&form->name, list->name);
7248         form->width=list->width;
7249         form->length=list->length;
7250         form->left=list->left;
7251         form->top=list->top;
7252         form->right=list->right;
7253         form->bottom=list->bottom;
7254 }
7255
7256 /****************************************************************************
7257 ****************************************************************************/
7258
7259 static WERROR fill_form_info_1(TALLOC_CTX *mem_ctx,
7260                                struct spoolss_FormInfo1 *form,
7261                                nt_forms_struct *list)
7262 {
7263         form->form_name         = talloc_strdup(mem_ctx, list->name);
7264         W_ERROR_HAVE_NO_MEMORY(form->form_name);
7265
7266         form->flags             = list->flag;
7267         form->size.width        = list->width;
7268         form->size.height       = list->length;
7269         form->area.left         = list->left;
7270         form->area.top          = list->top;
7271         form->area.right        = list->right;
7272         form->area.bottom       = list->bottom;
7273
7274         return WERR_OK;
7275 }
7276
7277 /****************************************************************************
7278 ****************************************************************************/
7279
7280 WERROR _spoolss_enumforms(pipes_struct *p, SPOOL_Q_ENUMFORMS *q_u, SPOOL_R_ENUMFORMS *r_u)
7281 {
7282         uint32 level = q_u->level;
7283         RPC_BUFFER *buffer = NULL;
7284         uint32 offered = q_u->offered;
7285         uint32 *needed = &r_u->needed;
7286         uint32 *numofforms = &r_u->numofforms;
7287         uint32 numbuiltinforms;
7288
7289         nt_forms_struct *list=NULL;
7290         nt_forms_struct *builtinlist=NULL;
7291         FORM_1 *forms_1;
7292         int buffer_size=0;
7293         int i;
7294
7295         /* that's an [in out] buffer */
7296
7297         if (!q_u->buffer && (offered!=0) ) {
7298                 return WERR_INVALID_PARAM;
7299         }
7300
7301         if (offered > MAX_RPC_DATA_SIZE) {
7302                 return WERR_INVALID_PARAM;
7303         }
7304
7305         rpcbuf_move(q_u->buffer, &r_u->buffer);
7306         buffer = r_u->buffer;
7307
7308         DEBUG(4,("_spoolss_enumforms\n"));
7309         DEBUGADD(5,("Offered buffer size [%d]\n", offered));
7310         DEBUGADD(5,("Info level [%d]\n",          level));
7311
7312         numbuiltinforms = get_builtin_ntforms(&builtinlist);
7313         DEBUGADD(5,("Number of builtin forms [%d]\n",     numbuiltinforms));
7314         *numofforms = get_ntforms(&list);
7315         DEBUGADD(5,("Number of user forms [%d]\n",     *numofforms));
7316         *numofforms += numbuiltinforms;
7317
7318         if (*numofforms == 0) {
7319                 SAFE_FREE(builtinlist);
7320                 SAFE_FREE(list);
7321                 return WERR_NO_MORE_ITEMS;
7322         }
7323
7324         switch (level) {
7325         case 1:
7326                 if ((forms_1=SMB_MALLOC_ARRAY(FORM_1, *numofforms)) == NULL) {
7327                         SAFE_FREE(builtinlist);
7328                         SAFE_FREE(list);
7329                         *numofforms=0;
7330                         return WERR_NOMEM;
7331                 }
7332
7333                 /* construct the list of form structures */
7334                 for (i=0; i<numbuiltinforms; i++) {
7335                         DEBUGADD(6,("Filling form number [%d]\n",i));
7336                         fill_form_1(&forms_1[i], &builtinlist[i]);
7337                 }
7338
7339                 SAFE_FREE(builtinlist);
7340
7341                 for (; i<*numofforms; i++) {
7342                         DEBUGADD(6,("Filling form number [%d]\n",i));
7343                         fill_form_1(&forms_1[i], &list[i-numbuiltinforms]);
7344                 }
7345
7346                 SAFE_FREE(list);
7347
7348                 /* check the required size. */
7349                 for (i=0; i<numbuiltinforms; i++) {
7350                         DEBUGADD(6,("adding form [%d]'s size\n",i));
7351                         buffer_size += spoolss_size_form_1(&forms_1[i]);
7352                 }
7353                 for (; i<*numofforms; i++) {
7354                         DEBUGADD(6,("adding form [%d]'s size\n",i));
7355                         buffer_size += spoolss_size_form_1(&forms_1[i]);
7356                 }
7357
7358                 *needed=buffer_size;
7359
7360                 if (*needed > offered) {
7361                         SAFE_FREE(forms_1);
7362                         *numofforms=0;
7363                         return WERR_INSUFFICIENT_BUFFER;
7364                 }
7365
7366                 if (!rpcbuf_alloc_size(buffer, buffer_size)){
7367                         SAFE_FREE(forms_1);
7368                         *numofforms=0;
7369                         return WERR_NOMEM;
7370                 }
7371
7372                 /* fill the buffer with the form structures */
7373                 for (i=0; i<numbuiltinforms; i++) {
7374                         DEBUGADD(6,("adding form [%d] to buffer\n",i));
7375                         smb_io_form_1("", buffer, &forms_1[i], 0);
7376                 }
7377                 for (; i<*numofforms; i++) {
7378                         DEBUGADD(6,("adding form [%d] to buffer\n",i));
7379                         smb_io_form_1("", buffer, &forms_1[i], 0);
7380                 }
7381
7382                 SAFE_FREE(forms_1);
7383
7384                 return WERR_OK;
7385
7386         default:
7387                 SAFE_FREE(list);
7388                 SAFE_FREE(builtinlist);
7389                 return WERR_UNKNOWN_LEVEL;
7390         }
7391 }
7392
7393 /****************************************************************
7394  _spoolss_GetForm
7395 ****************************************************************/
7396
7397 WERROR _spoolss_GetForm(pipes_struct *p,
7398                         struct spoolss_GetForm *r)
7399 {
7400         uint32 level = r->in.level;
7401         uint32 offered = r->in.offered;
7402         uint32 *needed = r->out.needed;
7403
7404         nt_forms_struct *list=NULL;
7405         nt_forms_struct builtin_form;
7406         bool foundBuiltin;
7407         union spoolss_FormInfo info;
7408         struct spoolss_FormInfo1 form_1;
7409         int numofforms=0, i=0;
7410
7411         /* that's an [in out] buffer */
7412
7413         if (!r->in.buffer && (offered!=0)) {
7414                 return WERR_INVALID_PARAM;
7415         }
7416
7417         DEBUG(4,("_spoolss_GetForm\n"));
7418         DEBUGADD(5,("Offered buffer size [%d]\n", offered));
7419         DEBUGADD(5,("Info level [%d]\n",          level));
7420
7421         foundBuiltin = get_a_builtin_ntform_by_string(r->in.form_name, &builtin_form);
7422         if (!foundBuiltin) {
7423                 numofforms = get_ntforms(&list);
7424                 DEBUGADD(5,("Number of forms [%d]\n",     numofforms));
7425
7426                 if (numofforms == 0)
7427                         return WERR_BADFID;
7428         }
7429
7430         ZERO_STRUCT(form_1);
7431
7432         switch (level) {
7433         case 1:
7434                 if (foundBuiltin) {
7435                         fill_form_info_1(p->mem_ctx, &form_1, &builtin_form);
7436                 } else {
7437
7438                         /* Check if the requested name is in the list of form structures */
7439                         for (i=0; i<numofforms; i++) {
7440
7441                                 DEBUG(4,("_spoolss_GetForm: checking form %s (want %s)\n",
7442                                         list[i].name, r->in.form_name));
7443
7444                                 if (strequal(r->in.form_name, list[i].name)) {
7445                                         DEBUGADD(6,("Found form %s number [%d]\n",
7446                                                 r->in.form_name, i));
7447                                         fill_form_info_1(p->mem_ctx, &form_1, &list[i]);
7448                                         break;
7449                                 }
7450                         }
7451
7452                         SAFE_FREE(list);
7453                         if (i == numofforms) {
7454                                 return WERR_BADFID;
7455                         }
7456                 }
7457                 /* check the required size. */
7458
7459                 info.info1 = form_1;
7460
7461                 *needed = ndr_size_spoolss_FormInfo(&info, 1, NULL, 0);
7462
7463                 if (*needed > offered) {
7464                         r->out.info = NULL;
7465                         return WERR_INSUFFICIENT_BUFFER;
7466                 }
7467
7468                 r->out.info->info1 = form_1;
7469
7470                 /* fill the buffer with the form structures */
7471                 DEBUGADD(6,("adding form %s [%d] to buffer\n",
7472                         r->in.form_name, i));
7473
7474                 return WERR_OK;
7475
7476         default:
7477                 SAFE_FREE(list);
7478                 return WERR_UNKNOWN_LEVEL;
7479         }
7480 }
7481
7482 /****************************************************************************
7483 ****************************************************************************/
7484
7485 static void fill_port_1(PORT_INFO_1 *port, const char *name)
7486 {
7487         init_unistr(&port->port_name, name);
7488 }
7489
7490 /****************************************************************************
7491  TODO: This probably needs distinguish between TCP/IP and Local ports
7492  somehow.
7493 ****************************************************************************/
7494
7495 static void fill_port_2(PORT_INFO_2 *port, const char *name)
7496 {
7497         init_unistr(&port->port_name, name);
7498         init_unistr(&port->monitor_name, "Local Monitor");
7499         init_unistr(&port->description, SPL_LOCAL_PORT );
7500         port->port_type=PORT_TYPE_WRITE;
7501         port->reserved=0x0;
7502 }
7503
7504
7505 /****************************************************************************
7506  wrapper around the enumer ports command
7507 ****************************************************************************/
7508
7509 WERROR enumports_hook(TALLOC_CTX *ctx, int *count, char ***lines )
7510 {
7511         char *cmd = lp_enumports_cmd();
7512         char **qlines = NULL;
7513         char *command = NULL;
7514         int numlines;
7515         int ret;
7516         int fd;
7517
7518         *count = 0;
7519         *lines = NULL;
7520
7521         /* if no hook then just fill in the default port */
7522
7523         if ( !*cmd ) {
7524                 if (!(qlines = TALLOC_ARRAY( NULL, char*, 2 ))) {
7525                         return WERR_NOMEM;
7526                 }
7527                 if (!(qlines[0] = talloc_strdup(qlines, SAMBA_PRINTER_PORT_NAME ))) {
7528                         TALLOC_FREE(qlines);
7529                         return WERR_NOMEM;
7530                 }
7531                 qlines[1] = NULL;
7532                 numlines = 1;
7533         }
7534         else {
7535                 /* we have a valid enumport command */
7536
7537                 command = talloc_asprintf(ctx, "%s \"%d\"", cmd, 1);
7538                 if (!command) {
7539                         return WERR_NOMEM;
7540                 }
7541
7542                 DEBUG(10,("Running [%s]\n", command));
7543                 ret = smbrun(command, &fd);
7544                 DEBUG(10,("Returned [%d]\n", ret));
7545                 TALLOC_FREE(command);
7546                 if (ret != 0) {
7547                         if (fd != -1) {
7548                                 close(fd);
7549                         }
7550                         return WERR_ACCESS_DENIED;
7551                 }
7552
7553                 numlines = 0;
7554                 qlines = fd_lines_load(fd, &numlines, 0, NULL);
7555                 DEBUGADD(10,("Lines returned = [%d]\n", numlines));
7556                 close(fd);
7557         }
7558
7559         *count = numlines;
7560         *lines = qlines;
7561
7562         return WERR_OK;
7563 }
7564
7565 /****************************************************************************
7566  enumports level 1.
7567 ****************************************************************************/
7568
7569 static WERROR enumports_level_1(RPC_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
7570 {
7571         PORT_INFO_1 *ports=NULL;
7572         int i=0;
7573         WERROR result = WERR_OK;
7574         char **qlines = NULL;
7575         int numlines = 0;
7576
7577         result = enumports_hook(talloc_tos(), &numlines, &qlines );
7578         if (!W_ERROR_IS_OK(result)) {
7579                 TALLOC_FREE(qlines);
7580                 return result;
7581         }
7582
7583         if(numlines) {
7584                 if((ports=SMB_MALLOC_ARRAY( PORT_INFO_1, numlines )) == NULL) {
7585                         DEBUG(10,("Returning WERR_NOMEM [%s]\n",
7586                                   win_errstr(WERR_NOMEM)));
7587                         TALLOC_FREE(qlines);
7588                         return WERR_NOMEM;
7589                 }
7590
7591                 for (i=0; i<numlines; i++) {
7592                         DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
7593                         fill_port_1(&ports[i], qlines[i]);
7594                 }
7595         }
7596         TALLOC_FREE(qlines);
7597
7598         *returned = numlines;
7599
7600         /* check the required size. */
7601         for (i=0; i<*returned; i++) {
7602                 DEBUGADD(6,("adding port [%d]'s size\n", i));
7603                 *needed += spoolss_size_port_info_1(&ports[i]);
7604         }
7605
7606         if (*needed > offered) {
7607                 result = WERR_INSUFFICIENT_BUFFER;
7608                 goto out;
7609         }
7610
7611         if (!rpcbuf_alloc_size(buffer, *needed)) {
7612                 result = WERR_NOMEM;
7613                 goto out;
7614         }
7615
7616         /* fill the buffer with the ports structures */
7617         for (i=0; i<*returned; i++) {
7618                 DEBUGADD(6,("adding port [%d] to buffer\n", i));
7619                 smb_io_port_1("", buffer, &ports[i], 0);
7620         }
7621
7622 out:
7623         SAFE_FREE(ports);
7624
7625         if ( !W_ERROR_IS_OK(result) )
7626                 *returned = 0;
7627
7628         return result;
7629 }
7630
7631 /****************************************************************************
7632  enumports level 2.
7633 ****************************************************************************/
7634
7635 static WERROR enumports_level_2(RPC_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
7636 {
7637         PORT_INFO_2 *ports=NULL;
7638         int i=0;
7639         WERROR result = WERR_OK;
7640         char **qlines = NULL;
7641         int numlines = 0;
7642
7643         result = enumports_hook(talloc_tos(), &numlines, &qlines );
7644         if ( !W_ERROR_IS_OK(result)) {
7645                 TALLOC_FREE(qlines);
7646                 return result;
7647         }
7648
7649         if(numlines) {
7650                 if((ports=SMB_MALLOC_ARRAY( PORT_INFO_2, numlines)) == NULL) {
7651                         TALLOC_FREE(qlines);
7652                         return WERR_NOMEM;
7653                 }
7654
7655                 for (i=0; i<numlines; i++) {
7656                         DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
7657                         fill_port_2(&(ports[i]), qlines[i]);
7658                 }
7659         }
7660
7661         TALLOC_FREE(qlines);
7662
7663         *returned = numlines;
7664
7665         /* check the required size. */
7666         for (i=0; i<*returned; i++) {
7667                 DEBUGADD(6,("adding port [%d]'s size\n", i));
7668                 *needed += spoolss_size_port_info_2(&ports[i]);
7669         }
7670
7671         if (*needed > offered) {
7672                 result = WERR_INSUFFICIENT_BUFFER;
7673                 goto out;
7674         }
7675
7676         if (!rpcbuf_alloc_size(buffer, *needed)) {
7677                 result = WERR_NOMEM;
7678                 goto out;
7679         }
7680
7681         /* fill the buffer with the ports structures */
7682         for (i=0; i<*returned; i++) {
7683                 DEBUGADD(6,("adding port [%d] to buffer\n", i));
7684                 smb_io_port_2("", buffer, &ports[i], 0);
7685         }
7686
7687 out:
7688         SAFE_FREE(ports);
7689
7690         if ( !W_ERROR_IS_OK(result) )
7691                 *returned = 0;
7692
7693         return result;
7694 }
7695
7696 /****************************************************************************
7697  enumports.
7698 ****************************************************************************/
7699
7700 WERROR _spoolss_enumports( pipes_struct *p, SPOOL_Q_ENUMPORTS *q_u, SPOOL_R_ENUMPORTS *r_u)
7701 {
7702         uint32 level = q_u->level;
7703         RPC_BUFFER *buffer = NULL;
7704         uint32 offered = q_u->offered;
7705         uint32 *needed = &r_u->needed;
7706         uint32 *returned = &r_u->returned;
7707
7708         /* that's an [in out] buffer */
7709
7710         if (!q_u->buffer && (offered!=0)) {
7711                 return WERR_INVALID_PARAM;
7712         }
7713
7714         if (offered > MAX_RPC_DATA_SIZE) {
7715                 return WERR_INVALID_PARAM;
7716         }
7717
7718         rpcbuf_move(q_u->buffer, &r_u->buffer);
7719         buffer = r_u->buffer;
7720
7721         DEBUG(4,("_spoolss_enumports\n"));
7722
7723         *returned=0;
7724         *needed=0;
7725
7726         switch (level) {
7727         case 1:
7728                 return enumports_level_1(buffer, offered, needed, returned);
7729         case 2:
7730                 return enumports_level_2(buffer, offered, needed, returned);
7731         default:
7732                 return WERR_UNKNOWN_LEVEL;
7733         }
7734 }
7735
7736 /****************************************************************************
7737 ****************************************************************************/
7738
7739 static WERROR spoolss_addprinterex_level_2(pipes_struct *p,
7740                                            const char *server,
7741                                            struct spoolss_SetPrinterInfoCtr *info_ctr,
7742                                            struct spoolss_DeviceMode *devmode,
7743                                            struct security_descriptor *sec_desc,
7744                                            struct spoolss_UserLevelCtr *user_ctr,
7745                                            POLICY_HND *handle)
7746 {
7747         NT_PRINTER_INFO_LEVEL *printer = NULL;
7748         fstring name;
7749         int     snum;
7750         WERROR err = WERR_OK;
7751
7752         if ( !(printer = TALLOC_ZERO_P(NULL, NT_PRINTER_INFO_LEVEL)) ) {
7753                 DEBUG(0,("spoolss_addprinterex_level_2: malloc fail.\n"));
7754                 return WERR_NOMEM;
7755         }
7756
7757         /* convert from UNICODE to ASCII - this allocates the info_2 struct inside *printer.*/
7758         if (!convert_printer_info_new(info_ctr, printer)) {
7759                 free_a_printer(&printer, 2);
7760                 return WERR_NOMEM;
7761         }
7762
7763         /* check to see if the printer already exists */
7764
7765         if ((snum = print_queue_snum(printer->info_2->sharename)) != -1) {
7766                 DEBUG(5, ("spoolss_addprinterex_level_2: Attempted to add a printer named [%s] when one already existed!\n",
7767                         printer->info_2->sharename));
7768                 free_a_printer(&printer, 2);
7769                 return WERR_PRINTER_ALREADY_EXISTS;
7770         }
7771
7772         /* FIXME!!!  smbd should check to see if the driver is installed before
7773            trying to add a printer like this  --jerry */
7774
7775         if (*lp_addprinter_cmd() ) {
7776                 if ( !add_printer_hook(p->mem_ctx, p->server_info->ptok,
7777                                        printer) ) {
7778                         free_a_printer(&printer,2);
7779                         return WERR_ACCESS_DENIED;
7780                 }
7781         } else {
7782                 DEBUG(0,("spoolss_addprinterex_level_2: add printer for printer %s called and no"
7783                         "smb.conf parameter \"addprinter command\" is defined. This"
7784                         "parameter must exist for this call to succeed\n",
7785                         printer->info_2->sharename ));
7786         }
7787
7788         /* use our primary netbios name since get_a_printer() will convert
7789            it to what the client expects on a case by case basis */
7790
7791         slprintf(name, sizeof(name)-1, "\\\\%s\\%s", global_myname(),
7792              printer->info_2->sharename);
7793
7794
7795         if ((snum = print_queue_snum(printer->info_2->sharename)) == -1) {
7796                 free_a_printer(&printer,2);
7797                 return WERR_ACCESS_DENIED;
7798         }
7799
7800         /* you must be a printer admin to add a new printer */
7801         if (!print_access_check(NULL, snum, PRINTER_ACCESS_ADMINISTER)) {
7802                 free_a_printer(&printer,2);
7803                 return WERR_ACCESS_DENIED;
7804         }
7805
7806         /*
7807          * Do sanity check on the requested changes for Samba.
7808          */
7809
7810         if (!check_printer_ok(printer->info_2, snum)) {
7811                 free_a_printer(&printer,2);
7812                 return WERR_INVALID_PARAM;
7813         }
7814
7815         /*
7816          * When a printer is created, the drivername bound to the printer is used
7817          * to lookup previously saved driver initialization info, which is then
7818          * bound to the new printer, simulating what happens in the Windows arch.
7819          */
7820
7821         if (!devmode)
7822         {
7823                 set_driver_init(printer, 2);
7824         }
7825         else
7826         {
7827                 /* A valid devmode was included, convert and link it
7828                 */
7829                 DEBUGADD(10, ("spoolss_addprinterex_level_2: devmode included, converting\n"));
7830
7831                 if (!convert_devicemode_new(printer->info_2->printername,
7832                                             devmode,
7833                                             &printer->info_2->devmode))
7834                         return  WERR_NOMEM;
7835         }
7836
7837         /* write the ASCII on disk */
7838         err = mod_a_printer(printer, 2);
7839         if (!W_ERROR_IS_OK(err)) {
7840                 free_a_printer(&printer,2);
7841                 return err;
7842         }
7843
7844         if (!open_printer_hnd(p, handle, name, PRINTER_ACCESS_ADMINISTER)) {
7845                 /* Handle open failed - remove addition. */
7846                 del_a_printer(printer->info_2->sharename);
7847                 free_a_printer(&printer,2);
7848                 ZERO_STRUCTP(handle);
7849                 return WERR_ACCESS_DENIED;
7850         }
7851
7852         update_c_setprinter(False);
7853         free_a_printer(&printer,2);
7854
7855         return WERR_OK;
7856 }
7857
7858 /****************************************************************
7859  _spoolss_AddPrinterEx
7860 ****************************************************************/
7861
7862 WERROR _spoolss_AddPrinterEx(pipes_struct *p,
7863                              struct spoolss_AddPrinterEx *r)
7864 {
7865         switch (r->in.info_ctr->level) {
7866         case 1:
7867                 /* we don't handle yet */
7868                 /* but I know what to do ... */
7869                 return WERR_UNKNOWN_LEVEL;
7870         case 2:
7871                 return spoolss_addprinterex_level_2(p, r->in.server,
7872                                                     r->in.info_ctr,
7873                                                     r->in.devmode_ctr->devmode,
7874                                                     r->in.secdesc_ctr->sd,
7875                                                     r->in.userlevel_ctr,
7876                                                     r->out.handle);
7877         default:
7878                 return WERR_UNKNOWN_LEVEL;
7879         }
7880 }
7881
7882 /****************************************************************
7883  _spoolss_AddPrinterDriver
7884 ****************************************************************/
7885
7886 WERROR _spoolss_AddPrinterDriver(pipes_struct *p,
7887                                  struct spoolss_AddPrinterDriver *r)
7888 {
7889         uint32_t level = r->in.info_ctr->level;
7890         struct spoolss_AddDriverInfoCtr *info = r->in.info_ctr;
7891         WERROR err = WERR_OK;
7892         NT_PRINTER_DRIVER_INFO_LEVEL driver;
7893         fstring driver_name;
7894         uint32 version;
7895         const char *fn;
7896
7897         switch (p->hdr_req.opnum) {
7898                 case NDR_SPOOLSS_ADDPRINTERDRIVER:
7899                         fn = "_spoolss_AddPrinterDriver";
7900                         break;
7901                 case NDR_SPOOLSS_ADDPRINTERDRIVEREX:
7902                         fn = "_spoolss_AddPrinterDriverEx";
7903                         break;
7904                 default:
7905                         return WERR_INVALID_PARAM;
7906         }
7907
7908
7909         /* FIXME */
7910         if (level != 3 && level != 6) {
7911                 /* Clever hack from Martin Zielinski <mz@seh.de>
7912                  * to allow downgrade from level 8 (Vista).
7913                  */
7914                 DEBUG(0,("%s: level %d not yet implemented\n", fn, level));
7915                 return WERR_UNKNOWN_LEVEL;
7916         }
7917
7918         ZERO_STRUCT(driver);
7919
7920         if (!convert_printer_driver_info(info, &driver, level)) {
7921                 err = WERR_NOMEM;
7922                 goto done;
7923         }
7924
7925         DEBUG(5,("Cleaning driver's information\n"));
7926         err = clean_up_driver_struct(p, driver, level);
7927         if (!W_ERROR_IS_OK(err))
7928                 goto done;
7929
7930         DEBUG(5,("Moving driver to final destination\n"));
7931         if( !W_ERROR_IS_OK(err = move_driver_to_download_area(p, driver, level,
7932                                                               &err)) ) {
7933                 goto done;
7934         }
7935
7936         if (add_a_printer_driver(driver, level)!=0) {
7937                 err = WERR_ACCESS_DENIED;
7938                 goto done;
7939         }
7940
7941         switch(level) {
7942         case 3:
7943                 fstrcpy(driver_name,
7944                         driver.info_3->name ? driver.info_3->name : "");
7945                 break;
7946         case 6:
7947                 fstrcpy(driver_name,
7948                         driver.info_6->name ?  driver.info_6->name : "");
7949                 break;
7950         }
7951
7952         /*
7953          * I think this is where he DrvUpgradePrinter() hook would be
7954          * be called in a driver's interface DLL on a Windows NT 4.0/2k
7955          * server.  Right now, we just need to send ourselves a message
7956          * to update each printer bound to this driver.   --jerry
7957          */
7958
7959         if (!srv_spoolss_drv_upgrade_printer(driver_name)) {
7960                 DEBUG(0,("%s: Failed to send message about upgrading driver [%s]!\n",
7961                         fn, driver_name));
7962         }
7963
7964         /*
7965          * Based on the version (e.g. driver destination dir: 0=9x,2=Nt/2k,3=2k/Xp),
7966          * decide if the driver init data should be deleted. The rules are:
7967          *  1) never delete init data if it is a 9x driver, they don't use it anyway
7968          *  2) delete init data only if there is no 2k/Xp driver
7969          *  3) always delete init data
7970          * The generalized rule is always use init data from the highest order driver.
7971          * It is necessary to follow the driver install by an initialization step to
7972          * finish off this process.
7973         */
7974         if (level == 3)
7975                 version = driver.info_3->cversion;
7976         else if (level == 6)
7977                 version = driver.info_6->version;
7978         else
7979                 version = -1;
7980         switch (version) {
7981                 /*
7982                  * 9x printer driver - never delete init data
7983                 */
7984                 case 0:
7985                         DEBUG(10,("%s: init data not deleted for 9x driver [%s]\n",
7986                                 fn, driver_name));
7987                         break;
7988
7989                 /*
7990                  * Nt or 2k (compatiblity mode) printer driver - only delete init data if
7991                  * there is no 2k/Xp driver init data for this driver name.
7992                 */
7993                 case 2:
7994                 {
7995                         NT_PRINTER_DRIVER_INFO_LEVEL driver1;
7996
7997                         if (!W_ERROR_IS_OK(get_a_printer_driver(&driver1, 3, driver_name, "Windows NT x86", 3))) {
7998                                 /*
7999                                  * No 2k/Xp driver found, delete init data (if any) for the new Nt driver.
8000                                 */
8001                                 if (!del_driver_init(driver_name))
8002                                         DEBUG(6,("%s: del_driver_init(%s) Nt failed!\n",
8003                                                 fn, driver_name));
8004                         } else {
8005                                 /*
8006                                  * a 2k/Xp driver was found, don't delete init data because Nt driver will use it.
8007                                 */
8008                                 free_a_printer_driver(driver1,3);
8009                                 DEBUG(10,("%s: init data not deleted for Nt driver [%s]\n",
8010                                         fn, driver_name));
8011                         }
8012                 }
8013                 break;
8014
8015                 /*
8016                  * 2k or Xp printer driver - always delete init data
8017                 */
8018                 case 3:
8019                         if (!del_driver_init(driver_name))
8020                                 DEBUG(6,("%s: del_driver_init(%s) 2k/Xp failed!\n",
8021                                         fn, driver_name));
8022                         break;
8023
8024                 default:
8025                         DEBUG(0,("%s: invalid level=%d\n", fn, level));
8026                         break;
8027         }
8028
8029
8030 done:
8031         free_a_printer_driver(driver, level);
8032         return err;
8033 }
8034
8035 /****************************************************************
8036  _spoolss_AddPrinterDriverEx
8037 ****************************************************************/
8038
8039 WERROR _spoolss_AddPrinterDriverEx(pipes_struct *p,
8040                                    struct spoolss_AddPrinterDriverEx *r)
8041 {
8042         struct spoolss_AddPrinterDriver a;
8043
8044         /*
8045          * we only support the semantics of AddPrinterDriver()
8046          * i.e. only copy files that are newer than existing ones
8047          */
8048
8049         if (r->in.flags != APD_COPY_NEW_FILES) {
8050                 return WERR_ACCESS_DENIED;
8051         }
8052
8053         a.in.servername         = r->in.servername;
8054         a.in.info_ctr           = r->in.info_ctr;
8055
8056         return _spoolss_AddPrinterDriver(p, &a);
8057 }
8058
8059 /****************************************************************************
8060 ****************************************************************************/
8061
8062 struct _spoolss_paths {
8063         int type;
8064         const char *share;
8065         const char *dir;
8066 };
8067
8068 enum { SPOOLSS_DRIVER_PATH, SPOOLSS_PRTPROCS_PATH };
8069
8070 static const struct _spoolss_paths spoolss_paths[]= {
8071         { SPOOLSS_DRIVER_PATH,          "print$",       "DRIVERS" },
8072         { SPOOLSS_PRTPROCS_PATH,        "prnproc$",     "PRTPROCS" }
8073 };
8074
8075 static WERROR compose_spoolss_server_path(TALLOC_CTX *mem_ctx,
8076                                           const char *servername,
8077                                           const char *environment,
8078                                           int component,
8079                                           char **path)
8080 {
8081         const char *pservername = NULL;
8082         const char *long_archi = SPOOLSS_ARCHITECTURE_NT_X86;
8083         const char *short_archi;
8084
8085         *path = NULL;
8086
8087         /* environment may be empty */
8088         if (environment && strlen(environment)) {
8089                 long_archi = environment;
8090         }
8091
8092         /* servername may be empty */
8093         if (servername && strlen(servername)) {
8094                 pservername = canon_servername(servername);
8095
8096                 if (!is_myname_or_ipaddr(pservername)) {
8097                         return WERR_INVALID_PARAM;
8098                 }
8099         }
8100
8101         if (!(short_archi = get_short_archi(long_archi))) {
8102                 return WERR_INVALID_ENVIRONMENT;
8103         }
8104
8105         switch (component) {
8106         case SPOOLSS_PRTPROCS_PATH:
8107         case SPOOLSS_DRIVER_PATH:
8108                 if (pservername) {
8109                         *path = talloc_asprintf(mem_ctx,
8110                                         "\\\\%s\\%s\\%s",
8111                                         pservername,
8112                                         spoolss_paths[component].share,
8113                                         short_archi);
8114                 } else {
8115                         *path = talloc_asprintf(mem_ctx, "%s\\%s\\%s",
8116                                         SPOOLSS_DEFAULT_SERVER_PATH,
8117                                         spoolss_paths[component].dir,
8118                                         short_archi);
8119                 }
8120                 break;
8121         default:
8122                 return WERR_INVALID_PARAM;
8123         }
8124
8125         if (!*path) {
8126                 return WERR_NOMEM;
8127         }
8128
8129         return WERR_OK;
8130 }
8131
8132 /****************************************************************************
8133 ****************************************************************************/
8134
8135 static WERROR getprinterdriverdir_level_1(TALLOC_CTX *mem_ctx,
8136                                           const char *servername,
8137                                           const char *environment,
8138                                           struct spoolss_DriverDirectoryInfo1 *r,
8139                                           uint32_t offered,
8140                                           uint32_t *needed)
8141 {
8142         WERROR werr;
8143         char *path = NULL;
8144
8145         werr = compose_spoolss_server_path(mem_ctx,
8146                                            servername,
8147                                            environment,
8148                                            SPOOLSS_DRIVER_PATH,
8149                                            &path);
8150         if (!W_ERROR_IS_OK(werr)) {
8151                 return werr;
8152         }
8153
8154         DEBUG(4,("printer driver directory: [%s]\n", path));
8155
8156         r->directory_name = path;
8157
8158         *needed += ndr_size_spoolss_DriverDirectoryInfo1(r, NULL, 0);
8159
8160         if (*needed > offered) {
8161                 talloc_free(path);
8162                 return WERR_INSUFFICIENT_BUFFER;
8163         }
8164
8165         return WERR_OK;
8166 }
8167
8168 /****************************************************************
8169  _spoolss_GetPrinterDriverDirectory
8170 ****************************************************************/
8171
8172 WERROR _spoolss_GetPrinterDriverDirectory(pipes_struct *p,
8173                                           struct spoolss_GetPrinterDriverDirectory *r)
8174 {
8175         WERROR werror;
8176
8177         /* that's an [in out] buffer */
8178
8179         if (!r->in.buffer && (r->in.offered != 0)) {
8180                 return WERR_INVALID_PARAM;
8181         }
8182
8183         DEBUG(5,("_spoolss_GetPrinterDriverDirectory: level %d\n",
8184                 r->in.level));
8185
8186         *r->out.needed = 0;
8187
8188         /* r->in.level is ignored */
8189
8190         werror = getprinterdriverdir_level_1(p->mem_ctx,
8191                                              r->in.server,
8192                                              r->in.environment,
8193                                              &r->out.info->info1,
8194                                              r->in.offered,
8195                                              r->out.needed);
8196         if (!W_ERROR_IS_OK(werror)) {
8197                 TALLOC_FREE(r->out.info);
8198         }
8199
8200         return werror;
8201 }
8202
8203 /****************************************************************************
8204 ****************************************************************************/
8205
8206 WERROR _spoolss_enumprinterdata(pipes_struct *p, SPOOL_Q_ENUMPRINTERDATA *q_u, SPOOL_R_ENUMPRINTERDATA *r_u)
8207 {
8208         POLICY_HND *handle = &q_u->handle;
8209         uint32 idx               = q_u->index;
8210         uint32 in_value_len      = q_u->valuesize;
8211         uint32 in_data_len       = q_u->datasize;
8212         uint32 *out_max_value_len = &r_u->valuesize;
8213         uint16 **out_value       = &r_u->value;
8214         uint32 *out_value_len    = &r_u->realvaluesize;
8215         uint32 *out_type         = &r_u->type;
8216         uint32 *out_max_data_len = &r_u->datasize;
8217         uint8  **data_out        = &r_u->data;
8218         uint32 *out_data_len     = &r_u->realdatasize;
8219
8220         NT_PRINTER_INFO_LEVEL *printer = NULL;
8221
8222         uint32          biggest_valuesize;
8223         uint32          biggest_datasize;
8224         uint32          data_len;
8225         Printer_entry   *Printer = find_printer_index_by_hnd(p, handle);
8226         int             snum;
8227         WERROR          result;
8228         REGISTRY_VALUE  *val = NULL;
8229         NT_PRINTER_DATA *p_data;
8230         int             i, key_index, num_values;
8231         int             name_length;
8232
8233         *out_type = 0;
8234
8235         *out_max_data_len = 0;
8236         *data_out         = NULL;
8237         *out_data_len     = 0;
8238
8239         DEBUG(5,("spoolss_enumprinterdata\n"));
8240
8241         if (!Printer) {
8242                 DEBUG(2,("_spoolss_enumprinterdata: Invalid handle (%s:%u:%u).\n", OUR_HANDLE(handle)));
8243                 return WERR_BADFID;
8244         }
8245
8246         if (!get_printer_snum(p,handle, &snum, NULL))
8247                 return WERR_BADFID;
8248
8249         result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8250         if (!W_ERROR_IS_OK(result))
8251                 return result;
8252
8253         p_data = printer->info_2->data;
8254         key_index = lookup_printerkey( p_data, SPOOL_PRINTERDATA_KEY );
8255
8256         result = WERR_OK;
8257
8258         /*
8259          * The NT machine wants to know the biggest size of value and data
8260          *
8261          * cf: MSDN EnumPrinterData remark section
8262          */
8263
8264         if ( !in_value_len && !in_data_len && (key_index != -1) )
8265         {
8266                 DEBUGADD(6,("Activating NT mega-hack to find sizes\n"));
8267
8268                 biggest_valuesize = 0;
8269                 biggest_datasize  = 0;
8270
8271                 num_values = regval_ctr_numvals( p_data->keys[key_index].values );
8272
8273                 for ( i=0; i<num_values; i++ )
8274                 {
8275                         val = regval_ctr_specific_value( p_data->keys[key_index].values, i );
8276
8277                         name_length = strlen(val->valuename);
8278                         if ( strlen(val->valuename) > biggest_valuesize )
8279                                 biggest_valuesize = name_length;
8280
8281                         if ( val->size > biggest_datasize )
8282                                 biggest_datasize = val->size;
8283
8284                         DEBUG(6,("current values: [%d], [%d]\n", biggest_valuesize,
8285                                 biggest_datasize));
8286                 }
8287
8288                 /* the value is an UNICODE string but real_value_size is the length
8289                    in bytes including the trailing 0 */
8290
8291                 *out_value_len = 2 * (1+biggest_valuesize);
8292                 *out_data_len  = biggest_datasize;
8293
8294                 DEBUG(6,("final values: [%d], [%d]\n", *out_value_len, *out_data_len));
8295
8296                 goto done;
8297         }
8298
8299         /*
8300          * the value len is wrong in NT sp3
8301          * that's the number of bytes not the number of unicode chars
8302          */
8303
8304         if ( key_index != -1 )
8305                 val = regval_ctr_specific_value( p_data->keys[key_index].values, idx );
8306
8307         if ( !val )
8308         {
8309
8310                 /* out_value should default to "" or else NT4 has
8311                    problems unmarshalling the response */
8312
8313                 *out_max_value_len=(in_value_len/sizeof(uint16));
8314
8315                 if (in_value_len) {
8316                         if((*out_value=(uint16 *)TALLOC_ZERO(p->mem_ctx, in_value_len*sizeof(uint8))) == NULL)
8317                         {
8318                                 result = WERR_NOMEM;
8319                                 goto done;
8320                         }
8321                         *out_value_len = (uint32)rpcstr_push((char *)*out_value, "", in_value_len, 0);
8322                 } else {
8323                         *out_value=NULL;
8324                         *out_value_len = 0;
8325                 }
8326
8327                 /* the data is counted in bytes */
8328
8329                 *out_max_data_len = in_data_len;
8330                 *out_data_len     = in_data_len;
8331
8332                 /* only allocate when given a non-zero data_len */
8333
8334                 if ( in_data_len && ((*data_out=(uint8 *)TALLOC_ZERO(p->mem_ctx, in_data_len*sizeof(uint8))) == NULL) )
8335                 {
8336                         result = WERR_NOMEM;
8337                         goto done;
8338                 }
8339
8340                 result = WERR_NO_MORE_ITEMS;
8341         }
8342         else
8343         {
8344                 /*
8345                  * the value is:
8346                  * - counted in bytes in the request
8347                  * - counted in UNICODE chars in the max reply
8348                  * - counted in bytes in the real size
8349                  *
8350                  * take a pause *before* coding not *during* coding
8351                  */
8352
8353                 /* name */
8354                 *out_max_value_len=(in_value_len/sizeof(uint16));
8355                 if (in_value_len) {
8356                         if ( (*out_value = (uint16 *)TALLOC_ZERO(p->mem_ctx, in_value_len*sizeof(uint8))) == NULL )
8357                         {
8358                                 result = WERR_NOMEM;
8359                                 goto done;
8360                         }
8361
8362                         *out_value_len = (uint32)rpcstr_push((char *)*out_value, regval_name(val), (size_t)in_value_len, 0);
8363                 } else {
8364                         *out_value = NULL;
8365                         *out_value_len = 0;
8366                 }
8367
8368                 /* type */
8369
8370                 *out_type = regval_type( val );
8371
8372                 /* data - counted in bytes */
8373
8374                 *out_max_data_len = in_data_len;
8375                 if ( in_data_len && (*data_out = (uint8 *)TALLOC_ZERO(p->mem_ctx, in_data_len*sizeof(uint8))) == NULL)
8376                 {
8377                         result = WERR_NOMEM;
8378                         goto done;
8379                 }
8380                 data_len = regval_size(val);
8381                 if ( *data_out && data_len )
8382                         memcpy( *data_out, regval_data_p(val), data_len );
8383                 *out_data_len = data_len;
8384         }
8385
8386 done:
8387         free_a_printer(&printer, 2);
8388         return result;
8389 }
8390
8391 /****************************************************************************
8392 ****************************************************************************/
8393
8394 WERROR _spoolss_setprinterdata( pipes_struct *p, SPOOL_Q_SETPRINTERDATA *q_u, SPOOL_R_SETPRINTERDATA *r_u)
8395 {
8396         POLICY_HND              *handle = &q_u->handle;
8397         UNISTR2                 *value = &q_u->value;
8398         uint32                  type = q_u->type;
8399         uint8                   *data = q_u->data;
8400         uint32                  real_len = q_u->real_len;
8401
8402         NT_PRINTER_INFO_LEVEL   *printer = NULL;
8403         int                     snum=0;
8404         WERROR                  status = WERR_OK;
8405         Printer_entry           *Printer=find_printer_index_by_hnd(p, handle);
8406         fstring                 valuename;
8407
8408         DEBUG(5,("spoolss_setprinterdata\n"));
8409
8410         if (!Printer) {
8411                 DEBUG(2,("_spoolss_setprinterdata: Invalid handle (%s:%u:%u).\n", OUR_HANDLE(handle)));
8412                 return WERR_BADFID;
8413         }
8414
8415         if ( Printer->printer_type == SPLHND_SERVER ) {
8416                 DEBUG(10,("_spoolss_setprinterdata: Not implemented for server handles yet\n"));
8417                 return WERR_INVALID_PARAM;
8418         }
8419
8420         if (!get_printer_snum(p,handle, &snum, NULL))
8421                 return WERR_BADFID;
8422
8423         /*
8424          * Access check : NT returns "access denied" if you make a
8425          * SetPrinterData call without the necessary privildge.
8426          * we were originally returning OK if nothing changed
8427          * which made Win2k issue **a lot** of SetPrinterData
8428          * when connecting to a printer  --jerry
8429          */
8430
8431         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER)
8432         {
8433                 DEBUG(3, ("_spoolss_setprinterdata: change denied by handle access permissions\n"));
8434                 status = WERR_ACCESS_DENIED;
8435                 goto done;
8436         }
8437
8438         status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8439         if (!W_ERROR_IS_OK(status))
8440                 return status;
8441
8442         unistr2_to_ascii(valuename, value, sizeof(valuename));
8443
8444         /*
8445          * When client side code sets a magic printer data key, detect it and save
8446          * the current printer data and the magic key's data (its the DEVMODE) for
8447          * future printer/driver initializations.
8448          */
8449         if ( (type == REG_BINARY) && strequal( valuename, PHANTOM_DEVMODE_KEY))
8450         {
8451                 /* Set devmode and printer initialization info */
8452                 status = save_driver_init( printer, 2, data, real_len );
8453
8454                 srv_spoolss_reset_printerdata( printer->info_2->drivername );
8455         }
8456         else
8457         {
8458         status = set_printer_dataex( printer, SPOOL_PRINTERDATA_KEY, valuename,
8459                                         type, data, real_len );
8460                 if ( W_ERROR_IS_OK(status) )
8461                         status = mod_a_printer(printer, 2);
8462         }
8463
8464 done:
8465         free_a_printer(&printer, 2);
8466
8467         return status;
8468 }
8469
8470 /****************************************************************
8471  _spoolss_ResetPrinter
8472 ****************************************************************/
8473
8474 WERROR _spoolss_ResetPrinter(pipes_struct *p,
8475                              struct spoolss_ResetPrinter *r)
8476 {
8477         POLICY_HND      *handle = r->in.handle;
8478         Printer_entry   *Printer=find_printer_index_by_hnd(p, handle);
8479         int             snum;
8480
8481         DEBUG(5,("_spoolss_ResetPrinter\n"));
8482
8483         /*
8484          * All we do is to check to see if the handle and queue is valid.
8485          * This call really doesn't mean anything to us because we only
8486          * support RAW printing.   --jerry
8487          */
8488
8489         if (!Printer) {
8490                 DEBUG(2,("_spoolss_ResetPrinter: Invalid handle (%s:%u:%u).\n",
8491                         OUR_HANDLE(handle)));
8492                 return WERR_BADFID;
8493         }
8494
8495         if (!get_printer_snum(p,handle, &snum, NULL))
8496                 return WERR_BADFID;
8497
8498
8499         /* blindly return success */
8500         return WERR_OK;
8501 }
8502
8503 /****************************************************************
8504  _spoolss_DeletePrinterData
8505 ****************************************************************/
8506
8507 WERROR _spoolss_DeletePrinterData(pipes_struct *p,
8508                                   struct spoolss_DeletePrinterData *r)
8509 {
8510         POLICY_HND      *handle = r->in.handle;
8511         NT_PRINTER_INFO_LEVEL   *printer = NULL;
8512         int             snum=0;
8513         WERROR          status = WERR_OK;
8514         Printer_entry   *Printer=find_printer_index_by_hnd(p, handle);
8515
8516         DEBUG(5,("_spoolss_DeletePrinterData\n"));
8517
8518         if (!Printer) {
8519                 DEBUG(2,("_spoolss_DeletePrinterData: Invalid handle (%s:%u:%u).\n",
8520                         OUR_HANDLE(handle)));
8521                 return WERR_BADFID;
8522         }
8523
8524         if (!get_printer_snum(p, handle, &snum, NULL))
8525                 return WERR_BADFID;
8526
8527         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
8528                 DEBUG(3, ("_spoolss_DeletePrinterData: "
8529                         "printer properties change denied by handle\n"));
8530                 return WERR_ACCESS_DENIED;
8531         }
8532
8533         status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8534         if (!W_ERROR_IS_OK(status))
8535                 return status;
8536
8537         if (!r->in.value_name) {
8538                 free_a_printer(&printer, 2);
8539                 return WERR_NOMEM;
8540         }
8541
8542         status = delete_printer_dataex( printer, SPOOL_PRINTERDATA_KEY,
8543                                         r->in.value_name );
8544
8545         if ( W_ERROR_IS_OK(status) )
8546                 mod_a_printer( printer, 2 );
8547
8548         free_a_printer(&printer, 2);
8549
8550         return status;
8551 }
8552
8553 /****************************************************************
8554  _spoolss_AddForm
8555 ****************************************************************/
8556
8557 WERROR _spoolss_AddForm(pipes_struct *p,
8558                         struct spoolss_AddForm *r)
8559 {
8560         POLICY_HND *handle = r->in.handle;
8561         struct spoolss_AddFormInfo1 *form = r->in.info.info1;
8562         nt_forms_struct tmpForm;
8563         int snum;
8564         WERROR status = WERR_OK;
8565         NT_PRINTER_INFO_LEVEL *printer = NULL;
8566
8567         int count=0;
8568         nt_forms_struct *list=NULL;
8569         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
8570
8571         DEBUG(5,("_spoolss_AddForm\n"));
8572
8573         if (!Printer) {
8574                 DEBUG(2,("_spoolss_AddForm: Invalid handle (%s:%u:%u).\n",
8575                         OUR_HANDLE(handle)));
8576                 return WERR_BADFID;
8577         }
8578
8579
8580         /* forms can be added on printer of on the print server handle */
8581
8582         if ( Printer->printer_type == SPLHND_PRINTER )
8583         {
8584                 if (!get_printer_snum(p,handle, &snum, NULL))
8585                         return WERR_BADFID;
8586
8587                 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8588                 if (!W_ERROR_IS_OK(status))
8589                         goto done;
8590         }
8591
8592         if ( !(Printer->access_granted & (PRINTER_ACCESS_ADMINISTER|SERVER_ACCESS_ADMINISTER)) ) {
8593                 DEBUG(2,("_spoolss_addform: denied by handle permissions.\n"));
8594                 status = WERR_ACCESS_DENIED;
8595                 goto done;
8596         }
8597
8598         /* can't add if builtin */
8599
8600         if (get_a_builtin_ntform_by_string(form->form_name, &tmpForm)) {
8601                 status = WERR_FILE_EXISTS;
8602                 goto done;
8603         }
8604
8605         count = get_ntforms(&list);
8606
8607         if(!add_a_form(&list, form, &count)) {
8608                 status =  WERR_NOMEM;
8609                 goto done;
8610         }
8611
8612         write_ntforms(&list, count);
8613
8614         /*
8615          * ChangeID must always be set if this is a printer
8616          */
8617
8618         if ( Printer->printer_type == SPLHND_PRINTER )
8619                 status = mod_a_printer(printer, 2);
8620
8621 done:
8622         if ( printer )
8623                 free_a_printer(&printer, 2);
8624         SAFE_FREE(list);
8625
8626         return status;
8627 }
8628
8629 /****************************************************************
8630  _spoolss_DeleteForm
8631 ****************************************************************/
8632
8633 WERROR _spoolss_DeleteForm(pipes_struct *p,
8634                            struct spoolss_DeleteForm *r)
8635 {
8636         POLICY_HND *handle = r->in.handle;
8637         const char *form_name = r->in.form_name;
8638         nt_forms_struct tmpForm;
8639         int count=0;
8640         nt_forms_struct *list=NULL;
8641         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
8642         int snum;
8643         WERROR status = WERR_OK;
8644         NT_PRINTER_INFO_LEVEL *printer = NULL;
8645
8646         DEBUG(5,("_spoolss_DeleteForm\n"));
8647
8648         if (!Printer) {
8649                 DEBUG(2,("_spoolss_DeleteForm: Invalid handle (%s:%u:%u).\n",
8650                         OUR_HANDLE(handle)));
8651                 return WERR_BADFID;
8652         }
8653
8654         /* forms can be deleted on printer of on the print server handle */
8655
8656         if ( Printer->printer_type == SPLHND_PRINTER )
8657         {
8658                 if (!get_printer_snum(p,handle, &snum, NULL))
8659                         return WERR_BADFID;
8660
8661                 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8662                 if (!W_ERROR_IS_OK(status))
8663                         goto done;
8664         }
8665
8666         if ( !(Printer->access_granted & (PRINTER_ACCESS_ADMINISTER|SERVER_ACCESS_ADMINISTER)) ) {
8667                 DEBUG(2,("_spoolss_DeleteForm: denied by handle permissions.\n"));
8668                 status = WERR_ACCESS_DENIED;
8669                 goto done;
8670         }
8671
8672         /* can't delete if builtin */
8673
8674         if (get_a_builtin_ntform_by_string(form_name,&tmpForm)) {
8675                 status = WERR_INVALID_PARAM;
8676                 goto done;
8677         }
8678
8679         count = get_ntforms(&list);
8680
8681         if ( !delete_a_form(&list, form_name, &count, &status ))
8682                 goto done;
8683
8684         /*
8685          * ChangeID must always be set if this is a printer
8686          */
8687
8688         if ( Printer->printer_type == SPLHND_PRINTER )
8689                 status = mod_a_printer(printer, 2);
8690
8691 done:
8692         if ( printer )
8693                 free_a_printer(&printer, 2);
8694         SAFE_FREE(list);
8695
8696         return status;
8697 }
8698
8699 /****************************************************************
8700  _spoolss_SetForm
8701 ****************************************************************/
8702
8703 WERROR _spoolss_SetForm(pipes_struct *p,
8704                         struct spoolss_SetForm *r)
8705 {
8706         POLICY_HND *handle = r->in.handle;
8707         struct spoolss_AddFormInfo1 *form = r->in.info.info1;
8708         nt_forms_struct tmpForm;
8709         int snum;
8710         WERROR status = WERR_OK;
8711         NT_PRINTER_INFO_LEVEL *printer = NULL;
8712
8713         int count=0;
8714         nt_forms_struct *list=NULL;
8715         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
8716
8717         DEBUG(5,("_spoolss_SetForm\n"));
8718
8719         if (!Printer) {
8720                 DEBUG(2,("_spoolss_SetForm: Invalid handle (%s:%u:%u).\n",
8721                         OUR_HANDLE(handle)));
8722                 return WERR_BADFID;
8723         }
8724
8725         /* forms can be modified on printer of on the print server handle */
8726
8727         if ( Printer->printer_type == SPLHND_PRINTER )
8728         {
8729                 if (!get_printer_snum(p,handle, &snum, NULL))
8730                         return WERR_BADFID;
8731
8732                 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8733                 if (!W_ERROR_IS_OK(status))
8734                         goto done;
8735         }
8736
8737         if ( !(Printer->access_granted & (PRINTER_ACCESS_ADMINISTER|SERVER_ACCESS_ADMINISTER)) ) {
8738                 DEBUG(2,("_spoolss_SetForm: denied by handle permissions\n"));
8739                 status = WERR_ACCESS_DENIED;
8740                 goto done;
8741         }
8742
8743         /* can't set if builtin */
8744         if (get_a_builtin_ntform_by_string(form->form_name, &tmpForm)) {
8745                 status = WERR_INVALID_PARAM;
8746                 goto done;
8747         }
8748
8749         count = get_ntforms(&list);
8750         update_a_form(&list, form, count);
8751         write_ntforms(&list, count);
8752
8753         /*
8754          * ChangeID must always be set if this is a printer
8755          */
8756
8757         if ( Printer->printer_type == SPLHND_PRINTER )
8758                 status = mod_a_printer(printer, 2);
8759
8760
8761 done:
8762         if ( printer )
8763                 free_a_printer(&printer, 2);
8764         SAFE_FREE(list);
8765
8766         return status;
8767 }
8768
8769 /****************************************************************************
8770  enumprintprocessors level 1.
8771 ****************************************************************************/
8772
8773 static WERROR enumprintprocessors_level_1(RPC_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
8774 {
8775         PRINTPROCESSOR_1 *info_1=NULL;
8776         WERROR result = WERR_OK;
8777
8778         if((info_1 = SMB_MALLOC_P(PRINTPROCESSOR_1)) == NULL)
8779                 return WERR_NOMEM;
8780
8781         (*returned) = 0x1;
8782
8783         init_unistr(&info_1->name, "winprint");
8784
8785         *needed += spoolss_size_printprocessor_info_1(info_1);
8786
8787         if (*needed > offered) {
8788                 result = WERR_INSUFFICIENT_BUFFER;
8789                 goto out;
8790         }
8791
8792         if (!rpcbuf_alloc_size(buffer, *needed)) {
8793                 result = WERR_NOMEM;
8794                 goto out;
8795         }
8796
8797         smb_io_printprocessor_info_1("", buffer, info_1, 0);
8798
8799 out:
8800         SAFE_FREE(info_1);
8801
8802         if ( !W_ERROR_IS_OK(result) )
8803                 *returned = 0;
8804
8805         return result;
8806 }
8807
8808 /****************************************************************************
8809 ****************************************************************************/
8810
8811 WERROR _spoolss_enumprintprocessors(pipes_struct *p, SPOOL_Q_ENUMPRINTPROCESSORS *q_u, SPOOL_R_ENUMPRINTPROCESSORS *r_u)
8812 {
8813         uint32 level = q_u->level;
8814         RPC_BUFFER *buffer = NULL;
8815         uint32 offered = q_u->offered;
8816         uint32 *needed = &r_u->needed;
8817         uint32 *returned = &r_u->returned;
8818
8819         /* that's an [in out] buffer */
8820
8821         if (!q_u->buffer && (offered!=0)) {
8822                 return WERR_INVALID_PARAM;
8823         }
8824
8825         if (offered > MAX_RPC_DATA_SIZE) {
8826                 return WERR_INVALID_PARAM;
8827         }
8828
8829         rpcbuf_move(q_u->buffer, &r_u->buffer);
8830         buffer = r_u->buffer;
8831
8832         DEBUG(5,("spoolss_enumprintprocessors\n"));
8833
8834         /*
8835          * Enumerate the print processors ...
8836          *
8837          * Just reply with "winprint", to keep NT happy
8838          * and I can use my nice printer checker.
8839          */
8840
8841         *returned=0;
8842         *needed=0;
8843
8844         switch (level) {
8845         case 1:
8846                 return enumprintprocessors_level_1(buffer, offered, needed, returned);
8847         default:
8848                 return WERR_UNKNOWN_LEVEL;
8849         }
8850 }
8851
8852 /****************************************************************************
8853  enumprintprocdatatypes level 1.
8854 ****************************************************************************/
8855
8856 static WERROR enumprintprocdatatypes_level_1(RPC_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
8857 {
8858         PRINTPROCDATATYPE_1 *info_1=NULL;
8859         WERROR result = WERR_OK;
8860
8861         if((info_1 = SMB_MALLOC_P(PRINTPROCDATATYPE_1)) == NULL)
8862                 return WERR_NOMEM;
8863
8864         (*returned) = 0x1;
8865
8866         init_unistr(&info_1->name, "RAW");
8867
8868         *needed += spoolss_size_printprocdatatype_info_1(info_1);
8869
8870         if (*needed > offered) {
8871                 result = WERR_INSUFFICIENT_BUFFER;
8872                 goto out;
8873         }
8874
8875         if (!rpcbuf_alloc_size(buffer, *needed)) {
8876                 result = WERR_NOMEM;
8877                 goto out;
8878         }
8879
8880         smb_io_printprocdatatype_info_1("", buffer, info_1, 0);
8881
8882 out:
8883         SAFE_FREE(info_1);
8884
8885         if ( !W_ERROR_IS_OK(result) )
8886                 *returned = 0;
8887
8888         return result;
8889 }
8890
8891 /****************************************************************************
8892 ****************************************************************************/
8893
8894 WERROR _spoolss_enumprintprocdatatypes(pipes_struct *p, SPOOL_Q_ENUMPRINTPROCDATATYPES *q_u, SPOOL_R_ENUMPRINTPROCDATATYPES *r_u)
8895 {
8896         uint32 level = q_u->level;
8897         RPC_BUFFER *buffer = NULL;
8898         uint32 offered = q_u->offered;
8899         uint32 *needed = &r_u->needed;
8900         uint32 *returned = &r_u->returned;
8901
8902         /* that's an [in out] buffer */
8903
8904         if (!q_u->buffer && (offered!=0)) {
8905                 return WERR_INVALID_PARAM;
8906         }
8907
8908         if (offered > MAX_RPC_DATA_SIZE) {
8909                 return WERR_INVALID_PARAM;
8910         }
8911
8912         rpcbuf_move(q_u->buffer, &r_u->buffer);
8913         buffer = r_u->buffer;
8914
8915         DEBUG(5,("_spoolss_enumprintprocdatatypes\n"));
8916
8917         *returned=0;
8918         *needed=0;
8919
8920         switch (level) {
8921         case 1:
8922                 return enumprintprocdatatypes_level_1(buffer, offered, needed, returned);
8923         default:
8924                 return WERR_UNKNOWN_LEVEL;
8925         }
8926 }
8927
8928 /****************************************************************************
8929  enumprintmonitors level 1.
8930 ****************************************************************************/
8931
8932 static WERROR enumprintmonitors_level_1(RPC_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
8933 {
8934         PRINTMONITOR_1 *info_1;
8935         WERROR result = WERR_OK;
8936         int i;
8937
8938         if((info_1 = SMB_MALLOC_ARRAY(PRINTMONITOR_1, 2)) == NULL)
8939                 return WERR_NOMEM;
8940
8941         *returned = 2;
8942
8943         init_unistr(&(info_1[0].name), SPL_LOCAL_PORT );
8944         init_unistr(&(info_1[1].name), SPL_TCPIP_PORT );
8945
8946         for ( i=0; i<*returned; i++ ) {
8947                 *needed += spoolss_size_printmonitor_info_1(&info_1[i]);
8948         }
8949
8950         if (*needed > offered) {
8951                 result = WERR_INSUFFICIENT_BUFFER;
8952                 goto out;
8953         }
8954
8955         if (!rpcbuf_alloc_size(buffer, *needed)) {
8956                 result = WERR_NOMEM;
8957                 goto out;
8958         }
8959
8960         for ( i=0; i<*returned; i++ ) {
8961                 smb_io_printmonitor_info_1("", buffer, &info_1[i], 0);
8962         }
8963
8964 out:
8965         SAFE_FREE(info_1);
8966
8967         if ( !W_ERROR_IS_OK(result) )
8968                 *returned = 0;
8969
8970         return result;
8971 }
8972
8973 /****************************************************************************
8974  enumprintmonitors level 2.
8975 ****************************************************************************/
8976
8977 static WERROR enumprintmonitors_level_2(RPC_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
8978 {
8979         PRINTMONITOR_2 *info_2;
8980         WERROR result = WERR_OK;
8981         int i;
8982
8983         if((info_2 = SMB_MALLOC_ARRAY(PRINTMONITOR_2, 2)) == NULL)
8984                 return WERR_NOMEM;
8985
8986         *returned = 2;
8987
8988         init_unistr( &(info_2[0].name), SPL_LOCAL_PORT );
8989         init_unistr( &(info_2[0].environment), "Windows NT X86" );
8990         init_unistr( &(info_2[0].dll_name), "localmon.dll" );
8991
8992         init_unistr( &(info_2[1].name), SPL_TCPIP_PORT );
8993         init_unistr( &(info_2[1].environment), "Windows NT X86" );
8994         init_unistr( &(info_2[1].dll_name), "tcpmon.dll" );
8995
8996         for ( i=0; i<*returned; i++ ) {
8997                 *needed += spoolss_size_printmonitor_info_2(&info_2[i]);
8998         }
8999
9000         if (*needed > offered) {
9001                 result = WERR_INSUFFICIENT_BUFFER;
9002                 goto out;
9003         }
9004
9005         if (!rpcbuf_alloc_size(buffer, *needed)) {
9006                 result = WERR_NOMEM;
9007                 goto out;
9008         }
9009
9010         for ( i=0; i<*returned; i++ ) {
9011                 smb_io_printmonitor_info_2("", buffer, &info_2[i], 0);
9012         }
9013
9014 out:
9015         SAFE_FREE(info_2);
9016
9017         if ( !W_ERROR_IS_OK(result) )
9018                 *returned = 0;
9019
9020         return result;
9021 }
9022
9023 /****************************************************************************
9024 ****************************************************************************/
9025
9026 WERROR _spoolss_enumprintmonitors(pipes_struct *p, SPOOL_Q_ENUMPRINTMONITORS *q_u, SPOOL_R_ENUMPRINTMONITORS *r_u)
9027 {
9028         uint32 level = q_u->level;
9029         RPC_BUFFER *buffer = NULL;
9030         uint32 offered = q_u->offered;
9031         uint32 *needed = &r_u->needed;
9032         uint32 *returned = &r_u->returned;
9033
9034         /* that's an [in out] buffer */
9035
9036         if (!q_u->buffer && (offered!=0)) {
9037                 return WERR_INVALID_PARAM;
9038         }
9039
9040         if (offered > MAX_RPC_DATA_SIZE) {
9041                 return WERR_INVALID_PARAM;
9042         }
9043
9044         rpcbuf_move(q_u->buffer, &r_u->buffer);
9045         buffer = r_u->buffer;
9046
9047         DEBUG(5,("spoolss_enumprintmonitors\n"));
9048
9049         /*
9050          * Enumerate the print monitors ...
9051          *
9052          * Just reply with "Local Port", to keep NT happy
9053          * and I can use my nice printer checker.
9054          */
9055
9056         *returned=0;
9057         *needed=0;
9058
9059         switch (level) {
9060         case 1:
9061                 return enumprintmonitors_level_1(buffer, offered, needed, returned);
9062         case 2:
9063                 return enumprintmonitors_level_2(buffer, offered, needed, returned);
9064         default:
9065                 return WERR_UNKNOWN_LEVEL;
9066         }
9067 }
9068
9069 /****************************************************************************
9070 ****************************************************************************/
9071
9072 static WERROR getjob_level_1(print_queue_struct **queue, int count, int snum,
9073                              NT_PRINTER_INFO_LEVEL *ntprinter,
9074                              uint32 jobid, RPC_BUFFER *buffer, uint32 offered,
9075                              uint32 *needed)
9076 {
9077         int i=0;
9078         bool found=False;
9079         JOB_INFO_1 *info_1=NULL;
9080         WERROR result = WERR_OK;
9081
9082         info_1=SMB_MALLOC_P(JOB_INFO_1);
9083
9084         if (info_1 == NULL) {
9085                 return WERR_NOMEM;
9086         }
9087
9088         for (i=0; i<count && found==False; i++) {
9089                 if ((*queue)[i].job==(int)jobid)
9090                         found=True;
9091         }
9092
9093         if (found==False) {
9094                 SAFE_FREE(info_1);
9095                 /* NT treats not found as bad param... yet another bad choice */
9096                 return WERR_INVALID_PARAM;
9097         }
9098
9099         fill_job_info_1( info_1, &((*queue)[i-1]), i, snum, ntprinter );
9100
9101         *needed += spoolss_size_job_info_1(info_1);
9102
9103         if (*needed > offered) {
9104                 result = WERR_INSUFFICIENT_BUFFER;
9105                 goto out;
9106         }
9107
9108         if (!rpcbuf_alloc_size(buffer, *needed)) {
9109                 result = WERR_NOMEM;
9110                 goto out;
9111         }
9112
9113         smb_io_job_info_1("", buffer, info_1, 0);
9114
9115 out:
9116         SAFE_FREE(info_1);
9117
9118         return result;
9119 }
9120
9121 /****************************************************************************
9122 ****************************************************************************/
9123
9124 static WERROR getjob_level_2(print_queue_struct **queue, int count, int snum,
9125                              NT_PRINTER_INFO_LEVEL *ntprinter,
9126                              uint32 jobid, RPC_BUFFER *buffer, uint32 offered,
9127                              uint32 *needed)
9128 {
9129         int             i = 0;
9130         bool            found = False;
9131         JOB_INFO_2      *info_2;
9132         WERROR          result;
9133         DEVICEMODE      *devmode = NULL;
9134         NT_DEVICEMODE   *nt_devmode = NULL;
9135
9136         if ( !(info_2=SMB_MALLOC_P(JOB_INFO_2)) )
9137                 return WERR_NOMEM;
9138
9139         ZERO_STRUCTP(info_2);
9140
9141         for ( i=0; i<count && found==False; i++ )
9142         {
9143                 if ((*queue)[i].job == (int)jobid)
9144                         found = True;
9145         }
9146
9147         if ( !found ) {
9148                 /* NT treats not found as bad param... yet another bad
9149                    choice */
9150                 result = WERR_INVALID_PARAM;
9151                 goto done;
9152         }
9153
9154         /*
9155          * if the print job does not have a DEVMODE associated with it,
9156          * just use the one for the printer. A NULL devicemode is not
9157          *  a failure condition
9158          */
9159
9160         if ( !(nt_devmode=print_job_devmode( lp_const_servicename(snum), jobid )) )
9161                 devmode = construct_dev_mode(lp_const_servicename(snum));
9162         else {
9163                 if ((devmode = SMB_MALLOC_P(DEVICEMODE)) != NULL) {
9164                         ZERO_STRUCTP( devmode );
9165                         convert_nt_devicemode( devmode, nt_devmode );
9166                 }
9167         }
9168
9169         fill_job_info_2(info_2, &((*queue)[i-1]), i, snum, ntprinter, devmode);
9170
9171         *needed += spoolss_size_job_info_2(info_2);
9172
9173         if (*needed > offered) {
9174                 result = WERR_INSUFFICIENT_BUFFER;
9175                 goto done;
9176         }
9177
9178         if (!rpcbuf_alloc_size(buffer, *needed)) {
9179                 result = WERR_NOMEM;
9180                 goto done;
9181         }
9182
9183         smb_io_job_info_2("", buffer, info_2, 0);
9184
9185         result = WERR_OK;
9186
9187  done:
9188         /* Cleanup allocated memory */
9189
9190         free_job_info_2(info_2);        /* Also frees devmode */
9191         SAFE_FREE(info_2);
9192
9193         return result;
9194 }
9195
9196 /****************************************************************************
9197 ****************************************************************************/
9198
9199 WERROR _spoolss_getjob( pipes_struct *p, SPOOL_Q_GETJOB *q_u, SPOOL_R_GETJOB *r_u)
9200 {
9201         POLICY_HND *handle = &q_u->handle;
9202         uint32 jobid = q_u->jobid;
9203         uint32 level = q_u->level;
9204         RPC_BUFFER *buffer = NULL;
9205         uint32 offered = q_u->offered;
9206         uint32 *needed = &r_u->needed;
9207         WERROR          wstatus = WERR_OK;
9208         NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
9209         int snum;
9210         int count;
9211         print_queue_struct      *queue = NULL;
9212         print_status_struct prt_status;
9213
9214         /* that's an [in out] buffer */
9215
9216         if (!q_u->buffer && (offered!=0)) {
9217                 return WERR_INVALID_PARAM;
9218         }
9219
9220         if (offered > MAX_RPC_DATA_SIZE) {
9221                 return WERR_INVALID_PARAM;
9222         }
9223
9224         rpcbuf_move(q_u->buffer, &r_u->buffer);
9225         buffer = r_u->buffer;
9226
9227         DEBUG(5,("spoolss_getjob\n"));
9228
9229         *needed = 0;
9230
9231         if (!get_printer_snum(p, handle, &snum, NULL))
9232                 return WERR_BADFID;
9233
9234         wstatus = get_a_printer(NULL, &ntprinter, 2, lp_servicename(snum));
9235         if ( !W_ERROR_IS_OK(wstatus) )
9236                 return wstatus;
9237
9238         count = print_queue_status(snum, &queue, &prt_status);
9239
9240         DEBUGADD(4,("count:[%d], prt_status:[%d], [%s]\n",
9241                      count, prt_status.status, prt_status.message));
9242
9243         switch ( level ) {
9244         case 1:
9245                         wstatus = getjob_level_1(&queue, count, snum, ntprinter, jobid,
9246                                 buffer, offered, needed);
9247                         break;
9248         case 2:
9249                         wstatus = getjob_level_2(&queue, count, snum, ntprinter, jobid,
9250                                 buffer, offered, needed);
9251                         break;
9252         default:
9253                         wstatus = WERR_UNKNOWN_LEVEL;
9254                         break;
9255         }
9256
9257         SAFE_FREE(queue);
9258         free_a_printer( &ntprinter, 2 );
9259
9260         return wstatus;
9261 }
9262
9263 /****************************************************************
9264  _spoolss_GetPrinterDataEx
9265
9266  From MSDN documentation of GetPrinterDataEx: pass request
9267  to GetPrinterData if key is "PrinterDriverData".
9268 ****************************************************************/
9269
9270 WERROR _spoolss_GetPrinterDataEx(pipes_struct *p,
9271                                  struct spoolss_GetPrinterDataEx *r)
9272 {
9273         POLICY_HND      *handle = r->in.handle;
9274         uint8           *data = NULL;
9275         const char      *keyname = r->in.key_name;
9276         const char      *valuename = r->in.value_name;
9277
9278         Printer_entry   *Printer = find_printer_index_by_hnd(p, handle);
9279
9280         NT_PRINTER_INFO_LEVEL   *printer = NULL;
9281         int                     snum = 0;
9282         WERROR                  status = WERR_OK;
9283
9284         DEBUG(4,("_spoolss_GetPrinterDataEx\n"));
9285
9286         DEBUG(10, ("_spoolss_GetPrinterDataEx: key => [%s], value => [%s]\n",
9287                 keyname, valuename));
9288
9289         /* in case of problem, return some default values */
9290
9291         *r->out.needed  = 0;
9292         *r->out.type    = 0;
9293
9294         if (!Printer) {
9295                 DEBUG(2,("_spoolss_GetPrinterDataEx: "
9296                         "Invalid handle (%s:%u:%u).\n", OUR_HANDLE(handle)));
9297                 status = WERR_BADFID;
9298                 goto done;
9299         }
9300
9301         /* Is the handle to a printer or to the server? */
9302
9303         if (Printer->printer_type == SPLHND_SERVER) {
9304                 DEBUG(10,("_spoolss_GetPrinterDataEx: "
9305                         "Not implemented for server handles yet\n"));
9306                 status = WERR_INVALID_PARAM;
9307                 goto done;
9308         }
9309
9310         if ( !get_printer_snum(p,handle, &snum, NULL) )
9311                 return WERR_BADFID;
9312
9313         status = get_a_printer(Printer, &printer, 2, lp_servicename(snum));
9314         if ( !W_ERROR_IS_OK(status) )
9315                 goto done;
9316
9317         /* check to see if the keyname is valid */
9318         if ( !strlen(keyname) ) {
9319                 status = WERR_INVALID_PARAM;
9320                 goto done;
9321         }
9322
9323         if ( lookup_printerkey( printer->info_2->data, keyname ) == -1 ) {
9324                 DEBUG(4,("_spoolss_GetPrinterDataEx: "
9325                         "Invalid keyname [%s]\n", keyname ));
9326                 free_a_printer( &printer, 2 );
9327                 status = WERR_BADFILE;
9328                 goto done;
9329         }
9330
9331         /* When given a new keyname, we should just create it */
9332
9333         status = get_printer_dataex( p->mem_ctx, printer, keyname, valuename,
9334                                      r->out.type, &data, r->out.needed,
9335                                      r->in.offered );
9336
9337         if (*r->out.needed > r->in.offered) {
9338                 status = WERR_MORE_DATA;
9339         }
9340
9341         if (W_ERROR_IS_OK(status)) {
9342                 memcpy(r->out.buffer, data, r->in.offered);
9343         }
9344
9345 done:
9346         if ( printer )
9347         free_a_printer( &printer, 2 );
9348
9349         return status;
9350 }
9351
9352 /****************************************************************
9353  _spoolss_SetPrinterDataEx
9354 ****************************************************************/
9355
9356 WERROR _spoolss_SetPrinterDataEx(pipes_struct *p,
9357                                  struct spoolss_SetPrinterDataEx *r)
9358 {
9359         POLICY_HND              *handle = r->in.handle;
9360         NT_PRINTER_INFO_LEVEL   *printer = NULL;
9361         int                     snum = 0;
9362         WERROR                  status = WERR_OK;
9363         Printer_entry           *Printer = find_printer_index_by_hnd(p, handle);
9364         char                    *oid_string;
9365
9366         DEBUG(4,("_spoolss_SetPrinterDataEx\n"));
9367
9368         /* From MSDN documentation of SetPrinterDataEx: pass request to
9369            SetPrinterData if key is "PrinterDriverData" */
9370
9371         if (!Printer) {
9372                 DEBUG(2,("_spoolss_SetPrinterDataEx: "
9373                         "Invalid handle (%s:%u:%u).\n", OUR_HANDLE(handle)));
9374                 return WERR_BADFID;
9375         }
9376
9377         if ( Printer->printer_type == SPLHND_SERVER ) {
9378                 DEBUG(10,("_spoolss_SetPrinterDataEx: "
9379                         "Not implemented for server handles yet\n"));
9380                 return WERR_INVALID_PARAM;
9381         }
9382
9383         if ( !get_printer_snum(p,handle, &snum, NULL) )
9384                 return WERR_BADFID;
9385
9386         /*
9387          * Access check : NT returns "access denied" if you make a
9388          * SetPrinterData call without the necessary privildge.
9389          * we were originally returning OK if nothing changed
9390          * which made Win2k issue **a lot** of SetPrinterData
9391          * when connecting to a printer  --jerry
9392          */
9393
9394         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER)
9395         {
9396                 DEBUG(3, ("_spoolss_SetPrinterDataEx: "
9397                         "change denied by handle access permissions\n"));
9398                 return WERR_ACCESS_DENIED;
9399         }
9400
9401         status = get_a_printer(Printer, &printer, 2, lp_servicename(snum));
9402         if (!W_ERROR_IS_OK(status))
9403                 return status;
9404
9405         /* check for OID in valuename */
9406
9407         if ( (oid_string = strchr( r->in.value_name, ',' )) != NULL )
9408         {
9409                 *oid_string = '\0';
9410                 oid_string++;
9411         }
9412
9413         /* save the registry data */
9414
9415         status = set_printer_dataex( printer, r->in.key_name, r->in.value_name,
9416                                      r->in.type, r->in.buffer, r->in.offered );
9417
9418         if ( W_ERROR_IS_OK(status) )
9419         {
9420                 /* save the OID if one was specified */
9421                 if ( oid_string ) {
9422                         char *str = talloc_asprintf(p->mem_ctx, "%s\\%s",
9423                                 r->in.key_name, SPOOL_OID_KEY);
9424                         if (!str) {
9425                                 return WERR_NOMEM;
9426                         }
9427
9428                         /*
9429                          * I'm not checking the status here on purpose.  Don't know
9430                          * if this is right, but I'm returning the status from the
9431                          * previous set_printer_dataex() call.  I have no idea if
9432                          * this is right.    --jerry
9433                          */
9434
9435                         set_printer_dataex( printer, str, r->in.value_name,
9436                                             REG_SZ, (uint8 *)oid_string,
9437                                             strlen(oid_string)+1 );
9438                 }
9439
9440                 status = mod_a_printer(printer, 2);
9441         }
9442
9443         free_a_printer(&printer, 2);
9444
9445         return status;
9446 }
9447
9448 /****************************************************************
9449  _spoolss_DeletePrinterDataEx
9450 ****************************************************************/
9451
9452 WERROR _spoolss_DeletePrinterDataEx(pipes_struct *p,
9453                                     struct spoolss_DeletePrinterDataEx *r)
9454 {
9455         POLICY_HND      *handle = r->in.handle;
9456         NT_PRINTER_INFO_LEVEL   *printer = NULL;
9457         int             snum=0;
9458         WERROR          status = WERR_OK;
9459         Printer_entry   *Printer=find_printer_index_by_hnd(p, handle);
9460
9461         DEBUG(5,("_spoolss_DeletePrinterDataEx\n"));
9462
9463         if (!Printer) {
9464                 DEBUG(2,("_spoolss_DeletePrinterDataEx: "
9465                         "Invalid handle (%s:%u:%u).\n", OUR_HANDLE(handle)));
9466                 return WERR_BADFID;
9467         }
9468
9469         if (!get_printer_snum(p, handle, &snum, NULL))
9470                 return WERR_BADFID;
9471
9472         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9473                 DEBUG(3, ("_spoolss_DeletePrinterDataEx: "
9474                         "printer properties change denied by handle\n"));
9475                 return WERR_ACCESS_DENIED;
9476         }
9477
9478         if (!r->in.value_name || !r->in.key_name) {
9479                 return WERR_NOMEM;
9480         }
9481
9482         status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9483         if (!W_ERROR_IS_OK(status))
9484                 return status;
9485
9486         status = delete_printer_dataex( printer, r->in.key_name, r->in.value_name );
9487
9488         if ( W_ERROR_IS_OK(status) )
9489                 mod_a_printer( printer, 2 );
9490
9491         free_a_printer(&printer, 2);
9492
9493         return status;
9494 }
9495
9496 /********************************************************************
9497  * spoolss_enumprinterkey
9498  ********************************************************************/
9499
9500
9501 WERROR _spoolss_enumprinterkey(pipes_struct *p, SPOOL_Q_ENUMPRINTERKEY *q_u, SPOOL_R_ENUMPRINTERKEY *r_u)
9502 {
9503         fstring         key;
9504         fstring         *keynames = NULL;
9505         uint16          *enumkeys = NULL;
9506         int             num_keys;
9507         int             printerkey_len;
9508         POLICY_HND      *handle = &q_u->handle;
9509         Printer_entry   *Printer = find_printer_index_by_hnd(p, handle);
9510         NT_PRINTER_DATA *data;
9511         NT_PRINTER_INFO_LEVEL   *printer = NULL;
9512         int             snum = 0;
9513         WERROR          status = WERR_BADFILE;
9514
9515
9516         DEBUG(4,("_spoolss_enumprinterkey\n"));
9517
9518         if (!Printer) {
9519                 DEBUG(2,("_spoolss_enumprinterkey: Invalid handle (%s:%u:%u).\n", OUR_HANDLE(handle)));
9520                 return WERR_BADFID;
9521         }
9522
9523         if ( !get_printer_snum(p,handle, &snum, NULL) )
9524                 return WERR_BADFID;
9525
9526         status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9527         if (!W_ERROR_IS_OK(status))
9528                 return status;
9529
9530         /* get the list of subkey names */
9531
9532         unistr2_to_ascii(key, &q_u->key, sizeof(key));
9533         data = printer->info_2->data;
9534
9535         num_keys = get_printer_subkeys( data, key, &keynames );
9536
9537         if ( num_keys == -1 ) {
9538                 status = WERR_BADFILE;
9539                 goto done;
9540         }
9541
9542         printerkey_len = init_unistr_array( &enumkeys,  keynames, NULL );
9543
9544         r_u->needed = printerkey_len*2;
9545
9546         if ( q_u->size < r_u->needed ) {
9547                 status = WERR_MORE_DATA;
9548                 goto done;
9549         }
9550
9551         if (!make_spoolss_buffer5(p->mem_ctx, &r_u->keys, printerkey_len, enumkeys)) {
9552                 status = WERR_NOMEM;
9553                 goto done;
9554         }
9555
9556         status = WERR_OK;
9557
9558         if ( q_u->size < r_u->needed )
9559                 status = WERR_MORE_DATA;
9560
9561 done:
9562         free_a_printer( &printer, 2 );
9563         SAFE_FREE( keynames );
9564
9565         return status;
9566 }
9567
9568 /****************************************************************
9569  _spoolss_DeletePrinterKey
9570 ****************************************************************/
9571
9572 WERROR _spoolss_DeletePrinterKey(pipes_struct *p,
9573                                  struct spoolss_DeletePrinterKey *r)
9574 {
9575         POLICY_HND              *handle = r->in.handle;
9576         Printer_entry           *Printer = find_printer_index_by_hnd(p, handle);
9577         NT_PRINTER_INFO_LEVEL   *printer = NULL;
9578         int                     snum=0;
9579         WERROR                  status;
9580
9581         DEBUG(5,("_spoolss_DeletePrinterKey\n"));
9582
9583         if (!Printer) {
9584                 DEBUG(2,("_spoolss_DeletePrinterKey: Invalid handle (%s:%u:%u).\n",
9585                         OUR_HANDLE(handle)));
9586                 return WERR_BADFID;
9587         }
9588
9589         /* if keyname == NULL, return error */
9590
9591         if ( !r->in.key_name )
9592                 return WERR_INVALID_PARAM;
9593
9594         if (!get_printer_snum(p, handle, &snum, NULL))
9595                 return WERR_BADFID;
9596
9597         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9598                 DEBUG(3, ("_spoolss_DeletePrinterKey: "
9599                         "printer properties change denied by handle\n"));
9600                 return WERR_ACCESS_DENIED;
9601         }
9602
9603         status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9604         if (!W_ERROR_IS_OK(status))
9605                 return status;
9606
9607         /* delete the key and all subneys */
9608
9609         status = delete_all_printer_data( printer->info_2, r->in.key_name );
9610
9611         if ( W_ERROR_IS_OK(status) )
9612                 status = mod_a_printer(printer, 2);
9613
9614         free_a_printer( &printer, 2 );
9615
9616         return status;
9617 }
9618
9619
9620 /********************************************************************
9621  * spoolss_enumprinterdataex
9622  ********************************************************************/
9623
9624 WERROR _spoolss_enumprinterdataex(pipes_struct *p, SPOOL_Q_ENUMPRINTERDATAEX *q_u, SPOOL_R_ENUMPRINTERDATAEX *r_u)
9625 {
9626         POLICY_HND      *handle = &q_u->handle;
9627         uint32          in_size = q_u->size;
9628         uint32          num_entries,
9629                         needed;
9630         NT_PRINTER_INFO_LEVEL   *printer = NULL;
9631         PRINTER_ENUM_VALUES     *enum_values = NULL;
9632         NT_PRINTER_DATA         *p_data;
9633         fstring         key;
9634         Printer_entry   *Printer = find_printer_index_by_hnd(p, handle);
9635         int             snum;
9636         WERROR          result;
9637         int             key_index;
9638         int             i;
9639         REGISTRY_VALUE  *val;
9640         char            *value_name;
9641         uint32          data_len;
9642
9643
9644         DEBUG(4,("_spoolss_enumprinterdataex\n"));
9645
9646         if (!Printer) {
9647                 DEBUG(2,("_spoolss_enumprinterdataex: Invalid handle (%s:%u:%u1<).\n", OUR_HANDLE(handle)));
9648                 return WERR_BADFID;
9649         }
9650
9651         /*
9652          * first check for a keyname of NULL or "".  Win2k seems to send
9653          * this a lot and we should send back WERR_INVALID_PARAM
9654          * no need to spend time looking up the printer in this case.
9655          * --jerry
9656          */
9657
9658         unistr2_to_ascii(key, &q_u->key, sizeof(key));
9659         if ( !strlen(key) ) {
9660                 result = WERR_INVALID_PARAM;
9661                 goto done;
9662         }
9663
9664         /* get the printer off of disk */
9665
9666         if (!get_printer_snum(p,handle, &snum, NULL))
9667                 return WERR_BADFID;
9668
9669         ZERO_STRUCT(printer);
9670         result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9671         if (!W_ERROR_IS_OK(result))
9672                 return result;
9673
9674         /* now look for a match on the key name */
9675
9676         p_data = printer->info_2->data;
9677
9678         unistr2_to_ascii(key, &q_u->key, sizeof(key));
9679         if ( (key_index = lookup_printerkey( p_data, key)) == -1  )
9680         {
9681                 DEBUG(10,("_spoolss_enumprinterdataex: Unknown keyname [%s]\n", key));
9682                 result = WERR_INVALID_PARAM;
9683                 goto done;
9684         }
9685
9686         result = WERR_OK;
9687         needed = 0;
9688
9689         /* allocate the memory for the array of pointers -- if necessary */
9690
9691         num_entries = regval_ctr_numvals( p_data->keys[key_index].values );
9692         if ( num_entries )
9693         {
9694                 if ( (enum_values=TALLOC_ARRAY(p->mem_ctx, PRINTER_ENUM_VALUES, num_entries)) == NULL )
9695                 {
9696                         DEBUG(0,("_spoolss_enumprinterdataex: talloc() failed to allocate memory for [%lu] bytes!\n",
9697                                 (unsigned long)num_entries*sizeof(PRINTER_ENUM_VALUES)));
9698                         result = WERR_NOMEM;
9699                         goto done;
9700                 }
9701
9702                 memset( enum_values, 0x0, num_entries*sizeof(PRINTER_ENUM_VALUES) );
9703         }
9704
9705         /*
9706          * loop through all params and build the array to pass
9707          * back to the  client
9708          */
9709
9710         for ( i=0; i<num_entries; i++ )
9711         {
9712                 /* lookup the registry value */
9713
9714                 val = regval_ctr_specific_value( p_data->keys[key_index].values, i );
9715                 DEBUG(10,("retrieved value number [%d] [%s]\n", i, regval_name(val) ));
9716
9717                 /* copy the data */
9718
9719                 value_name = regval_name( val );
9720                 init_unistr( &enum_values[i].valuename, value_name );
9721                 enum_values[i].value_len = (strlen(value_name)+1) * 2;
9722                 enum_values[i].type      = regval_type( val );
9723
9724                 data_len = regval_size( val );
9725                 if ( data_len ) {
9726                         if ( !(enum_values[i].data = (uint8 *)TALLOC_MEMDUP(p->mem_ctx, regval_data_p(val), data_len)) )
9727                         {
9728                                 DEBUG(0,("TALLOC_MEMDUP failed to allocate memory [data_len=%d] for data!\n",
9729                                         data_len ));
9730                                 result = WERR_NOMEM;
9731                                 goto done;
9732                         }
9733                 }
9734                 enum_values[i].data_len = data_len;
9735
9736                 /* keep track of the size of the array in bytes */
9737
9738                 needed += spoolss_size_printer_enum_values(&enum_values[i]);
9739         }
9740
9741         /* housekeeping information in the reply */
9742
9743         /* Fix from Martin Zielinski <mz@seh.de> - ensure
9744          * the hand marshalled container size is a multiple
9745          * of 4 bytes for RPC alignment.
9746          */
9747
9748         if (needed % 4) {
9749                 needed += 4-(needed % 4);
9750         }
9751
9752         r_u->needed     = needed;
9753         r_u->returned   = num_entries;
9754
9755         if (needed > in_size) {
9756                 result = WERR_MORE_DATA;
9757                 goto done;
9758         }
9759
9760         /* copy data into the reply */
9761
9762         /* mz: Vista x64 returns 0x6f7 (The stub received bad data), if the
9763            response buffer size is != the offered buffer size
9764
9765                 r_u->ctr.size           = r_u->needed;
9766         */
9767         r_u->ctr.size           = in_size;
9768
9769         r_u->ctr.size_of_array  = r_u->returned;
9770         r_u->ctr.values         = enum_values;
9771
9772 done:
9773         if ( printer )
9774         free_a_printer(&printer, 2);
9775
9776         return result;
9777 }
9778
9779 /****************************************************************************
9780 ****************************************************************************/
9781
9782 static WERROR getprintprocessordirectory_level_1(TALLOC_CTX *mem_ctx,
9783                                                  const char *servername,
9784                                                  const char *environment,
9785                                                  struct spoolss_PrintProcessorDirectoryInfo1 *r,
9786                                                  uint32_t offered,
9787                                                  uint32_t *needed)
9788 {
9789         WERROR werr;
9790         char *path = NULL;
9791
9792         werr = compose_spoolss_server_path(mem_ctx,
9793                                            servername,
9794                                            environment,
9795                                            SPOOLSS_PRTPROCS_PATH,
9796                                            &path);
9797         if (!W_ERROR_IS_OK(werr)) {
9798                 return werr;
9799         }
9800
9801         DEBUG(4,("print processor directory: [%s]\n", path));
9802
9803         r->directory_name = path;
9804
9805         *needed += ndr_size_spoolss_PrintProcessorDirectoryInfo1(r, NULL, 0);
9806
9807         if (*needed > offered) {
9808                 talloc_free(path);
9809                 return WERR_INSUFFICIENT_BUFFER;
9810         }
9811
9812         return WERR_OK;
9813 }
9814
9815 /****************************************************************
9816  _spoolss_GetPrintProcessorDirectory
9817 ****************************************************************/
9818
9819 WERROR _spoolss_GetPrintProcessorDirectory(pipes_struct *p,
9820                                            struct spoolss_GetPrintProcessorDirectory *r)
9821 {
9822         WERROR result;
9823
9824         /* that's an [in out] buffer */
9825
9826         if (!r->in.buffer && (r->in.offered != 0)) {
9827                 return WERR_INVALID_PARAM;
9828         }
9829
9830         DEBUG(5,("_spoolss_GetPrintProcessorDirectory: level %d\n",
9831                 r->in.level));
9832
9833         *r->out.needed = 0;
9834
9835         /* r->in.level is ignored */
9836
9837         result = getprintprocessordirectory_level_1(p->mem_ctx,
9838                                                     r->in.server,
9839                                                     r->in.environment,
9840                                                     &r->out.info->info1,
9841                                                     r->in.offered,
9842                                                     r->out.needed);
9843         if (!W_ERROR_IS_OK(result)) {
9844                 TALLOC_FREE(r->out.info);
9845         }
9846
9847         return result;
9848 }
9849
9850 /*******************************************************************
9851  ********************************************************************/
9852
9853 static bool push_monitorui_buf(TALLOC_CTX *mem_ctx, DATA_BLOB *buf,
9854                                const char *dllname)
9855 {
9856         enum ndr_err_code ndr_err;
9857         struct spoolss_MonitorUi ui;
9858
9859         ui.dll_name = dllname;
9860
9861         ndr_err = ndr_push_struct_blob(buf, mem_ctx, NULL, &ui,
9862                        (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorUi);
9863         if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9864                 NDR_PRINT_DEBUG(spoolss_MonitorUi, &ui);
9865         }
9866         return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9867 }
9868
9869 /*******************************************************************
9870  Streams the monitor UI DLL name in UNICODE
9871 *******************************************************************/
9872
9873 static WERROR xcvtcp_monitorui(TALLOC_CTX *mem_ctx,
9874                                NT_USER_TOKEN *token, DATA_BLOB *in,
9875                                DATA_BLOB *out, uint32_t *needed)
9876 {
9877         const char *dllname = "tcpmonui.dll";
9878
9879         *needed = (strlen(dllname)+1) * 2;
9880
9881         if (out->length < *needed) {
9882                 return WERR_INSUFFICIENT_BUFFER;
9883         }
9884
9885         if (!push_monitorui_buf(mem_ctx, out, dllname)) {
9886                 return WERR_NOMEM;
9887         }
9888
9889         return WERR_OK;
9890 }
9891
9892 /*******************************************************************
9893  ********************************************************************/
9894
9895 static bool pull_port_data_1(TALLOC_CTX *mem_ctx,
9896                              struct spoolss_PortData1 *port1,
9897                              const DATA_BLOB *buf)
9898 {
9899         enum ndr_err_code ndr_err;
9900         ndr_err = ndr_pull_struct_blob(buf, mem_ctx, NULL, port1,
9901                        (ndr_pull_flags_fn_t)ndr_pull_spoolss_PortData1);
9902         if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9903                 NDR_PRINT_DEBUG(spoolss_PortData1, port1);
9904         }
9905         return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9906 }
9907
9908 /*******************************************************************
9909  ********************************************************************/
9910
9911 static bool pull_port_data_2(TALLOC_CTX *mem_ctx,
9912                              struct spoolss_PortData2 *port2,
9913                              const DATA_BLOB *buf)
9914 {
9915         enum ndr_err_code ndr_err;
9916         ndr_err = ndr_pull_struct_blob(buf, mem_ctx, NULL, port2,
9917                        (ndr_pull_flags_fn_t)ndr_pull_spoolss_PortData2);
9918         if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9919                 NDR_PRINT_DEBUG(spoolss_PortData2, port2);
9920         }
9921         return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9922 }
9923
9924 /*******************************************************************
9925  Create a new TCP/IP port
9926 *******************************************************************/
9927
9928 static WERROR xcvtcp_addport(TALLOC_CTX *mem_ctx,
9929                              NT_USER_TOKEN *token, DATA_BLOB *in,
9930                              DATA_BLOB *out, uint32_t *needed)
9931 {
9932         struct spoolss_PortData1 port1;
9933         struct spoolss_PortData2 port2;
9934         char *device_uri = NULL;
9935         uint32_t version;
9936
9937         const char *portname;
9938         const char *hostaddress;
9939         const char *queue;
9940         uint32_t port_number;
9941         uint32_t protocol;
9942
9943         /* peek for spoolss_PortData version */
9944
9945         if (!in || (in->length < (128 + 4))) {
9946                 return WERR_GENERAL_FAILURE;
9947         }
9948
9949         version = IVAL(in->data, 128);
9950
9951         switch (version) {
9952                 case 1:
9953                         ZERO_STRUCT(port1);
9954
9955                         if (!pull_port_data_1(mem_ctx, &port1, in)) {
9956                                 return WERR_NOMEM;
9957                         }
9958
9959                         portname        = port1.portname;
9960                         hostaddress     = port1.hostaddress;
9961                         queue           = port1.queue;
9962                         protocol        = port1.protocol;
9963                         port_number     = port1.port_number;
9964
9965                         break;
9966                 case 2:
9967                         ZERO_STRUCT(port2);
9968
9969                         if (!pull_port_data_2(mem_ctx, &port2, in)) {
9970                                 return WERR_NOMEM;
9971                         }
9972
9973                         portname        = port2.portname;
9974                         hostaddress     = port2.hostaddress;
9975                         queue           = port2.queue;
9976                         protocol        = port2.protocol;
9977                         port_number     = port2.port_number;
9978
9979                         break;
9980                 default:
9981                         DEBUG(1,("xcvtcp_addport: "
9982                                 "unknown version of port_data: %d\n", version));
9983                         return WERR_UNKNOWN_PORT;
9984         }
9985
9986         /* create the device URI and call the add_port_hook() */
9987
9988         switch (protocol) {
9989         case PROTOCOL_RAWTCP_TYPE:
9990                 device_uri = talloc_asprintf(mem_ctx,
9991                                 "socket://%s:%d/", hostaddress,
9992                                 port_number);
9993                 break;
9994
9995         case PROTOCOL_LPR_TYPE:
9996                 device_uri = talloc_asprintf(mem_ctx,
9997                         "lpr://%s/%s", hostaddress, queue );
9998                 break;
9999
10000         default:
10001                 return WERR_UNKNOWN_PORT;
10002         }
10003
10004         if (!device_uri) {
10005                 return WERR_NOMEM;
10006         }
10007
10008         return add_port_hook(mem_ctx, token, portname, device_uri);
10009 }
10010
10011 /*******************************************************************
10012 *******************************************************************/
10013
10014 struct xcv_api_table xcvtcp_cmds[] = {
10015         { "MonitorUI",  xcvtcp_monitorui },
10016         { "AddPort",    xcvtcp_addport},
10017         { NULL,         NULL }
10018 };
10019
10020 static WERROR process_xcvtcp_command(TALLOC_CTX *mem_ctx,
10021                                      NT_USER_TOKEN *token, const char *command,
10022                                      DATA_BLOB *inbuf,
10023                                      DATA_BLOB *outbuf,
10024                                      uint32_t *needed )
10025 {
10026         int i;
10027
10028         DEBUG(10,("process_xcvtcp_command: Received command \"%s\"\n", command));
10029
10030         for ( i=0; xcvtcp_cmds[i].name; i++ ) {
10031                 if ( strcmp( command, xcvtcp_cmds[i].name ) == 0 )
10032                         return xcvtcp_cmds[i].fn(mem_ctx, token, inbuf, outbuf, needed);
10033         }
10034
10035         return WERR_BADFUNC;
10036 }
10037
10038 /*******************************************************************
10039 *******************************************************************/
10040 #if 0   /* don't support management using the "Local Port" monitor */
10041
10042 static WERROR xcvlocal_monitorui(TALLOC_CTX *mem_ctx,
10043                                  NT_USER_TOKEN *token, DATA_BLOB *in,
10044                                  DATA_BLOB *out, uint32_t *needed)
10045 {
10046         const char *dllname = "localui.dll";
10047
10048         *needed = (strlen(dllname)+1) * 2;
10049
10050         if (out->length < *needed) {
10051                 return WERR_INSUFFICIENT_BUFFER;
10052         }
10053
10054         if (!push_monitorui_buf(mem_ctx, out, dllname)) {
10055                 return WERR_NOMEM;
10056         }
10057
10058         return WERR_OK;
10059 }
10060
10061 /*******************************************************************
10062 *******************************************************************/
10063
10064 struct xcv_api_table xcvlocal_cmds[] = {
10065         { "MonitorUI",  xcvlocal_monitorui },
10066         { NULL,         NULL }
10067 };
10068 #else
10069 struct xcv_api_table xcvlocal_cmds[] = {
10070         { NULL,         NULL }
10071 };
10072 #endif
10073
10074
10075
10076 /*******************************************************************
10077 *******************************************************************/
10078
10079 static WERROR process_xcvlocal_command(TALLOC_CTX *mem_ctx,
10080                                        NT_USER_TOKEN *token, const char *command,
10081                                        DATA_BLOB *inbuf, DATA_BLOB *outbuf,
10082                                        uint32_t *needed)
10083 {
10084         int i;
10085
10086         DEBUG(10,("process_xcvlocal_command: Received command \"%s\"\n", command));
10087
10088         for ( i=0; xcvlocal_cmds[i].name; i++ ) {
10089                 if ( strcmp( command, xcvlocal_cmds[i].name ) == 0 )
10090                         return xcvlocal_cmds[i].fn(mem_ctx, token, inbuf, outbuf, needed);
10091         }
10092         return WERR_BADFUNC;
10093 }
10094
10095 /****************************************************************
10096  _spoolss_XcvData
10097 ****************************************************************/
10098
10099 WERROR _spoolss_XcvData(pipes_struct *p,
10100                         struct spoolss_XcvData *r)
10101 {
10102         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
10103         DATA_BLOB out_data;
10104         WERROR werror;
10105
10106         if (!Printer) {
10107                 DEBUG(2,("_spoolss_XcvData: Invalid handle (%s:%u:%u).\n",
10108                         OUR_HANDLE(r->in.handle)));
10109                 return WERR_BADFID;
10110         }
10111
10112         /* Has to be a handle to the TCP/IP port monitor */
10113
10114         if ( !(Printer->printer_type & (SPLHND_PORTMON_LOCAL|SPLHND_PORTMON_TCP)) ) {
10115                 DEBUG(2,("_spoolss_XcvData: Call only valid for Port Monitors\n"));
10116                 return WERR_BADFID;
10117         }
10118
10119         /* requires administrative access to the server */
10120
10121         if ( !(Printer->access_granted & SERVER_ACCESS_ADMINISTER) ) {
10122                 DEBUG(2,("_spoolss_XcvData: denied by handle permissions.\n"));
10123                 return WERR_ACCESS_DENIED;
10124         }
10125
10126         /* Allocate the outgoing buffer */
10127
10128         if (r->in.out_data_size) {
10129                 out_data = data_blob_talloc_zero(p->mem_ctx, r->in.out_data_size);
10130                 if (out_data.data == NULL) {
10131                         return WERR_NOMEM;
10132                 }
10133         }
10134
10135         switch ( Printer->printer_type ) {
10136         case SPLHND_PORTMON_TCP:
10137                 werror = process_xcvtcp_command(p->mem_ctx,
10138                                                 p->server_info->ptok,
10139                                                 r->in.function_name,
10140                                                 &r->in.in_data, &out_data,
10141                                                 r->out.needed);
10142                 break;
10143         case SPLHND_PORTMON_LOCAL:
10144                 werror = process_xcvlocal_command(p->mem_ctx,
10145                                                   p->server_info->ptok,
10146                                                   r->in.function_name,
10147                                                   &r->in.in_data, &out_data,
10148                                                   r->out.needed);
10149                 break;
10150         default:
10151                 werror = WERR_INVALID_PRINT_MONITOR;
10152         }
10153
10154         if (!W_ERROR_IS_OK(werror)) {
10155                 return werror;
10156         }
10157
10158         *r->out.status_code = 0;
10159
10160         memcpy(r->out.out_data, out_data.data, out_data.length);
10161
10162         return WERR_OK;
10163 }
10164
10165 /****************************************************************
10166  _spoolss_AddPrintProcessor
10167 ****************************************************************/
10168
10169 WERROR _spoolss_AddPrintProcessor(pipes_struct *p,
10170                                   struct spoolss_AddPrintProcessor *r)
10171 {
10172         /* for now, just indicate success and ignore the add.  We'll
10173            automatically set the winprint processor for printer
10174            entries later.  Used to debug the LexMark Optra S 1855 PCL
10175            driver --jerry */
10176
10177         return WERR_OK;
10178 }
10179
10180 /****************************************************************
10181  _spoolss_EnumPrinters
10182 ****************************************************************/
10183
10184 WERROR _spoolss_EnumPrinters(pipes_struct *p,
10185                              struct spoolss_EnumPrinters *r)
10186 {
10187         p->rng_fault_state = true;
10188         return WERR_NOT_SUPPORTED;
10189 }
10190
10191 /****************************************************************
10192  _spoolss_GetJob
10193 ****************************************************************/
10194
10195 WERROR _spoolss_GetJob(pipes_struct *p,
10196                        struct spoolss_GetJob *r)
10197 {
10198         p->rng_fault_state = true;
10199         return WERR_NOT_SUPPORTED;
10200 }
10201
10202 /****************************************************************
10203  _spoolss_EnumJobs
10204 ****************************************************************/
10205
10206 WERROR _spoolss_EnumJobs(pipes_struct *p,
10207                          struct spoolss_EnumJobs *r)
10208 {
10209         p->rng_fault_state = true;
10210         return WERR_NOT_SUPPORTED;
10211 }
10212
10213 /****************************************************************
10214  _spoolss_AddPrinter
10215 ****************************************************************/
10216
10217 WERROR _spoolss_AddPrinter(pipes_struct *p,
10218                            struct spoolss_AddPrinter *r)
10219 {
10220         p->rng_fault_state = true;
10221         return WERR_NOT_SUPPORTED;
10222 }
10223
10224 /****************************************************************
10225  _spoolss_GetPrinter
10226 ****************************************************************/
10227
10228 WERROR _spoolss_GetPrinter(pipes_struct *p,
10229                            struct spoolss_GetPrinter *r)
10230 {
10231         p->rng_fault_state = true;
10232         return WERR_NOT_SUPPORTED;
10233 }
10234
10235 /****************************************************************
10236  _spoolss_EnumPrinterDrivers
10237 ****************************************************************/
10238
10239 WERROR _spoolss_EnumPrinterDrivers(pipes_struct *p,
10240                                    struct spoolss_EnumPrinterDrivers *r)
10241 {
10242         p->rng_fault_state = true;
10243         return WERR_NOT_SUPPORTED;
10244 }
10245
10246 /****************************************************************
10247  _spoolss_GetPrinterDriver
10248 ****************************************************************/
10249
10250 WERROR _spoolss_GetPrinterDriver(pipes_struct *p,
10251                                  struct spoolss_GetPrinterDriver *r)
10252 {
10253         p->rng_fault_state = true;
10254         return WERR_NOT_SUPPORTED;
10255 }
10256
10257 /****************************************************************
10258  _spoolss_EnumPrintProcessors
10259 ****************************************************************/
10260
10261 WERROR _spoolss_EnumPrintProcessors(pipes_struct *p,
10262                                     struct spoolss_EnumPrintProcessors *r)
10263 {
10264         p->rng_fault_state = true;
10265         return WERR_NOT_SUPPORTED;
10266 }
10267
10268 /****************************************************************
10269  _spoolss_ReadPrinter
10270 ****************************************************************/
10271
10272 WERROR _spoolss_ReadPrinter(pipes_struct *p,
10273                             struct spoolss_ReadPrinter *r)
10274 {
10275         p->rng_fault_state = true;
10276         return WERR_NOT_SUPPORTED;
10277 }
10278
10279 /****************************************************************
10280  _spoolss_GetPrinterData
10281 ****************************************************************/
10282
10283 WERROR _spoolss_GetPrinterData(pipes_struct *p,
10284                                struct spoolss_GetPrinterData *r)
10285 {
10286         p->rng_fault_state = true;
10287         return WERR_NOT_SUPPORTED;
10288 }
10289
10290 /****************************************************************
10291  _spoolss_SetPrinterData
10292 ****************************************************************/
10293
10294 WERROR _spoolss_SetPrinterData(pipes_struct *p,
10295                                struct spoolss_SetPrinterData *r)
10296 {
10297         p->rng_fault_state = true;
10298         return WERR_NOT_SUPPORTED;
10299 }
10300
10301 /****************************************************************
10302  _spoolss_WaitForPrinterChange
10303 ****************************************************************/
10304
10305 WERROR _spoolss_WaitForPrinterChange(pipes_struct *p,
10306                                      struct spoolss_WaitForPrinterChange *r)
10307 {
10308         p->rng_fault_state = true;
10309         return WERR_NOT_SUPPORTED;
10310 }
10311
10312 /****************************************************************
10313  _spoolss_EnumForms
10314 ****************************************************************/
10315
10316 WERROR _spoolss_EnumForms(pipes_struct *p,
10317                           struct spoolss_EnumForms *r)
10318 {
10319         p->rng_fault_state = true;
10320         return WERR_NOT_SUPPORTED;
10321 }
10322
10323 /****************************************************************
10324  _spoolss_EnumPorts
10325 ****************************************************************/
10326
10327 WERROR _spoolss_EnumPorts(pipes_struct *p,
10328                           struct spoolss_EnumPorts *r)
10329 {
10330         p->rng_fault_state = true;
10331         return WERR_NOT_SUPPORTED;
10332 }
10333
10334 /****************************************************************
10335  _spoolss_EnumMonitors
10336 ****************************************************************/
10337
10338 WERROR _spoolss_EnumMonitors(pipes_struct *p,
10339                              struct spoolss_EnumMonitors *r)
10340 {
10341         p->rng_fault_state = true;
10342         return WERR_NOT_SUPPORTED;
10343 }
10344
10345 /****************************************************************
10346  _spoolss_AddPort
10347 ****************************************************************/
10348
10349 WERROR _spoolss_AddPort(pipes_struct *p,
10350                         struct spoolss_AddPort *r)
10351 {
10352         p->rng_fault_state = true;
10353         return WERR_NOT_SUPPORTED;
10354 }
10355
10356 /****************************************************************
10357  _spoolss_ConfigurePort
10358 ****************************************************************/
10359
10360 WERROR _spoolss_ConfigurePort(pipes_struct *p,
10361                               struct spoolss_ConfigurePort *r)
10362 {
10363         p->rng_fault_state = true;
10364         return WERR_NOT_SUPPORTED;
10365 }
10366
10367 /****************************************************************
10368  _spoolss_DeletePort
10369 ****************************************************************/
10370
10371 WERROR _spoolss_DeletePort(pipes_struct *p,
10372                            struct spoolss_DeletePort *r)
10373 {
10374         p->rng_fault_state = true;
10375         return WERR_NOT_SUPPORTED;
10376 }
10377
10378 /****************************************************************
10379  _spoolss_CreatePrinterIC
10380 ****************************************************************/
10381
10382 WERROR _spoolss_CreatePrinterIC(pipes_struct *p,
10383                                 struct spoolss_CreatePrinterIC *r)
10384 {
10385         p->rng_fault_state = true;
10386         return WERR_NOT_SUPPORTED;
10387 }
10388
10389 /****************************************************************
10390  _spoolss_PlayGDIScriptOnPrinterIC
10391 ****************************************************************/
10392
10393 WERROR _spoolss_PlayGDIScriptOnPrinterIC(pipes_struct *p,
10394                                          struct spoolss_PlayGDIScriptOnPrinterIC *r)
10395 {
10396         p->rng_fault_state = true;
10397         return WERR_NOT_SUPPORTED;
10398 }
10399
10400 /****************************************************************
10401  _spoolss_DeletePrinterIC
10402 ****************************************************************/
10403
10404 WERROR _spoolss_DeletePrinterIC(pipes_struct *p,
10405                                 struct spoolss_DeletePrinterIC *r)
10406 {
10407         p->rng_fault_state = true;
10408         return WERR_NOT_SUPPORTED;
10409 }
10410
10411 /****************************************************************
10412  _spoolss_AddPrinterConnection
10413 ****************************************************************/
10414
10415 WERROR _spoolss_AddPrinterConnection(pipes_struct *p,
10416                                      struct spoolss_AddPrinterConnection *r)
10417 {
10418         p->rng_fault_state = true;
10419         return WERR_NOT_SUPPORTED;
10420 }
10421
10422 /****************************************************************
10423  _spoolss_DeletePrinterConnection
10424 ****************************************************************/
10425
10426 WERROR _spoolss_DeletePrinterConnection(pipes_struct *p,
10427                                         struct spoolss_DeletePrinterConnection *r)
10428 {
10429         p->rng_fault_state = true;
10430         return WERR_NOT_SUPPORTED;
10431 }
10432
10433 /****************************************************************
10434  _spoolss_PrinterMessageBox
10435 ****************************************************************/
10436
10437 WERROR _spoolss_PrinterMessageBox(pipes_struct *p,
10438                                   struct spoolss_PrinterMessageBox *r)
10439 {
10440         p->rng_fault_state = true;
10441         return WERR_NOT_SUPPORTED;
10442 }
10443
10444 /****************************************************************
10445  _spoolss_AddMonitor
10446 ****************************************************************/
10447
10448 WERROR _spoolss_AddMonitor(pipes_struct *p,
10449                            struct spoolss_AddMonitor *r)
10450 {
10451         p->rng_fault_state = true;
10452         return WERR_NOT_SUPPORTED;
10453 }
10454
10455 /****************************************************************
10456  _spoolss_DeleteMonitor
10457 ****************************************************************/
10458
10459 WERROR _spoolss_DeleteMonitor(pipes_struct *p,
10460                               struct spoolss_DeleteMonitor *r)
10461 {
10462         p->rng_fault_state = true;
10463         return WERR_NOT_SUPPORTED;
10464 }
10465
10466 /****************************************************************
10467  _spoolss_DeletePrintProcessor
10468 ****************************************************************/
10469
10470 WERROR _spoolss_DeletePrintProcessor(pipes_struct *p,
10471                                      struct spoolss_DeletePrintProcessor *r)
10472 {
10473         p->rng_fault_state = true;
10474         return WERR_NOT_SUPPORTED;
10475 }
10476
10477 /****************************************************************
10478  _spoolss_AddPrintProvidor
10479 ****************************************************************/
10480
10481 WERROR _spoolss_AddPrintProvidor(pipes_struct *p,
10482                                  struct spoolss_AddPrintProvidor *r)
10483 {
10484         p->rng_fault_state = true;
10485         return WERR_NOT_SUPPORTED;
10486 }
10487
10488 /****************************************************************
10489  _spoolss_DeletePrintProvidor
10490 ****************************************************************/
10491
10492 WERROR _spoolss_DeletePrintProvidor(pipes_struct *p,
10493                                     struct spoolss_DeletePrintProvidor *r)
10494 {
10495         p->rng_fault_state = true;
10496         return WERR_NOT_SUPPORTED;
10497 }
10498
10499 /****************************************************************
10500  _spoolss_EnumPrintProcDataTypes
10501 ****************************************************************/
10502
10503 WERROR _spoolss_EnumPrintProcDataTypes(pipes_struct *p,
10504                                        struct spoolss_EnumPrintProcDataTypes *r)
10505 {
10506         p->rng_fault_state = true;
10507         return WERR_NOT_SUPPORTED;
10508 }
10509
10510 /****************************************************************
10511  _spoolss_GetPrinterDriver2
10512 ****************************************************************/
10513
10514 WERROR _spoolss_GetPrinterDriver2(pipes_struct *p,
10515                                   struct spoolss_GetPrinterDriver2 *r)
10516 {
10517         p->rng_fault_state = true;
10518         return WERR_NOT_SUPPORTED;
10519 }
10520
10521 /****************************************************************
10522  _spoolss_FindFirstPrinterChangeNotification
10523 ****************************************************************/
10524
10525 WERROR _spoolss_FindFirstPrinterChangeNotification(pipes_struct *p,
10526                                                    struct spoolss_FindFirstPrinterChangeNotification *r)
10527 {
10528         p->rng_fault_state = true;
10529         return WERR_NOT_SUPPORTED;
10530 }
10531
10532 /****************************************************************
10533  _spoolss_FindNextPrinterChangeNotification
10534 ****************************************************************/
10535
10536 WERROR _spoolss_FindNextPrinterChangeNotification(pipes_struct *p,
10537                                                   struct spoolss_FindNextPrinterChangeNotification *r)
10538 {
10539         p->rng_fault_state = true;
10540         return WERR_NOT_SUPPORTED;
10541 }
10542
10543 /****************************************************************
10544  _spoolss_RouterFindFirstPrinterChangeNotificationOld
10545 ****************************************************************/
10546
10547 WERROR _spoolss_RouterFindFirstPrinterChangeNotificationOld(pipes_struct *p,
10548                                                             struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
10549 {
10550         p->rng_fault_state = true;
10551         return WERR_NOT_SUPPORTED;
10552 }
10553
10554 /****************************************************************
10555  _spoolss_ReplyOpenPrinter
10556 ****************************************************************/
10557
10558 WERROR _spoolss_ReplyOpenPrinter(pipes_struct *p,
10559                                  struct spoolss_ReplyOpenPrinter *r)
10560 {
10561         p->rng_fault_state = true;
10562         return WERR_NOT_SUPPORTED;
10563 }
10564
10565 /****************************************************************
10566  _spoolss_RouterReplyPrinter
10567 ****************************************************************/
10568
10569 WERROR _spoolss_RouterReplyPrinter(pipes_struct *p,
10570                                    struct spoolss_RouterReplyPrinter *r)
10571 {
10572         p->rng_fault_state = true;
10573         return WERR_NOT_SUPPORTED;
10574 }
10575
10576 /****************************************************************
10577  _spoolss_ReplyClosePrinter
10578 ****************************************************************/
10579
10580 WERROR _spoolss_ReplyClosePrinter(pipes_struct *p,
10581                                   struct spoolss_ReplyClosePrinter *r)
10582 {
10583         p->rng_fault_state = true;
10584         return WERR_NOT_SUPPORTED;
10585 }
10586
10587 /****************************************************************
10588  _spoolss_AddPortEx
10589 ****************************************************************/
10590
10591 WERROR _spoolss_AddPortEx(pipes_struct *p,
10592                           struct spoolss_AddPortEx *r)
10593 {
10594         p->rng_fault_state = true;
10595         return WERR_NOT_SUPPORTED;
10596 }
10597
10598 /****************************************************************
10599  _spoolss_RouterFindFirstPrinterChangeNotification
10600 ****************************************************************/
10601
10602 WERROR _spoolss_RouterFindFirstPrinterChangeNotification(pipes_struct *p,
10603                                                          struct spoolss_RouterFindFirstPrinterChangeNotification *r)
10604 {
10605         p->rng_fault_state = true;
10606         return WERR_NOT_SUPPORTED;
10607 }
10608
10609 /****************************************************************
10610  _spoolss_SpoolerInit
10611 ****************************************************************/
10612
10613 WERROR _spoolss_SpoolerInit(pipes_struct *p,
10614                             struct spoolss_SpoolerInit *r)
10615 {
10616         p->rng_fault_state = true;
10617         return WERR_NOT_SUPPORTED;
10618 }
10619
10620 /****************************************************************
10621  _spoolss_ResetPrinterEx
10622 ****************************************************************/
10623
10624 WERROR _spoolss_ResetPrinterEx(pipes_struct *p,
10625                                struct spoolss_ResetPrinterEx *r)
10626 {
10627         p->rng_fault_state = true;
10628         return WERR_NOT_SUPPORTED;
10629 }
10630
10631 /****************************************************************
10632  _spoolss_RouterReplyPrinterEx
10633 ****************************************************************/
10634
10635 WERROR _spoolss_RouterReplyPrinterEx(pipes_struct *p,
10636                                      struct spoolss_RouterReplyPrinterEx *r)
10637 {
10638         p->rng_fault_state = true;
10639         return WERR_NOT_SUPPORTED;
10640 }
10641
10642 /****************************************************************
10643  _spoolss_44
10644 ****************************************************************/
10645
10646 WERROR _spoolss_44(pipes_struct *p,
10647                    struct spoolss_44 *r)
10648 {
10649         p->rng_fault_state = true;
10650         return WERR_NOT_SUPPORTED;
10651 }
10652
10653 /****************************************************************
10654  _spoolss_47
10655 ****************************************************************/
10656
10657 WERROR _spoolss_47(pipes_struct *p,
10658                    struct spoolss_47 *r)
10659 {
10660         p->rng_fault_state = true;
10661         return WERR_NOT_SUPPORTED;
10662 }
10663
10664 /****************************************************************
10665  _spoolss_EnumPrinterData
10666 ****************************************************************/
10667
10668 WERROR _spoolss_EnumPrinterData(pipes_struct *p,
10669                                 struct spoolss_EnumPrinterData *r)
10670 {
10671         p->rng_fault_state = true;
10672         return WERR_NOT_SUPPORTED;
10673 }
10674
10675 /****************************************************************
10676  _spoolss_4a
10677 ****************************************************************/
10678
10679 WERROR _spoolss_4a(pipes_struct *p,
10680                    struct spoolss_4a *r)
10681 {
10682         p->rng_fault_state = true;
10683         return WERR_NOT_SUPPORTED;
10684 }
10685
10686 /****************************************************************
10687  _spoolss_4b
10688 ****************************************************************/
10689
10690 WERROR _spoolss_4b(pipes_struct *p,
10691                    struct spoolss_4b *r)
10692 {
10693         p->rng_fault_state = true;
10694         return WERR_NOT_SUPPORTED;
10695 }
10696
10697 /****************************************************************
10698  _spoolss_4c
10699 ****************************************************************/
10700
10701 WERROR _spoolss_4c(pipes_struct *p,
10702                    struct spoolss_4c *r)
10703 {
10704         p->rng_fault_state = true;
10705         return WERR_NOT_SUPPORTED;
10706 }
10707
10708 /****************************************************************
10709  _spoolss_EnumPrinterDataEx
10710 ****************************************************************/
10711
10712 WERROR _spoolss_EnumPrinterDataEx(pipes_struct *p,
10713                                   struct spoolss_EnumPrinterDataEx *r)
10714 {
10715         p->rng_fault_state = true;
10716         return WERR_NOT_SUPPORTED;
10717 }
10718
10719 /****************************************************************
10720  _spoolss_EnumPrinterKey
10721 ****************************************************************/
10722
10723 WERROR _spoolss_EnumPrinterKey(pipes_struct *p,
10724                                struct spoolss_EnumPrinterKey *r)
10725 {
10726         p->rng_fault_state = true;
10727         return WERR_NOT_SUPPORTED;
10728 }
10729
10730 /****************************************************************
10731  _spoolss_53
10732 ****************************************************************/
10733
10734 WERROR _spoolss_53(pipes_struct *p,
10735                    struct spoolss_53 *r)
10736 {
10737         p->rng_fault_state = true;
10738         return WERR_NOT_SUPPORTED;
10739 }
10740
10741 /****************************************************************
10742  _spoolss_55
10743 ****************************************************************/
10744
10745 WERROR _spoolss_55(pipes_struct *p,
10746                    struct spoolss_55 *r)
10747 {
10748         p->rng_fault_state = true;
10749         return WERR_NOT_SUPPORTED;
10750 }
10751
10752 /****************************************************************
10753  _spoolss_56
10754 ****************************************************************/
10755
10756 WERROR _spoolss_56(pipes_struct *p,
10757                    struct spoolss_56 *r)
10758 {
10759         p->rng_fault_state = true;
10760         return WERR_NOT_SUPPORTED;
10761 }
10762
10763 /****************************************************************
10764  _spoolss_57
10765 ****************************************************************/
10766
10767 WERROR _spoolss_57(pipes_struct *p,
10768                    struct spoolss_57 *r)
10769 {
10770         p->rng_fault_state = true;
10771         return WERR_NOT_SUPPORTED;
10772 }
10773
10774 /****************************************************************
10775  _spoolss_5a
10776 ****************************************************************/
10777
10778 WERROR _spoolss_5a(pipes_struct *p,
10779                    struct spoolss_5a *r)
10780 {
10781         p->rng_fault_state = true;
10782         return WERR_NOT_SUPPORTED;
10783 }
10784
10785 /****************************************************************
10786  _spoolss_5b
10787 ****************************************************************/
10788
10789 WERROR _spoolss_5b(pipes_struct *p,
10790                    struct spoolss_5b *r)
10791 {
10792         p->rng_fault_state = true;
10793         return WERR_NOT_SUPPORTED;
10794 }
10795
10796 /****************************************************************
10797  _spoolss_5c
10798 ****************************************************************/
10799
10800 WERROR _spoolss_5c(pipes_struct *p,
10801                    struct spoolss_5c *r)
10802 {
10803         p->rng_fault_state = true;
10804         return WERR_NOT_SUPPORTED;
10805 }
10806
10807 /****************************************************************
10808  _spoolss_5d
10809 ****************************************************************/
10810
10811 WERROR _spoolss_5d(pipes_struct *p,
10812                    struct spoolss_5d *r)
10813 {
10814         p->rng_fault_state = true;
10815         return WERR_NOT_SUPPORTED;
10816 }
10817
10818 /****************************************************************
10819  _spoolss_5e
10820 ****************************************************************/
10821
10822 WERROR _spoolss_5e(pipes_struct *p,
10823                    struct spoolss_5e *r)
10824 {
10825         p->rng_fault_state = true;
10826         return WERR_NOT_SUPPORTED;
10827 }
10828
10829 /****************************************************************
10830  _spoolss_5f
10831 ****************************************************************/
10832
10833 WERROR _spoolss_5f(pipes_struct *p,
10834                    struct spoolss_5f *r)
10835 {
10836         p->rng_fault_state = true;
10837         return WERR_NOT_SUPPORTED;
10838 }
10839