source3/registry/reg_objects.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 frontend view functions. */
  21
  22 #include "includes.h"
  23 #include "registry.h"
  24
  25 #undef DBGC_CLASS
  26 #define DBGC_CLASS DBGC_REGISTRY
  27
  28 /* low level structure to contain registry values */
  29
  30 struct regval_blob {
  31         fstring         valuename;
  32         uint16          type;
  33         /* this should be encapsulated in an RPC_DATA_BLOB */
  34         uint32          size;   /* in bytes */
  35         uint8           *data_p;
  36 };
  37
  38 /* container for registry values */
  39
  40 struct regval_ctr {
  41         uint32          num_values;
  42         struct regval_blob **values;
  43         int seqnum;
  44 };
  45
  46 struct regsubkey_ctr {
  47         uint32_t        num_subkeys;
  48         char            **subkeys;
  49         struct db_context *subkeys_hash;
  50         int seqnum;
  51 };
  52
  53 /**********************************************************************
  54
  55  Note that the struct regsubkey_ctr and struct regval_ctr objects *must* be
  56  talloc()'d since the methods use the object pointer as the talloc
  57  context for internal private data.
  58
  59  There is no longer a regval_ctr_intit() and regval_ctr_destroy()
  60  pair of functions.  Simply TALLOC_ZERO_P() and TALLOC_FREE() the
  61  object.
  62
  63  **********************************************************************/
  64
  65 WERROR regsubkey_ctr_init(TALLOC_CTX *mem_ctx, struct regsubkey_ctr **ctr)
  66 {
  67         if (ctr == NULL) {
  68                 return WERR_INVALID_PARAM;
  69         }
  70
  71         *ctr = talloc_zero(mem_ctx, struct regsubkey_ctr);
  72         if (*ctr == NULL) {
  73                 return WERR_NOMEM;
  74         }
  75
  76         (*ctr)->subkeys_hash = db_open_rbt(*ctr);
  77         if ((*ctr)->subkeys_hash == NULL) {
  78                 talloc_free(*ctr);
  79                 return WERR_NOMEM;
  80         }
  81
  82         return WERR_OK;
  83 }
  84
  85 /**
  86  * re-initialize the list of subkeys (to the emtpy list)
  87  * in an already allocated regsubkey_ctr
  88  */
  89
  90 WERROR regsubkey_ctr_reinit(struct regsubkey_ctr *ctr)
  91 {
  92         if (ctr == NULL) {
  93                 return WERR_INVALID_PARAM;
  94         }
  95
  96         talloc_free(ctr->subkeys_hash);
  97         ctr->subkeys_hash = db_open_rbt(ctr);
  98         W_ERROR_HAVE_NO_MEMORY(ctr->subkeys_hash);
  99
 100         TALLOC_FREE(ctr->subkeys);
 101
 102         ctr->num_subkeys = 0;
 103         ctr->seqnum = 0;
 104
 105         return WERR_OK;
 106 }
 107
 108 WERROR regsubkey_ctr_set_seqnum(struct regsubkey_ctr *ctr, int seqnum)
 109 {
 110         if (ctr == NULL) {
 111                 return WERR_INVALID_PARAM;
 112         }
 113
 114         ctr->seqnum = seqnum;
 115
 116         return WERR_OK;
 117 }
 118
 119 int regsubkey_ctr_get_seqnum(struct regsubkey_ctr *ctr)
 120 {
 121         if (ctr == NULL) {
 122                 return -1;
 123         }
 124
 125         return ctr->seqnum;
 126 }
 127
 128 static WERROR regsubkey_ctr_hash_keyname(struct regsubkey_ctr *ctr,
 129                                          const char *keyname,
 130                                          uint32 idx)
 131 {
 132         WERROR werr;
 133
 134         werr = ntstatus_to_werror(dbwrap_store_bystring_upper(ctr->subkeys_hash,
 135                                                 keyname,
 136                                                 make_tdb_data((uint8 *)&idx,
 137                                                               sizeof(idx)),
 138                                                 TDB_REPLACE));
 139         if (!W_ERROR_IS_OK(werr)) {
 140                 DEBUG(1, ("error hashing new key '%s' in container: %s\n",
 141                           keyname, win_errstr(werr)));
 142         }
 143
 144         return werr;
 145 }
 146
 147 static WERROR regsubkey_ctr_unhash_keyname(struct regsubkey_ctr *ctr,
 148                                            const char *keyname)
 149 {
 150         WERROR werr;
 151
 152         werr = ntstatus_to_werror(dbwrap_delete_bystring_upper(ctr->subkeys_hash,
 153                                   keyname));
 154         if (!W_ERROR_IS_OK(werr)) {
 155                 DEBUG(1, ("error unhashing key '%s' in container: %s\n",
 156                           keyname, win_errstr(werr)));
 157         }
 158
 159         return werr;
 160 }
 161
 162 static WERROR regsubkey_ctr_index_for_keyname(struct regsubkey_ctr *ctr,
 163                                               const char *keyname,
 164                                               uint32 *idx)
 165 {
 166         TDB_DATA data;
 167
 168         if ((ctr == NULL) || (keyname == NULL)) {
 169                 return WERR_INVALID_PARAM;
 170         }
 171
 172         data = dbwrap_fetch_bystring_upper(ctr->subkeys_hash, ctr, keyname);
 173         if (data.dptr == NULL) {
 174                 return WERR_NOT_FOUND;
 175         }
 176
 177         if (data.dsize != sizeof(*idx)) {
 178                 talloc_free(data.dptr);
 179                 return WERR_INVALID_DATATYPE;
 180         }
 181
 182         if (idx != NULL) {
 183                 *idx = *(uint32 *)data.dptr;
 184         }
 185
 186         talloc_free(data.dptr);
 187         return WERR_OK;
 188 }
 189
 190 /***********************************************************************
 191  Add a new key to the array
 192  **********************************************************************/
 193
 194 WERROR regsubkey_ctr_addkey( struct regsubkey_ctr *ctr, const char *keyname )
 195 {
 196         char **newkeys;
 197         WERROR werr;
 198
 199         if ( !keyname ) {
 200                 return WERR_OK;
 201         }
 202
 203         /* make sure the keyname is not already there */
 204
 205         if ( regsubkey_ctr_key_exists( ctr, keyname ) ) {
 206                 return WERR_OK;
 207         }
 208
 209         if (!(newkeys = TALLOC_REALLOC_ARRAY(ctr, ctr->subkeys, char *,
 210                                              ctr->num_subkeys+1))) {
 211                 return WERR_NOMEM;
 212         }
 213
 214         ctr->subkeys = newkeys;
 215
 216         if (!(ctr->subkeys[ctr->num_subkeys] = talloc_strdup(ctr->subkeys,
 217                                                              keyname ))) {
 218                 /*
 219                  * Don't shrink the new array again, this wastes a pointer
 220                  */
 221                 return WERR_NOMEM;
 222         }
 223
 224         werr = regsubkey_ctr_hash_keyname(ctr, keyname, ctr->num_subkeys);
 225         W_ERROR_NOT_OK_RETURN(werr);
 226
 227         ctr->num_subkeys++;
 228
 229         return WERR_OK;
 230 }
 231
 232  /***********************************************************************
 233  Delete a key from the array
 234  **********************************************************************/
 235
 236 WERROR regsubkey_ctr_delkey( struct regsubkey_ctr *ctr, const char *keyname )
 237 {
 238         WERROR werr;
 239         uint32 idx, j;
 240
 241         if (keyname == NULL) {
 242                 return WERR_INVALID_PARAM;
 243         }
 244
 245         /* make sure the keyname is actually already there */
 246
 247         werr = regsubkey_ctr_index_for_keyname(ctr, keyname, &idx);
 248         W_ERROR_NOT_OK_RETURN(werr);
 249
 250         werr = regsubkey_ctr_unhash_keyname(ctr, keyname);
 251         W_ERROR_NOT_OK_RETURN(werr);
 252
 253         /* update if we have any keys left */
 254         ctr->num_subkeys--;
 255         if (idx < ctr->num_subkeys) {
 256                 memmove(&ctr->subkeys[idx], &ctr->subkeys[idx+1],
 257                         sizeof(char *) * (ctr->num_subkeys - idx));
 258
 259                 /* we have to re-hash rest of the array...  :-( */
 260                 for (j = idx; j < ctr->num_subkeys; j++) {
 261                         werr = regsubkey_ctr_hash_keyname(ctr, ctr->subkeys[j], j);
 262                         W_ERROR_NOT_OK_RETURN(werr);
 263                 }
 264         }
 265
 266         return WERR_OK;
 267 }
 268
 269 /***********************************************************************
 270  Check for the existance of a key
 271  **********************************************************************/
 272
 273 bool regsubkey_ctr_key_exists( struct regsubkey_ctr *ctr, const char *keyname )
 274 {
 275         WERROR werr;
 276
 277         if (!ctr->subkeys) {
 278                 return False;
 279         }
 280
 281         werr = regsubkey_ctr_index_for_keyname(ctr, keyname, NULL);
 282         if (!W_ERROR_IS_OK(werr)) {
 283                 return false;
 284         }
 285
 286         return true;
 287 }
 288
 289 /***********************************************************************
 290  How many keys does the container hold ?
 291  **********************************************************************/
 292
 293 int regsubkey_ctr_numkeys( struct regsubkey_ctr *ctr )
 294 {
 295         return ctr->num_subkeys;
 296 }
 297
 298 /***********************************************************************
 299  Retreive a specific key string
 300  **********************************************************************/
 301
 302 char* regsubkey_ctr_specific_key( struct regsubkey_ctr *ctr, uint32_t key_index )
 303 {
 304         if ( ! (key_index < ctr->num_subkeys) )
 305                 return NULL;
 306
 307         return ctr->subkeys[key_index];
 308 }
 309
 310 /*
 311  * Utility functions for struct regval_ctr
 312  */
 313
 314 /**
 315  * allocate a regval_ctr structure.
 316  */
 317 WERROR regval_ctr_init(TALLOC_CTX *mem_ctx, struct regval_ctr **ctr)
 318 {
 319         if (ctr == NULL) {
 320                 return WERR_INVALID_PARAM;
 321         }
 322
 323         *ctr = talloc_zero(mem_ctx, struct regval_ctr);
 324         if (*ctr == NULL) {
 325                 return WERR_NOMEM;
 326         }
 327
 328         return WERR_OK;
 329 }
 330
 331 /***********************************************************************
 332  How many keys does the container hold ?
 333  **********************************************************************/
 334
 335 int regval_ctr_numvals(struct regval_ctr *ctr)
 336 {
 337         return ctr->num_values;
 338 }
 339
 340 /***********************************************************************
 341  allocate memory for and duplicate a struct regval_blob.
 342  This is malloc'd memory so the caller should free it when done
 343  **********************************************************************/
 344
 345 struct regval_blob* dup_registry_value(struct regval_blob *val)
 346 {
 347         struct regval_blob *copy = NULL;
 348
 349         if ( !val )
 350                 return NULL;
 351
 352         if ( !(copy = SMB_MALLOC_P( struct regval_blob)) ) {
 353                 DEBUG(0,("dup_registry_value: malloc() failed!\n"));
 354                 return NULL;
 355         }
 356
 357         /* copy all the non-pointer initial data */
 358
 359         memcpy( copy, val, sizeof(struct regval_blob) );
 360
 361         copy->size = 0;
 362         copy->data_p = NULL;
 363
 364         if ( val->data_p && val->size )
 365         {
 366                 if ( !(copy->data_p = (uint8 *)memdup( val->data_p,
 367                                                        val->size )) ) {
 368                         DEBUG(0,("dup_registry_value: memdup() failed for [%d] "
 369                                  "bytes!\n", val->size));
 370                         SAFE_FREE( copy );
 371                         return NULL;
 372                 }
 373                 copy->size = val->size;
 374         }
 375
 376         return copy;
 377 }
 378
 379 /**********************************************************************
 380  free the memory allocated to a struct regval_blob
 381  *********************************************************************/
 382
 383 void free_registry_value(struct regval_blob *val)
 384 {
 385         if ( !val )
 386                 return;
 387
 388         SAFE_FREE( val->data_p );
 389         SAFE_FREE( val );
 390
 391         return;
 392 }
 393
 394 /**********************************************************************
 395  *********************************************************************/
 396
 397 uint8* regval_data_p(struct regval_blob *val)
 398 {
 399         return val->data_p;
 400 }
 401
 402 /**********************************************************************
 403  *********************************************************************/
 404
 405 uint32 regval_size(struct regval_blob *val)
 406 {
 407         return val->size;
 408 }
 409
 410 /**********************************************************************
 411  *********************************************************************/
 412
 413 char* regval_name(struct regval_blob *val)
 414 {
 415         return val->valuename;
 416 }
 417
 418 /**********************************************************************
 419  *********************************************************************/
 420
 421 uint32 regval_type(struct regval_blob *val)
 422 {
 423         return val->type;
 424 }
 425
 426 /***********************************************************************
 427  Retreive a pointer to a specific value.  Caller shoud dup the structure
 428  since this memory will go away when the ctr is free()'d
 429  **********************************************************************/
 430
 431 struct regval_blob *regval_ctr_specific_value(struct regval_ctr *ctr,
 432                                               uint32 idx)
 433 {
 434         if ( !(idx < ctr->num_values) )
 435                 return NULL;
 436
 437         return ctr->values[idx];
 438 }
 439
 440 /***********************************************************************
 441  Check for the existance of a value
 442  **********************************************************************/
 443
 444 bool regval_ctr_key_exists(struct regval_ctr *ctr, const char *value)
 445 {
 446         int     i;
 447
 448         for ( i=0; i<ctr->num_values; i++ ) {
 449                 if ( strequal( ctr->values[i]->valuename, value) )
 450                         return True;
 451         }
 452
 453         return False;
 454 }
 455
 456 /***********************************************************************
 457  * compose a struct regval_blob from input data
 458  **********************************************************************/
 459
 460 struct regval_blob *regval_compose(TALLOC_CTX *ctx, const char *name,
 461                                    uint16 type,
 462                                    const uint8 *data_p, size_t size)
 463 {
 464         struct regval_blob *regval = TALLOC_P(ctx, struct regval_blob);
 465
 466         if (regval == NULL) {
 467                 return NULL;
 468         }
 469
 470         fstrcpy(regval->valuename, name);
 471         regval->type = type;
 472         if (size) {
 473                 regval->data_p = (uint8 *)TALLOC_MEMDUP(regval, data_p, size);
 474                 if (!regval->data_p) {
 475                         TALLOC_FREE(regval);
 476                         return NULL;
 477                 }
 478         } else {
 479                 regval->data_p = NULL;
 480         }
 481         regval->size = size;
 482
 483         return regval;
 484 }
 485
 486 /***********************************************************************
 487  Add a new registry value to the array
 488  **********************************************************************/
 489
 490 int regval_ctr_addvalue(struct regval_ctr *ctr, const char *name, uint16 type,
 491                         const uint8 *data_p, size_t size)
 492 {
 493         if ( !name )
 494                 return ctr->num_values;
 495
 496         /* Delete the current value (if it exists) and add the new one */
 497
 498         regval_ctr_delvalue( ctr, name );
 499
 500         /* allocate a slot in the array of pointers */
 501
 502         if (  ctr->num_values == 0 ) {
 503                 ctr->values = TALLOC_P( ctr, struct regval_blob *);
 504         } else {
 505                 ctr->values = TALLOC_REALLOC_ARRAY(ctr, ctr->values,
 506                                                    struct regval_blob *,
 507                                                    ctr->num_values+1);
 508         }
 509
 510         if (!ctr->values) {
 511                 ctr->num_values = 0;
 512                 return 0;
 513         }
 514
 515         /* allocate a new value and store the pointer in the arrya */
 516
 517         ctr->values[ctr->num_values] = regval_compose(ctr, name, type, data_p,
 518                                                       size);
 519         if (ctr->values[ctr->num_values] == NULL) {
 520                 ctr->num_values = 0;
 521                 return 0;
 522         }
 523         ctr->num_values++;
 524
 525         return ctr->num_values;
 526 }
 527
 528 /***********************************************************************
 529  Add a new registry SZ value to the array
 530  **********************************************************************/
 531
 532 int regval_ctr_addvalue_sz(struct regval_ctr *ctr, const char *name, const char *data)
 533 {
 534         DATA_BLOB blob;
 535
 536         if (!push_reg_sz(ctr, &blob, data)) {
 537                 return -1;
 538         }
 539
 540         return regval_ctr_addvalue(ctr, name, REG_SZ,
 541                                    (const uint8 *)blob.data,
 542                                    blob.length);
 543 }
 544
 545 /***********************************************************************
 546  Add a new registry MULTI_SZ value to the array
 547  **********************************************************************/
 548
 549 int regval_ctr_addvalue_multi_sz(struct regval_ctr *ctr, const char *name, const char **data)
 550 {
 551         DATA_BLOB blob;
 552
 553         if (!push_reg_multi_sz(ctr, &blob, data)) {
 554                 return -1;
 555         }
 556
 557         return regval_ctr_addvalue(ctr, name, REG_MULTI_SZ,
 558                                    (const uint8 *)blob.data,
 559                                    blob.length);
 560 }
 561
 562 /***********************************************************************
 563  Add a new registry value to the array
 564  **********************************************************************/
 565
 566 int regval_ctr_copyvalue(struct regval_ctr *ctr, struct regval_blob *val)
 567 {
 568         if ( val ) {
 569                 regval_ctr_addvalue(ctr, val->valuename, val->type,
 570                                     (uint8 *)val->data_p, val->size);
 571         }
 572
 573         return ctr->num_values;
 574 }
 575
 576 /***********************************************************************
 577  Delete a single value from the registry container.
 578  No need to free memory since it is talloc'd.
 579  **********************************************************************/
 580
 581 int regval_ctr_delvalue(struct regval_ctr *ctr, const char *name)
 582 {
 583         int     i;
 584
 585         for ( i=0; i<ctr->num_values; i++ ) {
 586                 if ( strequal( ctr->values[i]->valuename, name ) )
 587                         break;
 588         }
 589
 590         /* just return if we don't find it */
 591
 592         if ( i == ctr->num_values )
 593                 return ctr->num_values;
 594
 595         /* If 'i' was not the last element, just shift everything down one */
 596         ctr->num_values--;
 597         if ( i < ctr->num_values )
 598                 memmove(&ctr->values[i], &ctr->values[i+1],
 599                         sizeof(struct regval_blob*)*(ctr->num_values-i));
 600
 601         return ctr->num_values;
 602 }
 603
 604 /***********************************************************************
 605  Retrieve single value from the registry container.
 606  No need to free memory since it is talloc'd.
 607  **********************************************************************/
 608
 609 struct regval_blob* regval_ctr_getvalue(struct regval_ctr *ctr,
 610                                         const char *name)
 611 {
 612         int     i;
 613
 614         /* search for the value */
 615
 616         for ( i=0; i<ctr->num_values; i++ ) {
 617                 if ( strequal( ctr->values[i]->valuename, name ) )
 618                         return ctr->values[i];
 619         }
 620
 621         return NULL;
 622 }
 623
 624 int regval_ctr_get_seqnum(struct regval_ctr *ctr)
 625 {
 626         if (ctr == NULL) {
 627                 return -1;
 628         }
 629
 630         return ctr->seqnum;
 631 }
 632
 633 WERROR regval_ctr_set_seqnum(struct regval_ctr *ctr, int seqnum)
 634 {
 635         if (ctr == NULL) {
 636                 return WERR_INVALID_PARAM;
 637         }
 638
 639         ctr->seqnum = seqnum;
 640
 641         return WERR_OK;
 642 }
 643
 644 /***********************************************************************
 645  return the data_p as a uint32
 646  **********************************************************************/
 647
 648 uint32 regval_dword(struct regval_blob *val)
 649 {
 650         uint32 data;
 651
 652         data = IVAL( regval_data_p(val), 0 );
 653
 654         return data;
 655 }
 656
 657 /***********************************************************************
 658  return the data_p as a character string
 659  **********************************************************************/
 660
 661 const char *regval_sz(struct regval_blob *val)
 662 {
 663         const char *data = NULL;
 664         DATA_BLOB blob = data_blob_const(regval_data_p(val), regval_size(val));
 665
 666         pull_reg_sz(talloc_tos(), &blob, &data);
 667
 668         return data;
 669 }