source3/registry/reg_backend_printing.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *  Virtual Windows Registry Layer
   4  *  Copyright (C) Gerald Carter                     2002-2005
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 3 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 /* Implementation of registry virtual views for printing information */
  21
  22 #include "includes.h"
  23 #include "registry.h"
  24 #include "reg_util_internal.h"
  25 #include "reg_backend_db.h"
  26 #include "reg_objects.h"
  27
  28 #undef DBGC_CLASS
  29 #define DBGC_CLASS DBGC_REGISTRY
  30
  31 /* registrt paths used in the print_registry[] */
  32
  33 #define KEY_MONITORS            "HKLM/SYSTEM/CURRENTCONTROLSET/CONTROL/PRINT/MONITORS"
  34 #define KEY_FORMS               "HKLM/SYSTEM/CURRENTCONTROLSET/CONTROL/PRINT/FORMS"
  35 #define KEY_CONTROL_PRINTERS    "HKLM/SYSTEM/CURRENTCONTROLSET/CONTROL/PRINT/PRINTERS"
  36 #define KEY_ENVIRONMENTS        "HKLM/SYSTEM/CURRENTCONTROLSET/CONTROL/PRINT/ENVIRONMENTS"
  37 #define KEY_CONTROL_PRINT       "HKLM/SYSTEM/CURRENTCONTROLSET/CONTROL/PRINT"
  38 #define KEY_WINNT_PRINTERS      "HKLM/SOFTWARE/MICROSOFT/WINDOWS NT/CURRENTVERSION/PRINT/PRINTERS"
  39 #define KEY_WINNT_PRINT         "HKLM/SOFTWARE/MICROSOFT/WINDOWS NT/CURRENTVERSION/PRINT"
  40 #define KEY_PORTS               "HKLM/SOFTWARE/MICROSOFT/WINDOWS NT/CURRENTVERSION/PORTS"
  41
  42 /* callback table for various registry paths below the ones we service in this module */
  43
  44 struct reg_dyn_tree {
  45         /* full key path in normalized form */
  46         const char *path;
  47
  48         /* callbscks for fetch/store operations */
  49         int ( *fetch_subkeys) ( const char *path, struct regsubkey_ctr *subkeys );
  50         bool (*store_subkeys) ( const char *path, struct regsubkey_ctr *subkeys );
  51         int  (*fetch_values)  ( const char *path, struct regval_ctr *values );
  52         bool (*store_values)  ( const char *path, struct regval_ctr *values );
  53 };
  54
  55 /*********************************************************************
  56  *********************************************************************
  57  ** Utility Functions
  58  *********************************************************************
  59  *********************************************************************/
  60
  61 /***********************************************************************
  62  simple function to prune a pathname down to the basename of a file
  63  **********************************************************************/
  64
  65 static const char *dos_basename(const char *path)
  66 {
  67         const char *p;
  68
  69         if (!(p = strrchr( path, '\\'))) {
  70                 p = path;
  71         } else {
  72                 p++;
  73         }
  74
  75         return p;
  76 }
  77
  78 /*********************************************************************
  79  *********************************************************************
  80  ** "HKLM/SYSTEM/CURRENTCONTROLSET/CONTROL/PRINT/FORMS"
  81  *********************************************************************
  82  *********************************************************************/
  83
  84 static int key_forms_fetch_keys(const char *key, struct regsubkey_ctr *subkeys)
  85 {
  86         char *p = reg_remaining_path(talloc_tos(), key + strlen(KEY_FORMS));
  87
  88         /* no keys below Forms */
  89
  90         if (p) {
  91                 return -1;
  92         }
  93
  94         return 0;
  95 }
  96
  97 /**********************************************************************
  98  *********************************************************************/
  99
 100 static int key_forms_fetch_values(const char *key, struct regval_ctr *values)
 101 {
 102         uint32          data[8];
 103         int             i, num_values, form_index = 1;
 104         nt_forms_struct *forms_list = NULL;
 105         nt_forms_struct *form;
 106
 107         DEBUG(10,("print_values_forms: key=>[%s]\n", key ? key : "NULL" ));
 108
 109         num_values = get_ntforms( &forms_list );
 110
 111         DEBUG(10,("hive_forms_fetch_values: [%d] user defined forms returned\n",
 112                 num_values));
 113
 114         /* handle user defined forms */
 115
 116         for ( i=0; i<num_values; i++ ) {
 117                 form = &forms_list[i];
 118
 119                 data[0] = form->width;
 120                 data[1] = form->length;
 121                 data[2] = form->left;
 122                 data[3] = form->top;
 123                 data[4] = form->right;
 124                 data[5] = form->bottom;
 125                 data[6] = form_index++;
 126                 data[7] = form->flag;
 127
 128                 regval_ctr_addvalue(values, form->name, REG_BINARY, (uint8_t *)data, sizeof(data));
 129         }
 130
 131         SAFE_FREE( forms_list );
 132         forms_list = NULL;
 133
 134         /* handle built-on forms */
 135
 136         num_values = get_builtin_ntforms( &forms_list );
 137
 138         DEBUG(10,("print_subpath_values_forms: [%d] built-in forms returned\n",
 139                 num_values));
 140
 141         for ( i=0; i<num_values; i++ ) {
 142                 form = &forms_list[i];
 143
 144                 data[0] = form->width;
 145                 data[1] = form->length;
 146                 data[2] = form->left;
 147                 data[3] = form->top;
 148                 data[4] = form->right;
 149                 data[5] = form->bottom;
 150                 data[6] = form_index++;
 151                 data[7] = form->flag;
 152
 153                 regval_ctr_addvalue(values, form->name, REG_BINARY, (uint8_t *)data, sizeof(data));
 154         }
 155
 156         SAFE_FREE(forms_list);
 157
 158         return regval_ctr_numvals(values);
 159 }
 160
 161 /*********************************************************************
 162  *********************************************************************
 163  ** "HKLM/SYSTEM/CURRENTCONTROLSET/CONTROL/PRINT/PRINTERS"
 164  ** "HKLM/SOFTWARE/MICROSOFT/WINDOWS NT/CURRENTVERSION/PRINT/PRINTERS"
 165  *********************************************************************
 166  *********************************************************************/
 167
 168 /*********************************************************************
 169  strip off prefix for printers key.  DOes return a pointer to static
 170  memory.
 171  *********************************************************************/
 172
 173 static char *strip_printers_prefix(const char *key)
 174 {
 175         char *subkeypath = NULL;
 176         char *path = NULL;
 177         TALLOC_CTX *ctx = talloc_tos();
 178
 179         path = talloc_strdup(ctx, key);
 180         if (!path) {
 181                 return NULL;
 182         }
 183         path = normalize_reg_path(ctx, path);
 184         if (!path) {
 185                 return NULL;
 186         }
 187
 188         /* normalizing the path does not change length, just key delimiters and case */
 189
 190         if (strncmp(path, KEY_WINNT_PRINTERS, strlen(KEY_WINNT_PRINTERS)) == 0) {
 191                 subkeypath = reg_remaining_path(ctx, key + strlen(KEY_WINNT_PRINTERS));
 192         } else {
 193                 subkeypath = reg_remaining_path(ctx, key + strlen(KEY_CONTROL_PRINTERS));
 194         }
 195
 196         TALLOC_FREE(path);
 197         return subkeypath;
 198 }
 199
 200 /*********************************************************************
 201  *********************************************************************/
 202
 203 static int key_printers_fetch_keys( const char *key, struct regsubkey_ctr *subkeys )
 204 {
 205         int n_services = lp_numservices();
 206         int snum;
 207         fstring sname;
 208         int i;
 209         int num_subkeys = 0;
 210         char *printers_key;
 211         char *printername, *printerdatakey;
 212         NT_PRINTER_INFO_LEVEL *printer = NULL;
 213         fstring *subkey_names = NULL;
 214
 215         DEBUG(10,("key_printers_fetch_keys: key=>[%s]\n", key ? key : "NULL" ));
 216
 217         printers_key = strip_printers_prefix( key );
 218
 219         if ( !printers_key ) {
 220                 /* enumerate all printers */
 221
 222                 for (snum=0; snum<n_services; snum++) {
 223                         if ( !(lp_snum_ok(snum) && lp_print_ok(snum) ) )
 224                                 continue;
 225
 226                         /* don't report the [printers] share */
 227
 228                         if ( strequal( lp_servicename(snum), PRINTERS_NAME ) )
 229                                 continue;
 230
 231                         fstrcpy( sname, lp_servicename(snum) );
 232
 233                         regsubkey_ctr_addkey( subkeys, sname );
 234                 }
 235
 236                 num_subkeys = regsubkey_ctr_numkeys( subkeys );
 237                 goto done;
 238         }
 239
 240         /* get information for a specific printer */
 241
 242         if (!reg_split_path( printers_key, &printername, &printerdatakey )) {
 243                 return -1;
 244         }
 245
 246         /* validate the printer name */
 247
 248         for (snum=0; snum<n_services; snum++) {
 249                 if ( !lp_snum_ok(snum) || !lp_print_ok(snum) )
 250                         continue;
 251                 if (strequal( lp_servicename(snum), printername ) )
 252                         break;
 253         }
 254
 255         if ( snum>=n_services
 256                 || !W_ERROR_IS_OK( get_a_printer(NULL, &printer, 2, printername) ) )
 257         {
 258                 return -1;
 259         }
 260
 261         num_subkeys = get_printer_subkeys( printer->info_2->data, printerdatakey?printerdatakey:"", &subkey_names );
 262
 263         for ( i=0; i<num_subkeys; i++ )
 264                 regsubkey_ctr_addkey( subkeys, subkey_names[i] );
 265
 266         free_a_printer( &printer, 2 );
 267
 268         /* no other subkeys below here */
 269
 270 done:
 271         SAFE_FREE( subkey_names );
 272
 273         return num_subkeys;
 274 }
 275
 276 /**********************************************************************
 277  Take a list of names and call add_printer_hook() if necessary
 278  Note that we do this a little differently from Windows since the
 279  keyname is the sharename and not the printer name.
 280  *********************************************************************/
 281
 282 static bool add_printers_by_registry( struct regsubkey_ctr *subkeys )
 283 {
 284         int i, num_keys, snum;
 285         char *printername;
 286         NT_PRINTER_INFO_LEVEL_2 info2;
 287         NT_PRINTER_INFO_LEVEL printer;
 288
 289         ZERO_STRUCT( info2 );
 290         printer.info_2 = &info2;
 291
 292         num_keys = regsubkey_ctr_numkeys( subkeys );
 293
 294         become_root();
 295         for ( i=0; i<num_keys; i++ ) {
 296                 printername = regsubkey_ctr_specific_key( subkeys, i );
 297                 snum = find_service( printername );
 298
 299                 /* just verify a valied snum for now */
 300                 if ( snum == -1 ) {
 301                         fstrcpy( info2.printername, printername );
 302                         fstrcpy( info2.sharename, printername );
 303                         if ( !add_printer_hook(talloc_tos(), NULL, &printer ) ) {
 304                                 DEBUG(0,("add_printers_by_registry: Failed to add printer [%s]\n",
 305                                         printername));
 306                         }
 307                 }
 308         }
 309         unbecome_root();
 310
 311         return True;
 312 }
 313
 314 /**********************************************************************
 315  *********************************************************************/
 316
 317 static bool key_printers_store_keys( const char *key, struct regsubkey_ctr *subkeys )
 318 {
 319         char *printers_key;
 320         char *printername, *printerdatakey;
 321         NT_PRINTER_INFO_LEVEL *printer = NULL;
 322         int i, num_subkeys, num_existing_keys;
 323         char *subkeyname;
 324         fstring *existing_subkeys = NULL;
 325
 326         printers_key = strip_printers_prefix( key );
 327
 328         if ( !printers_key ) {
 329                 /* have to deal with some new or deleted printer */
 330                 return add_printers_by_registry( subkeys );
 331         }
 332
 333         if (!reg_split_path( printers_key, &printername, &printerdatakey )) {
 334                 return False;
 335         }
 336
 337         /* lookup the printer */
 338
 339         if ( !W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, printername)) ) {
 340                 DEBUG(0,("key_printers_store_keys: Tried to store subkey for bad printername %s\n",
 341                         printername));
 342                 return False;
 343         }
 344
 345         /* get the top level printer keys */
 346
 347         num_existing_keys = get_printer_subkeys( printer->info_2->data, "", &existing_subkeys );
 348
 349         for ( i=0; i<num_existing_keys; i++ ) {
 350
 351                 /* remove the key if it has been deleted */
 352
 353                 if ( !regsubkey_ctr_key_exists( subkeys, existing_subkeys[i] ) ) {
 354                         DEBUG(5,("key_printers_store_keys: deleting key %s\n",
 355                                 existing_subkeys[i]));
 356                         delete_printer_key( printer->info_2->data, existing_subkeys[i] );
 357                 }
 358         }
 359
 360         num_subkeys = regsubkey_ctr_numkeys( subkeys );
 361         for ( i=0; i<num_subkeys; i++ ) {
 362                 subkeyname = regsubkey_ctr_specific_key(subkeys, i);
 363                 /* add any missing printer keys */
 364                 if ( lookup_printerkey(printer->info_2->data, subkeyname) == -1 ) {
 365                         DEBUG(5,("key_printers_store_keys: adding key %s\n",
 366                                 existing_subkeys[i]));
 367                         if ( add_new_printer_key( printer->info_2->data, subkeyname ) == -1 ) {
 368                                 SAFE_FREE( existing_subkeys );
 369                                 return False;
 370                         }
 371                 }
 372         }
 373
 374         /* write back to disk */
 375
 376         mod_a_printer( printer, 2 );
 377
 378         /* cleanup */
 379
 380         free_a_printer( &printer, 2 );
 381
 382         SAFE_FREE( existing_subkeys );
 383
 384         return True;
 385 }
 386
 387 /**********************************************************************
 388  *********************************************************************/
 389
 390 static void fill_in_printer_values(NT_PRINTER_INFO_LEVEL_2 *info2, struct regval_ctr *values)
 391 {
 392         struct spoolss_DeviceMode *devmode;
 393         char            *p;
 394         uint32 printer_status = PRINTER_STATUS_OK;
 395
 396         regval_ctr_addvalue( values, "Attributes",       REG_DWORD, (uint8_t *)&info2->attributes,       sizeof(info2->attributes) );
 397         regval_ctr_addvalue( values, "Priority",         REG_DWORD, (uint8_t *)&info2->priority,         sizeof(info2->attributes) );
 398         regval_ctr_addvalue( values, "ChangeID",         REG_DWORD, (uint8_t *)&info2->changeid,         sizeof(info2->changeid) );
 399         regval_ctr_addvalue( values, "Default Priority", REG_DWORD, (uint8_t *)&info2->default_priority, sizeof(info2->default_priority) );
 400
 401         /* lie and say everything is ok since we don't want to call print_queue_length() to get the real status */
 402         regval_ctr_addvalue( values, "Status",           REG_DWORD, (uint8_t *)&printer_status,          sizeof(info2->status) );
 403
 404         regval_ctr_addvalue( values, "StartTime",        REG_DWORD, (uint8_t *)&info2->starttime,        sizeof(info2->starttime) );
 405         regval_ctr_addvalue( values, "UntilTime",        REG_DWORD, (uint8_t *)&info2->untiltime,        sizeof(info2->untiltime) );
 406
 407         /* strip the \\server\ from this string */
 408         if ( !(p = strrchr( info2->printername, '\\' ) ) )
 409                 p = info2->printername;
 410         else
 411                 p++;
 412
 413         regval_ctr_addvalue_sz(values, "Name", p);
 414         regval_ctr_addvalue_sz(values, "Location", info2->location);
 415         regval_ctr_addvalue_sz(values, "Description", info2->comment);
 416         regval_ctr_addvalue_sz(values, "Parameters", info2->parameters);
 417         regval_ctr_addvalue_sz(values, "Port", info2->portname);
 418         regval_ctr_addvalue_sz(values, "Share Name", info2->sharename);
 419         regval_ctr_addvalue_sz(values, "Printer Driver", info2->drivername);
 420         regval_ctr_addvalue_sz(values, "Separator File", info2->sepfile);
 421         regval_ctr_addvalue_sz(values, "Print Processor", info2->printprocessor);
 422         regval_ctr_addvalue_sz(values, "Datatype", info2->datatype);
 423
 424         /* stream the device mode */
 425
 426         devmode = construct_dev_mode(values,info2->sharename);
 427         if (devmode) {
 428                 DATA_BLOB blob;
 429                 enum ndr_err_code ndr_err;
 430
 431                 ndr_err = ndr_push_struct_blob(&blob, values, devmode,
 432                                 (ndr_push_flags_fn_t)ndr_push_spoolss_DeviceMode);
 433
 434                 if (NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 435                         regval_ctr_addvalue(values, "Default Devmode", REG_BINARY,
 436                                             blob.data, blob.length);
 437                 }
 438         }
 439
 440         /* stream the printer security descriptor */
 441
 442         if (info2->secdesc_buf &&
 443             info2->secdesc_buf->sd &&
 444             info2->secdesc_buf->sd_size)
 445         {
 446                 NTSTATUS status;
 447                 DATA_BLOB blob;
 448
 449                 status = marshall_sec_desc(values, info2->secdesc_buf->sd,
 450                                            &blob.data, &blob.length);
 451                 if (NT_STATUS_IS_OK(status)) {
 452                         regval_ctr_addvalue(values, "Security", REG_BINARY,
 453                                             blob.data, blob.length);
 454                 }
 455         }
 456
 457         return;
 458 }
 459
 460 /**********************************************************************
 461  *********************************************************************/
 462
 463 static int key_printers_fetch_values(const char *key, struct regval_ctr *values)
 464 {
 465         int             num_values;
 466         char            *printers_key;
 467         char            *printername, *printerdatakey;
 468         NT_PRINTER_INFO_LEVEL   *printer = NULL;
 469         NT_PRINTER_DATA *p_data;
 470         int             i, key_index;
 471
 472         printers_key = strip_printers_prefix( key );
 473
 474         /* top level key values stored in the registry has no values */
 475
 476         if ( !printers_key ) {
 477                 /* normalize to the 'HKLM\SOFTWARE\...\Print\Printers' key */
 478                 return regdb_fetch_values( KEY_WINNT_PRINTERS, values );
 479         }
 480
 481         /* lookup the printer object */
 482
 483         if (!reg_split_path( printers_key, &printername, &printerdatakey )) {
 484                 return -1;
 485         }
 486
 487         if ( !W_ERROR_IS_OK( get_a_printer(NULL, &printer, 2, printername) ) )
 488                 goto done;
 489
 490         if ( !printerdatakey ) {
 491                 fill_in_printer_values( printer->info_2, values );
 492                 goto done;
 493         }
 494
 495         /* iterate over all printer data keys and fill the regval container */
 496
 497         p_data = printer->info_2->data;
 498         if ( (key_index = lookup_printerkey( p_data, printerdatakey )) == -1  ) {
 499                 /* failure....should never happen if the client has a valid open handle first */
 500                 DEBUG(10,("key_printers_fetch_values: Unknown keyname [%s]\n", printerdatakey));
 501                 free_a_printer( &printer, 2 );
 502                 return -1;
 503         }
 504
 505         num_values = regval_ctr_numvals( p_data->keys[key_index].values );
 506         for ( i=0; i<num_values; i++ )
 507                 regval_ctr_copyvalue( values, regval_ctr_specific_value(p_data->keys[key_index].values, i) );
 508
 509
 510 done:
 511         if ( printer )
 512                 free_a_printer( &printer, 2 );
 513
 514         return regval_ctr_numvals( values );
 515 }
 516
 517 /**********************************************************************
 518  *********************************************************************/
 519
 520 #define REG_IDX_ATTRIBUTES              1
 521 #define REG_IDX_PRIORITY                2
 522 #define REG_IDX_DEFAULT_PRIORITY        3
 523 #define REG_IDX_CHANGEID                4
 524 #define REG_IDX_STATUS                  5
 525 #define REG_IDX_STARTTIME               6
 526 #define REG_IDX_NAME                    7
 527 #define REG_IDX_LOCATION                8
 528 #define REG_IDX_DESCRIPTION             9
 529 #define REG_IDX_PARAMETERS              10
 530 #define REG_IDX_PORT                    12
 531 #define REG_IDX_SHARENAME               13
 532 #define REG_IDX_DRIVER                  14
 533 #define REG_IDX_SEP_FILE                15
 534 #define REG_IDX_PRINTPROC               16
 535 #define REG_IDX_DATATYPE                17
 536 #define REG_IDX_DEVMODE                 18
 537 #define REG_IDX_SECDESC                 19
 538 #define REG_IDX_UNTILTIME               20
 539
 540 struct {
 541         const char *name;
 542         int index;
 543 } printer_values_map[] = {
 544         { "Attributes",         REG_IDX_ATTRIBUTES },
 545         { "Priority",           REG_IDX_PRIORITY },
 546         { "Default Priority",   REG_IDX_DEFAULT_PRIORITY },
 547         { "ChangeID",           REG_IDX_CHANGEID },
 548         { "Status",             REG_IDX_STATUS },
 549         { "StartTime",          REG_IDX_STARTTIME },
 550         { "UntilTime",          REG_IDX_UNTILTIME },
 551         { "Name",               REG_IDX_NAME },
 552         { "Location",           REG_IDX_LOCATION },
 553         { "Description",        REG_IDX_DESCRIPTION },
 554         { "Parameters",         REG_IDX_PARAMETERS },
 555         { "Port",               REG_IDX_PORT },
 556         { "Share Name",         REG_IDX_SHARENAME },
 557         { "Printer Driver",     REG_IDX_DRIVER },
 558         { "Separator File",     REG_IDX_SEP_FILE },
 559         { "Print Processor",    REG_IDX_PRINTPROC },
 560         { "Datatype",           REG_IDX_DATATYPE },
 561         { "Default Devmode",    REG_IDX_DEVMODE },
 562         { "Security",           REG_IDX_SECDESC },
 563         { NULL, -1 }
 564 };
 565
 566
 567 static int find_valuename_index( const char *valuename )
 568 {
 569         int i;
 570
 571         for ( i=0; printer_values_map[i].name; i++ ) {
 572                 if ( strequal( valuename, printer_values_map[i].name ) )
 573                         return printer_values_map[i].index;
 574         }
 575
 576         return -1;
 577 }
 578
 579 /**********************************************************************
 580  *********************************************************************/
 581
 582 static void pull_reg_sz_fstring(TALLOC_CTX *mem_ctx, const DATA_BLOB *blob, fstring s)
 583 {
 584         const char *str;
 585         pull_reg_sz(mem_ctx, blob, &str);
 586         fstrcpy(s, str);
 587 }
 588
 589 static void convert_values_to_printer_info_2(TALLOC_CTX *mem_ctx,
 590                                              NT_PRINTER_INFO_LEVEL_2 *printer2,
 591                                              struct regval_ctr *values)
 592 {
 593         int num_values = regval_ctr_numvals( values );
 594         uint32 value_index;
 595         struct regval_blob *val;
 596         int i;
 597
 598         for ( i=0; i<num_values; i++ ) {
 599                 DATA_BLOB blob;
 600                 val = regval_ctr_specific_value( values, i );
 601                 value_index = find_valuename_index( regval_name( val ) );
 602
 603                 blob = data_blob_const(regval_data_p(val), regval_size(val));
 604
 605                 switch( value_index ) {
 606                         case REG_IDX_ATTRIBUTES:
 607                                 printer2->attributes = (uint32)(*regval_data_p(val));
 608                                 break;
 609                         case REG_IDX_PRIORITY:
 610                                 printer2->priority = (uint32)(*regval_data_p(val));
 611                                 break;
 612                         case REG_IDX_DEFAULT_PRIORITY:
 613                                 printer2->default_priority = (uint32)(*regval_data_p(val));
 614                                 break;
 615                         case REG_IDX_CHANGEID:
 616                                 printer2->changeid = (uint32)(*regval_data_p(val));
 617                                 break;
 618                         case REG_IDX_STARTTIME:
 619                                 printer2->starttime = (uint32)(*regval_data_p(val));
 620                                 break;
 621                         case REG_IDX_UNTILTIME:
 622                                 printer2->untiltime = (uint32)(*regval_data_p(val));
 623                                 break;
 624                         case REG_IDX_NAME:
 625                                 pull_reg_sz_fstring(mem_ctx, &blob, printer2->printername);
 626                                 break;
 627                         case REG_IDX_LOCATION:
 628                                 pull_reg_sz_fstring(mem_ctx, &blob, printer2->location);
 629                                 break;
 630                         case REG_IDX_DESCRIPTION:
 631                                 pull_reg_sz_fstring(mem_ctx, &blob, printer2->comment);
 632                                 break;
 633                         case REG_IDX_PARAMETERS:
 634                                 pull_reg_sz_fstring(mem_ctx, &blob, printer2->parameters);
 635                                 break;
 636                         case REG_IDX_PORT:
 637                                 pull_reg_sz_fstring(mem_ctx, &blob, printer2->portname);
 638                                 break;
 639                         case REG_IDX_SHARENAME:
 640                                 pull_reg_sz_fstring(mem_ctx, &blob, printer2->sharename);
 641                                 break;
 642                         case REG_IDX_DRIVER:
 643                                 pull_reg_sz_fstring(mem_ctx, &blob, printer2->drivername);
 644                                 break;
 645                         case REG_IDX_SEP_FILE:
 646                                 pull_reg_sz_fstring(mem_ctx, &blob, printer2->sepfile);
 647                                 break;
 648                         case REG_IDX_PRINTPROC:
 649                                 pull_reg_sz_fstring(mem_ctx, &blob, printer2->printprocessor);
 650                                 break;
 651                         case REG_IDX_DATATYPE:
 652                                 pull_reg_sz_fstring(mem_ctx, &blob, printer2->datatype);
 653                                 break;
 654                         case REG_IDX_DEVMODE:
 655                                 break;
 656                         case REG_IDX_SECDESC:
 657                                 break;
 658                         default:
 659                                 /* unsupported value...throw away */
 660                                 DEBUG(8,("convert_values_to_printer_info_2: Unsupported registry value [%s]\n",
 661                                         regval_name( val ) ));
 662                 }
 663         }
 664
 665         return;
 666 }
 667
 668 /**********************************************************************
 669  *********************************************************************/
 670
 671 static bool key_printers_store_values(const char *key, struct regval_ctr *values)
 672 {
 673         char *printers_key;
 674         char *printername, *keyname;
 675         NT_PRINTER_INFO_LEVEL   *printer = NULL;
 676         WERROR result;
 677         TALLOC_CTX *mem_ctx = talloc_init("key_printers_store_values");
 678
 679         printers_key = strip_printers_prefix( key );
 680
 681         /* values in the top level key get stored in the registry */
 682
 683         if ( !printers_key ) {
 684                 /* normalize on the 'HKLM\SOFTWARE\....\Print\Printers' key */
 685                 return regdb_store_values( KEY_WINNT_PRINTERS, values );
 686         }
 687
 688         if (!reg_split_path( printers_key, &printername, &keyname )) {
 689                 return False;
 690         }
 691
 692         if ( !W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, printername) ) )
 693                 return False;
 694
 695         /* deal with setting values directly under the printername */
 696
 697         if ( !keyname ) {
 698                 convert_values_to_printer_info_2(mem_ctx, printer->info_2, values );
 699         }
 700         else {
 701                 int num_values = regval_ctr_numvals( values );
 702                 int i;
 703                 struct regval_blob *val;
 704
 705                 delete_printer_key( printer->info_2->data, keyname );
 706
 707                 /* deal with any subkeys */
 708                 for ( i=0; i<num_values; i++ ) {
 709                         val = regval_ctr_specific_value( values, i );
 710                         result = set_printer_dataex( printer, keyname,
 711                                 regval_name( val ),
 712                                 regval_type( val ),
 713                                 regval_data_p( val ),
 714                                 regval_size( val ) );
 715                         if ( !W_ERROR_IS_OK(result) ) {
 716                                 DEBUG(0,("key_printers_store_values: failed to set printer data [%s]!\n",
 717                                         keyname));
 718                                 free_a_printer( &printer, 2 );
 719                                 talloc_destroy(mem_ctx);
 720                                 return False;
 721                         }
 722                 }
 723         }
 724
 725         result = mod_a_printer( printer, 2 );
 726
 727         free_a_printer( &printer, 2 );
 728         talloc_destroy(mem_ctx);
 729
 730         return W_ERROR_IS_OK(result);
 731 }
 732
 733 /*********************************************************************
 734  *********************************************************************
 735  ** "HKLM/SYSTEM/CURRENTCONTROLSET/CONTROL/PRINT/ENVIRONMENTS"
 736  *********************************************************************
 737  *********************************************************************/
 738
 739 static int key_driver_fetch_keys( const char *key, struct regsubkey_ctr *subkeys )
 740 {
 741         const char *environments[] = {
 742                 "Windows 4.0",
 743                 "Windows NT x86",
 744                 "Windows NT R4000",
 745                 "Windows NT Alpha_AXP",
 746                 "Windows NT PowerPC",
 747                 "Windows IA64",
 748                 "Windows x64",
 749                 NULL };
 750         fstring *drivers = NULL;
 751         int i, env_index, num_drivers;
 752         char *keystr, *base, *subkeypath;
 753         char *key2 = NULL;
 754         int num_subkeys = -1;
 755         int version;
 756         TALLOC_CTX *ctx = talloc_tos();
 757
 758         DEBUG(10,("key_driver_fetch_keys key=>[%s]\n", key ? key : "NULL" ));
 759
 760         keystr = reg_remaining_path(ctx, key + strlen(KEY_ENVIRONMENTS) );
 761
 762         /* list all possible architectures */
 763
 764         if ( !keystr ) {
 765                 for ( num_subkeys=0; environments[num_subkeys]; num_subkeys++ )
 766                         regsubkey_ctr_addkey( subkeys,  environments[num_subkeys] );
 767
 768                 return num_subkeys;
 769         }
 770
 771         /* we are dealing with a subkey of "Environments */
 772         key2 = talloc_strdup(ctx, keystr);
 773         if (!key2) {
 774                 return -1;
 775         }
 776         keystr = key2;
 777         if (!reg_split_path(keystr, &base, &subkeypath )) {
 778                 return -1;
 779         }
 780
 781         /* sanity check */
 782
 783         for ( env_index=0; environments[env_index]; env_index++ ) {
 784                 if ( strequal( environments[env_index], base ) )
 785                         break;
 786         }
 787         if ( !environments[env_index] )
 788                 return -1;
 789
 790         /* ...\Print\Environements\...\ */
 791
 792         if ( !subkeypath ) {
 793                 regsubkey_ctr_addkey( subkeys, "Drivers" );
 794                 regsubkey_ctr_addkey( subkeys, "Print Processors" );
 795
 796                 return 2;
 797         }
 798
 799         /* more of the key path to process */
 800
 801         keystr = subkeypath;
 802         if (!reg_split_path( keystr, &base, &subkeypath )) {
 803                 return -1;
 804         }
 805
 806         /* ...\Print\Environements\...\Drivers\ */
 807
 808         if ( !subkeypath ) {
 809                 if ( strequal(base, "Drivers") ) {
 810                         switch ( env_index ) {
 811                                 case 0: /* Win9x */
 812                                         regsubkey_ctr_addkey( subkeys, "Version-0" );
 813                                         break;
 814                                 default: /* Windows NT based systems */
 815                                         regsubkey_ctr_addkey( subkeys, "Version-2" );
 816                                         regsubkey_ctr_addkey( subkeys, "Version-3" );
 817                                         break;
 818                         }
 819
 820                         return regsubkey_ctr_numkeys( subkeys );
 821                 } else if ( strequal(base, "Print Processors") ) {
 822                         if ( env_index == 1 || env_index == 5 || env_index == 6 )
 823
 824
 825                         return regsubkey_ctr_numkeys( subkeys );
 826                 } else
 827                         return -1;      /* bad path */
 828         }
 829
 830         /* we finally get to enumerate the drivers */
 831
 832         /* only one possible subkey below PrintProc key */
 833
 834         if ( strequal(base, "Print Processors") ) {
 835                 keystr = subkeypath;
 836                 if (!reg_split_path( keystr, &base, &subkeypath )) {
 837                         return -1;
 838                 }
 839
 840                 /* no subkeys below this point */
 841
 842                 if ( subkeypath )
 843                         return -1;
 844
 845                 /* only allow one keyname here -- 'winprint' */
 846
 847                 return strequal( base, "winprint" ) ? 0 : -1;
 848         }
 849
 850         /* only dealing with drivers from here on out */
 851
 852         keystr = subkeypath;
 853         if (!reg_split_path( keystr, &base, &subkeypath )) {
 854                 return -1;
 855         }
 856
 857         version = atoi(&base[strlen(base)-1]);
 858
 859         switch (env_index) {
 860         case 0:
 861                 if ( version != 0 )
 862                         return -1;
 863                 break;
 864         default:
 865                 if ( version != 2 && version != 3 )
 866                         return -1;
 867                 break;
 868         }
 869
 870
 871         if ( !subkeypath ) {
 872                 num_drivers = get_ntdrivers( &drivers, environments[env_index], version );
 873                 for ( i=0; i<num_drivers; i++ )
 874                         regsubkey_ctr_addkey( subkeys, drivers[i] );
 875
 876                 return regsubkey_ctr_numkeys( subkeys );
 877         }
 878
 879         /* if anything else left, just say if has no subkeys */
 880
 881         DEBUG(1,("key_driver_fetch_keys unhandled key [%s] (subkey == %s)\n",
 882                 key, subkeypath ));
 883
 884         return 0;
 885 }
 886
 887
 888 /**********************************************************************
 889  *********************************************************************/
 890
 891 static void fill_in_driver_values(const struct spoolss_DriverInfo8 *r,
 892                                   struct regval_ctr *values)
 893 {
 894         uint8_t *buffer = NULL;
 895         int buffer_size = 0;
 896         int i, length;
 897         const char *filename;
 898         DATA_BLOB data;
 899
 900         filename = dos_basename(r->driver_path);
 901         regval_ctr_addvalue_sz(values, "Driver", filename);
 902
 903         filename = dos_basename(r->config_file);
 904         regval_ctr_addvalue_sz(values, "Configuration File", filename);
 905
 906         filename = dos_basename(r->data_file);
 907         regval_ctr_addvalue_sz(values, "Data File", filename);
 908
 909         filename = dos_basename(r->help_file);
 910         regval_ctr_addvalue_sz(values, "Help File", filename);
 911
 912         regval_ctr_addvalue_sz(values, "Datatype", r->default_datatype);
 913         regval_ctr_addvalue_sz(values, "Monitor", r->monitor_name);
 914
 915         regval_ctr_addvalue( values, "Version", REG_DWORD, (uint8_t *)&r->version,
 916                 sizeof(r->version) );
 917
 918         if (r->dependent_files) {
 919                 /* place the list of dependent files in a single
 920                    character buffer, separating each file name by
 921                    a NULL */
 922
 923                 for (i=0; r->dependent_files[i] && strcmp(r->dependent_files[i], ""); i++) {
 924                         /* strip the path to only the file's base name */
 925
 926                         filename = dos_basename(r->dependent_files[i]);
 927
 928                         length = strlen(filename);
 929
 930                         buffer = (uint8_t *)SMB_REALLOC( buffer, buffer_size + (length + 1)*sizeof(uint16) );
 931                         if ( !buffer ) {
 932                                 break;
 933                         }
 934
 935                         push_reg_sz(talloc_tos(), &data, filename);
 936                         memcpy( buffer+buffer_size, data.data, data.length);
 937
 938                         buffer_size += (length + 1)*sizeof(uint16);
 939                 }
 940
 941                 /* terminated by double NULL.  Add the final one here */
 942
 943                 buffer = (uint8_t *)SMB_REALLOC( buffer, buffer_size + 2 );
 944                 if ( !buffer ) {
 945                         buffer_size = 0;
 946                 } else {
 947                         buffer[buffer_size++] = (uint8_t)'\0';
 948                         buffer[buffer_size++] = (uint8_t)'\0';
 949                 }
 950         }
 951
 952         regval_ctr_addvalue( values, "Dependent Files",    REG_MULTI_SZ, buffer, buffer_size );
 953
 954         SAFE_FREE( buffer );
 955
 956         return;
 957 }
 958
 959 /**********************************************************************
 960  *********************************************************************/
 961
 962 static int driver_arch_fetch_values(char *key, struct regval_ctr *values)
 963 {
 964         char            *keystr, *base, *subkeypath;
 965         fstring         arch_environment;
 966         fstring         driver;
 967         int             version;
 968         struct spoolss_DriverInfo8 *driver_ctr;
 969         WERROR          w_result;
 970
 971         if (!reg_split_path( key, &base, &subkeypath )) {
 972                 return -1;
 973         }
 974
 975         /* no values in 'Environments\Drivers\Windows NT x86' */
 976
 977         if ( !subkeypath )
 978                 return 0;
 979
 980         /* We have the Architecture string and some subkey name:
 981            Currently we only support
 982            * Drivers
 983            * Print Processors
 984            Anything else is an error.
 985            */
 986
 987         fstrcpy( arch_environment, base );
 988
 989         keystr = subkeypath;
 990         if (!reg_split_path( keystr, &base, &subkeypath )) {
 991                 return -1;
 992         }
 993
 994         if ( strequal(base, "Print Processors") )
 995                 return 0;
 996
 997         /* only Drivers key can be left */
 998
 999         if ( !strequal(base, "Drivers") )
1000                 return -1;
1001
1002         if ( !subkeypath )
1003                 return 0;
1004
1005         /* We know that we have Architechure\Drivers with some subkey name
1006            The subkey name has to be Version-XX */
1007
1008         keystr = subkeypath;
1009         if (!reg_split_path( keystr, &base, &subkeypath )) {
1010                 return -1;
1011         }
1012
1013         if ( !subkeypath )
1014                 return 0;
1015
1016         version = atoi(&base[strlen(base)-1]);
1017
1018         /* BEGIN PRINTER DRIVER NAME BLOCK */
1019
1020         keystr = subkeypath;
1021         if (!reg_split_path( keystr, &base, &subkeypath )) {
1022                 return -1;
1023         }
1024
1025         /* don't go any deeper for now */
1026
1027         fstrcpy( driver, base );
1028
1029         w_result = get_a_printer_driver(talloc_tos(), &driver_ctr, driver, arch_environment, version);
1030
1031         if ( !W_ERROR_IS_OK(w_result) )
1032                 return -1;
1033
1034         fill_in_driver_values(driver_ctr, values);
1035
1036         free_a_printer_driver(driver_ctr);
1037
1038         /* END PRINTER DRIVER NAME BLOCK */
1039
1040
1041         DEBUG(8,("key_driver_fetch_values: Exit\n"));
1042
1043         return regval_ctr_numvals( values );
1044 }
1045
1046 /**********************************************************************
1047  *********************************************************************/
1048
1049 static int key_driver_fetch_values(const char *key, struct regval_ctr *values)
1050 {
1051         char *keystr = NULL;
1052         char *subkey = NULL;
1053         TALLOC_CTX *ctx = talloc_tos();
1054
1055         DEBUG(8,("key_driver_fetch_values: Enter key => [%s]\n", key ? key : "NULL"));
1056
1057         /* no values in the Environments key */
1058
1059         if (!(keystr = reg_remaining_path(ctx, key + strlen(KEY_ENVIRONMENTS))))
1060                 return 0;
1061
1062         subkey = talloc_strdup(ctx, keystr);
1063         if (!subkey) {
1064                 return 0;
1065         }
1066
1067         /* pass off to handle subkeys */
1068
1069         return driver_arch_fetch_values( subkey, values );
1070 }
1071
1072 /*********************************************************************
1073  *********************************************************************
1074  ** "HKLM/SYSTEM/CURRENTCONTROLSET/CONTROL/PRINT"
1075  *********************************************************************
1076  *********************************************************************/
1077
1078 static int key_print_fetch_keys( const char *key, struct regsubkey_ctr *subkeys )
1079 {
1080         int key_len = strlen(key);
1081
1082         /* no keys below 'Print' handled here */
1083
1084         if ( (key_len != strlen(KEY_CONTROL_PRINT)) && (key_len != strlen(KEY_WINNT_PRINT)) )
1085                 return -1;
1086
1087         regsubkey_ctr_addkey( subkeys, "Environments" );
1088         regsubkey_ctr_addkey( subkeys, "Monitors" );
1089         regsubkey_ctr_addkey( subkeys, "Forms" );
1090         regsubkey_ctr_addkey( subkeys, "Printers" );
1091
1092         return regsubkey_ctr_numkeys( subkeys );
1093 }
1094
1095 /**********************************************************************
1096  *********************************************************************
1097  ** Structure to hold dispatch table of ops for various printer keys.
1098  ** Make sure to always store deeper keys along the same path first so
1099  ** we ge a more specific match.
1100  *********************************************************************
1101  *********************************************************************/
1102
1103 static struct reg_dyn_tree print_registry[] = {
1104 /* just pass the monitor onto the registry tdb */
1105 { KEY_MONITORS,
1106         &regdb_fetch_keys,
1107         &regdb_store_keys,
1108         &regdb_fetch_values,
1109         &regdb_store_values },
1110 { KEY_FORMS,
1111         &key_forms_fetch_keys,
1112         NULL,
1113         &key_forms_fetch_values,
1114         NULL },
1115 { KEY_CONTROL_PRINTERS,
1116         &key_printers_fetch_keys,
1117         &key_printers_store_keys,
1118         &key_printers_fetch_values,
1119         &key_printers_store_values },
1120 { KEY_ENVIRONMENTS,
1121         &key_driver_fetch_keys,
1122         NULL,
1123         &key_driver_fetch_values,
1124         NULL },
1125 { KEY_CONTROL_PRINT,
1126         &key_print_fetch_keys,
1127         NULL,
1128         NULL,
1129         NULL },
1130 { KEY_WINNT_PRINTERS,
1131         &key_printers_fetch_keys,
1132         &key_printers_store_keys,
1133         &key_printers_fetch_values,
1134         &key_printers_store_values },
1135 { KEY_PORTS,
1136         &regdb_fetch_keys,
1137         &regdb_store_keys,
1138         &regdb_fetch_values,
1139         &regdb_store_values },
1140
1141 { NULL, NULL, NULL, NULL, NULL }
1142 };
1143
1144
1145 /**********************************************************************
1146  *********************************************************************
1147  ** Main reg_printing interface functions
1148  *********************************************************************
1149  *********************************************************************/
1150
1151 /***********************************************************************
1152  Lookup a key in the print_registry table, returning its index.
1153  -1 on failure
1154  **********************************************************************/
1155
1156 static int match_registry_path(const char *key)
1157 {
1158         int i;
1159         char *path = NULL;
1160         TALLOC_CTX *ctx = talloc_tos();
1161
1162         if ( !key )
1163                 return -1;
1164
1165         path = talloc_strdup(ctx, key);
1166         if (!path) {
1167                 return -1;
1168         }
1169         path = normalize_reg_path(ctx, path);
1170         if (!path) {
1171                 return -1;
1172         }
1173
1174         for ( i=0; print_registry[i].path; i++ ) {
1175                 if (strncmp( path, print_registry[i].path, strlen(print_registry[i].path) ) == 0 )
1176                         return i;
1177         }
1178
1179         return -1;
1180 }
1181
1182 /***********************************************************************
1183  **********************************************************************/
1184
1185 static int regprint_fetch_reg_keys( const char *key, struct regsubkey_ctr *subkeys )
1186 {
1187         int i = match_registry_path( key );
1188
1189         if ( i == -1 )
1190                 return -1;
1191
1192         if ( !print_registry[i].fetch_subkeys )
1193                 return -1;
1194
1195         return print_registry[i].fetch_subkeys( key, subkeys );
1196 }
1197
1198 /**********************************************************************
1199  *********************************************************************/
1200
1201 static bool regprint_store_reg_keys( const char *key, struct regsubkey_ctr *subkeys )
1202 {
1203         int i = match_registry_path( key );
1204
1205         if ( i == -1 )
1206                 return False;
1207
1208         if ( !print_registry[i].store_subkeys )
1209                 return False;
1210
1211         return print_registry[i].store_subkeys( key, subkeys );
1212 }
1213
1214 /**********************************************************************
1215  *********************************************************************/
1216
1217 static int regprint_fetch_reg_values(const char *key, struct regval_ctr *values)
1218 {
1219         int i = match_registry_path( key );
1220
1221         if ( i == -1 )
1222                 return -1;
1223
1224         /* return 0 values by default since we know the key had
1225            to exist because the client opened a handle */
1226
1227         if ( !print_registry[i].fetch_values )
1228                 return 0;
1229
1230         return print_registry[i].fetch_values( key, values );
1231 }
1232
1233 /**********************************************************************
1234  *********************************************************************/
1235
1236 static bool regprint_store_reg_values(const char *key, struct regval_ctr *values)
1237 {
1238         int i = match_registry_path( key );
1239
1240         if ( i == -1 )
1241                 return False;
1242
1243         if ( !print_registry[i].store_values )
1244                 return False;
1245
1246         return print_registry[i].store_values( key, values );
1247 }
1248
1249 /*
1250  * Table of function pointers for accessing printing data
1251  */
1252
1253 struct registry_ops printing_ops = {
1254         .fetch_subkeys = regprint_fetch_reg_keys,
1255         .fetch_values = regprint_fetch_reg_values,
1256         .store_subkeys = regprint_store_reg_keys,
1257         .store_values = regprint_store_reg_values,
1258 };