source3/registry/reg_objects.c

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