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