source4/lib/registry/tests/hive.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    local testing of registry library - hives
   5
   6    Copyright (C) Jelmer Vernooij 2005-2007
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #include "includes.h"
  24 #include "lib/registry/registry.h"
  25 #include "torture/torture.h"
  26 #include "librpc/gen_ndr/winreg.h"
  27 #include "system/filesys.h"
  28
  29 static bool test_del_nonexistant_key(struct torture_context *tctx,
  30                                      const void *test_data)
  31 {
  32         const struct hive_key *root = (const struct hive_key *)test_data;
  33         WERROR error = hive_key_del(root, "bla");
  34         torture_assert_werr_equal(tctx, error, WERR_NOT_FOUND,
  35                                   "invalid return code");
  36
  37         return true;
  38 }
  39
  40 static bool test_keyinfo_root(struct torture_context *tctx,
  41                               const void *test_data)
  42 {
  43         uint32_t num_subkeys, num_values;
  44         const struct hive_key *root = (const struct hive_key *)test_data;
  45         WERROR error;
  46
  47         /* This is a new backend. There should be no subkeys and no
  48          * values */
  49         error = hive_key_get_info(tctx, root, NULL, &num_subkeys, &num_values,
  50                                   NULL);
  51         torture_assert_werr_ok(tctx, error, "reg_key_num_subkeys()");
  52
  53         torture_assert_int_equal(tctx, num_subkeys, 0,
  54                                  "New key has non-zero subkey count");
  55
  56         torture_assert_werr_ok(tctx, error, "reg_key_num_values");
  57
  58         torture_assert_int_equal(tctx, num_values, 0,
  59                                  "New key has non-zero value count");
  60
  61         return true;
  62 }
  63
  64 static bool test_keyinfo_nums(struct torture_context *tctx,
  65                               const void *test_data)
  66 {
  67         uint32_t num_subkeys, num_values;
  68         const struct hive_key *root = (const struct hive_key *)test_data;
  69         WERROR error;
  70         struct hive_key *subkey;
  71         uint32_t data = 42;
  72
  73         error = hive_key_add_name(tctx, root, "Nested Keyll", NULL,
  74                                   NULL, &subkey);
  75         torture_assert_werr_ok(tctx, error, "hive_key_add_name");
  76
  77         error = hive_set_value(root, "Answer", REG_DWORD,
  78                                data_blob_talloc(tctx, &data, sizeof(data)));
  79         torture_assert_werr_ok(tctx, error, "hive_set_value");
  80
  81         /* This is a new backend. There should be no subkeys and no
  82          * values */
  83         error = hive_key_get_info(tctx, root, NULL, &num_subkeys, &num_values,
  84                                   NULL);
  85         torture_assert_werr_ok(tctx, error, "reg_key_num_subkeys()");
  86
  87         torture_assert_int_equal(tctx, num_subkeys, 1, "subkey count");
  88
  89         torture_assert_werr_ok(tctx, error, "reg_key_num_values");
  90
  91         torture_assert_int_equal(tctx, num_values, 1, "value count");
  92
  93         return true;
  94 }
  95
  96 static bool test_add_subkey(struct torture_context *tctx,
  97                             const void *test_data)
  98 {
  99         WERROR error;
 100         struct hive_key *subkey;
 101         const struct hive_key *root = (const struct hive_key *)test_data;
 102         TALLOC_CTX *mem_ctx = tctx;
 103
 104         error = hive_key_add_name(mem_ctx, root, "Nested Key", NULL,
 105                                   NULL, &subkey);
 106         torture_assert_werr_ok(tctx, error, "hive_key_add_name");
 107
 108         error = hive_key_del(root, "Nested Key");
 109         torture_assert_werr_ok(tctx, error, "reg_key_del");
 110
 111         return true;
 112 }
 113
 114 static bool test_flush_key(struct torture_context *tctx,
 115                            const void *test_data)
 116 {
 117         const struct hive_key *root = (const struct hive_key *)test_data;
 118
 119         torture_assert_werr_ok(tctx, hive_key_flush(root), "flush key");
 120
 121         return true;
 122 }
 123
 124 static bool test_del_key(struct torture_context *tctx, const void *test_data)
 125 {
 126         WERROR error;
 127         struct hive_key *subkey;
 128         const struct hive_key *root = (const struct hive_key *)test_data;
 129         TALLOC_CTX *mem_ctx = tctx;
 130
 131         error = hive_key_add_name(mem_ctx, root, "Nested Key", NULL,
 132                                   NULL, &subkey);
 133         torture_assert_werr_ok(tctx, error, "hive_key_add_name");
 134
 135         error = hive_key_del(root, "Nested Key");
 136         torture_assert_werr_ok(tctx, error, "reg_key_del");
 137
 138         error = hive_key_del(root, "Nested Key");
 139         torture_assert_werr_equal(tctx, error, WERR_NOT_FOUND, "reg_key_del");
 140
 141         return true;
 142 }
 143
 144 static bool test_set_value(struct torture_context *tctx,
 145                            const void *test_data)
 146 {
 147         WERROR error;
 148         struct hive_key *subkey;
 149         const struct hive_key *root = (const struct hive_key *)test_data;
 150         TALLOC_CTX *mem_ctx = tctx;
 151         uint32_t data = 42;
 152
 153         error = hive_key_add_name(mem_ctx, root, "YA Nested Key", NULL,
 154                                   NULL, &subkey);
 155         torture_assert_werr_ok(tctx, error, "hive_key_add_name");
 156
 157         error = hive_set_value(subkey, "Answer", REG_DWORD,
 158                                data_blob_talloc(mem_ctx, &data, sizeof(data)));
 159         torture_assert_werr_ok(tctx, error, "hive_set_value");
 160
 161         return true;
 162 }
 163
 164 static bool test_get_value(struct torture_context *tctx, const void *test_data)
 165 {
 166         WERROR error;
 167         struct hive_key *subkey;
 168         const struct hive_key *root = (const struct hive_key *)test_data;
 169         TALLOC_CTX *mem_ctx = tctx;
 170         uint32_t data = 42;
 171         uint32_t type;
 172         DATA_BLOB value;
 173
 174         error = hive_key_add_name(mem_ctx, root, "EYA Nested Key", NULL,
 175                                   NULL, &subkey);
 176         torture_assert_werr_ok(tctx, error, "hive_key_add_name");
 177
 178         error = hive_get_value(mem_ctx, subkey, "Answer", &type, &value);
 179         torture_assert_werr_equal(tctx, error, WERR_NOT_FOUND,
 180                                   "getting missing value");
 181
 182         error = hive_set_value(subkey, "Answer", REG_DWORD,
 183                                data_blob_talloc(mem_ctx, &data, sizeof(data)));
 184         torture_assert_werr_ok(tctx, error, "hive_set_value");
 185
 186         error = hive_get_value(mem_ctx, subkey, "Answer", &type, &value);
 187         torture_assert_werr_ok(tctx, error, "getting value");
 188
 189         torture_assert_int_equal(tctx, value.length, 4, "value length");
 190         torture_assert_int_equal(tctx, type, REG_DWORD, "value type");
 191         torture_assert(tctx, memcmp(value.data, &data, 4) == 0, "value data");
 192
 193         return true;
 194 }
 195
 196 static bool test_del_value(struct torture_context *tctx, const void *test_data)
 197 {
 198         WERROR error;
 199         struct hive_key *subkey;
 200         const struct hive_key *root = (const struct hive_key *)test_data;
 201         TALLOC_CTX *mem_ctx = tctx;
 202         uint32_t data = 42;
 203         uint32_t type;
 204         DATA_BLOB value;
 205
 206         error = hive_key_add_name(mem_ctx, root, "EEYA Nested Key", NULL,
 207                                                          NULL, &subkey);
 208         torture_assert_werr_ok(tctx, error, "hive_key_add_name");
 209
 210         error = hive_set_value(subkey, "Answer", REG_DWORD,
 211                                data_blob_talloc(mem_ctx, &data, sizeof(data)));
 212         torture_assert_werr_ok(tctx, error, "hive_set_value");
 213
 214         error = hive_key_del_value(subkey, "Answer");
 215         torture_assert_werr_ok(tctx, error, "deleting value");
 216
 217         error = hive_get_value(mem_ctx, subkey, "Answer", &type, &value);
 218         torture_assert_werr_equal(tctx, error, WERR_NOT_FOUND, "getting value");
 219
 220         error = hive_key_del_value(subkey, "Answer");
 221         torture_assert_werr_equal(tctx, error, WERR_NOT_FOUND,
 222                                   "deleting value");
 223
 224         return true;
 225 }
 226
 227 static bool test_list_values(struct torture_context *tctx,
 228                              const void *test_data)
 229 {
 230         WERROR error;
 231         struct hive_key *subkey;
 232         const struct hive_key *root = (const struct hive_key *)test_data;
 233         TALLOC_CTX *mem_ctx = tctx;
 234         uint32_t data = 42;
 235         uint32_t type;
 236         DATA_BLOB value;
 237         const char *name;
 238
 239         error = hive_key_add_name(mem_ctx, root, "AYAYA Nested Key", NULL,
 240                                   NULL, &subkey);
 241         torture_assert_werr_ok(tctx, error, "hive_key_add_name");
 242
 243         error = hive_set_value(subkey, "Answer", REG_DWORD,
 244                                data_blob_talloc(mem_ctx, &data, sizeof(data)));
 245         torture_assert_werr_ok(tctx, error, "hive_set_value");
 246
 247         error = hive_get_value_by_index(mem_ctx, subkey, 0, &name,
 248                                         &type, &value);
 249         torture_assert_werr_ok(tctx, error, "getting value");
 250
 251         torture_assert_str_equal(tctx, name, "Answer", "value name");
 252
 253         torture_assert_int_equal(tctx, value.length, 4, "value length");
 254         torture_assert_int_equal(tctx, type, REG_DWORD, "value type");
 255         torture_assert(tctx, memcmp(value.data, &data, 4) == 0, "value data");
 256
 257         error = hive_get_value_by_index(mem_ctx, subkey, 1, &name,
 258                                         &type, &value);
 259         torture_assert_werr_equal(tctx, error, WERR_NO_MORE_ITEMS,
 260                                   "getting missing value");
 261
 262         return true;
 263 }
 264
 265 static void tcase_add_tests(struct torture_tcase *tcase)
 266 {
 267         torture_tcase_add_simple_test(tcase, "del_nonexistant_key",
 268                                       test_del_nonexistant_key);
 269         torture_tcase_add_simple_test(tcase, "add_subkey",
 270                                       test_add_subkey);
 271         torture_tcase_add_simple_test(tcase, "flush_key",
 272                                       test_flush_key);
 273         torture_tcase_add_simple_test(tcase, "get_info",
 274                                       test_keyinfo_root);
 275         torture_tcase_add_simple_test(tcase, "get_info_nums",
 276                                       test_keyinfo_nums);
 277         torture_tcase_add_simple_test(tcase, "set_value",
 278                                       test_set_value);
 279         torture_tcase_add_simple_test(tcase, "get_value",
 280                                       test_get_value);
 281         torture_tcase_add_simple_test(tcase, "list_values",
 282                                       test_list_values);
 283         torture_tcase_add_simple_test(tcase, "del_key",
 284                                       test_del_key);
 285         torture_tcase_add_simple_test(tcase, "del_value",
 286                                       test_del_value);
 287 }
 288
 289 static bool hive_setup_dir(struct torture_context *tctx, void **data)
 290 {
 291         struct hive_key *key;
 292         WERROR error;
 293         char *dirname;
 294         NTSTATUS status;
 295
 296         status = torture_temp_dir(tctx, "hive-dir", &dirname);
 297         if (!NT_STATUS_IS_OK(status))
 298                 return false;
 299
 300         rmdir(dirname);
 301
 302         error = reg_create_directory(tctx, dirname, &key);
 303         if (!W_ERROR_IS_OK(error)) {
 304                 fprintf(stderr, "Unable to initialize dir hive\n");
 305                 return false;
 306         }
 307
 308         *data = key;
 309
 310         return true;
 311 }
 312
 313 static bool hive_setup_ldb(struct torture_context *tctx, void **data)
 314 {
 315         struct hive_key *key;
 316         WERROR error;
 317         char *dirname;
 318         NTSTATUS status;
 319
 320         status = torture_temp_dir(tctx, "hive-ldb", &dirname);
 321         if (!NT_STATUS_IS_OK(status))
 322                 return false;
 323
 324         rmdir(dirname);
 325
 326         error = reg_open_ldb_file(tctx, dirname, NULL, NULL, tctx->lp_ctx, &key);
 327         if (!W_ERROR_IS_OK(error)) {
 328                 fprintf(stderr, "Unable to initialize ldb hive\n");
 329                 return false;
 330         }
 331
 332         *data = key;
 333
 334         return true;
 335 }
 336
 337 static bool hive_setup_regf(struct torture_context *tctx, void **data)
 338 {
 339         struct hive_key *key;
 340         WERROR error;
 341         char *dirname;
 342         NTSTATUS status;
 343
 344         status = torture_temp_dir(tctx, "hive-dir", &dirname);
 345         if (!NT_STATUS_IS_OK(status))
 346                 return false;
 347
 348         rmdir(dirname);
 349
 350         error = reg_create_regf_file(tctx, dirname, 5, &key);
 351         if (!W_ERROR_IS_OK(error)) {
 352                 fprintf(stderr, "Unable to create new regf file\n");
 353                 return false;
 354         }
 355
 356         *data = key;
 357
 358         return true;
 359 }
 360
 361 static bool test_dir_refuses_null_location(struct torture_context *tctx)
 362 {
 363         torture_assert_werr_equal(tctx, WERR_INVALID_PARAM,
 364                                   reg_open_directory(NULL, NULL, NULL),
 365                                   "reg_open_directory accepts NULL location");
 366         return true;
 367 }
 368
 369 struct torture_suite *torture_registry_hive(TALLOC_CTX *mem_ctx)
 370 {
 371         struct torture_tcase *tcase;
 372         struct torture_suite *suite = torture_suite_create(mem_ctx, "HIVE");
 373
 374         torture_suite_add_simple_test(suite, "dir-refuses-null-location",
 375                                       test_dir_refuses_null_location);
 376
 377         tcase = torture_suite_add_tcase(suite, "dir");
 378         torture_tcase_set_fixture(tcase, hive_setup_dir, NULL);
 379         tcase_add_tests(tcase);
 380
 381         tcase = torture_suite_add_tcase(suite, "ldb");
 382         torture_tcase_set_fixture(tcase, hive_setup_ldb, NULL);
 383         tcase_add_tests(tcase);
 384
 385         tcase = torture_suite_add_tcase(suite, "regf");
 386         torture_tcase_set_fixture(tcase, hive_setup_regf, NULL);
 387         tcase_add_tests(tcase);
 388
 389         return suite;
 390 }