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_1(TALLOC_CTX *mem_ctx,
4208                                        uint32_t flags,
4209                                        union spoolss_PrinterInfo **info_p,
4210                                        uint32_t *count)
4211 {
4212         int snum;
4213         int n_services = lp_numservices();
4214         union spoolss_PrinterInfo *info = NULL;
4215         WERROR result = WERR_OK;
4216
4217         DEBUG(4,("enum_all_printers_info_1\n"));
4218
4219         *count = 0;
4220
4221         for (snum=0; snum<n_services; snum++) {
4222
4223                 NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
4224                 struct spoolss_PrinterInfo1 info1;
4225
4226                 if (!snum_is_shared_printer(snum)) {
4227                         continue;
4228                 }
4229
4230                 DEBUG(4,("Found a printer in smb.conf: %s[%x]\n", lp_servicename(snum), snum));
4231
4232                 result = get_a_printer(NULL, &ntprinter, 2, lp_const_servicename(snum));
4233                 if (!W_ERROR_IS_OK(result)) {
4234                         continue;
4235                 }
4236
4237                 result = construct_printer_info1(info, ntprinter, flags, &info1, snum);
4238                 free_a_printer(&ntprinter,2);
4239                 if (!W_ERROR_IS_OK(result)) {
4240                         continue;
4241                 }
4242
4243                 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4244                                             union spoolss_PrinterInfo,
4245                                             *count + 1);
4246                 if (!info) {
4247                         DEBUG(2,("enum_all_printers_info_1: failed to enlarge printers buffer!\n"));
4248                         result = WERR_NOMEM;
4249                         goto out;
4250                 }
4251
4252                 DEBUG(4,("ReAlloced memory for [%d] PRINTER_INFO_1\n", *count));
4253
4254                 info[*count].info1 = info1;
4255                 (*count)++;
4256         }
4257
4258  out:
4259         if (!W_ERROR_IS_OK(result)) {
4260                 TALLOC_FREE(info);
4261                 *count = 0;
4262                 return result;
4263         }
4264
4265         *info_p = info;
4266
4267         return WERR_OK;
4268 }
4269
4270 /********************************************************************
4271  enum_all_printers_info_1_local.
4272 *********************************************************************/
4273
4274 static WERROR enum_all_printers_info_1_local(TALLOC_CTX *mem_ctx,
4275                                              union spoolss_PrinterInfo **info,
4276                                              uint32_t *count)
4277 {
4278         DEBUG(4,("enum_all_printers_info_1_local\n"));
4279
4280         return enum_all_printers_info_1(mem_ctx, PRINTER_ENUM_ICON8, info, count);
4281 }
4282
4283 /********************************************************************
4284  enum_all_printers_info_1_name.
4285 *********************************************************************/
4286
4287 static WERROR enum_all_printers_info_1_name(TALLOC_CTX *mem_ctx,
4288                                             const char *name,
4289                                             union spoolss_PrinterInfo **info,
4290                                             uint32_t *count)
4291 {
4292         const char *s = name;
4293
4294         DEBUG(4,("enum_all_printers_info_1_name\n"));
4295
4296         if ((name[0] == '\\') && (name[1] == '\\')) {
4297                 s = name + 2;
4298         }
4299
4300         if (!is_myname_or_ipaddr(s)) {
4301                 return WERR_INVALID_NAME;
4302         }
4303
4304         return enum_all_printers_info_1(mem_ctx, PRINTER_ENUM_ICON8, info, count);
4305 }
4306
4307 /********************************************************************
4308  enum_all_printers_info_1_network.
4309 *********************************************************************/
4310
4311 static WERROR enum_all_printers_info_1_network(TALLOC_CTX *mem_ctx,
4312                                                const char *name,
4313                                                union spoolss_PrinterInfo **info,
4314                                                uint32_t *count)
4315 {
4316         const char *s = name;
4317
4318         DEBUG(4,("enum_all_printers_info_1_network\n"));
4319
4320         /* If we respond to a enum_printers level 1 on our name with flags
4321            set to PRINTER_ENUM_REMOTE with a list of printers then these
4322            printers incorrectly appear in the APW browse list.
4323            Specifically the printers for the server appear at the workgroup
4324            level where all the other servers in the domain are
4325            listed. Windows responds to this call with a
4326            WERR_CAN_NOT_COMPLETE so we should do the same. */
4327
4328         if (name[0] == '\\' && name[1] == '\\') {
4329                  s = name + 2;
4330         }
4331
4332         if (is_myname_or_ipaddr(s)) {
4333                  return WERR_CAN_NOT_COMPLETE;
4334         }
4335
4336         return enum_all_printers_info_1(mem_ctx, PRINTER_ENUM_NAME, info, count);
4337 }
4338
4339 /********************************************************************
4340  * api_spoolss_enumprinters
4341  *
4342  * called from api_spoolss_enumprinters (see this to understand)
4343  ********************************************************************/
4344
4345 static WERROR enum_all_printers_info_2(TALLOC_CTX *mem_ctx,
4346                                        union spoolss_PrinterInfo **info_p,
4347                                        uint32_t *count)
4348 {
4349         int snum;
4350         int n_services = lp_numservices();
4351         union spoolss_PrinterInfo *info = NULL;
4352         WERROR result = WERR_OK;
4353
4354         *count = 0;
4355
4356         for (snum=0; snum<n_services; snum++) {
4357
4358                 struct spoolss_PrinterInfo2 info2;
4359                 NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
4360
4361                 if (!snum_is_shared_printer(snum)) {
4362                         continue;
4363                 }
4364
4365                 DEBUG(4,("Found a printer in smb.conf: %s[%x]\n", lp_servicename(snum), snum));
4366
4367                 result = get_a_printer(NULL, &ntprinter, 2, lp_const_servicename(snum));
4368                 if (!W_ERROR_IS_OK(result)) {
4369                         continue;
4370                 }
4371
4372                 result = construct_printer_info2(info, ntprinter, &info2, snum);
4373                 free_a_printer(&ntprinter, 2);
4374                 if (!W_ERROR_IS_OK(result)) {
4375                         continue;
4376                 }
4377
4378                 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4379                                             union spoolss_PrinterInfo,
4380                                             *count + 1);
4381                 if (!info) {
4382                         DEBUG(2,("enum_all_printers_info_2: failed to enlarge printers buffer!\n"));
4383                         result = WERR_NOMEM;
4384                         goto out;
4385                 }
4386
4387                 DEBUG(4,("ReAlloced memory for [%d] PRINTER_INFO_2\n", *count + 1));
4388
4389                 info[*count].info2 = info2;
4390
4391                 (*count)++;
4392         }
4393
4394  out:
4395         if (!W_ERROR_IS_OK(result)) {
4396                 TALLOC_FREE(info);
4397                 *count = 0;
4398                 return result;
4399         }
4400
4401         *info_p = info;
4402
4403         return WERR_OK;
4404 }
4405
4406 /********************************************************************
4407  * handle enumeration of printers at level 1
4408  ********************************************************************/
4409
4410 static WERROR enumprinters_level1(TALLOC_CTX *mem_ctx,
4411                                   uint32_t flags,
4412                                   const char *name,
4413                                   union spoolss_PrinterInfo **info,
4414                                   uint32_t *count)
4415 {
4416         /* Not all the flags are equals */
4417
4418         if (flags & PRINTER_ENUM_LOCAL) {
4419                 return enum_all_printers_info_1_local(mem_ctx, info, count);
4420         }
4421
4422         if (flags & PRINTER_ENUM_NAME) {
4423                 return enum_all_printers_info_1_name(mem_ctx, name, info, count);
4424         }
4425
4426         if (flags & PRINTER_ENUM_NETWORK) {
4427                 return enum_all_printers_info_1_network(mem_ctx, name, info, count);
4428         }
4429
4430         return WERR_OK; /* NT4sp5 does that */
4431 }
4432
4433 /********************************************************************
4434  * handle enumeration of printers at level 2
4435  ********************************************************************/
4436
4437 static WERROR enumprinters_level2(TALLOC_CTX *mem_ctx,
4438                                   uint32_t flags,
4439                                   const char *servername,
4440                                   union spoolss_PrinterInfo **info,
4441                                   uint32_t *count)
4442 {
4443         if (flags & PRINTER_ENUM_LOCAL) {
4444                 return enum_all_printers_info_2(mem_ctx, info, count);
4445         }
4446
4447         if (flags & PRINTER_ENUM_NAME) {
4448                 if (!is_myname_or_ipaddr(canon_servername(servername))) {
4449                         return WERR_INVALID_NAME;
4450                 }
4451
4452                 return enum_all_printers_info_2(mem_ctx, info, count);
4453         }
4454
4455         if (flags & PRINTER_ENUM_REMOTE) {
4456                 return WERR_UNKNOWN_LEVEL;
4457         }
4458
4459         return WERR_OK;
4460 }
4461
4462 /********************************************************************
4463  * handle enumeration of printers at level 5
4464  ********************************************************************/
4465
4466 static WERROR enumprinters_level5(TALLOC_CTX *mem_ctx,
4467                                   uint32_t flags,
4468                                   const char *servername,
4469                                   union spoolss_PrinterInfo **info,
4470                                   uint32_t *count)
4471 {
4472 /*      return enum_all_printers_info_5(mem_ctx, info, offered, needed, count);*/
4473         return WERR_OK;
4474 }
4475
4476 /****************************************************************
4477  _spoolss_EnumPrinters
4478 ****************************************************************/
4479
4480 WERROR _spoolss_EnumPrinters(pipes_struct *p,
4481                              struct spoolss_EnumPrinters *r)
4482 {
4483         const char *name;
4484         WERROR result;
4485
4486         /* that's an [in out] buffer */
4487
4488         if (!r->in.buffer && (r->in.offered != 0)) {
4489                 return WERR_INVALID_PARAM;
4490         }
4491
4492         DEBUG(4,("_spoolss_EnumPrinters\n"));
4493
4494         *r->out.needed = 0;
4495         *r->out.count = 0;
4496         *r->out.info = NULL;
4497
4498         /*
4499          * Level 1:
4500          *          flags==PRINTER_ENUM_NAME
4501          *           if name=="" then enumerates all printers
4502          *           if name!="" then enumerate the printer
4503          *          flags==PRINTER_ENUM_REMOTE
4504          *          name is NULL, enumerate printers
4505          * Level 2: name!="" enumerates printers, name can't be NULL
4506          * Level 3: doesn't exist
4507          * Level 4: does a local registry lookup
4508          * Level 5: same as Level 2
4509          */
4510
4511         name = talloc_strdup_upper(p->mem_ctx, r->in.server);
4512         W_ERROR_HAVE_NO_MEMORY(name);
4513
4514         switch (r->in.level) {
4515         case 1:
4516                 result = enumprinters_level1(p->mem_ctx, r->in.flags, name,
4517                                              r->out.info, r->out.count);
4518                 break;
4519         case 2:
4520                 result = enumprinters_level2(p->mem_ctx, r->in.flags, name,
4521                                              r->out.info, r->out.count);
4522                 break;
4523         case 5:
4524                 result = enumprinters_level5(p->mem_ctx, r->in.flags, name,
4525                                              r->out.info, r->out.count);
4526                 break;
4527         case 3:
4528         case 4:
4529                 result = WERR_OK; /* ??? */
4530                 break;
4531         default:
4532                 return WERR_UNKNOWN_LEVEL;
4533         }
4534
4535         if (!W_ERROR_IS_OK(result)) {
4536                 return result;
4537         }
4538
4539         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
4540                                                      spoolss_EnumPrinters, NULL,
4541                                                      *r->out.info, r->in.level,
4542                                                      *r->out.count);
4543         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
4544         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
4545
4546         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
4547 }
4548
4549 /****************************************************************
4550  _spoolss_GetPrinter
4551 ****************************************************************/
4552
4553 WERROR _spoolss_GetPrinter(pipes_struct *p,
4554                            struct spoolss_GetPrinter *r)
4555 {
4556         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
4557         NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
4558         WERROR result = WERR_OK;
4559
4560         int snum;
4561
4562         /* that's an [in out] buffer */
4563
4564         if (!r->in.buffer && (r->in.offered != 0)) {
4565                 return WERR_INVALID_PARAM;
4566         }
4567
4568         *r->out.needed = 0;
4569
4570         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
4571                 return WERR_BADFID;
4572         }
4573
4574         result = get_a_printer(Printer, &ntprinter, 2,
4575                                lp_const_servicename(snum));
4576         if (!W_ERROR_IS_OK(result)) {
4577                 return result;
4578         }
4579
4580         switch (r->in.level) {
4581         case 0:
4582                 result = construct_printer_info0(p->mem_ctx, ntprinter,
4583                                                  &r->out.info->info0, snum);
4584                 break;
4585         case 1:
4586                 result = construct_printer_info1(p->mem_ctx, ntprinter,
4587                                                  PRINTER_ENUM_ICON8,
4588                                                  &r->out.info->info1, snum);
4589                 break;
4590         case 2:
4591                 result = construct_printer_info2(p->mem_ctx, ntprinter,
4592                                                  &r->out.info->info2, snum);
4593                 break;
4594         case 3:
4595                 result = construct_printer_info3(p->mem_ctx, ntprinter,
4596                                                  &r->out.info->info3, snum);
4597                 break;
4598         case 4:
4599                 result = construct_printer_info4(p->mem_ctx, ntprinter,
4600                                                  &r->out.info->info4, snum);
4601                 break;
4602         case 5:
4603                 result = construct_printer_info5(p->mem_ctx, ntprinter,
4604                                                  &r->out.info->info5, snum);
4605                 break;
4606         case 6:
4607                 result = construct_printer_info6(p->mem_ctx, ntprinter,
4608                                                  &r->out.info->info6, snum);
4609                 break;
4610         case 7:
4611                 result = construct_printer_info7(p->mem_ctx, Printer,
4612                                                  &r->out.info->info7, snum);
4613                 break;
4614         default:
4615                 result = WERR_UNKNOWN_LEVEL;
4616                 break;
4617         }
4618
4619         free_a_printer(&ntprinter, 2);
4620
4621         if (!W_ERROR_IS_OK(result)) {
4622                 TALLOC_FREE(r->out.info);
4623                 return result;
4624         }
4625
4626         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_PrinterInfo, NULL,
4627                                                r->out.info, r->in.level);
4628         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
4629
4630         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
4631 }
4632
4633 /********************************************************************
4634  ********************************************************************/
4635
4636 static const char **string_array_from_driver_info(TALLOC_CTX *mem_ctx,
4637                                                   fstring *fstring_array,
4638                                                   const char *cservername)
4639 {
4640         int i, num_strings = 0;
4641         const char **array = NULL;
4642
4643         for (i=0; fstring_array && fstring_array[i][0] != '\0'; i++) {
4644
4645                 const char *str = talloc_asprintf(mem_ctx, "\\\\%s%s",
4646                                                   cservername, fstring_array[i]);
4647                 if (!str) {
4648                         TALLOC_FREE(array);
4649                         return NULL;
4650                 }
4651
4652
4653                 if (!add_string_to_array(mem_ctx, str, &array, &num_strings)) {
4654                         TALLOC_FREE(array);
4655                         return NULL;
4656                 }
4657         }
4658
4659         if (i > 0) {
4660                 ADD_TO_ARRAY(mem_ctx, const char *, NULL,
4661                              &array, &num_strings);
4662         }
4663
4664         return array;
4665 }
4666
4667 /********************************************************************
4668  * fill a spoolss_DriverInfo1 struct
4669  ********************************************************************/
4670
4671 static WERROR fill_printer_driver_info1(TALLOC_CTX *mem_ctx,
4672                                         struct spoolss_DriverInfo1 *r,
4673                                         const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
4674                                         const char *servername,
4675                                         const char *architecture)
4676 {
4677         r->driver_name          = talloc_strdup(mem_ctx, driver->info_3->name);
4678         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4679
4680         return WERR_OK;
4681 }
4682
4683 /********************************************************************
4684  * fill a spoolss_DriverInfo2 struct
4685  ********************************************************************/
4686
4687 static WERROR fill_printer_driver_info2(TALLOC_CTX *mem_ctx,
4688                                         struct spoolss_DriverInfo2 *r,
4689                                         const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
4690                                         const char *servername)
4691
4692 {
4693         const char *cservername = canon_servername(servername);
4694
4695         r->version              = driver->info_3->cversion;
4696
4697         r->driver_name          = talloc_strdup(mem_ctx, driver->info_3->name);
4698         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4699         r->architecture         = talloc_strdup(mem_ctx, driver->info_3->environment);
4700         W_ERROR_HAVE_NO_MEMORY(r->architecture);
4701
4702         if (strlen(driver->info_3->driverpath)) {
4703                 r->driver_path  = talloc_asprintf(mem_ctx, "\\\\%s%s",
4704                                 cservername, driver->info_3->driverpath);
4705         } else {
4706                 r->driver_path  = talloc_strdup(mem_ctx, "");
4707         }
4708         W_ERROR_HAVE_NO_MEMORY(r->driver_path);
4709
4710         if (strlen(driver->info_3->datafile)) {
4711                 r->data_file    = talloc_asprintf(mem_ctx, "\\\\%s%s",
4712                                 cservername, driver->info_3->datafile);
4713         } else {
4714                 r->data_file    = talloc_strdup(mem_ctx, "");
4715         }
4716         W_ERROR_HAVE_NO_MEMORY(r->data_file);
4717
4718         if (strlen(driver->info_3->configfile)) {
4719                 r->config_file  = talloc_asprintf(mem_ctx, "\\\\%s%s",
4720                                 cservername, driver->info_3->configfile);
4721         } else {
4722                 r->config_file  = talloc_strdup(mem_ctx, "");
4723         }
4724         W_ERROR_HAVE_NO_MEMORY(r->config_file);
4725
4726         return WERR_OK;
4727 }
4728
4729 /********************************************************************
4730  * fill a spoolss_DriverInfo3 struct
4731  ********************************************************************/
4732
4733 static WERROR fill_printer_driver_info3(TALLOC_CTX *mem_ctx,
4734                                         struct spoolss_DriverInfo3 *r,
4735                                         const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
4736                                         const char *servername)
4737 {
4738         const char *cservername = canon_servername(servername);
4739
4740         r->version              = driver->info_3->cversion;
4741
4742         r->driver_name          = talloc_strdup(mem_ctx, driver->info_3->name);
4743         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4744         r->architecture         = talloc_strdup(mem_ctx, driver->info_3->environment);
4745         W_ERROR_HAVE_NO_MEMORY(r->architecture);
4746
4747         if (strlen(driver->info_3->driverpath)) {
4748                 r->driver_path  = talloc_asprintf(mem_ctx, "\\\\%s%s",
4749                                 cservername, driver->info_3->driverpath);
4750         } else {
4751                 r->driver_path  = talloc_strdup(mem_ctx, "");
4752         }
4753         W_ERROR_HAVE_NO_MEMORY(r->driver_path);
4754
4755         if (strlen(driver->info_3->datafile)) {
4756                 r->data_file    = talloc_asprintf(mem_ctx, "\\\\%s%s",
4757                                 cservername, driver->info_3->datafile);
4758         } else {
4759                 r->data_file    = talloc_strdup(mem_ctx, "");
4760         }
4761         W_ERROR_HAVE_NO_MEMORY(r->data_file);
4762
4763         if (strlen(driver->info_3->configfile)) {
4764                 r->config_file  = talloc_asprintf(mem_ctx, "\\\\%s%s",
4765                                 cservername, driver->info_3->configfile);
4766         } else {
4767                 r->config_file  = talloc_strdup(mem_ctx, "");
4768         }
4769         W_ERROR_HAVE_NO_MEMORY(r->config_file);
4770
4771         if (strlen(driver->info_3->helpfile)) {
4772                 r->help_file    = talloc_asprintf(mem_ctx, "\\\\%s%s",
4773                                 cservername, driver->info_3->helpfile);
4774         } else {
4775                 r->help_file    = talloc_strdup(mem_ctx, "");
4776         }
4777         W_ERROR_HAVE_NO_MEMORY(r->config_file);
4778
4779         r->monitor_name         = talloc_strdup(mem_ctx, driver->info_3->monitorname);
4780         W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
4781         r->default_datatype     = talloc_strdup(mem_ctx, driver->info_3->defaultdatatype);
4782         W_ERROR_HAVE_NO_MEMORY(r->default_datatype);
4783
4784         r->dependent_files = string_array_from_driver_info(mem_ctx,
4785                                                            driver->info_3->dependentfiles,
4786                                                            cservername);
4787         return WERR_OK;
4788 }
4789
4790 /********************************************************************
4791  * fill a spoolss_DriverInfo6 struct
4792  ********************************************************************/
4793
4794 static WERROR fill_printer_driver_info6(TALLOC_CTX *mem_ctx,
4795                                         struct spoolss_DriverInfo6 *r,
4796                                         const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
4797                                         const char *servername)
4798 {
4799         const char *cservername = canon_servername(servername);
4800
4801         r->version              = driver->info_3->cversion;
4802
4803         r->driver_name          = talloc_strdup(mem_ctx, driver->info_3->name);
4804         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4805         r->architecture         = talloc_strdup(mem_ctx, driver->info_3->environment);
4806         W_ERROR_HAVE_NO_MEMORY(r->architecture);
4807
4808         if (strlen(driver->info_3->driverpath)) {
4809                 r->driver_path  = talloc_asprintf(mem_ctx, "\\\\%s%s",
4810                                 cservername, driver->info_3->driverpath);
4811         } else {
4812                 r->driver_path  = talloc_strdup(mem_ctx, "");
4813         }
4814         W_ERROR_HAVE_NO_MEMORY(r->driver_path);
4815
4816         if (strlen(driver->info_3->datafile)) {
4817                 r->data_file    = talloc_asprintf(mem_ctx, "\\\\%s%s",
4818                                 cservername, driver->info_3->datafile);
4819         } else {
4820                 r->data_file    = talloc_strdup(mem_ctx, "");
4821         }
4822         W_ERROR_HAVE_NO_MEMORY(r->data_file);
4823
4824         if (strlen(driver->info_3->configfile)) {
4825                 r->config_file  = talloc_asprintf(mem_ctx, "\\\\%s%s",
4826                                 cservername, driver->info_3->configfile);
4827         } else {
4828                 r->config_file  = talloc_strdup(mem_ctx, "");
4829         }
4830         W_ERROR_HAVE_NO_MEMORY(r->config_file);
4831
4832         if (strlen(driver->info_3->helpfile)) {
4833                 r->help_file    = talloc_asprintf(mem_ctx, "\\\\%s%s",
4834                                 cservername, driver->info_3->helpfile);
4835         } else {
4836                 r->help_file    = talloc_strdup(mem_ctx, "");
4837         }
4838         W_ERROR_HAVE_NO_MEMORY(r->config_file);
4839
4840         r->monitor_name         = talloc_strdup(mem_ctx, driver->info_3->monitorname);
4841         W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
4842         r->default_datatype     = talloc_strdup(mem_ctx, driver->info_3->defaultdatatype);
4843         W_ERROR_HAVE_NO_MEMORY(r->default_datatype);
4844
4845         r->dependent_files = string_array_from_driver_info(mem_ctx,
4846                                                            driver->info_3->dependentfiles,
4847                                                            cservername);
4848         r->previous_names = string_array_from_driver_info(mem_ctx,
4849                                                           NULL,
4850                                                           cservername);
4851
4852         r->driver_date          = 0;
4853         r->driver_version       = 0;
4854
4855         r->manufacturer_name    = talloc_strdup(mem_ctx, "");
4856         W_ERROR_HAVE_NO_MEMORY(r->manufacturer_name);
4857         r->manufacturer_url     = talloc_strdup(mem_ctx, "");
4858         W_ERROR_HAVE_NO_MEMORY(r->manufacturer_url);
4859         r->hardware_id          = talloc_strdup(mem_ctx, "");
4860         W_ERROR_HAVE_NO_MEMORY(r->hardware_id);
4861         r->provider             = talloc_strdup(mem_ctx, "");
4862         W_ERROR_HAVE_NO_MEMORY(r->provider);
4863
4864         return WERR_OK;
4865 }
4866
4867 /********************************************************************
4868  * construct_printer_driver_info_1
4869  ********************************************************************/
4870
4871 static WERROR construct_printer_driver_info_1(TALLOC_CTX *mem_ctx,
4872                                               struct spoolss_DriverInfo1 *r,
4873                                               int snum,
4874                                               const char *servername,
4875                                               const char *architecture,
4876                                               uint32_t version)
4877 {
4878         NT_PRINTER_INFO_LEVEL *printer = NULL;
4879         NT_PRINTER_DRIVER_INFO_LEVEL driver;
4880         WERROR result;
4881
4882         ZERO_STRUCT(driver);
4883
4884         if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, lp_const_servicename(snum))))
4885                 return WERR_INVALID_PRINTER_NAME;
4886
4887         if (!W_ERROR_IS_OK(get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version))) {
4888                 free_a_printer(&printer, 2);
4889                 return WERR_UNKNOWN_PRINTER_DRIVER;
4890         }
4891
4892         result = fill_printer_driver_info1(mem_ctx, r, &driver, servername, architecture);
4893
4894         free_a_printer(&printer,2);
4895
4896         return result;
4897 }
4898
4899 /********************************************************************
4900  * construct_printer_driver_info_2
4901  * fill a printer_info_2 struct
4902  ********************************************************************/
4903
4904 static WERROR construct_printer_driver_info_2(TALLOC_CTX *mem_ctx,
4905                                               struct spoolss_DriverInfo2 *r,
4906                                               int snum,
4907                                               const char *servername,
4908                                               const char *architecture,
4909                                               uint32_t version)
4910 {
4911         NT_PRINTER_INFO_LEVEL *printer = NULL;
4912         NT_PRINTER_DRIVER_INFO_LEVEL driver;
4913         WERROR result;
4914
4915         ZERO_STRUCT(printer);
4916         ZERO_STRUCT(driver);
4917
4918         if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, lp_const_servicename(snum))))
4919                 return WERR_INVALID_PRINTER_NAME;
4920
4921         if (!W_ERROR_IS_OK(get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version))) {
4922                 free_a_printer(&printer, 2);
4923                 return WERR_UNKNOWN_PRINTER_DRIVER;
4924         }
4925
4926         result = fill_printer_driver_info2(mem_ctx, r, &driver, servername);
4927
4928         free_a_printer(&printer,2);
4929
4930         return result;
4931 }
4932
4933 /********************************************************************
4934  * construct_printer_info_3
4935  * fill a printer_info_3 struct
4936  ********************************************************************/
4937
4938 static WERROR construct_printer_driver_info_3(TALLOC_CTX *mem_ctx,
4939                                               struct spoolss_DriverInfo3 *r,
4940                                               int snum,
4941                                               const char *servername,
4942                                               const char *architecture,
4943                                               uint32_t version)
4944 {
4945         NT_PRINTER_INFO_LEVEL *printer = NULL;
4946         NT_PRINTER_DRIVER_INFO_LEVEL driver;
4947         WERROR status;
4948         ZERO_STRUCT(driver);
4949
4950         status=get_a_printer(NULL, &printer, 2, lp_const_servicename(snum) );
4951         DEBUG(8,("construct_printer_driver_info_3: status: %s\n", win_errstr(status)));
4952         if (!W_ERROR_IS_OK(status))
4953                 return WERR_INVALID_PRINTER_NAME;
4954
4955         status=get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
4956         DEBUG(8,("construct_printer_driver_info_3: status: %s\n", win_errstr(status)));
4957
4958 #if 0   /* JERRY */
4959
4960         /*
4961          * I put this code in during testing.  Helpful when commenting out the
4962          * support for DRIVER_INFO_6 in regards to win2k.  Not needed in general
4963          * as win2k always queries the driver using an infor level of 6.
4964          * I've left it in (but ifdef'd out) because I'll probably
4965          * use it in experimentation again in the future.   --jerry 22/01/2002
4966          */
4967
4968         if (!W_ERROR_IS_OK(status)) {
4969                 /*
4970                  * Is this a W2k client ?
4971                  */
4972                 if (version == 3) {
4973                         /* Yes - try again with a WinNT driver. */
4974                         version = 2;
4975                         status=get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
4976                         DEBUG(8,("construct_printer_driver_info_3: status: %s\n", win_errstr(status)));
4977                 }
4978 #endif
4979
4980                 if (!W_ERROR_IS_OK(status)) {
4981                         free_a_printer(&printer,2);
4982                         return WERR_UNKNOWN_PRINTER_DRIVER;
4983                 }
4984
4985 #if 0   /* JERRY */
4986         }
4987 #endif
4988
4989
4990         status = fill_printer_driver_info3(mem_ctx, r, &driver, servername);
4991
4992         free_a_printer(&printer,2);
4993
4994         return status;
4995 }
4996
4997 /********************************************************************
4998  * construct_printer_info_6
4999  * fill a printer_info_6 struct
5000  ********************************************************************/
5001
5002 static WERROR construct_printer_driver_info_6(TALLOC_CTX *mem_ctx,
5003                                               struct spoolss_DriverInfo6 *r,
5004                                               int snum,
5005                                               const char *servername,
5006                                               const char *architecture,
5007                                               uint32_t version)
5008 {
5009         NT_PRINTER_INFO_LEVEL           *printer = NULL;
5010         NT_PRINTER_DRIVER_INFO_LEVEL    driver;
5011         WERROR                          status;
5012
5013         ZERO_STRUCT(driver);
5014
5015         status=get_a_printer(NULL, &printer, 2, lp_const_servicename(snum) );
5016
5017         DEBUG(8,("construct_printer_driver_info_6: status: %s\n", win_errstr(status)));
5018
5019         if (!W_ERROR_IS_OK(status))
5020                 return WERR_INVALID_PRINTER_NAME;
5021
5022         status = get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
5023
5024         DEBUG(8,("construct_printer_driver_info_6: status: %s\n", win_errstr(status)));
5025
5026         if (!W_ERROR_IS_OK(status))
5027         {
5028                 /*
5029                  * Is this a W2k client ?
5030                  */
5031
5032                 if (version < 3) {
5033                         free_a_printer(&printer,2);
5034                         return WERR_UNKNOWN_PRINTER_DRIVER;
5035                 }
5036
5037                 /* Yes - try again with a WinNT driver. */
5038                 version = 2;
5039                 status=get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
5040                 DEBUG(8,("construct_printer_driver_info_6: status: %s\n", win_errstr(status)));
5041                 if (!W_ERROR_IS_OK(status)) {
5042                         free_a_printer(&printer,2);
5043                         return WERR_UNKNOWN_PRINTER_DRIVER;
5044                 }
5045         }
5046
5047         status = fill_printer_driver_info6(mem_ctx, r, &driver, servername);
5048
5049         free_a_printer(&printer,2);
5050         free_a_printer_driver(driver, 3);
5051
5052         return status;
5053 }
5054
5055 /****************************************************************
5056  _spoolss_GetPrinterDriver2
5057 ****************************************************************/
5058
5059 WERROR _spoolss_GetPrinterDriver2(pipes_struct *p,
5060                                   struct spoolss_GetPrinterDriver2 *r)
5061 {
5062         Printer_entry *printer;
5063         WERROR result;
5064
5065         const char *servername;
5066         int snum;
5067
5068         /* that's an [in out] buffer */
5069
5070         if (!r->in.buffer && (r->in.offered != 0)) {
5071                 return WERR_INVALID_PARAM;
5072         }
5073
5074         DEBUG(4,("_spoolss_GetPrinterDriver2\n"));
5075
5076         if (!(printer = find_printer_index_by_hnd(p, r->in.handle))) {
5077                 DEBUG(0,("_spoolss_GetPrinterDriver2: invalid printer handle!\n"));
5078                 return WERR_INVALID_PRINTER_NAME;
5079         }
5080
5081         *r->out.needed = 0;
5082         *r->out.server_major_version = 0;
5083         *r->out.server_minor_version = 0;
5084
5085         servername = get_server_name(printer);
5086
5087         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5088                 return WERR_BADFID;
5089         }
5090
5091         switch (r->in.level) {
5092         case 1:
5093                 result = construct_printer_driver_info_1(p->mem_ctx,
5094                                                          &r->out.info->info1,
5095                                                          snum,
5096                                                          servername,
5097                                                          r->in.architecture,
5098                                                          r->in.client_major_version);
5099                 break;
5100         case 2:
5101                 result = construct_printer_driver_info_2(p->mem_ctx,
5102                                                          &r->out.info->info2,
5103                                                          snum,
5104                                                          servername,
5105                                                          r->in.architecture,
5106                                                          r->in.client_major_version);
5107                 break;
5108         case 3:
5109                 result = construct_printer_driver_info_3(p->mem_ctx,
5110                                                          &r->out.info->info3,
5111                                                          snum,
5112                                                          servername,
5113                                                          r->in.architecture,
5114                                                          r->in.client_major_version);
5115                 break;
5116         case 6:
5117                 result = construct_printer_driver_info_6(p->mem_ctx,
5118                                                          &r->out.info->info6,
5119                                                          snum,
5120                                                          servername,
5121                                                          r->in.architecture,
5122                                                          r->in.client_major_version);
5123                 break;
5124         default:
5125 #if 0   /* JERRY */
5126         case 101:
5127                 /* apparently this call is the equivalent of
5128                    EnumPrinterDataEx() for the DsDriver key */
5129                 break;
5130 #endif
5131                 result = WERR_UNKNOWN_LEVEL;
5132                 break;
5133         }
5134
5135         if (!W_ERROR_IS_OK(result)) {
5136                 TALLOC_FREE(r->out.info);
5137                 return result;
5138         }
5139
5140         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_DriverInfo, NULL,
5141                                                r->out.info, r->in.level);
5142         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
5143
5144         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
5145 }
5146
5147
5148 /****************************************************************
5149  _spoolss_StartPagePrinter
5150 ****************************************************************/
5151
5152 WERROR _spoolss_StartPagePrinter(pipes_struct *p,
5153                                  struct spoolss_StartPagePrinter *r)
5154 {
5155         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5156
5157         if (!Printer) {
5158                 DEBUG(3,("_spoolss_StartPagePrinter: "
5159                         "Error in startpageprinter printer handle\n"));
5160                 return WERR_BADFID;
5161         }
5162
5163         Printer->page_started = true;
5164         return WERR_OK;
5165 }
5166
5167 /****************************************************************
5168  _spoolss_EndPagePrinter
5169 ****************************************************************/
5170
5171 WERROR _spoolss_EndPagePrinter(pipes_struct *p,
5172                                struct spoolss_EndPagePrinter *r)
5173 {
5174         int snum;
5175
5176         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5177
5178         if (!Printer) {
5179                 DEBUG(2,("_spoolss_EndPagePrinter: Invalid handle (%s:%u:%u).\n",
5180                         OUR_HANDLE(r->in.handle)));
5181                 return WERR_BADFID;
5182         }
5183
5184         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5185                 return WERR_BADFID;
5186
5187         Printer->page_started = false;
5188         print_job_endpage(snum, Printer->jobid);
5189
5190         return WERR_OK;
5191 }
5192
5193 /****************************************************************
5194  _spoolss_StartDocPrinter
5195 ****************************************************************/
5196
5197 WERROR _spoolss_StartDocPrinter(pipes_struct *p,
5198                                 struct spoolss_StartDocPrinter *r)
5199 {
5200         struct spoolss_DocumentInfo1 *info_1;
5201         int snum;
5202         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5203
5204         if (!Printer) {
5205                 DEBUG(2,("_spoolss_StartDocPrinter: "
5206                         "Invalid handle (%s:%u:%u)\n",
5207                         OUR_HANDLE(r->in.handle)));
5208                 return WERR_BADFID;
5209         }
5210
5211         if (r->in.level != 1) {
5212                 return WERR_UNKNOWN_LEVEL;
5213         }
5214
5215         info_1 = r->in.info.info1;
5216
5217         /*
5218          * a nice thing with NT is it doesn't listen to what you tell it.
5219          * when asked to send _only_ RAW datas, it tries to send datas
5220          * in EMF format.
5221          *
5222          * So I add checks like in NT Server ...
5223          */
5224
5225         if (info_1->datatype) {
5226                 if (strcmp(info_1->datatype, "RAW") != 0) {
5227                         *r->out.job_id = 0;
5228                         return WERR_INVALID_DATATYPE;
5229                 }
5230         }
5231
5232         /* get the share number of the printer */
5233         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5234                 return WERR_BADFID;
5235         }
5236
5237         Printer->jobid = print_job_start(p->server_info, snum,
5238                                          info_1->document_name,
5239                                          Printer->nt_devmode);
5240
5241         /* An error occured in print_job_start() so return an appropriate
5242            NT error code. */
5243
5244         if (Printer->jobid == -1) {
5245                 return map_werror_from_unix(errno);
5246         }
5247
5248         Printer->document_started = true;
5249         *r->out.job_id = Printer->jobid;
5250
5251         return WERR_OK;
5252 }
5253
5254 /****************************************************************
5255  _spoolss_EndDocPrinter
5256 ****************************************************************/
5257
5258 WERROR _spoolss_EndDocPrinter(pipes_struct *p,
5259                               struct spoolss_EndDocPrinter *r)
5260 {
5261         return _spoolss_enddocprinter_internal(p, r->in.handle);
5262 }
5263
5264 /****************************************************************
5265  _spoolss_WritePrinter
5266 ****************************************************************/
5267
5268 WERROR _spoolss_WritePrinter(pipes_struct *p,
5269                              struct spoolss_WritePrinter *r)
5270 {
5271         uint32_t buffer_written;
5272         int snum;
5273         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5274
5275         if (!Printer) {
5276                 DEBUG(2,("_spoolss_WritePrinter: Invalid handle (%s:%u:%u)\n",
5277                         OUR_HANDLE(r->in.handle)));
5278                 *r->out.num_written = r->in._data_size;
5279                 return WERR_BADFID;
5280         }
5281
5282         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5283                 return WERR_BADFID;
5284
5285         buffer_written = (uint32_t)print_job_write(snum, Printer->jobid,
5286                                                    (const char *)r->in.data.data,
5287                                                    (SMB_OFF_T)-1,
5288                                                    (size_t)r->in._data_size);
5289         if (buffer_written == (uint32_t)-1) {
5290                 *r->out.num_written = 0;
5291                 if (errno == ENOSPC)
5292                         return WERR_NO_SPOOL_SPACE;
5293                 else
5294                         return WERR_ACCESS_DENIED;
5295         }
5296
5297         *r->out.num_written = r->in._data_size;
5298
5299         return WERR_OK;
5300 }
5301
5302 /********************************************************************
5303  * api_spoolss_getprinter
5304  * called from the spoolss dispatcher
5305  *
5306  ********************************************************************/
5307
5308 static WERROR control_printer(struct policy_handle *handle, uint32_t command,
5309                               pipes_struct *p)
5310 {
5311         int snum;
5312         WERROR errcode = WERR_BADFUNC;
5313         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5314
5315         if (!Printer) {
5316                 DEBUG(2,("control_printer: Invalid handle (%s:%u:%u)\n",
5317                         OUR_HANDLE(handle)));
5318                 return WERR_BADFID;
5319         }
5320
5321         if (!get_printer_snum(p, handle, &snum, NULL))
5322                 return WERR_BADFID;
5323
5324         switch (command) {
5325         case SPOOLSS_PRINTER_CONTROL_PAUSE:
5326                 if (print_queue_pause(p->server_info, snum, &errcode)) {
5327                         errcode = WERR_OK;
5328                 }
5329                 break;
5330         case SPOOLSS_PRINTER_CONTROL_RESUME:
5331         case SPOOLSS_PRINTER_CONTROL_UNPAUSE:
5332                 if (print_queue_resume(p->server_info, snum, &errcode)) {
5333                         errcode = WERR_OK;
5334                 }
5335                 break;
5336         case SPOOLSS_PRINTER_CONTROL_PURGE:
5337                 if (print_queue_purge(p->server_info, snum, &errcode)) {
5338                         errcode = WERR_OK;
5339                 }
5340                 break;
5341         default:
5342                 return WERR_UNKNOWN_LEVEL;
5343         }
5344
5345         return errcode;
5346 }
5347
5348
5349 /****************************************************************
5350  _spoolss_AbortPrinter
5351  * From MSDN: "Deletes printer's spool file if printer is configured
5352  * for spooling"
5353 ****************************************************************/
5354
5355 WERROR _spoolss_AbortPrinter(pipes_struct *p,
5356                              struct spoolss_AbortPrinter *r)
5357 {
5358         Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
5359         int             snum;
5360         WERROR          errcode = WERR_OK;
5361
5362         if (!Printer) {
5363                 DEBUG(2,("_spoolss_AbortPrinter: Invalid handle (%s:%u:%u)\n",
5364                         OUR_HANDLE(r->in.handle)));
5365                 return WERR_BADFID;
5366         }
5367
5368         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5369                 return WERR_BADFID;
5370
5371         print_job_delete(p->server_info, snum, Printer->jobid, &errcode );
5372
5373         return errcode;
5374 }
5375
5376 /********************************************************************
5377  * called by spoolss_api_setprinter
5378  * when updating a printer description
5379  ********************************************************************/
5380
5381 static WERROR update_printer_sec(struct policy_handle *handle,
5382                                  pipes_struct *p, SEC_DESC_BUF *secdesc_ctr)
5383 {
5384         SEC_DESC_BUF *new_secdesc_ctr = NULL, *old_secdesc_ctr = NULL;
5385         WERROR result;
5386         int snum;
5387
5388         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5389
5390         if (!Printer || !get_printer_snum(p, handle, &snum, NULL)) {
5391                 DEBUG(2,("update_printer_sec: Invalid handle (%s:%u:%u)\n",
5392                          OUR_HANDLE(handle)));
5393
5394                 result = WERR_BADFID;
5395                 goto done;
5396         }
5397
5398         if (!secdesc_ctr) {
5399                 DEBUG(10,("update_printer_sec: secdesc_ctr is NULL !\n"));
5400                 result = WERR_INVALID_PARAM;
5401                 goto done;
5402         }
5403
5404         /* Check the user has permissions to change the security
5405            descriptor.  By experimentation with two NT machines, the user
5406            requires Full Access to the printer to change security
5407            information. */
5408
5409         if ( Printer->access_granted != PRINTER_ACCESS_ADMINISTER ) {
5410                 DEBUG(4,("update_printer_sec: updated denied by printer permissions\n"));
5411                 result = WERR_ACCESS_DENIED;
5412                 goto done;
5413         }
5414
5415         /* NT seems to like setting the security descriptor even though
5416            nothing may have actually changed. */
5417
5418         if ( !nt_printing_getsec(p->mem_ctx, Printer->sharename, &old_secdesc_ctr)) {
5419                 DEBUG(2,("update_printer_sec: nt_printing_getsec() failed\n"));
5420                 result = WERR_BADFID;
5421                 goto done;
5422         }
5423
5424         if (DEBUGLEVEL >= 10) {
5425                 SEC_ACL *the_acl;
5426                 int i;
5427
5428                 the_acl = old_secdesc_ctr->sd->dacl;
5429                 DEBUG(10, ("old_secdesc_ctr for %s has %d aces:\n",
5430                            PRINTERNAME(snum), the_acl->num_aces));
5431
5432                 for (i = 0; i < the_acl->num_aces; i++) {
5433                         DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
5434                                            &the_acl->aces[i].trustee),
5435                                   the_acl->aces[i].access_mask));
5436                 }
5437
5438                 the_acl = secdesc_ctr->sd->dacl;
5439
5440                 if (the_acl) {
5441                         DEBUG(10, ("secdesc_ctr for %s has %d aces:\n",
5442                                    PRINTERNAME(snum), the_acl->num_aces));
5443
5444                         for (i = 0; i < the_acl->num_aces; i++) {
5445                                 DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
5446                                                    &the_acl->aces[i].trustee),
5447                                            the_acl->aces[i].access_mask));
5448                         }
5449                 } else {
5450                         DEBUG(10, ("dacl for secdesc_ctr is NULL\n"));
5451                 }
5452         }
5453
5454         new_secdesc_ctr = sec_desc_merge(p->mem_ctx, secdesc_ctr, old_secdesc_ctr);
5455         if (!new_secdesc_ctr) {
5456                 result = WERR_NOMEM;
5457                 goto done;
5458         }
5459
5460         if (sec_desc_equal(new_secdesc_ctr->sd, old_secdesc_ctr->sd)) {
5461                 result = WERR_OK;
5462                 goto done;
5463         }
5464
5465         result = nt_printing_setsec(Printer->sharename, new_secdesc_ctr);
5466
5467  done:
5468
5469         return result;
5470 }
5471
5472 /********************************************************************
5473  Canonicalize printer info from a client
5474
5475  ATTN: It does not matter what we set the servername to hear
5476  since we do the necessary work in get_a_printer() to set it to
5477  the correct value based on what the client sent in the
5478  _spoolss_open_printer_ex().
5479  ********************************************************************/
5480
5481 static bool check_printer_ok(NT_PRINTER_INFO_LEVEL_2 *info, int snum)
5482 {
5483         fstring printername;
5484         const char *p;
5485
5486         DEBUG(5,("check_printer_ok: servername=%s printername=%s sharename=%s "
5487                 "portname=%s drivername=%s comment=%s location=%s\n",
5488                 info->servername, info->printername, info->sharename,
5489                 info->portname, info->drivername, info->comment, info->location));
5490
5491         /* we force some elements to "correct" values */
5492         slprintf(info->servername, sizeof(info->servername)-1, "\\\\%s", global_myname());
5493         fstrcpy(info->sharename, lp_servicename(snum));
5494
5495         /* check to see if we allow printername != sharename */
5496
5497         if ( lp_force_printername(snum) ) {
5498                 slprintf(info->printername, sizeof(info->printername)-1, "\\\\%s\\%s",
5499                         global_myname(), info->sharename );
5500         } else {
5501
5502                 /* make sure printername is in \\server\printername format */
5503
5504                 fstrcpy( printername, info->printername );
5505                 p = printername;
5506                 if ( printername[0] == '\\' && printername[1] == '\\' ) {
5507                         if ( (p = strchr_m( &printername[2], '\\' )) != NULL )
5508                                 p++;
5509                 }
5510
5511                 slprintf(info->printername, sizeof(info->printername)-1, "\\\\%s\\%s",
5512                          global_myname(), p );
5513         }
5514
5515         info->attributes |= PRINTER_ATTRIBUTE_SAMBA;
5516         info->attributes &= ~PRINTER_ATTRIBUTE_NOT_SAMBA;
5517
5518
5519
5520         return true;
5521 }
5522
5523 /****************************************************************************
5524 ****************************************************************************/
5525
5526 WERROR add_port_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, const char *portname, const char *uri )
5527 {
5528         char *cmd = lp_addport_cmd();
5529         char *command = NULL;
5530         int ret;
5531         SE_PRIV se_printop = SE_PRINT_OPERATOR;
5532         bool is_print_op = false;
5533
5534         if ( !*cmd ) {
5535                 return WERR_ACCESS_DENIED;
5536         }
5537
5538         command = talloc_asprintf(ctx,
5539                         "%s \"%s\" \"%s\"", cmd, portname, uri );
5540         if (!command) {
5541                 return WERR_NOMEM;
5542         }
5543
5544         if ( token )
5545                 is_print_op = user_has_privileges( token, &se_printop );
5546
5547         DEBUG(10,("Running [%s]\n", command));
5548
5549         /********* BEGIN SePrintOperatorPrivilege **********/
5550
5551         if ( is_print_op )
5552                 become_root();
5553
5554         ret = smbrun(command, NULL);
5555
5556         if ( is_print_op )
5557                 unbecome_root();
5558
5559         /********* END SePrintOperatorPrivilege **********/
5560
5561         DEBUGADD(10,("returned [%d]\n", ret));
5562
5563         TALLOC_FREE(command);
5564
5565         if ( ret != 0 ) {
5566                 return WERR_ACCESS_DENIED;
5567         }
5568
5569         return WERR_OK;
5570 }
5571
5572 /****************************************************************************
5573 ****************************************************************************/
5574
5575 bool add_printer_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, NT_PRINTER_INFO_LEVEL *printer)
5576 {
5577         char *cmd = lp_addprinter_cmd();
5578         char **qlines;
5579         char *command = NULL;
5580         int numlines;
5581         int ret;
5582         int fd;
5583         SE_PRIV se_printop = SE_PRINT_OPERATOR;
5584         bool is_print_op = false;
5585         char *remote_machine = talloc_strdup(ctx, "%m");
5586
5587         if (!remote_machine) {
5588                 return false;
5589         }
5590         remote_machine = talloc_sub_basic(ctx,
5591                                 current_user_info.smb_name,
5592                                 current_user_info.domain,
5593                                 remote_machine);
5594         if (!remote_machine) {
5595                 return false;
5596         }
5597
5598         command = talloc_asprintf(ctx,
5599                         "%s \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"",
5600                         cmd, printer->info_2->printername, printer->info_2->sharename,
5601                         printer->info_2->portname, printer->info_2->drivername,
5602                         printer->info_2->location, printer->info_2->comment, remote_machine);
5603         if (!command) {
5604                 return false;
5605         }
5606
5607         if ( token )
5608                 is_print_op = user_has_privileges( token, &se_printop );
5609
5610         DEBUG(10,("Running [%s]\n", command));
5611
5612         /********* BEGIN SePrintOperatorPrivilege **********/
5613
5614         if ( is_print_op )
5615                 become_root();
5616
5617         if ( (ret = smbrun(command, &fd)) == 0 ) {
5618                 /* Tell everyone we updated smb.conf. */
5619                 message_send_all(smbd_messaging_context(),
5620                                  MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
5621         }
5622
5623         if ( is_print_op )
5624                 unbecome_root();
5625
5626         /********* END SePrintOperatorPrivilege **********/
5627
5628         DEBUGADD(10,("returned [%d]\n", ret));
5629
5630         TALLOC_FREE(command);
5631         TALLOC_FREE(remote_machine);
5632
5633         if ( ret != 0 ) {
5634                 if (fd != -1)
5635                         close(fd);
5636                 return false;
5637         }
5638
5639         /* reload our services immediately */
5640         reload_services(false);
5641
5642         numlines = 0;
5643         /* Get lines and convert them back to dos-codepage */
5644         qlines = fd_lines_load(fd, &numlines, 0, NULL);
5645         DEBUGADD(10,("Lines returned = [%d]\n", numlines));
5646         close(fd);
5647
5648         /* Set the portname to what the script says the portname should be. */
5649         /* but don't require anything to be return from the script exit a good error code */
5650
5651         if (numlines) {
5652                 /* Set the portname to what the script says the portname should be. */
5653                 strncpy(printer->info_2->portname, qlines[0], sizeof(printer->info_2->portname));
5654                 DEBUGADD(6,("Line[0] = [%s]\n", qlines[0]));
5655         }
5656
5657         TALLOC_FREE(qlines);
5658         return true;
5659 }
5660
5661
5662 /********************************************************************
5663  * Called by spoolss_api_setprinter
5664  * when updating a printer description.
5665  ********************************************************************/
5666
5667 static WERROR update_printer(pipes_struct *p, struct policy_handle *handle,
5668                              struct spoolss_SetPrinterInfoCtr *info_ctr,
5669                              struct spoolss_DeviceMode *devmode)
5670 {
5671         int snum;
5672         NT_PRINTER_INFO_LEVEL *printer = NULL, *old_printer = NULL;
5673         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5674         WERROR result;
5675         UNISTR2 buffer;
5676         fstring asc_buffer;
5677
5678         DEBUG(8,("update_printer\n"));
5679
5680         result = WERR_OK;
5681
5682         if (!Printer) {
5683                 result = WERR_BADFID;
5684                 goto done;
5685         }
5686
5687         if (!get_printer_snum(p, handle, &snum, NULL)) {
5688                 result = WERR_BADFID;
5689                 goto done;
5690         }
5691
5692         if (!W_ERROR_IS_OK(get_a_printer(Printer, &printer, 2, lp_const_servicename(snum))) ||
5693             (!W_ERROR_IS_OK(get_a_printer(Printer, &old_printer, 2, lp_const_servicename(snum))))) {
5694                 result = WERR_BADFID;
5695                 goto done;
5696         }
5697
5698         DEBUGADD(8,("Converting info_2 struct\n"));
5699
5700         /*
5701          * convert_printer_info converts the incoming
5702          * info from the client and overwrites the info
5703          * just read from the tdb in the pointer 'printer'.
5704          */
5705
5706         if (!convert_printer_info(info_ctr, printer)) {
5707                 result =  WERR_NOMEM;
5708                 goto done;
5709         }
5710
5711         if (devmode) {
5712                 /* we have a valid devmode
5713                    convert it and link it*/
5714
5715                 DEBUGADD(8,("update_printer: Converting the devicemode struct\n"));
5716                 if (!convert_devicemode(printer->info_2->printername, devmode,
5717                                         &printer->info_2->devmode)) {
5718                         result =  WERR_NOMEM;
5719                         goto done;
5720                 }
5721         }
5722
5723         /* Do sanity check on the requested changes for Samba */
5724
5725         if (!check_printer_ok(printer->info_2, snum)) {
5726                 result = WERR_INVALID_PARAM;
5727                 goto done;
5728         }
5729
5730         /* FIXME!!! If the driver has changed we really should verify that
5731            it is installed before doing much else   --jerry */
5732
5733         /* Check calling user has permission to update printer description */
5734
5735         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
5736                 DEBUG(3, ("update_printer: printer property change denied by handle\n"));
5737                 result = WERR_ACCESS_DENIED;
5738                 goto done;
5739         }
5740
5741         /* Call addprinter hook */
5742         /* Check changes to see if this is really needed */
5743
5744         if ( *lp_addprinter_cmd()
5745                 && (!strequal(printer->info_2->drivername, old_printer->info_2->drivername)
5746                         || !strequal(printer->info_2->comment, old_printer->info_2->comment)
5747                         || !strequal(printer->info_2->portname, old_printer->info_2->portname)
5748                         || !strequal(printer->info_2->location, old_printer->info_2->location)) )
5749         {
5750                 /* add_printer_hook() will call reload_services() */
5751
5752                 if ( !add_printer_hook(p->mem_ctx, p->server_info->ptok,
5753                                        printer) ) {
5754                         result = WERR_ACCESS_DENIED;
5755                         goto done;
5756                 }
5757         }
5758
5759         /*
5760          * When a *new* driver is bound to a printer, the drivername is used to
5761          * lookup previously saved driver initialization info, which is then
5762          * bound to the printer, simulating what happens in the Windows arch.
5763          */
5764         if (!strequal(printer->info_2->drivername, old_printer->info_2->drivername))
5765         {
5766                 if (!set_driver_init(printer, 2))
5767                 {
5768                         DEBUG(5,("update_printer: Error restoring driver initialization data for driver [%s]!\n",
5769                                 printer->info_2->drivername));
5770                 }
5771
5772                 DEBUG(10,("update_printer: changing driver [%s]!  Sending event!\n",
5773                         printer->info_2->drivername));
5774
5775                 notify_printer_driver(snum, printer->info_2->drivername);
5776         }
5777
5778         /*
5779          * flag which changes actually occured.  This is a small subset of
5780          * all the possible changes.  We also have to update things in the
5781          * DsSpooler key.
5782          */
5783
5784         if (!strequal(printer->info_2->comment, old_printer->info_2->comment)) {
5785                 init_unistr2( &buffer, printer->info_2->comment, UNI_STR_TERMINATE);
5786                 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "description",
5787                         REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
5788
5789                 notify_printer_comment(snum, printer->info_2->comment);
5790         }
5791
5792         if (!strequal(printer->info_2->sharename, old_printer->info_2->sharename)) {
5793                 init_unistr2( &buffer, printer->info_2->sharename, UNI_STR_TERMINATE);
5794                 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "shareName",
5795                         REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
5796
5797                 notify_printer_sharename(snum, printer->info_2->sharename);
5798         }
5799
5800         if (!strequal(printer->info_2->printername, old_printer->info_2->printername)) {
5801                 char *pname;
5802
5803                 if ( (pname = strchr_m( printer->info_2->printername+2, '\\' )) != NULL )
5804                         pname++;
5805                 else
5806                         pname = printer->info_2->printername;
5807
5808
5809                 init_unistr2( &buffer, pname, UNI_STR_TERMINATE);
5810                 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "printerName",
5811                         REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
5812
5813                 notify_printer_printername( snum, pname );
5814         }
5815
5816         if (!strequal(printer->info_2->portname, old_printer->info_2->portname)) {
5817                 init_unistr2( &buffer, printer->info_2->portname, UNI_STR_TERMINATE);
5818                 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "portName",
5819                         REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
5820
5821                 notify_printer_port(snum, printer->info_2->portname);
5822         }
5823
5824         if (!strequal(printer->info_2->location, old_printer->info_2->location)) {
5825                 init_unistr2( &buffer, printer->info_2->location, UNI_STR_TERMINATE);
5826                 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "location",
5827                         REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
5828
5829                 notify_printer_location(snum, printer->info_2->location);
5830         }
5831
5832         /* here we need to update some more DsSpooler keys */
5833         /* uNCName, serverName, shortServerName */
5834
5835         init_unistr2( &buffer, global_myname(), UNI_STR_TERMINATE);
5836         set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "serverName",
5837                 REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
5838         set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "shortServerName",
5839                 REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
5840
5841         slprintf( asc_buffer, sizeof(asc_buffer)-1, "\\\\%s\\%s",
5842                  global_myname(), printer->info_2->sharename );
5843         init_unistr2( &buffer, asc_buffer, UNI_STR_TERMINATE);
5844         set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "uNCName",
5845                 REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
5846
5847         /* Update printer info */
5848         result = mod_a_printer(printer, 2);
5849
5850 done:
5851         free_a_printer(&printer, 2);
5852         free_a_printer(&old_printer, 2);
5853
5854
5855         return result;
5856 }
5857
5858 /****************************************************************************
5859 ****************************************************************************/
5860 static WERROR publish_or_unpublish_printer(pipes_struct *p,
5861                                            struct policy_handle *handle,
5862                                            struct spoolss_SetPrinterInfo7 *info7)
5863 {
5864 #ifdef HAVE_ADS
5865         int snum;
5866         Printer_entry *Printer;
5867
5868         if ( lp_security() != SEC_ADS ) {
5869                 return WERR_UNKNOWN_LEVEL;
5870         }
5871
5872         Printer = find_printer_index_by_hnd(p, handle);
5873
5874         DEBUG(5,("publish_or_unpublish_printer, action = %d\n",info7->action));
5875
5876         if (!Printer)
5877                 return WERR_BADFID;
5878
5879         if (!get_printer_snum(p, handle, &snum, NULL))
5880                 return WERR_BADFID;
5881
5882         nt_printer_publish(Printer, snum, info7->action);
5883
5884         return WERR_OK;
5885 #else
5886         return WERR_UNKNOWN_LEVEL;
5887 #endif
5888 }
5889
5890 /****************************************************************
5891  _spoolss_SetPrinter
5892 ****************************************************************/
5893
5894 WERROR _spoolss_SetPrinter(pipes_struct *p,
5895                            struct spoolss_SetPrinter *r)
5896 {
5897         WERROR result;
5898
5899         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5900
5901         if (!Printer) {
5902                 DEBUG(2,("_spoolss_SetPrinter: Invalid handle (%s:%u:%u)\n",
5903                         OUR_HANDLE(r->in.handle)));
5904                 return WERR_BADFID;
5905         }
5906
5907         /* check the level */
5908         switch (r->in.info_ctr->level) {
5909                 case 0:
5910                         return control_printer(r->in.handle, r->in.command, p);
5911                 case 2:
5912                         result = update_printer(p, r->in.handle,
5913                                                 r->in.info_ctr,
5914                                                 r->in.devmode_ctr->devmode);
5915                         if (!W_ERROR_IS_OK(result))
5916                                 return result;
5917                         if (r->in.secdesc_ctr->sd)
5918                                 result = update_printer_sec(r->in.handle, p,
5919                                                             r->in.secdesc_ctr);
5920                         return result;
5921                 case 3:
5922                         return update_printer_sec(r->in.handle, p,
5923                                                   r->in.secdesc_ctr);
5924                 case 7:
5925                         return publish_or_unpublish_printer(p, r->in.handle,
5926                                                             r->in.info_ctr->info.info7);
5927                 default:
5928                         return WERR_UNKNOWN_LEVEL;
5929         }
5930 }
5931
5932 /****************************************************************
5933  _spoolss_FindClosePrinterNotify
5934 ****************************************************************/
5935
5936 WERROR _spoolss_FindClosePrinterNotify(pipes_struct *p,
5937                                        struct spoolss_FindClosePrinterNotify *r)
5938 {
5939         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5940
5941         if (!Printer) {
5942                 DEBUG(2,("_spoolss_FindClosePrinterNotify: "
5943                         "Invalid handle (%s:%u:%u)\n", OUR_HANDLE(r->in.handle)));
5944                 return WERR_BADFID;
5945         }
5946
5947         if (Printer->notify.client_connected == true) {
5948                 int snum = -1;
5949
5950                 if ( Printer->printer_type == SPLHND_SERVER)
5951                         snum = -1;
5952                 else if ( (Printer->printer_type == SPLHND_PRINTER) &&
5953                                 !get_printer_snum(p, r->in.handle, &snum, NULL) )
5954                         return WERR_BADFID;
5955
5956                 srv_spoolss_replycloseprinter(snum, &Printer->notify.client_hnd);
5957         }
5958
5959         Printer->notify.flags=0;
5960         Printer->notify.options=0;
5961         Printer->notify.localmachine[0]='\0';
5962         Printer->notify.printerlocal=0;
5963         TALLOC_FREE(Printer->notify.option);
5964         Printer->notify.client_connected = false;
5965
5966         return WERR_OK;
5967 }
5968
5969 /****************************************************************
5970  _spoolss_AddJob
5971 ****************************************************************/
5972
5973 WERROR _spoolss_AddJob(pipes_struct *p,
5974                        struct spoolss_AddJob *r)
5975 {
5976         if (!r->in.buffer && (r->in.offered != 0)) {
5977                 return WERR_INVALID_PARAM;
5978         }
5979
5980         /* this is what a NT server returns for AddJob. AddJob must fail on
5981          * non-local printers */
5982
5983         if (r->in.level != 1) {
5984                 return WERR_UNKNOWN_LEVEL;
5985         }
5986
5987         return WERR_INVALID_PARAM;
5988 }
5989
5990 /****************************************************************************
5991 fill_job_info1
5992 ****************************************************************************/
5993
5994 static WERROR fill_job_info1(TALLOC_CTX *mem_ctx,
5995                              struct spoolss_JobInfo1 *r,
5996                              const print_queue_struct *queue,
5997                              int position, int snum,
5998                              const NT_PRINTER_INFO_LEVEL *ntprinter)
5999 {
6000         struct tm *t;
6001
6002         t = gmtime(&queue->time);
6003
6004         r->job_id               = queue->job;
6005
6006         r->printer_name         = talloc_strdup(mem_ctx, lp_servicename(snum));
6007         W_ERROR_HAVE_NO_MEMORY(r->printer_name);
6008         r->server_name          = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
6009         W_ERROR_HAVE_NO_MEMORY(r->server_name);
6010         r->user_name            = talloc_strdup(mem_ctx, queue->fs_user);
6011         W_ERROR_HAVE_NO_MEMORY(r->user_name);
6012         r->document_name        = talloc_strdup(mem_ctx, queue->fs_file);
6013         W_ERROR_HAVE_NO_MEMORY(r->document_name);
6014         r->data_type            = talloc_strdup(mem_ctx, "RAW");
6015         W_ERROR_HAVE_NO_MEMORY(r->data_type);
6016         r->text_status          = talloc_strdup(mem_ctx, "");
6017         W_ERROR_HAVE_NO_MEMORY(r->text_status);
6018
6019         r->status               = nt_printj_status(queue->status);
6020         r->priority             = queue->priority;
6021         r->position             = position;
6022         r->total_pages          = queue->page_count;
6023         r->pages_printed        = 0; /* ??? */
6024
6025         init_systemtime(&r->submitted, t);
6026
6027         return WERR_OK;
6028 }
6029
6030 /****************************************************************************
6031 fill_job_info2
6032 ****************************************************************************/
6033
6034 static WERROR fill_job_info2(TALLOC_CTX *mem_ctx,
6035                              struct spoolss_JobInfo2 *r,
6036                              const print_queue_struct *queue,
6037                              int position, int snum,
6038                              const NT_PRINTER_INFO_LEVEL *ntprinter,
6039                              struct spoolss_DeviceMode *devmode)
6040 {
6041         struct tm *t;
6042
6043         t = gmtime(&queue->time);
6044
6045         r->job_id               = queue->job;
6046
6047         r->printer_name         = talloc_strdup(mem_ctx, lp_servicename(snum));
6048         W_ERROR_HAVE_NO_MEMORY(r->printer_name);
6049         r->server_name          = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
6050         W_ERROR_HAVE_NO_MEMORY(r->server_name);
6051         r->user_name            = talloc_strdup(mem_ctx, queue->fs_user);
6052         W_ERROR_HAVE_NO_MEMORY(r->user_name);
6053         r->document_name        = talloc_strdup(mem_ctx, queue->fs_file);
6054         W_ERROR_HAVE_NO_MEMORY(r->document_name);
6055         r->notify_name          = talloc_strdup(mem_ctx, queue->fs_user);
6056         W_ERROR_HAVE_NO_MEMORY(r->notify_name);
6057         r->data_type            = talloc_strdup(mem_ctx, "RAW");
6058         W_ERROR_HAVE_NO_MEMORY(r->data_type);
6059         r->print_processor      = talloc_strdup(mem_ctx, "winprint");
6060         W_ERROR_HAVE_NO_MEMORY(r->print_processor);
6061         r->parameters           = talloc_strdup(mem_ctx, "");
6062         W_ERROR_HAVE_NO_MEMORY(r->parameters);
6063         r->driver_name          = talloc_strdup(mem_ctx, ntprinter->info_2->drivername);
6064         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
6065
6066         r->devmode              = devmode;
6067
6068         r->text_status          = talloc_strdup(mem_ctx, "");
6069         W_ERROR_HAVE_NO_MEMORY(r->text_status);
6070
6071         r->secdesc              = NULL;
6072
6073         r->status               = nt_printj_status(queue->status);
6074         r->priority             = queue->priority;
6075         r->position             = position;
6076         r->start_time           = 0;
6077         r->until_time           = 0;
6078         r->total_pages          = queue->page_count;
6079         r->size                 = queue->size;
6080         init_systemtime(&r->submitted, t);
6081         r->time                 = 0;
6082         r->pages_printed        = 0; /* ??? */
6083
6084         return WERR_OK;
6085 }
6086
6087 /****************************************************************************
6088  Enumjobs at level 1.
6089 ****************************************************************************/
6090
6091 static WERROR enumjobs_level1(TALLOC_CTX *mem_ctx,
6092                               const print_queue_struct *queue,
6093                               uint32_t num_queues, int snum,
6094                               const NT_PRINTER_INFO_LEVEL *ntprinter,
6095                               union spoolss_JobInfo **info_p,
6096                               uint32_t *count)
6097 {
6098         union spoolss_JobInfo *info;
6099         int i;
6100         WERROR result = WERR_OK;
6101
6102         info = TALLOC_ARRAY(mem_ctx, union spoolss_JobInfo, num_queues);
6103         W_ERROR_HAVE_NO_MEMORY(info);
6104
6105         *count = num_queues;
6106
6107         for (i=0; i<*count; i++) {
6108                 result = fill_job_info1(info,
6109                                         &info[i].info1,
6110                                         &queue[i],
6111                                         i,
6112                                         snum,
6113                                         ntprinter);
6114                 if (!W_ERROR_IS_OK(result)) {
6115                         goto out;
6116                 }
6117         }
6118
6119  out:
6120         if (!W_ERROR_IS_OK(result)) {
6121                 TALLOC_FREE(info);
6122                 *count = 0;
6123                 return result;
6124         }
6125
6126         *info_p = info;
6127
6128         return WERR_OK;
6129 }
6130
6131 /****************************************************************************
6132  Enumjobs at level 2.
6133 ****************************************************************************/
6134
6135 static WERROR enumjobs_level2(TALLOC_CTX *mem_ctx,
6136                               const print_queue_struct *queue,
6137                               uint32_t num_queues, int snum,
6138                               const NT_PRINTER_INFO_LEVEL *ntprinter,
6139                               union spoolss_JobInfo **info_p,
6140                               uint32_t *count)
6141 {
6142         union spoolss_JobInfo *info;
6143         int i;
6144         WERROR result = WERR_OK;
6145
6146         info = TALLOC_ARRAY(mem_ctx, union spoolss_JobInfo, num_queues);
6147         W_ERROR_HAVE_NO_MEMORY(info);
6148
6149         *count = num_queues;
6150
6151         for (i=0; i<*count; i++) {
6152
6153                 struct spoolss_DeviceMode *devmode;
6154
6155                 devmode = construct_dev_mode(info, lp_const_servicename(snum));
6156                 if (!devmode) {
6157                         result = WERR_NOMEM;
6158                         goto out;
6159                 }
6160
6161                 result = fill_job_info2(info,
6162                                         &info[i].info2,
6163                                         &queue[i],
6164                                         i,
6165                                         snum,
6166                                         ntprinter,
6167                                         devmode);
6168                 if (!W_ERROR_IS_OK(result)) {
6169                         goto out;
6170                 }
6171         }
6172
6173  out:
6174         if (!W_ERROR_IS_OK(result)) {
6175                 TALLOC_FREE(info);
6176                 *count = 0;
6177                 return result;
6178         }
6179
6180         *info_p = info;
6181
6182         return WERR_OK;
6183 }
6184
6185 /****************************************************************
6186  _spoolss_EnumJobs
6187 ****************************************************************/
6188
6189 WERROR _spoolss_EnumJobs(pipes_struct *p,
6190                          struct spoolss_EnumJobs *r)
6191 {
6192         WERROR result;
6193         NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
6194         int snum;
6195         print_status_struct prt_status;
6196         print_queue_struct *queue = NULL;
6197         uint32_t count;
6198
6199         /* that's an [in out] buffer */
6200
6201         if (!r->in.buffer && (r->in.offered != 0)) {
6202                 return WERR_INVALID_PARAM;
6203         }
6204
6205         DEBUG(4,("_spoolss_EnumJobs\n"));
6206
6207         *r->out.needed = 0;
6208         *r->out.count = 0;
6209         *r->out.info = NULL;
6210
6211         /* lookup the printer snum and tdb entry */
6212
6213         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
6214                 return WERR_BADFID;
6215         }
6216
6217         result = get_a_printer(NULL, &ntprinter, 2, lp_servicename(snum));
6218         if (!W_ERROR_IS_OK(result)) {
6219                 return result;
6220         }
6221
6222         count = print_queue_status(snum, &queue, &prt_status);
6223         DEBUGADD(4,("count:[%d], status:[%d], [%s]\n",
6224                 count, prt_status.status, prt_status.message));
6225
6226         if (count == 0) {
6227                 SAFE_FREE(queue);
6228                 free_a_printer(&ntprinter, 2);
6229                 return WERR_OK;
6230         }
6231
6232         switch (r->in.level) {
6233         case 1:
6234                 result = enumjobs_level1(p->mem_ctx, queue, count, snum,
6235                                          ntprinter, r->out.info, r->out.count);
6236                 break;
6237         case 2:
6238                 result = enumjobs_level2(p->mem_ctx, queue, count, snum,
6239                                          ntprinter, r->out.info, r->out.count);
6240                 break;
6241         default:
6242                 result = WERR_UNKNOWN_LEVEL;
6243                 break;
6244         }
6245
6246         SAFE_FREE(queue);
6247         free_a_printer(&ntprinter, 2);
6248
6249         if (!W_ERROR_IS_OK(result)) {
6250                 return result;
6251         }
6252
6253         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
6254                                                      spoolss_EnumJobs, NULL,
6255                                                      *r->out.info, r->in.level,
6256                                                      *r->out.count);
6257         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
6258         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
6259
6260         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
6261 }
6262
6263 /****************************************************************
6264  _spoolss_ScheduleJob
6265 ****************************************************************/
6266
6267 WERROR _spoolss_ScheduleJob(pipes_struct *p,
6268                             struct spoolss_ScheduleJob *r)
6269 {
6270         return WERR_OK;
6271 }
6272
6273 /****************************************************************
6274  _spoolss_SetJob
6275 ****************************************************************/
6276
6277 WERROR _spoolss_SetJob(pipes_struct *p,
6278                        struct spoolss_SetJob *r)
6279 {
6280         int snum;
6281         WERROR errcode = WERR_BADFUNC;
6282
6283         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
6284                 return WERR_BADFID;
6285         }
6286
6287         if (!print_job_exists(lp_const_servicename(snum), r->in.job_id)) {
6288                 return WERR_INVALID_PRINTER_NAME;
6289         }
6290
6291         switch (r->in.command) {
6292         case SPOOLSS_JOB_CONTROL_CANCEL:
6293         case SPOOLSS_JOB_CONTROL_DELETE:
6294                 if (print_job_delete(p->server_info, snum, r->in.job_id, &errcode)) {
6295                         errcode = WERR_OK;
6296                 }
6297                 break;
6298         case SPOOLSS_JOB_CONTROL_PAUSE:
6299                 if (print_job_pause(p->server_info, snum, r->in.job_id, &errcode)) {
6300                         errcode = WERR_OK;
6301                 }
6302                 break;
6303         case SPOOLSS_JOB_CONTROL_RESTART:
6304         case SPOOLSS_JOB_CONTROL_RESUME:
6305                 if (print_job_resume(p->server_info, snum, r->in.job_id, &errcode)) {
6306                         errcode = WERR_OK;
6307                 }
6308                 break;
6309         default:
6310                 return WERR_UNKNOWN_LEVEL;
6311         }
6312
6313         return errcode;
6314 }
6315
6316 /****************************************************************************
6317  Enumerates all printer drivers at level 1.
6318 ****************************************************************************/
6319
6320 static WERROR enumprinterdrivers_level1(TALLOC_CTX *mem_ctx,
6321                                         const char *servername,
6322                                         const char *architecture,
6323                                         union spoolss_DriverInfo **info_p,
6324                                         uint32_t *count)
6325 {
6326         int i;
6327         int ndrivers;
6328         uint32_t version;
6329         fstring *list = NULL;
6330         NT_PRINTER_DRIVER_INFO_LEVEL driver;
6331         union spoolss_DriverInfo *info = NULL;
6332         WERROR result = WERR_OK;
6333
6334         *count = 0;
6335
6336         for (version=0; version<DRIVER_MAX_VERSION; version++) {
6337                 list = NULL;
6338                 ndrivers = get_ntdrivers(&list, architecture, version);
6339                 DEBUGADD(4,("we have:[%d] drivers in environment [%s] and version [%d]\n",
6340                         ndrivers, architecture, version));
6341
6342                 if (ndrivers == -1) {
6343                         result = WERR_NOMEM;
6344                         goto out;
6345                 }
6346
6347                 if (ndrivers != 0) {
6348                         info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
6349                                                     union spoolss_DriverInfo,
6350                                                     *count + ndrivers);
6351                         if (!info) {
6352                                 DEBUG(0,("enumprinterdrivers_level1: "
6353                                         "failed to enlarge driver info buffer!\n"));
6354                                 result = WERR_NOMEM;
6355                                 goto out;
6356                         }
6357                 }
6358
6359                 for (i=0; i<ndrivers; i++) {
6360                         DEBUGADD(5,("\tdriver: [%s]\n", list[i]));
6361                         ZERO_STRUCT(driver);
6362                         result = get_a_printer_driver(&driver, 3, list[i],
6363                                                       architecture, version);
6364                         if (!W_ERROR_IS_OK(result)) {
6365                                 goto out;
6366                         }
6367                         result = fill_printer_driver_info1(info, &info[*count+i].info1,
6368                                                            &driver, servername,
6369                                                            architecture);
6370                         if (!W_ERROR_IS_OK(result)) {
6371                                 free_a_printer_driver(driver, 3);
6372                                 goto out;
6373                         }
6374                         free_a_printer_driver(driver, 3);
6375                 }
6376
6377                 *count += ndrivers;
6378                 SAFE_FREE(list);
6379         }
6380
6381  out:
6382         SAFE_FREE(list);
6383
6384         if (!W_ERROR_IS_OK(result)) {
6385                 TALLOC_FREE(info);
6386                 *count = 0;
6387                 return result;
6388         }
6389
6390         *info_p = info;
6391
6392         return WERR_OK;
6393 }
6394
6395 /****************************************************************************
6396  Enumerates all printer drivers at level 2.
6397 ****************************************************************************/
6398
6399 static WERROR enumprinterdrivers_level2(TALLOC_CTX *mem_ctx,
6400                                         const char *servername,
6401                                         const char *architecture,
6402                                         union spoolss_DriverInfo **info_p,
6403                                         uint32_t *count)
6404 {
6405         int i;
6406         int ndrivers;
6407         uint32_t version;
6408         fstring *list = NULL;
6409         NT_PRINTER_DRIVER_INFO_LEVEL driver;
6410         union spoolss_DriverInfo *info = NULL;
6411         WERROR result = WERR_OK;
6412
6413         *count = 0;
6414
6415         for (version=0; version<DRIVER_MAX_VERSION; version++) {
6416                 list = NULL;
6417                 ndrivers = get_ntdrivers(&list, architecture, version);
6418                 DEBUGADD(4,("we have:[%d] drivers in environment [%s] and version [%d]\n",
6419                         ndrivers, architecture, version));
6420
6421                 if (ndrivers == -1) {
6422                         result = WERR_NOMEM;
6423                         goto out;
6424                 }
6425
6426                 if (ndrivers != 0) {
6427                         info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
6428                                                     union spoolss_DriverInfo,
6429                                                     *count + ndrivers);
6430                         if (!info) {
6431                                 DEBUG(0,("enumprinterdrivers_level2: "
6432                                         "failed to enlarge driver info buffer!\n"));
6433                                 result = WERR_NOMEM;
6434                                 goto out;
6435                         }
6436                 }
6437
6438                 for (i=0; i<ndrivers; i++) {
6439                         DEBUGADD(5,("\tdriver: [%s]\n", list[i]));
6440                         ZERO_STRUCT(driver);
6441                         result = get_a_printer_driver(&driver, 3, list[i],
6442                                                       architecture, version);
6443                         if (!W_ERROR_IS_OK(result)) {
6444                                 goto out;
6445                         }
6446                         result = fill_printer_driver_info2(info, &info[*count+i].info2,
6447                                                            &driver, servername);
6448                         if (!W_ERROR_IS_OK(result)) {
6449                                 free_a_printer_driver(driver, 3);
6450                                 goto out;
6451                         }
6452                         free_a_printer_driver(driver, 3);
6453                 }
6454
6455                 *count += ndrivers;
6456                 SAFE_FREE(list);
6457         }
6458
6459  out:
6460         SAFE_FREE(list);
6461
6462         if (!W_ERROR_IS_OK(result)) {
6463                 TALLOC_FREE(info);
6464                 *count = 0;
6465                 return result;
6466         }
6467
6468         *info_p = info;
6469
6470         return WERR_OK;
6471 }
6472
6473 /****************************************************************************
6474  Enumerates all printer drivers at level 3.
6475 ****************************************************************************/
6476
6477 static WERROR enumprinterdrivers_level3(TALLOC_CTX *mem_ctx,
6478                                         const char *servername,
6479                                         const char *architecture,
6480                                         union spoolss_DriverInfo **info_p,
6481                                         uint32_t *count)
6482 {
6483         int i;
6484         int ndrivers;
6485         uint32_t version;
6486         fstring *list = NULL;
6487         union spoolss_DriverInfo *info = NULL;
6488         NT_PRINTER_DRIVER_INFO_LEVEL driver;
6489         WERROR result = WERR_OK;
6490
6491         *count = 0;
6492
6493         for (version=0; version<DRIVER_MAX_VERSION; version++) {
6494                 list = NULL;
6495                 ndrivers = get_ntdrivers(&list, architecture, version);
6496                 DEBUGADD(4,("we have:[%d] drivers in environment [%s] and version [%d]\n",
6497                         ndrivers, architecture, version));
6498
6499                 if (ndrivers == -1) {
6500                         result = WERR_NOMEM;
6501                         goto out;
6502                 }
6503
6504                 if (ndrivers != 0) {
6505                         info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
6506                                                     union spoolss_DriverInfo,
6507                                                     *count + ndrivers);
6508                         if (!info) {
6509                                 DEBUG(0,("enumprinterdrivers_level3: "
6510                                         "failed to enlarge driver info buffer!\n"));
6511                                 result = WERR_NOMEM;
6512                                 goto out;
6513                         }
6514                 }
6515
6516                 for (i=0; i<ndrivers; i++) {
6517                         DEBUGADD(5,("\tdriver: [%s]\n", list[i]));
6518                         ZERO_STRUCT(driver);
6519                         result = get_a_printer_driver(&driver, 3, list[i],
6520                                                       architecture, version);
6521                         if (!W_ERROR_IS_OK(result)) {
6522                                 goto out;
6523                         }
6524                         result = fill_printer_driver_info3(info, &info[*count+i].info3,
6525                                                            &driver, servername);
6526                         if (!W_ERROR_IS_OK(result)) {
6527                                 free_a_printer_driver(driver, 3);
6528                                 goto out;
6529                         }
6530
6531                         free_a_printer_driver(driver, 3);
6532                 }
6533
6534                 *count += ndrivers;
6535                 SAFE_FREE(list);
6536         }
6537
6538  out:
6539         SAFE_FREE(list);
6540
6541         if (!W_ERROR_IS_OK(result)) {
6542                 TALLOC_FREE(info);
6543                 *count = 0;
6544                 return result;
6545         }
6546
6547         *info_p = info;
6548
6549         return WERR_OK;
6550 }
6551
6552 /****************************************************************
6553  _spoolss_EnumPrinterDrivers
6554 ****************************************************************/
6555
6556 WERROR _spoolss_EnumPrinterDrivers(pipes_struct *p,
6557                                    struct spoolss_EnumPrinterDrivers *r)
6558 {
6559         const char *cservername;
6560         WERROR result;
6561
6562         /* that's an [in out] buffer */
6563
6564         if (!r->in.buffer && (r->in.offered != 0)) {
6565                 return WERR_INVALID_PARAM;
6566         }
6567
6568         DEBUG(4,("_spoolss_EnumPrinterDrivers\n"));
6569
6570         *r->out.needed = 0;
6571         *r->out.count = 0;
6572         *r->out.info = NULL;
6573
6574         cservername = canon_servername(r->in.server);
6575
6576         if (!is_myname_or_ipaddr(cservername)) {
6577                 return WERR_UNKNOWN_PRINTER_DRIVER;
6578         }
6579
6580         switch (r->in.level) {
6581         case 1:
6582                 result = enumprinterdrivers_level1(p->mem_ctx, cservername,
6583                                                    r->in.environment,
6584                                                    r->out.info, r->out.count);
6585                 break;
6586         case 2:
6587                 result = enumprinterdrivers_level2(p->mem_ctx, cservername,
6588                                                    r->in.environment,
6589                                                    r->out.info, r->out.count);
6590                 break;
6591         case 3:
6592                 result = enumprinterdrivers_level3(p->mem_ctx, cservername,
6593                                                    r->in.environment,
6594                                                    r->out.info, r->out.count);
6595                 break;
6596         default:
6597                 return WERR_UNKNOWN_LEVEL;
6598         }
6599
6600         if (!W_ERROR_IS_OK(result)) {
6601                 return result;
6602         }
6603
6604         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
6605                                                      spoolss_EnumPrinterDrivers, NULL,
6606                                                      *r->out.info, r->in.level,
6607                                                      *r->out.count);
6608         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
6609         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
6610
6611         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
6612 }
6613
6614 /****************************************************************************
6615 ****************************************************************************/
6616
6617 static WERROR fill_form_info_1(TALLOC_CTX *mem_ctx,
6618                                struct spoolss_FormInfo1 *r,
6619                                const nt_forms_struct *form)
6620 {
6621         r->form_name    = talloc_strdup(mem_ctx, form->name);
6622         W_ERROR_HAVE_NO_MEMORY(r->form_name);
6623
6624         r->flags        = form->flag;
6625         r->size.width   = form->width;
6626         r->size.height  = form->length;
6627         r->area.left    = form->left;
6628         r->area.top     = form->top;
6629         r->area.right   = form->right;
6630         r->area.bottom  = form->bottom;
6631
6632         return WERR_OK;
6633 }
6634
6635 /****************************************************************
6636  spoolss_enumforms_level1
6637 ****************************************************************/
6638
6639 static WERROR spoolss_enumforms_level1(TALLOC_CTX *mem_ctx,
6640                                        const nt_forms_struct *builtin_forms,
6641                                        uint32_t num_builtin_forms,
6642                                        const nt_forms_struct *user_forms,
6643                                        uint32_t num_user_forms,
6644                                        union spoolss_FormInfo **info_p,
6645                                        uint32_t *count)
6646 {
6647         union spoolss_FormInfo *info;
6648         WERROR result = WERR_OK;
6649         int i;
6650
6651         *count = num_builtin_forms + num_user_forms;
6652
6653         info = TALLOC_ARRAY(mem_ctx, union spoolss_FormInfo, *count);
6654         W_ERROR_HAVE_NO_MEMORY(info);
6655
6656         /* construct the list of form structures */
6657         for (i=0; i<num_builtin_forms; i++) {
6658                 DEBUGADD(6,("Filling form number [%d]\n",i));
6659                 result = fill_form_info_1(info, &info[i].info1,
6660                                           &builtin_forms[i]);
6661                 if (!W_ERROR_IS_OK(result)) {
6662                         goto out;
6663                 }
6664         }
6665
6666         for (; i<num_user_forms; i++) {
6667                 DEBUGADD(6,("Filling form number [%d]\n",i));
6668                 result = fill_form_info_1(info, &info[i].info1,
6669                                           &user_forms[i-num_builtin_forms]);
6670                 if (!W_ERROR_IS_OK(result)) {
6671                         goto out;
6672                 }
6673         }
6674
6675  out:
6676         if (!W_ERROR_IS_OK(result)) {
6677                 TALLOC_FREE(info);
6678                 *count = 0;
6679                 return result;
6680         }
6681
6682         *info_p = info;
6683
6684         return WERR_OK;
6685 }
6686
6687 /****************************************************************
6688  _spoolss_EnumForms
6689 ****************************************************************/
6690
6691 WERROR _spoolss_EnumForms(pipes_struct *p,
6692                           struct spoolss_EnumForms *r)
6693 {
6694         WERROR result;
6695         nt_forms_struct *user_forms = NULL;
6696         nt_forms_struct *builtin_forms = NULL;
6697         uint32_t num_user_forms;
6698         uint32_t num_builtin_forms;
6699
6700         *r->out.count = 0;
6701         *r->out.needed = 0;
6702         *r->out.info = NULL;
6703
6704         /* that's an [in out] buffer */
6705
6706         if (!r->in.buffer && (r->in.offered != 0) ) {
6707                 return WERR_INVALID_PARAM;
6708         }
6709
6710         DEBUG(4,("_spoolss_EnumForms\n"));
6711         DEBUGADD(5,("Offered buffer size [%d]\n", r->in.offered));
6712         DEBUGADD(5,("Info level [%d]\n",          r->in.level));
6713
6714         num_builtin_forms = get_builtin_ntforms(&builtin_forms);
6715         DEBUGADD(5,("Number of builtin forms [%d]\n", num_builtin_forms));
6716         num_user_forms = get_ntforms(&user_forms);
6717         DEBUGADD(5,("Number of user forms [%d]\n", num_user_forms));
6718
6719         if (num_user_forms + num_builtin_forms == 0) {
6720                 SAFE_FREE(builtin_forms);
6721                 SAFE_FREE(user_forms);
6722                 return WERR_NO_MORE_ITEMS;
6723         }
6724
6725         switch (r->in.level) {
6726         case 1:
6727                 result = spoolss_enumforms_level1(p->mem_ctx,
6728                                                   builtin_forms,
6729                                                   num_builtin_forms,
6730                                                   user_forms,
6731                                                   num_user_forms,
6732                                                   r->out.info,
6733                                                   r->out.count);
6734                 break;
6735         default:
6736                 result = WERR_UNKNOWN_LEVEL;
6737                 break;
6738         }
6739
6740         SAFE_FREE(user_forms);
6741         SAFE_FREE(builtin_forms);
6742
6743         if (!W_ERROR_IS_OK(result)) {
6744                 return result;
6745         }
6746
6747         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
6748                                                      spoolss_EnumForms, NULL,
6749                                                      *r->out.info, r->in.level,
6750                                                      *r->out.count);
6751         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
6752         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
6753
6754         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
6755 }
6756
6757 /****************************************************************
6758 ****************************************************************/
6759
6760 static WERROR find_form_byname(const char *name,
6761                                nt_forms_struct *form)
6762 {
6763         nt_forms_struct *list = NULL;
6764         int num_forms = 0, i = 0;
6765
6766         if (get_a_builtin_ntform_by_string(name, form)) {
6767                 return WERR_OK;
6768         }
6769
6770         num_forms = get_ntforms(&list);
6771         DEBUGADD(5,("Number of forms [%d]\n", num_forms));
6772
6773         if (num_forms == 0) {
6774                 return WERR_BADFID;
6775         }
6776
6777         /* Check if the requested name is in the list of form structures */
6778         for (i = 0; i < num_forms; i++) {
6779
6780                 DEBUG(4,("checking form %s (want %s)\n", list[i].name, name));
6781
6782                 if (strequal(name, list[i].name)) {
6783                         DEBUGADD(6,("Found form %s number [%d]\n", name, i));
6784                         *form = list[i];
6785                         SAFE_FREE(list);
6786                         return WERR_OK;
6787                 }
6788         }
6789
6790         SAFE_FREE(list);
6791
6792         return WERR_BADFID;
6793 }
6794
6795 /****************************************************************
6796  _spoolss_GetForm
6797 ****************************************************************/
6798
6799 WERROR _spoolss_GetForm(pipes_struct *p,
6800                         struct spoolss_GetForm *r)
6801 {
6802         WERROR result;
6803         nt_forms_struct form;
6804
6805         /* that's an [in out] buffer */
6806
6807         if (!r->in.buffer && (r->in.offered != 0)) {
6808                 return WERR_INVALID_PARAM;
6809         }
6810
6811         DEBUG(4,("_spoolss_GetForm\n"));
6812         DEBUGADD(5,("Offered buffer size [%d]\n", r->in.offered));
6813         DEBUGADD(5,("Info level [%d]\n",          r->in.level));
6814
6815         result = find_form_byname(r->in.form_name, &form);
6816         if (!W_ERROR_IS_OK(result)) {
6817                 TALLOC_FREE(r->out.info);
6818                 return result;
6819         }
6820
6821         switch (r->in.level) {
6822         case 1:
6823                 result = fill_form_info_1(p->mem_ctx,
6824                                           &r->out.info->info1,
6825                                           &form);
6826                 break;
6827
6828         default:
6829                 result = WERR_UNKNOWN_LEVEL;
6830                 break;
6831         }
6832
6833         if (!W_ERROR_IS_OK(result)) {
6834                 TALLOC_FREE(r->out.info);
6835                 return result;
6836         }
6837
6838         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_FormInfo, NULL,
6839                                                r->out.info, r->in.level);
6840         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
6841
6842         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
6843 }
6844
6845 /****************************************************************************
6846 ****************************************************************************/
6847
6848 static WERROR fill_port_1(TALLOC_CTX *mem_ctx,
6849                           struct spoolss_PortInfo1 *r,
6850                           const char *name)
6851 {
6852         r->port_name = talloc_strdup(mem_ctx, name);
6853         W_ERROR_HAVE_NO_MEMORY(r->port_name);
6854
6855         return WERR_OK;
6856 }
6857
6858 /****************************************************************************
6859  TODO: This probably needs distinguish between TCP/IP and Local ports
6860  somehow.
6861 ****************************************************************************/
6862
6863 static WERROR fill_port_2(TALLOC_CTX *mem_ctx,
6864                           struct spoolss_PortInfo2 *r,
6865                           const char *name)
6866 {
6867         r->port_name = talloc_strdup(mem_ctx, name);
6868         W_ERROR_HAVE_NO_MEMORY(r->port_name);
6869
6870         r->monitor_name = talloc_strdup(mem_ctx, "Local Monitor");
6871         W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
6872
6873         r->description = talloc_strdup(mem_ctx, SPL_LOCAL_PORT);
6874         W_ERROR_HAVE_NO_MEMORY(r->description);
6875
6876         r->port_type = SPOOLSS_PORT_TYPE_WRITE;
6877         r->reserved = 0;
6878
6879         return WERR_OK;
6880 }
6881
6882
6883 /****************************************************************************
6884  wrapper around the enumer ports command
6885 ****************************************************************************/
6886
6887 WERROR enumports_hook(TALLOC_CTX *ctx, int *count, char ***lines )
6888 {
6889         char *cmd = lp_enumports_cmd();
6890         char **qlines = NULL;
6891         char *command = NULL;
6892         int numlines;
6893         int ret;
6894         int fd;
6895
6896         *count = 0;
6897         *lines = NULL;
6898
6899         /* if no hook then just fill in the default port */
6900
6901         if ( !*cmd ) {
6902                 if (!(qlines = TALLOC_ARRAY( NULL, char*, 2 ))) {
6903                         return WERR_NOMEM;
6904                 }
6905                 if (!(qlines[0] = talloc_strdup(qlines, SAMBA_PRINTER_PORT_NAME ))) {
6906                         TALLOC_FREE(qlines);
6907                         return WERR_NOMEM;
6908                 }
6909                 qlines[1] = NULL;
6910                 numlines = 1;
6911         }
6912         else {
6913                 /* we have a valid enumport command */
6914
6915                 command = talloc_asprintf(ctx, "%s \"%d\"", cmd, 1);
6916                 if (!command) {
6917                         return WERR_NOMEM;
6918                 }
6919
6920                 DEBUG(10,("Running [%s]\n", command));
6921                 ret = smbrun(command, &fd);
6922                 DEBUG(10,("Returned [%d]\n", ret));
6923                 TALLOC_FREE(command);
6924                 if (ret != 0) {
6925                         if (fd != -1) {
6926                                 close(fd);
6927                         }
6928                         return WERR_ACCESS_DENIED;
6929                 }
6930
6931                 numlines = 0;
6932                 qlines = fd_lines_load(fd, &numlines, 0, NULL);
6933                 DEBUGADD(10,("Lines returned = [%d]\n", numlines));
6934                 close(fd);
6935         }
6936
6937         *count = numlines;
6938         *lines = qlines;
6939
6940         return WERR_OK;
6941 }
6942
6943 /****************************************************************************
6944  enumports level 1.
6945 ****************************************************************************/
6946
6947 static WERROR enumports_level_1(TALLOC_CTX *mem_ctx,
6948                                 union spoolss_PortInfo **info_p,
6949                                 uint32_t *count)
6950 {
6951         union spoolss_PortInfo *info = NULL;
6952         int i=0;
6953         WERROR result = WERR_OK;
6954         char **qlines = NULL;
6955         int numlines = 0;
6956
6957         result = enumports_hook(talloc_tos(), &numlines, &qlines );
6958         if (!W_ERROR_IS_OK(result)) {
6959                 goto out;
6960         }
6961
6962         if (numlines) {
6963                 info = TALLOC_ARRAY(mem_ctx, union spoolss_PortInfo, numlines);
6964                 if (!info) {
6965                         DEBUG(10,("Returning WERR_NOMEM\n"));
6966                         result = WERR_NOMEM;
6967                         goto out;
6968                 }
6969
6970                 for (i=0; i<numlines; i++) {
6971                         DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
6972                         result = fill_port_1(info, &info[i].info1, qlines[i]);
6973                         if (!W_ERROR_IS_OK(result)) {
6974                                 goto out;
6975                         }
6976                 }
6977         }
6978         TALLOC_FREE(qlines);
6979
6980 out:
6981         if (!W_ERROR_IS_OK(result)) {
6982                 TALLOC_FREE(info);
6983                 TALLOC_FREE(qlines);
6984                 *count = 0;
6985                 *info_p = NULL;
6986                 return result;
6987         }
6988
6989         *info_p = info;
6990         *count = numlines;
6991
6992         return WERR_OK;
6993 }
6994
6995 /****************************************************************************
6996  enumports level 2.
6997 ****************************************************************************/
6998
6999 static WERROR enumports_level_2(TALLOC_CTX *mem_ctx,
7000                                 union spoolss_PortInfo **info_p,
7001                                 uint32_t *count)
7002 {
7003         union spoolss_PortInfo *info = NULL;
7004         int i=0;
7005         WERROR result = WERR_OK;
7006         char **qlines = NULL;
7007         int numlines = 0;
7008
7009         result = enumports_hook(talloc_tos(), &numlines, &qlines );
7010         if (!W_ERROR_IS_OK(result)) {
7011                 goto out;
7012         }
7013
7014         if (numlines) {
7015                 info = TALLOC_ARRAY(mem_ctx, union spoolss_PortInfo, numlines);
7016                 if (!info) {
7017                         DEBUG(10,("Returning WERR_NOMEM\n"));
7018                         result = WERR_NOMEM;
7019                         goto out;
7020                 }
7021
7022                 for (i=0; i<numlines; i++) {
7023                         DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
7024                         result = fill_port_2(info, &info[i].info2, qlines[i]);
7025                         if (!W_ERROR_IS_OK(result)) {
7026                                 goto out;
7027                         }
7028                 }
7029         }
7030         TALLOC_FREE(qlines);
7031
7032 out:
7033         if (!W_ERROR_IS_OK(result)) {
7034                 TALLOC_FREE(info);
7035                 TALLOC_FREE(qlines);
7036                 *count = 0;
7037                 *info_p = NULL;
7038                 return result;
7039         }
7040
7041         *info_p = info;
7042         *count = numlines;
7043
7044         return WERR_OK;
7045 }
7046
7047 /****************************************************************
7048  _spoolss_EnumPorts
7049 ****************************************************************/
7050
7051 WERROR _spoolss_EnumPorts(pipes_struct *p,
7052                           struct spoolss_EnumPorts *r)
7053 {
7054         WERROR result;
7055
7056         /* that's an [in out] buffer */
7057
7058         if (!r->in.buffer && (r->in.offered != 0)) {
7059                 return WERR_INVALID_PARAM;
7060         }
7061
7062         DEBUG(4,("_spoolss_EnumPorts\n"));
7063
7064         *r->out.count = 0;
7065         *r->out.needed = 0;
7066         *r->out.info = NULL;
7067
7068         switch (r->in.level) {
7069         case 1:
7070                 result = enumports_level_1(p->mem_ctx, r->out.info,
7071                                            r->out.count);
7072                 break;
7073         case 2:
7074                 result = enumports_level_2(p->mem_ctx, r->out.info,
7075                                            r->out.count);
7076                 break;
7077         default:
7078                 return WERR_UNKNOWN_LEVEL;
7079         }
7080
7081         if (!W_ERROR_IS_OK(result)) {
7082                 return result;
7083         }
7084
7085         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
7086                                                      spoolss_EnumPorts, NULL,
7087                                                      *r->out.info, r->in.level,
7088                                                      *r->out.count);
7089         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
7090         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
7091
7092         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7093 }
7094
7095 /****************************************************************************
7096 ****************************************************************************/
7097
7098 static WERROR spoolss_addprinterex_level_2(pipes_struct *p,
7099                                            const char *server,
7100                                            struct spoolss_SetPrinterInfoCtr *info_ctr,
7101                                            struct spoolss_DeviceMode *devmode,
7102                                            struct security_descriptor *sec_desc,
7103                                            struct spoolss_UserLevelCtr *user_ctr,
7104                                            struct policy_handle *handle)
7105 {
7106         NT_PRINTER_INFO_LEVEL *printer = NULL;
7107         fstring name;
7108         int     snum;
7109         WERROR err = WERR_OK;
7110
7111         if ( !(printer = TALLOC_ZERO_P(NULL, NT_PRINTER_INFO_LEVEL)) ) {
7112                 DEBUG(0,("spoolss_addprinterex_level_2: malloc fail.\n"));
7113                 return WERR_NOMEM;
7114         }
7115
7116         /* convert from UNICODE to ASCII - this allocates the info_2 struct inside *printer.*/
7117         if (!convert_printer_info(info_ctr, printer)) {
7118                 free_a_printer(&printer, 2);
7119                 return WERR_NOMEM;
7120         }
7121
7122         /* check to see if the printer already exists */
7123
7124         if ((snum = print_queue_snum(printer->info_2->sharename)) != -1) {
7125                 DEBUG(5, ("spoolss_addprinterex_level_2: Attempted to add a printer named [%s] when one already existed!\n",
7126                         printer->info_2->sharename));
7127                 free_a_printer(&printer, 2);
7128                 return WERR_PRINTER_ALREADY_EXISTS;
7129         }
7130
7131         /* FIXME!!!  smbd should check to see if the driver is installed before
7132            trying to add a printer like this  --jerry */
7133
7134         if (*lp_addprinter_cmd() ) {
7135                 if ( !add_printer_hook(p->mem_ctx, p->server_info->ptok,
7136                                        printer) ) {
7137                         free_a_printer(&printer,2);
7138                         return WERR_ACCESS_DENIED;
7139                 }
7140         } else {
7141                 DEBUG(0,("spoolss_addprinterex_level_2: add printer for printer %s called and no"
7142                         "smb.conf parameter \"addprinter command\" is defined. This"
7143                         "parameter must exist for this call to succeed\n",
7144                         printer->info_2->sharename ));
7145         }
7146
7147         /* use our primary netbios name since get_a_printer() will convert
7148            it to what the client expects on a case by case basis */
7149
7150         slprintf(name, sizeof(name)-1, "\\\\%s\\%s", global_myname(),
7151              printer->info_2->sharename);
7152
7153
7154         if ((snum = print_queue_snum(printer->info_2->sharename)) == -1) {
7155                 free_a_printer(&printer,2);
7156                 return WERR_ACCESS_DENIED;
7157         }
7158
7159         /* you must be a printer admin to add a new printer */
7160         if (!print_access_check(NULL, snum, PRINTER_ACCESS_ADMINISTER)) {
7161                 free_a_printer(&printer,2);
7162                 return WERR_ACCESS_DENIED;
7163         }
7164
7165         /*
7166          * Do sanity check on the requested changes for Samba.
7167          */
7168
7169         if (!check_printer_ok(printer->info_2, snum)) {
7170                 free_a_printer(&printer,2);
7171                 return WERR_INVALID_PARAM;
7172         }
7173
7174         /*
7175          * When a printer is created, the drivername bound to the printer is used
7176          * to lookup previously saved driver initialization info, which is then
7177          * bound to the new printer, simulating what happens in the Windows arch.
7178          */
7179
7180         if (!devmode)
7181         {
7182                 set_driver_init(printer, 2);
7183         }
7184         else
7185         {
7186                 /* A valid devmode was included, convert and link it
7187                 */
7188                 DEBUGADD(10, ("spoolss_addprinterex_level_2: devmode included, converting\n"));
7189
7190                 if (!convert_devicemode(printer->info_2->printername, devmode,
7191                                         &printer->info_2->devmode)) {
7192                         return  WERR_NOMEM;
7193                 }
7194         }
7195
7196         /* write the ASCII on disk */
7197         err = mod_a_printer(printer, 2);
7198         if (!W_ERROR_IS_OK(err)) {
7199                 free_a_printer(&printer,2);
7200                 return err;
7201         }
7202
7203         if (!open_printer_hnd(p, handle, name, PRINTER_ACCESS_ADMINISTER)) {
7204                 /* Handle open failed - remove addition. */
7205                 del_a_printer(printer->info_2->sharename);
7206                 free_a_printer(&printer,2);
7207                 ZERO_STRUCTP(handle);
7208                 return WERR_ACCESS_DENIED;
7209         }
7210
7211         update_c_setprinter(false);
7212         free_a_printer(&printer,2);
7213
7214         return WERR_OK;
7215 }
7216
7217 /****************************************************************
7218  _spoolss_AddPrinterEx
7219 ****************************************************************/
7220
7221 WERROR _spoolss_AddPrinterEx(pipes_struct *p,
7222                              struct spoolss_AddPrinterEx *r)
7223 {
7224         switch (r->in.info_ctr->level) {
7225         case 1:
7226                 /* we don't handle yet */
7227                 /* but I know what to do ... */
7228                 return WERR_UNKNOWN_LEVEL;
7229         case 2:
7230                 return spoolss_addprinterex_level_2(p, r->in.server,
7231                                                     r->in.info_ctr,
7232                                                     r->in.devmode_ctr->devmode,
7233                                                     r->in.secdesc_ctr->sd,
7234                                                     r->in.userlevel_ctr,
7235                                                     r->out.handle);
7236         default:
7237                 return WERR_UNKNOWN_LEVEL;
7238         }
7239 }
7240
7241 /****************************************************************
7242  _spoolss_AddPrinterDriver
7243 ****************************************************************/
7244
7245 WERROR _spoolss_AddPrinterDriver(pipes_struct *p,
7246                                  struct spoolss_AddPrinterDriver *r)
7247 {
7248         uint32_t level = r->in.info_ctr->level;
7249         struct spoolss_AddDriverInfoCtr *info = r->in.info_ctr;
7250         WERROR err = WERR_OK;
7251         NT_PRINTER_DRIVER_INFO_LEVEL driver;
7252         const char *driver_name = NULL;
7253         uint32_t version;
7254         const char *fn;
7255
7256         switch (p->hdr_req.opnum) {
7257                 case NDR_SPOOLSS_ADDPRINTERDRIVER:
7258                         fn = "_spoolss_AddPrinterDriver";
7259                         break;
7260                 case NDR_SPOOLSS_ADDPRINTERDRIVEREX:
7261                         fn = "_spoolss_AddPrinterDriverEx";
7262                         break;
7263                 default:
7264                         return WERR_INVALID_PARAM;
7265         }
7266
7267
7268         /* FIXME */
7269         if (level != 3 && level != 6) {
7270                 /* Clever hack from Martin Zielinski <mz@seh.de>
7271                  * to allow downgrade from level 8 (Vista).
7272                  */
7273                 DEBUG(0,("%s: level %d not yet implemented\n", fn, level));
7274                 return WERR_UNKNOWN_LEVEL;
7275         }
7276
7277         ZERO_STRUCT(driver);
7278
7279         if (!convert_printer_driver_info(info, &driver, level)) {
7280                 err = WERR_NOMEM;
7281                 goto done;
7282         }
7283
7284         DEBUG(5,("Cleaning driver's information\n"));
7285         err = clean_up_driver_struct(p, driver, level);
7286         if (!W_ERROR_IS_OK(err))
7287                 goto done;
7288
7289         DEBUG(5,("Moving driver to final destination\n"));
7290         if( !W_ERROR_IS_OK(err = move_driver_to_download_area(p, driver, level,
7291                                                               &err)) ) {
7292                 goto done;
7293         }
7294
7295         if (add_a_printer_driver(driver, level)!=0) {
7296                 err = WERR_ACCESS_DENIED;
7297                 goto done;
7298         }
7299
7300         switch(level) {
7301         case 3:
7302                 driver_name = driver.info_3->name ? driver.info_3->name : "";
7303                 break;
7304         case 6:
7305                 driver_name = driver.info_6->name ? driver.info_6->name : "";
7306                 break;
7307         }
7308
7309         /*
7310          * I think this is where he DrvUpgradePrinter() hook would be
7311          * be called in a driver's interface DLL on a Windows NT 4.0/2k
7312          * server.  Right now, we just need to send ourselves a message
7313          * to update each printer bound to this driver.   --jerry
7314          */
7315
7316         if (!srv_spoolss_drv_upgrade_printer(driver_name)) {
7317                 DEBUG(0,("%s: Failed to send message about upgrading driver [%s]!\n",
7318                         fn, driver_name));
7319         }
7320
7321         /*
7322          * Based on the version (e.g. driver destination dir: 0=9x,2=Nt/2k,3=2k/Xp),
7323          * decide if the driver init data should be deleted. The rules are:
7324          *  1) never delete init data if it is a 9x driver, they don't use it anyway
7325          *  2) delete init data only if there is no 2k/Xp driver
7326          *  3) always delete init data
7327          * The generalized rule is always use init data from the highest order driver.
7328          * It is necessary to follow the driver install by an initialization step to
7329          * finish off this process.
7330         */
7331         if (level == 3)
7332                 version = driver.info_3->cversion;
7333         else if (level == 6)
7334                 version = driver.info_6->version;
7335         else
7336                 version = -1;
7337         switch (version) {
7338                 /*
7339                  * 9x printer driver - never delete init data
7340                 */
7341                 case 0:
7342                         DEBUG(10,("%s: init data not deleted for 9x driver [%s]\n",
7343                                 fn, driver_name));
7344                         break;
7345
7346                 /*
7347                  * Nt or 2k (compatiblity mode) printer driver - only delete init data if
7348                  * there is no 2k/Xp driver init data for this driver name.
7349                 */
7350                 case 2:
7351                 {
7352                         NT_PRINTER_DRIVER_INFO_LEVEL driver1;
7353
7354                         if (!W_ERROR_IS_OK(get_a_printer_driver(&driver1, 3, driver_name, "Windows NT x86", 3))) {
7355                                 /*
7356                                  * No 2k/Xp driver found, delete init data (if any) for the new Nt driver.
7357                                 */
7358                                 if (!del_driver_init(driver_name))
7359                                         DEBUG(6,("%s: del_driver_init(%s) Nt failed!\n",
7360                                                 fn, driver_name));
7361                         } else {
7362                                 /*
7363                                  * a 2k/Xp driver was found, don't delete init data because Nt driver will use it.
7364                                 */
7365                                 free_a_printer_driver(driver1,3);
7366                                 DEBUG(10,("%s: init data not deleted for Nt driver [%s]\n",
7367                                         fn, driver_name));
7368                         }
7369                 }
7370                 break;
7371
7372                 /*
7373                  * 2k or Xp printer driver - always delete init data
7374                 */
7375                 case 3:
7376                         if (!del_driver_init(driver_name))
7377                                 DEBUG(6,("%s: del_driver_init(%s) 2k/Xp failed!\n",
7378                                         fn, driver_name));
7379                         break;
7380
7381                 default:
7382                         DEBUG(0,("%s: invalid level=%d\n", fn, level));
7383                         break;
7384         }
7385
7386
7387 done:
7388         free_a_printer_driver(driver, level);
7389         return err;
7390 }
7391
7392 /****************************************************************
7393  _spoolss_AddPrinterDriverEx
7394 ****************************************************************/
7395
7396 WERROR _spoolss_AddPrinterDriverEx(pipes_struct *p,
7397                                    struct spoolss_AddPrinterDriverEx *r)
7398 {
7399         struct spoolss_AddPrinterDriver a;
7400
7401         /*
7402          * we only support the semantics of AddPrinterDriver()
7403          * i.e. only copy files that are newer than existing ones
7404          */
7405
7406         if (r->in.flags != APD_COPY_NEW_FILES) {
7407                 return WERR_ACCESS_DENIED;
7408         }
7409
7410         a.in.servername         = r->in.servername;
7411         a.in.info_ctr           = r->in.info_ctr;
7412
7413         return _spoolss_AddPrinterDriver(p, &a);
7414 }
7415
7416 /****************************************************************************
7417 ****************************************************************************/
7418
7419 struct _spoolss_paths {
7420         int type;
7421         const char *share;
7422         const char *dir;
7423 };
7424
7425 enum { SPOOLSS_DRIVER_PATH, SPOOLSS_PRTPROCS_PATH };
7426
7427 static const struct _spoolss_paths spoolss_paths[]= {
7428         { SPOOLSS_DRIVER_PATH,          "print$",       "DRIVERS" },
7429         { SPOOLSS_PRTPROCS_PATH,        "prnproc$",     "PRTPROCS" }
7430 };
7431
7432 static WERROR compose_spoolss_server_path(TALLOC_CTX *mem_ctx,
7433                                           const char *servername,
7434                                           const char *environment,
7435                                           int component,
7436                                           char **path)
7437 {
7438         const char *pservername = NULL;
7439         const char *long_archi = SPOOLSS_ARCHITECTURE_NT_X86;
7440         const char *short_archi;
7441
7442         *path = NULL;
7443
7444         /* environment may be empty */
7445         if (environment && strlen(environment)) {
7446                 long_archi = environment;
7447         }
7448
7449         /* servername may be empty */
7450         if (servername && strlen(servername)) {
7451                 pservername = canon_servername(servername);
7452
7453                 if (!is_myname_or_ipaddr(pservername)) {
7454                         return WERR_INVALID_PARAM;
7455                 }
7456         }
7457
7458         if (!(short_archi = get_short_archi(long_archi))) {
7459                 return WERR_INVALID_ENVIRONMENT;
7460         }
7461
7462         switch (component) {
7463         case SPOOLSS_PRTPROCS_PATH:
7464         case SPOOLSS_DRIVER_PATH:
7465                 if (pservername) {
7466                         *path = talloc_asprintf(mem_ctx,
7467                                         "\\\\%s\\%s\\%s",
7468                                         pservername,
7469                                         spoolss_paths[component].share,
7470                                         short_archi);
7471                 } else {
7472                         *path = talloc_asprintf(mem_ctx, "%s\\%s\\%s",
7473                                         SPOOLSS_DEFAULT_SERVER_PATH,
7474                                         spoolss_paths[component].dir,
7475                                         short_archi);
7476                 }
7477                 break;
7478         default:
7479                 return WERR_INVALID_PARAM;
7480         }
7481
7482         if (!*path) {
7483                 return WERR_NOMEM;
7484         }
7485
7486         return WERR_OK;
7487 }
7488
7489 /****************************************************************************
7490 ****************************************************************************/
7491
7492 static WERROR getprinterdriverdir_level_1(TALLOC_CTX *mem_ctx,
7493                                           const char *servername,
7494                                           const char *environment,
7495                                           struct spoolss_DriverDirectoryInfo1 *r)
7496 {
7497         WERROR werr;
7498         char *path = NULL;
7499
7500         werr = compose_spoolss_server_path(mem_ctx,
7501                                            servername,
7502                                            environment,
7503                                            SPOOLSS_DRIVER_PATH,
7504                                            &path);
7505         if (!W_ERROR_IS_OK(werr)) {
7506                 return werr;
7507         }
7508
7509         DEBUG(4,("printer driver directory: [%s]\n", path));
7510
7511         r->directory_name = path;
7512
7513         return WERR_OK;
7514 }
7515
7516 /****************************************************************
7517  _spoolss_GetPrinterDriverDirectory
7518 ****************************************************************/
7519
7520 WERROR _spoolss_GetPrinterDriverDirectory(pipes_struct *p,
7521                                           struct spoolss_GetPrinterDriverDirectory *r)
7522 {
7523         WERROR werror;
7524
7525         /* that's an [in out] buffer */
7526
7527         if (!r->in.buffer && (r->in.offered != 0)) {
7528                 return WERR_INVALID_PARAM;
7529         }
7530
7531         DEBUG(5,("_spoolss_GetPrinterDriverDirectory: level %d\n",
7532                 r->in.level));
7533
7534         *r->out.needed = 0;
7535
7536         /* r->in.level is ignored */
7537
7538         werror = getprinterdriverdir_level_1(p->mem_ctx,
7539                                              r->in.server,
7540                                              r->in.environment,
7541                                              &r->out.info->info1);
7542         if (!W_ERROR_IS_OK(werror)) {
7543                 TALLOC_FREE(r->out.info);
7544                 return werror;
7545         }
7546
7547         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_DriverDirectoryInfo, NULL,
7548                                                r->out.info, r->in.level);
7549         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
7550
7551         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7552 }
7553
7554 /****************************************************************
7555  _spoolss_EnumPrinterData
7556 ****************************************************************/
7557
7558 WERROR _spoolss_EnumPrinterData(pipes_struct *p,
7559                                 struct spoolss_EnumPrinterData *r)
7560 {
7561         NT_PRINTER_INFO_LEVEL *printer = NULL;
7562         Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
7563         int             snum;
7564         WERROR          result;
7565         REGISTRY_VALUE  *val = NULL;
7566         NT_PRINTER_DATA *p_data;
7567         int             i, key_index, num_values;
7568         int             name_length;
7569
7570         *r->out.value_needed    = 0;
7571         *r->out.type            = REG_NONE;
7572         *r->out.data_needed     = 0;
7573
7574         DEBUG(5,("_spoolss_EnumPrinterData\n"));
7575
7576         if (!Printer) {
7577                 DEBUG(2,("_spoolss_EnumPrinterData: Invalid handle (%s:%u:%u).\n",
7578                         OUR_HANDLE(r->in.handle)));
7579                 return WERR_BADFID;
7580         }
7581
7582         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
7583                 return WERR_BADFID;
7584         }
7585
7586         result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
7587         if (!W_ERROR_IS_OK(result)) {
7588                 return result;
7589         }
7590
7591         p_data = printer->info_2->data;
7592         key_index = lookup_printerkey( p_data, SPOOL_PRINTERDATA_KEY );
7593
7594         result = WERR_OK;
7595
7596         /*
7597          * The NT machine wants to know the biggest size of value and data
7598          *
7599          * cf: MSDN EnumPrinterData remark section
7600          */
7601
7602         if (!r->in.value_offered && !r->in.data_offered && (key_index != -1)) {
7603
7604                 uint32_t biggest_valuesize = 0;
7605                 uint32_t biggest_datasize = 0;
7606
7607                 DEBUGADD(6,("Activating NT mega-hack to find sizes\n"));
7608
7609                 num_values = regval_ctr_numvals( p_data->keys[key_index].values );
7610
7611                 for ( i=0; i<num_values; i++ )
7612                 {
7613                         val = regval_ctr_specific_value( p_data->keys[key_index].values, i );
7614
7615                         name_length = strlen(val->valuename);
7616                         if ( strlen(val->valuename) > biggest_valuesize )
7617                                 biggest_valuesize = name_length;
7618
7619                         if ( val->size > biggest_datasize )
7620                                 biggest_datasize = val->size;
7621
7622                         DEBUG(6,("current values: [%d], [%d]\n", biggest_valuesize,
7623                                 biggest_datasize));
7624                 }
7625
7626                 /* the value is an UNICODE string but real_value_size is the length
7627                    in bytes including the trailing 0 */
7628
7629                 *r->out.value_needed = 2 * (1 + biggest_valuesize);
7630                 *r->out.data_needed  = biggest_datasize;
7631
7632                 DEBUG(6,("final values: [%d], [%d]\n",
7633                         *r->out.value_needed, *r->out.data_needed));
7634
7635                 goto done;
7636         }
7637
7638         /*
7639          * the value len is wrong in NT sp3
7640          * that's the number of bytes not the number of unicode chars
7641          */
7642
7643         if (key_index != -1) {
7644                 val = regval_ctr_specific_value(p_data->keys[key_index].values,
7645                                                 r->in.enum_index);
7646         }
7647
7648         if (!val) {
7649
7650                 /* out_value should default to "" or else NT4 has
7651                    problems unmarshalling the response */
7652
7653                 if (r->in.value_offered) {
7654                         *r->out.value_needed = 1;
7655                         r->out.value_name = talloc_strdup(r, "");
7656                         if (!r->out.value_name) {
7657                                 result = WERR_NOMEM;
7658                                 goto done;
7659                         }
7660                 } else {
7661                         r->out.value_name = NULL;
7662                         *r->out.value_needed = 0;
7663                 }
7664
7665                 /* the data is counted in bytes */
7666
7667                 *r->out.data_needed = r->in.data_offered;
7668
7669                 result = WERR_NO_MORE_ITEMS;
7670         } else {
7671                 /*
7672                  * the value is:
7673                  * - counted in bytes in the request
7674                  * - counted in UNICODE chars in the max reply
7675                  * - counted in bytes in the real size
7676                  *
7677                  * take a pause *before* coding not *during* coding
7678                  */
7679
7680                 /* name */
7681                 if (r->in.value_offered) {
7682                         r->out.value_name = talloc_strdup(r, regval_name(val));
7683                         if (!r->out.value_name) {
7684                                 result = WERR_NOMEM;
7685                                 goto done;
7686                         }
7687                         *r->out.value_needed = strlen_m(regval_name(val));
7688                 } else {
7689                         r->out.value_name = NULL;
7690                         *r->out.value_needed = 0;
7691                 }
7692
7693                 /* type */
7694
7695                 *r->out.type = regval_type(val);
7696
7697                 /* data - counted in bytes */
7698
7699                 if (r->out.data && regval_size(val)) {
7700                         memcpy(r->out.data, regval_data_p(val), regval_size(val));
7701                 }
7702
7703                 *r->out.data_needed = regval_size(val);
7704         }
7705
7706 done:
7707         free_a_printer(&printer, 2);
7708         return result;
7709 }
7710
7711 /****************************************************************
7712  _spoolss_SetPrinterData
7713 ****************************************************************/
7714
7715 WERROR _spoolss_SetPrinterData(pipes_struct *p,
7716                                struct spoolss_SetPrinterData *r)
7717 {
7718         NT_PRINTER_INFO_LEVEL *printer = NULL;
7719         int snum=0;
7720         WERROR result = WERR_OK;
7721         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
7722         DATA_BLOB blob;
7723
7724         DEBUG(5,("_spoolss_SetPrinterData\n"));
7725
7726         if (!Printer) {
7727                 DEBUG(2,("_spoolss_SetPrinterData: Invalid handle (%s:%u:%u).\n",
7728                         OUR_HANDLE(r->in.handle)));
7729                 return WERR_BADFID;
7730         }
7731
7732         if (Printer->printer_type == SPLHND_SERVER) {
7733                 DEBUG(10,("_spoolss_SetPrinterData: "
7734                         "Not implemented for server handles yet\n"));
7735                 return WERR_INVALID_PARAM;
7736         }
7737
7738         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
7739                 return WERR_BADFID;
7740         }
7741
7742         /*
7743          * Access check : NT returns "access denied" if you make a
7744          * SetPrinterData call without the necessary privildge.
7745          * we were originally returning OK if nothing changed
7746          * which made Win2k issue **a lot** of SetPrinterData
7747          * when connecting to a printer  --jerry
7748          */
7749
7750         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
7751                 DEBUG(3,("_spoolss_SetPrinterData: "
7752                         "change denied by handle access permissions\n"));
7753                 result = WERR_ACCESS_DENIED;
7754                 goto done;
7755         }
7756
7757         result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
7758         if (!W_ERROR_IS_OK(result)) {
7759                 return result;
7760         }
7761
7762         result = push_spoolss_PrinterData(p->mem_ctx, &blob,
7763                                           r->in.type, &r->in.data);
7764         if (!W_ERROR_IS_OK(result)) {
7765                 goto done;
7766         }
7767
7768         /*
7769          * When client side code sets a magic printer data key, detect it and save
7770          * the current printer data and the magic key's data (its the DEVMODE) for
7771          * future printer/driver initializations.
7772          */
7773         if ((r->in.type == REG_BINARY) && strequal(r->in.value_name, PHANTOM_DEVMODE_KEY)) {
7774                 /* Set devmode and printer initialization info */
7775                 result = save_driver_init(printer, 2, blob.data, blob.length);
7776
7777                 srv_spoolss_reset_printerdata(printer->info_2->drivername);
7778
7779                 goto done;
7780         }
7781
7782         result = set_printer_dataex(printer, SPOOL_PRINTERDATA_KEY,
7783                                     r->in.value_name, r->in.type,
7784                                     blob.data, blob.length);
7785         if (W_ERROR_IS_OK(result)) {
7786                 result = mod_a_printer(printer, 2);
7787         }
7788
7789 done:
7790         free_a_printer(&printer, 2);
7791
7792         return result;
7793 }
7794
7795 /****************************************************************
7796  _spoolss_ResetPrinter
7797 ****************************************************************/
7798
7799 WERROR _spoolss_ResetPrinter(pipes_struct *p,
7800                              struct spoolss_ResetPrinter *r)
7801 {
7802         Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
7803         int             snum;
7804
7805         DEBUG(5,("_spoolss_ResetPrinter\n"));
7806
7807         /*
7808          * All we do is to check to see if the handle and queue is valid.
7809          * This call really doesn't mean anything to us because we only
7810          * support RAW printing.   --jerry
7811          */
7812
7813         if (!Printer) {
7814                 DEBUG(2,("_spoolss_ResetPrinter: Invalid handle (%s:%u:%u).\n",
7815                         OUR_HANDLE(r->in.handle)));
7816                 return WERR_BADFID;
7817         }
7818
7819         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
7820                 return WERR_BADFID;
7821
7822
7823         /* blindly return success */
7824         return WERR_OK;
7825 }
7826
7827 /****************************************************************
7828  _spoolss_DeletePrinterData
7829 ****************************************************************/
7830
7831 WERROR _spoolss_DeletePrinterData(pipes_struct *p,
7832                                   struct spoolss_DeletePrinterData *r)
7833 {
7834         NT_PRINTER_INFO_LEVEL   *printer = NULL;
7835         int             snum=0;
7836         WERROR          status = WERR_OK;
7837         Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
7838
7839         DEBUG(5,("_spoolss_DeletePrinterData\n"));
7840
7841         if (!Printer) {
7842                 DEBUG(2,("_spoolss_DeletePrinterData: Invalid handle (%s:%u:%u).\n",
7843                         OUR_HANDLE(r->in.handle)));
7844                 return WERR_BADFID;
7845         }
7846
7847         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
7848                 return WERR_BADFID;
7849
7850         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
7851                 DEBUG(3, ("_spoolss_DeletePrinterData: "
7852                         "printer properties change denied by handle\n"));
7853                 return WERR_ACCESS_DENIED;
7854         }
7855
7856         status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
7857         if (!W_ERROR_IS_OK(status))
7858                 return status;
7859
7860         if (!r->in.value_name) {
7861                 free_a_printer(&printer, 2);
7862                 return WERR_NOMEM;
7863         }
7864
7865         status = delete_printer_dataex( printer, SPOOL_PRINTERDATA_KEY,
7866                                         r->in.value_name );
7867
7868         if ( W_ERROR_IS_OK(status) )
7869                 mod_a_printer( printer, 2 );
7870
7871         free_a_printer(&printer, 2);
7872
7873         return status;
7874 }
7875
7876 /****************************************************************
7877  _spoolss_AddForm
7878 ****************************************************************/
7879
7880 WERROR _spoolss_AddForm(pipes_struct *p,
7881                         struct spoolss_AddForm *r)
7882 {
7883         struct spoolss_AddFormInfo1 *form = r->in.info.info1;
7884         nt_forms_struct tmpForm;
7885         int snum;
7886         WERROR status = WERR_OK;
7887         NT_PRINTER_INFO_LEVEL *printer = NULL;
7888
7889         int count=0;
7890         nt_forms_struct *list=NULL;
7891         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
7892
7893         DEBUG(5,("_spoolss_AddForm\n"));
7894
7895         if (!Printer) {
7896                 DEBUG(2,("_spoolss_AddForm: Invalid handle (%s:%u:%u).\n",
7897                         OUR_HANDLE(r->in.handle)));
7898                 return WERR_BADFID;
7899         }
7900
7901
7902         /* forms can be added on printer of on the print server handle */
7903
7904         if ( Printer->printer_type == SPLHND_PRINTER )
7905         {
7906                 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
7907                         return WERR_BADFID;
7908
7909                 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
7910                 if (!W_ERROR_IS_OK(status))
7911                         goto done;
7912         }
7913
7914         if ( !(Printer->access_granted & (PRINTER_ACCESS_ADMINISTER|SERVER_ACCESS_ADMINISTER)) ) {
7915                 DEBUG(2,("_spoolss_addform: denied by handle permissions.\n"));
7916                 status = WERR_ACCESS_DENIED;
7917                 goto done;
7918         }
7919
7920         /* can't add if builtin */
7921
7922         if (get_a_builtin_ntform_by_string(form->form_name, &tmpForm)) {
7923                 status = WERR_FILE_EXISTS;
7924                 goto done;
7925         }
7926
7927         count = get_ntforms(&list);
7928
7929         if(!add_a_form(&list, form, &count)) {
7930                 status =  WERR_NOMEM;
7931                 goto done;
7932         }
7933
7934         write_ntforms(&list, count);
7935
7936         /*
7937          * ChangeID must always be set if this is a printer
7938          */
7939
7940         if ( Printer->printer_type == SPLHND_PRINTER )
7941                 status = mod_a_printer(printer, 2);
7942
7943 done:
7944         if ( printer )
7945                 free_a_printer(&printer, 2);
7946         SAFE_FREE(list);
7947
7948         return status;
7949 }
7950
7951 /****************************************************************
7952  _spoolss_DeleteForm
7953 ****************************************************************/
7954
7955 WERROR _spoolss_DeleteForm(pipes_struct *p,
7956                            struct spoolss_DeleteForm *r)
7957 {
7958         const char *form_name = r->in.form_name;
7959         nt_forms_struct tmpForm;
7960         int count=0;
7961         nt_forms_struct *list=NULL;
7962         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
7963         int snum;
7964         WERROR status = WERR_OK;
7965         NT_PRINTER_INFO_LEVEL *printer = NULL;
7966
7967         DEBUG(5,("_spoolss_DeleteForm\n"));
7968
7969         if (!Printer) {
7970                 DEBUG(2,("_spoolss_DeleteForm: Invalid handle (%s:%u:%u).\n",
7971                         OUR_HANDLE(r->in.handle)));
7972                 return WERR_BADFID;
7973         }
7974
7975         /* forms can be deleted on printer of on the print server handle */
7976
7977         if ( Printer->printer_type == SPLHND_PRINTER )
7978         {
7979                 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
7980                         return WERR_BADFID;
7981
7982                 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
7983                 if (!W_ERROR_IS_OK(status))
7984                         goto done;
7985         }
7986
7987         if ( !(Printer->access_granted & (PRINTER_ACCESS_ADMINISTER|SERVER_ACCESS_ADMINISTER)) ) {
7988                 DEBUG(2,("_spoolss_DeleteForm: denied by handle permissions.\n"));
7989                 status = WERR_ACCESS_DENIED;
7990                 goto done;
7991         }
7992
7993         /* can't delete if builtin */
7994
7995         if (get_a_builtin_ntform_by_string(form_name,&tmpForm)) {
7996                 status = WERR_INVALID_PARAM;
7997                 goto done;
7998         }
7999
8000         count = get_ntforms(&list);
8001
8002         if ( !delete_a_form(&list, form_name, &count, &status ))
8003                 goto done;
8004
8005         /*
8006          * ChangeID must always be set if this is a printer
8007          */
8008
8009         if ( Printer->printer_type == SPLHND_PRINTER )
8010                 status = mod_a_printer(printer, 2);
8011
8012 done:
8013         if ( printer )
8014                 free_a_printer(&printer, 2);
8015         SAFE_FREE(list);
8016
8017         return status;
8018 }
8019
8020 /****************************************************************
8021  _spoolss_SetForm
8022 ****************************************************************/
8023
8024 WERROR _spoolss_SetForm(pipes_struct *p,
8025                         struct spoolss_SetForm *r)
8026 {
8027         struct spoolss_AddFormInfo1 *form = r->in.info.info1;
8028         nt_forms_struct tmpForm;
8029         int snum;
8030         WERROR status = WERR_OK;
8031         NT_PRINTER_INFO_LEVEL *printer = NULL;
8032
8033         int count=0;
8034         nt_forms_struct *list=NULL;
8035         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8036
8037         DEBUG(5,("_spoolss_SetForm\n"));
8038
8039         if (!Printer) {
8040                 DEBUG(2,("_spoolss_SetForm: Invalid handle (%s:%u:%u).\n",
8041                         OUR_HANDLE(r->in.handle)));
8042                 return WERR_BADFID;
8043         }
8044
8045         /* forms can be modified on printer of on the print server handle */
8046
8047         if ( Printer->printer_type == SPLHND_PRINTER )
8048         {
8049                 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8050                         return WERR_BADFID;
8051
8052                 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8053                 if (!W_ERROR_IS_OK(status))
8054                         goto done;
8055         }
8056
8057         if ( !(Printer->access_granted & (PRINTER_ACCESS_ADMINISTER|SERVER_ACCESS_ADMINISTER)) ) {
8058                 DEBUG(2,("_spoolss_SetForm: denied by handle permissions\n"));
8059                 status = WERR_ACCESS_DENIED;
8060                 goto done;
8061         }
8062
8063         /* can't set if builtin */
8064         if (get_a_builtin_ntform_by_string(form->form_name, &tmpForm)) {
8065                 status = WERR_INVALID_PARAM;
8066                 goto done;
8067         }
8068
8069         count = get_ntforms(&list);
8070         update_a_form(&list, form, count);
8071         write_ntforms(&list, count);
8072
8073         /*
8074          * ChangeID must always be set if this is a printer
8075          */
8076
8077         if ( Printer->printer_type == SPLHND_PRINTER )
8078                 status = mod_a_printer(printer, 2);
8079
8080
8081 done:
8082         if ( printer )
8083                 free_a_printer(&printer, 2);
8084         SAFE_FREE(list);
8085
8086         return status;
8087 }
8088
8089 /****************************************************************************
8090  fill_print_processor1
8091 ****************************************************************************/
8092
8093 static WERROR fill_print_processor1(TALLOC_CTX *mem_ctx,
8094                                     struct spoolss_PrintProcessorInfo1 *r,
8095                                     const char *print_processor_name)
8096 {
8097         r->print_processor_name = talloc_strdup(mem_ctx, print_processor_name);
8098         W_ERROR_HAVE_NO_MEMORY(r->print_processor_name);
8099
8100         return WERR_OK;
8101 }
8102
8103 /****************************************************************************
8104  enumprintprocessors level 1.
8105 ****************************************************************************/
8106
8107 static WERROR enumprintprocessors_level_1(TALLOC_CTX *mem_ctx,
8108                                           union spoolss_PrintProcessorInfo **info_p,
8109                                           uint32_t *count)
8110 {
8111         union spoolss_PrintProcessorInfo *info;
8112         WERROR result;
8113
8114         info = TALLOC_ARRAY(mem_ctx, union spoolss_PrintProcessorInfo, 1);
8115         W_ERROR_HAVE_NO_MEMORY(info);
8116
8117         *count = 1;
8118
8119         result = fill_print_processor1(info, &info[0].info1, "winprint");
8120         if (!W_ERROR_IS_OK(result)) {
8121                 goto out;
8122         }
8123
8124  out:
8125         if (!W_ERROR_IS_OK(result)) {
8126                 TALLOC_FREE(info);
8127                 *count = 0;
8128                 return result;
8129         }
8130
8131         *info_p = info;
8132
8133         return WERR_OK;
8134 }
8135
8136 /****************************************************************
8137  _spoolss_EnumPrintProcessors
8138 ****************************************************************/
8139
8140 WERROR _spoolss_EnumPrintProcessors(pipes_struct *p,
8141                                     struct spoolss_EnumPrintProcessors *r)
8142 {
8143         WERROR result;
8144
8145         /* that's an [in out] buffer */
8146
8147         if (!r->in.buffer && (r->in.offered != 0)) {
8148                 return WERR_INVALID_PARAM;
8149         }
8150
8151         DEBUG(5,("_spoolss_EnumPrintProcessors\n"));
8152
8153         /*
8154          * Enumerate the print processors ...
8155          *
8156          * Just reply with "winprint", to keep NT happy
8157          * and I can use my nice printer checker.
8158          */
8159
8160         *r->out.count = 0;
8161         *r->out.needed = 0;
8162         *r->out.info = NULL;
8163
8164         switch (r->in.level) {
8165         case 1:
8166                 result = enumprintprocessors_level_1(p->mem_ctx, r->out.info,
8167                                                      r->out.count);
8168                 break;
8169         default:
8170                 return WERR_UNKNOWN_LEVEL;
8171         }
8172
8173         if (!W_ERROR_IS_OK(result)) {
8174                 return result;
8175         }
8176
8177         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8178                                                      spoolss_EnumPrintProcessors, NULL,
8179                                                      *r->out.info, r->in.level,
8180                                                      *r->out.count);
8181         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8182         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8183
8184         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8185 }
8186
8187 /****************************************************************************
8188  fill_printprocdatatype1
8189 ****************************************************************************/
8190
8191 static WERROR fill_printprocdatatype1(TALLOC_CTX *mem_ctx,
8192                                       struct spoolss_PrintProcDataTypesInfo1 *r,
8193                                       const char *name_array)
8194 {
8195         r->name_array = talloc_strdup(mem_ctx, name_array);
8196         W_ERROR_HAVE_NO_MEMORY(r->name_array);
8197
8198         return WERR_OK;
8199 }
8200
8201 /****************************************************************************
8202  enumprintprocdatatypes level 1.
8203 ****************************************************************************/
8204
8205 static WERROR enumprintprocdatatypes_level_1(TALLOC_CTX *mem_ctx,
8206                                              union spoolss_PrintProcDataTypesInfo **info_p,
8207                                              uint32_t *count)
8208 {
8209         WERROR result;
8210         union spoolss_PrintProcDataTypesInfo *info;
8211
8212         info = TALLOC_ARRAY(mem_ctx, union spoolss_PrintProcDataTypesInfo, 1);
8213         W_ERROR_HAVE_NO_MEMORY(info);
8214
8215         *count = 1;
8216
8217         result = fill_printprocdatatype1(info, &info[0].info1, "RAW");
8218         if (!W_ERROR_IS_OK(result)) {
8219                 goto out;
8220         }
8221
8222  out:
8223         if (!W_ERROR_IS_OK(result)) {
8224                 TALLOC_FREE(info);
8225                 *count = 0;
8226                 return result;
8227         }
8228
8229         *info_p = info;
8230
8231         return WERR_OK;
8232 }
8233
8234 /****************************************************************
8235  _spoolss_EnumPrintProcDataTypes
8236 ****************************************************************/
8237
8238 WERROR _spoolss_EnumPrintProcDataTypes(pipes_struct *p,
8239                                        struct spoolss_EnumPrintProcDataTypes *r)
8240 {
8241         WERROR result;
8242
8243         /* that's an [in out] buffer */
8244
8245         if (!r->in.buffer && (r->in.offered != 0)) {
8246                 return WERR_INVALID_PARAM;
8247         }
8248
8249         DEBUG(5,("_spoolss_EnumPrintProcDataTypes\n"));
8250
8251         *r->out.count = 0;
8252         *r->out.needed = 0;
8253         *r->out.info = NULL;
8254
8255         switch (r->in.level) {
8256         case 1:
8257                 result = enumprintprocdatatypes_level_1(p->mem_ctx, r->out.info,
8258                                                         r->out.count);
8259                 break;
8260         default:
8261                 return WERR_UNKNOWN_LEVEL;
8262         }
8263
8264         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8265                                                      spoolss_EnumPrintProcDataTypes, NULL,
8266                                                      *r->out.info, r->in.level,
8267                                                      *r->out.count);
8268         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8269         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8270
8271         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8272 }
8273
8274 /****************************************************************************
8275  fill_monitor_1
8276 ****************************************************************************/
8277
8278 static WERROR fill_monitor_1(TALLOC_CTX *mem_ctx,
8279                              struct spoolss_MonitorInfo1 *r,
8280                              const char *monitor_name)
8281 {
8282         r->monitor_name                 = talloc_strdup(mem_ctx, monitor_name);
8283         W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
8284
8285         return WERR_OK;
8286 }
8287
8288 /****************************************************************************
8289  fill_monitor_2
8290 ****************************************************************************/
8291
8292 static WERROR fill_monitor_2(TALLOC_CTX *mem_ctx,
8293                              struct spoolss_MonitorInfo2 *r,
8294                              const char *monitor_name,
8295                              const char *environment,
8296                              const char *dll_name)
8297 {
8298         r->monitor_name                 = talloc_strdup(mem_ctx, monitor_name);
8299         W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
8300         r->environment                  = talloc_strdup(mem_ctx, environment);
8301         W_ERROR_HAVE_NO_MEMORY(r->environment);
8302         r->dll_name                     = talloc_strdup(mem_ctx, dll_name);
8303         W_ERROR_HAVE_NO_MEMORY(r->dll_name);
8304
8305         return WERR_OK;
8306 }
8307
8308 /****************************************************************************
8309  enumprintmonitors level 1.
8310 ****************************************************************************/
8311
8312 static WERROR enumprintmonitors_level_1(TALLOC_CTX *mem_ctx,
8313                                         union spoolss_MonitorInfo **info_p,
8314                                         uint32_t *count)
8315 {
8316         union spoolss_MonitorInfo *info;
8317         WERROR result = WERR_OK;
8318
8319         info = TALLOC_ARRAY(mem_ctx, union spoolss_MonitorInfo, 2);
8320         W_ERROR_HAVE_NO_MEMORY(info);
8321
8322         *count = 2;
8323
8324         result = fill_monitor_1(info, &info[0].info1,
8325                                 SPL_LOCAL_PORT);
8326         if (!W_ERROR_IS_OK(result)) {
8327                 goto out;
8328         }
8329
8330         result = fill_monitor_1(info, &info[1].info1,
8331                                 SPL_TCPIP_PORT);
8332         if (!W_ERROR_IS_OK(result)) {
8333                 goto out;
8334         }
8335
8336 out:
8337         if (!W_ERROR_IS_OK(result)) {
8338                 TALLOC_FREE(info);
8339                 *count = 0;
8340                 return result;
8341         }
8342
8343         *info_p = info;
8344
8345         return WERR_OK;
8346 }
8347
8348 /****************************************************************************
8349  enumprintmonitors level 2.
8350 ****************************************************************************/
8351
8352 static WERROR enumprintmonitors_level_2(TALLOC_CTX *mem_ctx,
8353                                         union spoolss_MonitorInfo **info_p,
8354                                         uint32_t *count)
8355 {
8356         union spoolss_MonitorInfo *info;
8357         WERROR result = WERR_OK;
8358
8359         info = TALLOC_ARRAY(mem_ctx, union spoolss_MonitorInfo, 2);
8360         W_ERROR_HAVE_NO_MEMORY(info);
8361
8362         *count = 2;
8363
8364         result = fill_monitor_2(info, &info[0].info2,
8365                                 SPL_LOCAL_PORT,
8366                                 "Windows NT X86", /* FIXME */
8367                                 "localmon.dll");
8368         if (!W_ERROR_IS_OK(result)) {
8369                 goto out;
8370         }
8371
8372         result = fill_monitor_2(info, &info[1].info2,
8373                                 SPL_TCPIP_PORT,
8374                                 "Windows NT X86", /* FIXME */
8375                                 "tcpmon.dll");
8376         if (!W_ERROR_IS_OK(result)) {
8377                 goto out;
8378         }
8379
8380 out:
8381         if (!W_ERROR_IS_OK(result)) {
8382                 TALLOC_FREE(info);
8383                 *count = 0;
8384                 return result;
8385         }
8386
8387         *info_p = info;
8388
8389         return WERR_OK;
8390 }
8391
8392 /****************************************************************
8393  _spoolss_EnumMonitors
8394 ****************************************************************/
8395
8396 WERROR _spoolss_EnumMonitors(pipes_struct *p,
8397                              struct spoolss_EnumMonitors *r)
8398 {
8399         WERROR result;
8400
8401         /* that's an [in out] buffer */
8402
8403         if (!r->in.buffer && (r->in.offered != 0)) {
8404                 return WERR_INVALID_PARAM;
8405         }
8406
8407         DEBUG(5,("_spoolss_EnumMonitors\n"));
8408
8409         /*
8410          * Enumerate the print monitors ...
8411          *
8412          * Just reply with "Local Port", to keep NT happy
8413          * and I can use my nice printer checker.
8414          */
8415
8416         *r->out.count = 0;
8417         *r->out.needed = 0;
8418         *r->out.info = NULL;
8419
8420         switch (r->in.level) {
8421         case 1:
8422                 result = enumprintmonitors_level_1(p->mem_ctx, r->out.info,
8423                                                    r->out.count);
8424                 break;
8425         case 2:
8426                 result = enumprintmonitors_level_2(p->mem_ctx, r->out.info,
8427                                                    r->out.count);
8428                 break;
8429         default:
8430                 return WERR_UNKNOWN_LEVEL;
8431         }
8432
8433         if (!W_ERROR_IS_OK(result)) {
8434                 return result;
8435         }
8436
8437         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8438                                                      spoolss_EnumMonitors, NULL,
8439                                                      *r->out.info, r->in.level,
8440                                                      *r->out.count);
8441         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8442         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8443
8444         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8445 }
8446
8447 /****************************************************************************
8448 ****************************************************************************/
8449
8450 static WERROR getjob_level_1(TALLOC_CTX *mem_ctx,
8451                              const print_queue_struct *queue,
8452                              int count, int snum,
8453                              const NT_PRINTER_INFO_LEVEL *ntprinter,
8454                              uint32_t jobid,
8455                              struct spoolss_JobInfo1 *r)
8456 {
8457         int i = 0;
8458         bool found = false;
8459
8460         for (i=0; i<count && found == false; i++) {
8461                 if (queue[i].job == (int)jobid) {
8462                         found = true;
8463                 }
8464         }
8465
8466         if (found == false) {
8467                 /* NT treats not found as bad param... yet another bad choice */
8468                 return WERR_INVALID_PARAM;
8469         }
8470
8471         return fill_job_info1(mem_ctx,
8472                               r,
8473                               &queue[i-1],
8474                               i,
8475                               snum,
8476                               ntprinter);
8477 }
8478
8479 /****************************************************************************
8480 ****************************************************************************/
8481
8482 static WERROR getjob_level_2(TALLOC_CTX *mem_ctx,
8483                              const print_queue_struct *queue,
8484                              int count, int snum,
8485                              const NT_PRINTER_INFO_LEVEL *ntprinter,
8486                              uint32_t jobid,
8487                              struct spoolss_JobInfo2 *r)
8488 {
8489         int i = 0;
8490         bool found = false;
8491         struct spoolss_DeviceMode *devmode;
8492         NT_DEVICEMODE *nt_devmode;
8493         WERROR result;
8494
8495         for (i=0; i<count && found == false; i++) {
8496                 if (queue[i].job == (int)jobid) {
8497                         found = true;
8498                 }
8499         }
8500
8501         if (found == false) {
8502                 /* NT treats not found as bad param... yet another bad
8503                    choice */
8504                 return WERR_INVALID_PARAM;
8505         }
8506
8507         /*
8508          * if the print job does not have a DEVMODE associated with it,
8509          * just use the one for the printer. A NULL devicemode is not
8510          *  a failure condition
8511          */
8512
8513         nt_devmode = print_job_devmode(lp_const_servicename(snum), jobid);
8514         if (nt_devmode) {
8515                 devmode = TALLOC_ZERO_P(mem_ctx, struct spoolss_DeviceMode);
8516                 W_ERROR_HAVE_NO_MEMORY(devmode);
8517                 result = convert_nt_devicemode(devmode, devmode, nt_devmode);
8518                 if (!W_ERROR_IS_OK(result)) {
8519                         return result;
8520                 }
8521         } else {
8522                 devmode = construct_dev_mode(mem_ctx, lp_const_servicename(snum));
8523                 W_ERROR_HAVE_NO_MEMORY(devmode);
8524         }
8525
8526         return fill_job_info2(mem_ctx,
8527                               r,
8528                               &queue[i-1],
8529                               i,
8530                               snum,
8531                               ntprinter,
8532                               devmode);
8533 }
8534
8535 /****************************************************************
8536  _spoolss_GetJob
8537 ****************************************************************/
8538
8539 WERROR _spoolss_GetJob(pipes_struct *p,
8540                        struct spoolss_GetJob *r)
8541 {
8542         WERROR result = WERR_OK;
8543         NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
8544         int snum;
8545         int count;
8546         print_queue_struct      *queue = NULL;
8547         print_status_struct prt_status;
8548
8549         /* that's an [in out] buffer */
8550
8551         if (!r->in.buffer && (r->in.offered != 0)) {
8552                 return WERR_INVALID_PARAM;
8553         }
8554
8555         DEBUG(5,("_spoolss_GetJob\n"));
8556
8557         *r->out.needed = 0;
8558
8559         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8560                 return WERR_BADFID;
8561         }
8562
8563         result = get_a_printer(NULL, &ntprinter, 2, lp_servicename(snum));
8564         if (!W_ERROR_IS_OK(result)) {
8565                 return result;
8566         }
8567
8568         count = print_queue_status(snum, &queue, &prt_status);
8569
8570         DEBUGADD(4,("count:[%d], prt_status:[%d], [%s]\n",
8571                      count, prt_status.status, prt_status.message));
8572
8573         switch (r->in.level) {
8574         case 1:
8575                 result = getjob_level_1(p->mem_ctx,
8576                                         queue, count, snum, ntprinter,
8577                                         r->in.job_id, &r->out.info->info1);
8578                 break;
8579         case 2:
8580                 result = getjob_level_2(p->mem_ctx,
8581                                         queue, count, snum, ntprinter,
8582                                         r->in.job_id, &r->out.info->info2);
8583                 break;
8584         default:
8585                 result = WERR_UNKNOWN_LEVEL;
8586                 break;
8587         }
8588
8589         SAFE_FREE(queue);
8590         free_a_printer(&ntprinter, 2);
8591
8592         if (!W_ERROR_IS_OK(result)) {
8593                 TALLOC_FREE(r->out.info);
8594                 return result;
8595         }
8596
8597         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_JobInfo, NULL,
8598                                                r->out.info, r->in.level);
8599         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
8600
8601         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8602 }
8603
8604 /****************************************************************
8605  _spoolss_GetPrinterDataEx
8606
8607  From MSDN documentation of GetPrinterDataEx: pass request
8608  to GetPrinterData if key is "PrinterDriverData".
8609 ****************************************************************/
8610
8611 WERROR _spoolss_GetPrinterDataEx(pipes_struct *p,
8612                                  struct spoolss_GetPrinterDataEx *r)
8613 {
8614
8615         Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
8616         REGISTRY_VALUE          *val = NULL;
8617         NT_PRINTER_INFO_LEVEL   *printer = NULL;
8618         int                     snum = 0;
8619         WERROR result = WERR_OK;
8620
8621         DEBUG(4,("_spoolss_GetPrinterDataEx\n"));
8622
8623         DEBUG(10, ("_spoolss_GetPrinterDataEx: key => [%s], value => [%s]\n",
8624                 r->in.key_name, r->in.value_name));
8625
8626         /* in case of problem, return some default values */
8627
8628         *r->out.needed  = 0;
8629         *r->out.type    = REG_NONE;
8630
8631         if (!Printer) {
8632                 DEBUG(2,("_spoolss_GetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
8633                         OUR_HANDLE(r->in.handle)));
8634                 result = WERR_BADFID;
8635                 goto done;
8636         }
8637
8638         /* Is the handle to a printer or to the server? */
8639
8640         if (Printer->printer_type == SPLHND_SERVER) {
8641                 DEBUG(10,("_spoolss_GetPrinterDataEx: "
8642                         "Not implemented for server handles yet\n"));
8643                 result = WERR_INVALID_PARAM;
8644                 goto done;
8645         }
8646
8647         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8648                 return WERR_BADFID;
8649         }
8650
8651         result = get_a_printer(Printer, &printer, 2, lp_servicename(snum));
8652         if (!W_ERROR_IS_OK(result)) {
8653                 goto done;
8654         }
8655
8656         /* check to see if the keyname is valid */
8657         if (!strlen(r->in.key_name)) {
8658                 result = WERR_INVALID_PARAM;
8659                 goto done;
8660         }
8661
8662         if (lookup_printerkey(printer->info_2->data, r->in.key_name) == -1) {
8663                 DEBUG(4,("_spoolss_GetPrinterDataEx: "
8664                         "Invalid keyname [%s]\n", r->in.key_name ));
8665                 result = WERR_BADFILE;
8666                 goto done;
8667         }
8668
8669         /* When given a new keyname, we should just create it */
8670
8671         val = get_printer_data(printer->info_2,
8672                                r->in.key_name, r->in.value_name);
8673         if (!val) {
8674                 result = WERR_BADFILE;
8675                 goto done;
8676         }
8677
8678         *r->out.needed = regval_size(val);
8679
8680         if (*r->out.needed > r->in.offered) {
8681                 result = WERR_MORE_DATA;
8682                 goto done;
8683         }
8684
8685         *r->out.type = regval_type(val);
8686
8687         memcpy(r->out.buffer, regval_data_p(val), regval_size(val));
8688
8689  done:
8690         if (printer) {
8691                 free_a_printer(&printer, 2);
8692         }
8693
8694         return result;
8695 }
8696
8697 /****************************************************************
8698  _spoolss_SetPrinterDataEx
8699 ****************************************************************/
8700
8701 WERROR _spoolss_SetPrinterDataEx(pipes_struct *p,
8702                                  struct spoolss_SetPrinterDataEx *r)
8703 {
8704         NT_PRINTER_INFO_LEVEL   *printer = NULL;
8705         int                     snum = 0;
8706         WERROR                  result = WERR_OK;
8707         Printer_entry           *Printer = find_printer_index_by_hnd(p, r->in.handle);
8708         char                    *oid_string;
8709
8710         DEBUG(4,("_spoolss_SetPrinterDataEx\n"));
8711
8712         /* From MSDN documentation of SetPrinterDataEx: pass request to
8713            SetPrinterData if key is "PrinterDriverData" */
8714
8715         if (!Printer) {
8716                 DEBUG(2,("_spoolss_SetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
8717                         OUR_HANDLE(r->in.handle)));
8718                 return WERR_BADFID;
8719         }
8720
8721         if (Printer->printer_type == SPLHND_SERVER) {
8722                 DEBUG(10,("_spoolss_SetPrinterDataEx: "
8723                         "Not implemented for server handles yet\n"));
8724                 return WERR_INVALID_PARAM;
8725         }
8726
8727         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8728                 return WERR_BADFID;
8729         }
8730
8731         /*
8732          * Access check : NT returns "access denied" if you make a
8733          * SetPrinterData call without the necessary privildge.
8734          * we were originally returning OK if nothing changed
8735          * which made Win2k issue **a lot** of SetPrinterData
8736          * when connecting to a printer  --jerry
8737          */
8738
8739         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
8740                 DEBUG(3, ("_spoolss_SetPrinterDataEx: "
8741                         "change denied by handle access permissions\n"));
8742                 return WERR_ACCESS_DENIED;
8743         }
8744
8745         result = get_a_printer(Printer, &printer, 2, lp_servicename(snum));
8746         if (!W_ERROR_IS_OK(result)) {
8747                 return result;
8748         }
8749
8750         /* check for OID in valuename */
8751
8752         oid_string = strchr(r->in.value_name, ',');
8753         if (oid_string) {
8754                 *oid_string = '\0';
8755                 oid_string++;
8756         }
8757
8758         /* save the registry data */
8759
8760         result = set_printer_dataex(printer, r->in.key_name, r->in.value_name,
8761                                     r->in.type, r->in.buffer, r->in.offered);
8762
8763         if (W_ERROR_IS_OK(result)) {
8764                 /* save the OID if one was specified */
8765                 if (oid_string) {
8766                         char *str = talloc_asprintf(p->mem_ctx, "%s\\%s",
8767                                 r->in.key_name, SPOOL_OID_KEY);
8768                         if (!str) {
8769                                 result = WERR_NOMEM;
8770                                 goto done;
8771                         }
8772
8773                         /*
8774                          * I'm not checking the status here on purpose.  Don't know
8775                          * if this is right, but I'm returning the status from the
8776                          * previous set_printer_dataex() call.  I have no idea if
8777                          * this is right.    --jerry
8778                          */
8779
8780                         set_printer_dataex(printer, str, r->in.value_name,
8781                                            REG_SZ, (uint8_t *)oid_string,
8782                                            strlen(oid_string)+1);
8783                 }
8784
8785                 result = mod_a_printer(printer, 2);
8786         }
8787
8788  done:
8789         free_a_printer(&printer, 2);
8790
8791         return result;
8792 }
8793
8794 /****************************************************************
8795  _spoolss_DeletePrinterDataEx
8796 ****************************************************************/
8797
8798 WERROR _spoolss_DeletePrinterDataEx(pipes_struct *p,
8799                                     struct spoolss_DeletePrinterDataEx *r)
8800 {
8801         NT_PRINTER_INFO_LEVEL   *printer = NULL;
8802         int             snum=0;
8803         WERROR          status = WERR_OK;
8804         Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
8805
8806         DEBUG(5,("_spoolss_DeletePrinterDataEx\n"));
8807
8808         if (!Printer) {
8809                 DEBUG(2,("_spoolss_DeletePrinterDataEx: "
8810                         "Invalid handle (%s:%u:%u).\n",
8811                         OUR_HANDLE(r->in.handle)));
8812                 return WERR_BADFID;
8813         }
8814
8815         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8816                 return WERR_BADFID;
8817
8818         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
8819                 DEBUG(3, ("_spoolss_DeletePrinterDataEx: "
8820                         "printer properties change denied by handle\n"));
8821                 return WERR_ACCESS_DENIED;
8822         }
8823
8824         if (!r->in.value_name || !r->in.key_name) {
8825                 return WERR_NOMEM;
8826         }
8827
8828         status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8829         if (!W_ERROR_IS_OK(status))
8830                 return status;
8831
8832         status = delete_printer_dataex( printer, r->in.key_name, r->in.value_name );
8833
8834         if ( W_ERROR_IS_OK(status) )
8835                 mod_a_printer( printer, 2 );
8836
8837         free_a_printer(&printer, 2);
8838
8839         return status;
8840 }
8841
8842 /****************************************************************
8843  _spoolss_EnumPrinterKey
8844 ****************************************************************/
8845
8846 WERROR _spoolss_EnumPrinterKey(pipes_struct *p,
8847                                struct spoolss_EnumPrinterKey *r)
8848 {
8849         fstring         *keynames = NULL;
8850         int             num_keys;
8851         Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
8852         NT_PRINTER_DATA *data;
8853         NT_PRINTER_INFO_LEVEL   *printer = NULL;
8854         int             snum = 0;
8855         WERROR          result = WERR_BADFILE;
8856         int i;
8857         const char **array = NULL;
8858
8859
8860         DEBUG(4,("_spoolss_EnumPrinterKey\n"));
8861
8862         if (!Printer) {
8863                 DEBUG(2,("_spoolss_EnumPrinterKey: Invalid handle (%s:%u:%u).\n",
8864                         OUR_HANDLE(r->in.handle)));
8865                 return WERR_BADFID;
8866         }
8867
8868         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8869                 return WERR_BADFID;
8870         }
8871
8872         result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8873         if (!W_ERROR_IS_OK(result)) {
8874                 return result;
8875         }
8876
8877         /* get the list of subkey names */
8878
8879         data = printer->info_2->data;
8880
8881         num_keys = get_printer_subkeys(data, r->in.key_name, &keynames);
8882         if (num_keys == -1) {
8883                 result = WERR_BADFILE;
8884                 goto done;
8885         }
8886
8887         *r->out.needed = 4;
8888
8889         array = talloc_zero_array(r->out.key_buffer, const char *, num_keys + 1);
8890         if (!array) {
8891                 result = WERR_NOMEM;
8892                 goto done;
8893         }
8894
8895         for (i=0; i < num_keys; i++) {
8896                 array[i] = talloc_strdup(array, keynames[i]);
8897                 if (!array[i]) {
8898                         result = WERR_NOMEM;
8899                         goto done;
8900                 }
8901
8902                 *r->out.needed += strlen_m_term(keynames[i]) * 2;
8903         }
8904
8905         if (r->in.offered < *r->out.needed) {
8906                 result = WERR_MORE_DATA;
8907                 goto done;
8908         }
8909
8910         result = WERR_OK;
8911
8912         *r->out.key_buffer = array;
8913
8914  done:
8915         if (!W_ERROR_IS_OK(result)) {
8916                 TALLOC_FREE(array);
8917                 ZERO_STRUCTP(r->out.key_buffer);
8918         }
8919
8920         free_a_printer(&printer, 2);
8921         SAFE_FREE(keynames);
8922
8923         return result;
8924 }
8925
8926 /****************************************************************
8927  _spoolss_DeletePrinterKey
8928 ****************************************************************/
8929
8930 WERROR _spoolss_DeletePrinterKey(pipes_struct *p,
8931                                  struct spoolss_DeletePrinterKey *r)
8932 {
8933         Printer_entry           *Printer = find_printer_index_by_hnd(p, r->in.handle);
8934         NT_PRINTER_INFO_LEVEL   *printer = NULL;
8935         int                     snum=0;
8936         WERROR                  status;
8937
8938         DEBUG(5,("_spoolss_DeletePrinterKey\n"));
8939
8940         if (!Printer) {
8941                 DEBUG(2,("_spoolss_DeletePrinterKey: Invalid handle (%s:%u:%u).\n",
8942                         OUR_HANDLE(r->in.handle)));
8943                 return WERR_BADFID;
8944         }
8945
8946         /* if keyname == NULL, return error */
8947
8948         if ( !r->in.key_name )
8949                 return WERR_INVALID_PARAM;
8950
8951         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8952                 return WERR_BADFID;
8953
8954         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
8955                 DEBUG(3, ("_spoolss_DeletePrinterKey: "
8956                         "printer properties change denied by handle\n"));
8957                 return WERR_ACCESS_DENIED;
8958         }
8959
8960         status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8961         if (!W_ERROR_IS_OK(status))
8962                 return status;
8963
8964         /* delete the key and all subneys */
8965
8966         status = delete_all_printer_data( printer->info_2, r->in.key_name );
8967
8968         if ( W_ERROR_IS_OK(status) )
8969                 status = mod_a_printer(printer, 2);
8970
8971         free_a_printer( &printer, 2 );
8972
8973         return status;
8974 }
8975
8976 /****************************************************************
8977 ****************************************************************/
8978
8979 static WERROR registry_value_to_printer_enum_value(TALLOC_CTX *mem_ctx,
8980                                                    REGISTRY_VALUE *v,
8981                                                    struct spoolss_PrinterEnumValues *r)
8982 {
8983         WERROR result;
8984
8985         r->data = TALLOC_ZERO_P(mem_ctx, union spoolss_PrinterData);
8986         W_ERROR_HAVE_NO_MEMORY(r->data);
8987
8988         r->value_name   = talloc_strdup(mem_ctx, regval_name(v));
8989         W_ERROR_HAVE_NO_MEMORY(r->value_name);
8990
8991         r->type         = regval_type(v);
8992         r->data_length  = regval_size(v);
8993
8994         if (r->data_length) {
8995                 DATA_BLOB blob = data_blob_const(regval_data_p(v),
8996                                                  regval_size(v));
8997                 result = pull_spoolss_PrinterData(mem_ctx, &blob,
8998                                                   r->data,
8999                                                   r->type);
9000                 if (!W_ERROR_IS_OK(result)) {
9001                         return result;
9002                 }
9003         }
9004
9005         return WERR_OK;
9006 }
9007
9008 /****************************************************************
9009  _spoolss_EnumPrinterDataEx
9010 ****************************************************************/
9011
9012 WERROR _spoolss_EnumPrinterDataEx(pipes_struct *p,
9013                                   struct spoolss_EnumPrinterDataEx *r)
9014 {
9015         uint32_t        count = 0;
9016         NT_PRINTER_INFO_LEVEL   *printer = NULL;
9017         struct spoolss_PrinterEnumValues *info = NULL;
9018         NT_PRINTER_DATA         *p_data;
9019         Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
9020         int             snum;
9021         WERROR          result;
9022         int             key_index;
9023         int             i;
9024
9025         DEBUG(4,("_spoolss_EnumPrinterDataEx\n"));
9026
9027         *r->out.count = 0;
9028         *r->out.needed = 0;
9029         *r->out.info = NULL;
9030
9031         if (!Printer) {
9032                 DEBUG(2,("_spoolss_EnumPrinterDataEx: Invalid handle (%s:%u:%u1<).\n",
9033                         OUR_HANDLE(r->in.handle)));
9034                 return WERR_BADFID;
9035         }
9036
9037         /*
9038          * first check for a keyname of NULL or "".  Win2k seems to send
9039          * this a lot and we should send back WERR_INVALID_PARAM
9040          * no need to spend time looking up the printer in this case.
9041          * --jerry
9042          */
9043
9044         if (!strlen(r->in.key_name)) {
9045                 result = WERR_INVALID_PARAM;
9046                 goto done;
9047         }
9048
9049         /* get the printer off of disk */
9050
9051         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9052                 return WERR_BADFID;
9053         }
9054
9055         ZERO_STRUCT(printer);
9056         result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9057         if (!W_ERROR_IS_OK(result)) {
9058                 return result;
9059         }
9060
9061         /* now look for a match on the key name */
9062
9063         p_data = printer->info_2->data;
9064
9065         key_index = lookup_printerkey(p_data, r->in.key_name);
9066         if (key_index == -1) {
9067                 DEBUG(10,("_spoolss_EnumPrinterDataEx: Unknown keyname [%s]\n",
9068                         r->in.key_name));
9069                 result = WERR_INVALID_PARAM;
9070                 goto done;
9071         }
9072
9073         /* allocate the memory for the array of pointers -- if necessary */
9074
9075         count = regval_ctr_numvals(p_data->keys[key_index].values);
9076         if (!count) {
9077                 result = WERR_OK; /* ??? */
9078                 goto done;
9079         }
9080
9081         info = TALLOC_ZERO_ARRAY(p->mem_ctx,
9082                                  struct spoolss_PrinterEnumValues,
9083                                  count);
9084         if (!info) {
9085                 DEBUG(0,("_spoolss_EnumPrinterDataEx: talloc() failed\n"));
9086                 result = WERR_NOMEM;
9087                 goto done;
9088         }
9089
9090         /*
9091          * loop through all params and build the array to pass
9092          * back to the  client
9093          */
9094
9095         for (i=0; i < count; i++) {
9096
9097                 REGISTRY_VALUE  *val;
9098
9099                 /* lookup the registry value */
9100
9101                 val = regval_ctr_specific_value(p_data->keys[key_index].values, i);
9102
9103                 DEBUG(10,("retrieved value number [%d] [%s]\n", i, regval_name(val)));
9104
9105                 /* copy the data */
9106
9107                 result = registry_value_to_printer_enum_value(info, val, &info[i]);
9108                 if (!W_ERROR_IS_OK(result)) {
9109                         goto done;
9110                 }
9111         }
9112
9113 #if 0 /* FIXME - gd */
9114         /* housekeeping information in the reply */
9115
9116         /* Fix from Martin Zielinski <mz@seh.de> - ensure
9117          * the hand marshalled container size is a multiple
9118          * of 4 bytes for RPC alignment.
9119          */
9120
9121         if (needed % 4) {
9122                 needed += 4-(needed % 4);
9123         }
9124 #endif
9125         *r->out.count   = count;
9126         *r->out.info    = info;
9127
9128  done:
9129
9130         if (printer) {
9131                 free_a_printer(&printer, 2);
9132         }
9133
9134         if (!W_ERROR_IS_OK(result)) {
9135                 return result;
9136         }
9137
9138         *r->out.needed  = SPOOLSS_BUFFER_ARRAY(p->mem_ctx,
9139                                                spoolss_EnumPrinterDataEx, NULL,
9140                                                *r->out.info,
9141                                                *r->out.count);
9142         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
9143         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, *r->out.count);
9144
9145         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
9146 }
9147
9148 /****************************************************************************
9149 ****************************************************************************/
9150
9151 static WERROR getprintprocessordirectory_level_1(TALLOC_CTX *mem_ctx,
9152                                                  const char *servername,
9153                                                  const char *environment,
9154                                                  struct spoolss_PrintProcessorDirectoryInfo1 *r)
9155 {
9156         WERROR werr;
9157         char *path = NULL;
9158
9159         werr = compose_spoolss_server_path(mem_ctx,
9160                                            servername,
9161                                            environment,
9162                                            SPOOLSS_PRTPROCS_PATH,
9163                                            &path);
9164         if (!W_ERROR_IS_OK(werr)) {
9165                 return werr;
9166         }
9167
9168         DEBUG(4,("print processor directory: [%s]\n", path));
9169
9170         r->directory_name = path;
9171
9172         return WERR_OK;
9173 }
9174
9175 /****************************************************************
9176  _spoolss_GetPrintProcessorDirectory
9177 ****************************************************************/
9178
9179 WERROR _spoolss_GetPrintProcessorDirectory(pipes_struct *p,
9180                                            struct spoolss_GetPrintProcessorDirectory *r)
9181 {
9182         WERROR result;
9183
9184         /* that's an [in out] buffer */
9185
9186         if (!r->in.buffer && (r->in.offered != 0)) {
9187                 return WERR_INVALID_PARAM;
9188         }
9189
9190         DEBUG(5,("_spoolss_GetPrintProcessorDirectory: level %d\n",
9191                 r->in.level));
9192
9193         *r->out.needed = 0;
9194
9195         /* r->in.level is ignored */
9196
9197         result = getprintprocessordirectory_level_1(p->mem_ctx,
9198                                                     r->in.server,
9199                                                     r->in.environment,
9200                                                     &r->out.info->info1);
9201         if (!W_ERROR_IS_OK(result)) {
9202                 TALLOC_FREE(r->out.info);
9203                 return result;
9204         }
9205
9206         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_PrintProcessorDirectoryInfo, NULL,
9207                                                r->out.info, r->in.level);
9208         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
9209
9210         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
9211 }
9212
9213 /*******************************************************************
9214  ********************************************************************/
9215
9216 static bool push_monitorui_buf(TALLOC_CTX *mem_ctx, DATA_BLOB *buf,
9217                                const char *dllname)
9218 {
9219         enum ndr_err_code ndr_err;
9220         struct spoolss_MonitorUi ui;
9221
9222         ui.dll_name = dllname;
9223
9224         ndr_err = ndr_push_struct_blob(buf, mem_ctx, NULL, &ui,
9225                        (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorUi);
9226         if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9227                 NDR_PRINT_DEBUG(spoolss_MonitorUi, &ui);
9228         }
9229         return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9230 }
9231
9232 /*******************************************************************
9233  Streams the monitor UI DLL name in UNICODE
9234 *******************************************************************/
9235
9236 static WERROR xcvtcp_monitorui(TALLOC_CTX *mem_ctx,
9237                                NT_USER_TOKEN *token, DATA_BLOB *in,
9238                                DATA_BLOB *out, uint32_t *needed)
9239 {
9240         const char *dllname = "tcpmonui.dll";
9241
9242         *needed = (strlen(dllname)+1) * 2;
9243
9244         if (out->length < *needed) {
9245                 return WERR_INSUFFICIENT_BUFFER;
9246         }
9247
9248         if (!push_monitorui_buf(mem_ctx, out, dllname)) {
9249                 return WERR_NOMEM;
9250         }
9251
9252         return WERR_OK;
9253 }
9254
9255 /*******************************************************************
9256  ********************************************************************/
9257
9258 static bool pull_port_data_1(TALLOC_CTX *mem_ctx,
9259                              struct spoolss_PortData1 *port1,
9260                              const DATA_BLOB *buf)
9261 {
9262         enum ndr_err_code ndr_err;
9263         ndr_err = ndr_pull_struct_blob(buf, mem_ctx, NULL, port1,
9264                        (ndr_pull_flags_fn_t)ndr_pull_spoolss_PortData1);
9265         if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9266                 NDR_PRINT_DEBUG(spoolss_PortData1, port1);
9267         }
9268         return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9269 }
9270
9271 /*******************************************************************
9272  ********************************************************************/
9273
9274 static bool pull_port_data_2(TALLOC_CTX *mem_ctx,
9275                              struct spoolss_PortData2 *port2,
9276                              const DATA_BLOB *buf)
9277 {
9278         enum ndr_err_code ndr_err;
9279         ndr_err = ndr_pull_struct_blob(buf, mem_ctx, NULL, port2,
9280                        (ndr_pull_flags_fn_t)ndr_pull_spoolss_PortData2);
9281         if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9282                 NDR_PRINT_DEBUG(spoolss_PortData2, port2);
9283         }
9284         return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9285 }
9286
9287 /*******************************************************************
9288  Create a new TCP/IP port
9289 *******************************************************************/
9290
9291 static WERROR xcvtcp_addport(TALLOC_CTX *mem_ctx,
9292                              NT_USER_TOKEN *token, DATA_BLOB *in,
9293                              DATA_BLOB *out, uint32_t *needed)
9294 {
9295         struct spoolss_PortData1 port1;
9296         struct spoolss_PortData2 port2;
9297         char *device_uri = NULL;
9298         uint32_t version;
9299
9300         const char *portname;
9301         const char *hostaddress;
9302         const char *queue;
9303         uint32_t port_number;
9304         uint32_t protocol;
9305
9306         /* peek for spoolss_PortData version */
9307
9308         if (!in || (in->length < (128 + 4))) {
9309                 return WERR_GENERAL_FAILURE;
9310         }
9311
9312         version = IVAL(in->data, 128);
9313
9314         switch (version) {
9315                 case 1:
9316                         ZERO_STRUCT(port1);
9317
9318                         if (!pull_port_data_1(mem_ctx, &port1, in)) {
9319                                 return WERR_NOMEM;
9320                         }
9321
9322                         portname        = port1.portname;
9323                         hostaddress     = port1.hostaddress;
9324                         queue           = port1.queue;
9325                         protocol        = port1.protocol;
9326                         port_number     = port1.port_number;
9327
9328                         break;
9329                 case 2:
9330                         ZERO_STRUCT(port2);
9331
9332                         if (!pull_port_data_2(mem_ctx, &port2, in)) {
9333                                 return WERR_NOMEM;
9334                         }
9335
9336                         portname        = port2.portname;
9337                         hostaddress     = port2.hostaddress;
9338                         queue           = port2.queue;
9339                         protocol        = port2.protocol;
9340                         port_number     = port2.port_number;
9341
9342                         break;
9343                 default:
9344                         DEBUG(1,("xcvtcp_addport: "
9345                                 "unknown version of port_data: %d\n", version));
9346                         return WERR_UNKNOWN_PORT;
9347         }
9348
9349         /* create the device URI and call the add_port_hook() */
9350
9351         switch (protocol) {
9352         case PROTOCOL_RAWTCP_TYPE:
9353                 device_uri = talloc_asprintf(mem_ctx,
9354                                 "socket://%s:%d/", hostaddress,
9355                                 port_number);
9356                 break;
9357
9358         case PROTOCOL_LPR_TYPE:
9359                 device_uri = talloc_asprintf(mem_ctx,
9360                         "lpr://%s/%s", hostaddress, queue );
9361                 break;
9362
9363         default:
9364                 return WERR_UNKNOWN_PORT;
9365         }
9366
9367         if (!device_uri) {
9368                 return WERR_NOMEM;
9369         }
9370
9371         return add_port_hook(mem_ctx, token, portname, device_uri);
9372 }
9373
9374 /*******************************************************************
9375 *******************************************************************/
9376
9377 struct xcv_api_table xcvtcp_cmds[] = {
9378         { "MonitorUI",  xcvtcp_monitorui },
9379         { "AddPort",    xcvtcp_addport},
9380         { NULL,         NULL }
9381 };
9382
9383 static WERROR process_xcvtcp_command(TALLOC_CTX *mem_ctx,
9384                                      NT_USER_TOKEN *token, const char *command,
9385                                      DATA_BLOB *inbuf,
9386                                      DATA_BLOB *outbuf,
9387                                      uint32_t *needed )
9388 {
9389         int i;
9390
9391         DEBUG(10,("process_xcvtcp_command: Received command \"%s\"\n", command));
9392
9393         for ( i=0; xcvtcp_cmds[i].name; i++ ) {
9394                 if ( strcmp( command, xcvtcp_cmds[i].name ) == 0 )
9395                         return xcvtcp_cmds[i].fn(mem_ctx, token, inbuf, outbuf, needed);
9396         }
9397
9398         return WERR_BADFUNC;
9399 }
9400
9401 /*******************************************************************
9402 *******************************************************************/
9403 #if 0   /* don't support management using the "Local Port" monitor */
9404
9405 static WERROR xcvlocal_monitorui(TALLOC_CTX *mem_ctx,
9406                                  NT_USER_TOKEN *token, DATA_BLOB *in,
9407                                  DATA_BLOB *out, uint32_t *needed)
9408 {
9409         const char *dllname = "localui.dll";
9410
9411         *needed = (strlen(dllname)+1) * 2;
9412
9413         if (out->length < *needed) {
9414                 return WERR_INSUFFICIENT_BUFFER;
9415         }
9416
9417         if (!push_monitorui_buf(mem_ctx, out, dllname)) {
9418                 return WERR_NOMEM;
9419         }
9420
9421         return WERR_OK;
9422 }
9423
9424 /*******************************************************************
9425 *******************************************************************/
9426
9427 struct xcv_api_table xcvlocal_cmds[] = {
9428         { "MonitorUI",  xcvlocal_monitorui },
9429         { NULL,         NULL }
9430 };
9431 #else
9432 struct xcv_api_table xcvlocal_cmds[] = {
9433         { NULL,         NULL }
9434 };
9435 #endif
9436
9437
9438
9439 /*******************************************************************
9440 *******************************************************************/
9441
9442 static WERROR process_xcvlocal_command(TALLOC_CTX *mem_ctx,
9443                                        NT_USER_TOKEN *token, const char *command,
9444                                        DATA_BLOB *inbuf, DATA_BLOB *outbuf,
9445                                        uint32_t *needed)
9446 {
9447         int i;
9448
9449         DEBUG(10,("process_xcvlocal_command: Received command \"%s\"\n", command));
9450
9451         for ( i=0; xcvlocal_cmds[i].name; i++ ) {
9452                 if ( strcmp( command, xcvlocal_cmds[i].name ) == 0 )
9453                         return xcvlocal_cmds[i].fn(mem_ctx, token, inbuf, outbuf, needed);
9454         }
9455         return WERR_BADFUNC;
9456 }
9457
9458 /****************************************************************
9459  _spoolss_XcvData
9460 ****************************************************************/
9461
9462 WERROR _spoolss_XcvData(pipes_struct *p,
9463                         struct spoolss_XcvData *r)
9464 {
9465         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9466         DATA_BLOB out_data = data_blob_null;
9467         WERROR werror;
9468
9469         if (!Printer) {
9470                 DEBUG(2,("_spoolss_XcvData: Invalid handle (%s:%u:%u).\n",
9471                         OUR_HANDLE(r->in.handle)));
9472                 return WERR_BADFID;
9473         }
9474
9475         /* Has to be a handle to the TCP/IP port monitor */
9476
9477         if ( !(Printer->printer_type & (SPLHND_PORTMON_LOCAL|SPLHND_PORTMON_TCP)) ) {
9478                 DEBUG(2,("_spoolss_XcvData: Call only valid for Port Monitors\n"));
9479                 return WERR_BADFID;
9480         }
9481
9482         /* requires administrative access to the server */
9483
9484         if ( !(Printer->access_granted & SERVER_ACCESS_ADMINISTER) ) {
9485                 DEBUG(2,("_spoolss_XcvData: denied by handle permissions.\n"));
9486                 return WERR_ACCESS_DENIED;
9487         }
9488
9489         /* Allocate the outgoing buffer */
9490
9491         if (r->in.out_data_size) {
9492                 out_data = data_blob_talloc_zero(p->mem_ctx, r->in.out_data_size);
9493                 if (out_data.data == NULL) {
9494                         return WERR_NOMEM;
9495                 }
9496         }
9497
9498         switch ( Printer->printer_type ) {
9499         case SPLHND_PORTMON_TCP:
9500                 werror = process_xcvtcp_command(p->mem_ctx,
9501                                                 p->server_info->ptok,
9502                                                 r->in.function_name,
9503                                                 &r->in.in_data, &out_data,
9504                                                 r->out.needed);
9505                 break;
9506         case SPLHND_PORTMON_LOCAL:
9507                 werror = process_xcvlocal_command(p->mem_ctx,
9508                                                   p->server_info->ptok,
9509                                                   r->in.function_name,
9510                                                   &r->in.in_data, &out_data,
9511                                                   r->out.needed);
9512                 break;
9513         default:
9514                 werror = WERR_INVALID_PRINT_MONITOR;
9515         }
9516
9517         if (!W_ERROR_IS_OK(werror)) {
9518                 return werror;
9519         }
9520
9521         *r->out.status_code = 0;
9522
9523         memcpy(r->out.out_data, out_data.data, out_data.length);
9524
9525         return WERR_OK;
9526 }
9527
9528 /****************************************************************
9529  _spoolss_AddPrintProcessor
9530 ****************************************************************/
9531
9532 WERROR _spoolss_AddPrintProcessor(pipes_struct *p,
9533                                   struct spoolss_AddPrintProcessor *r)
9534 {
9535         /* for now, just indicate success and ignore the add.  We'll
9536            automatically set the winprint processor for printer
9537            entries later.  Used to debug the LexMark Optra S 1855 PCL
9538            driver --jerry */
9539
9540         return WERR_OK;
9541 }
9542
9543 /****************************************************************
9544  _spoolss_AddPrinter
9545 ****************************************************************/
9546
9547 WERROR _spoolss_AddPrinter(pipes_struct *p,
9548                            struct spoolss_AddPrinter *r)
9549 {
9550         p->rng_fault_state = true;
9551         return WERR_NOT_SUPPORTED;
9552 }
9553
9554 /****************************************************************
9555  _spoolss_GetPrinterDriver
9556 ****************************************************************/
9557
9558 WERROR _spoolss_GetPrinterDriver(pipes_struct *p,
9559                                  struct spoolss_GetPrinterDriver *r)
9560 {
9561         p->rng_fault_state = true;
9562         return WERR_NOT_SUPPORTED;
9563 }
9564
9565 /****************************************************************
9566  _spoolss_ReadPrinter
9567 ****************************************************************/
9568
9569 WERROR _spoolss_ReadPrinter(pipes_struct *p,
9570                             struct spoolss_ReadPrinter *r)
9571 {
9572         p->rng_fault_state = true;
9573         return WERR_NOT_SUPPORTED;
9574 }
9575
9576 /****************************************************************
9577  _spoolss_WaitForPrinterChange
9578 ****************************************************************/
9579
9580 WERROR _spoolss_WaitForPrinterChange(pipes_struct *p,
9581                                      struct spoolss_WaitForPrinterChange *r)
9582 {
9583         p->rng_fault_state = true;
9584         return WERR_NOT_SUPPORTED;
9585 }
9586
9587 /****************************************************************
9588  _spoolss_AddPort
9589 ****************************************************************/
9590
9591 WERROR _spoolss_AddPort(pipes_struct *p,
9592                         struct spoolss_AddPort *r)
9593 {
9594         p->rng_fault_state = true;
9595         return WERR_NOT_SUPPORTED;
9596 }
9597
9598 /****************************************************************
9599  _spoolss_ConfigurePort
9600 ****************************************************************/
9601
9602 WERROR _spoolss_ConfigurePort(pipes_struct *p,
9603                               struct spoolss_ConfigurePort *r)
9604 {
9605         p->rng_fault_state = true;
9606         return WERR_NOT_SUPPORTED;
9607 }
9608
9609 /****************************************************************
9610  _spoolss_DeletePort
9611 ****************************************************************/
9612
9613 WERROR _spoolss_DeletePort(pipes_struct *p,
9614                            struct spoolss_DeletePort *r)
9615 {
9616         p->rng_fault_state = true;
9617         return WERR_NOT_SUPPORTED;
9618 }
9619
9620 /****************************************************************
9621  _spoolss_CreatePrinterIC
9622 ****************************************************************/
9623
9624 WERROR _spoolss_CreatePrinterIC(pipes_struct *p,
9625                                 struct spoolss_CreatePrinterIC *r)
9626 {
9627         p->rng_fault_state = true;
9628         return WERR_NOT_SUPPORTED;
9629 }
9630
9631 /****************************************************************
9632  _spoolss_PlayGDIScriptOnPrinterIC
9633 ****************************************************************/
9634
9635 WERROR _spoolss_PlayGDIScriptOnPrinterIC(pipes_struct *p,
9636                                          struct spoolss_PlayGDIScriptOnPrinterIC *r)
9637 {
9638         p->rng_fault_state = true;
9639         return WERR_NOT_SUPPORTED;
9640 }
9641
9642 /****************************************************************
9643  _spoolss_DeletePrinterIC
9644 ****************************************************************/
9645
9646 WERROR _spoolss_DeletePrinterIC(pipes_struct *p,
9647                                 struct spoolss_DeletePrinterIC *r)
9648 {
9649         p->rng_fault_state = true;
9650         return WERR_NOT_SUPPORTED;
9651 }
9652
9653 /****************************************************************
9654  _spoolss_AddPrinterConnection
9655 ****************************************************************/
9656
9657 WERROR _spoolss_AddPrinterConnection(pipes_struct *p,
9658                                      struct spoolss_AddPrinterConnection *r)
9659 {
9660         p->rng_fault_state = true;
9661         return WERR_NOT_SUPPORTED;
9662 }
9663
9664 /****************************************************************
9665  _spoolss_DeletePrinterConnection
9666 ****************************************************************/
9667
9668 WERROR _spoolss_DeletePrinterConnection(pipes_struct *p,
9669                                         struct spoolss_DeletePrinterConnection *r)
9670 {
9671         p->rng_fault_state = true;
9672         return WERR_NOT_SUPPORTED;
9673 }
9674
9675 /****************************************************************
9676  _spoolss_PrinterMessageBox
9677 ****************************************************************/
9678
9679 WERROR _spoolss_PrinterMessageBox(pipes_struct *p,
9680                                   struct spoolss_PrinterMessageBox *r)
9681 {
9682         p->rng_fault_state = true;
9683         return WERR_NOT_SUPPORTED;
9684 }
9685
9686 /****************************************************************
9687  _spoolss_AddMonitor
9688 ****************************************************************/
9689
9690 WERROR _spoolss_AddMonitor(pipes_struct *p,
9691                            struct spoolss_AddMonitor *r)
9692 {
9693         p->rng_fault_state = true;
9694         return WERR_NOT_SUPPORTED;
9695 }
9696
9697 /****************************************************************
9698  _spoolss_DeleteMonitor
9699 ****************************************************************/
9700
9701 WERROR _spoolss_DeleteMonitor(pipes_struct *p,
9702                               struct spoolss_DeleteMonitor *r)
9703 {
9704         p->rng_fault_state = true;
9705         return WERR_NOT_SUPPORTED;
9706 }
9707
9708 /****************************************************************
9709  _spoolss_DeletePrintProcessor
9710 ****************************************************************/
9711
9712 WERROR _spoolss_DeletePrintProcessor(pipes_struct *p,
9713                                      struct spoolss_DeletePrintProcessor *r)
9714 {
9715         p->rng_fault_state = true;
9716         return WERR_NOT_SUPPORTED;
9717 }
9718
9719 /****************************************************************
9720  _spoolss_AddPrintProvidor
9721 ****************************************************************/
9722
9723 WERROR _spoolss_AddPrintProvidor(pipes_struct *p,
9724                                  struct spoolss_AddPrintProvidor *r)
9725 {
9726         p->rng_fault_state = true;
9727         return WERR_NOT_SUPPORTED;
9728 }
9729
9730 /****************************************************************
9731  _spoolss_DeletePrintProvidor
9732 ****************************************************************/
9733
9734 WERROR _spoolss_DeletePrintProvidor(pipes_struct *p,
9735                                     struct spoolss_DeletePrintProvidor *r)
9736 {
9737         p->rng_fault_state = true;
9738         return WERR_NOT_SUPPORTED;
9739 }
9740
9741 /****************************************************************
9742  _spoolss_FindFirstPrinterChangeNotification
9743 ****************************************************************/
9744
9745 WERROR _spoolss_FindFirstPrinterChangeNotification(pipes_struct *p,
9746                                                    struct spoolss_FindFirstPrinterChangeNotification *r)
9747 {
9748         p->rng_fault_state = true;
9749         return WERR_NOT_SUPPORTED;
9750 }
9751
9752 /****************************************************************
9753  _spoolss_FindNextPrinterChangeNotification
9754 ****************************************************************/
9755
9756 WERROR _spoolss_FindNextPrinterChangeNotification(pipes_struct *p,
9757                                                   struct spoolss_FindNextPrinterChangeNotification *r)
9758 {
9759         p->rng_fault_state = true;
9760         return WERR_NOT_SUPPORTED;
9761 }
9762
9763 /****************************************************************
9764  _spoolss_RouterFindFirstPrinterChangeNotificationOld
9765 ****************************************************************/
9766
9767 WERROR _spoolss_RouterFindFirstPrinterChangeNotificationOld(pipes_struct *p,
9768                                                             struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
9769 {
9770         p->rng_fault_state = true;
9771         return WERR_NOT_SUPPORTED;
9772 }
9773
9774 /****************************************************************
9775  _spoolss_ReplyOpenPrinter
9776 ****************************************************************/
9777
9778 WERROR _spoolss_ReplyOpenPrinter(pipes_struct *p,
9779                                  struct spoolss_ReplyOpenPrinter *r)
9780 {
9781         p->rng_fault_state = true;
9782         return WERR_NOT_SUPPORTED;
9783 }
9784
9785 /****************************************************************
9786  _spoolss_RouterReplyPrinter
9787 ****************************************************************/
9788
9789 WERROR _spoolss_RouterReplyPrinter(pipes_struct *p,
9790                                    struct spoolss_RouterReplyPrinter *r)
9791 {
9792         p->rng_fault_state = true;
9793         return WERR_NOT_SUPPORTED;
9794 }
9795
9796 /****************************************************************
9797  _spoolss_ReplyClosePrinter
9798 ****************************************************************/
9799
9800 WERROR _spoolss_ReplyClosePrinter(pipes_struct *p,
9801                                   struct spoolss_ReplyClosePrinter *r)
9802 {
9803         p->rng_fault_state = true;
9804         return WERR_NOT_SUPPORTED;
9805 }
9806
9807 /****************************************************************
9808  _spoolss_AddPortEx
9809 ****************************************************************/
9810
9811 WERROR _spoolss_AddPortEx(pipes_struct *p,
9812                           struct spoolss_AddPortEx *r)
9813 {
9814         p->rng_fault_state = true;
9815         return WERR_NOT_SUPPORTED;
9816 }
9817
9818 /****************************************************************
9819  _spoolss_RouterFindFirstPrinterChangeNotification
9820 ****************************************************************/
9821
9822 WERROR _spoolss_RouterFindFirstPrinterChangeNotification(pipes_struct *p,
9823                                                          struct spoolss_RouterFindFirstPrinterChangeNotification *r)
9824 {
9825         p->rng_fault_state = true;
9826         return WERR_NOT_SUPPORTED;
9827 }
9828
9829 /****************************************************************
9830  _spoolss_SpoolerInit
9831 ****************************************************************/
9832
9833 WERROR _spoolss_SpoolerInit(pipes_struct *p,
9834                             struct spoolss_SpoolerInit *r)
9835 {
9836         p->rng_fault_state = true;
9837         return WERR_NOT_SUPPORTED;
9838 }
9839
9840 /****************************************************************
9841  _spoolss_ResetPrinterEx
9842 ****************************************************************/
9843
9844 WERROR _spoolss_ResetPrinterEx(pipes_struct *p,
9845                                struct spoolss_ResetPrinterEx *r)
9846 {
9847         p->rng_fault_state = true;
9848         return WERR_NOT_SUPPORTED;
9849 }
9850
9851 /****************************************************************
9852  _spoolss_RouterReplyPrinterEx
9853 ****************************************************************/
9854
9855 WERROR _spoolss_RouterReplyPrinterEx(pipes_struct *p,
9856                                      struct spoolss_RouterReplyPrinterEx *r)
9857 {
9858         p->rng_fault_state = true;
9859         return WERR_NOT_SUPPORTED;
9860 }
9861
9862 /****************************************************************
9863  _spoolss_44
9864 ****************************************************************/
9865
9866 WERROR _spoolss_44(pipes_struct *p,
9867                    struct spoolss_44 *r)
9868 {
9869         p->rng_fault_state = true;
9870         return WERR_NOT_SUPPORTED;
9871 }
9872
9873 /****************************************************************
9874  _spoolss_47
9875 ****************************************************************/
9876
9877 WERROR _spoolss_47(pipes_struct *p,
9878                    struct spoolss_47 *r)
9879 {
9880         p->rng_fault_state = true;
9881         return WERR_NOT_SUPPORTED;
9882 }
9883
9884 /****************************************************************
9885  _spoolss_4a
9886 ****************************************************************/
9887
9888 WERROR _spoolss_4a(pipes_struct *p,
9889                    struct spoolss_4a *r)
9890 {
9891         p->rng_fault_state = true;
9892         return WERR_NOT_SUPPORTED;
9893 }
9894
9895 /****************************************************************
9896  _spoolss_4b
9897 ****************************************************************/
9898
9899 WERROR _spoolss_4b(pipes_struct *p,
9900                    struct spoolss_4b *r)
9901 {
9902         p->rng_fault_state = true;
9903         return WERR_NOT_SUPPORTED;
9904 }
9905
9906 /****************************************************************
9907  _spoolss_4c
9908 ****************************************************************/
9909
9910 WERROR _spoolss_4c(pipes_struct *p,
9911                    struct spoolss_4c *r)
9912 {
9913         p->rng_fault_state = true;
9914         return WERR_NOT_SUPPORTED;
9915 }
9916
9917 /****************************************************************
9918  _spoolss_53
9919 ****************************************************************/
9920
9921 WERROR _spoolss_53(pipes_struct *p,
9922                    struct spoolss_53 *r)
9923 {
9924         p->rng_fault_state = true;
9925         return WERR_NOT_SUPPORTED;
9926 }
9927
9928 /****************************************************************
9929  _spoolss_55
9930 ****************************************************************/
9931
9932 WERROR _spoolss_55(pipes_struct *p,
9933                    struct spoolss_55 *r)
9934 {
9935         p->rng_fault_state = true;
9936         return WERR_NOT_SUPPORTED;
9937 }
9938
9939 /****************************************************************
9940  _spoolss_56
9941 ****************************************************************/
9942
9943 WERROR _spoolss_56(pipes_struct *p,
9944                    struct spoolss_56 *r)
9945 {
9946         p->rng_fault_state = true;
9947         return WERR_NOT_SUPPORTED;
9948 }
9949
9950 /****************************************************************
9951  _spoolss_57
9952 ****************************************************************/
9953
9954 WERROR _spoolss_57(pipes_struct *p,
9955                    struct spoolss_57 *r)
9956 {
9957         p->rng_fault_state = true;
9958         return WERR_NOT_SUPPORTED;
9959 }
9960
9961 /****************************************************************
9962  _spoolss_5a
9963 ****************************************************************/
9964
9965 WERROR _spoolss_5a(pipes_struct *p,
9966                    struct spoolss_5a *r)
9967 {
9968         p->rng_fault_state = true;
9969         return WERR_NOT_SUPPORTED;
9970 }
9971
9972 /****************************************************************
9973  _spoolss_5b
9974 ****************************************************************/
9975
9976 WERROR _spoolss_5b(pipes_struct *p,
9977                    struct spoolss_5b *r)
9978 {
9979         p->rng_fault_state = true;
9980         return WERR_NOT_SUPPORTED;
9981 }
9982
9983 /****************************************************************
9984  _spoolss_5c
9985 ****************************************************************/
9986
9987 WERROR _spoolss_5c(pipes_struct *p,
9988                    struct spoolss_5c *r)
9989 {
9990         p->rng_fault_state = true;
9991         return WERR_NOT_SUPPORTED;
9992 }
9993
9994 /****************************************************************
9995  _spoolss_5d
9996 ****************************************************************/
9997
9998 WERROR _spoolss_5d(pipes_struct *p,
9999                    struct spoolss_5d *r)
10000 {
10001         p->rng_fault_state = true;
10002         return WERR_NOT_SUPPORTED;
10003 }
10004
10005 /****************************************************************
10006  _spoolss_5e
10007 ****************************************************************/
10008
10009 WERROR _spoolss_5e(pipes_struct *p,
10010                    struct spoolss_5e *r)
10011 {
10012         p->rng_fault_state = true;
10013         return WERR_NOT_SUPPORTED;
10014 }
10015
10016 /****************************************************************
10017  _spoolss_5f
10018 ****************************************************************/
10019
10020 WERROR _spoolss_5f(pipes_struct *p,
10021                    struct spoolss_5f *r)
10022 {
10023         p->rng_fault_state = true;
10024         return WERR_NOT_SUPPORTED;
10025 }
10026