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