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  *  Copyright (C) Guenther Deschner                 2009.
  11  *
  12  *  This program is free software; you can redistribute it and/or modify
  13  *  it under the terms of the GNU General Public License as published by
  14  *  the Free Software Foundation; either version 3 of the License, or
  15  *  (at your option) any later version.
  16  *
  17  *  This program is distributed in the hope that it will be useful,
  18  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  *  GNU General Public License for more details.
  21  *
  22  *  You should have received a copy of the GNU General Public License
  23  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
  24  */
  25
  26 /* Since the SPOOLSS rpc routines are basically DOS 16-bit calls wrapped
  27    up, all the errors returned are DOS errors, not NT status codes. */
  28
  29 #include "includes.h"
  30 #include "../librpc/gen_ndr/srv_spoolss.h"
  31 #include "../librpc/gen_ndr/cli_spoolss.h"
  32
  33 /* macros stolen from s4 spoolss server */
  34 #define SPOOLSS_BUFFER_UNION(fn,ic,info,level) \
  35         ((info)?ndr_size_##fn(info, level, ic, 0):0)
  36
  37 #define SPOOLSS_BUFFER_UNION_ARRAY(mem_ctx,fn,ic,info,level,count) \
  38         ((info)?ndr_size_##fn##_info(mem_ctx, ic, level, count, info):0)
  39
  40 #define SPOOLSS_BUFFER_ARRAY(mem_ctx,fn,ic,info,count) \
  41         ((info)?ndr_size_##fn##_info(mem_ctx, ic, count, info):0)
  42
  43 #define SPOOLSS_BUFFER_OK(val_true,val_false) ((r->in.offered >= *r->out.needed)?val_true:val_false)
  44
  45
  46 extern userdom_struct current_user_info;
  47
  48 #undef DBGC_CLASS
  49 #define DBGC_CLASS DBGC_RPC_SRV
  50
  51 #ifndef MAX_OPEN_PRINTER_EXS
  52 #define MAX_OPEN_PRINTER_EXS 50
  53 #endif
  54
  55 #define MAGIC_DISPLAY_FREQUENCY 0xfade2bad
  56 #define PHANTOM_DEVMODE_KEY "_p_f_a_n_t_0_m_"
  57
  58 static Printer_entry *printers_list;
  59
  60 typedef struct _counter_printer_0 {
  61         struct _counter_printer_0 *next;
  62         struct _counter_printer_0 *prev;
  63
  64         int snum;
  65         uint32_t counter;
  66 } counter_printer_0;
  67
  68 static counter_printer_0 *counter_list;
  69
  70 static struct rpc_pipe_client *notify_cli_pipe; /* print notify back-channel pipe handle*/
  71 static uint32_t smb_connections = 0;
  72
  73
  74 /* in printing/nt_printing.c */
  75
  76 extern struct standard_mapping printer_std_mapping, printserver_std_mapping;
  77
  78 /* API table for Xcv Monitor functions */
  79
  80 struct xcv_api_table {
  81         const char *name;
  82         WERROR(*fn) (TALLOC_CTX *mem_ctx, NT_USER_TOKEN *token, DATA_BLOB *in, DATA_BLOB *out, uint32_t *needed);
  83 };
  84
  85 /********************************************************************
  86  * Canonicalize servername.
  87  ********************************************************************/
  88
  89 static const char *canon_servername(const char *servername)
  90 {
  91         const char *pservername = servername;
  92         while (*pservername == '\\') {
  93                 pservername++;
  94         }
  95         return pservername;
  96 }
  97
  98 /* translate between internal status numbers and NT status numbers */
  99 static int nt_printj_status(int v)
 100 {
 101         switch (v) {
 102         case LPQ_QUEUED:
 103                 return 0;
 104         case LPQ_PAUSED:
 105                 return JOB_STATUS_PAUSED;
 106         case LPQ_SPOOLING:
 107                 return JOB_STATUS_SPOOLING;
 108         case LPQ_PRINTING:
 109                 return JOB_STATUS_PRINTING;
 110         case LPQ_ERROR:
 111                 return JOB_STATUS_ERROR;
 112         case LPQ_DELETING:
 113                 return JOB_STATUS_DELETING;
 114         case LPQ_OFFLINE:
 115                 return JOB_STATUS_OFFLINE;
 116         case LPQ_PAPEROUT:
 117                 return JOB_STATUS_PAPEROUT;
 118         case LPQ_PRINTED:
 119                 return JOB_STATUS_PRINTED;
 120         case LPQ_DELETED:
 121                 return JOB_STATUS_DELETED;
 122         case LPQ_BLOCKED:
 123                 return JOB_STATUS_BLOCKED_DEVQ;
 124         case LPQ_USER_INTERVENTION:
 125                 return JOB_STATUS_USER_INTERVENTION;
 126         }
 127         return 0;
 128 }
 129
 130 static int nt_printq_status(int v)
 131 {
 132         switch (v) {
 133         case LPQ_PAUSED:
 134                 return PRINTER_STATUS_PAUSED;
 135         case LPQ_QUEUED:
 136         case LPQ_SPOOLING:
 137         case LPQ_PRINTING:
 138                 return 0;
 139         }
 140         return 0;
 141 }
 142
 143 /***************************************************************************
 144  Disconnect from the client
 145 ****************************************************************************/
 146
 147 static void srv_spoolss_replycloseprinter(int snum, struct policy_handle *handle)
 148 {
 149         WERROR result;
 150         NTSTATUS status;
 151
 152         /*
 153          * Tell the specific printing tdb we no longer want messages for this printer
 154          * by deregistering our PID.
 155          */
 156
 157         if (!print_notify_deregister_pid(snum))
 158                 DEBUG(0,("print_notify_register_pid: Failed to register our pid for printer %s\n", lp_const_servicename(snum) ));
 159
 160         /* weird if the test succeds !!! */
 161         if (smb_connections==0) {
 162                 DEBUG(0,("srv_spoolss_replycloseprinter:Trying to close non-existant notify backchannel !\n"));
 163                 return;
 164         }
 165
 166         status = rpccli_spoolss_ReplyClosePrinter(notify_cli_pipe, talloc_tos(),
 167                                                   handle,
 168                                                   &result);
 169         if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result))
 170                 DEBUG(0,("srv_spoolss_replycloseprinter: reply_close_printer failed [%s].\n",
 171                         win_errstr(result)));
 172
 173         /* if it's the last connection, deconnect the IPC$ share */
 174         if (smb_connections==1) {
 175
 176                 cli_shutdown( rpc_pipe_np_smb_conn(notify_cli_pipe) );
 177                 notify_cli_pipe = NULL; /* The above call shuts downn the pipe also. */
 178
 179                 messaging_deregister(smbd_messaging_context(),
 180                                      MSG_PRINTER_NOTIFY2, NULL);
 181
 182                 /* Tell the connections db we're no longer interested in
 183                  * printer notify messages. */
 184
 185                 register_message_flags(false, FLAG_MSG_PRINT_NOTIFY);
 186         }
 187
 188         smb_connections--;
 189 }
 190
 191 /****************************************************************************
 192  Functions to free a printer entry datastruct.
 193 ****************************************************************************/
 194
 195 static int printer_entry_destructor(Printer_entry *Printer)
 196 {
 197         if (Printer->notify.client_connected == true) {
 198                 int snum = -1;
 199
 200                 if ( Printer->printer_type == SPLHND_SERVER) {
 201                         snum = -1;
 202                         srv_spoolss_replycloseprinter(snum, &Printer->notify.client_hnd);
 203                 } else if (Printer->printer_type == SPLHND_PRINTER) {
 204                         snum = print_queue_snum(Printer->sharename);
 205                         if (snum != -1)
 206                                 srv_spoolss_replycloseprinter(snum,
 207                                                 &Printer->notify.client_hnd);
 208                 }
 209         }
 210
 211         Printer->notify.flags=0;
 212         Printer->notify.options=0;
 213         Printer->notify.localmachine[0]='\0';
 214         Printer->notify.printerlocal=0;
 215         TALLOC_FREE(Printer->notify.option);
 216         Printer->notify.client_connected = false;
 217
 218         free_nt_devicemode( &Printer->nt_devmode );
 219         free_a_printer( &Printer->printer_info, 2 );
 220
 221         /* Remove from the internal list. */
 222         DLIST_REMOVE(printers_list, Printer);
 223         return 0;
 224 }
 225
 226 /****************************************************************************
 227   find printer index by handle
 228 ****************************************************************************/
 229
 230 static Printer_entry *find_printer_index_by_hnd(pipes_struct *p,
 231                                                 struct policy_handle *hnd)
 232 {
 233         Printer_entry *find_printer = NULL;
 234
 235         if(!find_policy_by_hnd(p,hnd,(void **)(void *)&find_printer)) {
 236                 DEBUG(2,("find_printer_index_by_hnd: Printer handle not found: "));
 237                 return NULL;
 238         }
 239
 240         return find_printer;
 241 }
 242
 243 /****************************************************************************
 244  Close printer index by handle.
 245 ****************************************************************************/
 246
 247 static bool close_printer_handle(pipes_struct *p, struct policy_handle *hnd)
 248 {
 249         Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
 250
 251         if (!Printer) {
 252                 DEBUG(2,("close_printer_handle: Invalid handle (%s:%u:%u)\n",
 253                         OUR_HANDLE(hnd)));
 254                 return false;
 255         }
 256
 257         close_policy_hnd(p, hnd);
 258
 259         return true;
 260 }
 261
 262 /****************************************************************************
 263  Delete a printer given a handle.
 264 ****************************************************************************/
 265
 266 static WERROR delete_printer_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, const char *sharename)
 267 {
 268         char *cmd = lp_deleteprinter_cmd();
 269         char *command = NULL;
 270         int ret;
 271         SE_PRIV se_printop = SE_PRINT_OPERATOR;
 272         bool is_print_op = false;
 273
 274         /* can't fail if we don't try */
 275
 276         if ( !*cmd )
 277                 return WERR_OK;
 278
 279         command = talloc_asprintf(ctx,
 280                         "%s \"%s\"",
 281                         cmd, sharename);
 282         if (!command) {
 283                 return WERR_NOMEM;
 284         }
 285         if ( token )
 286                 is_print_op = user_has_privileges( token, &se_printop );
 287
 288         DEBUG(10,("Running [%s]\n", command));
 289
 290         /********** BEGIN SePrintOperatorPrivlege BLOCK **********/
 291
 292         if ( is_print_op )
 293                 become_root();
 294
 295         if ( (ret = smbrun(command, NULL)) == 0 ) {
 296                 /* Tell everyone we updated smb.conf. */
 297                 message_send_all(smbd_messaging_context(),
 298                                  MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
 299         }
 300
 301         if ( is_print_op )
 302                 unbecome_root();
 303
 304         /********** END SePrintOperatorPrivlege BLOCK **********/
 305
 306         DEBUGADD(10,("returned [%d]\n", ret));
 307
 308         TALLOC_FREE(command);
 309
 310         if (ret != 0)
 311                 return WERR_BADFID; /* What to return here? */
 312
 313         /* go ahead and re-read the services immediately */
 314         become_root();
 315         reload_services(false);
 316         unbecome_root();
 317
 318         if ( lp_servicenumber( sharename )  < 0 )
 319                 return WERR_ACCESS_DENIED;
 320
 321         return WERR_OK;
 322 }
 323
 324 /****************************************************************************
 325  Delete a printer given a handle.
 326 ****************************************************************************/
 327
 328 static WERROR delete_printer_handle(pipes_struct *p, struct policy_handle *hnd)
 329 {
 330         Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
 331
 332         if (!Printer) {
 333                 DEBUG(2,("delete_printer_handle: Invalid handle (%s:%u:%u)\n",
 334                         OUR_HANDLE(hnd)));
 335                 return WERR_BADFID;
 336         }
 337
 338         /*
 339          * It turns out that Windows allows delete printer on a handle
 340          * opened by an admin user, then used on a pipe handle created
 341          * by an anonymous user..... but they're working on security.... riiight !
 342          * JRA.
 343          */
 344
 345         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
 346                 DEBUG(3, ("delete_printer_handle: denied by handle\n"));
 347                 return WERR_ACCESS_DENIED;
 348         }
 349
 350         /* this does not need a become root since the access check has been
 351            done on the handle already */
 352
 353         if (del_a_printer( Printer->sharename ) != 0) {
 354                 DEBUG(3,("Error deleting printer %s\n", Printer->sharename));
 355                 return WERR_BADFID;
 356         }
 357
 358         return delete_printer_hook(p->mem_ctx, p->server_info->ptok,
 359                                    Printer->sharename );
 360 }
 361
 362 /****************************************************************************
 363  Return the snum of a printer corresponding to an handle.
 364 ****************************************************************************/
 365
 366 static bool get_printer_snum(pipes_struct *p, struct policy_handle *hnd,
 367                              int *number, struct share_params **params)
 368 {
 369         Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
 370
 371         if (!Printer) {
 372                 DEBUG(2,("get_printer_snum: Invalid handle (%s:%u:%u)\n",
 373                         OUR_HANDLE(hnd)));
 374                 return false;
 375         }
 376
 377         switch (Printer->printer_type) {
 378                 case SPLHND_PRINTER:
 379                         DEBUG(4,("short name:%s\n", Printer->sharename));
 380                         *number = print_queue_snum(Printer->sharename);
 381                         return (*number != -1);
 382                 case SPLHND_SERVER:
 383                         return false;
 384                 default:
 385                         return false;
 386         }
 387 }
 388
 389 /****************************************************************************
 390  Set printer handle type.
 391  Check if it's \\server or \\server\printer
 392 ****************************************************************************/
 393
 394 static bool set_printer_hnd_printertype(Printer_entry *Printer, const char *handlename)
 395 {
 396         DEBUG(3,("Setting printer type=%s\n", handlename));
 397
 398         if ( strlen(handlename) < 3 ) {
 399                 DEBUGADD(4,("A print server must have at least 1 char ! %s\n", handlename));
 400                 return false;
 401         }
 402
 403         /* it's a print server */
 404         if (*handlename=='\\' && *(handlename+1)=='\\' && !strchr_m(handlename+2, '\\')) {
 405                 DEBUGADD(4,("Printer is a print server\n"));
 406                 Printer->printer_type = SPLHND_SERVER;
 407         }
 408         /* it's a printer (set_printer_hnd_name() will handle port monitors */
 409         else {
 410                 DEBUGADD(4,("Printer is a printer\n"));
 411                 Printer->printer_type = SPLHND_PRINTER;
 412         }
 413
 414         return true;
 415 }
 416
 417 /****************************************************************************
 418  Set printer handle name..  Accept names like \\server, \\server\printer,
 419  \\server\SHARE, & "\\server\,XcvMonitor Standard TCP/IP Port"    See
 420  the MSDN docs regarding OpenPrinter() for details on the XcvData() and
 421  XcvDataPort() interface.
 422 ****************************************************************************/
 423
 424 static bool set_printer_hnd_name(Printer_entry *Printer, const char *handlename)
 425 {
 426         int snum;
 427         int n_services=lp_numservices();
 428         char *aprinter, *printername;
 429         const char *servername;
 430         fstring sname;
 431         bool found = false;
 432         NT_PRINTER_INFO_LEVEL *printer = NULL;
 433         WERROR result;
 434
 435         DEBUG(4,("Setting printer name=%s (len=%lu)\n", handlename,
 436                 (unsigned long)strlen(handlename)));
 437
 438         aprinter = CONST_DISCARD(char *, handlename);
 439         if ( *handlename == '\\' ) {
 440                 servername = canon_servername(handlename);
 441                 if ( (aprinter = strchr_m( servername, '\\' )) != NULL ) {
 442                         *aprinter = '\0';
 443                         aprinter++;
 444                 }
 445         } else {
 446                 servername = global_myname();
 447         }
 448
 449         /* save the servername to fill in replies on this handle */
 450
 451         if ( !is_myname_or_ipaddr( servername ) )
 452                 return false;
 453
 454         fstrcpy( Printer->servername, servername );
 455
 456         if ( Printer->printer_type == SPLHND_SERVER )
 457                 return true;
 458
 459         if ( Printer->printer_type != SPLHND_PRINTER )
 460                 return false;
 461
 462         DEBUGADD(5, ("searching for [%s]\n", aprinter ));
 463
 464         /* check for the Port Monitor Interface */
 465
 466         if ( strequal( aprinter, SPL_XCV_MONITOR_TCPMON ) ) {
 467                 Printer->printer_type = SPLHND_PORTMON_TCP;
 468                 fstrcpy(sname, SPL_XCV_MONITOR_TCPMON);
 469                 found = true;
 470         }
 471         else if ( strequal( aprinter, SPL_XCV_MONITOR_LOCALMON ) ) {
 472                 Printer->printer_type = SPLHND_PORTMON_LOCAL;
 473                 fstrcpy(sname, SPL_XCV_MONITOR_LOCALMON);
 474                 found = true;
 475         }
 476
 477         /* Search all sharenames first as this is easier than pulling
 478            the printer_info_2 off of disk. Don't use find_service() since
 479            that calls out to map_username() */
 480
 481         /* do another loop to look for printernames */
 482
 483         for (snum=0; !found && snum<n_services; snum++) {
 484
 485                 /* no point going on if this is not a printer */
 486
 487                 if ( !(lp_snum_ok(snum) && lp_print_ok(snum)) )
 488                         continue;
 489
 490                 fstrcpy(sname, lp_servicename(snum));
 491                 if ( strequal( aprinter, sname ) ) {
 492                         found = true;
 493                         break;
 494                 }
 495
 496                 /* no point looking up the printer object if
 497                    we aren't allowing printername != sharename */
 498
 499                 if ( lp_force_printername(snum) )
 500                         continue;
 501
 502                 fstrcpy(sname, lp_servicename(snum));
 503
 504                 printer = NULL;
 505
 506                 /* This call doesn't fill in the location or comment from
 507                  * a CUPS server for efficiency with large numbers of printers.
 508                  * JRA.
 509                  */
 510
 511                 result = get_a_printer_search( NULL, &printer, 2, sname );
 512                 if ( !W_ERROR_IS_OK(result) ) {
 513                         DEBUG(0,("set_printer_hnd_name: failed to lookup printer [%s] -- result [%s]\n",
 514                                 sname, win_errstr(result)));
 515                         continue;
 516                 }
 517
 518                 /* printername is always returned as \\server\printername */
 519                 if ( !(printername = strchr_m(&printer->info_2->printername[2], '\\')) ) {
 520                         DEBUG(0,("set_printer_hnd_name: info2->printername in wrong format! [%s]\n",
 521                                 printer->info_2->printername));
 522                         free_a_printer( &printer, 2);
 523                         continue;
 524                 }
 525
 526                 printername++;
 527
 528                 if ( strequal(printername, aprinter) ) {
 529                         free_a_printer( &printer, 2);
 530                         found = true;
 531                         break;
 532                 }
 533
 534                 DEBUGADD(10, ("printername: %s\n", printername));
 535
 536                 free_a_printer( &printer, 2);
 537         }
 538
 539         free_a_printer( &printer, 2);
 540
 541         if ( !found ) {
 542                 DEBUGADD(4,("Printer not found\n"));
 543                 return false;
 544         }
 545
 546         DEBUGADD(4,("set_printer_hnd_name: Printer found: %s -> %s\n", aprinter, sname));
 547
 548         fstrcpy(Printer->sharename, sname);
 549
 550         return true;
 551 }
 552
 553 /****************************************************************************
 554  Find first available printer slot. creates a printer handle for you.
 555  ****************************************************************************/
 556
 557 static bool open_printer_hnd(pipes_struct *p, struct policy_handle *hnd,
 558                              const char *name, uint32_t access_granted)
 559 {
 560         Printer_entry *new_printer;
 561
 562         DEBUG(10,("open_printer_hnd: name [%s]\n", name));
 563
 564         new_printer = TALLOC_ZERO_P(NULL, Printer_entry);
 565         if (new_printer == NULL) {
 566                 return false;
 567         }
 568         talloc_set_destructor(new_printer, printer_entry_destructor);
 569
 570         if (!create_policy_hnd(p, hnd, new_printer)) {
 571                 TALLOC_FREE(new_printer);
 572                 return false;
 573         }
 574
 575         /* Add to the internal list. */
 576         DLIST_ADD(printers_list, new_printer);
 577
 578         new_printer->notify.option=NULL;
 579
 580         if (!set_printer_hnd_printertype(new_printer, name)) {
 581                 close_printer_handle(p, hnd);
 582                 return false;
 583         }
 584
 585         if (!set_printer_hnd_name(new_printer, name)) {
 586                 close_printer_handle(p, hnd);
 587                 return false;
 588         }
 589
 590         new_printer->access_granted = access_granted;
 591
 592         DEBUG(5, ("%d printer handles active\n",
 593                   (int)num_pipe_handles(p->pipe_handles)));
 594
 595         return true;
 596 }
 597
 598 /***************************************************************************
 599  check to see if the client motify handle is monitoring the notification
 600  given by (notify_type, notify_field).
 601  **************************************************************************/
 602
 603 static bool is_monitoring_event_flags(uint32_t flags, uint16_t notify_type,
 604                                       uint16_t notify_field)
 605 {
 606         return true;
 607 }
 608
 609 static bool is_monitoring_event(Printer_entry *p, uint16_t notify_type,
 610                                 uint16_t notify_field)
 611 {
 612         struct spoolss_NotifyOption *option = p->notify.option;
 613         uint32_t i, j;
 614
 615         /*
 616          * Flags should always be zero when the change notify
 617          * is registered by the client's spooler.  A user Win32 app
 618          * might use the flags though instead of the NOTIFY_OPTION_INFO
 619          * --jerry
 620          */
 621
 622         if (!option) {
 623                 return false;
 624         }
 625
 626         if (p->notify.flags)
 627                 return is_monitoring_event_flags(
 628                         p->notify.flags, notify_type, notify_field);
 629
 630         for (i = 0; i < option->count; i++) {
 631
 632                 /* Check match for notify_type */
 633
 634                 if (option->types[i].type != notify_type)
 635                         continue;
 636
 637                 /* Check match for field */
 638
 639                 for (j = 0; j < option->types[i].count; j++) {
 640                         if (option->types[i].fields[j].field == notify_field) {
 641                                 return true;
 642                         }
 643                 }
 644         }
 645
 646         DEBUG(10, ("Open handle for \\\\%s\\%s is not monitoring 0x%02x/0x%02x\n",
 647                    p->servername, p->sharename, notify_type, notify_field));
 648
 649         return false;
 650 }
 651
 652 #define SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(_data, _integer) \
 653         _data->data.integer[0] = _integer; \
 654         _data->data.integer[1] = 0;
 655
 656
 657 #define SETUP_SPOOLSS_NOTIFY_DATA_STRING(_data, _p) \
 658         _data->data.string.string = talloc_strdup(mem_ctx, _p); \
 659         if (!_data->data.string.string) {\
 660                 _data->data.string.size = 0; \
 661         } \
 662         _data->data.string.size = strlen_m_term(_p) * 2;
 663
 664 #define SETUP_SPOOLSS_NOTIFY_DATA_DEVMODE(_data, _devmode) \
 665         _data->data.devmode.devmode = _devmode;
 666
 667 #define SETUP_SPOOLSS_NOTIFY_DATA_SECDESC(_data, _size, _sd) \
 668         _data->data.sd.sd = dup_sec_desc(mem_ctx, _sd); \
 669         if (!_data->data.sd.sd) { \
 670                 _data->data.sd.sd_size = 0; \
 671         } \
 672         _data->data.sd.sd_size = _size;
 673
 674 static void init_systemtime_buffer(TALLOC_CTX *mem_ctx,
 675                                    struct tm *t,
 676                                    const char **pp,
 677                                    uint32_t *plen)
 678 {
 679         struct spoolss_Time st;
 680         uint32_t len = 16;
 681         char *p;
 682
 683         if (!init_systemtime(&st, t)) {
 684                 return;
 685         }
 686
 687         p = talloc_array(mem_ctx, char, len);
 688         if (!p) {
 689                 return;
 690         }
 691
 692         /*
 693          * Systemtime must be linearized as a set of UINT16's.
 694          * Fix from Benjamin (Bj) Kuit bj@it.uts.edu.au
 695          */
 696
 697         SSVAL(p, 0, st.year);
 698         SSVAL(p, 2, st.month);
 699         SSVAL(p, 4, st.day_of_week);
 700         SSVAL(p, 6, st.day);
 701         SSVAL(p, 8, st.hour);
 702         SSVAL(p, 10, st.minute);
 703         SSVAL(p, 12, st.second);
 704         SSVAL(p, 14, st.millisecond);
 705
 706         *pp = p;
 707         *plen = len;
 708 }
 709
 710 /* Convert a notification message to a struct spoolss_Notify */
 711
 712 static void notify_one_value(struct spoolss_notify_msg *msg,
 713                              struct spoolss_Notify *data,
 714                              TALLOC_CTX *mem_ctx)
 715 {
 716         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, msg->notify.value[0]);
 717 }
 718
 719 static void notify_string(struct spoolss_notify_msg *msg,
 720                           struct spoolss_Notify *data,
 721                           TALLOC_CTX *mem_ctx)
 722 {
 723         /* The length of the message includes the trailing \0 */
 724
 725         data->data.string.size = msg->len * 2;
 726         data->data.string.string = talloc_strdup(mem_ctx, msg->notify.data);
 727         if (!data->data.string.string) {
 728                 data->data.string.size = 0;
 729                 return;
 730         }
 731 }
 732
 733 static void notify_system_time(struct spoolss_notify_msg *msg,
 734                                struct spoolss_Notify *data,
 735                                TALLOC_CTX *mem_ctx)
 736 {
 737         data->data.string.string = NULL;
 738         data->data.string.size = 0;
 739
 740         if (msg->len != sizeof(time_t)) {
 741                 DEBUG(5, ("notify_system_time: received wrong sized message (%d)\n",
 742                           msg->len));
 743                 return;
 744         }
 745
 746         init_systemtime_buffer(mem_ctx, gmtime((time_t *)msg->notify.data),
 747                                &data->data.string.string,
 748                                &data->data.string.size);
 749 }
 750
 751 struct notify2_message_table {
 752         const char *name;
 753         void (*fn)(struct spoolss_notify_msg *msg,
 754                    struct spoolss_Notify *data, TALLOC_CTX *mem_ctx);
 755 };
 756
 757 static struct notify2_message_table printer_notify_table[] = {
 758         /* 0x00 */ { "PRINTER_NOTIFY_FIELD_SERVER_NAME", notify_string },
 759         /* 0x01 */ { "PRINTER_NOTIFY_FIELD_PRINTER_NAME", notify_string },
 760         /* 0x02 */ { "PRINTER_NOTIFY_FIELD_SHARE_NAME", notify_string },
 761         /* 0x03 */ { "PRINTER_NOTIFY_FIELD_PORT_NAME", notify_string },
 762         /* 0x04 */ { "PRINTER_NOTIFY_FIELD_DRIVER_NAME", notify_string },
 763         /* 0x05 */ { "PRINTER_NOTIFY_FIELD_COMMENT", notify_string },
 764         /* 0x06 */ { "PRINTER_NOTIFY_FIELD_LOCATION", notify_string },
 765         /* 0x07 */ { "PRINTER_NOTIFY_FIELD_DEVMODE", NULL },
 766         /* 0x08 */ { "PRINTER_NOTIFY_FIELD_SEPFILE", notify_string },
 767         /* 0x09 */ { "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR", notify_string },
 768         /* 0x0a */ { "PRINTER_NOTIFY_FIELD_PARAMETERS", NULL },
 769         /* 0x0b */ { "PRINTER_NOTIFY_FIELD_DATATYPE", notify_string },
 770         /* 0x0c */ { "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NULL },
 771         /* 0x0d */ { "PRINTER_NOTIFY_FIELD_ATTRIBUTES", notify_one_value },
 772         /* 0x0e */ { "PRINTER_NOTIFY_FIELD_PRIORITY", notify_one_value },
 773         /* 0x0f */ { "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY", NULL },
 774         /* 0x10 */ { "PRINTER_NOTIFY_FIELD_START_TIME", NULL },
 775         /* 0x11 */ { "PRINTER_NOTIFY_FIELD_UNTIL_TIME", NULL },
 776         /* 0x12 */ { "PRINTER_NOTIFY_FIELD_STATUS", notify_one_value },
 777 };
 778
 779 static struct notify2_message_table job_notify_table[] = {
 780         /* 0x00 */ { "JOB_NOTIFY_FIELD_PRINTER_NAME", NULL },
 781         /* 0x01 */ { "JOB_NOTIFY_FIELD_MACHINE_NAME", NULL },
 782         /* 0x02 */ { "JOB_NOTIFY_FIELD_PORT_NAME", NULL },
 783         /* 0x03 */ { "JOB_NOTIFY_FIELD_USER_NAME", notify_string },
 784         /* 0x04 */ { "JOB_NOTIFY_FIELD_NOTIFY_NAME", NULL },
 785         /* 0x05 */ { "JOB_NOTIFY_FIELD_DATATYPE", NULL },
 786         /* 0x06 */ { "JOB_NOTIFY_FIELD_PRINT_PROCESSOR", NULL },
 787         /* 0x07 */ { "JOB_NOTIFY_FIELD_PARAMETERS", NULL },
 788         /* 0x08 */ { "JOB_NOTIFY_FIELD_DRIVER_NAME", NULL },
 789         /* 0x09 */ { "JOB_NOTIFY_FIELD_DEVMODE", NULL },
 790         /* 0x0a */ { "JOB_NOTIFY_FIELD_STATUS", notify_one_value },
 791         /* 0x0b */ { "JOB_NOTIFY_FIELD_STATUS_STRING", NULL },
 792         /* 0x0c */ { "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NULL },
 793         /* 0x0d */ { "JOB_NOTIFY_FIELD_DOCUMENT", notify_string },
 794         /* 0x0e */ { "JOB_NOTIFY_FIELD_PRIORITY", NULL },
 795         /* 0x0f */ { "JOB_NOTIFY_FIELD_POSITION", NULL },
 796         /* 0x10 */ { "JOB_NOTIFY_FIELD_SUBMITTED", notify_system_time },
 797         /* 0x11 */ { "JOB_NOTIFY_FIELD_START_TIME", NULL },
 798         /* 0x12 */ { "JOB_NOTIFY_FIELD_UNTIL_TIME", NULL },
 799         /* 0x13 */ { "JOB_NOTIFY_FIELD_TIME", NULL },
 800         /* 0x14 */ { "JOB_NOTIFY_FIELD_TOTAL_PAGES", notify_one_value },
 801         /* 0x15 */ { "JOB_NOTIFY_FIELD_PAGES_PRINTED", NULL },
 802         /* 0x16 */ { "JOB_NOTIFY_FIELD_TOTAL_BYTES", notify_one_value },
 803         /* 0x17 */ { "JOB_NOTIFY_FIELD_BYTES_PRINTED", NULL },
 804 };
 805
 806
 807 /***********************************************************************
 808  Allocate talloc context for container object
 809  **********************************************************************/
 810
 811 static void notify_msg_ctr_init( SPOOLSS_NOTIFY_MSG_CTR *ctr )
 812 {
 813         if ( !ctr )
 814                 return;
 815
 816         ctr->ctx = talloc_init("notify_msg_ctr_init %p", ctr);
 817
 818         return;
 819 }
 820
 821 /***********************************************************************
 822  release all allocated memory and zero out structure
 823  **********************************************************************/
 824
 825 static void notify_msg_ctr_destroy( SPOOLSS_NOTIFY_MSG_CTR *ctr )
 826 {
 827         if ( !ctr )
 828                 return;
 829
 830         if ( ctr->ctx )
 831                 talloc_destroy(ctr->ctx);
 832
 833         ZERO_STRUCTP(ctr);
 834
 835         return;
 836 }
 837
 838 /***********************************************************************
 839  **********************************************************************/
 840
 841 static TALLOC_CTX* notify_ctr_getctx( SPOOLSS_NOTIFY_MSG_CTR *ctr )
 842 {
 843         if ( !ctr )
 844                 return NULL;
 845
 846         return ctr->ctx;
 847 }
 848
 849 /***********************************************************************
 850  **********************************************************************/
 851
 852 static SPOOLSS_NOTIFY_MSG_GROUP* notify_ctr_getgroup( SPOOLSS_NOTIFY_MSG_CTR *ctr, uint32_t idx )
 853 {
 854         if ( !ctr || !ctr->msg_groups )
 855                 return NULL;
 856
 857         if ( idx >= ctr->num_groups )
 858                 return NULL;
 859
 860         return &ctr->msg_groups[idx];
 861
 862 }
 863
 864 /***********************************************************************
 865  How many groups of change messages do we have ?
 866  **********************************************************************/
 867
 868 static int notify_msg_ctr_numgroups( SPOOLSS_NOTIFY_MSG_CTR *ctr )
 869 {
 870         if ( !ctr )
 871                 return 0;
 872
 873         return ctr->num_groups;
 874 }
 875
 876 /***********************************************************************
 877  Add a SPOOLSS_NOTIFY_MSG_CTR to the correct group
 878  **********************************************************************/
 879
 880 static int notify_msg_ctr_addmsg( SPOOLSS_NOTIFY_MSG_CTR *ctr, SPOOLSS_NOTIFY_MSG *msg )
 881 {
 882         SPOOLSS_NOTIFY_MSG_GROUP        *groups = NULL;
 883         SPOOLSS_NOTIFY_MSG_GROUP        *msg_grp = NULL;
 884         SPOOLSS_NOTIFY_MSG              *msg_list = NULL;
 885         int                             i, new_slot;
 886
 887         if ( !ctr || !msg )
 888                 return 0;
 889
 890         /* loop over all groups looking for a matching printer name */
 891
 892         for ( i=0; i<ctr->num_groups; i++ ) {
 893                 if ( strcmp(ctr->msg_groups[i].printername, msg->printer) == 0 )
 894                         break;
 895         }
 896
 897         /* add a new group? */
 898
 899         if ( i == ctr->num_groups ) {
 900                 ctr->num_groups++;
 901
 902                 if ( !(groups = TALLOC_REALLOC_ARRAY( ctr->ctx, ctr->msg_groups, SPOOLSS_NOTIFY_MSG_GROUP, ctr->num_groups)) ) {
 903                         DEBUG(0,("notify_msg_ctr_addmsg: talloc_realloc() failed!\n"));
 904                         return 0;
 905                 }
 906                 ctr->msg_groups = groups;
 907
 908                 /* clear the new entry and set the printer name */
 909
 910                 ZERO_STRUCT( ctr->msg_groups[ctr->num_groups-1] );
 911                 fstrcpy( ctr->msg_groups[ctr->num_groups-1].printername, msg->printer );
 912         }
 913
 914         /* add the change messages; 'i' is the correct index now regardless */
 915
 916         msg_grp = &ctr->msg_groups[i];
 917
 918         msg_grp->num_msgs++;
 919
 920         if ( !(msg_list = TALLOC_REALLOC_ARRAY( ctr->ctx, msg_grp->msgs, SPOOLSS_NOTIFY_MSG, msg_grp->num_msgs )) ) {
 921                 DEBUG(0,("notify_msg_ctr_addmsg: talloc_realloc() failed for new message [%d]!\n", msg_grp->num_msgs));
 922                 return 0;
 923         }
 924         msg_grp->msgs = msg_list;
 925
 926         new_slot = msg_grp->num_msgs-1;
 927         memcpy( &msg_grp->msgs[new_slot], msg, sizeof(SPOOLSS_NOTIFY_MSG) );
 928
 929         /* need to allocate own copy of data */
 930
 931         if ( msg->len != 0 )
 932                 msg_grp->msgs[new_slot].notify.data = (char *)
 933                         TALLOC_MEMDUP( ctr->ctx, msg->notify.data, msg->len );
 934
 935         return ctr->num_groups;
 936 }
 937
 938 /***********************************************************************
 939  Send a change notication message on all handles which have a call
 940  back registered
 941  **********************************************************************/
 942
 943 static void send_notify2_changes( SPOOLSS_NOTIFY_MSG_CTR *ctr, uint32_t idx )
 944 {
 945         Printer_entry            *p;
 946         TALLOC_CTX               *mem_ctx = notify_ctr_getctx( ctr );
 947         SPOOLSS_NOTIFY_MSG_GROUP *msg_group = notify_ctr_getgroup( ctr, idx );
 948         SPOOLSS_NOTIFY_MSG       *messages;
 949         int                      sending_msg_count;
 950
 951         if ( !msg_group ) {
 952                 DEBUG(5,("send_notify2_changes() called with no msg group!\n"));
 953                 return;
 954         }
 955
 956         messages = msg_group->msgs;
 957
 958         if ( !messages ) {
 959                 DEBUG(5,("send_notify2_changes() called with no messages!\n"));
 960                 return;
 961         }
 962
 963         DEBUG(8,("send_notify2_changes: Enter...[%s]\n", msg_group->printername));
 964
 965         /* loop over all printers */
 966
 967         for (p = printers_list; p; p = p->next) {
 968                 struct spoolss_Notify *notifies;
 969                 uint32_t count = 0;
 970                 uint32_t id;
 971                 int     i;
 972
 973                 /* Is there notification on this handle? */
 974
 975                 if ( !p->notify.client_connected )
 976                         continue;
 977
 978                 DEBUG(10,("Client connected! [\\\\%s\\%s]\n", p->servername, p->sharename));
 979
 980                 /* For this printer?  Print servers always receive
 981                    notifications. */
 982
 983                 if ( ( p->printer_type == SPLHND_PRINTER )  &&
 984                     ( !strequal(msg_group->printername, p->sharename) ) )
 985                         continue;
 986
 987                 DEBUG(10,("Our printer\n"));
 988
 989                 /* allocate the max entries possible */
 990
 991                 notifies = TALLOC_ZERO_ARRAY(mem_ctx, struct spoolss_Notify, msg_group->num_msgs);
 992                 if (!notifies) {
 993                         return;
 994                 }
 995
 996                 /* build the array of change notifications */
 997
 998                 sending_msg_count = 0;
 999
1000                 for ( i=0; i<msg_group->num_msgs; i++ ) {
1001                         SPOOLSS_NOTIFY_MSG      *msg = &messages[i];
1002
1003                         /* Are we monitoring this event? */
1004
1005                         if (!is_monitoring_event(p, msg->type, msg->field))
1006                                 continue;
1007
1008                         sending_msg_count++;
1009
1010
1011                         DEBUG(10,("process_notify2_message: Sending message type [0x%x] field [0x%2x] for printer [%s]\n",
1012                                 msg->type, msg->field, p->sharename));
1013
1014                         /*
1015                          * if the is a printer notification handle and not a job notification
1016                          * type, then set the id to 0.  Other wise just use what was specified
1017                          * in the message.
1018                          *
1019                          * When registering change notification on a print server handle
1020                          * we always need to send back the id (snum) matching the printer
1021                          * for which the change took place.  For change notify registered
1022                          * on a printer handle, this does not matter and the id should be 0.
1023                          *
1024                          * --jerry
1025                          */
1026
1027                         if ( ( p->printer_type == SPLHND_PRINTER ) && ( msg->type == PRINTER_NOTIFY_TYPE ) )
1028                                 id = 0;
1029                         else
1030                                 id = msg->id;
1031
1032
1033                         /* Convert unix jobid to smb jobid */
1034
1035                         if (msg->flags & SPOOLSS_NOTIFY_MSG_UNIX_JOBID) {
1036                                 id = sysjob_to_jobid(msg->id);
1037
1038                                 if (id == -1) {
1039                                         DEBUG(3, ("no such unix jobid %d\n", msg->id));
1040                                         goto done;
1041                                 }
1042                         }
1043
1044                         construct_info_data( &notifies[count], msg->type, msg->field, id );
1045
1046                         switch(msg->type) {
1047                         case PRINTER_NOTIFY_TYPE:
1048                                 if ( printer_notify_table[msg->field].fn )
1049                                         printer_notify_table[msg->field].fn(msg, &notifies[count], mem_ctx);
1050                                 break;
1051
1052                         case JOB_NOTIFY_TYPE:
1053                                 if ( job_notify_table[msg->field].fn )
1054                                         job_notify_table[msg->field].fn(msg, &notifies[count], mem_ctx);
1055                                 break;
1056
1057                         default:
1058                                 DEBUG(5, ("Unknown notification type %d\n", msg->type));
1059                                 goto done;
1060                         }
1061
1062                         count++;
1063                 }
1064
1065                 if ( sending_msg_count ) {
1066                         NTSTATUS status;
1067                         WERROR werr;
1068                         union spoolss_ReplyPrinterInfo info;
1069                         struct spoolss_NotifyInfo info0;
1070                         uint32_t reply_result;
1071
1072                         info0.version   = 0x2;
1073                         info0.flags     = count ? 0x00020000 /* ??? */ : PRINTER_NOTIFY_INFO_DISCARDED;
1074                         info0.count     = count;
1075                         info0.notifies  = notifies;
1076
1077                         info.info0 = &info0;
1078
1079                         status = rpccli_spoolss_RouterReplyPrinterEx(notify_cli_pipe, mem_ctx,
1080                                                                      &p->notify.client_hnd,
1081                                                                      p->notify.change, /* color */
1082                                                                      p->notify.flags,
1083                                                                      &reply_result,
1084                                                                      0, /* reply_type, must be 0 */
1085                                                                      info,
1086                                                                      &werr);
1087                         if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(werr)) {
1088                                 DEBUG(1,("RouterReplyPrinterEx to client: %s failed: %s\n",
1089                                         notify_cli_pipe->srv_name_slash,
1090                                         win_errstr(werr)));
1091                         }
1092                         switch (reply_result) {
1093                                 case 0:
1094                                         break;
1095                                 case PRINTER_NOTIFY_INFO_DISCARDED:
1096                                 case PRINTER_NOTIFY_INFO_DISCARDNOTED:
1097                                 case PRINTER_NOTIFY_INFO_COLOR_MISMATCH:
1098                                         break;
1099                                 default:
1100                                         break;
1101                         }
1102                 }
1103         }
1104
1105 done:
1106         DEBUG(8,("send_notify2_changes: Exit...\n"));
1107         return;
1108 }
1109
1110 /***********************************************************************
1111  **********************************************************************/
1112
1113 static bool notify2_unpack_msg( SPOOLSS_NOTIFY_MSG *msg, struct timeval *tv, void *buf, size_t len )
1114 {
1115
1116         uint32_t tv_sec, tv_usec;
1117         size_t offset = 0;
1118
1119         /* Unpack message */
1120
1121         offset += tdb_unpack((uint8_t *)buf + offset, len - offset, "f",
1122                              msg->printer);
1123
1124         offset += tdb_unpack((uint8_t *)buf + offset, len - offset, "ddddddd",
1125                                 &tv_sec, &tv_usec,
1126                                 &msg->type, &msg->field, &msg->id, &msg->len, &msg->flags);
1127
1128         if (msg->len == 0)
1129                 tdb_unpack((uint8_t *)buf + offset, len - offset, "dd",
1130                            &msg->notify.value[0], &msg->notify.value[1]);
1131         else
1132                 tdb_unpack((uint8_t *)buf + offset, len - offset, "B",
1133                            &msg->len, &msg->notify.data);
1134
1135         DEBUG(3, ("notify2_unpack_msg: got NOTIFY2 message for printer %s, jobid %u type %d, field 0x%02x, flags 0x%04x\n",
1136                   msg->printer, (unsigned int)msg->id, msg->type, msg->field, msg->flags));
1137
1138         tv->tv_sec = tv_sec;
1139         tv->tv_usec = tv_usec;
1140
1141         if (msg->len == 0)
1142                 DEBUG(3, ("notify2_unpack_msg: value1 = %d, value2 = %d\n", msg->notify.value[0],
1143                           msg->notify.value[1]));
1144         else
1145                 dump_data(3, (uint8_t *)msg->notify.data, msg->len);
1146
1147         return true;
1148 }
1149
1150 /********************************************************************
1151  Receive a notify2 message list
1152  ********************************************************************/
1153
1154 static void receive_notify2_message_list(struct messaging_context *msg,
1155                                          void *private_data,
1156                                          uint32_t msg_type,
1157                                          struct server_id server_id,
1158                                          DATA_BLOB *data)
1159 {
1160         size_t                  msg_count, i;
1161         char                    *buf = (char *)data->data;
1162         char                    *msg_ptr;
1163         size_t                  msg_len;
1164         SPOOLSS_NOTIFY_MSG      notify;
1165         SPOOLSS_NOTIFY_MSG_CTR  messages;
1166         int                     num_groups;
1167
1168         if (data->length < 4) {
1169                 DEBUG(0,("receive_notify2_message_list: bad message format (len < 4)!\n"));
1170                 return;
1171         }
1172
1173         msg_count = IVAL(buf, 0);
1174         msg_ptr = buf + 4;
1175
1176         DEBUG(5, ("receive_notify2_message_list: got %lu messages in list\n", (unsigned long)msg_count));
1177
1178         if (msg_count == 0) {
1179                 DEBUG(0,("receive_notify2_message_list: bad message format (msg_count == 0) !\n"));
1180                 return;
1181         }
1182
1183         /* initialize the container */
1184
1185         ZERO_STRUCT( messages );
1186         notify_msg_ctr_init( &messages );
1187
1188         /*
1189          * build message groups for each printer identified
1190          * in a change_notify msg.  Remember that a PCN message
1191          * includes the handle returned for the srv_spoolss_replyopenprinter()
1192          * call.  Therefore messages are grouped according to printer handle.
1193          */
1194
1195         for ( i=0; i<msg_count; i++ ) {
1196                 struct timeval msg_tv;
1197
1198                 if (msg_ptr + 4 - buf > data->length) {
1199                         DEBUG(0,("receive_notify2_message_list: bad message format (len > buf_size) !\n"));
1200                         return;
1201                 }
1202
1203                 msg_len = IVAL(msg_ptr,0);
1204                 msg_ptr += 4;
1205
1206                 if (msg_ptr + msg_len - buf > data->length) {
1207                         DEBUG(0,("receive_notify2_message_list: bad message format (bad len) !\n"));
1208                         return;
1209                 }
1210
1211                 /* unpack messages */
1212
1213                 ZERO_STRUCT( notify );
1214                 notify2_unpack_msg( &notify, &msg_tv, msg_ptr, msg_len );
1215                 msg_ptr += msg_len;
1216
1217                 /* add to correct list in container */
1218
1219                 notify_msg_ctr_addmsg( &messages, &notify );
1220
1221                 /* free memory that might have been allocated by notify2_unpack_msg() */
1222
1223                 if ( notify.len != 0 )
1224                         SAFE_FREE( notify.notify.data );
1225         }
1226
1227         /* process each group of messages */
1228
1229         num_groups = notify_msg_ctr_numgroups( &messages );
1230         for ( i=0; i<num_groups; i++ )
1231                 send_notify2_changes( &messages, i );
1232
1233
1234         /* cleanup */
1235
1236         DEBUG(10,("receive_notify2_message_list: processed %u messages\n",
1237                 (uint32_t)msg_count ));
1238
1239         notify_msg_ctr_destroy( &messages );
1240
1241         return;
1242 }
1243
1244 /********************************************************************
1245  Send a message to ourself about new driver being installed
1246  so we can upgrade the information for each printer bound to this
1247  driver
1248  ********************************************************************/
1249
1250 static bool srv_spoolss_drv_upgrade_printer(const char *drivername)
1251 {
1252         int len = strlen(drivername);
1253
1254         if (!len)
1255                 return false;
1256
1257         DEBUG(10,("srv_spoolss_drv_upgrade_printer: Sending message about driver upgrade [%s]\n",
1258                 drivername));
1259
1260         messaging_send_buf(smbd_messaging_context(), procid_self(),
1261                            MSG_PRINTER_DRVUPGRADE,
1262                            (uint8_t *)drivername, len+1);
1263
1264         return true;
1265 }
1266
1267 /**********************************************************************
1268  callback to receive a MSG_PRINTER_DRVUPGRADE message and interate
1269  over all printers, upgrading ones as necessary
1270  **********************************************************************/
1271
1272 void do_drv_upgrade_printer(struct messaging_context *msg,
1273                             void *private_data,
1274                             uint32_t msg_type,
1275                             struct server_id server_id,
1276                             DATA_BLOB *data)
1277 {
1278         fstring drivername;
1279         int snum;
1280         int n_services = lp_numservices();
1281         size_t len;
1282
1283         len = MIN(data->length,sizeof(drivername)-1);
1284         strncpy(drivername, (const char *)data->data, len);
1285
1286         DEBUG(10,("do_drv_upgrade_printer: Got message for new driver [%s]\n", drivername ));
1287
1288         /* Iterate the printer list */
1289
1290         for (snum=0; snum<n_services; snum++)
1291         {
1292                 if (lp_snum_ok(snum) && lp_print_ok(snum) )
1293                 {
1294                         WERROR result;
1295                         NT_PRINTER_INFO_LEVEL *printer = NULL;
1296
1297                         result = get_a_printer(NULL, &printer, 2, lp_const_servicename(snum));
1298                         if (!W_ERROR_IS_OK(result))
1299                                 continue;
1300
1301                         if (printer && printer->info_2 && !strcmp(drivername, printer->info_2->drivername))
1302                         {
1303                                 DEBUG(6,("Updating printer [%s]\n", printer->info_2->printername));
1304
1305                                 /* all we care about currently is the change_id */
1306
1307                                 result = mod_a_printer(printer, 2);
1308                                 if (!W_ERROR_IS_OK(result)) {
1309                                         DEBUG(3,("do_drv_upgrade_printer: mod_a_printer() failed with status [%s]\n",
1310                                                 win_errstr(result)));
1311                                 }
1312                         }
1313
1314                         free_a_printer(&printer, 2);
1315                 }
1316         }
1317
1318         /* all done */
1319 }
1320
1321 /********************************************************************
1322  Update the cache for all printq's with a registered client
1323  connection
1324  ********************************************************************/
1325
1326 void update_monitored_printq_cache( void )
1327 {
1328         Printer_entry *printer = printers_list;
1329         int snum;
1330
1331         /* loop through all printers and update the cache where
1332            client_connected == true */
1333         while ( printer )
1334         {
1335                 if ( (printer->printer_type == SPLHND_PRINTER)
1336                         && printer->notify.client_connected )
1337                 {
1338                         snum = print_queue_snum(printer->sharename);
1339                         print_queue_status( snum, NULL, NULL );
1340                 }
1341
1342                 printer = printer->next;
1343         }
1344
1345         return;
1346 }
1347 /********************************************************************
1348  Send a message to ourself about new driver being installed
1349  so we can upgrade the information for each printer bound to this
1350  driver
1351  ********************************************************************/
1352
1353 static bool srv_spoolss_reset_printerdata(char* drivername)
1354 {
1355         int len = strlen(drivername);
1356
1357         if (!len)
1358                 return false;
1359
1360         DEBUG(10,("srv_spoolss_reset_printerdata: Sending message about resetting printerdata [%s]\n",
1361                 drivername));
1362
1363         messaging_send_buf(smbd_messaging_context(), procid_self(),
1364                            MSG_PRINTERDATA_INIT_RESET,
1365                            (uint8_t *)drivername, len+1);
1366
1367         return true;
1368 }
1369
1370 /**********************************************************************
1371  callback to receive a MSG_PRINTERDATA_INIT_RESET message and interate
1372  over all printers, resetting printer data as neessary
1373  **********************************************************************/
1374
1375 void reset_all_printerdata(struct messaging_context *msg,
1376                            void *private_data,
1377                            uint32_t msg_type,
1378                            struct server_id server_id,
1379                            DATA_BLOB *data)
1380 {
1381         fstring drivername;
1382         int snum;
1383         int n_services = lp_numservices();
1384         size_t len;
1385
1386         len = MIN( data->length, sizeof(drivername)-1 );
1387         strncpy( drivername, (const char *)data->data, len );
1388
1389         DEBUG(10,("reset_all_printerdata: Got message for new driver [%s]\n", drivername ));
1390
1391         /* Iterate the printer list */
1392
1393         for ( snum=0; snum<n_services; snum++ )
1394         {
1395                 if ( lp_snum_ok(snum) && lp_print_ok(snum) )
1396                 {
1397                         WERROR result;
1398                         NT_PRINTER_INFO_LEVEL *printer = NULL;
1399
1400                         result = get_a_printer( NULL, &printer, 2, lp_const_servicename(snum) );
1401                         if ( !W_ERROR_IS_OK(result) )
1402                                 continue;
1403
1404                         /*
1405                          * if the printer is bound to the driver,
1406                          * then reset to the new driver initdata
1407                          */
1408
1409                         if ( printer && printer->info_2 && !strcmp(drivername, printer->info_2->drivername) )
1410                         {
1411                                 DEBUG(6,("reset_all_printerdata: Updating printer [%s]\n", printer->info_2->printername));
1412
1413                                 if ( !set_driver_init(printer, 2) ) {
1414                                         DEBUG(5,("reset_all_printerdata: Error resetting printer data for printer [%s], driver [%s]!\n",
1415                                                 printer->info_2->printername, printer->info_2->drivername));
1416                                 }
1417
1418                                 result = mod_a_printer( printer, 2 );
1419                                 if ( !W_ERROR_IS_OK(result) ) {
1420                                         DEBUG(3,("reset_all_printerdata: mod_a_printer() failed!  (%s)\n",
1421                                                 get_dos_error_msg(result)));
1422                                 }
1423                         }
1424
1425                         free_a_printer( &printer, 2 );
1426                 }
1427         }
1428
1429         /* all done */
1430
1431         return;
1432 }
1433
1434 /****************************************************************
1435  _spoolss_OpenPrinter
1436 ****************************************************************/
1437
1438 WERROR _spoolss_OpenPrinter(pipes_struct *p,
1439                             struct spoolss_OpenPrinter *r)
1440 {
1441         struct spoolss_OpenPrinterEx e;
1442         WERROR werr;
1443
1444         ZERO_STRUCT(e.in.userlevel);
1445
1446         e.in.printername        = r->in.printername;
1447         e.in.datatype           = r->in.datatype;
1448         e.in.devmode_ctr        = r->in.devmode_ctr;
1449         e.in.access_mask        = r->in.access_mask;
1450         e.in.level              = 0;
1451
1452         e.out.handle            = r->out.handle;
1453
1454         werr = _spoolss_OpenPrinterEx(p, &e);
1455
1456         if (W_ERROR_EQUAL(werr, WERR_INVALID_PARAM)) {
1457                 /* OpenPrinterEx returns this for a bad
1458                  * printer name. We must return WERR_INVALID_PRINTER_NAME
1459                  * instead.
1460                  */
1461                 werr = WERR_INVALID_PRINTER_NAME;
1462         }
1463
1464         return werr;
1465 }
1466
1467 /********************************************************************
1468  ********************************************************************/
1469
1470 bool convert_devicemode(const char *printername,
1471                         const struct spoolss_DeviceMode *devmode,
1472                         NT_DEVICEMODE **pp_nt_devmode)
1473 {
1474         NT_DEVICEMODE *nt_devmode = *pp_nt_devmode;
1475
1476         /*
1477          * Ensure nt_devmode is a valid pointer
1478          * as we will be overwriting it.
1479          */
1480
1481         if (nt_devmode == NULL) {
1482                 DEBUG(5, ("convert_devicemode: allocating a generic devmode\n"));
1483                 if ((nt_devmode = construct_nt_devicemode(printername)) == NULL)
1484                         return false;
1485         }
1486
1487         fstrcpy(nt_devmode->devicename, devmode->devicename);
1488         fstrcpy(nt_devmode->formname, devmode->formname);
1489
1490         nt_devmode->devicename[31] = '\0';
1491         nt_devmode->formname[31] = '\0';
1492
1493         nt_devmode->specversion         = devmode->specversion;
1494         nt_devmode->driverversion       = devmode->driverversion;
1495         nt_devmode->size                = devmode->size;
1496         nt_devmode->fields              = devmode->fields;
1497         nt_devmode->orientation         = devmode->orientation;
1498         nt_devmode->papersize           = devmode->papersize;
1499         nt_devmode->paperlength         = devmode->paperlength;
1500         nt_devmode->paperwidth          = devmode->paperwidth;
1501         nt_devmode->scale               = devmode->scale;
1502         nt_devmode->copies              = devmode->copies;
1503         nt_devmode->defaultsource       = devmode->defaultsource;
1504         nt_devmode->printquality        = devmode->printquality;
1505         nt_devmode->color               = devmode->color;
1506         nt_devmode->duplex              = devmode->duplex;
1507         nt_devmode->yresolution         = devmode->yresolution;
1508         nt_devmode->ttoption            = devmode->ttoption;
1509         nt_devmode->collate             = devmode->collate;
1510
1511         nt_devmode->logpixels           = devmode->logpixels;
1512         nt_devmode->bitsperpel          = devmode->bitsperpel;
1513         nt_devmode->pelswidth           = devmode->pelswidth;
1514         nt_devmode->pelsheight          = devmode->pelsheight;
1515         nt_devmode->displayflags        = devmode->displayflags;
1516         nt_devmode->displayfrequency    = devmode->displayfrequency;
1517         nt_devmode->icmmethod           = devmode->icmmethod;
1518         nt_devmode->icmintent           = devmode->icmintent;
1519         nt_devmode->mediatype           = devmode->mediatype;
1520         nt_devmode->dithertype          = devmode->dithertype;
1521         nt_devmode->reserved1           = devmode->reserved1;
1522         nt_devmode->reserved2           = devmode->reserved2;
1523         nt_devmode->panningwidth        = devmode->panningwidth;
1524         nt_devmode->panningheight       = devmode->panningheight;
1525
1526         /*
1527          * Only change private and driverextra if the incoming devmode
1528          * has a new one. JRA.
1529          */
1530
1531         if ((devmode->__driverextra_length != 0) && (devmode->driverextra_data.data != NULL)) {
1532                 SAFE_FREE(nt_devmode->nt_dev_private);
1533                 nt_devmode->driverextra = devmode->__driverextra_length;
1534                 if((nt_devmode->nt_dev_private = SMB_MALLOC_ARRAY(uint8_t, nt_devmode->driverextra)) == NULL)
1535                         return false;
1536                 memcpy(nt_devmode->nt_dev_private, devmode->driverextra_data.data, nt_devmode->driverextra);
1537         }
1538
1539         *pp_nt_devmode = nt_devmode;
1540
1541         return true;
1542 }
1543
1544 /****************************************************************
1545  _spoolss_OpenPrinterEx
1546 ****************************************************************/
1547
1548 WERROR _spoolss_OpenPrinterEx(pipes_struct *p,
1549                               struct spoolss_OpenPrinterEx *r)
1550 {
1551         int snum;
1552         Printer_entry *Printer=NULL;
1553
1554         if (!r->in.printername) {
1555                 return WERR_INVALID_PARAM;
1556         }
1557
1558         /* some sanity check because you can open a printer or a print server */
1559         /* aka: \\server\printer or \\server */
1560
1561         DEBUGADD(3,("checking name: %s\n", r->in.printername));
1562
1563         if (!open_printer_hnd(p, r->out.handle, r->in.printername, 0)) {
1564                 ZERO_STRUCTP(r->out.handle);
1565                 return WERR_INVALID_PARAM;
1566         }
1567
1568         Printer = find_printer_index_by_hnd(p, r->out.handle);
1569         if ( !Printer ) {
1570                 DEBUG(0,("_spoolss_OpenPrinterEx: logic error.  Can't find printer "
1571                         "handle we created for printer %s\n", r->in.printername));
1572                 close_printer_handle(p, r->out.handle);
1573                 ZERO_STRUCTP(r->out.handle);
1574                 return WERR_INVALID_PARAM;
1575         }
1576
1577         /*
1578          * First case: the user is opening the print server:
1579          *
1580          * Disallow MS AddPrinterWizard if parameter disables it. A Win2k
1581          * client 1st tries an OpenPrinterEx with access==0, MUST be allowed.
1582          *
1583          * Then both Win2k and WinNT clients try an OpenPrinterEx with
1584          * SERVER_ALL_ACCESS, which we allow only if the user is root (uid=0)
1585          * or if the user is listed in the smb.conf printer admin parameter.
1586          *
1587          * Then they try OpenPrinterEx with SERVER_READ which we allow. This lets the
1588          * client view printer folder, but does not show the MSAPW.
1589          *
1590          * Note: this test needs code to check access rights here too. Jeremy
1591          * could you look at this?
1592          *
1593          * Second case: the user is opening a printer:
1594          * NT doesn't let us connect to a printer if the connecting user
1595          * doesn't have print permission.
1596          *
1597          * Third case: user is opening a Port Monitor
1598          * access checks same as opening a handle to the print server.
1599          */
1600
1601         switch (Printer->printer_type )
1602         {
1603         case SPLHND_SERVER:
1604         case SPLHND_PORTMON_TCP:
1605         case SPLHND_PORTMON_LOCAL:
1606                 /* Printserver handles use global struct... */
1607
1608                 snum = -1;
1609
1610                 /* Map standard access rights to object specific access rights */
1611
1612                 se_map_standard(&r->in.access_mask,
1613                                 &printserver_std_mapping);
1614
1615                 /* Deny any object specific bits that don't apply to print
1616                    servers (i.e printer and job specific bits) */
1617
1618                 r->in.access_mask &= SPECIFIC_RIGHTS_MASK;
1619
1620                 if (r->in.access_mask &
1621                     ~(SERVER_ACCESS_ADMINISTER | SERVER_ACCESS_ENUMERATE)) {
1622                         DEBUG(3, ("access DENIED for non-printserver bits\n"));
1623                         close_printer_handle(p, r->out.handle);
1624                         ZERO_STRUCTP(r->out.handle);
1625                         return WERR_ACCESS_DENIED;
1626                 }
1627
1628                 /* Allow admin access */
1629
1630                 if ( r->in.access_mask & SERVER_ACCESS_ADMINISTER )
1631                 {
1632                         SE_PRIV se_printop = SE_PRINT_OPERATOR;
1633
1634                         if (!lp_ms_add_printer_wizard()) {
1635                                 close_printer_handle(p, r->out.handle);
1636                                 ZERO_STRUCTP(r->out.handle);
1637                                 return WERR_ACCESS_DENIED;
1638                         }
1639
1640                         /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
1641                            and not a printer admin, then fail */
1642
1643                         if ((p->server_info->utok.uid != sec_initial_uid()) &&
1644                             !user_has_privileges(p->server_info->ptok,
1645                                                  &se_printop ) &&
1646                             !token_contains_name_in_list(
1647                                     uidtoname(p->server_info->utok.uid),
1648                                     NULL, NULL,
1649                                     p->server_info->ptok,
1650                                     lp_printer_admin(snum))) {
1651                                 close_printer_handle(p, r->out.handle);
1652                                 ZERO_STRUCTP(r->out.handle);
1653                                 return WERR_ACCESS_DENIED;
1654                         }
1655
1656                         r->in.access_mask = SERVER_ACCESS_ADMINISTER;
1657                 }
1658                 else
1659                 {
1660                         r->in.access_mask = SERVER_ACCESS_ENUMERATE;
1661                 }
1662
1663                 DEBUG(4,("Setting print server access = %s\n", (r->in.access_mask == SERVER_ACCESS_ADMINISTER)
1664                         ? "SERVER_ACCESS_ADMINISTER" : "SERVER_ACCESS_ENUMERATE" ));
1665
1666                 /* We fall through to return WERR_OK */
1667                 break;
1668
1669         case SPLHND_PRINTER:
1670                 /* NT doesn't let us connect to a printer if the connecting user
1671                    doesn't have print permission.  */
1672
1673                 if (!get_printer_snum(p, r->out.handle, &snum, NULL)) {
1674                         close_printer_handle(p, r->out.handle);
1675                         ZERO_STRUCTP(r->out.handle);
1676                         return WERR_BADFID;
1677                 }
1678
1679                 if (r->in.access_mask == SEC_FLAG_MAXIMUM_ALLOWED) {
1680                         r->in.access_mask = PRINTER_ACCESS_ADMINISTER;
1681                 }
1682
1683                 se_map_standard(&r->in.access_mask, &printer_std_mapping);
1684
1685                 /* map an empty access mask to the minimum access mask */
1686                 if (r->in.access_mask == 0x0)
1687                         r->in.access_mask = PRINTER_ACCESS_USE;
1688
1689                 /*
1690                  * If we are not serving the printer driver for this printer,
1691                  * map PRINTER_ACCESS_ADMINISTER to PRINTER_ACCESS_USE.  This
1692                  * will keep NT clients happy  --jerry
1693                  */
1694
1695                 if (lp_use_client_driver(snum)
1696                         && (r->in.access_mask & PRINTER_ACCESS_ADMINISTER))
1697                 {
1698                         r->in.access_mask = PRINTER_ACCESS_USE;
1699                 }
1700
1701                 /* check smb.conf parameters and the the sec_desc */
1702
1703                 if ( !check_access(get_client_fd(), lp_hostsallow(snum), lp_hostsdeny(snum)) ) {
1704                         DEBUG(3, ("access DENIED (hosts allow/deny) for printer open\n"));
1705                         ZERO_STRUCTP(r->out.handle);
1706                         return WERR_ACCESS_DENIED;
1707                 }
1708
1709                 if (!user_ok_token(uidtoname(p->server_info->utok.uid), NULL,
1710                                    p->server_info->ptok, snum) ||
1711                     !print_access_check(p->server_info, snum,
1712                                         r->in.access_mask)) {
1713                         DEBUG(3, ("access DENIED for printer open\n"));
1714                         close_printer_handle(p, r->out.handle);
1715                         ZERO_STRUCTP(r->out.handle);
1716                         return WERR_ACCESS_DENIED;
1717                 }
1718
1719                 if ((r->in.access_mask & SPECIFIC_RIGHTS_MASK)& ~(PRINTER_ACCESS_ADMINISTER|PRINTER_ACCESS_USE)) {
1720                         DEBUG(3, ("access DENIED for printer open - unknown bits\n"));
1721                         close_printer_handle(p, r->out.handle);
1722                         ZERO_STRUCTP(r->out.handle);
1723                         return WERR_ACCESS_DENIED;
1724                 }
1725
1726                 if (r->in.access_mask & PRINTER_ACCESS_ADMINISTER)
1727                         r->in.access_mask = PRINTER_ACCESS_ADMINISTER;
1728                 else
1729                         r->in.access_mask = PRINTER_ACCESS_USE;
1730
1731                 DEBUG(4,("Setting printer access = %s\n", (r->in.access_mask == PRINTER_ACCESS_ADMINISTER)
1732                         ? "PRINTER_ACCESS_ADMINISTER" : "PRINTER_ACCESS_USE" ));
1733
1734                 break;
1735
1736         default:
1737                 /* sanity check to prevent programmer error */
1738                 ZERO_STRUCTP(r->out.handle);
1739                 return WERR_BADFID;
1740         }
1741
1742         Printer->access_granted = r->in.access_mask;
1743
1744         /*
1745          * If the client sent a devmode in the OpenPrinter() call, then
1746          * save it here in case we get a job submission on this handle
1747          */
1748
1749          if ((Printer->printer_type != SPLHND_SERVER) &&
1750              r->in.devmode_ctr.devmode) {
1751                 convert_devicemode(Printer->sharename,
1752                                    r->in.devmode_ctr.devmode,
1753                                    &Printer->nt_devmode);
1754          }
1755
1756 #if 0   /* JERRY -- I'm doubtful this is really effective */
1757         /* HACK ALERT!!! Sleep for 1/3 of a second to try trigger a LAN/WAN
1758            optimization in Windows 2000 clients  --jerry */
1759
1760         if ( (r->in.access_mask == PRINTER_ACCESS_ADMINISTER)
1761                 && (RA_WIN2K == get_remote_arch()) )
1762         {
1763                 DEBUG(10,("_spoolss_OpenPrinterEx: Enabling LAN/WAN hack for Win2k clients.\n"));
1764                 sys_usleep( 500000 );
1765         }
1766 #endif
1767
1768         return WERR_OK;
1769 }
1770
1771 /****************************************************************************
1772 ****************************************************************************/
1773
1774 static bool printer_info2_to_nt_printer_info2(struct spoolss_SetPrinterInfo2 *r,
1775                                               NT_PRINTER_INFO_LEVEL_2 *d)
1776 {
1777         DEBUG(7,("printer_info2_to_nt_printer_info2\n"));
1778
1779         if (!r || !d) {
1780                 return false;
1781         }
1782
1783         d->attributes           = r->attributes;
1784         d->priority             = r->priority;
1785         d->default_priority     = r->defaultpriority;
1786         d->starttime            = r->starttime;
1787         d->untiltime            = r->untiltime;
1788         d->status               = r->status;
1789         d->cjobs                = r->cjobs;
1790
1791         fstrcpy(d->servername,  r->servername);
1792         fstrcpy(d->printername, r->printername);
1793         fstrcpy(d->sharename,   r->sharename);
1794         fstrcpy(d->portname,    r->portname);
1795         fstrcpy(d->drivername,  r->drivername);
1796         slprintf(d->comment, sizeof(d->comment)-1, "%s", r->comment);
1797         fstrcpy(d->location,    r->location);
1798         fstrcpy(d->sepfile,     r->sepfile);
1799         fstrcpy(d->printprocessor, r->printprocessor);
1800         fstrcpy(d->datatype,    r->datatype);
1801         fstrcpy(d->parameters,  r->parameters);
1802
1803         return true;
1804 }
1805
1806 /****************************************************************************
1807 ****************************************************************************/
1808
1809 static bool convert_printer_info(struct spoolss_SetPrinterInfoCtr *info_ctr,
1810                                  NT_PRINTER_INFO_LEVEL *printer)
1811 {
1812         bool ret;
1813
1814         switch (info_ctr->level) {
1815         case 2:
1816                 /* allocate memory if needed.  Messy because
1817                    convert_printer_info is used to update an existing
1818                    printer or build a new one */
1819
1820                 if (!printer->info_2) {
1821                         printer->info_2 = TALLOC_ZERO_P(printer, NT_PRINTER_INFO_LEVEL_2);
1822                         if (!printer->info_2) {
1823                                 DEBUG(0,("convert_printer_info: "
1824                                         "talloc() failed!\n"));
1825                                 return false;
1826                         }
1827                 }
1828
1829                 ret = printer_info2_to_nt_printer_info2(info_ctr->info.info2,
1830                                                         printer->info_2);
1831                 printer->info_2->setuptime = time(NULL);
1832                 return ret;
1833         }
1834
1835         return false;
1836 }
1837
1838 /****************************************************************
1839  _spoolss_ClosePrinter
1840 ****************************************************************/
1841
1842 WERROR _spoolss_ClosePrinter(pipes_struct *p,
1843                              struct spoolss_ClosePrinter *r)
1844 {
1845         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
1846
1847         if (Printer && Printer->document_started) {
1848                 struct spoolss_EndDocPrinter e;
1849
1850                 e.in.handle = r->in.handle;
1851
1852                 _spoolss_EndDocPrinter(p, &e);
1853         }
1854
1855         if (!close_printer_handle(p, r->in.handle))
1856                 return WERR_BADFID;
1857
1858         /* clear the returned printer handle.  Observed behavior
1859            from Win2k server.  Don't think this really matters.
1860            Previous code just copied the value of the closed
1861            handle.    --jerry */
1862
1863         ZERO_STRUCTP(r->out.handle);
1864
1865         return WERR_OK;
1866 }
1867
1868 /****************************************************************
1869  _spoolss_DeletePrinter
1870 ****************************************************************/
1871
1872 WERROR _spoolss_DeletePrinter(pipes_struct *p,
1873                               struct spoolss_DeletePrinter *r)
1874 {
1875         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
1876         WERROR result;
1877
1878         if (Printer && Printer->document_started) {
1879                 struct spoolss_EndDocPrinter e;
1880
1881                 e.in.handle = r->in.handle;
1882
1883                 _spoolss_EndDocPrinter(p, &e);
1884         }
1885
1886         result = delete_printer_handle(p, r->in.handle);
1887
1888         update_c_setprinter(false);
1889
1890         return result;
1891 }
1892
1893 /*******************************************************************
1894  * static function to lookup the version id corresponding to an
1895  * long architecture string
1896  ******************************************************************/
1897
1898 static const struct print_architecture_table_node archi_table[]= {
1899
1900         {"Windows 4.0",          SPL_ARCH_WIN40,        0 },
1901         {"Windows NT x86",       SPL_ARCH_W32X86,       2 },
1902         {"Windows NT R4000",     SPL_ARCH_W32MIPS,      2 },
1903         {"Windows NT Alpha_AXP", SPL_ARCH_W32ALPHA,     2 },
1904         {"Windows NT PowerPC",   SPL_ARCH_W32PPC,       2 },
1905         {"Windows IA64",         SPL_ARCH_IA64,         3 },
1906         {"Windows x64",          SPL_ARCH_X64,          3 },
1907         {NULL,                   "",            -1 }
1908 };
1909
1910 static int get_version_id(const char *arch)
1911 {
1912         int i;
1913
1914         for (i=0; archi_table[i].long_archi != NULL; i++)
1915         {
1916                 if (strcmp(arch, archi_table[i].long_archi) == 0)
1917                         return (archi_table[i].version);
1918         }
1919
1920         return -1;
1921 }
1922
1923 /****************************************************************
1924  _spoolss_DeletePrinterDriver
1925 ****************************************************************/
1926
1927 WERROR _spoolss_DeletePrinterDriver(pipes_struct *p,
1928                                     struct spoolss_DeletePrinterDriver *r)
1929 {
1930
1931         struct spoolss_DriverInfo8 *info = NULL;
1932         struct spoolss_DriverInfo8 *info_win2k = NULL;
1933         int                             version;
1934         WERROR                          status;
1935         WERROR                          status_win2k = WERR_ACCESS_DENIED;
1936         SE_PRIV                         se_printop = SE_PRINT_OPERATOR;
1937
1938         /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
1939            and not a printer admin, then fail */
1940
1941         if ( (p->server_info->utok.uid != sec_initial_uid())
1942                 && !user_has_privileges(p->server_info->ptok, &se_printop )
1943                 && !token_contains_name_in_list(
1944                         uidtoname(p->server_info->utok.uid), NULL,
1945                         NULL, p->server_info->ptok,
1946                         lp_printer_admin(-1)) )
1947         {
1948                 return WERR_ACCESS_DENIED;
1949         }
1950
1951         /* check that we have a valid driver name first */
1952
1953         if ((version = get_version_id(r->in.architecture)) == -1)
1954                 return WERR_INVALID_ENVIRONMENT;
1955
1956         if (!W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx, &info, r->in.driver,
1957                                                 r->in.architecture,
1958                                                 version)))
1959         {
1960                 /* try for Win2k driver if "Windows NT x86" */
1961
1962                 if ( version == 2 ) {
1963                         version = 3;
1964                         if (!W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx,
1965                                                                 &info,
1966                                                                 r->in.driver,
1967                                                                 r->in.architecture,
1968                                                                 version))) {
1969                                 status = WERR_UNKNOWN_PRINTER_DRIVER;
1970                                 goto done;
1971                         }
1972                 }
1973                 /* otherwise it was a failure */
1974                 else {
1975                         status = WERR_UNKNOWN_PRINTER_DRIVER;
1976                         goto done;
1977                 }
1978
1979         }
1980
1981         if (printer_driver_in_use(info)) {
1982                 status = WERR_PRINTER_DRIVER_IN_USE;
1983                 goto done;
1984         }
1985
1986         if ( version == 2 )
1987         {
1988                 if (W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx,
1989                                                        &info_win2k,
1990                                                        r->in.driver,
1991                                                        r->in.architecture, 3)))
1992                 {
1993                         /* if we get to here, we now have 2 driver info structures to remove */
1994                         /* remove the Win2k driver first*/
1995
1996                         status_win2k = delete_printer_driver(
1997                                 p, info_win2k, 3, false);
1998                         free_a_printer_driver(info_win2k);
1999
2000                         /* this should not have failed---if it did, report to client */
2001                         if ( !W_ERROR_IS_OK(status_win2k) )
2002                         {
2003                                 status = status_win2k;
2004                                 goto done;
2005                         }
2006                 }
2007         }
2008
2009         status = delete_printer_driver(p, info, version, false);
2010
2011         /* if at least one of the deletes succeeded return OK */
2012
2013         if ( W_ERROR_IS_OK(status) || W_ERROR_IS_OK(status_win2k) )
2014                 status = WERR_OK;
2015
2016 done:
2017         free_a_printer_driver(info);
2018
2019         return status;
2020 }
2021
2022 /****************************************************************
2023  _spoolss_DeletePrinterDriverEx
2024 ****************************************************************/
2025
2026 WERROR _spoolss_DeletePrinterDriverEx(pipes_struct *p,
2027                                       struct spoolss_DeletePrinterDriverEx *r)
2028 {
2029         struct spoolss_DriverInfo8      *info = NULL;
2030         struct spoolss_DriverInfo8      *info_win2k = NULL;
2031         int                             version;
2032         bool                            delete_files;
2033         WERROR                          status;
2034         WERROR                          status_win2k = WERR_ACCESS_DENIED;
2035         SE_PRIV                         se_printop = SE_PRINT_OPERATOR;
2036
2037         /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
2038            and not a printer admin, then fail */
2039
2040         if ( (p->server_info->utok.uid != sec_initial_uid())
2041                 && !user_has_privileges(p->server_info->ptok, &se_printop )
2042                 && !token_contains_name_in_list(
2043                         uidtoname(p->server_info->utok.uid), NULL, NULL,
2044                         p->server_info->ptok, lp_printer_admin(-1)) )
2045         {
2046                 return WERR_ACCESS_DENIED;
2047         }
2048
2049         /* check that we have a valid driver name first */
2050         if ((version = get_version_id(r->in.architecture)) == -1) {
2051                 /* this is what NT returns */
2052                 return WERR_INVALID_ENVIRONMENT;
2053         }
2054
2055         if (r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION)
2056                 version = r->in.version;
2057
2058         status = get_a_printer_driver(p->mem_ctx, &info, r->in.driver,
2059                                       r->in.architecture, version);
2060
2061         if ( !W_ERROR_IS_OK(status) )
2062         {
2063                 /*
2064                  * if the client asked for a specific version,
2065                  * or this is something other than Windows NT x86,
2066                  * then we've failed
2067                  */
2068
2069                 if ( (r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION) || (version !=2) )
2070                         goto done;
2071
2072                 /* try for Win2k driver if "Windows NT x86" */
2073
2074                 version = 3;
2075                 if (!W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx, &info, r->in.driver,
2076                                                         r->in.architecture,
2077                                                         version))) {
2078                         status = WERR_UNKNOWN_PRINTER_DRIVER;
2079                         goto done;
2080                 }
2081         }
2082
2083         if (printer_driver_in_use(info)) {
2084                 status = WERR_PRINTER_DRIVER_IN_USE;
2085                 goto done;
2086         }
2087
2088         /*
2089          * we have a couple of cases to consider.
2090          * (1) Are any files in use?  If so and DPD_DELTE_ALL_FILE is set,
2091          *     then the delete should fail if **any** files overlap with
2092          *     other drivers
2093          * (2) If DPD_DELTE_UNUSED_FILES is sert, then delete all
2094          *     non-overlapping files
2095          * (3) If neither DPD_DELTE_ALL_FILE nor DPD_DELTE_ALL_FILES
2096          *     is set, the do not delete any files
2097          * Refer to MSDN docs on DeletePrinterDriverEx() for details.
2098          */
2099
2100         delete_files = r->in.delete_flags & (DPD_DELETE_ALL_FILES|DPD_DELETE_UNUSED_FILES);
2101
2102         /* fail if any files are in use and DPD_DELETE_ALL_FILES is set */
2103
2104         if (delete_files && printer_driver_files_in_use(info, info) & (r->in.delete_flags & DPD_DELETE_ALL_FILES)) {
2105                 /* no idea of the correct error here */
2106                 status = WERR_ACCESS_DENIED;
2107                 goto done;
2108         }
2109
2110
2111         /* also check for W32X86/3 if necessary; maybe we already have? */
2112
2113         if ( (version == 2) && ((r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION) != DPD_DELETE_SPECIFIC_VERSION)  ) {
2114                 if (W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx, &info_win2k,
2115                                                        r->in.driver,
2116                                                        r->in.architecture, 3)))
2117                 {
2118
2119                         if (delete_files && printer_driver_files_in_use(info, info_win2k) & (r->in.delete_flags & DPD_DELETE_ALL_FILES) ) {
2120                                 /* no idea of the correct error here */
2121                                 free_a_printer_driver(info_win2k);
2122                                 status = WERR_ACCESS_DENIED;
2123                                 goto done;
2124                         }
2125
2126                         /* if we get to here, we now have 2 driver info structures to remove */
2127                         /* remove the Win2k driver first*/
2128
2129                         status_win2k = delete_printer_driver(
2130                                 p, info_win2k, 3, delete_files);
2131                         free_a_printer_driver(info_win2k);
2132
2133                         /* this should not have failed---if it did, report to client */
2134
2135                         if ( !W_ERROR_IS_OK(status_win2k) )
2136                                 goto done;
2137                 }
2138         }
2139
2140         status = delete_printer_driver(p, info, version, delete_files);
2141
2142         if ( W_ERROR_IS_OK(status) || W_ERROR_IS_OK(status_win2k) )
2143                 status = WERR_OK;
2144 done:
2145         free_a_printer_driver(info);
2146
2147         return status;
2148 }
2149
2150
2151 /****************************************************************************
2152  Internal routine for removing printerdata
2153  ***************************************************************************/
2154
2155 static WERROR delete_printer_dataex( NT_PRINTER_INFO_LEVEL *printer, const char *key, const char *value )
2156 {
2157         return delete_printer_data( printer->info_2, key, value );
2158 }
2159
2160 /****************************************************************************
2161  Internal routine for storing printerdata
2162  ***************************************************************************/
2163
2164 WERROR set_printer_dataex(NT_PRINTER_INFO_LEVEL *printer,
2165                           const char *key, const char *value,
2166                           uint32_t type, uint8_t *data, int real_len)
2167 {
2168         /* the registry objects enforce uniqueness based on value name */
2169
2170         return add_printer_data( printer->info_2, key, value, type, data, real_len );
2171 }
2172
2173 /********************************************************************
2174  GetPrinterData on a printer server Handle.
2175 ********************************************************************/
2176
2177 static WERROR getprinterdata_printer_server(TALLOC_CTX *mem_ctx,
2178                                             const char *value,
2179                                             enum winreg_Type *type,
2180                                             union spoolss_PrinterData *data)
2181 {
2182         DEBUG(8,("getprinterdata_printer_server:%s\n", value));
2183
2184         if (!StrCaseCmp(value, "W3SvcInstalled")) {
2185                 *type = REG_DWORD;
2186                 data->value = 0x00;
2187                 return WERR_OK;
2188         }
2189
2190         if (!StrCaseCmp(value, "BeepEnabled")) {
2191                 *type = REG_DWORD;
2192                 data->value = 0x00;
2193                 return WERR_OK;
2194         }
2195
2196         if (!StrCaseCmp(value, "EventLog")) {
2197                 *type = REG_DWORD;
2198                 /* formally was 0x1b */
2199                 data->value = 0x00;
2200                 return WERR_OK;
2201         }
2202
2203         if (!StrCaseCmp(value, "NetPopup")) {
2204                 *type = REG_DWORD;
2205                 data->value = 0x00;
2206                 return WERR_OK;
2207         }
2208
2209         if (!StrCaseCmp(value, "MajorVersion")) {
2210                 *type = REG_DWORD;
2211
2212                 /* Windows NT 4.0 seems to not allow uploading of drivers
2213                    to a server that reports 0x3 as the MajorVersion.
2214                    need to investigate more how Win2k gets around this .
2215                    -- jerry */
2216
2217                 if (RA_WINNT == get_remote_arch()) {
2218                         data->value = 0x02;
2219                 } else {
2220                         data->value = 0x03;
2221                 }
2222
2223                 return WERR_OK;
2224         }
2225
2226         if (!StrCaseCmp(value, "MinorVersion")) {
2227                 *type = REG_DWORD;
2228                 data->value = 0x00;
2229                 return WERR_OK;
2230         }
2231
2232         /* REG_BINARY
2233          *  uint32_t size        = 0x114
2234          *  uint32_t major       = 5
2235          *  uint32_t minor       = [0|1]
2236          *  uint32_t build       = [2195|2600]
2237          *  extra unicode string = e.g. "Service Pack 3"
2238          */
2239         if (!StrCaseCmp(value, "OSVersion")) {
2240                 DATA_BLOB blob;
2241                 enum ndr_err_code ndr_err;
2242                 struct spoolss_OSVersion os;
2243
2244                 os.major                = 5;    /* Windows 2000 == 5.0 */
2245                 os.minor                = 0;
2246                 os.build                = 2195; /* build */
2247                 os.extra_string         = "";   /* leave extra string empty */
2248
2249                 ndr_err = ndr_push_struct_blob(&blob, mem_ctx, NULL, &os,
2250                         (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion);
2251                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2252                         return WERR_GENERAL_FAILURE;
2253                 }
2254
2255                 *type = REG_BINARY;
2256                 data->binary = blob;
2257
2258                 return WERR_OK;
2259         }
2260
2261
2262         if (!StrCaseCmp(value, "DefaultSpoolDirectory")) {
2263                 *type = REG_SZ;
2264
2265                 data->string = talloc_strdup(mem_ctx, "C:\\PRINTERS");
2266                 W_ERROR_HAVE_NO_MEMORY(data->string);
2267
2268                 return WERR_OK;
2269         }
2270
2271         if (!StrCaseCmp(value, "Architecture")) {
2272                 *type = REG_SZ;
2273
2274                 data->string = talloc_strdup(mem_ctx, "Windows NT x86");
2275                 W_ERROR_HAVE_NO_MEMORY(data->string);
2276
2277                 return WERR_OK;
2278         }
2279
2280         if (!StrCaseCmp(value, "DsPresent")) {
2281                 *type = REG_DWORD;
2282
2283                 /* only show the publish check box if we are a
2284                    member of a AD domain */
2285
2286                 if (lp_security() == SEC_ADS) {
2287                         data->value = 0x01;
2288                 } else {
2289                         data->value = 0x00;
2290                 }
2291                 return WERR_OK;
2292         }
2293
2294         if (!StrCaseCmp(value, "DNSMachineName")) {
2295                 const char *hostname = get_mydnsfullname();
2296
2297                 if (!hostname) {
2298                         return WERR_BADFILE;
2299                 }
2300
2301                 *type = REG_SZ;
2302                 data->string = talloc_strdup(mem_ctx, hostname);
2303                 W_ERROR_HAVE_NO_MEMORY(data->string);
2304
2305                 return WERR_OK;
2306         }
2307
2308         *type = REG_NONE;
2309
2310         return WERR_INVALID_PARAM;
2311 }
2312
2313 /****************************************************************
2314  _spoolss_GetPrinterData
2315 ****************************************************************/
2316
2317 WERROR _spoolss_GetPrinterData(pipes_struct *p,
2318                                struct spoolss_GetPrinterData *r)
2319 {
2320         struct spoolss_GetPrinterDataEx r2;
2321
2322         r2.in.handle            = r->in.handle;
2323         r2.in.key_name          = "PrinterDriverData";
2324         r2.in.value_name        = r->in.value_name;
2325         r2.in.offered           = r->in.offered;
2326         r2.out.type             = r->out.type;
2327         r2.out.data             = r->out.data;
2328         r2.out.needed           = r->out.needed;
2329
2330         return _spoolss_GetPrinterDataEx(p, &r2);
2331 }
2332
2333 /*********************************************************
2334  Connect to the client machine.
2335 **********************************************************/
2336
2337 static bool spoolss_connect_to_client(struct rpc_pipe_client **pp_pipe,
2338                         struct sockaddr_storage *client_ss, const char *remote_machine)
2339 {
2340         NTSTATUS ret;
2341         struct cli_state *the_cli;
2342         struct sockaddr_storage rm_addr;
2343
2344         if ( is_zero_addr((struct sockaddr *)client_ss) ) {
2345                 if ( !resolve_name( remote_machine, &rm_addr, 0x20, false) ) {
2346                         DEBUG(2,("spoolss_connect_to_client: Can't resolve address for %s\n", remote_machine));
2347                         return false;
2348                 }
2349
2350                 if (ismyaddr((struct sockaddr *)&rm_addr)) {
2351                         DEBUG(0,("spoolss_connect_to_client: Machine %s is one of our addresses. Cannot add to ourselves.\n", remote_machine));
2352                         return false;
2353                 }
2354         } else {
2355                 char addr[INET6_ADDRSTRLEN];
2356                 rm_addr = *client_ss;
2357                 print_sockaddr(addr, sizeof(addr), &rm_addr);
2358                 DEBUG(5,("spoolss_connect_to_client: Using address %s (no name resolution necessary)\n",
2359                         addr));
2360         }
2361
2362         /* setup the connection */
2363
2364         ret = cli_full_connection( &the_cli, global_myname(), remote_machine,
2365                 &rm_addr, 0, "IPC$", "IPC",
2366                 "", /* username */
2367                 "", /* domain */
2368                 "", /* password */
2369                 0, lp_client_signing(), NULL );
2370
2371         if ( !NT_STATUS_IS_OK( ret ) ) {
2372                 DEBUG(2,("spoolss_connect_to_client: connection to [%s] failed!\n",
2373                         remote_machine ));
2374                 return false;
2375         }
2376
2377         if ( the_cli->protocol != PROTOCOL_NT1 ) {
2378                 DEBUG(0,("spoolss_connect_to_client: machine %s didn't negotiate NT protocol.\n", remote_machine));
2379                 cli_shutdown(the_cli);
2380                 return false;
2381         }
2382
2383         /*
2384          * Ok - we have an anonymous connection to the IPC$ share.
2385          * Now start the NT Domain stuff :-).
2386          */
2387
2388         ret = cli_rpc_pipe_open_noauth(the_cli, &ndr_table_spoolss.syntax_id, pp_pipe);
2389         if (!NT_STATUS_IS_OK(ret)) {
2390                 DEBUG(2,("spoolss_connect_to_client: unable to open the spoolss pipe on machine %s. Error was : %s.\n",
2391                         remote_machine, nt_errstr(ret)));
2392                 cli_shutdown(the_cli);
2393                 return false;
2394         }
2395
2396         return true;
2397 }
2398
2399 /***************************************************************************
2400  Connect to the client.
2401 ****************************************************************************/
2402
2403 static bool srv_spoolss_replyopenprinter(int snum, const char *printer,
2404                                         uint32_t localprinter, uint32_t type,
2405                                         struct policy_handle *handle,
2406                                         struct sockaddr_storage *client_ss)
2407 {
2408         WERROR result;
2409         NTSTATUS status;
2410
2411         /*
2412          * If it's the first connection, contact the client
2413          * and connect to the IPC$ share anonymously
2414          */
2415         if (smb_connections==0) {
2416                 fstring unix_printer;
2417
2418                 fstrcpy(unix_printer, printer+2); /* the +2 is to strip the leading 2 backslashs */
2419
2420                 if ( !spoolss_connect_to_client( &notify_cli_pipe, client_ss, unix_printer ))
2421                         return false;
2422
2423                 messaging_register(smbd_messaging_context(), NULL,
2424                                    MSG_PRINTER_NOTIFY2,
2425                                    receive_notify2_message_list);
2426                 /* Tell the connections db we're now interested in printer
2427                  * notify messages. */
2428                 register_message_flags(true, FLAG_MSG_PRINT_NOTIFY);
2429         }
2430
2431         /*
2432          * Tell the specific printing tdb we want messages for this printer
2433          * by registering our PID.
2434          */
2435
2436         if (!print_notify_register_pid(snum))
2437                 DEBUG(0,("print_notify_register_pid: Failed to register our pid for printer %s\n", printer ));
2438
2439         smb_connections++;
2440
2441         status = rpccli_spoolss_ReplyOpenPrinter(notify_cli_pipe, talloc_tos(),
2442                                                  printer,
2443                                                  localprinter,
2444                                                  type,
2445                                                  0,
2446                                                  NULL,
2447                                                  handle,
2448                                                  &result);
2449         if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result))
2450                 DEBUG(5,("srv_spoolss_reply_open_printer: Client RPC returned [%s]\n",
2451                         win_errstr(result)));
2452
2453         return (W_ERROR_IS_OK(result));
2454 }
2455
2456 /****************************************************************
2457  ****************************************************************/
2458
2459 static struct spoolss_NotifyOption *dup_spoolss_NotifyOption(TALLOC_CTX *mem_ctx,
2460                                                              const struct spoolss_NotifyOption *r)
2461 {
2462         struct spoolss_NotifyOption *option;
2463         uint32_t i,k;
2464
2465         if (!r) {
2466                 return NULL;
2467         }
2468
2469         option = talloc_zero(mem_ctx, struct spoolss_NotifyOption);
2470         if (!option) {
2471                 return NULL;
2472         }
2473
2474         *option = *r;
2475
2476         if (!option->count) {
2477                 return option;
2478         }
2479
2480         option->types = talloc_zero_array(option,
2481                 struct spoolss_NotifyOptionType, option->count);
2482         if (!option->types) {
2483                 talloc_free(option);
2484                 return NULL;
2485         }
2486
2487         for (i=0; i < option->count; i++) {
2488                 option->types[i] = r->types[i];
2489
2490                 if (option->types[i].count) {
2491                         option->types[i].fields = talloc_zero_array(option,
2492                                 union spoolss_Field, option->types[i].count);
2493                         if (!option->types[i].fields) {
2494                                 talloc_free(option);
2495                                 return NULL;
2496                         }
2497                         for (k=0; k<option->types[i].count; k++) {
2498                                 option->types[i].fields[k] =
2499                                         r->types[i].fields[k];
2500                         }
2501                 }
2502         }
2503
2504         return option;
2505 }
2506
2507 /****************************************************************
2508  * _spoolss_RemoteFindFirstPrinterChangeNotifyEx
2509  *
2510  * before replying OK: status=0 a rpc call is made to the workstation
2511  * asking ReplyOpenPrinter
2512  *
2513  * in fact ReplyOpenPrinter is the changenotify equivalent on the spoolss pipe
2514  * called from api_spoolss_rffpcnex
2515 ****************************************************************/
2516
2517 WERROR _spoolss_RemoteFindFirstPrinterChangeNotifyEx(pipes_struct *p,
2518                                                      struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
2519 {
2520         int snum = -1;
2521         struct spoolss_NotifyOption *option = r->in.notify_options;
2522         struct sockaddr_storage client_ss;
2523
2524         /* store the notify value in the printer struct */
2525
2526         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
2527
2528         if (!Printer) {
2529                 DEBUG(2,("_spoolss_RemoteFindFirstPrinterChangeNotifyEx: "
2530                         "Invalid handle (%s:%u:%u).\n",
2531                         OUR_HANDLE(r->in.handle)));
2532                 return WERR_BADFID;
2533         }
2534
2535         Printer->notify.flags           = r->in.flags;
2536         Printer->notify.options         = r->in.options;
2537         Printer->notify.printerlocal    = r->in.printer_local;
2538
2539         TALLOC_FREE(Printer->notify.option);
2540         Printer->notify.option = dup_spoolss_NotifyOption(Printer, option);
2541
2542         fstrcpy(Printer->notify.localmachine, r->in.local_machine);
2543
2544         /* Connect to the client machine and send a ReplyOpenPrinter */
2545
2546         if ( Printer->printer_type == SPLHND_SERVER)
2547                 snum = -1;
2548         else if ( (Printer->printer_type == SPLHND_PRINTER) &&
2549                         !get_printer_snum(p, r->in.handle, &snum, NULL) )
2550                 return WERR_BADFID;
2551
2552         if (!interpret_string_addr(&client_ss, p->client_address,
2553                                    AI_NUMERICHOST)) {
2554                 return WERR_SERVER_UNAVAILABLE;
2555         }
2556
2557         if(!srv_spoolss_replyopenprinter(snum, Printer->notify.localmachine,
2558                                         Printer->notify.printerlocal, 1,
2559                                         &Printer->notify.client_hnd, &client_ss))
2560                 return WERR_SERVER_UNAVAILABLE;
2561
2562         Printer->notify.client_connected = true;
2563
2564         return WERR_OK;
2565 }
2566
2567 /*******************************************************************
2568  * fill a notify_info_data with the servername
2569  ********************************************************************/
2570
2571 void spoolss_notify_server_name(int snum,
2572                                        struct spoolss_Notify *data,
2573                                        print_queue_struct *queue,
2574                                        NT_PRINTER_INFO_LEVEL *printer,
2575                                        TALLOC_CTX *mem_ctx)
2576 {
2577         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->servername);
2578 }
2579
2580 /*******************************************************************
2581  * fill a notify_info_data with the printername (not including the servername).
2582  ********************************************************************/
2583
2584 void spoolss_notify_printer_name(int snum,
2585                                         struct spoolss_Notify *data,
2586                                         print_queue_struct *queue,
2587                                         NT_PRINTER_INFO_LEVEL *printer,
2588                                         TALLOC_CTX *mem_ctx)
2589 {
2590         /* the notify name should not contain the \\server\ part */
2591         char *p = strrchr(printer->info_2->printername, '\\');
2592
2593         if (!p) {
2594                 p = printer->info_2->printername;
2595         } else {
2596                 p++;
2597         }
2598
2599         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, p);
2600 }
2601
2602 /*******************************************************************
2603  * fill a notify_info_data with the servicename
2604  ********************************************************************/
2605
2606 void spoolss_notify_share_name(int snum,
2607                                       struct spoolss_Notify *data,
2608                                       print_queue_struct *queue,
2609                                       NT_PRINTER_INFO_LEVEL *printer,
2610                                       TALLOC_CTX *mem_ctx)
2611 {
2612         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, lp_servicename(snum));
2613 }
2614
2615 /*******************************************************************
2616  * fill a notify_info_data with the port name
2617  ********************************************************************/
2618
2619 void spoolss_notify_port_name(int snum,
2620                                      struct spoolss_Notify *data,
2621                                      print_queue_struct *queue,
2622                                      NT_PRINTER_INFO_LEVEL *printer,
2623                                      TALLOC_CTX *mem_ctx)
2624 {
2625         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->portname);
2626 }
2627
2628 /*******************************************************************
2629  * fill a notify_info_data with the printername
2630  * but it doesn't exist, have to see what to do
2631  ********************************************************************/
2632
2633 void spoolss_notify_driver_name(int snum,
2634                                        struct spoolss_Notify *data,
2635                                        print_queue_struct *queue,
2636                                        NT_PRINTER_INFO_LEVEL *printer,
2637                                        TALLOC_CTX *mem_ctx)
2638 {
2639         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->drivername);
2640 }
2641
2642 /*******************************************************************
2643  * fill a notify_info_data with the comment
2644  ********************************************************************/
2645
2646 void spoolss_notify_comment(int snum,
2647                                    struct spoolss_Notify *data,
2648                                    print_queue_struct *queue,
2649                                    NT_PRINTER_INFO_LEVEL *printer,
2650                                    TALLOC_CTX *mem_ctx)
2651 {
2652         char *p;
2653
2654         if (*printer->info_2->comment == '\0') {
2655                 p = lp_comment(snum);
2656         } else {
2657                 p = printer->info_2->comment;
2658         }
2659
2660         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->comment);
2661 }
2662
2663 /*******************************************************************
2664  * fill a notify_info_data with the comment
2665  * location = "Room 1, floor 2, building 3"
2666  ********************************************************************/
2667
2668 void spoolss_notify_location(int snum,
2669                                     struct spoolss_Notify *data,
2670                                     print_queue_struct *queue,
2671                                     NT_PRINTER_INFO_LEVEL *printer,
2672                                     TALLOC_CTX *mem_ctx)
2673 {
2674         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->location);
2675 }
2676
2677 /*******************************************************************
2678  * fill a notify_info_data with the device mode
2679  * jfm:xxxx don't to it for know but that's a real problem !!!
2680  ********************************************************************/
2681
2682 static void spoolss_notify_devmode(int snum,
2683                                    struct spoolss_Notify *data,
2684                                    print_queue_struct *queue,
2685                                    NT_PRINTER_INFO_LEVEL *printer,
2686                                    TALLOC_CTX *mem_ctx)
2687 {
2688         /* for a dummy implementation we have to zero the fields */
2689         SETUP_SPOOLSS_NOTIFY_DATA_DEVMODE(data, NULL);
2690 }
2691
2692 /*******************************************************************
2693  * fill a notify_info_data with the separator file name
2694  ********************************************************************/
2695
2696 void spoolss_notify_sepfile(int snum,
2697                                    struct spoolss_Notify *data,
2698                                    print_queue_struct *queue,
2699                                    NT_PRINTER_INFO_LEVEL *printer,
2700                                    TALLOC_CTX *mem_ctx)
2701 {
2702         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->sepfile);
2703 }
2704
2705 /*******************************************************************
2706  * fill a notify_info_data with the print processor
2707  * jfm:xxxx return always winprint to indicate we don't do anything to it
2708  ********************************************************************/
2709
2710 void spoolss_notify_print_processor(int snum,
2711                                            struct spoolss_Notify *data,
2712                                            print_queue_struct *queue,
2713                                            NT_PRINTER_INFO_LEVEL *printer,
2714                                            TALLOC_CTX *mem_ctx)
2715 {
2716         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->printprocessor);
2717 }
2718
2719 /*******************************************************************
2720  * fill a notify_info_data with the print processor options
2721  * jfm:xxxx send an empty string
2722  ********************************************************************/
2723
2724 void spoolss_notify_parameters(int snum,
2725                                       struct spoolss_Notify *data,
2726                                       print_queue_struct *queue,
2727                                       NT_PRINTER_INFO_LEVEL *printer,
2728                                       TALLOC_CTX *mem_ctx)
2729 {
2730         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->parameters);
2731 }
2732
2733 /*******************************************************************
2734  * fill a notify_info_data with the data type
2735  * jfm:xxxx always send RAW as data type
2736  ********************************************************************/
2737
2738 void spoolss_notify_datatype(int snum,
2739                                     struct spoolss_Notify *data,
2740                                     print_queue_struct *queue,
2741                                     NT_PRINTER_INFO_LEVEL *printer,
2742                                     TALLOC_CTX *mem_ctx)
2743 {
2744         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->datatype);
2745 }
2746
2747 /*******************************************************************
2748  * fill a notify_info_data with the security descriptor
2749  * jfm:xxxx send an null pointer to say no security desc
2750  * have to implement security before !
2751  ********************************************************************/
2752
2753 static void spoolss_notify_security_desc(int snum,
2754                                          struct spoolss_Notify *data,
2755                                          print_queue_struct *queue,
2756                                          NT_PRINTER_INFO_LEVEL *printer,
2757                                          TALLOC_CTX *mem_ctx)
2758 {
2759         SETUP_SPOOLSS_NOTIFY_DATA_SECDESC(data,
2760                                           printer->info_2->secdesc_buf->sd_size,
2761                                           printer->info_2->secdesc_buf->sd);
2762 }
2763
2764 /*******************************************************************
2765  * fill a notify_info_data with the attributes
2766  * jfm:xxxx a samba printer is always shared
2767  ********************************************************************/
2768
2769 void spoolss_notify_attributes(int snum,
2770                                       struct spoolss_Notify *data,
2771                                       print_queue_struct *queue,
2772                                       NT_PRINTER_INFO_LEVEL *printer,
2773                                       TALLOC_CTX *mem_ctx)
2774 {
2775         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->attributes);
2776 }
2777
2778 /*******************************************************************
2779  * fill a notify_info_data with the priority
2780  ********************************************************************/
2781
2782 static void spoolss_notify_priority(int snum,
2783                                     struct spoolss_Notify *data,
2784                                     print_queue_struct *queue,
2785                                     NT_PRINTER_INFO_LEVEL *printer,
2786                                     TALLOC_CTX *mem_ctx)
2787 {
2788         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->priority);
2789 }
2790
2791 /*******************************************************************
2792  * fill a notify_info_data with the default priority
2793  ********************************************************************/
2794
2795 static void spoolss_notify_default_priority(int snum,
2796                                             struct spoolss_Notify *data,
2797                                             print_queue_struct *queue,
2798                                             NT_PRINTER_INFO_LEVEL *printer,
2799                                             TALLOC_CTX *mem_ctx)
2800 {
2801         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->default_priority);
2802 }
2803
2804 /*******************************************************************
2805  * fill a notify_info_data with the start time
2806  ********************************************************************/
2807
2808 static void spoolss_notify_start_time(int snum,
2809                                       struct spoolss_Notify *data,
2810                                       print_queue_struct *queue,
2811                                       NT_PRINTER_INFO_LEVEL *printer,
2812                                       TALLOC_CTX *mem_ctx)
2813 {
2814         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->starttime);
2815 }
2816
2817 /*******************************************************************
2818  * fill a notify_info_data with the until time
2819  ********************************************************************/
2820
2821 static void spoolss_notify_until_time(int snum,
2822                                       struct spoolss_Notify *data,
2823                                       print_queue_struct *queue,
2824                                       NT_PRINTER_INFO_LEVEL *printer,
2825                                       TALLOC_CTX *mem_ctx)
2826 {
2827         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->untiltime);
2828 }
2829
2830 /*******************************************************************
2831  * fill a notify_info_data with the status
2832  ********************************************************************/
2833
2834 static void spoolss_notify_status(int snum,
2835                                   struct spoolss_Notify *data,
2836                                   print_queue_struct *queue,
2837                                   NT_PRINTER_INFO_LEVEL *printer,
2838                                   TALLOC_CTX *mem_ctx)
2839 {
2840         print_status_struct status;
2841
2842         print_queue_length(snum, &status);
2843         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, status.status);
2844 }
2845
2846 /*******************************************************************
2847  * fill a notify_info_data with the number of jobs queued
2848  ********************************************************************/
2849
2850 void spoolss_notify_cjobs(int snum,
2851                                  struct spoolss_Notify *data,
2852                                  print_queue_struct *queue,
2853                                  NT_PRINTER_INFO_LEVEL *printer,
2854                                  TALLOC_CTX *mem_ctx)
2855 {
2856         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, print_queue_length(snum, NULL));
2857 }
2858
2859 /*******************************************************************
2860  * fill a notify_info_data with the average ppm
2861  ********************************************************************/
2862
2863 static void spoolss_notify_average_ppm(int snum,
2864                                        struct spoolss_Notify *data,
2865                                        print_queue_struct *queue,
2866                                        NT_PRINTER_INFO_LEVEL *printer,
2867                                        TALLOC_CTX *mem_ctx)
2868 {
2869         /* always respond 8 pages per minutes */
2870         /* a little hard ! */
2871         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->averageppm);
2872 }
2873
2874 /*******************************************************************
2875  * fill a notify_info_data with username
2876  ********************************************************************/
2877
2878 static void spoolss_notify_username(int snum,
2879                                     struct spoolss_Notify *data,
2880                                     print_queue_struct *queue,
2881                                     NT_PRINTER_INFO_LEVEL *printer,
2882                                     TALLOC_CTX *mem_ctx)
2883 {
2884         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, queue->fs_user);
2885 }
2886
2887 /*******************************************************************
2888  * fill a notify_info_data with job status
2889  ********************************************************************/
2890
2891 static void spoolss_notify_job_status(int snum,
2892                                       struct spoolss_Notify *data,
2893                                       print_queue_struct *queue,
2894                                       NT_PRINTER_INFO_LEVEL *printer,
2895                                       TALLOC_CTX *mem_ctx)
2896 {
2897         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, nt_printj_status(queue->status));
2898 }
2899
2900 /*******************************************************************
2901  * fill a notify_info_data with job name
2902  ********************************************************************/
2903
2904 static void spoolss_notify_job_name(int snum,
2905                                     struct spoolss_Notify *data,
2906                                     print_queue_struct *queue,
2907                                     NT_PRINTER_INFO_LEVEL *printer,
2908                                     TALLOC_CTX *mem_ctx)
2909 {
2910         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, queue->fs_file);
2911 }
2912
2913 /*******************************************************************
2914  * fill a notify_info_data with job status
2915  ********************************************************************/
2916
2917 static void spoolss_notify_job_status_string(int snum,
2918                                              struct spoolss_Notify *data,
2919                                              print_queue_struct *queue,
2920                                              NT_PRINTER_INFO_LEVEL *printer,
2921                                              TALLOC_CTX *mem_ctx)
2922 {
2923         /*
2924          * Now we're returning job status codes we just return a "" here. JRA.
2925          */
2926
2927         const char *p = "";
2928
2929 #if 0 /* NO LONGER NEEDED - JRA. 02/22/2001 */
2930         p = "unknown";
2931
2932         switch (queue->status) {
2933         case LPQ_QUEUED:
2934                 p = "Queued";
2935                 break;
2936         case LPQ_PAUSED:
2937                 p = "";    /* NT provides the paused string */
2938                 break;
2939         case LPQ_SPOOLING:
2940                 p = "Spooling";
2941                 break;
2942         case LPQ_PRINTING:
2943                 p = "Printing";
2944                 break;
2945         }
2946 #endif /* NO LONGER NEEDED. */
2947
2948         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, p);
2949 }
2950
2951 /*******************************************************************
2952  * fill a notify_info_data with job time
2953  ********************************************************************/
2954
2955 static void spoolss_notify_job_time(int snum,
2956                                     struct spoolss_Notify *data,
2957                                     print_queue_struct *queue,
2958                                     NT_PRINTER_INFO_LEVEL *printer,
2959                                     TALLOC_CTX *mem_ctx)
2960 {
2961         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, 0);
2962 }
2963
2964 /*******************************************************************
2965  * fill a notify_info_data with job size
2966  ********************************************************************/
2967
2968 static void spoolss_notify_job_size(int snum,
2969                                     struct spoolss_Notify *data,
2970                                     print_queue_struct *queue,
2971                                     NT_PRINTER_INFO_LEVEL *printer,
2972                                     TALLOC_CTX *mem_ctx)
2973 {
2974         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->size);
2975 }
2976
2977 /*******************************************************************
2978  * fill a notify_info_data with page info
2979  ********************************************************************/
2980 static void spoolss_notify_total_pages(int snum,
2981                                 struct spoolss_Notify *data,
2982                                 print_queue_struct *queue,
2983                                 NT_PRINTER_INFO_LEVEL *printer,
2984                                 TALLOC_CTX *mem_ctx)
2985 {
2986         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->page_count);
2987 }
2988
2989 /*******************************************************************
2990  * fill a notify_info_data with pages printed info.
2991  ********************************************************************/
2992 static void spoolss_notify_pages_printed(int snum,
2993                                 struct spoolss_Notify *data,
2994                                 print_queue_struct *queue,
2995                                 NT_PRINTER_INFO_LEVEL *printer,
2996                                 TALLOC_CTX *mem_ctx)
2997 {
2998         /* Add code when back-end tracks this */
2999         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, 0);
3000 }
3001
3002 /*******************************************************************
3003  Fill a notify_info_data with job position.
3004  ********************************************************************/
3005
3006 static void spoolss_notify_job_position(int snum,
3007                                         struct spoolss_Notify *data,
3008                                         print_queue_struct *queue,
3009                                         NT_PRINTER_INFO_LEVEL *printer,
3010                                         TALLOC_CTX *mem_ctx)
3011 {
3012         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->job);
3013 }
3014
3015 /*******************************************************************
3016  Fill a notify_info_data with submitted time.
3017  ********************************************************************/
3018
3019 static void spoolss_notify_submitted_time(int snum,
3020                                           struct spoolss_Notify *data,
3021                                           print_queue_struct *queue,
3022                                           NT_PRINTER_INFO_LEVEL *printer,
3023                                           TALLOC_CTX *mem_ctx)
3024 {
3025         data->data.string.string = NULL;
3026         data->data.string.size = 0;
3027
3028         init_systemtime_buffer(mem_ctx, gmtime(&queue->time),
3029                                &data->data.string.string,
3030                                &data->data.string.size);
3031
3032 }
3033
3034 struct s_notify_info_data_table
3035 {
3036         enum spoolss_NotifyType type;
3037         uint16_t field;
3038         const char *name;
3039         enum spoolss_NotifyTable variable_type;
3040         void (*fn) (int snum, struct spoolss_Notify *data,
3041                     print_queue_struct *queue,
3042                     NT_PRINTER_INFO_LEVEL *printer, TALLOC_CTX *mem_ctx);
3043 };
3044
3045 /* A table describing the various print notification constants and
3046    whether the notification data is a pointer to a variable sized
3047    buffer, a one value uint32_t or a two value uint32_t. */
3048
3049 static const struct s_notify_info_data_table notify_info_data_table[] =
3050 {
3051 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SERVER_NAME,         "PRINTER_NOTIFY_FIELD_SERVER_NAME",         NOTIFY_TABLE_STRING,   spoolss_notify_server_name },
3052 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRINTER_NAME,        "PRINTER_NOTIFY_FIELD_PRINTER_NAME",        NOTIFY_TABLE_STRING,   spoolss_notify_printer_name },
3053 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SHARE_NAME,          "PRINTER_NOTIFY_FIELD_SHARE_NAME",          NOTIFY_TABLE_STRING,   spoolss_notify_share_name },
3054 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PORT_NAME,           "PRINTER_NOTIFY_FIELD_PORT_NAME",           NOTIFY_TABLE_STRING,   spoolss_notify_port_name },
3055 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DRIVER_NAME,         "PRINTER_NOTIFY_FIELD_DRIVER_NAME",         NOTIFY_TABLE_STRING,   spoolss_notify_driver_name },
3056 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_COMMENT,             "PRINTER_NOTIFY_FIELD_COMMENT",             NOTIFY_TABLE_STRING,   spoolss_notify_comment },
3057 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_LOCATION,            "PRINTER_NOTIFY_FIELD_LOCATION",            NOTIFY_TABLE_STRING,   spoolss_notify_location },
3058 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DEVMODE,             "PRINTER_NOTIFY_FIELD_DEVMODE",             NOTIFY_TABLE_DEVMODE,  spoolss_notify_devmode },
3059 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SEPFILE,             "PRINTER_NOTIFY_FIELD_SEPFILE",             NOTIFY_TABLE_STRING,   spoolss_notify_sepfile },
3060 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR,     "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR",     NOTIFY_TABLE_STRING,   spoolss_notify_print_processor },
3061 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PARAMETERS,          "PRINTER_NOTIFY_FIELD_PARAMETERS",          NOTIFY_TABLE_STRING,   spoolss_notify_parameters },
3062 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DATATYPE,            "PRINTER_NOTIFY_FIELD_DATATYPE",            NOTIFY_TABLE_STRING,   spoolss_notify_datatype },
3063 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR, "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NOTIFY_TABLE_SECURITYDESCRIPTOR,   spoolss_notify_security_desc },
3064 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_ATTRIBUTES,          "PRINTER_NOTIFY_FIELD_ATTRIBUTES",          NOTIFY_TABLE_DWORD,    spoolss_notify_attributes },
3065 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRIORITY,            "PRINTER_NOTIFY_FIELD_PRIORITY",            NOTIFY_TABLE_DWORD,    spoolss_notify_priority },
3066 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY,    "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY",    NOTIFY_TABLE_DWORD,    spoolss_notify_default_priority },
3067 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_START_TIME,          "PRINTER_NOTIFY_FIELD_START_TIME",          NOTIFY_TABLE_DWORD,    spoolss_notify_start_time },
3068 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_UNTIL_TIME,          "PRINTER_NOTIFY_FIELD_UNTIL_TIME",          NOTIFY_TABLE_DWORD,    spoolss_notify_until_time },
3069 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_STATUS,              "PRINTER_NOTIFY_FIELD_STATUS",              NOTIFY_TABLE_DWORD,    spoolss_notify_status },
3070 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_STATUS_STRING,       "PRINTER_NOTIFY_FIELD_STATUS_STRING",       NOTIFY_TABLE_STRING,   NULL },
3071 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_CJOBS,               "PRINTER_NOTIFY_FIELD_CJOBS",               NOTIFY_TABLE_DWORD,    spoolss_notify_cjobs },
3072 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_AVERAGE_PPM,         "PRINTER_NOTIFY_FIELD_AVERAGE_PPM",         NOTIFY_TABLE_DWORD,    spoolss_notify_average_ppm },
3073 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_TOTAL_PAGES,         "PRINTER_NOTIFY_FIELD_TOTAL_PAGES",         NOTIFY_TABLE_DWORD,    NULL },
3074 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PAGES_PRINTED,       "PRINTER_NOTIFY_FIELD_PAGES_PRINTED",       NOTIFY_TABLE_DWORD,    NULL },
3075 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_TOTAL_BYTES,         "PRINTER_NOTIFY_FIELD_TOTAL_BYTES",         NOTIFY_TABLE_DWORD,    NULL },
3076 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_BYTES_PRINTED,       "PRINTER_NOTIFY_FIELD_BYTES_PRINTED",       NOTIFY_TABLE_DWORD,    NULL },
3077 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_PRINTER_NAME,            "JOB_NOTIFY_FIELD_PRINTER_NAME",            NOTIFY_TABLE_STRING,   spoolss_notify_printer_name },
3078 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_MACHINE_NAME,            "JOB_NOTIFY_FIELD_MACHINE_NAME",            NOTIFY_TABLE_STRING,   spoolss_notify_server_name },
3079 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_PORT_NAME,               "JOB_NOTIFY_FIELD_PORT_NAME",               NOTIFY_TABLE_STRING,   spoolss_notify_port_name },
3080 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_USER_NAME,               "JOB_NOTIFY_FIELD_USER_NAME",               NOTIFY_TABLE_STRING,   spoolss_notify_username },
3081 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_NOTIFY_NAME,             "JOB_NOTIFY_FIELD_NOTIFY_NAME",             NOTIFY_TABLE_STRING,   spoolss_notify_username },
3082 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_DATATYPE,                "JOB_NOTIFY_FIELD_DATATYPE",                NOTIFY_TABLE_STRING,   spoolss_notify_datatype },
3083 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_PRINT_PROCESSOR,         "JOB_NOTIFY_FIELD_PRINT_PROCESSOR",         NOTIFY_TABLE_STRING,   spoolss_notify_print_processor },
3084 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_PARAMETERS,              "JOB_NOTIFY_FIELD_PARAMETERS",              NOTIFY_TABLE_STRING,   spoolss_notify_parameters },
3085 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_DRIVER_NAME,             "JOB_NOTIFY_FIELD_DRIVER_NAME",             NOTIFY_TABLE_STRING,   spoolss_notify_driver_name },
3086 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_DEVMODE,                 "JOB_NOTIFY_FIELD_DEVMODE",                 NOTIFY_TABLE_DEVMODE,  spoolss_notify_devmode },
3087 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_STATUS,                  "JOB_NOTIFY_FIELD_STATUS",                  NOTIFY_TABLE_DWORD,    spoolss_notify_job_status },
3088 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_STATUS_STRING,           "JOB_NOTIFY_FIELD_STATUS_STRING",           NOTIFY_TABLE_STRING,   spoolss_notify_job_status_string },
3089 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR,     "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR",     NOTIFY_TABLE_SECURITYDESCRIPTOR,   NULL },
3090 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_DOCUMENT,                "JOB_NOTIFY_FIELD_DOCUMENT",                NOTIFY_TABLE_STRING,   spoolss_notify_job_name },
3091 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_PRIORITY,                "JOB_NOTIFY_FIELD_PRIORITY",                NOTIFY_TABLE_DWORD,    spoolss_notify_priority },
3092 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_POSITION,                "JOB_NOTIFY_FIELD_POSITION",                NOTIFY_TABLE_DWORD,    spoolss_notify_job_position },
3093 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_SUBMITTED,               "JOB_NOTIFY_FIELD_SUBMITTED",               NOTIFY_TABLE_TIME,     spoolss_notify_submitted_time },
3094 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_START_TIME,              "JOB_NOTIFY_FIELD_START_TIME",              NOTIFY_TABLE_DWORD,    spoolss_notify_start_time },
3095 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_UNTIL_TIME,              "JOB_NOTIFY_FIELD_UNTIL_TIME",              NOTIFY_TABLE_DWORD,    spoolss_notify_until_time },
3096 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_TIME,                    "JOB_NOTIFY_FIELD_TIME",                    NOTIFY_TABLE_DWORD,    spoolss_notify_job_time },
3097 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_TOTAL_PAGES,             "JOB_NOTIFY_FIELD_TOTAL_PAGES",             NOTIFY_TABLE_DWORD,    spoolss_notify_total_pages },
3098 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_PAGES_PRINTED,           "JOB_NOTIFY_FIELD_PAGES_PRINTED",           NOTIFY_TABLE_DWORD,    spoolss_notify_pages_printed },
3099 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_TOTAL_BYTES,             "JOB_NOTIFY_FIELD_TOTAL_BYTES",             NOTIFY_TABLE_DWORD,    spoolss_notify_job_size },
3100 };
3101
3102 /*******************************************************************
3103  Return the variable_type of info_data structure.
3104 ********************************************************************/
3105
3106 static uint32_t variable_type_of_notify_info_data(enum spoolss_NotifyType type,
3107                                                   uint16_t field)
3108 {
3109         int i=0;
3110
3111         for (i = 0; i < ARRAY_SIZE(notify_info_data_table); i++) {
3112                 if ( (notify_info_data_table[i].type == type) &&
3113                      (notify_info_data_table[i].field == field) ) {
3114                         return notify_info_data_table[i].variable_type;
3115                 }
3116         }
3117
3118         DEBUG(5, ("invalid notify data type %d/%d\n", type, field));
3119
3120         return 0;
3121 }
3122
3123 /****************************************************************************
3124 ****************************************************************************/
3125
3126 static bool search_notify(enum spoolss_NotifyType type,
3127                           uint16_t field,
3128                           int *value)
3129 {
3130         int i;
3131
3132         for (i = 0; i < ARRAY_SIZE(notify_info_data_table); i++) {
3133                 if (notify_info_data_table[i].type == type &&
3134                     notify_info_data_table[i].field == field &&
3135                     notify_info_data_table[i].fn != NULL) {
3136                         *value = i;
3137                         return true;
3138                 }
3139         }
3140
3141         return false;
3142 }
3143
3144 /****************************************************************************
3145 ****************************************************************************/
3146
3147 void construct_info_data(struct spoolss_Notify *info_data,
3148                          enum spoolss_NotifyType type,
3149                          uint16_t field,
3150                          int id)
3151 {
3152         info_data->type                 = type;
3153         info_data->field.field          = field;
3154         info_data->variable_type        = variable_type_of_notify_info_data(type, field);
3155         info_data->job_id               = id;
3156 }
3157
3158 /*******************************************************************
3159  *
3160  * fill a notify_info struct with info asked
3161  *
3162  ********************************************************************/
3163
3164 static bool construct_notify_printer_info(Printer_entry *print_hnd,
3165                                           struct spoolss_NotifyInfo *info,
3166                                           int snum,
3167                                           const struct spoolss_NotifyOptionType *option_type,
3168                                           uint32_t id,
3169                                           TALLOC_CTX *mem_ctx)
3170 {
3171         int field_num,j;
3172         enum spoolss_NotifyType type;
3173         uint16_t field;
3174
3175         struct spoolss_Notify *current_data;
3176         NT_PRINTER_INFO_LEVEL *printer = NULL;
3177         print_queue_struct *queue=NULL;
3178
3179         type = option_type->type;
3180
3181         DEBUG(4,("construct_notify_printer_info: Notify type: [%s], number of notify info: [%d] on printer: [%s]\n",
3182                 (type == PRINTER_NOTIFY_TYPE ? "PRINTER_NOTIFY_TYPE" : "JOB_NOTIFY_TYPE"),
3183                 option_type->count, lp_servicename(snum)));
3184
3185         if (!W_ERROR_IS_OK(get_a_printer(print_hnd, &printer, 2, lp_const_servicename(snum))))
3186                 return false;
3187
3188         for(field_num=0; field_num < option_type->count; field_num++) {
3189                 field = option_type->fields[field_num].field;
3190
3191                 DEBUG(4,("construct_notify_printer_info: notify [%d]: type [%x], field [%x]\n", field_num, type, field));
3192
3193                 if (!search_notify(type, field, &j) )
3194                         continue;
3195
3196                 info->notifies = TALLOC_REALLOC_ARRAY(info, info->notifies,
3197                                                       struct spoolss_Notify,
3198                                                       info->count + 1);
3199                 if (info->notifies == NULL) {
3200                         DEBUG(2,("construct_notify_printer_info: failed to enlarge buffer info->data!\n"));
3201                         free_a_printer(&printer, 2);
3202                         return false;
3203                 }
3204
3205                 current_data = &info->notifies[info->count];
3206
3207                 construct_info_data(current_data, type, field, id);
3208
3209                 DEBUG(10,("construct_notify_printer_info: calling [%s]  snum=%d  printername=[%s])\n",
3210                                 notify_info_data_table[j].name, snum, printer->info_2->printername ));
3211
3212                 notify_info_data_table[j].fn(snum, current_data, queue,
3213                                              printer, mem_ctx);
3214
3215                 info->count++;
3216         }
3217
3218         free_a_printer(&printer, 2);
3219         return true;
3220 }
3221
3222 /*******************************************************************
3223  *
3224  * fill a notify_info struct with info asked
3225  *
3226  ********************************************************************/
3227
3228 static bool construct_notify_jobs_info(print_queue_struct *queue,
3229                                        struct spoolss_NotifyInfo *info,
3230                                        NT_PRINTER_INFO_LEVEL *printer,
3231                                        int snum,
3232                                        const struct spoolss_NotifyOptionType *option_type,
3233                                        uint32_t id,
3234                                        TALLOC_CTX *mem_ctx)
3235 {
3236         int field_num,j;
3237         enum spoolss_NotifyType type;
3238         uint16_t field;
3239         struct spoolss_Notify *current_data;
3240
3241         DEBUG(4,("construct_notify_jobs_info\n"));
3242
3243         type = option_type->type;
3244
3245         DEBUGADD(4,("Notify type: [%s], number of notify info: [%d]\n",
3246                 (type == PRINTER_NOTIFY_TYPE ? "PRINTER_NOTIFY_TYPE" : "JOB_NOTIFY_TYPE"),
3247                 option_type->count));
3248
3249         for(field_num=0; field_num<option_type->count; field_num++) {
3250                 field = option_type->fields[field_num].field;
3251
3252                 if (!search_notify(type, field, &j) )
3253                         continue;
3254
3255                 info->notifies = TALLOC_REALLOC_ARRAY(info, info->notifies,
3256                                                       struct spoolss_Notify,
3257                                                       info->count + 1);
3258                 if (info->notifies == NULL) {
3259                         DEBUG(2,("construct_notify_jobs_info: failed to enlarg buffer info->data!\n"));
3260                         return false;
3261                 }
3262
3263                 current_data=&(info->notifies[info->count]);
3264
3265                 construct_info_data(current_data, type, field, id);
3266                 notify_info_data_table[j].fn(snum, current_data, queue,
3267                                              printer, mem_ctx);
3268                 info->count++;
3269         }
3270
3271         return true;
3272 }
3273
3274 /*
3275  * JFM: The enumeration is not that simple, it's even non obvious.
3276  *
3277  * let's take an example: I want to monitor the PRINTER SERVER for
3278  * the printer's name and the number of jobs currently queued.
3279  * So in the NOTIFY_OPTION, I have one NOTIFY_OPTION_TYPE structure.
3280  * Its type is PRINTER_NOTIFY_TYPE and it has 2 fields NAME and CJOBS.
3281  *
3282  * I have 3 printers on the back of my server.
3283  *
3284  * Now the response is a NOTIFY_INFO structure, with 6 NOTIFY_INFO_DATA
3285  * structures.
3286  *   Number     Data                    Id
3287  *      1       printer 1 name          1
3288  *      2       printer 1 cjob          1
3289  *      3       printer 2 name          2
3290  *      4       printer 2 cjob          2
3291  *      5       printer 3 name          3
3292  *      6       printer 3 name          3
3293  *
3294  * that's the print server case, the printer case is even worse.
3295  */
3296
3297 /*******************************************************************
3298  *
3299  * enumerate all printers on the printserver
3300  * fill a notify_info struct with info asked
3301  *
3302  ********************************************************************/
3303
3304 static WERROR printserver_notify_info(pipes_struct *p,
3305                                       struct policy_handle *hnd,
3306                                       struct spoolss_NotifyInfo *info,
3307                                       TALLOC_CTX *mem_ctx)
3308 {
3309         int snum;
3310         Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
3311         int n_services=lp_numservices();
3312         int i;
3313         struct spoolss_NotifyOption *option;
3314         struct spoolss_NotifyOptionType option_type;
3315
3316         DEBUG(4,("printserver_notify_info\n"));
3317
3318         if (!Printer)
3319                 return WERR_BADFID;
3320
3321         option = Printer->notify.option;
3322
3323         info->version   = 2;
3324         info->notifies  = NULL;
3325         info->count     = 0;
3326
3327         /* a bug in xp sp2 rc2 causes it to send a fnpcn request without
3328            sending a ffpcn() request first */
3329
3330         if ( !option )
3331                 return WERR_BADFID;
3332
3333         for (i=0; i<option->count; i++) {
3334                 option_type = option->types[i];
3335
3336                 if (option_type.type != PRINTER_NOTIFY_TYPE)
3337                         continue;
3338
3339                 for (snum=0; snum<n_services; snum++)
3340                 {
3341                         if ( lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum) )
3342                                 construct_notify_printer_info ( Printer, info, snum, &option_type, snum, mem_ctx );
3343                 }
3344         }
3345
3346 #if 0
3347         /*
3348          * Debugging information, don't delete.
3349          */
3350
3351         DEBUG(1,("dumping the NOTIFY_INFO\n"));
3352         DEBUGADD(1,("info->version:[%d], info->flags:[%d], info->count:[%d]\n", info->version, info->flags, info->count));
3353         DEBUGADD(1,("num\ttype\tfield\tres\tid\tsize\tenc_type\n"));
3354
3355         for (i=0; i<info->count; i++) {
3356                 DEBUGADD(1,("[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\n",
3357                 i, info->data[i].type, info->data[i].field, info->data[i].reserved,
3358                 info->data[i].id, info->data[i].size, info->data[i].enc_type));
3359         }
3360 #endif
3361
3362         return WERR_OK;
3363 }
3364
3365 /*******************************************************************
3366  *
3367  * fill a notify_info struct with info asked
3368  *
3369  ********************************************************************/
3370
3371 static WERROR printer_notify_info(pipes_struct *p, struct policy_handle *hnd,
3372                                   struct spoolss_NotifyInfo *info,
3373                                   TALLOC_CTX *mem_ctx)
3374 {
3375         int snum;
3376         Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
3377         int i;
3378         uint32_t id;
3379         struct spoolss_NotifyOption *option;
3380         struct spoolss_NotifyOptionType option_type;
3381         int count,j;
3382         print_queue_struct *queue=NULL;
3383         print_status_struct status;
3384
3385         DEBUG(4,("printer_notify_info\n"));
3386
3387         if (!Printer)
3388                 return WERR_BADFID;
3389
3390         option = Printer->notify.option;
3391         id = 0x0;
3392
3393         info->version   = 2;
3394         info->notifies  = NULL;
3395         info->count     = 0;
3396
3397         /* a bug in xp sp2 rc2 causes it to send a fnpcn request without
3398            sending a ffpcn() request first */
3399
3400         if ( !option )
3401                 return WERR_BADFID;
3402
3403         get_printer_snum(p, hnd, &snum, NULL);
3404
3405         for (i=0; i<option->count; i++) {
3406                 option_type = option->types[i];
3407
3408                 switch (option_type.type) {
3409                 case PRINTER_NOTIFY_TYPE:
3410                         if(construct_notify_printer_info(Printer, info, snum,
3411                                                          &option_type, id,
3412                                                          mem_ctx))
3413                                 id--;
3414                         break;
3415
3416                 case JOB_NOTIFY_TYPE: {
3417                         NT_PRINTER_INFO_LEVEL *printer = NULL;
3418
3419                         count = print_queue_status(snum, &queue, &status);
3420
3421                         if (!W_ERROR_IS_OK(get_a_printer(Printer, &printer, 2, lp_const_servicename(snum))))
3422                                 goto done;
3423
3424                         for (j=0; j<count; j++) {
3425                                 construct_notify_jobs_info(&queue[j], info,
3426                                                            printer, snum,
3427                                                            &option_type,
3428                                                            queue[j].job,
3429                                                            mem_ctx);
3430                         }
3431
3432                         free_a_printer(&printer, 2);
3433
3434                 done:
3435                         SAFE_FREE(queue);
3436                         break;
3437                 }
3438                 }
3439         }
3440
3441         /*
3442          * Debugging information, don't delete.
3443          */
3444         /*
3445         DEBUG(1,("dumping the NOTIFY_INFO\n"));
3446         DEBUGADD(1,("info->version:[%d], info->flags:[%d], info->count:[%d]\n", info->version, info->flags, info->count));
3447         DEBUGADD(1,("num\ttype\tfield\tres\tid\tsize\tenc_type\n"));
3448
3449         for (i=0; i<info->count; i++) {
3450                 DEBUGADD(1,("[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\n",
3451                 i, info->data[i].type, info->data[i].field, info->data[i].reserved,
3452                 info->data[i].id, info->data[i].size, info->data[i].enc_type));
3453         }
3454         */
3455         return WERR_OK;
3456 }
3457
3458 /****************************************************************
3459  _spoolss_RouterRefreshPrinterChangeNotify
3460 ****************************************************************/
3461
3462 WERROR _spoolss_RouterRefreshPrinterChangeNotify(pipes_struct *p,
3463                                                  struct spoolss_RouterRefreshPrinterChangeNotify *r)
3464 {
3465         struct spoolss_NotifyInfo *info;
3466
3467         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
3468         WERROR result = WERR_BADFID;
3469
3470         /* we always have a spoolss_NotifyInfo struct */
3471         info = talloc_zero(p->mem_ctx, struct spoolss_NotifyInfo);
3472         if (!info) {
3473                 result = WERR_NOMEM;
3474                 goto done;
3475         }
3476
3477         *r->out.info = info;
3478
3479         if (!Printer) {
3480                 DEBUG(2,("_spoolss_RouterRefreshPrinterChangeNotify: "
3481                         "Invalid handle (%s:%u:%u).\n",
3482                         OUR_HANDLE(r->in.handle)));
3483                 goto done;
3484         }
3485
3486         DEBUG(4,("Printer type %x\n",Printer->printer_type));
3487
3488         /*
3489          *      We are now using the change value, and
3490          *      I should check for PRINTER_NOTIFY_OPTIONS_REFRESH but as
3491          *      I don't have a global notification system, I'm sending back all the
3492          *      informations even when _NOTHING_ has changed.
3493          */
3494
3495         /* We need to keep track of the change value to send back in
3496            RRPCN replies otherwise our updates are ignored. */
3497
3498         Printer->notify.fnpcn = true;
3499
3500         if (Printer->notify.client_connected) {
3501                 DEBUG(10,("_spoolss_RouterRefreshPrinterChangeNotify: "
3502                         "Saving change value in request [%x]\n",
3503                         r->in.change_low));
3504                 Printer->notify.change = r->in.change_low;
3505         }
3506
3507         /* just ignore the spoolss_NotifyOption */
3508
3509         switch (Printer->printer_type) {
3510                 case SPLHND_SERVER:
3511                         result = printserver_notify_info(p, r->in.handle,
3512                                                          info, p->mem_ctx);
3513                         break;
3514
3515                 case SPLHND_PRINTER:
3516                         result = printer_notify_info(p, r->in.handle,
3517                                                      info, p->mem_ctx);
3518                         break;
3519         }
3520
3521         Printer->notify.fnpcn = false;
3522
3523 done:
3524         return result;
3525 }
3526
3527 /********************************************************************
3528  * construct_printer_info_0
3529  * fill a printer_info_0 struct
3530  ********************************************************************/
3531
3532 static WERROR construct_printer_info0(TALLOC_CTX *mem_ctx,
3533                                       const NT_PRINTER_INFO_LEVEL *ntprinter,
3534                                       struct spoolss_PrinterInfo0 *r,
3535                                       int snum)
3536 {
3537         int count;
3538         counter_printer_0 *session_counter;
3539         time_t setuptime;
3540         print_status_struct status;
3541
3542         r->printername          = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
3543         W_ERROR_HAVE_NO_MEMORY(r->printername);
3544
3545         r->servername           = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
3546         W_ERROR_HAVE_NO_MEMORY(r->servername);
3547
3548         count = print_queue_length(snum, &status);
3549
3550         /* check if we already have a counter for this printer */
3551         for (session_counter = counter_list; session_counter; session_counter = session_counter->next) {
3552                 if (session_counter->snum == snum)
3553                         break;
3554         }
3555
3556         /* it's the first time, add it to the list */
3557         if (session_counter == NULL) {
3558                 session_counter = SMB_MALLOC_P(counter_printer_0);
3559                 W_ERROR_HAVE_NO_MEMORY(session_counter);
3560                 ZERO_STRUCTP(session_counter);
3561                 session_counter->snum           = snum;
3562                 session_counter->counter        = 0;
3563                 DLIST_ADD(counter_list, session_counter);
3564         }
3565
3566         /* increment it */
3567         session_counter->counter++;
3568
3569         r->cjobs                        = count;
3570         r->total_jobs                   = 0;
3571         r->total_bytes                  = 0;
3572
3573         setuptime = (time_t)ntprinter->info_2->setuptime;
3574
3575         init_systemtime(&r->time, gmtime(&setuptime));
3576
3577         /* JFM:
3578          * the global_counter should be stored in a TDB as it's common to all the clients
3579          * and should be zeroed on samba startup
3580          */
3581         r->global_counter               = session_counter->counter;
3582         r->total_pages                  = 0;
3583         /* in 2.2 we reported ourselves as 0x0004 and 0x0565 */
3584         r->version                      = 0x0005;       /* NT 5 */
3585         r->free_build                   = 0x0893;       /* build 2195 */
3586         r->spooling                     = 0;
3587         r->max_spooling                 = 0;
3588         r->session_counter              = session_counter->counter;
3589         r->num_error_out_of_paper       = 0x0;
3590         r->num_error_not_ready          = 0x0;          /* number of print failure */
3591         r->job_error                    = 0x0;
3592         r->number_of_processors         = 0x1;
3593         r->processor_type               = PROCESSOR_INTEL_PENTIUM; /* 586 Pentium ? */
3594         r->high_part_total_bytes        = 0x0;
3595         r->change_id                    = ntprinter->info_2->changeid; /* ChangeID in milliseconds*/
3596         r->last_error                   = WERR_OK;
3597         r->status                       = nt_printq_status(status.status);
3598         r->enumerate_network_printers   = 0x0;
3599         r->c_setprinter                 = get_c_setprinter(); /* monotonically increasing sum of delta printer counts */
3600         r->processor_architecture       = 0x0;
3601         r->processor_level              = 0x6;          /* 6  ???*/
3602         r->ref_ic                       = 0;
3603         r->reserved2                    = 0;
3604         r->reserved3                    = 0;
3605
3606         return WERR_OK;
3607 }
3608
3609 /****************************************************************************
3610  Convert an NT_DEVICEMODE to a spoolss_DeviceMode structure.  Both pointers
3611  should be valid upon entry
3612 ****************************************************************************/
3613
3614 static WERROR convert_nt_devicemode(TALLOC_CTX *mem_ctx,
3615                                     struct spoolss_DeviceMode *r,
3616                                     const NT_DEVICEMODE *ntdevmode)
3617 {
3618         if (!r || !ntdevmode) {
3619                 return WERR_INVALID_PARAM;
3620         }
3621
3622         r->devicename           = talloc_strdup(mem_ctx, ntdevmode->devicename);
3623         W_ERROR_HAVE_NO_MEMORY(r->devicename);
3624
3625         r->specversion          = ntdevmode->specversion;
3626         r->driverversion        = ntdevmode->driverversion;
3627         r->size                 = ntdevmode->size;
3628         r->__driverextra_length = ntdevmode->driverextra;
3629         r->fields               = ntdevmode->fields;
3630
3631         r->orientation          = ntdevmode->orientation;
3632         r->papersize            = ntdevmode->papersize;
3633         r->paperlength          = ntdevmode->paperlength;
3634         r->paperwidth           = ntdevmode->paperwidth;
3635         r->scale                = ntdevmode->scale;
3636         r->copies               = ntdevmode->copies;
3637         r->defaultsource        = ntdevmode->defaultsource;
3638         r->printquality         = ntdevmode->printquality;
3639         r->color                = ntdevmode->color;
3640         r->duplex               = ntdevmode->duplex;
3641         r->yresolution          = ntdevmode->yresolution;
3642         r->ttoption             = ntdevmode->ttoption;
3643         r->collate              = ntdevmode->collate;
3644
3645         r->formname             = talloc_strdup(mem_ctx, ntdevmode->formname);
3646         W_ERROR_HAVE_NO_MEMORY(r->formname);
3647
3648         /* all 0 below are values that have not been set in the old parsing/copy
3649          * function, maybe they should... - gd */
3650
3651         r->logpixels            = 0;
3652         r->bitsperpel           = 0;
3653         r->pelswidth            = 0;
3654         r->pelsheight           = 0;
3655         r->displayflags         = 0;
3656         r->displayfrequency     = 0;
3657         r->icmmethod            = ntdevmode->icmmethod;
3658         r->icmintent            = ntdevmode->icmintent;
3659         r->mediatype            = ntdevmode->mediatype;
3660         r->dithertype           = ntdevmode->dithertype;
3661         r->reserved1            = 0;
3662         r->reserved2            = 0;
3663         r->panningwidth         = 0;
3664         r->panningheight        = 0;
3665
3666         if (ntdevmode->nt_dev_private != NULL) {
3667                 r->driverextra_data = data_blob_talloc(mem_ctx,
3668                         ntdevmode->nt_dev_private,
3669                         ntdevmode->driverextra);
3670                 W_ERROR_HAVE_NO_MEMORY(r->driverextra_data.data);
3671         }
3672
3673         return WERR_OK;
3674 }
3675
3676
3677 /****************************************************************************
3678  Create a spoolss_DeviceMode struct. Returns talloced memory.
3679 ****************************************************************************/
3680
3681 struct spoolss_DeviceMode *construct_dev_mode(TALLOC_CTX *mem_ctx,
3682                                               const char *servicename)
3683 {
3684         WERROR result;
3685         NT_PRINTER_INFO_LEVEL   *printer = NULL;
3686         struct spoolss_DeviceMode *devmode = NULL;
3687
3688         DEBUG(7,("construct_dev_mode\n"));
3689
3690         DEBUGADD(8,("getting printer characteristics\n"));
3691
3692         if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, servicename)))
3693                 return NULL;
3694
3695         if (!printer->info_2->devmode) {
3696                 DEBUG(5, ("BONG! There was no device mode!\n"));
3697                 goto done;
3698         }
3699
3700         devmode = TALLOC_ZERO_P(mem_ctx, struct spoolss_DeviceMode);
3701         if (!devmode) {
3702                 DEBUG(2,("construct_dev_mode: talloc fail.\n"));
3703                 goto done;
3704         }
3705
3706         DEBUGADD(8,("loading DEVICEMODE\n"));
3707
3708         result = convert_nt_devicemode(mem_ctx, devmode, printer->info_2->devmode);
3709         if (!W_ERROR_IS_OK(result)) {
3710                 TALLOC_FREE(devmode);
3711         }
3712
3713 done:
3714         free_a_printer(&printer,2);
3715
3716         return devmode;
3717 }
3718
3719 /********************************************************************
3720  * construct_printer_info1
3721  * fill a spoolss_PrinterInfo1 struct
3722 ********************************************************************/
3723
3724 static WERROR construct_printer_info1(TALLOC_CTX *mem_ctx,
3725                                       const NT_PRINTER_INFO_LEVEL *ntprinter,
3726                                       uint32_t flags,
3727                                       struct spoolss_PrinterInfo1 *r,
3728                                       int snum)
3729 {
3730         r->flags                = flags;
3731
3732         r->description          = talloc_asprintf(mem_ctx, "%s,%s,%s",
3733                                                   ntprinter->info_2->printername,
3734                                                   ntprinter->info_2->drivername,
3735                                                   ntprinter->info_2->location);
3736         W_ERROR_HAVE_NO_MEMORY(r->description);
3737
3738         if (*ntprinter->info_2->comment == '\0') {
3739                 r->comment      = talloc_strdup(mem_ctx, lp_comment(snum));
3740         } else {
3741                 r->comment      = talloc_strdup(mem_ctx, ntprinter->info_2->comment); /* saved comment */
3742         }
3743         W_ERROR_HAVE_NO_MEMORY(r->comment);
3744
3745         r->name                 = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
3746         W_ERROR_HAVE_NO_MEMORY(r->name);
3747
3748         return WERR_OK;
3749 }
3750
3751 /********************************************************************
3752  * construct_printer_info2
3753  * fill a spoolss_PrinterInfo2 struct
3754 ********************************************************************/
3755
3756 static WERROR construct_printer_info2(TALLOC_CTX *mem_ctx,
3757                                       const NT_PRINTER_INFO_LEVEL *ntprinter,
3758                                       struct spoolss_PrinterInfo2 *r,
3759                                       int snum)
3760 {
3761         int count;
3762
3763         print_status_struct status;
3764
3765         count = print_queue_length(snum, &status);
3766
3767         r->servername           = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
3768         W_ERROR_HAVE_NO_MEMORY(r->servername);
3769         r->printername          = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
3770         W_ERROR_HAVE_NO_MEMORY(r->printername);
3771         r->sharename            = talloc_strdup(mem_ctx, lp_servicename(snum));
3772         W_ERROR_HAVE_NO_MEMORY(r->sharename);
3773         r->portname             = talloc_strdup(mem_ctx, ntprinter->info_2->portname);
3774         W_ERROR_HAVE_NO_MEMORY(r->portname);
3775         r->drivername           = talloc_strdup(mem_ctx, ntprinter->info_2->drivername);
3776         W_ERROR_HAVE_NO_MEMORY(r->drivername);
3777
3778         if (*ntprinter->info_2->comment == '\0') {
3779                 r->comment      = talloc_strdup(mem_ctx, lp_comment(snum));
3780         } else {
3781                 r->comment      = talloc_strdup(mem_ctx, ntprinter->info_2->comment);
3782         }
3783         W_ERROR_HAVE_NO_MEMORY(r->comment);
3784
3785         r->location             = talloc_strdup(mem_ctx, ntprinter->info_2->location);
3786         W_ERROR_HAVE_NO_MEMORY(r->location);
3787         r->sepfile              = talloc_strdup(mem_ctx, ntprinter->info_2->sepfile);
3788         W_ERROR_HAVE_NO_MEMORY(r->sepfile);
3789         r->printprocessor       = talloc_strdup(mem_ctx, ntprinter->info_2->printprocessor);
3790         W_ERROR_HAVE_NO_MEMORY(r->printprocessor);
3791         r->datatype             = talloc_strdup(mem_ctx, ntprinter->info_2->datatype);
3792         W_ERROR_HAVE_NO_MEMORY(r->datatype);
3793         r->parameters           = talloc_strdup(mem_ctx, ntprinter->info_2->parameters);
3794         W_ERROR_HAVE_NO_MEMORY(r->parameters);
3795
3796         r->attributes           = ntprinter->info_2->attributes;
3797
3798         r->priority             = ntprinter->info_2->priority;
3799         r->defaultpriority      = ntprinter->info_2->default_priority;
3800         r->starttime            = ntprinter->info_2->starttime;
3801         r->untiltime            = ntprinter->info_2->untiltime;
3802         r->status               = nt_printq_status(status.status);
3803         r->cjobs                = count;
3804         r->averageppm           = ntprinter->info_2->averageppm;
3805
3806         r->devmode = construct_dev_mode(mem_ctx, lp_const_servicename(snum));
3807         if (!r->devmode) {
3808                 DEBUG(8,("Returning NULL Devicemode!\n"));
3809         }
3810
3811         r->secdesc              = NULL;
3812
3813         if (ntprinter->info_2->secdesc_buf && ntprinter->info_2->secdesc_buf->sd_size != 0) {
3814                 /* don't use talloc_steal() here unless you do a deep steal of all
3815                    the SEC_DESC members */
3816
3817                 r->secdesc      = dup_sec_desc(mem_ctx, ntprinter->info_2->secdesc_buf->sd);
3818         }
3819
3820         return WERR_OK;
3821 }
3822
3823 /********************************************************************
3824  * construct_printer_info3
3825  * fill a spoolss_PrinterInfo3 struct
3826  ********************************************************************/
3827
3828 static WERROR construct_printer_info3(TALLOC_CTX *mem_ctx,
3829                                       const NT_PRINTER_INFO_LEVEL *ntprinter,
3830                                       struct spoolss_PrinterInfo3 *r,
3831                                       int snum)
3832 {
3833         /* These are the components of the SD we are returning. */
3834
3835         if (ntprinter->info_2->secdesc_buf && ntprinter->info_2->secdesc_buf->sd_size != 0) {
3836                 /* don't use talloc_steal() here unless you do a deep steal of all
3837                    the SEC_DESC members */
3838
3839                 r->secdesc = dup_sec_desc(mem_ctx,
3840                                           ntprinter->info_2->secdesc_buf->sd);
3841                 W_ERROR_HAVE_NO_MEMORY(r->secdesc);
3842         }
3843
3844         return WERR_OK;
3845 }
3846
3847 /********************************************************************
3848  * construct_printer_info4
3849  * fill a spoolss_PrinterInfo4 struct
3850  ********************************************************************/
3851
3852 static WERROR construct_printer_info4(TALLOC_CTX *mem_ctx,
3853                                       const NT_PRINTER_INFO_LEVEL *ntprinter,
3854                                       struct spoolss_PrinterInfo4 *r,
3855                                       int snum)
3856 {
3857         r->printername  = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
3858         W_ERROR_HAVE_NO_MEMORY(r->printername);
3859         r->servername   = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
3860         W_ERROR_HAVE_NO_MEMORY(r->servername);
3861
3862         r->attributes   = ntprinter->info_2->attributes;
3863
3864         return WERR_OK;
3865 }
3866
3867 /********************************************************************
3868  * construct_printer_info5
3869  * fill a spoolss_PrinterInfo5 struct
3870  ********************************************************************/
3871
3872 static WERROR construct_printer_info5(TALLOC_CTX *mem_ctx,
3873                                       const NT_PRINTER_INFO_LEVEL *ntprinter,
3874                                       struct spoolss_PrinterInfo5 *r,
3875                                       int snum)
3876 {
3877         r->printername  = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
3878         W_ERROR_HAVE_NO_MEMORY(r->printername);
3879         r->portname     = talloc_strdup(mem_ctx, ntprinter->info_2->portname);
3880         W_ERROR_HAVE_NO_MEMORY(r->portname);
3881
3882         r->attributes   = ntprinter->info_2->attributes;
3883
3884         /* these two are not used by NT+ according to MSDN */
3885
3886         r->device_not_selected_timeout          = 0x0;  /* have seen 0x3a98 */
3887         r->transmission_retry_timeout           = 0x0;  /* have seen 0xafc8 */
3888
3889         return WERR_OK;
3890 }
3891
3892 /********************************************************************
3893  * construct_printer_info_6
3894  * fill a spoolss_PrinterInfo6 struct
3895  ********************************************************************/
3896
3897 static WERROR construct_printer_info6(TALLOC_CTX *mem_ctx,
3898                                       const NT_PRINTER_INFO_LEVEL *ntprinter,
3899                                       struct spoolss_PrinterInfo6 *r,
3900                                       int snum)
3901 {
3902         int count;
3903         print_status_struct status;
3904
3905         count = print_queue_length(snum, &status);
3906
3907         r->status = nt_printq_status(status.status);
3908
3909         return WERR_OK;
3910 }
3911
3912 /********************************************************************
3913  * construct_printer_info7
3914  * fill a spoolss_PrinterInfo7 struct
3915  ********************************************************************/
3916
3917 static WERROR construct_printer_info7(TALLOC_CTX *mem_ctx,
3918                                       Printer_entry *print_hnd,
3919                                       struct spoolss_PrinterInfo7 *r,
3920                                       int snum)
3921 {
3922         struct GUID guid;
3923
3924         if (is_printer_published(print_hnd, snum, &guid)) {
3925                 r->guid = talloc_strdup_upper(mem_ctx, GUID_string2(mem_ctx, &guid));
3926                 r->action = DSPRINT_PUBLISH;
3927         } else {
3928                 r->guid = talloc_strdup(mem_ctx, "");
3929                 r->action = DSPRINT_UNPUBLISH;
3930         }
3931         W_ERROR_HAVE_NO_MEMORY(r->guid);
3932
3933         return WERR_OK;
3934 }
3935
3936 /********************************************************************
3937  * construct_printer_info8
3938  * fill a spoolss_PrinterInfo8 struct
3939  ********************************************************************/
3940
3941 static WERROR construct_printer_info8(TALLOC_CTX *mem_ctx,
3942                                       const NT_PRINTER_INFO_LEVEL *ntprinter,
3943                                       struct spoolss_DeviceModeInfo *r,
3944                                       int snum)
3945 {
3946         struct spoolss_DeviceMode *devmode;
3947         WERROR result;
3948
3949         if (!ntprinter->info_2->devmode) {
3950                 r->devmode = NULL;
3951                 return WERR_OK;
3952         }
3953
3954         devmode = TALLOC_ZERO_P(mem_ctx, struct spoolss_DeviceMode);
3955         W_ERROR_HAVE_NO_MEMORY(devmode);
3956
3957         result = convert_nt_devicemode(mem_ctx, devmode, ntprinter->info_2->devmode);
3958         if (!W_ERROR_IS_OK(result)) {
3959                 TALLOC_FREE(devmode);
3960                 return result;
3961         }
3962
3963         r->devmode      = devmode;
3964
3965         return WERR_OK;
3966 }
3967
3968
3969 /********************************************************************
3970 ********************************************************************/
3971
3972 static bool snum_is_shared_printer(int snum)
3973 {
3974         return (lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum));
3975 }
3976
3977 /********************************************************************
3978  Spoolss_enumprinters.
3979 ********************************************************************/
3980
3981 static WERROR enum_all_printers_info_level(TALLOC_CTX *mem_ctx,
3982                                            uint32_t level,
3983                                            uint32_t flags,
3984                                            union spoolss_PrinterInfo **info_p,
3985                                            uint32_t *count_p)
3986 {
3987         int snum;
3988         int n_services = lp_numservices();
3989         union spoolss_PrinterInfo *info = NULL;
3990         uint32_t count = 0;
3991         WERROR result = WERR_OK;
3992
3993         *count_p = 0;
3994         *info_p = NULL;
3995
3996         for (snum = 0; snum < n_services; snum++) {
3997
3998                 NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
3999
4000                 if (!snum_is_shared_printer(snum)) {
4001                         continue;
4002                 }
4003
4004                 DEBUG(4,("Found a printer in smb.conf: %s[%x]\n",
4005                         lp_servicename(snum), snum));
4006
4007                 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4008                                             union spoolss_PrinterInfo,
4009                                             count + 1);
4010                 if (!info) {
4011                         result = WERR_NOMEM;
4012                         goto out;
4013                 }
4014
4015                 result = get_a_printer(NULL, &ntprinter, 2,
4016                                        lp_const_servicename(snum));
4017                 if (!W_ERROR_IS_OK(result)) {
4018                         goto out;
4019                 }
4020
4021                 switch (level) {
4022                 case 0:
4023                         result = construct_printer_info0(info, ntprinter,
4024                                                          &info[count].info0, snum);
4025                         break;
4026                 case 1:
4027                         result = construct_printer_info1(info, ntprinter, flags,
4028                                                          &info[count].info1, snum);
4029                         break;
4030                 case 2:
4031                         result = construct_printer_info2(info, ntprinter,
4032                                                          &info[count].info2, snum);
4033                         break;
4034                 case 4:
4035                         result = construct_printer_info4(info, ntprinter,
4036                                                          &info[count].info4, snum);
4037                         break;
4038                 case 5:
4039                         result = construct_printer_info5(info, ntprinter,
4040                                                          &info[count].info5, snum);
4041                         break;
4042
4043                 default:
4044                         result = WERR_UNKNOWN_LEVEL;
4045                         free_a_printer(&ntprinter, 2);
4046                         goto out;
4047                 }
4048
4049                 free_a_printer(&ntprinter, 2);
4050                 if (!W_ERROR_IS_OK(result)) {
4051                         goto out;
4052                 }
4053
4054                 count++;
4055         }
4056
4057         *count_p = count;
4058         *info_p = info;
4059
4060  out:
4061         if (!W_ERROR_IS_OK(result)) {
4062                 TALLOC_FREE(info);
4063                 return result;
4064         }
4065
4066         *info_p = info;
4067
4068         return WERR_OK;
4069 }
4070
4071 /********************************************************************
4072  * handle enumeration of printers at level 0
4073  ********************************************************************/
4074
4075 static WERROR enumprinters_level0(TALLOC_CTX *mem_ctx,
4076                                   uint32_t flags,
4077                                   const char *servername,
4078                                   union spoolss_PrinterInfo **info,
4079                                   uint32_t *count)
4080 {
4081         DEBUG(4,("enum_all_printers_info_0\n"));
4082
4083         return enum_all_printers_info_level(mem_ctx, 0, flags, info, count);
4084 }
4085
4086
4087 /********************************************************************
4088 ********************************************************************/
4089
4090 static WERROR enum_all_printers_info_1(TALLOC_CTX *mem_ctx,
4091                                        uint32_t flags,
4092                                        union spoolss_PrinterInfo **info,
4093                                        uint32_t *count)
4094 {
4095         DEBUG(4,("enum_all_printers_info_1\n"));
4096
4097         return enum_all_printers_info_level(mem_ctx, 1, flags, info, count);
4098 }
4099
4100 /********************************************************************
4101  enum_all_printers_info_1_local.
4102 *********************************************************************/
4103
4104 static WERROR enum_all_printers_info_1_local(TALLOC_CTX *mem_ctx,
4105                                              union spoolss_PrinterInfo **info,
4106                                              uint32_t *count)
4107 {
4108         DEBUG(4,("enum_all_printers_info_1_local\n"));
4109
4110         return enum_all_printers_info_1(mem_ctx, PRINTER_ENUM_ICON8, info, count);
4111 }
4112
4113 /********************************************************************
4114  enum_all_printers_info_1_name.
4115 *********************************************************************/
4116
4117 static WERROR enum_all_printers_info_1_name(TALLOC_CTX *mem_ctx,
4118                                             const char *name,
4119                                             union spoolss_PrinterInfo **info,
4120                                             uint32_t *count)
4121 {
4122         const char *s = name;
4123
4124         DEBUG(4,("enum_all_printers_info_1_name\n"));
4125
4126         if ((name[0] == '\\') && (name[1] == '\\')) {
4127                 s = name + 2;
4128         }
4129
4130         if (!is_myname_or_ipaddr(s)) {
4131                 return WERR_INVALID_NAME;
4132         }
4133
4134         return enum_all_printers_info_1(mem_ctx, PRINTER_ENUM_ICON8, info, count);
4135 }
4136
4137 /********************************************************************
4138  enum_all_printers_info_1_network.
4139 *********************************************************************/
4140
4141 static WERROR enum_all_printers_info_1_network(TALLOC_CTX *mem_ctx,
4142                                                const char *name,
4143                                                union spoolss_PrinterInfo **info,
4144                                                uint32_t *count)
4145 {
4146         const char *s = name;
4147
4148         DEBUG(4,("enum_all_printers_info_1_network\n"));
4149
4150         /* If we respond to a enum_printers level 1 on our name with flags
4151            set to PRINTER_ENUM_REMOTE with a list of printers then these
4152            printers incorrectly appear in the APW browse list.
4153            Specifically the printers for the server appear at the workgroup
4154            level where all the other servers in the domain are
4155            listed. Windows responds to this call with a
4156            WERR_CAN_NOT_COMPLETE so we should do the same. */
4157
4158         if (name[0] == '\\' && name[1] == '\\') {
4159                  s = name + 2;
4160         }
4161
4162         if (is_myname_or_ipaddr(s)) {
4163                  return WERR_CAN_NOT_COMPLETE;
4164         }
4165
4166         return enum_all_printers_info_1(mem_ctx, PRINTER_ENUM_NAME, info, count);
4167 }
4168
4169 /********************************************************************
4170  * api_spoolss_enumprinters
4171  *
4172  * called from api_spoolss_enumprinters (see this to understand)
4173  ********************************************************************/
4174
4175 static WERROR enum_all_printers_info_2(TALLOC_CTX *mem_ctx,
4176                                        union spoolss_PrinterInfo **info,
4177                                        uint32_t *count)
4178 {
4179         DEBUG(4,("enum_all_printers_info_2\n"));
4180
4181         return enum_all_printers_info_level(mem_ctx, 2, 0, info, count);
4182 }
4183
4184 /********************************************************************
4185  * handle enumeration of printers at level 1
4186  ********************************************************************/
4187
4188 static WERROR enumprinters_level1(TALLOC_CTX *mem_ctx,
4189                                   uint32_t flags,
4190                                   const char *name,
4191                                   union spoolss_PrinterInfo **info,
4192                                   uint32_t *count)
4193 {
4194         /* Not all the flags are equals */
4195
4196         if (flags & PRINTER_ENUM_LOCAL) {
4197                 return enum_all_printers_info_1_local(mem_ctx, info, count);
4198         }
4199
4200         if (flags & PRINTER_ENUM_NAME) {
4201                 return enum_all_printers_info_1_name(mem_ctx, name, info, count);
4202         }
4203
4204         if (flags & PRINTER_ENUM_NETWORK) {
4205                 return enum_all_printers_info_1_network(mem_ctx, name, info, count);
4206         }
4207
4208         return WERR_OK; /* NT4sp5 does that */
4209 }
4210
4211 /********************************************************************
4212  * handle enumeration of printers at level 2
4213  ********************************************************************/
4214
4215 static WERROR enumprinters_level2(TALLOC_CTX *mem_ctx,
4216                                   uint32_t flags,
4217                                   const char *servername,
4218                                   union spoolss_PrinterInfo **info,
4219                                   uint32_t *count)
4220 {
4221         if (flags & PRINTER_ENUM_LOCAL) {
4222                 return enum_all_printers_info_2(mem_ctx, info, count);
4223         }
4224
4225         if (flags & PRINTER_ENUM_NAME) {
4226                 if (!is_myname_or_ipaddr(canon_servername(servername))) {
4227                         return WERR_INVALID_NAME;
4228                 }
4229
4230                 return enum_all_printers_info_2(mem_ctx, info, count);
4231         }
4232
4233         if (flags & PRINTER_ENUM_REMOTE) {
4234                 return WERR_UNKNOWN_LEVEL;
4235         }
4236
4237         return WERR_OK;
4238 }
4239
4240 /********************************************************************
4241  * handle enumeration of printers at level 4
4242  ********************************************************************/
4243
4244 static WERROR enumprinters_level4(TALLOC_CTX *mem_ctx,
4245                                   uint32_t flags,
4246                                   const char *servername,
4247                                   union spoolss_PrinterInfo **info,
4248                                   uint32_t *count)
4249 {
4250         DEBUG(4,("enum_all_printers_info_4\n"));
4251
4252         return enum_all_printers_info_level(mem_ctx, 4, flags, info, count);
4253 }
4254
4255
4256 /********************************************************************
4257  * handle enumeration of printers at level 5
4258  ********************************************************************/
4259
4260 static WERROR enumprinters_level5(TALLOC_CTX *mem_ctx,
4261                                   uint32_t flags,
4262                                   const char *servername,
4263                                   union spoolss_PrinterInfo **info,
4264                                   uint32_t *count)
4265 {
4266         DEBUG(4,("enum_all_printers_info_5\n"));
4267
4268         return enum_all_printers_info_level(mem_ctx, 5, flags, info, count);
4269 }
4270
4271 /****************************************************************
4272  _spoolss_EnumPrinters
4273 ****************************************************************/
4274
4275 WERROR _spoolss_EnumPrinters(pipes_struct *p,
4276                              struct spoolss_EnumPrinters *r)
4277 {
4278         const char *name;
4279         WERROR result;
4280
4281         /* that's an [in out] buffer */
4282
4283         if (!r->in.buffer && (r->in.offered != 0)) {
4284                 return WERR_INVALID_PARAM;
4285         }
4286
4287         DEBUG(4,("_spoolss_EnumPrinters\n"));
4288
4289         *r->out.needed = 0;
4290         *r->out.count = 0;
4291         *r->out.info = NULL;
4292
4293         /*
4294          * Level 1:
4295          *          flags==PRINTER_ENUM_NAME
4296          *           if name=="" then enumerates all printers
4297          *           if name!="" then enumerate the printer
4298          *          flags==PRINTER_ENUM_REMOTE
4299          *          name is NULL, enumerate printers
4300          * Level 2: name!="" enumerates printers, name can't be NULL
4301          * Level 3: doesn't exist
4302          * Level 4: does a local registry lookup
4303          * Level 5: same as Level 2
4304          */
4305
4306         name = talloc_strdup_upper(p->mem_ctx, r->in.server);
4307         W_ERROR_HAVE_NO_MEMORY(name);
4308
4309         switch (r->in.level) {
4310         case 0:
4311                 result = enumprinters_level0(p->mem_ctx, r->in.flags, name,
4312                                              r->out.info, r->out.count);
4313                 break;
4314         case 1:
4315                 result = enumprinters_level1(p->mem_ctx, r->in.flags, name,
4316                                              r->out.info, r->out.count);
4317                 break;
4318         case 2:
4319                 result = enumprinters_level2(p->mem_ctx, r->in.flags, name,
4320                                              r->out.info, r->out.count);
4321                 break;
4322         case 4:
4323                 result = enumprinters_level4(p->mem_ctx, r->in.flags, name,
4324                                              r->out.info, r->out.count);
4325                 break;
4326         case 5:
4327                 result = enumprinters_level5(p->mem_ctx, r->in.flags, name,
4328                                              r->out.info, r->out.count);
4329                 break;
4330         default:
4331                 return WERR_UNKNOWN_LEVEL;
4332         }
4333
4334         if (!W_ERROR_IS_OK(result)) {
4335                 return result;
4336         }
4337
4338         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
4339                                                      spoolss_EnumPrinters, NULL,
4340                                                      *r->out.info, r->in.level,
4341                                                      *r->out.count);
4342         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
4343         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
4344
4345         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
4346 }
4347
4348 /****************************************************************
4349  _spoolss_GetPrinter
4350 ****************************************************************/
4351
4352 WERROR _spoolss_GetPrinter(pipes_struct *p,
4353                            struct spoolss_GetPrinter *r)
4354 {
4355         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
4356         NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
4357         WERROR result = WERR_OK;
4358
4359         int snum;
4360
4361         /* that's an [in out] buffer */
4362
4363         if (!r->in.buffer && (r->in.offered != 0)) {
4364                 return WERR_INVALID_PARAM;
4365         }
4366
4367         *r->out.needed = 0;
4368
4369         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
4370                 return WERR_BADFID;
4371         }
4372
4373         result = get_a_printer(Printer, &ntprinter, 2,
4374                                lp_const_servicename(snum));
4375         if (!W_ERROR_IS_OK(result)) {
4376                 return result;
4377         }
4378
4379         switch (r->in.level) {
4380         case 0:
4381                 result = construct_printer_info0(p->mem_ctx, ntprinter,
4382                                                  &r->out.info->info0, snum);
4383                 break;
4384         case 1:
4385                 result = construct_printer_info1(p->mem_ctx, ntprinter,
4386                                                  PRINTER_ENUM_ICON8,
4387                                                  &r->out.info->info1, snum);
4388                 break;
4389         case 2:
4390                 result = construct_printer_info2(p->mem_ctx, ntprinter,
4391                                                  &r->out.info->info2, snum);
4392                 break;
4393         case 3:
4394                 result = construct_printer_info3(p->mem_ctx, ntprinter,
4395                                                  &r->out.info->info3, snum);
4396                 break;
4397         case 4:
4398                 result = construct_printer_info4(p->mem_ctx, ntprinter,
4399                                                  &r->out.info->info4, snum);
4400                 break;
4401         case 5:
4402                 result = construct_printer_info5(p->mem_ctx, ntprinter,
4403                                                  &r->out.info->info5, snum);
4404                 break;
4405         case 6:
4406                 result = construct_printer_info6(p->mem_ctx, ntprinter,
4407                                                  &r->out.info->info6, snum);
4408                 break;
4409         case 7:
4410                 result = construct_printer_info7(p->mem_ctx, Printer,
4411                                                  &r->out.info->info7, snum);
4412                 break;
4413         case 8:
4414                 result = construct_printer_info8(p->mem_ctx, ntprinter,
4415                                                  &r->out.info->info8, snum);
4416                 break;
4417         default:
4418                 result = WERR_UNKNOWN_LEVEL;
4419                 break;
4420         }
4421
4422         free_a_printer(&ntprinter, 2);
4423
4424         if (!W_ERROR_IS_OK(result)) {
4425                 TALLOC_FREE(r->out.info);
4426                 return result;
4427         }
4428
4429         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_PrinterInfo, NULL,
4430                                                r->out.info, r->in.level);
4431         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
4432
4433         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
4434 }
4435
4436 /********************************************************************
4437  ********************************************************************/
4438
4439 static const char **string_array_from_driver_info(TALLOC_CTX *mem_ctx,
4440                                                   const char **string_array,
4441                                                   const char *cservername)
4442 {
4443         int i, num_strings = 0;
4444         const char **array = NULL;
4445
4446         if (!string_array) {
4447                 return NULL;
4448         }
4449
4450         for (i=0; string_array[i] && string_array[i][0] != '\0'; i++) {
4451
4452                 const char *str = talloc_asprintf(mem_ctx, "\\\\%s%s",
4453                                                   cservername, string_array[i]);
4454                 if (!str) {
4455                         TALLOC_FREE(array);
4456                         return NULL;
4457                 }
4458
4459
4460                 if (!add_string_to_array(mem_ctx, str, &array, &num_strings)) {
4461                         TALLOC_FREE(array);
4462                         return NULL;
4463                 }
4464         }
4465
4466         if (i > 0) {
4467                 ADD_TO_ARRAY(mem_ctx, const char *, NULL,
4468                              &array, &num_strings);
4469         }
4470
4471         return array;
4472 }
4473
4474 #define FILL_DRIVER_STRING(mem_ctx, in, out) \
4475         do { \
4476                 if (in && strlen(in)) { \
4477                         out = talloc_strdup(mem_ctx, in); \
4478                         W_ERROR_HAVE_NO_MEMORY(out); \
4479                 } else { \
4480                         out = NULL; \
4481                 } \
4482         } while (0);
4483
4484 #define FILL_DRIVER_UNC_STRING(mem_ctx, server, in, out) \
4485         do { \
4486                 if (in && strlen(in)) { \
4487                         out = talloc_asprintf(mem_ctx, "\\\\%s%s", server, in); \
4488                 } else { \
4489                         out = talloc_strdup(mem_ctx, ""); \
4490                 } \
4491                 W_ERROR_HAVE_NO_MEMORY(out); \
4492         } while (0);
4493
4494 /********************************************************************
4495  * fill a spoolss_DriverInfo1 struct
4496  ********************************************************************/
4497
4498 static WERROR fill_printer_driver_info1(TALLOC_CTX *mem_ctx,
4499                                         struct spoolss_DriverInfo1 *r,
4500                                         const struct spoolss_DriverInfo8 *driver,
4501                                         const char *servername,
4502                                         const char *architecture)
4503 {
4504         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
4505         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4506
4507         return WERR_OK;
4508 }
4509
4510 /********************************************************************
4511  * fill a spoolss_DriverInfo2 struct
4512  ********************************************************************/
4513
4514 static WERROR fill_printer_driver_info2(TALLOC_CTX *mem_ctx,
4515                                         struct spoolss_DriverInfo2 *r,
4516                                         const struct spoolss_DriverInfo8 *driver,
4517                                         const char *servername)
4518
4519 {
4520         const char *cservername = canon_servername(servername);
4521
4522         r->version              = driver->version;
4523
4524         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
4525         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4526         r->architecture         = talloc_strdup(mem_ctx, driver->architecture);
4527         W_ERROR_HAVE_NO_MEMORY(r->architecture);
4528
4529         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4530                                driver->driver_path,
4531                                r->driver_path);
4532
4533         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4534                                driver->data_file,
4535                                r->data_file);
4536
4537         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4538                                driver->config_file,
4539                                r->config_file);
4540
4541         return WERR_OK;
4542 }
4543
4544 /********************************************************************
4545  * fill a spoolss_DriverInfo3 struct
4546  ********************************************************************/
4547
4548 static WERROR fill_printer_driver_info3(TALLOC_CTX *mem_ctx,
4549                                         struct spoolss_DriverInfo3 *r,
4550                                         const struct spoolss_DriverInfo8 *driver,
4551                                         const char *servername)
4552 {
4553         const char *cservername = canon_servername(servername);
4554
4555         r->version              = driver->version;
4556
4557         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
4558         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4559         r->architecture         = talloc_strdup(mem_ctx, driver->architecture);
4560         W_ERROR_HAVE_NO_MEMORY(r->architecture);
4561
4562         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4563                                driver->driver_path,
4564                                r->driver_path);
4565
4566         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4567                                driver->data_file,
4568                                r->data_file);
4569
4570         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4571                                driver->config_file,
4572                                r->config_file);
4573
4574         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4575                                driver->help_file,
4576                                r->help_file);
4577
4578         FILL_DRIVER_STRING(mem_ctx,
4579                            driver->monitor_name,
4580                            r->monitor_name);
4581
4582         FILL_DRIVER_STRING(mem_ctx,
4583                            driver->default_datatype,
4584                            r->default_datatype);
4585
4586         r->dependent_files = string_array_from_driver_info(mem_ctx,
4587                                                            driver->dependent_files,
4588                                                            cservername);
4589         return WERR_OK;
4590 }
4591
4592 /********************************************************************
4593  * fill a spoolss_DriverInfo4 struct
4594  ********************************************************************/
4595
4596 static WERROR fill_printer_driver_info4(TALLOC_CTX *mem_ctx,
4597                                         struct spoolss_DriverInfo4 *r,
4598                                         const struct spoolss_DriverInfo8 *driver,
4599                                         const char *servername)
4600 {
4601         const char *cservername = canon_servername(servername);
4602
4603         r->version              = driver->version;
4604
4605         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
4606         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4607         r->architecture         = talloc_strdup(mem_ctx, driver->architecture);
4608         W_ERROR_HAVE_NO_MEMORY(r->architecture);
4609
4610         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4611                                driver->driver_path,
4612                                r->driver_path);
4613
4614         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4615                                driver->data_file,
4616                                r->data_file);
4617
4618         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4619                                driver->config_file,
4620                                r->config_file);
4621
4622         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4623                                driver->help_file,
4624                                r->help_file);
4625
4626         r->dependent_files = string_array_from_driver_info(mem_ctx,
4627                                                            driver->dependent_files,
4628                                                            cservername);
4629
4630         FILL_DRIVER_STRING(mem_ctx,
4631                            driver->monitor_name,
4632                            r->monitor_name);
4633
4634         FILL_DRIVER_STRING(mem_ctx,
4635                            driver->default_datatype,
4636                            r->default_datatype);
4637
4638         r->previous_names = string_array_from_driver_info(mem_ctx,
4639                                                           driver->previous_names,
4640                                                           cservername);
4641
4642         return WERR_OK;
4643 }
4644
4645 /********************************************************************
4646  * fill a spoolss_DriverInfo5 struct
4647  ********************************************************************/
4648
4649 static WERROR fill_printer_driver_info5(TALLOC_CTX *mem_ctx,
4650                                         struct spoolss_DriverInfo5 *r,
4651                                         const struct spoolss_DriverInfo8 *driver,
4652                                         const char *servername)
4653 {
4654         const char *cservername = canon_servername(servername);
4655
4656         r->version              = driver->version;
4657
4658         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
4659         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4660         r->architecture         = talloc_strdup(mem_ctx, driver->architecture);
4661         W_ERROR_HAVE_NO_MEMORY(r->architecture);
4662
4663         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4664                                driver->driver_path,
4665                                r->driver_path);
4666
4667         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4668                                driver->data_file,
4669                                r->data_file);
4670
4671         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4672                                driver->config_file,
4673                                r->config_file);
4674
4675         r->driver_attributes    = 0;
4676         r->config_version       = 0;
4677         r->driver_version       = 0;
4678
4679         return WERR_OK;
4680 }
4681 /********************************************************************
4682  * fill a spoolss_DriverInfo6 struct
4683  ********************************************************************/
4684
4685 static WERROR fill_printer_driver_info6(TALLOC_CTX *mem_ctx,
4686                                         struct spoolss_DriverInfo6 *r,
4687                                         const struct spoolss_DriverInfo8 *driver,
4688                                         const char *servername)
4689 {
4690         const char *cservername = canon_servername(servername);
4691
4692         r->version              = driver->version;
4693
4694         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
4695         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4696         r->architecture         = talloc_strdup(mem_ctx, driver->architecture);
4697         W_ERROR_HAVE_NO_MEMORY(r->architecture);
4698
4699         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4700                                driver->driver_path,
4701                                r->driver_path);
4702
4703         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4704                                driver->data_file,
4705                                r->data_file);
4706
4707         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4708                                driver->config_file,
4709                                r->config_file);
4710
4711         FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4712                                driver->help_file,
4713                                r->help_file);
4714
4715         FILL_DRIVER_STRING(mem_ctx,
4716                            driver->monitor_name,
4717                            r->monitor_name);
4718
4719         FILL_DRIVER_STRING(mem_ctx,
4720                            driver->default_datatype,
4721                            r->default_datatype);
4722
4723         r->dependent_files = string_array_from_driver_info(mem_ctx,
4724                                                            driver->dependent_files,
4725                                                            cservername);
4726         r->previous_names = string_array_from_driver_info(mem_ctx,
4727                                                           driver->previous_names,
4728                                                           cservername);
4729
4730         r->driver_date          = driver->driver_date;
4731         r->driver_version       = driver->driver_version;
4732
4733         FILL_DRIVER_STRING(mem_ctx,
4734                            driver->manufacturer_name,
4735                            r->manufacturer_name);
4736         FILL_DRIVER_STRING(mem_ctx,
4737                            driver->manufacturer_url,
4738                            r->manufacturer_url);
4739         FILL_DRIVER_STRING(mem_ctx,
4740                            driver->hardware_id,
4741                            r->hardware_id);
4742         FILL_DRIVER_STRING(mem_ctx,
4743                            driver->provider,
4744                            r->provider);
4745
4746         return WERR_OK;
4747 }
4748
4749 /********************************************************************
4750  ********************************************************************/
4751
4752 static WERROR fill_spoolss_DriverFileInfo(TALLOC_CTX *mem_ctx,
4753                                           struct spoolss_DriverFileInfo *r,
4754                                           const char *cservername,
4755                                           const char *file_name,
4756                                           enum spoolss_DriverFileType file_type,
4757                                           uint32_t file_version)
4758 {
4759         r->file_name    = talloc_asprintf(mem_ctx, "\\\\%s%s",
4760                                           cservername, file_name);
4761         W_ERROR_HAVE_NO_MEMORY(r->file_name);
4762         r->file_type    = file_type;
4763         r->file_version = file_version;
4764
4765         return WERR_OK;
4766 }
4767
4768 /********************************************************************
4769  ********************************************************************/
4770
4771 static WERROR spoolss_DriverFileInfo_from_driver(TALLOC_CTX *mem_ctx,
4772                                                  const struct spoolss_DriverInfo8 *driver,
4773                                                  const char *cservername,
4774                                                  struct spoolss_DriverFileInfo **info_p,
4775                                                  uint32_t *count_p)
4776 {
4777         struct spoolss_DriverFileInfo *info = NULL;
4778         uint32_t count = 0;
4779         WERROR result;
4780         uint32_t i;
4781
4782         *info_p = NULL;
4783         *count_p = 0;
4784
4785         if (strlen(driver->driver_path)) {
4786                 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4787                                             struct spoolss_DriverFileInfo,
4788                                             count + 1);
4789                 W_ERROR_HAVE_NO_MEMORY(info);
4790                 result = fill_spoolss_DriverFileInfo(info,
4791                                                      &info[count],
4792                                                      cservername,
4793                                                      driver->driver_path,
4794                                                      SPOOLSS_DRIVER_FILE_TYPE_RENDERING,
4795                                                      0);
4796                 W_ERROR_NOT_OK_RETURN(result);
4797                 count++;
4798         }
4799
4800         if (strlen(driver->config_file)) {
4801                 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4802                                             struct spoolss_DriverFileInfo,
4803                                             count + 1);
4804                 W_ERROR_HAVE_NO_MEMORY(info);
4805                 result = fill_spoolss_DriverFileInfo(info,
4806                                                      &info[count],
4807                                                      cservername,
4808                                                      driver->config_file,
4809                                                      SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION,
4810                                                      0);
4811                 W_ERROR_NOT_OK_RETURN(result);
4812                 count++;
4813         }
4814
4815         if (strlen(driver->data_file)) {
4816                 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4817                                             struct spoolss_DriverFileInfo,
4818                                             count + 1);
4819                 W_ERROR_HAVE_NO_MEMORY(info);
4820                 result = fill_spoolss_DriverFileInfo(info,
4821                                                      &info[count],
4822                                                      cservername,
4823                                                      driver->data_file,
4824                                                      SPOOLSS_DRIVER_FILE_TYPE_DATA,
4825                                                      0);
4826                 W_ERROR_NOT_OK_RETURN(result);
4827                 count++;
4828         }
4829
4830         if (strlen(driver->help_file)) {
4831                 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4832                                             struct spoolss_DriverFileInfo,
4833                                             count + 1);
4834                 W_ERROR_HAVE_NO_MEMORY(info);
4835                 result = fill_spoolss_DriverFileInfo(info,
4836                                                      &info[count],
4837                                                      cservername,
4838                                                      driver->help_file,
4839                                                      SPOOLSS_DRIVER_FILE_TYPE_HELP,
4840                                                      0);
4841                 W_ERROR_NOT_OK_RETURN(result);
4842                 count++;
4843         }
4844
4845         for (i=0; driver->dependent_files[i] && driver->dependent_files[i][0] != '\0'; i++) {
4846                 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4847                                             struct spoolss_DriverFileInfo,
4848                                             count + 1);
4849                 W_ERROR_HAVE_NO_MEMORY(info);
4850                 result = fill_spoolss_DriverFileInfo(info,
4851                                                      &info[count],
4852                                                      cservername,
4853                                                      driver->dependent_files[i],
4854                                                      SPOOLSS_DRIVER_FILE_TYPE_OTHER,
4855                                                      0);
4856                 W_ERROR_NOT_OK_RETURN(result);
4857                 count++;
4858         }
4859
4860         *info_p = info;
4861         *count_p = count;
4862
4863         return WERR_OK;
4864 }
4865
4866 /********************************************************************
4867  * fill a spoolss_DriverInfo101 sttruct
4868  ********************************************************************/
4869
4870 static WERROR fill_printer_driver_info101(TALLOC_CTX *mem_ctx,
4871                                           struct spoolss_DriverInfo101 *r,
4872                                           const struct spoolss_DriverInfo8 *driver,
4873                                           const char *servername)
4874 {
4875         const char *cservername = canon_servername(servername);
4876         WERROR result;
4877
4878         r->version              = driver->version;
4879
4880         r->driver_name          = talloc_strdup(mem_ctx, driver->driver_name);
4881         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4882         r->architecture         = talloc_strdup(mem_ctx, driver->architecture);
4883         W_ERROR_HAVE_NO_MEMORY(r->architecture);
4884
4885         result = spoolss_DriverFileInfo_from_driver(mem_ctx, driver,
4886                                                     cservername,
4887                                                     &r->file_info,
4888                                                     &r->file_count);
4889         if (!W_ERROR_IS_OK(result)) {
4890                 return result;
4891         }
4892
4893         FILL_DRIVER_STRING(mem_ctx,
4894                            driver->monitor_name,
4895                            r->monitor_name);
4896
4897         FILL_DRIVER_STRING(mem_ctx,
4898                            driver->default_datatype,
4899                            r->default_datatype);
4900
4901         r->previous_names = string_array_from_driver_info(mem_ctx,
4902                                                           driver->previous_names,
4903                                                           cservername);
4904         r->driver_date          = driver->driver_date;
4905         r->driver_version       = driver->driver_version;
4906
4907         FILL_DRIVER_STRING(mem_ctx,
4908                            driver->manufacturer_name,
4909                            r->manufacturer_name);
4910         FILL_DRIVER_STRING(mem_ctx,
4911                            driver->manufacturer_url,
4912                            r->manufacturer_url);
4913         FILL_DRIVER_STRING(mem_ctx,
4914                            driver->hardware_id,
4915                            r->hardware_id);
4916         FILL_DRIVER_STRING(mem_ctx,
4917                            driver->provider,
4918                            r->provider);
4919
4920         return WERR_OK;
4921 }
4922
4923 /********************************************************************
4924  * construct_printer_driver_info_1
4925  ********************************************************************/
4926
4927 static WERROR construct_printer_driver_info_1(TALLOC_CTX *mem_ctx,
4928                                               struct spoolss_DriverInfo1 *r,
4929                                               int snum,
4930                                               const char *servername,
4931                                               const char *architecture,
4932                                               uint32_t version)
4933 {
4934         NT_PRINTER_INFO_LEVEL *printer = NULL;
4935         struct spoolss_DriverInfo8 *driver;
4936         WERROR result;
4937
4938         if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, lp_const_servicename(snum))))
4939                 return WERR_INVALID_PRINTER_NAME;
4940
4941         if (!W_ERROR_IS_OK(get_a_printer_driver(mem_ctx, &driver, printer->info_2->drivername, architecture, version))) {
4942                 free_a_printer(&printer, 2);
4943                 return WERR_UNKNOWN_PRINTER_DRIVER;
4944         }
4945
4946         result = fill_printer_driver_info1(mem_ctx, r, driver, servername, architecture);
4947
4948         free_a_printer_driver(driver);
4949         free_a_printer(&printer,2);
4950
4951         return result;
4952 }
4953
4954 /********************************************************************
4955  * construct_printer_driver_info_2
4956  * fill a printer_info_2 struct
4957  ********************************************************************/
4958
4959 static WERROR construct_printer_driver_info_2(TALLOC_CTX *mem_ctx,
4960                                               struct spoolss_DriverInfo2 *r,
4961                                               int snum,
4962                                               const char *servername,
4963                                               const char *architecture,
4964                                               uint32_t version)
4965 {
4966         NT_PRINTER_INFO_LEVEL *printer = NULL;
4967         struct spoolss_DriverInfo8 *driver;
4968         WERROR result;
4969
4970         ZERO_STRUCT(printer);
4971
4972         if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, lp_const_servicename(snum))))
4973                 return WERR_INVALID_PRINTER_NAME;
4974
4975         if (!W_ERROR_IS_OK(get_a_printer_driver(mem_ctx, &driver, printer->info_2->drivername, architecture, version))) {
4976                 free_a_printer(&printer, 2);
4977                 return WERR_UNKNOWN_PRINTER_DRIVER;
4978         }
4979
4980         result = fill_printer_driver_info2(mem_ctx, r, driver, servername);
4981
4982         free_a_printer_driver(driver);
4983         free_a_printer(&printer,2);
4984
4985         return result;
4986 }
4987
4988 /********************************************************************
4989  * construct_printer_info_3
4990  * fill a printer_info_3 struct
4991  ********************************************************************/
4992
4993 static WERROR construct_printer_driver_info_3(TALLOC_CTX *mem_ctx,
4994                                               struct spoolss_DriverInfo3 *r,
4995                                               int snum,
4996                                               const char *servername,
4997                                               const char *architecture,
4998                                               uint32_t version)
4999 {
5000         NT_PRINTER_INFO_LEVEL *printer = NULL;
5001         struct spoolss_DriverInfo8 *driver;
5002         WERROR status;
5003         ZERO_STRUCT(driver);
5004
5005         status=get_a_printer(NULL, &printer, 2, lp_const_servicename(snum) );
5006         DEBUG(8,("construct_printer_driver_info_3: status: %s\n", win_errstr(status)));
5007         if (!W_ERROR_IS_OK(status))
5008                 return WERR_INVALID_PRINTER_NAME;
5009
5010         status = get_a_printer_driver(mem_ctx, &driver, printer->info_2->drivername, architecture, version);
5011         DEBUG(8,("construct_printer_driver_info_3: status: %s\n", win_errstr(status)));
5012
5013 #if 0   /* JERRY */
5014
5015         /*
5016          * I put this code in during testing.  Helpful when commenting out the
5017          * support for DRIVER_INFO_6 in regards to win2k.  Not needed in general
5018          * as win2k always queries the driver using an infor level of 6.
5019          * I've left it in (but ifdef'd out) because I'll probably
5020          * use it in experimentation again in the future.   --jerry 22/01/2002
5021          */
5022
5023         if (!W_ERROR_IS_OK(status)) {
5024                 /*
5025                  * Is this a W2k client ?
5026                  */
5027                 if (version == 3) {
5028                         /* Yes - try again with a WinNT driver. */
5029                         version = 2;
5030                         status=get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
5031                         DEBUG(8,("construct_printer_driver_info_3: status: %s\n", win_errstr(status)));
5032                 }
5033 #endif
5034
5035                 if (!W_ERROR_IS_OK(status)) {
5036                         free_a_printer(&printer,2);
5037                         return WERR_UNKNOWN_PRINTER_DRIVER;
5038                 }
5039
5040 #if 0   /* JERRY */
5041         }
5042 #endif
5043
5044
5045         status = fill_printer_driver_info3(mem_ctx, r, driver, servername);
5046
5047         free_a_printer_driver(driver);
5048         free_a_printer(&printer,2);
5049
5050         return status;
5051 }
5052
5053 /********************************************************************
5054  * construct_printer_info_6
5055  * fill a printer_info_6 struct
5056  ********************************************************************/
5057
5058 static WERROR construct_printer_driver_info_6(TALLOC_CTX *mem_ctx,
5059                                               struct spoolss_DriverInfo6 *r,
5060                                               int snum,
5061                                               const char *servername,
5062                                               const char *architecture,
5063                                               uint32_t version)
5064 {
5065         NT_PRINTER_INFO_LEVEL           *printer = NULL;
5066         struct spoolss_DriverInfo8 *driver;
5067         WERROR                          status;
5068
5069         status=get_a_printer(NULL, &printer, 2, lp_const_servicename(snum) );
5070
5071         DEBUG(8,("construct_printer_driver_info_6: status: %s\n", win_errstr(status)));
5072
5073         if (!W_ERROR_IS_OK(status))
5074                 return WERR_INVALID_PRINTER_NAME;
5075
5076         status = get_a_printer_driver(mem_ctx, &driver, printer->info_2->drivername, architecture, version);
5077
5078         DEBUG(8,("construct_printer_driver_info_6: status: %s\n", win_errstr(status)));
5079
5080         if (!W_ERROR_IS_OK(status))
5081         {
5082                 /*
5083                  * Is this a W2k client ?
5084                  */
5085
5086                 if (version < 3) {
5087                         free_a_printer(&printer,2);
5088                         return WERR_UNKNOWN_PRINTER_DRIVER;
5089                 }
5090
5091                 /* Yes - try again with a WinNT driver. */
5092                 version = 2;
5093                 status = get_a_printer_driver(mem_ctx, &driver, printer->info_2->drivername, architecture, version);
5094                 DEBUG(8,("construct_printer_driver_info_6: status: %s\n", win_errstr(status)));
5095                 if (!W_ERROR_IS_OK(status)) {
5096                         free_a_printer(&printer,2);
5097                         return WERR_UNKNOWN_PRINTER_DRIVER;
5098                 }
5099         }
5100
5101         status = fill_printer_driver_info6(mem_ctx, r, driver, servername);
5102
5103         free_a_printer(&printer,2);
5104         free_a_printer_driver(driver);
5105
5106         return status;
5107 }
5108
5109 /********************************************************************
5110  * construct_printer_info_101
5111  * fill a printer_info_101 struct
5112  ********************************************************************/
5113
5114 static WERROR construct_printer_driver_info_101(TALLOC_CTX *mem_ctx,
5115                                                 struct spoolss_DriverInfo101 *r,
5116                                                 int snum,
5117                                                 const char *servername,
5118                                                 const char *architecture,
5119                                                 uint32_t version)
5120 {
5121         NT_PRINTER_INFO_LEVEL           *printer = NULL;
5122         struct spoolss_DriverInfo8 *driver;
5123         WERROR                          result;
5124
5125         result = get_a_printer(NULL, &printer, 2, lp_const_servicename(snum));
5126
5127         DEBUG(8,("construct_printer_driver_info_101: status: %s\n",
5128                 win_errstr(result)));
5129
5130         if (!W_ERROR_IS_OK(result)) {
5131                 return WERR_INVALID_PRINTER_NAME;
5132         }
5133
5134         result = get_a_printer_driver(mem_ctx, &driver, printer->info_2->drivername,
5135                                       architecture, version);
5136
5137         DEBUG(8,("construct_printer_driver_info_101: status: %s\n",
5138                 win_errstr(result)));
5139
5140         if (!W_ERROR_IS_OK(result)) {
5141                 /*
5142                  * Is this a W2k client ?
5143                  */
5144
5145                 if (version < 3) {
5146                         free_a_printer(&printer, 2);
5147                         return WERR_UNKNOWN_PRINTER_DRIVER;
5148                 }
5149
5150                 /* Yes - try again with a WinNT driver. */
5151                 version = 2;
5152                 result = get_a_printer_driver(mem_ctx, &driver, printer->info_2->drivername,
5153                                               architecture, version);
5154                 DEBUG(8,("construct_printer_driver_info_6: status: %s\n",
5155                         win_errstr(result)));
5156                 if (!W_ERROR_IS_OK(result)) {
5157                         free_a_printer(&printer, 2);
5158                         return WERR_UNKNOWN_PRINTER_DRIVER;
5159                 }
5160         }
5161
5162         result = fill_printer_driver_info101(mem_ctx, r, driver, servername);
5163
5164         free_a_printer(&printer, 2);
5165         free_a_printer_driver(driver);
5166
5167         return result;
5168 }
5169
5170 /****************************************************************
5171  _spoolss_GetPrinterDriver2
5172 ****************************************************************/
5173
5174 WERROR _spoolss_GetPrinterDriver2(pipes_struct *p,
5175                                   struct spoolss_GetPrinterDriver2 *r)
5176 {
5177         Printer_entry *printer;
5178         WERROR result;
5179
5180         const char *servername;
5181         int snum;
5182
5183         /* that's an [in out] buffer */
5184
5185         if (!r->in.buffer && (r->in.offered != 0)) {
5186                 return WERR_INVALID_PARAM;
5187         }
5188
5189         DEBUG(4,("_spoolss_GetPrinterDriver2\n"));
5190
5191         if (!(printer = find_printer_index_by_hnd(p, r->in.handle))) {
5192                 DEBUG(0,("_spoolss_GetPrinterDriver2: invalid printer handle!\n"));
5193                 return WERR_INVALID_PRINTER_NAME;
5194         }
5195
5196         *r->out.needed = 0;
5197         *r->out.server_major_version = 0;
5198         *r->out.server_minor_version = 0;
5199
5200         servername = get_server_name(printer);
5201
5202         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5203                 return WERR_BADFID;
5204         }
5205
5206         switch (r->in.level) {
5207         case 1:
5208                 result = construct_printer_driver_info_1(p->mem_ctx,
5209                                                          &r->out.info->info1,
5210                                                          snum,
5211                                                          servername,
5212                                                          r->in.architecture,
5213                                                          r->in.client_major_version);
5214                 break;
5215         case 2:
5216                 result = construct_printer_driver_info_2(p->mem_ctx,
5217                                                          &r->out.info->info2,
5218                                                          snum,
5219                                                          servername,
5220                                                          r->in.architecture,
5221                                                          r->in.client_major_version);
5222                 break;
5223         case 3:
5224                 result = construct_printer_driver_info_3(p->mem_ctx,
5225                                                          &r->out.info->info3,
5226                                                          snum,
5227                                                          servername,
5228                                                          r->in.architecture,
5229                                                          r->in.client_major_version);
5230                 break;
5231         case 6:
5232                 result = construct_printer_driver_info_6(p->mem_ctx,
5233                                                          &r->out.info->info6,
5234                                                          snum,
5235                                                          servername,
5236                                                          r->in.architecture,
5237                                                          r->in.client_major_version);
5238                 break;
5239         case 101:
5240                 result = construct_printer_driver_info_101(p->mem_ctx,
5241                                                            &r->out.info->info101,
5242                                                            snum,
5243                                                            servername,
5244                                                            r->in.architecture,
5245                                                            r->in.client_major_version);
5246                 break;
5247         default:
5248                 result = WERR_UNKNOWN_LEVEL;
5249                 break;
5250         }
5251
5252         if (!W_ERROR_IS_OK(result)) {
5253                 TALLOC_FREE(r->out.info);
5254                 return result;
5255         }
5256
5257         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_DriverInfo, NULL,
5258                                                r->out.info, r->in.level);
5259         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
5260
5261         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
5262 }
5263
5264
5265 /****************************************************************
5266  _spoolss_StartPagePrinter
5267 ****************************************************************/
5268
5269 WERROR _spoolss_StartPagePrinter(pipes_struct *p,
5270                                  struct spoolss_StartPagePrinter *r)
5271 {
5272         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5273
5274         if (!Printer) {
5275                 DEBUG(3,("_spoolss_StartPagePrinter: "
5276                         "Error in startpageprinter printer handle\n"));
5277                 return WERR_BADFID;
5278         }
5279
5280         Printer->page_started = true;
5281         return WERR_OK;
5282 }
5283
5284 /****************************************************************
5285  _spoolss_EndPagePrinter
5286 ****************************************************************/
5287
5288 WERROR _spoolss_EndPagePrinter(pipes_struct *p,
5289                                struct spoolss_EndPagePrinter *r)
5290 {
5291         int snum;
5292
5293         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5294
5295         if (!Printer) {
5296                 DEBUG(2,("_spoolss_EndPagePrinter: Invalid handle (%s:%u:%u).\n",
5297                         OUR_HANDLE(r->in.handle)));
5298                 return WERR_BADFID;
5299         }
5300
5301         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5302                 return WERR_BADFID;
5303
5304         Printer->page_started = false;
5305         print_job_endpage(snum, Printer->jobid);
5306
5307         return WERR_OK;
5308 }
5309
5310 /****************************************************************
5311  _spoolss_StartDocPrinter
5312 ****************************************************************/
5313
5314 WERROR _spoolss_StartDocPrinter(pipes_struct *p,
5315                                 struct spoolss_StartDocPrinter *r)
5316 {
5317         struct spoolss_DocumentInfo1 *info_1;
5318         int snum;
5319         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5320
5321         if (!Printer) {
5322                 DEBUG(2,("_spoolss_StartDocPrinter: "
5323                         "Invalid handle (%s:%u:%u)\n",
5324                         OUR_HANDLE(r->in.handle)));
5325                 return WERR_BADFID;
5326         }
5327
5328         if (r->in.level != 1) {
5329                 return WERR_UNKNOWN_LEVEL;
5330         }
5331
5332         info_1 = r->in.info.info1;
5333
5334         /*
5335          * a nice thing with NT is it doesn't listen to what you tell it.
5336          * when asked to send _only_ RAW datas, it tries to send datas
5337          * in EMF format.
5338          *
5339          * So I add checks like in NT Server ...
5340          */
5341
5342         if (info_1->datatype) {
5343                 if (strcmp(info_1->datatype, "RAW") != 0) {
5344                         *r->out.job_id = 0;
5345                         return WERR_INVALID_DATATYPE;
5346                 }
5347         }
5348
5349         /* get the share number of the printer */
5350         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5351                 return WERR_BADFID;
5352         }
5353
5354         Printer->jobid = print_job_start(p->server_info, snum,
5355                                          info_1->document_name,
5356                                          Printer->nt_devmode);
5357
5358         /* An error occured in print_job_start() so return an appropriate
5359            NT error code. */
5360
5361         if (Printer->jobid == -1) {
5362                 return map_werror_from_unix(errno);
5363         }
5364
5365         Printer->document_started = true;
5366         *r->out.job_id = Printer->jobid;
5367
5368         return WERR_OK;
5369 }
5370
5371 /****************************************************************
5372  _spoolss_EndDocPrinter
5373 ****************************************************************/
5374
5375 WERROR _spoolss_EndDocPrinter(pipes_struct *p,
5376                               struct spoolss_EndDocPrinter *r)
5377 {
5378         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5379         int snum;
5380
5381         if (!Printer) {
5382                 DEBUG(2,("_spoolss_EndDocPrinter: Invalid handle (%s:%u:%u)\n",
5383                         OUR_HANDLE(r->in.handle)));
5384                 return WERR_BADFID;
5385         }
5386
5387         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5388                 return WERR_BADFID;
5389         }
5390
5391         Printer->document_started = false;
5392         print_job_end(snum, Printer->jobid, NORMAL_CLOSE);
5393         /* error codes unhandled so far ... */
5394
5395         return WERR_OK;
5396 }
5397
5398 /****************************************************************
5399  _spoolss_WritePrinter
5400 ****************************************************************/
5401
5402 WERROR _spoolss_WritePrinter(pipes_struct *p,
5403                              struct spoolss_WritePrinter *r)
5404 {
5405         uint32_t buffer_written;
5406         int snum;
5407         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5408
5409         if (!Printer) {
5410                 DEBUG(2,("_spoolss_WritePrinter: Invalid handle (%s:%u:%u)\n",
5411                         OUR_HANDLE(r->in.handle)));
5412                 *r->out.num_written = r->in._data_size;
5413                 return WERR_BADFID;
5414         }
5415
5416         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5417                 return WERR_BADFID;
5418
5419         buffer_written = (uint32_t)print_job_write(snum, Printer->jobid,
5420                                                    (const char *)r->in.data.data,
5421                                                    (SMB_OFF_T)-1,
5422                                                    (size_t)r->in._data_size);
5423         if (buffer_written == (uint32_t)-1) {
5424                 *r->out.num_written = 0;
5425                 if (errno == ENOSPC)
5426                         return WERR_NO_SPOOL_SPACE;
5427                 else
5428                         return WERR_ACCESS_DENIED;
5429         }
5430
5431         *r->out.num_written = r->in._data_size;
5432
5433         return WERR_OK;
5434 }
5435
5436 /********************************************************************
5437  * api_spoolss_getprinter
5438  * called from the spoolss dispatcher
5439  *
5440  ********************************************************************/
5441
5442 static WERROR control_printer(struct policy_handle *handle, uint32_t command,
5443                               pipes_struct *p)
5444 {
5445         int snum;
5446         WERROR errcode = WERR_BADFUNC;
5447         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5448
5449         if (!Printer) {
5450                 DEBUG(2,("control_printer: Invalid handle (%s:%u:%u)\n",
5451                         OUR_HANDLE(handle)));
5452                 return WERR_BADFID;
5453         }
5454
5455         if (!get_printer_snum(p, handle, &snum, NULL))
5456                 return WERR_BADFID;
5457
5458         switch (command) {
5459         case SPOOLSS_PRINTER_CONTROL_PAUSE:
5460                 errcode = print_queue_pause(p->server_info, snum);
5461                 break;
5462         case SPOOLSS_PRINTER_CONTROL_RESUME:
5463         case SPOOLSS_PRINTER_CONTROL_UNPAUSE:
5464                 errcode = print_queue_resume(p->server_info, snum);
5465                 break;
5466         case SPOOLSS_PRINTER_CONTROL_PURGE:
5467                 errcode = print_queue_purge(p->server_info, snum);
5468                 break;
5469         default:
5470                 return WERR_UNKNOWN_LEVEL;
5471         }
5472
5473         return errcode;
5474 }
5475
5476
5477 /****************************************************************
5478  _spoolss_AbortPrinter
5479  * From MSDN: "Deletes printer's spool file if printer is configured
5480  * for spooling"
5481 ****************************************************************/
5482
5483 WERROR _spoolss_AbortPrinter(pipes_struct *p,
5484                              struct spoolss_AbortPrinter *r)
5485 {
5486         Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
5487         int             snum;
5488         WERROR          errcode = WERR_OK;
5489
5490         if (!Printer) {
5491                 DEBUG(2,("_spoolss_AbortPrinter: Invalid handle (%s:%u:%u)\n",
5492                         OUR_HANDLE(r->in.handle)));
5493                 return WERR_BADFID;
5494         }
5495
5496         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5497                 return WERR_BADFID;
5498
5499         print_job_delete(p->server_info, snum, Printer->jobid, &errcode );
5500
5501         return errcode;
5502 }
5503
5504 /********************************************************************
5505  * called by spoolss_api_setprinter
5506  * when updating a printer description
5507  ********************************************************************/
5508
5509 static WERROR update_printer_sec(struct policy_handle *handle,
5510                                  pipes_struct *p, SEC_DESC_BUF *secdesc_ctr)
5511 {
5512         SEC_DESC_BUF *new_secdesc_ctr = NULL, *old_secdesc_ctr = NULL;
5513         WERROR result;
5514         int snum;
5515
5516         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5517
5518         if (!Printer || !get_printer_snum(p, handle, &snum, NULL)) {
5519                 DEBUG(2,("update_printer_sec: Invalid handle (%s:%u:%u)\n",
5520                          OUR_HANDLE(handle)));
5521
5522                 result = WERR_BADFID;
5523                 goto done;
5524         }
5525
5526         if (!secdesc_ctr) {
5527                 DEBUG(10,("update_printer_sec: secdesc_ctr is NULL !\n"));
5528                 result = WERR_INVALID_PARAM;
5529                 goto done;
5530         }
5531
5532         /* Check the user has permissions to change the security
5533            descriptor.  By experimentation with two NT machines, the user
5534            requires Full Access to the printer to change security
5535            information. */
5536
5537         if ( Printer->access_granted != PRINTER_ACCESS_ADMINISTER ) {
5538                 DEBUG(4,("update_printer_sec: updated denied by printer permissions\n"));
5539                 result = WERR_ACCESS_DENIED;
5540                 goto done;
5541         }
5542
5543         /* NT seems to like setting the security descriptor even though
5544            nothing may have actually changed. */
5545
5546         if ( !nt_printing_getsec(p->mem_ctx, Printer->sharename, &old_secdesc_ctr)) {
5547                 DEBUG(2,("update_printer_sec: nt_printing_getsec() failed\n"));
5548                 result = WERR_BADFID;
5549                 goto done;
5550         }
5551
5552         if (DEBUGLEVEL >= 10) {
5553                 SEC_ACL *the_acl;
5554                 int i;
5555
5556                 the_acl = old_secdesc_ctr->sd->dacl;
5557                 DEBUG(10, ("old_secdesc_ctr for %s has %d aces:\n",
5558                            PRINTERNAME(snum), the_acl->num_aces));
5559
5560                 for (i = 0; i < the_acl->num_aces; i++) {
5561                         DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
5562                                            &the_acl->aces[i].trustee),
5563                                   the_acl->aces[i].access_mask));
5564                 }
5565
5566                 the_acl = secdesc_ctr->sd->dacl;
5567
5568                 if (the_acl) {
5569                         DEBUG(10, ("secdesc_ctr for %s has %d aces:\n",
5570                                    PRINTERNAME(snum), the_acl->num_aces));
5571
5572                         for (i = 0; i < the_acl->num_aces; i++) {
5573                                 DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
5574                                                    &the_acl->aces[i].trustee),
5575                                            the_acl->aces[i].access_mask));
5576                         }
5577                 } else {
5578                         DEBUG(10, ("dacl for secdesc_ctr is NULL\n"));
5579                 }
5580         }
5581
5582         new_secdesc_ctr = sec_desc_merge(p->mem_ctx, secdesc_ctr, old_secdesc_ctr);
5583         if (!new_secdesc_ctr) {
5584                 result = WERR_NOMEM;
5585                 goto done;
5586         }
5587
5588         if (security_descriptor_equal(new_secdesc_ctr->sd, old_secdesc_ctr->sd)) {
5589                 result = WERR_OK;
5590                 goto done;
5591         }
5592
5593         result = nt_printing_setsec(Printer->sharename, new_secdesc_ctr);
5594
5595  done:
5596
5597         return result;
5598 }
5599
5600 /********************************************************************
5601  Canonicalize printer info from a client
5602
5603  ATTN: It does not matter what we set the servername to hear
5604  since we do the necessary work in get_a_printer() to set it to
5605  the correct value based on what the client sent in the
5606  _spoolss_open_printer_ex().
5607  ********************************************************************/
5608
5609 static bool check_printer_ok(NT_PRINTER_INFO_LEVEL_2 *info, int snum)
5610 {
5611         fstring printername;
5612         const char *p;
5613
5614         DEBUG(5,("check_printer_ok: servername=%s printername=%s sharename=%s "
5615                 "portname=%s drivername=%s comment=%s location=%s\n",
5616                 info->servername, info->printername, info->sharename,
5617                 info->portname, info->drivername, info->comment, info->location));
5618
5619         /* we force some elements to "correct" values */
5620         slprintf(info->servername, sizeof(info->servername)-1, "\\\\%s", global_myname());
5621         fstrcpy(info->sharename, lp_servicename(snum));
5622
5623         /* check to see if we allow printername != sharename */
5624
5625         if ( lp_force_printername(snum) ) {
5626                 slprintf(info->printername, sizeof(info->printername)-1, "\\\\%s\\%s",
5627                         global_myname(), info->sharename );
5628         } else {
5629
5630                 /* make sure printername is in \\server\printername format */
5631
5632                 fstrcpy( printername, info->printername );
5633                 p = printername;
5634                 if ( printername[0] == '\\' && printername[1] == '\\' ) {
5635                         if ( (p = strchr_m( &printername[2], '\\' )) != NULL )
5636                                 p++;
5637                 }
5638
5639                 slprintf(info->printername, sizeof(info->printername)-1, "\\\\%s\\%s",
5640                          global_myname(), p );
5641         }
5642
5643         info->attributes |= PRINTER_ATTRIBUTE_SAMBA;
5644         info->attributes &= ~PRINTER_ATTRIBUTE_NOT_SAMBA;
5645
5646
5647
5648         return true;
5649 }
5650
5651 /****************************************************************************
5652 ****************************************************************************/
5653
5654 static WERROR add_port_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, const char *portname, const char *uri)
5655 {
5656         char *cmd = lp_addport_cmd();
5657         char *command = NULL;
5658         int ret;
5659         SE_PRIV se_printop = SE_PRINT_OPERATOR;
5660         bool is_print_op = false;
5661
5662         if ( !*cmd ) {
5663                 return WERR_ACCESS_DENIED;
5664         }
5665
5666         command = talloc_asprintf(ctx,
5667                         "%s \"%s\" \"%s\"", cmd, portname, uri );
5668         if (!command) {
5669                 return WERR_NOMEM;
5670         }
5671
5672         if ( token )
5673                 is_print_op = user_has_privileges( token, &se_printop );
5674
5675         DEBUG(10,("Running [%s]\n", command));
5676
5677         /********* BEGIN SePrintOperatorPrivilege **********/
5678
5679         if ( is_print_op )
5680                 become_root();
5681
5682         ret = smbrun(command, NULL);
5683
5684         if ( is_print_op )
5685                 unbecome_root();
5686
5687         /********* END SePrintOperatorPrivilege **********/
5688
5689         DEBUGADD(10,("returned [%d]\n", ret));
5690
5691         TALLOC_FREE(command);
5692
5693         if ( ret != 0 ) {
5694                 return WERR_ACCESS_DENIED;
5695         }
5696
5697         return WERR_OK;
5698 }
5699
5700 /****************************************************************************
5701 ****************************************************************************/
5702
5703 bool add_printer_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, NT_PRINTER_INFO_LEVEL *printer)
5704 {
5705         char *cmd = lp_addprinter_cmd();
5706         char **qlines;
5707         char *command = NULL;
5708         int numlines;
5709         int ret;
5710         int fd;
5711         SE_PRIV se_printop = SE_PRINT_OPERATOR;
5712         bool is_print_op = false;
5713         char *remote_machine = talloc_strdup(ctx, "%m");
5714
5715         if (!remote_machine) {
5716                 return false;
5717         }
5718         remote_machine = talloc_sub_basic(ctx,
5719                                 current_user_info.smb_name,
5720                                 current_user_info.domain,
5721                                 remote_machine);
5722         if (!remote_machine) {
5723                 return false;
5724         }
5725
5726         command = talloc_asprintf(ctx,
5727                         "%s \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"",
5728                         cmd, printer->info_2->printername, printer->info_2->sharename,
5729                         printer->info_2->portname, printer->info_2->drivername,
5730                         printer->info_2->location, printer->info_2->comment, remote_machine);
5731         if (!command) {
5732                 return false;
5733         }
5734
5735         if ( token )
5736                 is_print_op = user_has_privileges( token, &se_printop );
5737
5738         DEBUG(10,("Running [%s]\n", command));
5739
5740         /********* BEGIN SePrintOperatorPrivilege **********/
5741
5742         if ( is_print_op )
5743                 become_root();
5744
5745         if ( (ret = smbrun(command, &fd)) == 0 ) {
5746                 /* Tell everyone we updated smb.conf. */
5747                 message_send_all(smbd_messaging_context(),
5748                                  MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
5749         }
5750
5751         if ( is_print_op )
5752                 unbecome_root();
5753
5754         /********* END SePrintOperatorPrivilege **********/
5755
5756         DEBUGADD(10,("returned [%d]\n", ret));
5757
5758         TALLOC_FREE(command);
5759         TALLOC_FREE(remote_machine);
5760
5761         if ( ret != 0 ) {
5762                 if (fd != -1)
5763                         close(fd);
5764                 return false;
5765         }
5766
5767         /* reload our services immediately */
5768         become_root();
5769         reload_services(false);
5770         unbecome_root();
5771
5772         numlines = 0;
5773         /* Get lines and convert them back to dos-codepage */
5774         qlines = fd_lines_load(fd, &numlines, 0, NULL);
5775         DEBUGADD(10,("Lines returned = [%d]\n", numlines));
5776         close(fd);
5777
5778         /* Set the portname to what the script says the portname should be. */
5779         /* but don't require anything to be return from the script exit a good error code */
5780
5781         if (numlines) {
5782                 /* Set the portname to what the script says the portname should be. */
5783                 strncpy(printer->info_2->portname, qlines[0], sizeof(printer->info_2->portname));
5784                 DEBUGADD(6,("Line[0] = [%s]\n", qlines[0]));
5785         }
5786
5787         TALLOC_FREE(qlines);
5788         return true;
5789 }
5790
5791
5792 /********************************************************************
5793  * Called by spoolss_api_setprinter
5794  * when updating a printer description.
5795  ********************************************************************/
5796
5797 static WERROR update_printer(pipes_struct *p, struct policy_handle *handle,
5798                              struct spoolss_SetPrinterInfoCtr *info_ctr,
5799                              struct spoolss_DeviceMode *devmode)
5800 {
5801         int snum;
5802         NT_PRINTER_INFO_LEVEL *printer = NULL, *old_printer = NULL;
5803         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5804         WERROR result;
5805         DATA_BLOB buffer;
5806         fstring asc_buffer;
5807
5808         DEBUG(8,("update_printer\n"));
5809
5810         result = WERR_OK;
5811
5812         if (!Printer) {
5813                 result = WERR_BADFID;
5814                 goto done;
5815         }
5816
5817         if (!get_printer_snum(p, handle, &snum, NULL)) {
5818                 result = WERR_BADFID;
5819                 goto done;
5820         }
5821
5822         if (!W_ERROR_IS_OK(get_a_printer(Printer, &printer, 2, lp_const_servicename(snum))) ||
5823             (!W_ERROR_IS_OK(get_a_printer(Printer, &old_printer, 2, lp_const_servicename(snum))))) {
5824                 result = WERR_BADFID;
5825                 goto done;
5826         }
5827
5828         DEBUGADD(8,("Converting info_2 struct\n"));
5829
5830         /*
5831          * convert_printer_info converts the incoming
5832          * info from the client and overwrites the info
5833          * just read from the tdb in the pointer 'printer'.
5834          */
5835
5836         if (!convert_printer_info(info_ctr, printer)) {
5837                 result =  WERR_NOMEM;
5838                 goto done;
5839         }
5840
5841         if (devmode) {
5842                 /* we have a valid devmode
5843                    convert it and link it*/
5844
5845                 DEBUGADD(8,("update_printer: Converting the devicemode struct\n"));
5846                 if (!convert_devicemode(printer->info_2->printername, devmode,
5847                                         &printer->info_2->devmode)) {
5848                         result =  WERR_NOMEM;
5849                         goto done;
5850                 }
5851         }
5852
5853         /* Do sanity check on the requested changes for Samba */
5854
5855         if (!check_printer_ok(printer->info_2, snum)) {
5856                 result = WERR_INVALID_PARAM;
5857                 goto done;
5858         }
5859
5860         /* FIXME!!! If the driver has changed we really should verify that
5861            it is installed before doing much else   --jerry */
5862
5863         /* Check calling user has permission to update printer description */
5864
5865         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
5866                 DEBUG(3, ("update_printer: printer property change denied by handle\n"));
5867                 result = WERR_ACCESS_DENIED;
5868                 goto done;
5869         }
5870
5871         /* Call addprinter hook */
5872         /* Check changes to see if this is really needed */
5873
5874         if ( *lp_addprinter_cmd()
5875                 && (!strequal(printer->info_2->drivername, old_printer->info_2->drivername)
5876                         || !strequal(printer->info_2->comment, old_printer->info_2->comment)
5877                         || !strequal(printer->info_2->portname, old_printer->info_2->portname)
5878                         || !strequal(printer->info_2->location, old_printer->info_2->location)) )
5879         {
5880                 /* add_printer_hook() will call reload_services() */
5881
5882                 if ( !add_printer_hook(p->mem_ctx, p->server_info->ptok,
5883                                        printer) ) {
5884                         result = WERR_ACCESS_DENIED;
5885                         goto done;
5886                 }
5887         }
5888
5889         /*
5890          * When a *new* driver is bound to a printer, the drivername is used to
5891          * lookup previously saved driver initialization info, which is then
5892          * bound to the printer, simulating what happens in the Windows arch.
5893          */
5894         if (!strequal(printer->info_2->drivername, old_printer->info_2->drivername))
5895         {
5896                 if (!set_driver_init(printer, 2))
5897                 {
5898                         DEBUG(5,("update_printer: Error restoring driver initialization data for driver [%s]!\n",
5899                                 printer->info_2->drivername));
5900                 }
5901
5902                 DEBUG(10,("update_printer: changing driver [%s]!  Sending event!\n",
5903                         printer->info_2->drivername));
5904
5905                 notify_printer_driver(snum, printer->info_2->drivername);
5906         }
5907
5908         /*
5909          * flag which changes actually occured.  This is a small subset of
5910          * all the possible changes.  We also have to update things in the
5911          * DsSpooler key.
5912          */
5913
5914         if (!strequal(printer->info_2->comment, old_printer->info_2->comment)) {
5915                 push_reg_sz(talloc_tos(), &buffer, printer->info_2->comment);
5916                 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "description",
5917                         REG_SZ, buffer.data, buffer.length);
5918
5919                 notify_printer_comment(snum, printer->info_2->comment);
5920         }
5921
5922         if (!strequal(printer->info_2->sharename, old_printer->info_2->sharename)) {
5923                 push_reg_sz(talloc_tos(), &buffer, printer->info_2->sharename);
5924                 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "shareName",
5925                         REG_SZ, buffer.data, buffer.length);
5926
5927                 notify_printer_sharename(snum, printer->info_2->sharename);
5928         }
5929
5930         if (!strequal(printer->info_2->printername, old_printer->info_2->printername)) {
5931                 char *pname;
5932
5933                 if ( (pname = strchr_m( printer->info_2->printername+2, '\\' )) != NULL )
5934                         pname++;
5935                 else
5936                         pname = printer->info_2->printername;
5937
5938
5939                 push_reg_sz(talloc_tos(), &buffer, pname);
5940                 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "printerName",
5941                         REG_SZ, buffer.data, buffer.length);
5942
5943                 notify_printer_printername( snum, pname );
5944         }
5945
5946         if (!strequal(printer->info_2->portname, old_printer->info_2->portname)) {
5947                 push_reg_sz(talloc_tos(), &buffer, printer->info_2->portname);
5948                 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "portName",
5949                         REG_SZ, buffer.data, buffer.length);
5950
5951                 notify_printer_port(snum, printer->info_2->portname);
5952         }
5953
5954         if (!strequal(printer->info_2->location, old_printer->info_2->location)) {
5955                 push_reg_sz(talloc_tos(), &buffer, printer->info_2->location);
5956                 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "location",
5957                         REG_SZ, buffer.data, buffer.length);
5958
5959                 notify_printer_location(snum, printer->info_2->location);
5960         }
5961
5962         /* here we need to update some more DsSpooler keys */
5963         /* uNCName, serverName, shortServerName */
5964
5965         push_reg_sz(talloc_tos(), &buffer, global_myname());
5966         set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "serverName",
5967                 REG_SZ, buffer.data, buffer.length);
5968         set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "shortServerName",
5969                 REG_SZ, buffer.data, buffer.length);
5970
5971         slprintf( asc_buffer, sizeof(asc_buffer)-1, "\\\\%s\\%s",
5972                  global_myname(), printer->info_2->sharename );
5973         push_reg_sz(talloc_tos(), &buffer, asc_buffer);
5974         set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "uNCName",
5975                 REG_SZ, buffer.data, buffer.length);
5976
5977         /* Update printer info */
5978         result = mod_a_printer(printer, 2);
5979
5980 done:
5981         free_a_printer(&printer, 2);
5982         free_a_printer(&old_printer, 2);
5983
5984
5985         return result;
5986 }
5987
5988 /****************************************************************************
5989 ****************************************************************************/
5990 static WERROR publish_or_unpublish_printer(pipes_struct *p,
5991                                            struct policy_handle *handle,
5992                                            struct spoolss_SetPrinterInfo7 *info7)
5993 {
5994 #ifdef HAVE_ADS
5995         int snum;
5996         Printer_entry *Printer;
5997
5998         if ( lp_security() != SEC_ADS ) {
5999                 return WERR_UNKNOWN_LEVEL;
6000         }
6001
6002         Printer = find_printer_index_by_hnd(p, handle);
6003
6004         DEBUG(5,("publish_or_unpublish_printer, action = %d\n",info7->action));
6005
6006         if (!Printer)
6007                 return WERR_BADFID;
6008
6009         if (!get_printer_snum(p, handle, &snum, NULL))
6010                 return WERR_BADFID;
6011
6012         nt_printer_publish(Printer, snum, info7->action);
6013
6014         return WERR_OK;
6015 #else
6016         return WERR_UNKNOWN_LEVEL;
6017 #endif
6018 }
6019
6020 /****************************************************************
6021  _spoolss_SetPrinter
6022 ****************************************************************/
6023
6024 WERROR _spoolss_SetPrinter(pipes_struct *p,
6025                            struct spoolss_SetPrinter *r)
6026 {
6027         WERROR result;
6028
6029         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
6030
6031         if (!Printer) {
6032                 DEBUG(2,("_spoolss_SetPrinter: Invalid handle (%s:%u:%u)\n",
6033                         OUR_HANDLE(r->in.handle)));
6034                 return WERR_BADFID;
6035         }
6036
6037         /* check the level */
6038         switch (r->in.info_ctr->level) {
6039                 case 0:
6040                         return control_printer(r->in.handle, r->in.command, p);
6041                 case 2:
6042                         result = update_printer(p, r->in.handle,
6043                                                 r->in.info_ctr,
6044                                                 r->in.devmode_ctr->devmode);
6045                         if (!W_ERROR_IS_OK(result))
6046                                 return result;
6047                         if (r->in.secdesc_ctr->sd)
6048                                 result = update_printer_sec(r->in.handle, p,
6049                                                             r->in.secdesc_ctr);
6050                         return result;
6051                 case 3:
6052                         return update_printer_sec(r->in.handle, p,
6053                                                   r->in.secdesc_ctr);
6054                 case 7:
6055                         return publish_or_unpublish_printer(p, r->in.handle,
6056                                                             r->in.info_ctr->info.info7);
6057                 default:
6058                         return WERR_UNKNOWN_LEVEL;
6059         }
6060 }
6061
6062 /****************************************************************
6063  _spoolss_FindClosePrinterNotify
6064 ****************************************************************/
6065
6066 WERROR _spoolss_FindClosePrinterNotify(pipes_struct *p,
6067                                        struct spoolss_FindClosePrinterNotify *r)
6068 {
6069         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
6070
6071         if (!Printer) {
6072                 DEBUG(2,("_spoolss_FindClosePrinterNotify: "
6073                         "Invalid handle (%s:%u:%u)\n", OUR_HANDLE(r->in.handle)));
6074                 return WERR_BADFID;
6075         }
6076
6077         if (Printer->notify.client_connected == true) {
6078                 int snum = -1;
6079
6080                 if ( Printer->printer_type == SPLHND_SERVER)
6081                         snum = -1;
6082                 else if ( (Printer->printer_type == SPLHND_PRINTER) &&
6083                                 !get_printer_snum(p, r->in.handle, &snum, NULL) )
6084                         return WERR_BADFID;
6085
6086                 srv_spoolss_replycloseprinter(snum, &Printer->notify.client_hnd);
6087         }
6088
6089         Printer->notify.flags=0;
6090         Printer->notify.options=0;
6091         Printer->notify.localmachine[0]='\0';
6092         Printer->notify.printerlocal=0;
6093         TALLOC_FREE(Printer->notify.option);
6094         Printer->notify.client_connected = false;
6095
6096         return WERR_OK;
6097 }
6098
6099 /****************************************************************
6100  _spoolss_AddJob
6101 ****************************************************************/
6102
6103 WERROR _spoolss_AddJob(pipes_struct *p,
6104                        struct spoolss_AddJob *r)
6105 {
6106         if (!r->in.buffer && (r->in.offered != 0)) {
6107                 return WERR_INVALID_PARAM;
6108         }
6109
6110         /* this is what a NT server returns for AddJob. AddJob must fail on
6111          * non-local printers */
6112
6113         if (r->in.level != 1) {
6114                 return WERR_UNKNOWN_LEVEL;
6115         }
6116
6117         return WERR_INVALID_PARAM;
6118 }
6119
6120 /****************************************************************************
6121 fill_job_info1
6122 ****************************************************************************/
6123
6124 static WERROR fill_job_info1(TALLOC_CTX *mem_ctx,
6125                              struct spoolss_JobInfo1 *r,
6126                              const print_queue_struct *queue,
6127                              int position, int snum,
6128                              const NT_PRINTER_INFO_LEVEL *ntprinter)
6129 {
6130         struct tm *t;
6131
6132         t = gmtime(&queue->time);
6133
6134         r->job_id               = queue->job;
6135
6136         r->printer_name         = talloc_strdup(mem_ctx, lp_servicename(snum));
6137         W_ERROR_HAVE_NO_MEMORY(r->printer_name);
6138         r->server_name          = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
6139         W_ERROR_HAVE_NO_MEMORY(r->server_name);
6140         r->user_name            = talloc_strdup(mem_ctx, queue->fs_user);
6141         W_ERROR_HAVE_NO_MEMORY(r->user_name);
6142         r->document_name        = talloc_strdup(mem_ctx, queue->fs_file);
6143         W_ERROR_HAVE_NO_MEMORY(r->document_name);
6144         r->data_type            = talloc_strdup(mem_ctx, "RAW");
6145         W_ERROR_HAVE_NO_MEMORY(r->data_type);
6146         r->text_status          = talloc_strdup(mem_ctx, "");
6147         W_ERROR_HAVE_NO_MEMORY(r->text_status);
6148
6149         r->status               = nt_printj_status(queue->status);
6150         r->priority             = queue->priority;
6151         r->position             = position;
6152         r->total_pages          = queue->page_count;
6153         r->pages_printed        = 0; /* ??? */
6154
6155         init_systemtime(&r->submitted, t);
6156
6157         return WERR_OK;
6158 }
6159
6160 /****************************************************************************
6161 fill_job_info2
6162 ****************************************************************************/
6163
6164 static WERROR fill_job_info2(TALLOC_CTX *mem_ctx,
6165                              struct spoolss_JobInfo2 *r,
6166                              const print_queue_struct *queue,
6167                              int position, int snum,
6168                              const NT_PRINTER_INFO_LEVEL *ntprinter,
6169                              struct spoolss_DeviceMode *devmode)
6170 {
6171         struct tm *t;
6172
6173         t = gmtime(&queue->time);
6174
6175         r->job_id               = queue->job;
6176
6177         r->printer_name         = talloc_strdup(mem_ctx, lp_servicename(snum));
6178         W_ERROR_HAVE_NO_MEMORY(r->printer_name);
6179         r->server_name          = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
6180         W_ERROR_HAVE_NO_MEMORY(r->server_name);
6181         r->user_name            = talloc_strdup(mem_ctx, queue->fs_user);
6182         W_ERROR_HAVE_NO_MEMORY(r->user_name);
6183         r->document_name        = talloc_strdup(mem_ctx, queue->fs_file);
6184         W_ERROR_HAVE_NO_MEMORY(r->document_name);
6185         r->notify_name          = talloc_strdup(mem_ctx, queue->fs_user);
6186         W_ERROR_HAVE_NO_MEMORY(r->notify_name);
6187         r->data_type            = talloc_strdup(mem_ctx, "RAW");
6188         W_ERROR_HAVE_NO_MEMORY(r->data_type);
6189         r->print_processor      = talloc_strdup(mem_ctx, "winprint");
6190         W_ERROR_HAVE_NO_MEMORY(r->print_processor);
6191         r->parameters           = talloc_strdup(mem_ctx, "");
6192         W_ERROR_HAVE_NO_MEMORY(r->parameters);
6193         r->driver_name          = talloc_strdup(mem_ctx, ntprinter->info_2->drivername);
6194         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
6195
6196         r->devmode              = devmode;
6197
6198         r->text_status          = talloc_strdup(mem_ctx, "");
6199         W_ERROR_HAVE_NO_MEMORY(r->text_status);
6200
6201         r->secdesc              = NULL;
6202
6203         r->status               = nt_printj_status(queue->status);
6204         r->priority             = queue->priority;
6205         r->position             = position;
6206         r->start_time           = 0;
6207         r->until_time           = 0;
6208         r->total_pages          = queue->page_count;
6209         r->size                 = queue->size;
6210         init_systemtime(&r->submitted, t);
6211         r->time                 = 0;
6212         r->pages_printed        = 0; /* ??? */
6213
6214         return WERR_OK;
6215 }
6216
6217 /****************************************************************************
6218  Enumjobs at level 1.
6219 ****************************************************************************/
6220
6221 static WERROR enumjobs_level1(TALLOC_CTX *mem_ctx,
6222                               const print_queue_struct *queue,
6223                               uint32_t num_queues, int snum,
6224                               const NT_PRINTER_INFO_LEVEL *ntprinter,
6225                               union spoolss_JobInfo **info_p,
6226                               uint32_t *count)
6227 {
6228         union spoolss_JobInfo *info;
6229         int i;
6230         WERROR result = WERR_OK;
6231
6232         info = TALLOC_ARRAY(mem_ctx, union spoolss_JobInfo, num_queues);
6233         W_ERROR_HAVE_NO_MEMORY(info);
6234
6235         *count = num_queues;
6236
6237         for (i=0; i<*count; i++) {
6238                 result = fill_job_info1(info,
6239                                         &info[i].info1,
6240                                         &queue[i],
6241                                         i,
6242                                         snum,
6243                                         ntprinter);
6244                 if (!W_ERROR_IS_OK(result)) {
6245                         goto out;
6246                 }
6247         }
6248
6249  out:
6250         if (!W_ERROR_IS_OK(result)) {
6251                 TALLOC_FREE(info);
6252                 *count = 0;
6253                 return result;
6254         }
6255
6256         *info_p = info;
6257
6258         return WERR_OK;
6259 }
6260
6261 /****************************************************************************
6262  Enumjobs at level 2.
6263 ****************************************************************************/
6264
6265 static WERROR enumjobs_level2(TALLOC_CTX *mem_ctx,
6266                               const print_queue_struct *queue,
6267                               uint32_t num_queues, int snum,
6268                               const NT_PRINTER_INFO_LEVEL *ntprinter,
6269                               union spoolss_JobInfo **info_p,
6270                               uint32_t *count)
6271 {
6272         union spoolss_JobInfo *info;
6273         int i;
6274         WERROR result = WERR_OK;
6275
6276         info = TALLOC_ARRAY(mem_ctx, union spoolss_JobInfo, num_queues);
6277         W_ERROR_HAVE_NO_MEMORY(info);
6278
6279         *count = num_queues;
6280
6281         for (i=0; i<*count; i++) {
6282
6283                 struct spoolss_DeviceMode *devmode;
6284
6285                 devmode = construct_dev_mode(info, lp_const_servicename(snum));
6286                 if (!devmode) {
6287                         result = WERR_NOMEM;
6288                         goto out;
6289                 }
6290
6291                 result = fill_job_info2(info,
6292                                         &info[i].info2,
6293                                         &queue[i],
6294                                         i,
6295                                         snum,
6296                                         ntprinter,
6297                                         devmode);
6298                 if (!W_ERROR_IS_OK(result)) {
6299                         goto out;
6300                 }
6301         }
6302
6303  out:
6304         if (!W_ERROR_IS_OK(result)) {
6305                 TALLOC_FREE(info);
6306                 *count = 0;
6307                 return result;
6308         }
6309
6310         *info_p = info;
6311
6312         return WERR_OK;
6313 }
6314
6315 /****************************************************************
6316  _spoolss_EnumJobs
6317 ****************************************************************/
6318
6319 WERROR _spoolss_EnumJobs(pipes_struct *p,
6320                          struct spoolss_EnumJobs *r)
6321 {
6322         WERROR result;
6323         NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
6324         int snum;
6325         print_status_struct prt_status;
6326         print_queue_struct *queue = NULL;
6327         uint32_t count;
6328
6329         /* that's an [in out] buffer */
6330
6331         if (!r->in.buffer && (r->in.offered != 0)) {
6332                 return WERR_INVALID_PARAM;
6333         }
6334
6335         DEBUG(4,("_spoolss_EnumJobs\n"));
6336
6337         *r->out.needed = 0;
6338         *r->out.count = 0;
6339         *r->out.info = NULL;
6340
6341         /* lookup the printer snum and tdb entry */
6342
6343         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
6344                 return WERR_BADFID;
6345         }
6346
6347         result = get_a_printer(NULL, &ntprinter, 2, lp_servicename(snum));
6348         if (!W_ERROR_IS_OK(result)) {
6349                 return result;
6350         }
6351
6352         count = print_queue_status(snum, &queue, &prt_status);
6353         DEBUGADD(4,("count:[%d], status:[%d], [%s]\n",
6354                 count, prt_status.status, prt_status.message));
6355
6356         if (count == 0) {
6357                 SAFE_FREE(queue);
6358                 free_a_printer(&ntprinter, 2);
6359                 return WERR_OK;
6360         }
6361
6362         switch (r->in.level) {
6363         case 1:
6364                 result = enumjobs_level1(p->mem_ctx, queue, count, snum,
6365                                          ntprinter, r->out.info, r->out.count);
6366                 break;
6367         case 2:
6368                 result = enumjobs_level2(p->mem_ctx, queue, count, snum,
6369                                          ntprinter, r->out.info, r->out.count);
6370                 break;
6371         default:
6372                 result = WERR_UNKNOWN_LEVEL;
6373                 break;
6374         }
6375
6376         SAFE_FREE(queue);
6377         free_a_printer(&ntprinter, 2);
6378
6379         if (!W_ERROR_IS_OK(result)) {
6380                 return result;
6381         }
6382
6383         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
6384                                                      spoolss_EnumJobs, NULL,
6385                                                      *r->out.info, r->in.level,
6386                                                      *r->out.count);
6387         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
6388         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
6389
6390         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
6391 }
6392
6393 /****************************************************************
6394  _spoolss_ScheduleJob
6395 ****************************************************************/
6396
6397 WERROR _spoolss_ScheduleJob(pipes_struct *p,
6398                             struct spoolss_ScheduleJob *r)
6399 {
6400         return WERR_OK;
6401 }
6402
6403 /****************************************************************
6404  _spoolss_SetJob
6405 ****************************************************************/
6406
6407 WERROR _spoolss_SetJob(pipes_struct *p,
6408                        struct spoolss_SetJob *r)
6409 {
6410         int snum;
6411         WERROR errcode = WERR_BADFUNC;
6412
6413         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
6414                 return WERR_BADFID;
6415         }
6416
6417         if (!print_job_exists(lp_const_servicename(snum), r->in.job_id)) {
6418                 return WERR_INVALID_PRINTER_NAME;
6419         }
6420
6421         switch (r->in.command) {
6422         case SPOOLSS_JOB_CONTROL_CANCEL:
6423         case SPOOLSS_JOB_CONTROL_DELETE:
6424                 if (print_job_delete(p->server_info, snum, r->in.job_id, &errcode)) {
6425                         errcode = WERR_OK;
6426                 }
6427                 break;
6428         case SPOOLSS_JOB_CONTROL_PAUSE:
6429                 if (print_job_pause(p->server_info, snum, r->in.job_id, &errcode)) {
6430                         errcode = WERR_OK;
6431                 }
6432                 break;
6433         case SPOOLSS_JOB_CONTROL_RESTART:
6434         case SPOOLSS_JOB_CONTROL_RESUME:
6435                 if (print_job_resume(p->server_info, snum, r->in.job_id, &errcode)) {
6436                         errcode = WERR_OK;
6437                 }
6438                 break;
6439         default:
6440                 return WERR_UNKNOWN_LEVEL;
6441         }
6442
6443         return errcode;
6444 }
6445
6446 /****************************************************************************
6447  Enumerates all printer drivers by level and architecture.
6448 ****************************************************************************/
6449
6450 static WERROR enumprinterdrivers_level_by_architecture(TALLOC_CTX *mem_ctx,
6451                                                        const char *servername,
6452                                                        const char *architecture,
6453                                                        uint32_t level,
6454                                                        union spoolss_DriverInfo **info_p,
6455                                                        uint32_t *count_p)
6456 {
6457         int i;
6458         int ndrivers;
6459         uint32_t version;
6460         fstring *list = NULL;
6461         struct spoolss_DriverInfo8 *driver;
6462         union spoolss_DriverInfo *info = NULL;
6463         uint32_t count = 0;
6464         WERROR result = WERR_OK;
6465
6466         *count_p = 0;
6467         *info_p = NULL;
6468
6469         for (version=0; version<DRIVER_MAX_VERSION; version++) {
6470                 list = NULL;
6471                 ndrivers = get_ntdrivers(&list, architecture, version);
6472                 DEBUGADD(4,("we have:[%d] drivers in environment [%s] and version [%d]\n",
6473                         ndrivers, architecture, version));
6474
6475                 if (ndrivers == -1) {
6476                         result = WERR_NOMEM;
6477                         goto out;
6478                 }
6479
6480                 if (ndrivers != 0) {
6481                         info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
6482                                                     union spoolss_DriverInfo,
6483                                                     count + ndrivers);
6484                         if (!info) {
6485                                 DEBUG(0,("enumprinterdrivers_level1: "
6486                                         "failed to enlarge driver info buffer!\n"));
6487                                 result = WERR_NOMEM;
6488                                 goto out;
6489                         }
6490                 }
6491
6492                 for (i=0; i<ndrivers; i++) {
6493                         DEBUGADD(5,("\tdriver: [%s]\n", list[i]));
6494                         ZERO_STRUCT(driver);
6495                         result = get_a_printer_driver(mem_ctx, &driver, list[i],
6496                                                       architecture, version);
6497                         if (!W_ERROR_IS_OK(result)) {
6498                                 goto out;
6499                         }
6500
6501                         switch (level) {
6502                         case 1:
6503                                 result = fill_printer_driver_info1(info, &info[count+i].info1,
6504                                                                    driver, servername,
6505                                                                    architecture);
6506                                 break;
6507                         case 2:
6508                                 result = fill_printer_driver_info2(info, &info[count+i].info2,
6509                                                                    driver, servername);
6510                                 break;
6511                         case 3:
6512                                 result = fill_printer_driver_info3(info, &info[count+i].info3,
6513                                                                    driver, servername);
6514                                 break;
6515                         case 4:
6516                                 result = fill_printer_driver_info4(info, &info[count+i].info4,
6517                                                                    driver, servername);
6518                                 break;
6519                         case 5:
6520                                 result = fill_printer_driver_info5(info, &info[count+i].info5,
6521                                                                    driver, servername);
6522                                 break;
6523                         case 6:
6524                                 result = fill_printer_driver_info6(info, &info[count+i].info6,
6525                                                                    driver, servername);
6526                                 break;
6527                         default:
6528                                 result = WERR_UNKNOWN_LEVEL;
6529                                 break;
6530                         }
6531
6532                         free_a_printer_driver(driver);
6533
6534                         if (!W_ERROR_IS_OK(result)) {
6535                                 goto out;
6536                         }
6537                 }
6538
6539                 count += ndrivers;
6540                 SAFE_FREE(list);
6541         }
6542
6543  out:
6544         SAFE_FREE(list);
6545
6546         if (!W_ERROR_IS_OK(result)) {
6547                 TALLOC_FREE(info);
6548                 return result;
6549         }
6550
6551         *info_p = info;
6552         *count_p = count;
6553
6554         return WERR_OK;
6555 }
6556
6557 /****************************************************************************
6558  Enumerates all printer drivers by level.
6559 ****************************************************************************/
6560
6561 static WERROR enumprinterdrivers_level(TALLOC_CTX *mem_ctx,
6562                                        const char *servername,
6563                                        const char *architecture,
6564                                        uint32_t level,
6565                                        union spoolss_DriverInfo **info_p,
6566                                        uint32_t *count_p)
6567 {
6568         uint32_t a,i;
6569         WERROR result = WERR_OK;
6570
6571         if (strequal(architecture, "all")) {
6572
6573                 for (a=0; archi_table[a].long_archi != NULL; a++) {
6574
6575                         union spoolss_DriverInfo *info = NULL;
6576                         uint32_t count = 0;
6577
6578                         result = enumprinterdrivers_level_by_architecture(mem_ctx,
6579                                                                           servername,
6580                                                                           archi_table[a].long_archi,
6581                                                                           level,
6582                                                                           &info,
6583                                                                           &count);
6584                         if (!W_ERROR_IS_OK(result)) {
6585                                 continue;
6586                         }
6587
6588                         for (i=0; i < count; i++) {
6589                                 ADD_TO_ARRAY(mem_ctx, union spoolss_DriverInfo,
6590                                              info[i], info_p, count_p);
6591                         }
6592                 }
6593
6594                 return result;
6595         }
6596
6597         return enumprinterdrivers_level_by_architecture(mem_ctx,
6598                                                         servername,
6599                                                         architecture,
6600                                                         level,
6601                                                         info_p,
6602                                                         count_p);
6603 }
6604
6605 /****************************************************************************
6606  Enumerates all printer drivers at level 1.
6607 ****************************************************************************/
6608
6609 static WERROR enumprinterdrivers_level1(TALLOC_CTX *mem_ctx,
6610                                         const char *servername,
6611                                         const char *architecture,
6612                                         union spoolss_DriverInfo **info_p,
6613                                         uint32_t *count)
6614 {
6615         return enumprinterdrivers_level(mem_ctx, servername, architecture, 1,
6616                                         info_p, count);
6617 }
6618
6619 /****************************************************************************
6620  Enumerates all printer drivers at level 2.
6621 ****************************************************************************/
6622
6623 static WERROR enumprinterdrivers_level2(TALLOC_CTX *mem_ctx,
6624                                         const char *servername,
6625                                         const char *architecture,
6626                                         union spoolss_DriverInfo **info_p,
6627                                         uint32_t *count)
6628 {
6629         return enumprinterdrivers_level(mem_ctx, servername, architecture, 2,
6630                                         info_p, count);
6631 }
6632
6633 /****************************************************************************
6634  Enumerates all printer drivers at level 3.
6635 ****************************************************************************/
6636
6637 static WERROR enumprinterdrivers_level3(TALLOC_CTX *mem_ctx,
6638                                         const char *servername,
6639                                         const char *architecture,
6640                                         union spoolss_DriverInfo **info_p,
6641                                         uint32_t *count)
6642 {
6643         return enumprinterdrivers_level(mem_ctx, servername, architecture, 3,
6644                                         info_p, count);
6645 }
6646
6647 /****************************************************************************
6648  Enumerates all printer drivers at level 4.
6649 ****************************************************************************/
6650
6651 static WERROR enumprinterdrivers_level4(TALLOC_CTX *mem_ctx,
6652                                         const char *servername,
6653                                         const char *architecture,
6654                                         union spoolss_DriverInfo **info_p,
6655                                         uint32_t *count)
6656 {
6657         return enumprinterdrivers_level(mem_ctx, servername, architecture, 4,
6658                                         info_p, count);
6659 }
6660
6661 /****************************************************************************
6662  Enumerates all printer drivers at level 5.
6663 ****************************************************************************/
6664
6665 static WERROR enumprinterdrivers_level5(TALLOC_CTX *mem_ctx,
6666                                         const char *servername,
6667                                         const char *architecture,
6668                                         union spoolss_DriverInfo **info_p,
6669                                         uint32_t *count)
6670 {
6671         return enumprinterdrivers_level(mem_ctx, servername, architecture, 5,
6672                                         info_p, count);
6673 }
6674
6675 /****************************************************************************
6676  Enumerates all printer drivers at level 6.
6677 ****************************************************************************/
6678
6679 static WERROR enumprinterdrivers_level6(TALLOC_CTX *mem_ctx,
6680                                         const char *servername,
6681                                         const char *architecture,
6682                                         union spoolss_DriverInfo **info_p,
6683                                         uint32_t *count)
6684 {
6685         return enumprinterdrivers_level(mem_ctx, servername, architecture, 6,
6686                                         info_p, count);
6687 }
6688
6689
6690 /****************************************************************
6691  _spoolss_EnumPrinterDrivers
6692 ****************************************************************/
6693
6694 WERROR _spoolss_EnumPrinterDrivers(pipes_struct *p,
6695                                    struct spoolss_EnumPrinterDrivers *r)
6696 {
6697         const char *cservername;
6698         WERROR result;
6699
6700         /* that's an [in out] buffer */
6701
6702         if (!r->in.buffer && (r->in.offered != 0)) {
6703                 return WERR_INVALID_PARAM;
6704         }
6705
6706         DEBUG(4,("_spoolss_EnumPrinterDrivers\n"));
6707
6708         *r->out.needed = 0;
6709         *r->out.count = 0;
6710         *r->out.info = NULL;
6711
6712         cservername = canon_servername(r->in.server);
6713
6714         if (!is_myname_or_ipaddr(cservername)) {
6715                 return WERR_UNKNOWN_PRINTER_DRIVER;
6716         }
6717
6718         switch (r->in.level) {
6719         case 1:
6720                 result = enumprinterdrivers_level1(p->mem_ctx, cservername,
6721                                                    r->in.environment,
6722                                                    r->out.info, r->out.count);
6723                 break;
6724         case 2:
6725                 result = enumprinterdrivers_level2(p->mem_ctx, cservername,
6726                                                    r->in.environment,
6727                                                    r->out.info, r->out.count);
6728                 break;
6729         case 3:
6730                 result = enumprinterdrivers_level3(p->mem_ctx, cservername,
6731                                                    r->in.environment,
6732                                                    r->out.info, r->out.count);
6733                 break;
6734         case 4:
6735                 result = enumprinterdrivers_level4(p->mem_ctx, cservername,
6736                                                    r->in.environment,
6737                                                    r->out.info, r->out.count);
6738                 break;
6739         case 5:
6740                 result = enumprinterdrivers_level5(p->mem_ctx, cservername,
6741                                                    r->in.environment,
6742                                                    r->out.info, r->out.count);
6743                 break;
6744         case 6:
6745                 result = enumprinterdrivers_level6(p->mem_ctx, cservername,
6746                                                    r->in.environment,
6747                                                    r->out.info, r->out.count);
6748                 break;
6749         default:
6750                 return WERR_UNKNOWN_LEVEL;
6751         }
6752
6753         if (!W_ERROR_IS_OK(result)) {
6754                 return result;
6755         }
6756
6757         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
6758                                                      spoolss_EnumPrinterDrivers, NULL,
6759                                                      *r->out.info, r->in.level,
6760                                                      *r->out.count);
6761         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
6762         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
6763
6764         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
6765 }
6766
6767 /****************************************************************************
6768 ****************************************************************************/
6769
6770 static WERROR fill_form_info_1(TALLOC_CTX *mem_ctx,
6771                                struct spoolss_FormInfo1 *r,
6772                                const nt_forms_struct *form)
6773 {
6774         r->form_name    = talloc_strdup(mem_ctx, form->name);
6775         W_ERROR_HAVE_NO_MEMORY(r->form_name);
6776
6777         r->flags        = form->flag;
6778         r->size.width   = form->width;
6779         r->size.height  = form->length;
6780         r->area.left    = form->left;
6781         r->area.top     = form->top;
6782         r->area.right   = form->right;
6783         r->area.bottom  = form->bottom;
6784
6785         return WERR_OK;
6786 }
6787
6788 /****************************************************************
6789  spoolss_enumforms_level1
6790 ****************************************************************/
6791
6792 static WERROR spoolss_enumforms_level1(TALLOC_CTX *mem_ctx,
6793                                        const nt_forms_struct *builtin_forms,
6794                                        uint32_t num_builtin_forms,
6795                                        const nt_forms_struct *user_forms,
6796                                        uint32_t num_user_forms,
6797                                        union spoolss_FormInfo **info_p,
6798                                        uint32_t *count)
6799 {
6800         union spoolss_FormInfo *info;
6801         WERROR result = WERR_OK;
6802         int i;
6803
6804         *count = num_builtin_forms + num_user_forms;
6805
6806         info = TALLOC_ARRAY(mem_ctx, union spoolss_FormInfo, *count);
6807         W_ERROR_HAVE_NO_MEMORY(info);
6808
6809         /* construct the list of form structures */
6810         for (i=0; i<num_builtin_forms; i++) {
6811                 DEBUGADD(6,("Filling builtin form number [%d]\n",i));
6812                 result = fill_form_info_1(info, &info[i].info1,
6813                                           &builtin_forms[i]);
6814                 if (!W_ERROR_IS_OK(result)) {
6815                         goto out;
6816                 }
6817         }
6818
6819         for (i=0; i<num_user_forms; i++) {
6820                 DEBUGADD(6,("Filling user form number [%d]\n",i));
6821                 result = fill_form_info_1(info, &info[i+num_builtin_forms].info1,
6822                                           &user_forms[i]);
6823                 if (!W_ERROR_IS_OK(result)) {
6824                         goto out;
6825                 }
6826         }
6827
6828  out:
6829         if (!W_ERROR_IS_OK(result)) {
6830                 TALLOC_FREE(info);
6831                 *count = 0;
6832                 return result;
6833         }
6834
6835         *info_p = info;
6836
6837         return WERR_OK;
6838 }
6839
6840 /****************************************************************
6841  _spoolss_EnumForms
6842 ****************************************************************/
6843
6844 WERROR _spoolss_EnumForms(pipes_struct *p,
6845                           struct spoolss_EnumForms *r)
6846 {
6847         WERROR result;
6848         nt_forms_struct *user_forms = NULL;
6849         nt_forms_struct *builtin_forms = NULL;
6850         uint32_t num_user_forms;
6851         uint32_t num_builtin_forms;
6852
6853         *r->out.count = 0;
6854         *r->out.needed = 0;
6855         *r->out.info = NULL;
6856
6857         /* that's an [in out] buffer */
6858
6859         if (!r->in.buffer && (r->in.offered != 0) ) {
6860                 return WERR_INVALID_PARAM;
6861         }
6862
6863         DEBUG(4,("_spoolss_EnumForms\n"));
6864         DEBUGADD(5,("Offered buffer size [%d]\n", r->in.offered));
6865         DEBUGADD(5,("Info level [%d]\n",          r->in.level));
6866
6867         num_builtin_forms = get_builtin_ntforms(&builtin_forms);
6868         DEBUGADD(5,("Number of builtin forms [%d]\n", num_builtin_forms));
6869         num_user_forms = get_ntforms(&user_forms);
6870         DEBUGADD(5,("Number of user forms [%d]\n", num_user_forms));
6871
6872         if (num_user_forms + num_builtin_forms == 0) {
6873                 SAFE_FREE(builtin_forms);
6874                 SAFE_FREE(user_forms);
6875                 return WERR_NO_MORE_ITEMS;
6876         }
6877
6878         switch (r->in.level) {
6879         case 1:
6880                 result = spoolss_enumforms_level1(p->mem_ctx,
6881                                                   builtin_forms,
6882                                                   num_builtin_forms,
6883                                                   user_forms,
6884                                                   num_user_forms,
6885                                                   r->out.info,
6886                                                   r->out.count);
6887                 break;
6888         default:
6889                 result = WERR_UNKNOWN_LEVEL;
6890                 break;
6891         }
6892
6893         SAFE_FREE(user_forms);
6894         SAFE_FREE(builtin_forms);
6895
6896         if (!W_ERROR_IS_OK(result)) {
6897                 return result;
6898         }
6899
6900         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
6901                                                      spoolss_EnumForms, NULL,
6902                                                      *r->out.info, r->in.level,
6903                                                      *r->out.count);
6904         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
6905         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
6906
6907         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
6908 }
6909
6910 /****************************************************************
6911 ****************************************************************/
6912
6913 static WERROR find_form_byname(const char *name,
6914                                nt_forms_struct *form)
6915 {
6916         nt_forms_struct *list = NULL;
6917         int num_forms = 0, i = 0;
6918
6919         if (get_a_builtin_ntform_by_string(name, form)) {
6920                 return WERR_OK;
6921         }
6922
6923         num_forms = get_ntforms(&list);
6924         DEBUGADD(5,("Number of forms [%d]\n", num_forms));
6925
6926         if (num_forms == 0) {
6927                 return WERR_BADFID;
6928         }
6929
6930         /* Check if the requested name is in the list of form structures */
6931         for (i = 0; i < num_forms; i++) {
6932
6933                 DEBUG(4,("checking form %s (want %s)\n", list[i].name, name));
6934
6935                 if (strequal(name, list[i].name)) {
6936                         DEBUGADD(6,("Found form %s number [%d]\n", name, i));
6937                         *form = list[i];
6938                         SAFE_FREE(list);
6939                         return WERR_OK;
6940                 }
6941         }
6942
6943         SAFE_FREE(list);
6944
6945         return WERR_BADFID;
6946 }
6947
6948 /****************************************************************
6949  _spoolss_GetForm
6950 ****************************************************************/
6951
6952 WERROR _spoolss_GetForm(pipes_struct *p,
6953                         struct spoolss_GetForm *r)
6954 {
6955         WERROR result;
6956         nt_forms_struct form;
6957
6958         /* that's an [in out] buffer */
6959
6960         if (!r->in.buffer && (r->in.offered != 0)) {
6961                 return WERR_INVALID_PARAM;
6962         }
6963
6964         DEBUG(4,("_spoolss_GetForm\n"));
6965         DEBUGADD(5,("Offered buffer size [%d]\n", r->in.offered));
6966         DEBUGADD(5,("Info level [%d]\n",          r->in.level));
6967
6968         result = find_form_byname(r->in.form_name, &form);
6969         if (!W_ERROR_IS_OK(result)) {
6970                 TALLOC_FREE(r->out.info);
6971                 return result;
6972         }
6973
6974         switch (r->in.level) {
6975         case 1:
6976                 result = fill_form_info_1(p->mem_ctx,
6977                                           &r->out.info->info1,
6978                                           &form);
6979                 break;
6980
6981         default:
6982                 result = WERR_UNKNOWN_LEVEL;
6983                 break;
6984         }
6985
6986         if (!W_ERROR_IS_OK(result)) {
6987                 TALLOC_FREE(r->out.info);
6988                 return result;
6989         }
6990
6991         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_FormInfo, NULL,
6992                                                r->out.info, r->in.level);
6993         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
6994
6995         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
6996 }
6997
6998 /****************************************************************************
6999 ****************************************************************************/
7000
7001 static WERROR fill_port_1(TALLOC_CTX *mem_ctx,
7002                           struct spoolss_PortInfo1 *r,
7003                           const char *name)
7004 {
7005         r->port_name = talloc_strdup(mem_ctx, name);
7006         W_ERROR_HAVE_NO_MEMORY(r->port_name);
7007
7008         return WERR_OK;
7009 }
7010
7011 /****************************************************************************
7012  TODO: This probably needs distinguish between TCP/IP and Local ports
7013  somehow.
7014 ****************************************************************************/
7015
7016 static WERROR fill_port_2(TALLOC_CTX *mem_ctx,
7017                           struct spoolss_PortInfo2 *r,
7018                           const char *name)
7019 {
7020         r->port_name = talloc_strdup(mem_ctx, name);
7021         W_ERROR_HAVE_NO_MEMORY(r->port_name);
7022
7023         r->monitor_name = talloc_strdup(mem_ctx, "Local Monitor");
7024         W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
7025
7026         r->description = talloc_strdup(mem_ctx, SPL_LOCAL_PORT);
7027         W_ERROR_HAVE_NO_MEMORY(r->description);
7028
7029         r->port_type = SPOOLSS_PORT_TYPE_WRITE;
7030         r->reserved = 0;
7031
7032         return WERR_OK;
7033 }
7034
7035
7036 /****************************************************************************
7037  wrapper around the enumer ports command
7038 ****************************************************************************/
7039
7040 static WERROR enumports_hook(TALLOC_CTX *ctx, int *count, char ***lines)
7041 {
7042         char *cmd = lp_enumports_cmd();
7043         char **qlines = NULL;
7044         char *command = NULL;
7045         int numlines;
7046         int ret;
7047         int fd;
7048
7049         *count = 0;
7050         *lines = NULL;
7051
7052         /* if no hook then just fill in the default port */
7053
7054         if ( !*cmd ) {
7055                 if (!(qlines = TALLOC_ARRAY( NULL, char*, 2 ))) {
7056                         return WERR_NOMEM;
7057                 }
7058                 if (!(qlines[0] = talloc_strdup(qlines, SAMBA_PRINTER_PORT_NAME ))) {
7059                         TALLOC_FREE(qlines);
7060                         return WERR_NOMEM;
7061                 }
7062                 qlines[1] = NULL;
7063                 numlines = 1;
7064         }
7065         else {
7066                 /* we have a valid enumport command */
7067
7068                 command = talloc_asprintf(ctx, "%s \"%d\"", cmd, 1);
7069                 if (!command) {
7070                         return WERR_NOMEM;
7071                 }
7072
7073                 DEBUG(10,("Running [%s]\n", command));
7074                 ret = smbrun(command, &fd);
7075                 DEBUG(10,("Returned [%d]\n", ret));
7076                 TALLOC_FREE(command);
7077                 if (ret != 0) {
7078                         if (fd != -1) {
7079                                 close(fd);
7080                         }
7081                         return WERR_ACCESS_DENIED;
7082                 }
7083
7084                 numlines = 0;
7085                 qlines = fd_lines_load(fd, &numlines, 0, NULL);
7086                 DEBUGADD(10,("Lines returned = [%d]\n", numlines));
7087                 close(fd);
7088         }
7089
7090         *count = numlines;
7091         *lines = qlines;
7092
7093         return WERR_OK;
7094 }
7095
7096 /****************************************************************************
7097  enumports level 1.
7098 ****************************************************************************/
7099
7100 static WERROR enumports_level_1(TALLOC_CTX *mem_ctx,
7101                                 union spoolss_PortInfo **info_p,
7102                                 uint32_t *count)
7103 {
7104         union spoolss_PortInfo *info = NULL;
7105         int i=0;
7106         WERROR result = WERR_OK;
7107         char **qlines = NULL;
7108         int numlines = 0;
7109
7110         result = enumports_hook(talloc_tos(), &numlines, &qlines );
7111         if (!W_ERROR_IS_OK(result)) {
7112                 goto out;
7113         }
7114
7115         if (numlines) {
7116                 info = TALLOC_ARRAY(mem_ctx, union spoolss_PortInfo, numlines);
7117                 if (!info) {
7118                         DEBUG(10,("Returning WERR_NOMEM\n"));
7119                         result = WERR_NOMEM;
7120                         goto out;
7121                 }
7122
7123                 for (i=0; i<numlines; i++) {
7124                         DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
7125                         result = fill_port_1(info, &info[i].info1, qlines[i]);
7126                         if (!W_ERROR_IS_OK(result)) {
7127                                 goto out;
7128                         }
7129                 }
7130         }
7131         TALLOC_FREE(qlines);
7132
7133 out:
7134         if (!W_ERROR_IS_OK(result)) {
7135                 TALLOC_FREE(info);
7136                 TALLOC_FREE(qlines);
7137                 *count = 0;
7138                 *info_p = NULL;
7139                 return result;
7140         }
7141
7142         *info_p = info;
7143         *count = numlines;
7144
7145         return WERR_OK;
7146 }
7147
7148 /****************************************************************************
7149  enumports level 2.
7150 ****************************************************************************/
7151
7152 static WERROR enumports_level_2(TALLOC_CTX *mem_ctx,
7153                                 union spoolss_PortInfo **info_p,
7154                                 uint32_t *count)
7155 {
7156         union spoolss_PortInfo *info = NULL;
7157         int i=0;
7158         WERROR result = WERR_OK;
7159         char **qlines = NULL;
7160         int numlines = 0;
7161
7162         result = enumports_hook(talloc_tos(), &numlines, &qlines );
7163         if (!W_ERROR_IS_OK(result)) {
7164                 goto out;
7165         }
7166
7167         if (numlines) {
7168                 info = TALLOC_ARRAY(mem_ctx, union spoolss_PortInfo, numlines);
7169                 if (!info) {
7170                         DEBUG(10,("Returning WERR_NOMEM\n"));
7171                         result = WERR_NOMEM;
7172                         goto out;
7173                 }
7174
7175                 for (i=0; i<numlines; i++) {
7176                         DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
7177                         result = fill_port_2(info, &info[i].info2, qlines[i]);
7178                         if (!W_ERROR_IS_OK(result)) {
7179                                 goto out;
7180                         }
7181                 }
7182         }
7183         TALLOC_FREE(qlines);
7184
7185 out:
7186         if (!W_ERROR_IS_OK(result)) {
7187                 TALLOC_FREE(info);
7188                 TALLOC_FREE(qlines);
7189                 *count = 0;
7190                 *info_p = NULL;
7191                 return result;
7192         }
7193
7194         *info_p = info;
7195         *count = numlines;
7196
7197         return WERR_OK;
7198 }
7199
7200 /****************************************************************
7201  _spoolss_EnumPorts
7202 ****************************************************************/
7203
7204 WERROR _spoolss_EnumPorts(pipes_struct *p,
7205                           struct spoolss_EnumPorts *r)
7206 {
7207         WERROR result;
7208
7209         /* that's an [in out] buffer */
7210
7211         if (!r->in.buffer && (r->in.offered != 0)) {
7212                 return WERR_INVALID_PARAM;
7213         }
7214
7215         DEBUG(4,("_spoolss_EnumPorts\n"));
7216
7217         *r->out.count = 0;
7218         *r->out.needed = 0;
7219         *r->out.info = NULL;
7220
7221         switch (r->in.level) {
7222         case 1:
7223                 result = enumports_level_1(p->mem_ctx, r->out.info,
7224                                            r->out.count);
7225                 break;
7226         case 2:
7227                 result = enumports_level_2(p->mem_ctx, r->out.info,
7228                                            r->out.count);
7229                 break;
7230         default:
7231                 return WERR_UNKNOWN_LEVEL;
7232         }
7233
7234         if (!W_ERROR_IS_OK(result)) {
7235                 return result;
7236         }
7237
7238         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
7239                                                      spoolss_EnumPorts, NULL,
7240                                                      *r->out.info, r->in.level,
7241                                                      *r->out.count);
7242         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
7243         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
7244
7245         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7246 }
7247
7248 /****************************************************************************
7249 ****************************************************************************/
7250
7251 static WERROR spoolss_addprinterex_level_2(pipes_struct *p,
7252                                            const char *server,
7253                                            struct spoolss_SetPrinterInfoCtr *info_ctr,
7254                                            struct spoolss_DeviceMode *devmode,
7255                                            struct security_descriptor *sec_desc,
7256                                            struct spoolss_UserLevelCtr *user_ctr,
7257                                            struct policy_handle *handle)
7258 {
7259         NT_PRINTER_INFO_LEVEL *printer = NULL;
7260         fstring name;
7261         int     snum;
7262         WERROR err = WERR_OK;
7263
7264         if ( !(printer = TALLOC_ZERO_P(NULL, NT_PRINTER_INFO_LEVEL)) ) {
7265                 DEBUG(0,("spoolss_addprinterex_level_2: malloc fail.\n"));
7266                 return WERR_NOMEM;
7267         }
7268
7269         /* convert from UNICODE to ASCII - this allocates the info_2 struct inside *printer.*/
7270         if (!convert_printer_info(info_ctr, printer)) {
7271                 free_a_printer(&printer, 2);
7272                 return WERR_NOMEM;
7273         }
7274
7275         /* check to see if the printer already exists */
7276
7277         if ((snum = print_queue_snum(printer->info_2->sharename)) != -1) {
7278                 DEBUG(5, ("spoolss_addprinterex_level_2: Attempted to add a printer named [%s] when one already existed!\n",
7279                         printer->info_2->sharename));
7280                 free_a_printer(&printer, 2);
7281                 return WERR_PRINTER_ALREADY_EXISTS;
7282         }
7283
7284         /* FIXME!!!  smbd should check to see if the driver is installed before
7285            trying to add a printer like this  --jerry */
7286
7287         if (*lp_addprinter_cmd() ) {
7288                 if ( !add_printer_hook(p->mem_ctx, p->server_info->ptok,
7289                                        printer) ) {
7290                         free_a_printer(&printer,2);
7291                         return WERR_ACCESS_DENIED;
7292                 }
7293         } else {
7294                 DEBUG(0,("spoolss_addprinterex_level_2: add printer for printer %s called and no"
7295                         "smb.conf parameter \"addprinter command\" is defined. This"
7296                         "parameter must exist for this call to succeed\n",
7297                         printer->info_2->sharename ));
7298         }
7299
7300         /* use our primary netbios name since get_a_printer() will convert
7301            it to what the client expects on a case by case basis */
7302
7303         slprintf(name, sizeof(name)-1, "\\\\%s\\%s", global_myname(),
7304              printer->info_2->sharename);
7305
7306
7307         if ((snum = print_queue_snum(printer->info_2->sharename)) == -1) {
7308                 free_a_printer(&printer,2);
7309                 return WERR_ACCESS_DENIED;
7310         }
7311
7312         /* you must be a printer admin to add a new printer */
7313         if (!print_access_check(p->server_info, snum, PRINTER_ACCESS_ADMINISTER)) {
7314                 free_a_printer(&printer,2);
7315                 return WERR_ACCESS_DENIED;
7316         }
7317
7318         /*
7319          * Do sanity check on the requested changes for Samba.
7320          */
7321
7322         if (!check_printer_ok(printer->info_2, snum)) {
7323                 free_a_printer(&printer,2);
7324                 return WERR_INVALID_PARAM;
7325         }
7326
7327         /*
7328          * When a printer is created, the drivername bound to the printer is used
7329          * to lookup previously saved driver initialization info, which is then
7330          * bound to the new printer, simulating what happens in the Windows arch.
7331          */
7332
7333         if (!devmode)
7334         {
7335                 set_driver_init(printer, 2);
7336         }
7337         else
7338         {
7339                 /* A valid devmode was included, convert and link it
7340                 */
7341                 DEBUGADD(10, ("spoolss_addprinterex_level_2: devmode included, converting\n"));
7342
7343                 if (!convert_devicemode(printer->info_2->printername, devmode,
7344                                         &printer->info_2->devmode)) {
7345                         return  WERR_NOMEM;
7346                 }
7347         }
7348
7349         /* write the ASCII on disk */
7350         err = mod_a_printer(printer, 2);
7351         if (!W_ERROR_IS_OK(err)) {
7352                 free_a_printer(&printer,2);
7353                 return err;
7354         }
7355
7356         if (!open_printer_hnd(p, handle, name, PRINTER_ACCESS_ADMINISTER)) {
7357                 /* Handle open failed - remove addition. */
7358                 del_a_printer(printer->info_2->sharename);
7359                 free_a_printer(&printer,2);
7360                 ZERO_STRUCTP(handle);
7361                 return WERR_ACCESS_DENIED;
7362         }
7363
7364         update_c_setprinter(false);
7365         free_a_printer(&printer,2);
7366
7367         return WERR_OK;
7368 }
7369
7370 /****************************************************************
7371  _spoolss_AddPrinterEx
7372 ****************************************************************/
7373
7374 WERROR _spoolss_AddPrinterEx(pipes_struct *p,
7375                              struct spoolss_AddPrinterEx *r)
7376 {
7377         switch (r->in.info_ctr->level) {
7378         case 1:
7379                 /* we don't handle yet */
7380                 /* but I know what to do ... */
7381                 return WERR_UNKNOWN_LEVEL;
7382         case 2:
7383                 return spoolss_addprinterex_level_2(p, r->in.server,
7384                                                     r->in.info_ctr,
7385                                                     r->in.devmode_ctr->devmode,
7386                                                     r->in.secdesc_ctr->sd,
7387                                                     r->in.userlevel_ctr,
7388                                                     r->out.handle);
7389         default:
7390                 return WERR_UNKNOWN_LEVEL;
7391         }
7392 }
7393
7394 /****************************************************************
7395  _spoolss_AddPrinter
7396 ****************************************************************/
7397
7398 WERROR _spoolss_AddPrinter(pipes_struct *p,
7399                            struct spoolss_AddPrinter *r)
7400 {
7401         struct spoolss_AddPrinterEx a;
7402         struct spoolss_UserLevelCtr userlevel_ctr;
7403
7404         ZERO_STRUCT(userlevel_ctr);
7405
7406         userlevel_ctr.level = 1;
7407
7408         a.in.server             = r->in.server;
7409         a.in.info_ctr           = r->in.info_ctr;
7410         a.in.devmode_ctr        = r->in.devmode_ctr;
7411         a.in.secdesc_ctr        = r->in.secdesc_ctr;
7412         a.in.userlevel_ctr      = &userlevel_ctr;
7413         a.out.handle            = r->out.handle;
7414
7415         return _spoolss_AddPrinterEx(p, &a);
7416 }
7417
7418 /****************************************************************
7419  _spoolss_AddPrinterDriver
7420 ****************************************************************/
7421
7422 WERROR _spoolss_AddPrinterDriver(pipes_struct *p,
7423                                  struct spoolss_AddPrinterDriver *r)
7424 {
7425         WERROR err = WERR_OK;
7426         char *driver_name = NULL;
7427         uint32_t version;
7428         const char *fn;
7429
7430         switch (p->hdr_req.opnum) {
7431                 case NDR_SPOOLSS_ADDPRINTERDRIVER:
7432                         fn = "_spoolss_AddPrinterDriver";
7433                         break;
7434                 case NDR_SPOOLSS_ADDPRINTERDRIVEREX:
7435                         fn = "_spoolss_AddPrinterDriverEx";
7436                         break;
7437                 default:
7438                         return WERR_INVALID_PARAM;
7439         }
7440
7441
7442         /* FIXME */
7443         if (r->in.info_ctr->level != 3 && r->in.info_ctr->level != 6) {
7444                 /* Clever hack from Martin Zielinski <mz@seh.de>
7445                  * to allow downgrade from level 8 (Vista).
7446                  */
7447                 DEBUG(0,("%s: level %d not yet implemented\n", fn,
7448                         r->in.info_ctr->level));
7449                 return WERR_UNKNOWN_LEVEL;
7450         }
7451
7452         DEBUG(5,("Cleaning driver's information\n"));
7453         err = clean_up_driver_struct(p, r->in.info_ctr);
7454         if (!W_ERROR_IS_OK(err))
7455                 goto done;
7456
7457         DEBUG(5,("Moving driver to final destination\n"));
7458         if( !W_ERROR_IS_OK(err = move_driver_to_download_area(p, r->in.info_ctr,
7459                                                               &err)) ) {
7460                 goto done;
7461         }
7462
7463         if (add_a_printer_driver(p->mem_ctx, r->in.info_ctr, &driver_name, &version)!=0) {
7464                 err = WERR_ACCESS_DENIED;
7465                 goto done;
7466         }
7467
7468         /*
7469          * I think this is where he DrvUpgradePrinter() hook would be
7470          * be called in a driver's interface DLL on a Windows NT 4.0/2k
7471          * server.  Right now, we just need to send ourselves a message
7472          * to update each printer bound to this driver.   --jerry
7473          */
7474
7475         if (!srv_spoolss_drv_upgrade_printer(driver_name)) {
7476                 DEBUG(0,("%s: Failed to send message about upgrading driver [%s]!\n",
7477                         fn, driver_name));
7478         }
7479
7480         /*
7481          * Based on the version (e.g. driver destination dir: 0=9x,2=Nt/2k,3=2k/Xp),
7482          * decide if the driver init data should be deleted. The rules are:
7483          *  1) never delete init data if it is a 9x driver, they don't use it anyway
7484          *  2) delete init data only if there is no 2k/Xp driver
7485          *  3) always delete init data
7486          * The generalized rule is always use init data from the highest order driver.
7487          * It is necessary to follow the driver install by an initialization step to
7488          * finish off this process.
7489         */
7490
7491         switch (version) {
7492                 /*
7493                  * 9x printer driver - never delete init data
7494                 */
7495                 case 0:
7496                         DEBUG(10,("%s: init data not deleted for 9x driver [%s]\n",
7497                                 fn, driver_name));
7498                         break;
7499
7500                 /*
7501                  * Nt or 2k (compatiblity mode) printer driver - only delete init data if
7502                  * there is no 2k/Xp driver init data for this driver name.
7503                 */
7504                 case 2:
7505                 {
7506                         struct spoolss_DriverInfo8 *driver1;
7507
7508                         if (!W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx, &driver1, driver_name, "Windows NT x86", 3))) {
7509                                 /*
7510                                  * No 2k/Xp driver found, delete init data (if any) for the new Nt driver.
7511                                 */
7512                                 if (!del_driver_init(driver_name))
7513                                         DEBUG(6,("%s: del_driver_init(%s) Nt failed!\n",
7514                                                 fn, driver_name));
7515                         } else {
7516                                 /*
7517                                  * a 2k/Xp driver was found, don't delete init data because Nt driver will use it.
7518                                 */
7519                                 free_a_printer_driver(driver1);
7520                                 DEBUG(10,("%s: init data not deleted for Nt driver [%s]\n",
7521                                         fn, driver_name));
7522                         }
7523                 }
7524                 break;
7525
7526                 /*
7527                  * 2k or Xp printer driver - always delete init data
7528                 */
7529                 case 3:
7530                         if (!del_driver_init(driver_name))
7531                                 DEBUG(6,("%s: del_driver_init(%s) 2k/Xp failed!\n",
7532                                         fn, driver_name));
7533                         break;
7534
7535                 default:
7536                         DEBUG(0,("%s: invalid level=%d\n", fn,
7537                                 r->in.info_ctr->level));
7538                         break;
7539         }
7540
7541
7542 done:
7543         return err;
7544 }
7545
7546 /****************************************************************
7547  _spoolss_AddPrinterDriverEx
7548 ****************************************************************/
7549
7550 WERROR _spoolss_AddPrinterDriverEx(pipes_struct *p,
7551                                    struct spoolss_AddPrinterDriverEx *r)
7552 {
7553         struct spoolss_AddPrinterDriver a;
7554
7555         /*
7556          * we only support the semantics of AddPrinterDriver()
7557          * i.e. only copy files that are newer than existing ones
7558          */
7559
7560         if (r->in.flags != APD_COPY_NEW_FILES) {
7561                 return WERR_ACCESS_DENIED;
7562         }
7563
7564         a.in.servername         = r->in.servername;
7565         a.in.info_ctr           = r->in.info_ctr;
7566
7567         return _spoolss_AddPrinterDriver(p, &a);
7568 }
7569
7570 /****************************************************************************
7571 ****************************************************************************/
7572
7573 struct _spoolss_paths {
7574         int type;
7575         const char *share;
7576         const char *dir;
7577 };
7578
7579 enum { SPOOLSS_DRIVER_PATH, SPOOLSS_PRTPROCS_PATH };
7580
7581 static const struct _spoolss_paths spoolss_paths[]= {
7582         { SPOOLSS_DRIVER_PATH,          "print$",       "DRIVERS" },
7583         { SPOOLSS_PRTPROCS_PATH,        "prnproc$",     "PRTPROCS" }
7584 };
7585
7586 static WERROR compose_spoolss_server_path(TALLOC_CTX *mem_ctx,
7587                                           const char *servername,
7588                                           const char *environment,
7589                                           int component,
7590                                           char **path)
7591 {
7592         const char *pservername = NULL;
7593         const char *long_archi = SPOOLSS_ARCHITECTURE_NT_X86;
7594         const char *short_archi;
7595
7596         *path = NULL;
7597
7598         /* environment may be empty */
7599         if (environment && strlen(environment)) {
7600                 long_archi = environment;
7601         }
7602
7603         /* servername may be empty */
7604         if (servername && strlen(servername)) {
7605                 pservername = canon_servername(servername);
7606
7607                 if (!is_myname_or_ipaddr(pservername)) {
7608                         return WERR_INVALID_PARAM;
7609                 }
7610         }
7611
7612         if (!(short_archi = get_short_archi(long_archi))) {
7613                 return WERR_INVALID_ENVIRONMENT;
7614         }
7615
7616         switch (component) {
7617         case SPOOLSS_PRTPROCS_PATH:
7618         case SPOOLSS_DRIVER_PATH:
7619                 if (pservername) {
7620                         *path = talloc_asprintf(mem_ctx,
7621                                         "\\\\%s\\%s\\%s",
7622                                         pservername,
7623                                         spoolss_paths[component].share,
7624                                         short_archi);
7625                 } else {
7626                         *path = talloc_asprintf(mem_ctx, "%s\\%s\\%s",
7627                                         SPOOLSS_DEFAULT_SERVER_PATH,
7628                                         spoolss_paths[component].dir,
7629                                         short_archi);
7630                 }
7631                 break;
7632         default:
7633                 return WERR_INVALID_PARAM;
7634         }
7635
7636         if (!*path) {
7637                 return WERR_NOMEM;
7638         }
7639
7640         return WERR_OK;
7641 }
7642
7643 /****************************************************************************
7644 ****************************************************************************/
7645
7646 static WERROR getprinterdriverdir_level_1(TALLOC_CTX *mem_ctx,
7647                                           const char *servername,
7648                                           const char *environment,
7649                                           struct spoolss_DriverDirectoryInfo1 *r)
7650 {
7651         WERROR werr;
7652         char *path = NULL;
7653
7654         werr = compose_spoolss_server_path(mem_ctx,
7655                                            servername,
7656                                            environment,
7657                                            SPOOLSS_DRIVER_PATH,
7658                                            &path);
7659         if (!W_ERROR_IS_OK(werr)) {
7660                 return werr;
7661         }
7662
7663         DEBUG(4,("printer driver directory: [%s]\n", path));
7664
7665         r->directory_name = path;
7666
7667         return WERR_OK;
7668 }
7669
7670 /****************************************************************
7671  _spoolss_GetPrinterDriverDirectory
7672 ****************************************************************/
7673
7674 WERROR _spoolss_GetPrinterDriverDirectory(pipes_struct *p,
7675                                           struct spoolss_GetPrinterDriverDirectory *r)
7676 {
7677         WERROR werror;
7678
7679         /* that's an [in out] buffer */
7680
7681         if (!r->in.buffer && (r->in.offered != 0)) {
7682                 return WERR_INVALID_PARAM;
7683         }
7684
7685         DEBUG(5,("_spoolss_GetPrinterDriverDirectory: level %d\n",
7686                 r->in.level));
7687
7688         *r->out.needed = 0;
7689
7690         /* r->in.level is ignored */
7691
7692         werror = getprinterdriverdir_level_1(p->mem_ctx,
7693                                              r->in.server,
7694                                              r->in.environment,
7695                                              &r->out.info->info1);
7696         if (!W_ERROR_IS_OK(werror)) {
7697                 TALLOC_FREE(r->out.info);
7698                 return werror;
7699         }
7700
7701         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_DriverDirectoryInfo, NULL,
7702                                                r->out.info, r->in.level);
7703         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
7704
7705         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7706 }
7707
7708 /****************************************************************
7709  _spoolss_EnumPrinterData
7710 ****************************************************************/
7711
7712 WERROR _spoolss_EnumPrinterData(pipes_struct *p,
7713                                 struct spoolss_EnumPrinterData *r)
7714 {
7715         NT_PRINTER_INFO_LEVEL *printer = NULL;
7716         Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
7717         int             snum;
7718         WERROR          result;
7719         struct regval_blob      *val = NULL;
7720         NT_PRINTER_DATA *p_data;
7721         int             i, key_index, num_values;
7722         int             name_length;
7723
7724         *r->out.value_needed    = 0;
7725         *r->out.type            = REG_NONE;
7726         *r->out.data_needed     = 0;
7727
7728         DEBUG(5,("_spoolss_EnumPrinterData\n"));
7729
7730         if (!Printer) {
7731                 DEBUG(2,("_spoolss_EnumPrinterData: Invalid handle (%s:%u:%u).\n",
7732                         OUR_HANDLE(r->in.handle)));
7733                 return WERR_BADFID;
7734         }
7735
7736         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
7737                 return WERR_BADFID;
7738         }
7739
7740         result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
7741         if (!W_ERROR_IS_OK(result)) {
7742                 return result;
7743         }
7744
7745         p_data = printer->info_2->data;
7746         key_index = lookup_printerkey( p_data, SPOOL_PRINTERDATA_KEY );
7747
7748         result = WERR_OK;
7749
7750         /*
7751          * The NT machine wants to know the biggest size of value and data
7752          *
7753          * cf: MSDN EnumPrinterData remark section
7754          */
7755
7756         if (!r->in.value_offered && !r->in.data_offered && (key_index != -1)) {
7757
7758                 uint32_t biggest_valuesize = 0;
7759                 uint32_t biggest_datasize = 0;
7760
7761                 DEBUGADD(6,("Activating NT mega-hack to find sizes\n"));
7762
7763                 num_values = regval_ctr_numvals( p_data->keys[key_index].values );
7764
7765                 for ( i=0; i<num_values; i++ )
7766                 {
7767                         val = regval_ctr_specific_value( p_data->keys[key_index].values, i );
7768
7769                         name_length = strlen(val->valuename);
7770                         if ( strlen(val->valuename) > biggest_valuesize )
7771                                 biggest_valuesize = name_length;
7772
7773                         if ( val->size > biggest_datasize )
7774                                 biggest_datasize = val->size;
7775
7776                         DEBUG(6,("current values: [%d], [%d]\n", biggest_valuesize,
7777                                 biggest_datasize));
7778                 }
7779
7780                 /* the value is an UNICODE string but real_value_size is the length
7781                    in bytes including the trailing 0 */
7782
7783                 *r->out.value_needed = 2 * (1 + biggest_valuesize);
7784                 *r->out.data_needed  = biggest_datasize;
7785
7786                 DEBUG(6,("final values: [%d], [%d]\n",
7787                         *r->out.value_needed, *r->out.data_needed));
7788
7789                 goto done;
7790         }
7791
7792         /*
7793          * the value len is wrong in NT sp3
7794          * that's the number of bytes not the number of unicode chars
7795          */
7796
7797         if (key_index != -1) {
7798                 val = regval_ctr_specific_value(p_data->keys[key_index].values,
7799                                                 r->in.enum_index);
7800         }
7801
7802         if (!val) {
7803
7804                 /* out_value should default to "" or else NT4 has
7805                    problems unmarshalling the response */
7806
7807                 if (r->in.value_offered) {
7808                         *r->out.value_needed = 1;
7809                         r->out.value_name = talloc_strdup(r, "");
7810                         if (!r->out.value_name) {
7811                                 result = WERR_NOMEM;
7812                                 goto done;
7813                         }
7814                 } else {
7815                         r->out.value_name = NULL;
7816                         *r->out.value_needed = 0;
7817                 }
7818
7819                 /* the data is counted in bytes */
7820
7821                 *r->out.data_needed = r->in.data_offered;
7822
7823                 result = WERR_NO_MORE_ITEMS;
7824         } else {
7825                 /*
7826                  * the value is:
7827                  * - counted in bytes in the request
7828                  * - counted in UNICODE chars in the max reply
7829                  * - counted in bytes in the real size
7830                  *
7831                  * take a pause *before* coding not *during* coding
7832                  */
7833
7834                 /* name */
7835                 if (r->in.value_offered) {
7836                         r->out.value_name = talloc_strdup(r, regval_name(val));
7837                         if (!r->out.value_name) {
7838                                 result = WERR_NOMEM;
7839                                 goto done;
7840                         }
7841                         *r->out.value_needed = strlen_m(regval_name(val));
7842                 } else {
7843                         r->out.value_name = NULL;
7844                         *r->out.value_needed = 0;
7845                 }
7846
7847                 /* type */
7848
7849                 *r->out.type = regval_type(val);
7850
7851                 /* data - counted in bytes */
7852
7853                 if (r->out.data && regval_size(val)) {
7854                         memcpy(r->out.data, regval_data_p(val), regval_size(val));
7855                 }
7856
7857                 *r->out.data_needed = regval_size(val);
7858         }
7859
7860 done:
7861         free_a_printer(&printer, 2);
7862         return result;
7863 }
7864
7865 /****************************************************************
7866  _spoolss_SetPrinterData
7867 ****************************************************************/
7868
7869 WERROR _spoolss_SetPrinterData(pipes_struct *p,
7870                                struct spoolss_SetPrinterData *r)
7871 {
7872         struct spoolss_SetPrinterDataEx r2;
7873
7874         r2.in.handle            = r->in.handle;
7875         r2.in.key_name          = "PrinterDriverData";
7876         r2.in.value_name        = r->in.value_name;
7877         r2.in.type              = r->in.type;
7878         r2.in.data              = r->in.data;
7879         r2.in._offered          = r->in._offered;
7880
7881         return _spoolss_SetPrinterDataEx(p, &r2);
7882 }
7883
7884 /****************************************************************
7885  _spoolss_ResetPrinter
7886 ****************************************************************/
7887
7888 WERROR _spoolss_ResetPrinter(pipes_struct *p,
7889                              struct spoolss_ResetPrinter *r)
7890 {
7891         Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
7892         int             snum;
7893
7894         DEBUG(5,("_spoolss_ResetPrinter\n"));
7895
7896         /*
7897          * All we do is to check to see if the handle and queue is valid.
7898          * This call really doesn't mean anything to us because we only
7899          * support RAW printing.   --jerry
7900          */
7901
7902         if (!Printer) {
7903                 DEBUG(2,("_spoolss_ResetPrinter: Invalid handle (%s:%u:%u).\n",
7904                         OUR_HANDLE(r->in.handle)));
7905                 return WERR_BADFID;
7906         }
7907
7908         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
7909                 return WERR_BADFID;
7910
7911
7912         /* blindly return success */
7913         return WERR_OK;
7914 }
7915
7916 /****************************************************************
7917  _spoolss_DeletePrinterData
7918 ****************************************************************/
7919
7920 WERROR _spoolss_DeletePrinterData(pipes_struct *p,
7921                                   struct spoolss_DeletePrinterData *r)
7922 {
7923         struct spoolss_DeletePrinterDataEx r2;
7924
7925         r2.in.handle            = r->in.handle;
7926         r2.in.key_name          = "PrinterDriverData";
7927         r2.in.value_name        = r->in.value_name;
7928
7929         return _spoolss_DeletePrinterDataEx(p, &r2);
7930 }
7931
7932 /****************************************************************
7933  _spoolss_AddForm
7934 ****************************************************************/
7935
7936 WERROR _spoolss_AddForm(pipes_struct *p,
7937                         struct spoolss_AddForm *r)
7938 {
7939         struct spoolss_AddFormInfo1 *form = r->in.info.info1;
7940         nt_forms_struct tmpForm;
7941         int snum = -1;
7942         WERROR status = WERR_OK;
7943         NT_PRINTER_INFO_LEVEL *printer = NULL;
7944         SE_PRIV se_printop = SE_PRINT_OPERATOR;
7945
7946         int count=0;
7947         nt_forms_struct *list=NULL;
7948         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
7949
7950         DEBUG(5,("_spoolss_AddForm\n"));
7951
7952         if (!Printer) {
7953                 DEBUG(2,("_spoolss_AddForm: Invalid handle (%s:%u:%u).\n",
7954                         OUR_HANDLE(r->in.handle)));
7955                 return WERR_BADFID;
7956         }
7957
7958
7959         /* forms can be added on printer of on the print server handle */
7960
7961         if ( Printer->printer_type == SPLHND_PRINTER )
7962         {
7963                 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
7964                         return WERR_BADFID;
7965
7966                 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
7967                 if (!W_ERROR_IS_OK(status))
7968                         goto done;
7969         }
7970
7971         /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
7972            and not a printer admin, then fail */
7973
7974         if ((p->server_info->utok.uid != sec_initial_uid()) &&
7975              !user_has_privileges(p->server_info->ptok, &se_printop) &&
7976              !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
7977                                           NULL, NULL,
7978                                           p->server_info->ptok,
7979                                           lp_printer_admin(snum))) {
7980                 DEBUG(2,("_spoolss_Addform: denied by insufficient permissions.\n"));
7981                 return WERR_ACCESS_DENIED;
7982         }
7983
7984         /* can't add if builtin */
7985
7986         if (get_a_builtin_ntform_by_string(form->form_name, &tmpForm)) {
7987                 status = WERR_FILE_EXISTS;
7988                 goto done;
7989         }
7990
7991         count = get_ntforms(&list);
7992
7993         if(!add_a_form(&list, form, &count)) {
7994                 status =  WERR_NOMEM;
7995                 goto done;
7996         }
7997
7998         become_root();
7999         write_ntforms(&list, count);
8000         unbecome_root();
8001
8002         /*
8003          * ChangeID must always be set if this is a printer
8004          */
8005
8006         if ( Printer->printer_type == SPLHND_PRINTER )
8007                 status = mod_a_printer(printer, 2);
8008
8009 done:
8010         if ( printer )
8011                 free_a_printer(&printer, 2);
8012         SAFE_FREE(list);
8013
8014         return status;
8015 }
8016
8017 /****************************************************************
8018  _spoolss_DeleteForm
8019 ****************************************************************/
8020
8021 WERROR _spoolss_DeleteForm(pipes_struct *p,
8022                            struct spoolss_DeleteForm *r)
8023 {
8024         const char *form_name = r->in.form_name;
8025         nt_forms_struct tmpForm;
8026         int count=0;
8027         nt_forms_struct *list=NULL;
8028         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8029         int snum = -1;
8030         WERROR status = WERR_OK;
8031         NT_PRINTER_INFO_LEVEL *printer = NULL;
8032         SE_PRIV se_printop = SE_PRINT_OPERATOR;
8033         bool ret = false;
8034
8035         DEBUG(5,("_spoolss_DeleteForm\n"));
8036
8037         if (!Printer) {
8038                 DEBUG(2,("_spoolss_DeleteForm: Invalid handle (%s:%u:%u).\n",
8039                         OUR_HANDLE(r->in.handle)));
8040                 return WERR_BADFID;
8041         }
8042
8043         /* forms can be deleted on printer of on the print server handle */
8044
8045         if ( Printer->printer_type == SPLHND_PRINTER )
8046         {
8047                 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8048                         return WERR_BADFID;
8049
8050                 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8051                 if (!W_ERROR_IS_OK(status))
8052                         goto done;
8053         }
8054
8055         if ((p->server_info->utok.uid != sec_initial_uid()) &&
8056              !user_has_privileges(p->server_info->ptok, &se_printop) &&
8057              !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
8058                                           NULL, NULL,
8059                                           p->server_info->ptok,
8060                                           lp_printer_admin(snum))) {
8061                 DEBUG(2,("_spoolss_DeleteForm: denied by insufficient permissions.\n"));
8062                 return WERR_ACCESS_DENIED;
8063         }
8064
8065
8066         /* can't delete if builtin */
8067
8068         if (get_a_builtin_ntform_by_string(form_name,&tmpForm)) {
8069                 status = WERR_INVALID_PARAM;
8070                 goto done;
8071         }
8072
8073         count = get_ntforms(&list);
8074
8075         become_root();
8076         ret = delete_a_form(&list, form_name, &count, &status);
8077         unbecome_root();
8078         if (ret == false) {
8079                 goto done;
8080         }
8081
8082         /*
8083          * ChangeID must always be set if this is a printer
8084          */
8085
8086         if ( Printer->printer_type == SPLHND_PRINTER )
8087                 status = mod_a_printer(printer, 2);
8088
8089 done:
8090         if ( printer )
8091                 free_a_printer(&printer, 2);
8092         SAFE_FREE(list);
8093
8094         return status;
8095 }
8096
8097 /****************************************************************
8098  _spoolss_SetForm
8099 ****************************************************************/
8100
8101 WERROR _spoolss_SetForm(pipes_struct *p,
8102                         struct spoolss_SetForm *r)
8103 {
8104         struct spoolss_AddFormInfo1 *form = r->in.info.info1;
8105         nt_forms_struct tmpForm;
8106         int snum = -1;
8107         WERROR status = WERR_OK;
8108         NT_PRINTER_INFO_LEVEL *printer = NULL;
8109         SE_PRIV se_printop = SE_PRINT_OPERATOR;
8110
8111         int count=0;
8112         nt_forms_struct *list=NULL;
8113         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8114
8115         DEBUG(5,("_spoolss_SetForm\n"));
8116
8117         if (!Printer) {
8118                 DEBUG(2,("_spoolss_SetForm: Invalid handle (%s:%u:%u).\n",
8119                         OUR_HANDLE(r->in.handle)));
8120                 return WERR_BADFID;
8121         }
8122
8123         /* forms can be modified on printer of on the print server handle */
8124
8125         if ( Printer->printer_type == SPLHND_PRINTER )
8126         {
8127                 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8128                         return WERR_BADFID;
8129
8130                 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8131                 if (!W_ERROR_IS_OK(status))
8132                         goto done;
8133         }
8134
8135         /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
8136            and not a printer admin, then fail */
8137
8138         if ((p->server_info->utok.uid != sec_initial_uid()) &&
8139              !user_has_privileges(p->server_info->ptok, &se_printop) &&
8140              !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
8141                                           NULL, NULL,
8142                                           p->server_info->ptok,
8143                                           lp_printer_admin(snum))) {
8144                 DEBUG(2,("_spoolss_Setform: denied by insufficient permissions.\n"));
8145                 return WERR_ACCESS_DENIED;
8146         }
8147
8148         /* can't set if builtin */
8149         if (get_a_builtin_ntform_by_string(form->form_name, &tmpForm)) {
8150                 status = WERR_INVALID_PARAM;
8151                 goto done;
8152         }
8153
8154         count = get_ntforms(&list);
8155         update_a_form(&list, form, count);
8156         become_root();
8157         write_ntforms(&list, count);
8158         unbecome_root();
8159
8160         /*
8161          * ChangeID must always be set if this is a printer
8162          */
8163
8164         if ( Printer->printer_type == SPLHND_PRINTER )
8165                 status = mod_a_printer(printer, 2);
8166
8167
8168 done:
8169         if ( printer )
8170                 free_a_printer(&printer, 2);
8171         SAFE_FREE(list);
8172
8173         return status;
8174 }
8175
8176 /****************************************************************************
8177  fill_print_processor1
8178 ****************************************************************************/
8179
8180 static WERROR fill_print_processor1(TALLOC_CTX *mem_ctx,
8181                                     struct spoolss_PrintProcessorInfo1 *r,
8182                                     const char *print_processor_name)
8183 {
8184         r->print_processor_name = talloc_strdup(mem_ctx, print_processor_name);
8185         W_ERROR_HAVE_NO_MEMORY(r->print_processor_name);
8186
8187         return WERR_OK;
8188 }
8189
8190 /****************************************************************************
8191  enumprintprocessors level 1.
8192 ****************************************************************************/
8193
8194 static WERROR enumprintprocessors_level_1(TALLOC_CTX *mem_ctx,
8195                                           union spoolss_PrintProcessorInfo **info_p,
8196                                           uint32_t *count)
8197 {
8198         union spoolss_PrintProcessorInfo *info;
8199         WERROR result;
8200
8201         info = TALLOC_ARRAY(mem_ctx, union spoolss_PrintProcessorInfo, 1);
8202         W_ERROR_HAVE_NO_MEMORY(info);
8203
8204         *count = 1;
8205
8206         result = fill_print_processor1(info, &info[0].info1, "winprint");
8207         if (!W_ERROR_IS_OK(result)) {
8208                 goto out;
8209         }
8210
8211  out:
8212         if (!W_ERROR_IS_OK(result)) {
8213                 TALLOC_FREE(info);
8214                 *count = 0;
8215                 return result;
8216         }
8217
8218         *info_p = info;
8219
8220         return WERR_OK;
8221 }
8222
8223 /****************************************************************
8224  _spoolss_EnumPrintProcessors
8225 ****************************************************************/
8226
8227 WERROR _spoolss_EnumPrintProcessors(pipes_struct *p,
8228                                     struct spoolss_EnumPrintProcessors *r)
8229 {
8230         WERROR result;
8231
8232         /* that's an [in out] buffer */
8233
8234         if (!r->in.buffer && (r->in.offered != 0)) {
8235                 return WERR_INVALID_PARAM;
8236         }
8237
8238         DEBUG(5,("_spoolss_EnumPrintProcessors\n"));
8239
8240         /*
8241          * Enumerate the print processors ...
8242          *
8243          * Just reply with "winprint", to keep NT happy
8244          * and I can use my nice printer checker.
8245          */
8246
8247         *r->out.count = 0;
8248         *r->out.needed = 0;
8249         *r->out.info = NULL;
8250
8251         switch (r->in.level) {
8252         case 1:
8253                 result = enumprintprocessors_level_1(p->mem_ctx, r->out.info,
8254                                                      r->out.count);
8255                 break;
8256         default:
8257                 return WERR_UNKNOWN_LEVEL;
8258         }
8259
8260         if (!W_ERROR_IS_OK(result)) {
8261                 return result;
8262         }
8263
8264         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8265                                                      spoolss_EnumPrintProcessors, NULL,
8266                                                      *r->out.info, r->in.level,
8267                                                      *r->out.count);
8268         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8269         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8270
8271         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8272 }
8273
8274 /****************************************************************************
8275  fill_printprocdatatype1
8276 ****************************************************************************/
8277
8278 static WERROR fill_printprocdatatype1(TALLOC_CTX *mem_ctx,
8279                                       struct spoolss_PrintProcDataTypesInfo1 *r,
8280                                       const char *name_array)
8281 {
8282         r->name_array = talloc_strdup(mem_ctx, name_array);
8283         W_ERROR_HAVE_NO_MEMORY(r->name_array);
8284
8285         return WERR_OK;
8286 }
8287
8288 /****************************************************************************
8289  enumprintprocdatatypes level 1.
8290 ****************************************************************************/
8291
8292 static WERROR enumprintprocdatatypes_level_1(TALLOC_CTX *mem_ctx,
8293                                              union spoolss_PrintProcDataTypesInfo **info_p,
8294                                              uint32_t *count)
8295 {
8296         WERROR result;
8297         union spoolss_PrintProcDataTypesInfo *info;
8298
8299         info = TALLOC_ARRAY(mem_ctx, union spoolss_PrintProcDataTypesInfo, 1);
8300         W_ERROR_HAVE_NO_MEMORY(info);
8301
8302         *count = 1;
8303
8304         result = fill_printprocdatatype1(info, &info[0].info1, "RAW");
8305         if (!W_ERROR_IS_OK(result)) {
8306                 goto out;
8307         }
8308
8309  out:
8310         if (!W_ERROR_IS_OK(result)) {
8311                 TALLOC_FREE(info);
8312                 *count = 0;
8313                 return result;
8314         }
8315
8316         *info_p = info;
8317
8318         return WERR_OK;
8319 }
8320
8321 /****************************************************************
8322  _spoolss_EnumPrintProcDataTypes
8323 ****************************************************************/
8324
8325 WERROR _spoolss_EnumPrintProcDataTypes(pipes_struct *p,
8326                                        struct spoolss_EnumPrintProcDataTypes *r)
8327 {
8328         WERROR result;
8329
8330         /* that's an [in out] buffer */
8331
8332         if (!r->in.buffer && (r->in.offered != 0)) {
8333                 return WERR_INVALID_PARAM;
8334         }
8335
8336         DEBUG(5,("_spoolss_EnumPrintProcDataTypes\n"));
8337
8338         *r->out.count = 0;
8339         *r->out.needed = 0;
8340         *r->out.info = NULL;
8341
8342         switch (r->in.level) {
8343         case 1:
8344                 result = enumprintprocdatatypes_level_1(p->mem_ctx, r->out.info,
8345                                                         r->out.count);
8346                 break;
8347         default:
8348                 return WERR_UNKNOWN_LEVEL;
8349         }
8350
8351         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8352                                                      spoolss_EnumPrintProcDataTypes, NULL,
8353                                                      *r->out.info, r->in.level,
8354                                                      *r->out.count);
8355         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8356         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8357
8358         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8359 }
8360
8361 /****************************************************************************
8362  fill_monitor_1
8363 ****************************************************************************/
8364
8365 static WERROR fill_monitor_1(TALLOC_CTX *mem_ctx,
8366                              struct spoolss_MonitorInfo1 *r,
8367                              const char *monitor_name)
8368 {
8369         r->monitor_name                 = talloc_strdup(mem_ctx, monitor_name);
8370         W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
8371
8372         return WERR_OK;
8373 }
8374
8375 /****************************************************************************
8376  fill_monitor_2
8377 ****************************************************************************/
8378
8379 static WERROR fill_monitor_2(TALLOC_CTX *mem_ctx,
8380                              struct spoolss_MonitorInfo2 *r,
8381                              const char *monitor_name,
8382                              const char *environment,
8383                              const char *dll_name)
8384 {
8385         r->monitor_name                 = talloc_strdup(mem_ctx, monitor_name);
8386         W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
8387         r->environment                  = talloc_strdup(mem_ctx, environment);
8388         W_ERROR_HAVE_NO_MEMORY(r->environment);
8389         r->dll_name                     = talloc_strdup(mem_ctx, dll_name);
8390         W_ERROR_HAVE_NO_MEMORY(r->dll_name);
8391
8392         return WERR_OK;
8393 }
8394
8395 /****************************************************************************
8396  enumprintmonitors level 1.
8397 ****************************************************************************/
8398
8399 static WERROR enumprintmonitors_level_1(TALLOC_CTX *mem_ctx,
8400                                         union spoolss_MonitorInfo **info_p,
8401                                         uint32_t *count)
8402 {
8403         union spoolss_MonitorInfo *info;
8404         WERROR result = WERR_OK;
8405
8406         info = TALLOC_ARRAY(mem_ctx, union spoolss_MonitorInfo, 2);
8407         W_ERROR_HAVE_NO_MEMORY(info);
8408
8409         *count = 2;
8410
8411         result = fill_monitor_1(info, &info[0].info1,
8412                                 SPL_LOCAL_PORT);
8413         if (!W_ERROR_IS_OK(result)) {
8414                 goto out;
8415         }
8416
8417         result = fill_monitor_1(info, &info[1].info1,
8418                                 SPL_TCPIP_PORT);
8419         if (!W_ERROR_IS_OK(result)) {
8420                 goto out;
8421         }
8422
8423 out:
8424         if (!W_ERROR_IS_OK(result)) {
8425                 TALLOC_FREE(info);
8426                 *count = 0;
8427                 return result;
8428         }
8429
8430         *info_p = info;
8431
8432         return WERR_OK;
8433 }
8434
8435 /****************************************************************************
8436  enumprintmonitors level 2.
8437 ****************************************************************************/
8438
8439 static WERROR enumprintmonitors_level_2(TALLOC_CTX *mem_ctx,
8440                                         union spoolss_MonitorInfo **info_p,
8441                                         uint32_t *count)
8442 {
8443         union spoolss_MonitorInfo *info;
8444         WERROR result = WERR_OK;
8445
8446         info = TALLOC_ARRAY(mem_ctx, union spoolss_MonitorInfo, 2);
8447         W_ERROR_HAVE_NO_MEMORY(info);
8448
8449         *count = 2;
8450
8451         result = fill_monitor_2(info, &info[0].info2,
8452                                 SPL_LOCAL_PORT,
8453                                 "Windows NT X86", /* FIXME */
8454                                 "localmon.dll");
8455         if (!W_ERROR_IS_OK(result)) {
8456                 goto out;
8457         }
8458
8459         result = fill_monitor_2(info, &info[1].info2,
8460                                 SPL_TCPIP_PORT,
8461                                 "Windows NT X86", /* FIXME */
8462                                 "tcpmon.dll");
8463         if (!W_ERROR_IS_OK(result)) {
8464                 goto out;
8465         }
8466
8467 out:
8468         if (!W_ERROR_IS_OK(result)) {
8469                 TALLOC_FREE(info);
8470                 *count = 0;
8471                 return result;
8472         }
8473
8474         *info_p = info;
8475
8476         return WERR_OK;
8477 }
8478
8479 /****************************************************************
8480  _spoolss_EnumMonitors
8481 ****************************************************************/
8482
8483 WERROR _spoolss_EnumMonitors(pipes_struct *p,
8484                              struct spoolss_EnumMonitors *r)
8485 {
8486         WERROR result;
8487
8488         /* that's an [in out] buffer */
8489
8490         if (!r->in.buffer && (r->in.offered != 0)) {
8491                 return WERR_INVALID_PARAM;
8492         }
8493
8494         DEBUG(5,("_spoolss_EnumMonitors\n"));
8495
8496         /*
8497          * Enumerate the print monitors ...
8498          *
8499          * Just reply with "Local Port", to keep NT happy
8500          * and I can use my nice printer checker.
8501          */
8502
8503         *r->out.count = 0;
8504         *r->out.needed = 0;
8505         *r->out.info = NULL;
8506
8507         switch (r->in.level) {
8508         case 1:
8509                 result = enumprintmonitors_level_1(p->mem_ctx, r->out.info,
8510                                                    r->out.count);
8511                 break;
8512         case 2:
8513                 result = enumprintmonitors_level_2(p->mem_ctx, r->out.info,
8514                                                    r->out.count);
8515                 break;
8516         default:
8517                 return WERR_UNKNOWN_LEVEL;
8518         }
8519
8520         if (!W_ERROR_IS_OK(result)) {
8521                 return result;
8522         }
8523
8524         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8525                                                      spoolss_EnumMonitors, NULL,
8526                                                      *r->out.info, r->in.level,
8527                                                      *r->out.count);
8528         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8529         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8530
8531         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8532 }
8533
8534 /****************************************************************************
8535 ****************************************************************************/
8536
8537 static WERROR getjob_level_1(TALLOC_CTX *mem_ctx,
8538                              const print_queue_struct *queue,
8539                              int count, int snum,
8540                              const NT_PRINTER_INFO_LEVEL *ntprinter,
8541                              uint32_t jobid,
8542                              struct spoolss_JobInfo1 *r)
8543 {
8544         int i = 0;
8545         bool found = false;
8546
8547         for (i=0; i<count && found == false; i++) {
8548                 if (queue[i].job == (int)jobid) {
8549                         found = true;
8550                 }
8551         }
8552
8553         if (found == false) {
8554                 /* NT treats not found as bad param... yet another bad choice */
8555                 return WERR_INVALID_PARAM;
8556         }
8557
8558         return fill_job_info1(mem_ctx,
8559                               r,
8560                               &queue[i-1],
8561                               i,
8562                               snum,
8563                               ntprinter);
8564 }
8565
8566 /****************************************************************************
8567 ****************************************************************************/
8568
8569 static WERROR getjob_level_2(TALLOC_CTX *mem_ctx,
8570                              const print_queue_struct *queue,
8571                              int count, int snum,
8572                              const NT_PRINTER_INFO_LEVEL *ntprinter,
8573                              uint32_t jobid,
8574                              struct spoolss_JobInfo2 *r)
8575 {
8576         int i = 0;
8577         bool found = false;
8578         struct spoolss_DeviceMode *devmode;
8579         NT_DEVICEMODE *nt_devmode;
8580         WERROR result;
8581
8582         for (i=0; i<count && found == false; i++) {
8583                 if (queue[i].job == (int)jobid) {
8584                         found = true;
8585                 }
8586         }
8587
8588         if (found == false) {
8589                 /* NT treats not found as bad param... yet another bad
8590                    choice */
8591                 return WERR_INVALID_PARAM;
8592         }
8593
8594         /*
8595          * if the print job does not have a DEVMODE associated with it,
8596          * just use the one for the printer. A NULL devicemode is not
8597          *  a failure condition
8598          */
8599
8600         nt_devmode = print_job_devmode(lp_const_servicename(snum), jobid);
8601         if (nt_devmode) {
8602                 devmode = TALLOC_ZERO_P(mem_ctx, struct spoolss_DeviceMode);
8603                 W_ERROR_HAVE_NO_MEMORY(devmode);
8604                 result = convert_nt_devicemode(devmode, devmode, nt_devmode);
8605                 if (!W_ERROR_IS_OK(result)) {
8606                         return result;
8607                 }
8608         } else {
8609                 devmode = construct_dev_mode(mem_ctx, lp_const_servicename(snum));
8610                 W_ERROR_HAVE_NO_MEMORY(devmode);
8611         }
8612
8613         return fill_job_info2(mem_ctx,
8614                               r,
8615                               &queue[i-1],
8616                               i,
8617                               snum,
8618                               ntprinter,
8619                               devmode);
8620 }
8621
8622 /****************************************************************
8623  _spoolss_GetJob
8624 ****************************************************************/
8625
8626 WERROR _spoolss_GetJob(pipes_struct *p,
8627                        struct spoolss_GetJob *r)
8628 {
8629         WERROR result = WERR_OK;
8630         NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
8631         int snum;
8632         int count;
8633         print_queue_struct      *queue = NULL;
8634         print_status_struct prt_status;
8635
8636         /* that's an [in out] buffer */
8637
8638         if (!r->in.buffer && (r->in.offered != 0)) {
8639                 return WERR_INVALID_PARAM;
8640         }
8641
8642         DEBUG(5,("_spoolss_GetJob\n"));
8643
8644         *r->out.needed = 0;
8645
8646         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8647                 return WERR_BADFID;
8648         }
8649
8650         result = get_a_printer(NULL, &ntprinter, 2, lp_servicename(snum));
8651         if (!W_ERROR_IS_OK(result)) {
8652                 return result;
8653         }
8654
8655         count = print_queue_status(snum, &queue, &prt_status);
8656
8657         DEBUGADD(4,("count:[%d], prt_status:[%d], [%s]\n",
8658                      count, prt_status.status, prt_status.message));
8659
8660         switch (r->in.level) {
8661         case 1:
8662                 result = getjob_level_1(p->mem_ctx,
8663                                         queue, count, snum, ntprinter,
8664                                         r->in.job_id, &r->out.info->info1);
8665                 break;
8666         case 2:
8667                 result = getjob_level_2(p->mem_ctx,
8668                                         queue, count, snum, ntprinter,
8669                                         r->in.job_id, &r->out.info->info2);
8670                 break;
8671         default:
8672                 result = WERR_UNKNOWN_LEVEL;
8673                 break;
8674         }
8675
8676         SAFE_FREE(queue);
8677         free_a_printer(&ntprinter, 2);
8678
8679         if (!W_ERROR_IS_OK(result)) {
8680                 TALLOC_FREE(r->out.info);
8681                 return result;
8682         }
8683
8684         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_JobInfo, NULL,
8685                                                r->out.info, r->in.level);
8686         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
8687
8688         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8689 }
8690
8691 /****************************************************************
8692  _spoolss_GetPrinterDataEx
8693 ****************************************************************/
8694
8695 WERROR _spoolss_GetPrinterDataEx(pipes_struct *p,
8696                                  struct spoolss_GetPrinterDataEx *r)
8697 {
8698
8699         Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
8700         struct regval_blob              *val = NULL;
8701         NT_PRINTER_INFO_LEVEL   *printer = NULL;
8702         int                     snum = 0;
8703         WERROR result = WERR_OK;
8704         DATA_BLOB blob;
8705
8706         DEBUG(4,("_spoolss_GetPrinterDataEx\n"));
8707
8708         DEBUG(10, ("_spoolss_GetPrinterDataEx: key => [%s], value => [%s]\n",
8709                 r->in.key_name, r->in.value_name));
8710
8711         /* in case of problem, return some default values */
8712
8713         *r->out.needed  = 0;
8714         *r->out.type    = REG_NONE;
8715
8716         if (!Printer) {
8717                 DEBUG(2,("_spoolss_GetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
8718                         OUR_HANDLE(r->in.handle)));
8719                 result = WERR_BADFID;
8720                 goto done;
8721         }
8722
8723         /* Is the handle to a printer or to the server? */
8724
8725         if (Printer->printer_type == SPLHND_SERVER) {
8726
8727                 result = getprinterdata_printer_server(p->mem_ctx,
8728                                                        r->in.value_name,
8729                                                        r->out.type,
8730                                                        r->out.data);
8731                 goto done;
8732         }
8733
8734         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8735                 result = WERR_BADFID;
8736                 goto done;
8737         }
8738
8739         result = get_a_printer(Printer, &printer, 2, lp_servicename(snum));
8740         if (!W_ERROR_IS_OK(result)) {
8741                 goto done;
8742         }
8743
8744         /* check to see if the keyname is valid */
8745         if (!strlen(r->in.key_name)) {
8746                 result = WERR_INVALID_PARAM;
8747                 goto done;
8748         }
8749
8750         /* XP sends this and wants to change id value from the PRINTER_INFO_0 */
8751
8752         if (strequal(r->in.key_name, SPOOL_PRINTERDATA_KEY) &&
8753             strequal(r->in.value_name, "ChangeId")) {
8754                 *r->out.type = REG_DWORD;
8755                 *r->out.needed = 4;
8756                 r->out.data->value = printer->info_2->changeid;
8757                 result = WERR_OK;
8758                 goto done;
8759         }
8760
8761         if (lookup_printerkey(printer->info_2->data, r->in.key_name) == -1) {
8762                 DEBUG(4,("_spoolss_GetPrinterDataEx: "
8763                         "Invalid keyname [%s]\n", r->in.key_name ));
8764                 result = WERR_BADFILE;
8765                 goto done;
8766         }
8767
8768         val = get_printer_data(printer->info_2,
8769                                r->in.key_name, r->in.value_name);
8770         if (!val) {
8771                 result = WERR_BADFILE;
8772                 goto done;
8773         }
8774
8775         *r->out.needed = regval_size(val);
8776         *r->out.type = regval_type(val);
8777
8778         blob = data_blob_const(regval_data_p(val), regval_size(val));
8779
8780         result = pull_spoolss_PrinterData(p->mem_ctx, &blob,
8781                                           r->out.data,
8782                                           *r->out.type);
8783
8784  done:
8785         if (printer) {
8786                 free_a_printer(&printer, 2);
8787         }
8788
8789         if (!W_ERROR_IS_OK(result)) {
8790                 return result;
8791         }
8792
8793         *r->out.needed  = ndr_size_spoolss_PrinterData(r->out.data, *r->out.type, NULL, 0);
8794         *r->out.type    = SPOOLSS_BUFFER_OK(*r->out.type, REG_NONE);
8795         r->out.data     = SPOOLSS_BUFFER_OK(r->out.data, r->out.data);
8796
8797         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
8798 }
8799
8800 /****************************************************************
8801  _spoolss_SetPrinterDataEx
8802 ****************************************************************/
8803
8804 WERROR _spoolss_SetPrinterDataEx(pipes_struct *p,
8805                                  struct spoolss_SetPrinterDataEx *r)
8806 {
8807         NT_PRINTER_INFO_LEVEL   *printer = NULL;
8808         int                     snum = 0;
8809         WERROR                  result = WERR_OK;
8810         Printer_entry           *Printer = find_printer_index_by_hnd(p, r->in.handle);
8811         char                    *oid_string;
8812         DATA_BLOB blob;
8813
8814         DEBUG(4,("_spoolss_SetPrinterDataEx\n"));
8815
8816         /* From MSDN documentation of SetPrinterDataEx: pass request to
8817            SetPrinterData if key is "PrinterDriverData" */
8818
8819         if (!Printer) {
8820                 DEBUG(2,("_spoolss_SetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
8821                         OUR_HANDLE(r->in.handle)));
8822                 return WERR_BADFID;
8823         }
8824
8825         if (Printer->printer_type == SPLHND_SERVER) {
8826                 DEBUG(10,("_spoolss_SetPrinterDataEx: "
8827                         "Not implemented for server handles yet\n"));
8828                 return WERR_INVALID_PARAM;
8829         }
8830
8831         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8832                 return WERR_BADFID;
8833         }
8834
8835         /*
8836          * Access check : NT returns "access denied" if you make a
8837          * SetPrinterData call without the necessary privildge.
8838          * we were originally returning OK if nothing changed
8839          * which made Win2k issue **a lot** of SetPrinterData
8840          * when connecting to a printer  --jerry
8841          */
8842
8843         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
8844                 DEBUG(3, ("_spoolss_SetPrinterDataEx: "
8845                         "change denied by handle access permissions\n"));
8846                 return WERR_ACCESS_DENIED;
8847         }
8848
8849         result = get_a_printer(Printer, &printer, 2, lp_servicename(snum));
8850         if (!W_ERROR_IS_OK(result)) {
8851                 return result;
8852         }
8853
8854         /* check for OID in valuename */
8855
8856         oid_string = strchr(r->in.value_name, ',');
8857         if (oid_string) {
8858                 *oid_string = '\0';
8859                 oid_string++;
8860         }
8861
8862         result = push_spoolss_PrinterData(p->mem_ctx, &blob,
8863                                           r->in.type, &r->in.data);
8864         if (!W_ERROR_IS_OK(result)) {
8865                 goto done;
8866         }
8867
8868         /*
8869          * When client side code sets a magic printer data key, detect it and save
8870          * the current printer data and the magic key's data (its the DEVMODE) for
8871          * future printer/driver initializations.
8872          */
8873         if ((r->in.type == REG_BINARY) && strequal(r->in.value_name, PHANTOM_DEVMODE_KEY)) {
8874                 /* Set devmode and printer initialization info */
8875                 result = save_driver_init(printer, 2, blob.data, blob.length);
8876
8877                 srv_spoolss_reset_printerdata(printer->info_2->drivername);
8878
8879                 goto done;
8880         }
8881
8882         /* save the registry data */
8883
8884         result = set_printer_dataex(printer, r->in.key_name, r->in.value_name,
8885                                     r->in.type, blob.data, blob.length);
8886
8887         if (W_ERROR_IS_OK(result)) {
8888                 /* save the OID if one was specified */
8889                 if (oid_string) {
8890                         char *str = talloc_asprintf(p->mem_ctx, "%s\\%s",
8891                                 r->in.key_name, SPOOL_OID_KEY);
8892                         if (!str) {
8893                                 result = WERR_NOMEM;
8894                                 goto done;
8895                         }
8896
8897                         /*
8898                          * I'm not checking the status here on purpose.  Don't know
8899                          * if this is right, but I'm returning the status from the
8900                          * previous set_printer_dataex() call.  I have no idea if
8901                          * this is right.    --jerry
8902                          */
8903
8904                         set_printer_dataex(printer, str, r->in.value_name,
8905                                            REG_SZ, (uint8_t *)oid_string,
8906                                            strlen(oid_string)+1);
8907                 }
8908
8909                 result = mod_a_printer(printer, 2);
8910         }
8911
8912  done:
8913         free_a_printer(&printer, 2);
8914
8915         return result;
8916 }
8917
8918 /****************************************************************
8919  _spoolss_DeletePrinterDataEx
8920 ****************************************************************/
8921
8922 WERROR _spoolss_DeletePrinterDataEx(pipes_struct *p,
8923                                     struct spoolss_DeletePrinterDataEx *r)
8924 {
8925         NT_PRINTER_INFO_LEVEL   *printer = NULL;
8926         int             snum=0;
8927         WERROR          status = WERR_OK;
8928         Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
8929
8930         DEBUG(5,("_spoolss_DeletePrinterDataEx\n"));
8931
8932         if (!Printer) {
8933                 DEBUG(2,("_spoolss_DeletePrinterDataEx: "
8934                         "Invalid handle (%s:%u:%u).\n",
8935                         OUR_HANDLE(r->in.handle)));
8936                 return WERR_BADFID;
8937         }
8938
8939         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8940                 return WERR_BADFID;
8941
8942         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
8943                 DEBUG(3, ("_spoolss_DeletePrinterDataEx: "
8944                         "printer properties change denied by handle\n"));
8945                 return WERR_ACCESS_DENIED;
8946         }
8947
8948         if (!r->in.value_name || !r->in.key_name) {
8949                 return WERR_NOMEM;
8950         }
8951
8952         status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8953         if (!W_ERROR_IS_OK(status))
8954                 return status;
8955
8956         status = delete_printer_dataex( printer, r->in.key_name, r->in.value_name );
8957
8958         if ( W_ERROR_IS_OK(status) )
8959                 mod_a_printer( printer, 2 );
8960
8961         free_a_printer(&printer, 2);
8962
8963         return status;
8964 }
8965
8966 /****************************************************************
8967  _spoolss_EnumPrinterKey
8968 ****************************************************************/
8969
8970 WERROR _spoolss_EnumPrinterKey(pipes_struct *p,
8971                                struct spoolss_EnumPrinterKey *r)
8972 {
8973         fstring         *keynames = NULL;
8974         int             num_keys;
8975         Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
8976         NT_PRINTER_DATA *data;
8977         NT_PRINTER_INFO_LEVEL   *printer = NULL;
8978         int             snum = 0;
8979         WERROR          result = WERR_BADFILE;
8980         int i;
8981         const char **array = NULL;
8982         DATA_BLOB blob;
8983
8984         DEBUG(4,("_spoolss_EnumPrinterKey\n"));
8985
8986         if (!Printer) {
8987                 DEBUG(2,("_spoolss_EnumPrinterKey: Invalid handle (%s:%u:%u).\n",
8988                         OUR_HANDLE(r->in.handle)));
8989                 return WERR_BADFID;
8990         }
8991
8992         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8993                 return WERR_BADFID;
8994         }
8995
8996         result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8997         if (!W_ERROR_IS_OK(result)) {
8998                 return result;
8999         }
9000
9001         /* get the list of subkey names */
9002
9003         data = printer->info_2->data;
9004
9005         num_keys = get_printer_subkeys(data, r->in.key_name, &keynames);
9006         if (num_keys == -1) {
9007                 result = WERR_BADFILE;
9008                 goto done;
9009         }
9010
9011         array = talloc_zero_array(r->out.key_buffer, const char *, num_keys + 1);
9012         if (!array) {
9013                 result = WERR_NOMEM;
9014                 goto done;
9015         }
9016
9017         for (i=0; i < num_keys; i++) {
9018
9019                 DEBUG(10,("_spoolss_EnumPrinterKey: adding keyname: %s\n",
9020                         keynames[i]));
9021
9022                 array[i] = talloc_strdup(array, keynames[i]);
9023                 if (!array[i]) {
9024                         result = WERR_NOMEM;
9025                         goto done;
9026                 }
9027         }
9028
9029         if (!push_reg_multi_sz(p->mem_ctx, &blob, array)) {
9030                 result = WERR_NOMEM;
9031                 goto done;
9032         }
9033
9034         *r->out.needed = blob.length;
9035
9036         if (r->in.offered < *r->out.needed) {
9037                 result = WERR_MORE_DATA;
9038         } else {
9039                 result = WERR_OK;
9040                 r->out.key_buffer->string = array;
9041         }
9042
9043  done:
9044         if (!W_ERROR_IS_OK(result)) {
9045                 TALLOC_FREE(array);
9046                 if (!W_ERROR_EQUAL(result, WERR_MORE_DATA)) {
9047                         *r->out.needed = 0;
9048                 }
9049         }
9050
9051         free_a_printer(&printer, 2);
9052         SAFE_FREE(keynames);
9053
9054         return result;
9055 }
9056
9057 /****************************************************************
9058  _spoolss_DeletePrinterKey
9059 ****************************************************************/
9060
9061 WERROR _spoolss_DeletePrinterKey(pipes_struct *p,
9062                                  struct spoolss_DeletePrinterKey *r)
9063 {
9064         Printer_entry           *Printer = find_printer_index_by_hnd(p, r->in.handle);
9065         NT_PRINTER_INFO_LEVEL   *printer = NULL;
9066         int                     snum=0;
9067         WERROR                  status;
9068
9069         DEBUG(5,("_spoolss_DeletePrinterKey\n"));
9070
9071         if (!Printer) {
9072                 DEBUG(2,("_spoolss_DeletePrinterKey: Invalid handle (%s:%u:%u).\n",
9073                         OUR_HANDLE(r->in.handle)));
9074                 return WERR_BADFID;
9075         }
9076
9077         /* if keyname == NULL, return error */
9078
9079         if ( !r->in.key_name )
9080                 return WERR_INVALID_PARAM;
9081
9082         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
9083                 return WERR_BADFID;
9084
9085         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9086                 DEBUG(3, ("_spoolss_DeletePrinterKey: "
9087                         "printer properties change denied by handle\n"));
9088                 return WERR_ACCESS_DENIED;
9089         }
9090
9091         status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9092         if (!W_ERROR_IS_OK(status))
9093                 return status;
9094
9095         /* delete the key and all subneys */
9096
9097         status = delete_all_printer_data( printer->info_2, r->in.key_name );
9098
9099         if ( W_ERROR_IS_OK(status) )
9100                 status = mod_a_printer(printer, 2);
9101
9102         free_a_printer( &printer, 2 );
9103
9104         return status;
9105 }
9106
9107 /****************************************************************
9108 ****************************************************************/
9109
9110 static WERROR registry_value_to_printer_enum_value(TALLOC_CTX *mem_ctx,
9111                                                    struct regval_blob *v,
9112                                                    struct spoolss_PrinterEnumValues *r)
9113 {
9114         WERROR result;
9115
9116         r->data = TALLOC_ZERO_P(mem_ctx, union spoolss_PrinterData);
9117         W_ERROR_HAVE_NO_MEMORY(r->data);
9118
9119         r->value_name   = talloc_strdup(mem_ctx, regval_name(v));
9120         W_ERROR_HAVE_NO_MEMORY(r->value_name);
9121
9122         r->type         = regval_type(v);
9123         r->data_length  = regval_size(v);
9124
9125         if (r->data_length) {
9126                 DATA_BLOB blob = data_blob_const(regval_data_p(v),
9127                                                  regval_size(v));
9128                 result = pull_spoolss_PrinterData(mem_ctx, &blob,
9129                                                   r->data,
9130                                                   r->type);
9131                 if (!W_ERROR_IS_OK(result)) {
9132                         return result;
9133                 }
9134         }
9135
9136         return WERR_OK;
9137 }
9138
9139 /****************************************************************
9140  _spoolss_EnumPrinterDataEx
9141 ****************************************************************/
9142
9143 WERROR _spoolss_EnumPrinterDataEx(pipes_struct *p,
9144                                   struct spoolss_EnumPrinterDataEx *r)
9145 {
9146         uint32_t        count = 0;
9147         NT_PRINTER_INFO_LEVEL   *printer = NULL;
9148         struct spoolss_PrinterEnumValues *info = NULL;
9149         NT_PRINTER_DATA         *p_data;
9150         Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
9151         int             snum;
9152         WERROR          result;
9153         int             key_index;
9154         int             i;
9155
9156         DEBUG(4,("_spoolss_EnumPrinterDataEx\n"));
9157
9158         *r->out.count = 0;
9159         *r->out.needed = 0;
9160         *r->out.info = NULL;
9161
9162         if (!Printer) {
9163                 DEBUG(2,("_spoolss_EnumPrinterDataEx: Invalid handle (%s:%u:%u1<).\n",
9164                         OUR_HANDLE(r->in.handle)));
9165                 return WERR_BADFID;
9166         }
9167
9168         /*
9169          * first check for a keyname of NULL or "".  Win2k seems to send
9170          * this a lot and we should send back WERR_INVALID_PARAM
9171          * no need to spend time looking up the printer in this case.
9172          * --jerry
9173          */
9174
9175         if (!strlen(r->in.key_name)) {
9176                 result = WERR_INVALID_PARAM;
9177                 goto done;
9178         }
9179
9180         /* get the printer off of disk */
9181
9182         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9183                 return WERR_BADFID;
9184         }
9185
9186         ZERO_STRUCT(printer);
9187         result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9188         if (!W_ERROR_IS_OK(result)) {
9189                 return result;
9190         }
9191
9192         /* now look for a match on the key name */
9193
9194         p_data = printer->info_2->data;
9195
9196         key_index = lookup_printerkey(p_data, r->in.key_name);
9197         if (key_index == -1) {
9198                 DEBUG(10,("_spoolss_EnumPrinterDataEx: Unknown keyname [%s]\n",
9199                         r->in.key_name));
9200                 result = WERR_INVALID_PARAM;
9201                 goto done;
9202         }
9203
9204         /* allocate the memory for the array of pointers -- if necessary */
9205
9206         count = regval_ctr_numvals(p_data->keys[key_index].values);
9207         if (!count) {
9208                 result = WERR_OK; /* ??? */
9209                 goto done;
9210         }
9211
9212         info = TALLOC_ZERO_ARRAY(p->mem_ctx,
9213                                  struct spoolss_PrinterEnumValues,
9214                                  count);
9215         if (!info) {
9216                 DEBUG(0,("_spoolss_EnumPrinterDataEx: talloc() failed\n"));
9217                 result = WERR_NOMEM;
9218                 goto done;
9219         }
9220
9221         /*
9222          * loop through all params and build the array to pass
9223          * back to the  client
9224          */
9225
9226         for (i=0; i < count; i++) {
9227
9228                 struct regval_blob      *val;
9229
9230                 /* lookup the registry value */
9231
9232                 val = regval_ctr_specific_value(p_data->keys[key_index].values, i);
9233
9234                 DEBUG(10,("retrieved value number [%d] [%s]\n", i, regval_name(val)));
9235
9236                 /* copy the data */
9237
9238                 result = registry_value_to_printer_enum_value(info, val, &info[i]);
9239                 if (!W_ERROR_IS_OK(result)) {
9240                         goto done;
9241                 }
9242         }
9243
9244 #if 0 /* FIXME - gd */
9245         /* housekeeping information in the reply */
9246
9247         /* Fix from Martin Zielinski <mz@seh.de> - ensure
9248          * the hand marshalled container size is a multiple
9249          * of 4 bytes for RPC alignment.
9250          */
9251
9252         if (needed % 4) {
9253                 needed += 4-(needed % 4);
9254         }
9255 #endif
9256         *r->out.count   = count;
9257         *r->out.info    = info;
9258
9259  done:
9260
9261         if (printer) {
9262                 free_a_printer(&printer, 2);
9263         }
9264
9265         if (!W_ERROR_IS_OK(result)) {
9266                 return result;
9267         }
9268
9269         *r->out.needed  = SPOOLSS_BUFFER_ARRAY(p->mem_ctx,
9270                                                spoolss_EnumPrinterDataEx, NULL,
9271                                                *r->out.info,
9272                                                *r->out.count);
9273         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
9274         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, *r->out.count);
9275
9276         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
9277 }
9278
9279 /****************************************************************************
9280 ****************************************************************************/
9281
9282 static WERROR getprintprocessordirectory_level_1(TALLOC_CTX *mem_ctx,
9283                                                  const char *servername,
9284                                                  const char *environment,
9285                                                  struct spoolss_PrintProcessorDirectoryInfo1 *r)
9286 {
9287         WERROR werr;
9288         char *path = NULL;
9289
9290         werr = compose_spoolss_server_path(mem_ctx,
9291                                            servername,
9292                                            environment,
9293                                            SPOOLSS_PRTPROCS_PATH,
9294                                            &path);
9295         if (!W_ERROR_IS_OK(werr)) {
9296                 return werr;
9297         }
9298
9299         DEBUG(4,("print processor directory: [%s]\n", path));
9300
9301         r->directory_name = path;
9302
9303         return WERR_OK;
9304 }
9305
9306 /****************************************************************
9307  _spoolss_GetPrintProcessorDirectory
9308 ****************************************************************/
9309
9310 WERROR _spoolss_GetPrintProcessorDirectory(pipes_struct *p,
9311                                            struct spoolss_GetPrintProcessorDirectory *r)
9312 {
9313         WERROR result;
9314
9315         /* that's an [in out] buffer */
9316
9317         if (!r->in.buffer && (r->in.offered != 0)) {
9318                 return WERR_INVALID_PARAM;
9319         }
9320
9321         DEBUG(5,("_spoolss_GetPrintProcessorDirectory: level %d\n",
9322                 r->in.level));
9323
9324         *r->out.needed = 0;
9325
9326         /* r->in.level is ignored */
9327
9328         /* We always should reply with a local print processor directory so that
9329          * users are not forced to have a [prnproc$] share on the Samba spoolss
9330          * server - Guenther */
9331
9332         result = getprintprocessordirectory_level_1(p->mem_ctx,
9333                                                     NULL, /* r->in.server */
9334                                                     r->in.environment,
9335                                                     &r->out.info->info1);
9336         if (!W_ERROR_IS_OK(result)) {
9337                 TALLOC_FREE(r->out.info);
9338                 return result;
9339         }
9340
9341         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_PrintProcessorDirectoryInfo, NULL,
9342                                                r->out.info, r->in.level);
9343         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
9344
9345         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
9346 }
9347
9348 /*******************************************************************
9349  ********************************************************************/
9350
9351 static bool push_monitorui_buf(TALLOC_CTX *mem_ctx, DATA_BLOB *buf,
9352                                const char *dllname)
9353 {
9354         enum ndr_err_code ndr_err;
9355         struct spoolss_MonitorUi ui;
9356
9357         ui.dll_name = dllname;
9358
9359         ndr_err = ndr_push_struct_blob(buf, mem_ctx, NULL, &ui,
9360                        (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorUi);
9361         if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9362                 NDR_PRINT_DEBUG(spoolss_MonitorUi, &ui);
9363         }
9364         return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9365 }
9366
9367 /*******************************************************************
9368  Streams the monitor UI DLL name in UNICODE
9369 *******************************************************************/
9370
9371 static WERROR xcvtcp_monitorui(TALLOC_CTX *mem_ctx,
9372                                NT_USER_TOKEN *token, DATA_BLOB *in,
9373                                DATA_BLOB *out, uint32_t *needed)
9374 {
9375         const char *dllname = "tcpmonui.dll";
9376
9377         *needed = (strlen(dllname)+1) * 2;
9378
9379         if (out->length < *needed) {
9380                 return WERR_INSUFFICIENT_BUFFER;
9381         }
9382
9383         if (!push_monitorui_buf(mem_ctx, out, dllname)) {
9384                 return WERR_NOMEM;
9385         }
9386
9387         return WERR_OK;
9388 }
9389
9390 /*******************************************************************
9391  ********************************************************************/
9392
9393 static bool pull_port_data_1(TALLOC_CTX *mem_ctx,
9394                              struct spoolss_PortData1 *port1,
9395                              const DATA_BLOB *buf)
9396 {
9397         enum ndr_err_code ndr_err;
9398         ndr_err = ndr_pull_struct_blob(buf, mem_ctx, NULL, port1,
9399                        (ndr_pull_flags_fn_t)ndr_pull_spoolss_PortData1);
9400         if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9401                 NDR_PRINT_DEBUG(spoolss_PortData1, port1);
9402         }
9403         return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9404 }
9405
9406 /*******************************************************************
9407  ********************************************************************/
9408
9409 static bool pull_port_data_2(TALLOC_CTX *mem_ctx,
9410                              struct spoolss_PortData2 *port2,
9411                              const DATA_BLOB *buf)
9412 {
9413         enum ndr_err_code ndr_err;
9414         ndr_err = ndr_pull_struct_blob(buf, mem_ctx, NULL, port2,
9415                        (ndr_pull_flags_fn_t)ndr_pull_spoolss_PortData2);
9416         if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9417                 NDR_PRINT_DEBUG(spoolss_PortData2, port2);
9418         }
9419         return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9420 }
9421
9422 /*******************************************************************
9423  Create a new TCP/IP port
9424 *******************************************************************/
9425
9426 static WERROR xcvtcp_addport(TALLOC_CTX *mem_ctx,
9427                              NT_USER_TOKEN *token, DATA_BLOB *in,
9428                              DATA_BLOB *out, uint32_t *needed)
9429 {
9430         struct spoolss_PortData1 port1;
9431         struct spoolss_PortData2 port2;
9432         char *device_uri = NULL;
9433         uint32_t version;
9434
9435         const char *portname;
9436         const char *hostaddress;
9437         const char *queue;
9438         uint32_t port_number;
9439         uint32_t protocol;
9440
9441         /* peek for spoolss_PortData version */
9442
9443         if (!in || (in->length < (128 + 4))) {
9444                 return WERR_GENERAL_FAILURE;
9445         }
9446
9447         version = IVAL(in->data, 128);
9448
9449         switch (version) {
9450                 case 1:
9451                         ZERO_STRUCT(port1);
9452
9453                         if (!pull_port_data_1(mem_ctx, &port1, in)) {
9454                                 return WERR_NOMEM;
9455                         }
9456
9457                         portname        = port1.portname;
9458                         hostaddress     = port1.hostaddress;
9459                         queue           = port1.queue;
9460                         protocol        = port1.protocol;
9461                         port_number     = port1.port_number;
9462
9463                         break;
9464                 case 2:
9465                         ZERO_STRUCT(port2);
9466
9467                         if (!pull_port_data_2(mem_ctx, &port2, in)) {
9468                                 return WERR_NOMEM;
9469                         }
9470
9471                         portname        = port2.portname;
9472                         hostaddress     = port2.hostaddress;
9473                         queue           = port2.queue;
9474                         protocol        = port2.protocol;
9475                         port_number     = port2.port_number;
9476
9477                         break;
9478                 default:
9479                         DEBUG(1,("xcvtcp_addport: "
9480                                 "unknown version of port_data: %d\n", version));
9481                         return WERR_UNKNOWN_PORT;
9482         }
9483
9484         /* create the device URI and call the add_port_hook() */
9485
9486         switch (protocol) {
9487         case PROTOCOL_RAWTCP_TYPE:
9488                 device_uri = talloc_asprintf(mem_ctx,
9489                                 "socket://%s:%d/", hostaddress,
9490                                 port_number);
9491                 break;
9492
9493         case PROTOCOL_LPR_TYPE:
9494                 device_uri = talloc_asprintf(mem_ctx,
9495                         "lpr://%s/%s", hostaddress, queue );
9496                 break;
9497
9498         default:
9499                 return WERR_UNKNOWN_PORT;
9500         }
9501
9502         if (!device_uri) {
9503                 return WERR_NOMEM;
9504         }
9505
9506         return add_port_hook(mem_ctx, token, portname, device_uri);
9507 }
9508
9509 /*******************************************************************
9510 *******************************************************************/
9511
9512 struct xcv_api_table xcvtcp_cmds[] = {
9513         { "MonitorUI",  xcvtcp_monitorui },
9514         { "AddPort",    xcvtcp_addport},
9515         { NULL,         NULL }
9516 };
9517
9518 static WERROR process_xcvtcp_command(TALLOC_CTX *mem_ctx,
9519                                      NT_USER_TOKEN *token, const char *command,
9520                                      DATA_BLOB *inbuf,
9521                                      DATA_BLOB *outbuf,
9522                                      uint32_t *needed )
9523 {
9524         int i;
9525
9526         DEBUG(10,("process_xcvtcp_command: Received command \"%s\"\n", command));
9527
9528         for ( i=0; xcvtcp_cmds[i].name; i++ ) {
9529                 if ( strcmp( command, xcvtcp_cmds[i].name ) == 0 )
9530                         return xcvtcp_cmds[i].fn(mem_ctx, token, inbuf, outbuf, needed);
9531         }
9532
9533         return WERR_BADFUNC;
9534 }
9535
9536 /*******************************************************************
9537 *******************************************************************/
9538 #if 0   /* don't support management using the "Local Port" monitor */
9539
9540 static WERROR xcvlocal_monitorui(TALLOC_CTX *mem_ctx,
9541                                  NT_USER_TOKEN *token, DATA_BLOB *in,
9542                                  DATA_BLOB *out, uint32_t *needed)
9543 {
9544         const char *dllname = "localui.dll";
9545
9546         *needed = (strlen(dllname)+1) * 2;
9547
9548         if (out->length < *needed) {
9549                 return WERR_INSUFFICIENT_BUFFER;
9550         }
9551
9552         if (!push_monitorui_buf(mem_ctx, out, dllname)) {
9553                 return WERR_NOMEM;
9554         }
9555
9556         return WERR_OK;
9557 }
9558
9559 /*******************************************************************
9560 *******************************************************************/
9561
9562 struct xcv_api_table xcvlocal_cmds[] = {
9563         { "MonitorUI",  xcvlocal_monitorui },
9564         { NULL,         NULL }
9565 };
9566 #else
9567 struct xcv_api_table xcvlocal_cmds[] = {
9568         { NULL,         NULL }
9569 };
9570 #endif
9571
9572
9573
9574 /*******************************************************************
9575 *******************************************************************/
9576
9577 static WERROR process_xcvlocal_command(TALLOC_CTX *mem_ctx,
9578                                        NT_USER_TOKEN *token, const char *command,
9579                                        DATA_BLOB *inbuf, DATA_BLOB *outbuf,
9580                                        uint32_t *needed)
9581 {
9582         int i;
9583
9584         DEBUG(10,("process_xcvlocal_command: Received command \"%s\"\n", command));
9585
9586         for ( i=0; xcvlocal_cmds[i].name; i++ ) {
9587                 if ( strcmp( command, xcvlocal_cmds[i].name ) == 0 )
9588                         return xcvlocal_cmds[i].fn(mem_ctx, token, inbuf, outbuf, needed);
9589         }
9590         return WERR_BADFUNC;
9591 }
9592
9593 /****************************************************************
9594  _spoolss_XcvData
9595 ****************************************************************/
9596
9597 WERROR _spoolss_XcvData(pipes_struct *p,
9598                         struct spoolss_XcvData *r)
9599 {
9600         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9601         DATA_BLOB out_data = data_blob_null;
9602         WERROR werror;
9603
9604         if (!Printer) {
9605                 DEBUG(2,("_spoolss_XcvData: Invalid handle (%s:%u:%u).\n",
9606                         OUR_HANDLE(r->in.handle)));
9607                 return WERR_BADFID;
9608         }
9609
9610         /* Has to be a handle to the TCP/IP port monitor */
9611
9612         if ( !(Printer->printer_type & (SPLHND_PORTMON_LOCAL|SPLHND_PORTMON_TCP)) ) {
9613                 DEBUG(2,("_spoolss_XcvData: Call only valid for Port Monitors\n"));
9614                 return WERR_BADFID;
9615         }
9616
9617         /* requires administrative access to the server */
9618
9619         if ( !(Printer->access_granted & SERVER_ACCESS_ADMINISTER) ) {
9620                 DEBUG(2,("_spoolss_XcvData: denied by handle permissions.\n"));
9621                 return WERR_ACCESS_DENIED;
9622         }
9623
9624         /* Allocate the outgoing buffer */
9625
9626         if (r->in.out_data_size) {
9627                 out_data = data_blob_talloc_zero(p->mem_ctx, r->in.out_data_size);
9628                 if (out_data.data == NULL) {
9629                         return WERR_NOMEM;
9630                 }
9631         }
9632
9633         switch ( Printer->printer_type ) {
9634         case SPLHND_PORTMON_TCP:
9635                 werror = process_xcvtcp_command(p->mem_ctx,
9636                                                 p->server_info->ptok,
9637                                                 r->in.function_name,
9638                                                 &r->in.in_data, &out_data,
9639                                                 r->out.needed);
9640                 break;
9641         case SPLHND_PORTMON_LOCAL:
9642                 werror = process_xcvlocal_command(p->mem_ctx,
9643                                                   p->server_info->ptok,
9644                                                   r->in.function_name,
9645                                                   &r->in.in_data, &out_data,
9646                                                   r->out.needed);
9647                 break;
9648         default:
9649                 werror = WERR_INVALID_PRINT_MONITOR;
9650         }
9651
9652         if (!W_ERROR_IS_OK(werror)) {
9653                 return werror;
9654         }
9655
9656         *r->out.status_code = 0;
9657
9658         memcpy(r->out.out_data, out_data.data, out_data.length);
9659
9660         return WERR_OK;
9661 }
9662
9663 /****************************************************************
9664  _spoolss_AddPrintProcessor
9665 ****************************************************************/
9666
9667 WERROR _spoolss_AddPrintProcessor(pipes_struct *p,
9668                                   struct spoolss_AddPrintProcessor *r)
9669 {
9670         /* for now, just indicate success and ignore the add.  We'll
9671            automatically set the winprint processor for printer
9672            entries later.  Used to debug the LexMark Optra S 1855 PCL
9673            driver --jerry */
9674
9675         return WERR_OK;
9676 }
9677
9678 /****************************************************************
9679  _spoolss_AddPort
9680 ****************************************************************/
9681
9682 WERROR _spoolss_AddPort(pipes_struct *p,
9683                         struct spoolss_AddPort *r)
9684 {
9685         /* do what w2k3 does */
9686
9687         return WERR_NOT_SUPPORTED;
9688 }
9689
9690 /****************************************************************
9691  _spoolss_GetPrinterDriver
9692 ****************************************************************/
9693
9694 WERROR _spoolss_GetPrinterDriver(pipes_struct *p,
9695                                  struct spoolss_GetPrinterDriver *r)
9696 {
9697         p->rng_fault_state = true;
9698         return WERR_NOT_SUPPORTED;
9699 }
9700
9701 /****************************************************************
9702  _spoolss_ReadPrinter
9703 ****************************************************************/
9704
9705 WERROR _spoolss_ReadPrinter(pipes_struct *p,
9706                             struct spoolss_ReadPrinter *r)
9707 {
9708         p->rng_fault_state = true;
9709         return WERR_NOT_SUPPORTED;
9710 }
9711
9712 /****************************************************************
9713  _spoolss_WaitForPrinterChange
9714 ****************************************************************/
9715
9716 WERROR _spoolss_WaitForPrinterChange(pipes_struct *p,
9717                                      struct spoolss_WaitForPrinterChange *r)
9718 {
9719         p->rng_fault_state = true;
9720         return WERR_NOT_SUPPORTED;
9721 }
9722
9723 /****************************************************************
9724  _spoolss_ConfigurePort
9725 ****************************************************************/
9726
9727 WERROR _spoolss_ConfigurePort(pipes_struct *p,
9728                               struct spoolss_ConfigurePort *r)
9729 {
9730         p->rng_fault_state = true;
9731         return WERR_NOT_SUPPORTED;
9732 }
9733
9734 /****************************************************************
9735  _spoolss_DeletePort
9736 ****************************************************************/
9737
9738 WERROR _spoolss_DeletePort(pipes_struct *p,
9739                            struct spoolss_DeletePort *r)
9740 {
9741         p->rng_fault_state = true;
9742         return WERR_NOT_SUPPORTED;
9743 }
9744
9745 /****************************************************************
9746  _spoolss_CreatePrinterIC
9747 ****************************************************************/
9748
9749 WERROR _spoolss_CreatePrinterIC(pipes_struct *p,
9750                                 struct spoolss_CreatePrinterIC *r)
9751 {
9752         p->rng_fault_state = true;
9753         return WERR_NOT_SUPPORTED;
9754 }
9755
9756 /****************************************************************
9757  _spoolss_PlayGDIScriptOnPrinterIC
9758 ****************************************************************/
9759
9760 WERROR _spoolss_PlayGDIScriptOnPrinterIC(pipes_struct *p,
9761                                          struct spoolss_PlayGDIScriptOnPrinterIC *r)
9762 {
9763         p->rng_fault_state = true;
9764         return WERR_NOT_SUPPORTED;
9765 }
9766
9767 /****************************************************************
9768  _spoolss_DeletePrinterIC
9769 ****************************************************************/
9770
9771 WERROR _spoolss_DeletePrinterIC(pipes_struct *p,
9772                                 struct spoolss_DeletePrinterIC *r)
9773 {
9774         p->rng_fault_state = true;
9775         return WERR_NOT_SUPPORTED;
9776 }
9777
9778 /****************************************************************
9779  _spoolss_AddPrinterConnection
9780 ****************************************************************/
9781
9782 WERROR _spoolss_AddPrinterConnection(pipes_struct *p,
9783                                      struct spoolss_AddPrinterConnection *r)
9784 {
9785         p->rng_fault_state = true;
9786         return WERR_NOT_SUPPORTED;
9787 }
9788
9789 /****************************************************************
9790  _spoolss_DeletePrinterConnection
9791 ****************************************************************/
9792
9793 WERROR _spoolss_DeletePrinterConnection(pipes_struct *p,
9794                                         struct spoolss_DeletePrinterConnection *r)
9795 {
9796         p->rng_fault_state = true;
9797         return WERR_NOT_SUPPORTED;
9798 }
9799
9800 /****************************************************************
9801  _spoolss_PrinterMessageBox
9802 ****************************************************************/
9803
9804 WERROR _spoolss_PrinterMessageBox(pipes_struct *p,
9805                                   struct spoolss_PrinterMessageBox *r)
9806 {
9807         p->rng_fault_state = true;
9808         return WERR_NOT_SUPPORTED;
9809 }
9810
9811 /****************************************************************
9812  _spoolss_AddMonitor
9813 ****************************************************************/
9814
9815 WERROR _spoolss_AddMonitor(pipes_struct *p,
9816                            struct spoolss_AddMonitor *r)
9817 {
9818         p->rng_fault_state = true;
9819         return WERR_NOT_SUPPORTED;
9820 }
9821
9822 /****************************************************************
9823  _spoolss_DeleteMonitor
9824 ****************************************************************/
9825
9826 WERROR _spoolss_DeleteMonitor(pipes_struct *p,
9827                               struct spoolss_DeleteMonitor *r)
9828 {
9829         p->rng_fault_state = true;
9830         return WERR_NOT_SUPPORTED;
9831 }
9832
9833 /****************************************************************
9834  _spoolss_DeletePrintProcessor
9835 ****************************************************************/
9836
9837 WERROR _spoolss_DeletePrintProcessor(pipes_struct *p,
9838                                      struct spoolss_DeletePrintProcessor *r)
9839 {
9840         p->rng_fault_state = true;
9841         return WERR_NOT_SUPPORTED;
9842 }
9843
9844 /****************************************************************
9845  _spoolss_AddPrintProvidor
9846 ****************************************************************/
9847
9848 WERROR _spoolss_AddPrintProvidor(pipes_struct *p,
9849                                  struct spoolss_AddPrintProvidor *r)
9850 {
9851         p->rng_fault_state = true;
9852         return WERR_NOT_SUPPORTED;
9853 }
9854
9855 /****************************************************************
9856  _spoolss_DeletePrintProvidor
9857 ****************************************************************/
9858
9859 WERROR _spoolss_DeletePrintProvidor(pipes_struct *p,
9860                                     struct spoolss_DeletePrintProvidor *r)
9861 {
9862         p->rng_fault_state = true;
9863         return WERR_NOT_SUPPORTED;
9864 }
9865
9866 /****************************************************************
9867  _spoolss_FindFirstPrinterChangeNotification
9868 ****************************************************************/
9869
9870 WERROR _spoolss_FindFirstPrinterChangeNotification(pipes_struct *p,
9871                                                    struct spoolss_FindFirstPrinterChangeNotification *r)
9872 {
9873         p->rng_fault_state = true;
9874         return WERR_NOT_SUPPORTED;
9875 }
9876
9877 /****************************************************************
9878  _spoolss_FindNextPrinterChangeNotification
9879 ****************************************************************/
9880
9881 WERROR _spoolss_FindNextPrinterChangeNotification(pipes_struct *p,
9882                                                   struct spoolss_FindNextPrinterChangeNotification *r)
9883 {
9884         p->rng_fault_state = true;
9885         return WERR_NOT_SUPPORTED;
9886 }
9887
9888 /****************************************************************
9889  _spoolss_RouterFindFirstPrinterChangeNotificationOld
9890 ****************************************************************/
9891
9892 WERROR _spoolss_RouterFindFirstPrinterChangeNotificationOld(pipes_struct *p,
9893                                                             struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
9894 {
9895         p->rng_fault_state = true;
9896         return WERR_NOT_SUPPORTED;
9897 }
9898
9899 /****************************************************************
9900  _spoolss_ReplyOpenPrinter
9901 ****************************************************************/
9902
9903 WERROR _spoolss_ReplyOpenPrinter(pipes_struct *p,
9904                                  struct spoolss_ReplyOpenPrinter *r)
9905 {
9906         p->rng_fault_state = true;
9907         return WERR_NOT_SUPPORTED;
9908 }
9909
9910 /****************************************************************
9911  _spoolss_RouterReplyPrinter
9912 ****************************************************************/
9913
9914 WERROR _spoolss_RouterReplyPrinter(pipes_struct *p,
9915                                    struct spoolss_RouterReplyPrinter *r)
9916 {
9917         p->rng_fault_state = true;
9918         return WERR_NOT_SUPPORTED;
9919 }
9920
9921 /****************************************************************
9922  _spoolss_ReplyClosePrinter
9923 ****************************************************************/
9924
9925 WERROR _spoolss_ReplyClosePrinter(pipes_struct *p,
9926                                   struct spoolss_ReplyClosePrinter *r)
9927 {
9928         p->rng_fault_state = true;
9929         return WERR_NOT_SUPPORTED;
9930 }
9931
9932 /****************************************************************
9933  _spoolss_AddPortEx
9934 ****************************************************************/
9935
9936 WERROR _spoolss_AddPortEx(pipes_struct *p,
9937                           struct spoolss_AddPortEx *r)
9938 {
9939         p->rng_fault_state = true;
9940         return WERR_NOT_SUPPORTED;
9941 }
9942
9943 /****************************************************************
9944  _spoolss_RouterFindFirstPrinterChangeNotification
9945 ****************************************************************/
9946
9947 WERROR _spoolss_RouterFindFirstPrinterChangeNotification(pipes_struct *p,
9948                                                          struct spoolss_RouterFindFirstPrinterChangeNotification *r)
9949 {
9950         p->rng_fault_state = true;
9951         return WERR_NOT_SUPPORTED;
9952 }
9953
9954 /****************************************************************
9955  _spoolss_SpoolerInit
9956 ****************************************************************/
9957
9958 WERROR _spoolss_SpoolerInit(pipes_struct *p,
9959                             struct spoolss_SpoolerInit *r)
9960 {
9961         p->rng_fault_state = true;
9962         return WERR_NOT_SUPPORTED;
9963 }
9964
9965 /****************************************************************
9966  _spoolss_ResetPrinterEx
9967 ****************************************************************/
9968
9969 WERROR _spoolss_ResetPrinterEx(pipes_struct *p,
9970                                struct spoolss_ResetPrinterEx *r)
9971 {
9972         p->rng_fault_state = true;
9973         return WERR_NOT_SUPPORTED;
9974 }
9975
9976 /****************************************************************
9977  _spoolss_RouterReplyPrinterEx
9978 ****************************************************************/
9979
9980 WERROR _spoolss_RouterReplyPrinterEx(pipes_struct *p,
9981                                      struct spoolss_RouterReplyPrinterEx *r)
9982 {
9983         p->rng_fault_state = true;
9984         return WERR_NOT_SUPPORTED;
9985 }
9986
9987 /****************************************************************
9988  _spoolss_44
9989 ****************************************************************/
9990
9991 WERROR _spoolss_44(pipes_struct *p,
9992                    struct spoolss_44 *r)
9993 {
9994         p->rng_fault_state = true;
9995         return WERR_NOT_SUPPORTED;
9996 }
9997
9998 /****************************************************************
9999  _spoolss_47
10000 ****************************************************************/
10001
10002 WERROR _spoolss_47(pipes_struct *p,
10003                    struct spoolss_47 *r)
10004 {
10005         p->rng_fault_state = true;
10006         return WERR_NOT_SUPPORTED;
10007 }
10008
10009 /****************************************************************
10010  _spoolss_4a
10011 ****************************************************************/
10012
10013 WERROR _spoolss_4a(pipes_struct *p,
10014                    struct spoolss_4a *r)
10015 {
10016         p->rng_fault_state = true;
10017         return WERR_NOT_SUPPORTED;
10018 }
10019
10020 /****************************************************************
10021  _spoolss_4b
10022 ****************************************************************/
10023
10024 WERROR _spoolss_4b(pipes_struct *p,
10025                    struct spoolss_4b *r)
10026 {
10027         p->rng_fault_state = true;
10028         return WERR_NOT_SUPPORTED;
10029 }
10030
10031 /****************************************************************
10032  _spoolss_4c
10033 ****************************************************************/
10034
10035 WERROR _spoolss_4c(pipes_struct *p,
10036                    struct spoolss_4c *r)
10037 {
10038         p->rng_fault_state = true;
10039         return WERR_NOT_SUPPORTED;
10040 }
10041
10042 /****************************************************************
10043  _spoolss_53
10044 ****************************************************************/
10045
10046 WERROR _spoolss_53(pipes_struct *p,
10047                    struct spoolss_53 *r)
10048 {
10049         p->rng_fault_state = true;
10050         return WERR_NOT_SUPPORTED;
10051 }
10052
10053 /****************************************************************
10054  _spoolss_55
10055 ****************************************************************/
10056
10057 WERROR _spoolss_55(pipes_struct *p,
10058                    struct spoolss_55 *r)
10059 {
10060         p->rng_fault_state = true;
10061         return WERR_NOT_SUPPORTED;
10062 }
10063
10064 /****************************************************************
10065  _spoolss_56
10066 ****************************************************************/
10067
10068 WERROR _spoolss_56(pipes_struct *p,
10069                    struct spoolss_56 *r)
10070 {
10071         p->rng_fault_state = true;
10072         return WERR_NOT_SUPPORTED;
10073 }
10074
10075 /****************************************************************
10076  _spoolss_57
10077 ****************************************************************/
10078
10079 WERROR _spoolss_57(pipes_struct *p,
10080                    struct spoolss_57 *r)
10081 {
10082         p->rng_fault_state = true;
10083         return WERR_NOT_SUPPORTED;
10084 }
10085
10086 /****************************************************************
10087  _spoolss_5a
10088 ****************************************************************/
10089
10090 WERROR _spoolss_5a(pipes_struct *p,
10091                    struct spoolss_5a *r)
10092 {
10093         p->rng_fault_state = true;
10094         return WERR_NOT_SUPPORTED;
10095 }
10096
10097 /****************************************************************
10098  _spoolss_5b
10099 ****************************************************************/
10100
10101 WERROR _spoolss_5b(pipes_struct *p,
10102                    struct spoolss_5b *r)
10103 {
10104         p->rng_fault_state = true;
10105         return WERR_NOT_SUPPORTED;
10106 }
10107
10108 /****************************************************************
10109  _spoolss_5c
10110 ****************************************************************/
10111
10112 WERROR _spoolss_5c(pipes_struct *p,
10113                    struct spoolss_5c *r)
10114 {
10115         p->rng_fault_state = true;
10116         return WERR_NOT_SUPPORTED;
10117 }
10118
10119 /****************************************************************
10120  _spoolss_5d
10121 ****************************************************************/
10122
10123 WERROR _spoolss_5d(pipes_struct *p,
10124                    struct spoolss_5d *r)
10125 {
10126         p->rng_fault_state = true;
10127         return WERR_NOT_SUPPORTED;
10128 }
10129
10130 /****************************************************************
10131  _spoolss_5e
10132 ****************************************************************/
10133
10134 WERROR _spoolss_5e(pipes_struct *p,
10135                    struct spoolss_5e *r)
10136 {
10137         p->rng_fault_state = true;
10138         return WERR_NOT_SUPPORTED;
10139 }
10140
10141 /****************************************************************
10142  _spoolss_5f
10143 ****************************************************************/
10144
10145 WERROR _spoolss_5f(pipes_struct *p,
10146                    struct spoolss_5f *r)
10147 {
10148         p->rng_fault_state = true;
10149         return WERR_NOT_SUPPORTED;
10150 }
10151
10152 /****************************************************************
10153  _spoolss_60
10154 ****************************************************************/
10155
10156 WERROR _spoolss_60(pipes_struct *p,
10157                    struct spoolss_60 *r)
10158 {
10159         p->rng_fault_state = true;
10160         return WERR_NOT_SUPPORTED;
10161 }
10162
10163 /****************************************************************
10164  _spoolss_61
10165 ****************************************************************/
10166
10167 WERROR _spoolss_61(pipes_struct *p,
10168                    struct spoolss_61 *r)
10169 {
10170         p->rng_fault_state = true;
10171         return WERR_NOT_SUPPORTED;
10172 }
10173
10174 /****************************************************************
10175  _spoolss_62
10176 ****************************************************************/
10177
10178 WERROR _spoolss_62(pipes_struct *p,
10179                    struct spoolss_62 *r)
10180 {
10181         p->rng_fault_state = true;
10182         return WERR_NOT_SUPPORTED;
10183 }
10184
10185 /****************************************************************
10186  _spoolss_63
10187 ****************************************************************/
10188
10189 WERROR _spoolss_63(pipes_struct *p,
10190                    struct spoolss_63 *r)
10191 {
10192         p->rng_fault_state = true;
10193         return WERR_NOT_SUPPORTED;
10194 }
10195
10196 /****************************************************************
10197  _spoolss_64
10198 ****************************************************************/
10199
10200 WERROR _spoolss_64(pipes_struct *p,
10201                    struct spoolss_64 *r)
10202 {
10203         p->rng_fault_state = true;
10204         return WERR_NOT_SUPPORTED;
10205 }
10206
10207 /****************************************************************
10208  _spoolss_65
10209 ****************************************************************/
10210
10211 WERROR _spoolss_65(pipes_struct *p,
10212                    struct spoolss_65 *r)
10213 {
10214         p->rng_fault_state = true;
10215         return WERR_NOT_SUPPORTED;
10216 }
10217
10218 /****************************************************************
10219  _spoolss_GetCorePrinterDrivers
10220 ****************************************************************/
10221
10222 WERROR _spoolss_GetCorePrinterDrivers(pipes_struct *p,
10223                                       struct spoolss_GetCorePrinterDrivers *r)
10224 {
10225         p->rng_fault_state = true;
10226         return WERR_NOT_SUPPORTED;
10227 }
10228
10229 /****************************************************************
10230  _spoolss_67
10231 ****************************************************************/
10232
10233 WERROR _spoolss_67(pipes_struct *p,
10234                    struct spoolss_67 *r)
10235 {
10236         p->rng_fault_state = true;
10237         return WERR_NOT_SUPPORTED;
10238 }
10239
10240 /****************************************************************
10241  _spoolss_GetPrinterDriverPackagePath
10242 ****************************************************************/
10243
10244 WERROR _spoolss_GetPrinterDriverPackagePath(pipes_struct *p,
10245                                             struct spoolss_GetPrinterDriverPackagePath *r)
10246 {
10247         p->rng_fault_state = true;
10248         return WERR_NOT_SUPPORTED;
10249 }
10250
10251 /****************************************************************
10252  _spoolss_69
10253 ****************************************************************/
10254
10255 WERROR _spoolss_69(pipes_struct *p,
10256                    struct spoolss_69 *r)
10257 {
10258         p->rng_fault_state = true;
10259         return WERR_NOT_SUPPORTED;
10260 }
10261
10262 /****************************************************************
10263  _spoolss_6a
10264 ****************************************************************/
10265
10266 WERROR _spoolss_6a(pipes_struct *p,
10267                    struct spoolss_6a *r)
10268 {
10269         p->rng_fault_state = true;
10270         return WERR_NOT_SUPPORTED;
10271 }
10272
10273 /****************************************************************
10274  _spoolss_6b
10275 ****************************************************************/
10276
10277 WERROR _spoolss_6b(pipes_struct *p,
10278                    struct spoolss_6b *r)
10279 {
10280         p->rng_fault_state = true;
10281         return WERR_NOT_SUPPORTED;
10282 }
10283
10284 /****************************************************************
10285  _spoolss_6c
10286 ****************************************************************/
10287
10288 WERROR _spoolss_6c(pipes_struct *p,
10289                    struct spoolss_6c *r)
10290 {
10291         p->rng_fault_state = true;
10292         return WERR_NOT_SUPPORTED;
10293 }
10294
10295 /****************************************************************
10296  _spoolss_6d
10297 ****************************************************************/
10298
10299 WERROR _spoolss_6d(pipes_struct *p,
10300                    struct spoolss_6d *r)
10301 {
10302         p->rng_fault_state = true;
10303         return WERR_NOT_SUPPORTED;
10304 }