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