source4/torture/local/fsrvp_state.c

   1 /*
   2    Test suite for FSRVP server state
   3
   4    Copyright (C) David Disseldorp 2012-2015
   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 #include "includes.h"
  21 #include <unistd.h>
  22
  23 #include "librpc/gen_ndr/security.h"
  24 #include "lib/param/param.h"
  25 #include "lib/util/dlinklist.h"
  26 #include "libcli/resolve/resolve.h"
  27 #include "librpc/gen_ndr/ndr_fsrvp.h"
  28 #include "librpc/gen_ndr/ndr_fsrvp_c.h"
  29 #include "source3/rpc_server/fss/srv_fss_private.h"
  30 #include "torture/torture.h"
  31 #include "torture/local/proto.h"
  32
  33 static bool test_fsrvp_state_empty(struct torture_context *tctx)
  34 {
  35         NTSTATUS status;
  36         struct fss_global fss_global;
  37         struct stat sbuf;
  38         char db_dir[] = "fsrvp_torture_XXXXXX";
  39         char *db_path = talloc_asprintf(NULL, "%s/%s",
  40                                         mkdtemp(db_dir), FSS_DB_NAME);
  41
  42         memset(&fss_global, 0, sizeof(fss_global));
  43         fss_global.mem_ctx = talloc_new(NULL);
  44         fss_global.db_path = db_path;
  45
  46         status = fss_state_store(fss_global.mem_ctx, fss_global.sc_sets,
  47                                  fss_global.sc_sets_count, fss_global.db_path);
  48         torture_assert_ntstatus_ok(tctx, status,
  49                                    "failed to store empty fss state");
  50
  51         torture_assert_int_equal(tctx, stat(fss_global.db_path, &sbuf), 0,
  52                         "failed to stat fss state tdb");
  53         talloc_free(fss_global.mem_ctx);
  54
  55         memset(&fss_global, 0, sizeof(fss_global));
  56         fss_global.mem_ctx = talloc_new(NULL);
  57         fss_global.db_path = db_path;
  58
  59         status = fss_state_retrieve(fss_global.mem_ctx, &fss_global.sc_sets,
  60                                     &fss_global.sc_sets_count,
  61                                     fss_global.db_path);
  62         torture_assert_ntstatus_ok(tctx, status,
  63                                    "failed to retrieve empty fss state");
  64         torture_assert_int_equal(tctx, fss_global.sc_sets_count, 0,
  65                                  "sc_sets_count set when it should be zero");
  66         talloc_free(fss_global.mem_ctx);
  67         unlink(db_path);
  68         rmdir(db_dir);
  69         talloc_free(db_path);
  70
  71         return true;
  72 }
  73
  74 static bool test_fsrvp_state_sc_set(struct torture_context *tctx,
  75                                     TALLOC_CTX *mem_ctx,
  76                                     struct fss_sc_set **sc_set_out)
  77 {
  78         struct fss_sc_set *sc_set;
  79
  80         sc_set = talloc_zero(mem_ctx, struct fss_sc_set);
  81         sc_set->id = GUID_random();
  82         sc_set->id_str = GUID_string(sc_set, &sc_set->id);
  83         sc_set->state = FSS_SC_COMMITED;
  84         sc_set->context = FSRVP_CTX_FILE_SHARE_BACKUP;
  85         *sc_set_out = sc_set;
  86
  87         return true;
  88 }
  89
  90 static bool test_fsrvp_state_sc(struct torture_context *tctx,
  91                                 TALLOC_CTX *mem_ctx,
  92                                 struct fss_sc **sc_out)
  93 {
  94         struct fss_sc *sc;
  95
  96         sc = talloc_zero(mem_ctx, struct fss_sc);
  97         sc->id = GUID_random();
  98         sc->id_str = GUID_string(sc, &sc->id);
  99         sc->volume_name = talloc_strdup(sc, "/this/is/a/path");
 100         /* keep snap path NULL, i.e. not yet commited */
 101         sc->create_ts = time(NULL);
 102         *sc_out = sc;
 103
 104         return true;
 105 }
 106
 107 static bool test_fsrvp_state_smap(struct torture_context *tctx,
 108                                 TALLOC_CTX *mem_ctx,
 109                                 const char *base_share_name,
 110                                 const char *sc_share_name,
 111                                 struct fss_sc_smap **smap_out)
 112 {
 113         struct fss_sc_smap *smap;
 114
 115         smap = talloc_zero(mem_ctx, struct fss_sc_smap);
 116         smap->share_name = talloc_strdup(mem_ctx, base_share_name);
 117         smap->sc_share_name = talloc_strdup(mem_ctx, sc_share_name);
 118         smap->sc_share_comment = talloc_strdup(mem_ctx, "test sc share comment");
 119         smap->is_exposed = false;
 120         *smap_out = smap;
 121
 122         return true;
 123 }
 124
 125 static bool test_fsrvp_state_smap_compare(struct torture_context *tctx,
 126                                           struct fss_sc_smap *smap_1,
 127                                           struct fss_sc_smap *smap_2)
 128 {
 129         /* already confirmed by caller */
 130         torture_assert_str_equal(tctx, smap_1->sc_share_name,
 131                                  smap_2->sc_share_name,
 132                                  "smap sc share name strings differ");
 133
 134         torture_assert_str_equal(tctx, smap_1->share_name,
 135                                  smap_2->share_name,
 136                                  "smap share name strings differ");
 137
 138         torture_assert_str_equal(tctx, smap_1->sc_share_comment,
 139                                  smap_2->sc_share_comment,
 140                                  "smap sc share comment strings differ");
 141
 142         torture_assert(tctx, (smap_1->is_exposed == smap_2->is_exposed),
 143                        "smap exposure settings differ");
 144
 145         return true;
 146 }
 147
 148 static bool test_fsrvp_state_sc_compare(struct torture_context *tctx,
 149                                         struct fss_sc *sc_1,
 150                                         struct fss_sc *sc_2)
 151 {
 152         struct fss_sc_smap *smap_1;
 153         struct fss_sc_smap *smap_2;
 154         bool ok;
 155
 156         /* should have already been confirmed by the caller */
 157         torture_assert(tctx, GUID_equal(&sc_1->id, &sc_2->id),
 158                        "sc guids differ");
 159
 160         torture_assert_str_equal(tctx, sc_1->volume_name, sc_2->volume_name,
 161                                  "sc volume_name strings differ");
 162
 163         /* may be null, assert_str_eq handles null ptrs safely */
 164         torture_assert_str_equal(tctx, sc_1->sc_path, sc_2->sc_path,
 165                                  "sc path strings differ");
 166
 167         torture_assert(tctx, difftime(sc_1->create_ts, sc_2->create_ts) == 0,
 168                        "sc create timestamps differ");
 169
 170         torture_assert_int_equal(tctx, sc_1->smaps_count, sc_2->smaps_count,
 171                                  "sc smaps counts differ");
 172
 173         for (smap_1 = sc_1->smaps; smap_1; smap_1 = smap_1->next) {
 174                 bool matched = false;
 175                 for (smap_2 = sc_2->smaps; smap_2; smap_2 = smap_2->next) {
 176                         if (strcmp(smap_1->sc_share_name,
 177                                    smap_2->sc_share_name) == 0) {
 178                                 matched = true;
 179                                 ok = test_fsrvp_state_smap_compare(tctx,
 180                                                                    smap_1,
 181                                                                    smap_2);
 182                                 torture_assert(tctx, ok, "");
 183                                 break;
 184                         }
 185                 }
 186                 torture_assert(tctx, matched, "no match for smap");
 187         }
 188
 189         return true;
 190 }
 191
 192 static bool test_fsrvp_state_sc_set_compare(struct torture_context *tctx,
 193                                             struct fss_sc_set *sc_set_1,
 194                                             struct fss_sc_set *sc_set_2)
 195 {
 196         struct fss_sc *sc_1;
 197         struct fss_sc *sc_2;
 198         bool ok;
 199
 200         /* should have already been confirmed by the caller */
 201         torture_assert(tctx, GUID_equal(&sc_set_1->id, &sc_set_2->id),
 202                        "sc_set guids differ");
 203
 204         torture_assert_str_equal(tctx, sc_set_1->id_str, sc_set_2->id_str,
 205                                  "sc_set guid strings differ");
 206
 207         torture_assert_int_equal(tctx, sc_set_1->state, sc_set_2->state,
 208                                  "sc_set state enums differ");
 209
 210         torture_assert_int_equal(tctx, sc_set_1->context, sc_set_2->context,
 211                                  "sc_set contexts differ");
 212
 213         torture_assert_int_equal(tctx, sc_set_1->scs_count, sc_set_2->scs_count,
 214                                  "sc_set sc counts differ");
 215
 216         for (sc_1 = sc_set_1->scs; sc_1; sc_1 = sc_1->next) {
 217                 bool matched = false;
 218                 for (sc_2 = sc_set_2->scs; sc_2; sc_2 = sc_2->next) {
 219                         if (GUID_equal(&sc_1->id, &sc_2->id)) {
 220                                 matched = true;
 221                                 ok = test_fsrvp_state_sc_compare(tctx, sc_1,
 222                                                                        sc_2);
 223                                 torture_assert(tctx, ok, "");
 224                                 break;
 225                         }
 226                 }
 227                 torture_assert(tctx, matched, "no match for sc");
 228         }
 229         return true;
 230 }
 231
 232 static bool test_fsrvp_state_compare(struct torture_context *tctx,
 233                                      struct fss_global *fss_1,
 234                                      struct fss_global *fss_2)
 235 {
 236         struct fss_sc_set *sc_set_1;
 237         struct fss_sc_set *sc_set_2;
 238         bool ok;
 239
 240         torture_assert_int_equal(tctx, fss_1->sc_sets_count,
 241                                  fss_2->sc_sets_count,
 242                                  "sc_sets_count differ");
 243
 244         for (sc_set_1 = fss_1->sc_sets; sc_set_1; sc_set_1 = sc_set_1->next) {
 245                 bool matched = false;
 246                 for (sc_set_2 = fss_2->sc_sets;
 247                      sc_set_2;
 248                      sc_set_2 = sc_set_2->next) {
 249                         if (GUID_equal(&sc_set_1->id, &sc_set_2->id)) {
 250                                 matched = true;
 251                                 ok = test_fsrvp_state_sc_set_compare(tctx,
 252                                                                      sc_set_1,
 253                                                                      sc_set_2);
 254                                 torture_assert(tctx, ok, "");
 255                                 break;
 256                         }
 257                 }
 258                 torture_assert(tctx, matched, "no match for sc_set");
 259         }
 260
 261         return true;
 262 }
 263
 264 /*
 265  * test a simple heirarchy of:
 266  *
 267  *       |
 268  *     sc_set
 269  *       |
 270  *      sc
 271  *        \
 272  *       smap
 273  */
 274 static bool test_fsrvp_state_single(struct torture_context *tctx)
 275 {
 276         NTSTATUS status;
 277         bool ok;
 278         struct fss_global fss_gs;
 279         struct fss_global fss_gr;
 280         struct fss_sc_set *sc_set;
 281         struct fss_sc *sc;
 282         struct fss_sc_smap *smap;
 283         char db_dir[] = "fsrvp_torture_XXXXXX";
 284         char *db_path = talloc_asprintf(NULL, "%s/%s",
 285                                         mkdtemp(db_dir), FSS_DB_NAME);
 286
 287         memset(&fss_gs, 0, sizeof(fss_gs));
 288         fss_gs.mem_ctx = talloc_new(NULL);
 289         fss_gs.db_path = db_path;
 290
 291         ok = test_fsrvp_state_sc_set(tctx, fss_gs.mem_ctx, &sc_set);
 292         torture_assert(tctx, ok, "failed to create sc set");
 293
 294         /* use parent as mem ctx */
 295         ok = test_fsrvp_state_sc(tctx, sc_set, &sc);
 296         torture_assert(tctx, ok, "failed to create sc");
 297
 298         ok = test_fsrvp_state_smap(tctx, sc, "base_share", "sc_share", &smap);
 299         torture_assert(tctx, ok, "failed to create smap");
 300
 301         DLIST_ADD_END(fss_gs.sc_sets, sc_set);
 302         fss_gs.sc_sets_count++;
 303         DLIST_ADD_END(sc_set->scs, sc);
 304         sc_set->scs_count++;
 305         sc->sc_set = sc_set;
 306         DLIST_ADD_END(sc->smaps, smap);
 307         sc->smaps_count++;
 308
 309         status = fss_state_store(fss_gs.mem_ctx, fss_gs.sc_sets,
 310                                  fss_gs.sc_sets_count, fss_gs.db_path);
 311         torture_assert_ntstatus_ok(tctx, status,
 312                                    "failed to store fss state");
 313
 314         memset(&fss_gr, 0, sizeof(fss_gr));
 315         fss_gr.mem_ctx = talloc_new(NULL);
 316         fss_gr.db_path = db_path;
 317
 318         status = fss_state_retrieve(fss_gr.mem_ctx, &fss_gr.sc_sets,
 319                                     &fss_gr.sc_sets_count, fss_gr.db_path);
 320         torture_assert_ntstatus_ok(tctx, status,
 321                                    "failed to retrieve fss state");
 322
 323         ok = test_fsrvp_state_compare(tctx, &fss_gs, &fss_gr);
 324         torture_assert(tctx, ok,
 325                        "stored and retrieved state comparison failed");
 326
 327         talloc_free(fss_gs.mem_ctx);
 328         talloc_free(fss_gr.mem_ctx);
 329         unlink(db_path);
 330         rmdir(db_dir);
 331         talloc_free(db_path);
 332
 333         return true;
 334 }
 335
 336 /*
 337  * test a complex heirarchy of:
 338  *
 339  *              /\
 340  *             /  \
 341  *     sc_set_a    sc_set_b
 342  *     /     \
 343  * sc_aa      sc_ab
 344  * |          |   \
 345  * smap_aaa   |    \
 346  *            |     \
 347  *       smap_aba   smap_abb
 348  */
 349 static bool test_fsrvp_state_multi(struct torture_context *tctx)
 350 {
 351         NTSTATUS status;
 352         bool ok;
 353         struct fss_global fss_gs;
 354         struct fss_global fss_gr;
 355         struct fss_sc_set *sc_set_a;
 356         struct fss_sc_set *sc_set_b;
 357         struct fss_sc *sc_aa;
 358         struct fss_sc *sc_ab;
 359         struct fss_sc_smap *smap_aaa;
 360         struct fss_sc_smap *smap_aba;
 361         struct fss_sc_smap *smap_abb;
 362         char db_dir[] = "fsrvp_torture_XXXXXX";
 363         char *db_path = talloc_asprintf(NULL, "%s/%s",
 364                                         mkdtemp(db_dir), FSS_DB_NAME);
 365
 366         memset(&fss_gs, 0, sizeof(fss_gs));
 367         fss_gs.mem_ctx = talloc_new(NULL);
 368         fss_gs.db_path = db_path;
 369
 370         ok = test_fsrvp_state_sc_set(tctx, fss_gs.mem_ctx, &sc_set_a);
 371         torture_assert(tctx, ok, "failed to create sc set");
 372
 373         ok = test_fsrvp_state_sc_set(tctx, fss_gs.mem_ctx, &sc_set_b);
 374         torture_assert(tctx, ok, "failed to create sc set");
 375
 376         /* use parent as mem ctx */
 377         ok = test_fsrvp_state_sc(tctx, sc_set_a, &sc_aa);
 378         torture_assert(tctx, ok, "failed to create sc");
 379
 380         ok = test_fsrvp_state_sc(tctx, sc_set_a, &sc_ab);
 381         torture_assert(tctx, ok, "failed to create sc");
 382
 383         ok = test_fsrvp_state_smap(tctx, sc_ab, "share_aa", "sc_share_aaa",
 384                                    &smap_aaa);
 385         torture_assert(tctx, ok, "failed to create smap");
 386
 387         ok = test_fsrvp_state_smap(tctx, sc_ab, "share_ab", "sc_share_aba",
 388                                    &smap_aba);
 389         torture_assert(tctx, ok, "failed to create smap");
 390
 391         ok = test_fsrvp_state_smap(tctx, sc_ab, "share_ab", "sc_share_abb",
 392                                    &smap_abb);
 393         torture_assert(tctx, ok, "failed to create smap");
 394
 395         DLIST_ADD_END(fss_gs.sc_sets, sc_set_a);
 396         fss_gs.sc_sets_count++;
 397         DLIST_ADD_END(fss_gs.sc_sets, sc_set_b);
 398         fss_gs.sc_sets_count++;
 399
 400         DLIST_ADD_END(sc_set_a->scs, sc_aa);
 401         sc_set_a->scs_count++;
 402         sc_aa->sc_set = sc_set_a;
 403         DLIST_ADD_END(sc_set_a->scs, sc_ab);
 404         sc_set_a->scs_count++;
 405         sc_ab->sc_set = sc_set_a;
 406
 407         DLIST_ADD_END(sc_aa->smaps, smap_aaa);
 408         sc_aa->smaps_count++;
 409         DLIST_ADD_END(sc_ab->smaps, smap_aba);
 410         sc_ab->smaps_count++;
 411         DLIST_ADD_END(sc_ab->smaps, smap_abb);
 412         sc_ab->smaps_count++;
 413
 414         status = fss_state_store(fss_gs.mem_ctx, fss_gs.sc_sets,
 415                                  fss_gs.sc_sets_count, fss_gs.db_path);
 416         torture_assert_ntstatus_ok(tctx, status,
 417                                    "failed to store fss state");
 418
 419         memset(&fss_gr, 0, sizeof(fss_gr));
 420         fss_gr.mem_ctx = talloc_new(NULL);
 421         fss_gr.db_path = db_path;
 422         status = fss_state_retrieve(fss_gr.mem_ctx, &fss_gr.sc_sets,
 423                                     &fss_gr.sc_sets_count, fss_gr.db_path);
 424         torture_assert_ntstatus_ok(tctx, status,
 425                                    "failed to retrieve fss state");
 426
 427         ok = test_fsrvp_state_compare(tctx, &fss_gs, &fss_gr);
 428         torture_assert(tctx, ok,
 429                        "stored and retrieved state comparison failed");
 430
 431         talloc_free(fss_gs.mem_ctx);
 432         talloc_free(fss_gr.mem_ctx);
 433         unlink(db_path);
 434         rmdir(db_dir);
 435         talloc_free(db_path);
 436
 437         return true;
 438 }
 439
 440 static bool test_fsrvp_state_none(struct torture_context *tctx)
 441 {
 442         NTSTATUS status;
 443         struct fss_global fss_global;
 444         char db_dir[] = "fsrvp_torture_XXXXXX";
 445         char *db_path = talloc_asprintf(NULL, "%s/%s",
 446                                         mkdtemp(db_dir), FSS_DB_NAME);
 447
 448         memset(&fss_global, 0, sizeof(fss_global));
 449         fss_global.mem_ctx = talloc_new(NULL);
 450         fss_global.db_path = db_path;
 451
 452         status = fss_state_retrieve(fss_global.mem_ctx, &fss_global.sc_sets,
 453                                     &fss_global.sc_sets_count,
 454                                     fss_global.db_path);
 455         torture_assert_ntstatus_ok(tctx, status,
 456                                    "failed to retrieve fss state");
 457         torture_assert_int_equal(tctx, fss_global.sc_sets_count, 0,
 458                                  "sc_sets_count set when it should be zero");
 459         talloc_free(fss_global.mem_ctx);
 460         unlink(db_path);
 461         rmdir(db_dir);
 462         talloc_free(db_path);
 463
 464         return true;
 465 }
 466
 467 struct torture_suite *torture_local_fsrvp(TALLOC_CTX *mem_ctx)
 468 {
 469         struct torture_suite *suite = torture_suite_create(mem_ctx,
 470                                                            "fsrvp_state");
 471
 472         /* dbwrap uses talloc_tos(), hence we need a stackframe :( */
 473         talloc_stackframe();
 474
 475         torture_suite_add_simple_test(suite,
 476                                       "state_empty",
 477                                       test_fsrvp_state_empty);
 478
 479         torture_suite_add_simple_test(suite,
 480                                       "state_single",
 481                                       test_fsrvp_state_single);
 482
 483         torture_suite_add_simple_test(suite,
 484                                       "state_multi",
 485                                       test_fsrvp_state_multi);
 486
 487         torture_suite_add_simple_test(suite,
 488                                       "state_none",
 489                                       test_fsrvp_state_none);
 490
 491         return suite;
 492 }