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