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