source3/rpc_server/srv_spoolss_nt.c

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