src/test/test_storagedir.c

   1 /* Copyright (c) 2017, The Tor Project, Inc. */
   2 /* See LICENSE for licensing information */
   3
   4 #include "or.h"
   5 #include "storagedir.h"
   6 #include "test.h"
   7
   8 #ifdef HAVE_UTIME_H
   9 #include <utime.h>
  10 #endif
  11
  12 static void
  13 test_storagedir_empty(void *arg)
  14 {
  15   char *dirname = tor_strdup(get_fname_rnd("store_dir"));
  16   storage_dir_t *d = NULL;
  17   (void)arg;
  18
  19   tt_int_op(FN_NOENT, OP_EQ, file_status(dirname));
  20
  21   d = storage_dir_new(dirname, 10);
  22   tt_assert(d);
  23
  24   tt_int_op(FN_DIR, OP_EQ, file_status(dirname));
  25
  26   tt_int_op(0, OP_EQ, smartlist_len(storage_dir_list(d)));
  27   tt_u64_op(0, OP_EQ, storage_dir_get_usage(d));
  28
  29   storage_dir_free(d);
  30   d = storage_dir_new(dirname, 10);
  31   tt_assert(d);
  32
  33   tt_int_op(FN_DIR, OP_EQ, file_status(dirname));
  34
  35   tt_int_op(0, OP_EQ, smartlist_len(storage_dir_list(d)));
  36   tt_u64_op(0, OP_EQ, storage_dir_get_usage(d));
  37
  38  done:
  39   storage_dir_free(d);
  40   tor_free(dirname);
  41 }
  42
  43 static void
  44 test_storagedir_basic(void *arg)
  45 {
  46   char *dirname = tor_strdup(get_fname_rnd("store_dir"));
  47   storage_dir_t *d = NULL;
  48   uint8_t *junk = NULL, *bytes = NULL;
  49   const size_t junklen = 1024;
  50   char *fname1 = NULL, *fname2 = NULL;
  51   const char hello_str[] = "then what are we but cold, alone ... ?";
  52   tor_mmap_t *mapping = NULL;
  53   (void)arg;
  54
  55   junk = tor_malloc(junklen);
  56   crypto_rand((void*)junk, junklen);
  57
  58   d = storage_dir_new(dirname, 10);
  59   tt_assert(d);
  60   tt_u64_op(0, OP_EQ, storage_dir_get_usage(d));
  61
  62   int r;
  63   r = storage_dir_save_string_to_file(d, hello_str, 1, &fname1);
  64   tt_int_op(r, OP_EQ, 0);
  65   tt_ptr_op(fname1, OP_NE, NULL);
  66   tt_u64_op(strlen(hello_str), OP_EQ, storage_dir_get_usage(d));
  67
  68   r = storage_dir_save_bytes_to_file(d, junk, junklen, 1, &fname2);
  69   tt_int_op(r, OP_EQ, 0);
  70   tt_ptr_op(fname2, OP_NE, NULL);
  71
  72   tt_str_op(fname1, OP_NE, fname2);
  73
  74   tt_int_op(2, OP_EQ, smartlist_len(storage_dir_list(d)));
  75   tt_u64_op(junklen + strlen(hello_str), OP_EQ, storage_dir_get_usage(d));
  76   tt_assert(smartlist_contains_string(storage_dir_list(d), fname1));
  77   tt_assert(smartlist_contains_string(storage_dir_list(d), fname2));
  78
  79   storage_dir_free(d);
  80   d = storage_dir_new(dirname, 10);
  81   tt_assert(d);
  82   tt_int_op(2, OP_EQ, smartlist_len(storage_dir_list(d)));
  83   tt_u64_op(junklen + strlen(hello_str), OP_EQ, storage_dir_get_usage(d));
  84   tt_assert(smartlist_contains_string(storage_dir_list(d), fname1));
  85   tt_assert(smartlist_contains_string(storage_dir_list(d), fname2));
  86
  87   size_t n;
  88   bytes = storage_dir_read(d, fname2, 1, &n);
  89   tt_assert(bytes);
  90   tt_u64_op(n, OP_EQ, junklen);
  91   tt_mem_op(bytes, OP_EQ, junk, junklen);
  92
  93   mapping = storage_dir_map(d, fname1);
  94   tt_assert(mapping);
  95   tt_u64_op(mapping->size, OP_EQ, strlen(hello_str));
  96   tt_mem_op(mapping->data, OP_EQ, hello_str, strlen(hello_str));
  97
  98  done:
  99   tor_free(dirname);
 100   tor_free(junk);
 101   tor_free(bytes);
 102   tor_munmap_file(mapping);
 103   storage_dir_free(d);
 104   tor_free(fname1);
 105   tor_free(fname2);
 106 }
 107
 108 static void
 109 test_storagedir_deletion(void *arg)
 110 {
 111   (void)arg;
 112   char *dirname = tor_strdup(get_fname_rnd("store_dir"));
 113   storage_dir_t *d = NULL;
 114   char *fn1 = NULL, *fn2 = NULL;
 115   char *bytes = NULL;
 116   int r;
 117   const char str1[] = "There are nine and sixty ways to disguise communiques";
 118   const char str2[] = "And rather more than one of them is right";
 119
 120   // Make sure the directory is there. */
 121   d = storage_dir_new(dirname, 10);
 122   storage_dir_free(d);
 123   d = NULL;
 124
 125   tor_asprintf(&fn1, "%s/1007", dirname);
 126   r = write_str_to_file(fn1, str1, 0);
 127   tt_int_op(r, OP_EQ, 0);
 128
 129   tor_asprintf(&fn2, "%s/1003.tmp", dirname);
 130   r = write_str_to_file(fn2, str2, 0);
 131   tt_int_op(r, OP_EQ, 0);
 132
 133   // The tempfile should be deleted the next time we list the directory.
 134   d = storage_dir_new(dirname, 10);
 135   tt_int_op(1, OP_EQ, smartlist_len(storage_dir_list(d)));
 136   tt_u64_op(strlen(str1), OP_EQ, storage_dir_get_usage(d));
 137   tt_int_op(FN_FILE, OP_EQ, file_status(fn1));
 138   tt_int_op(FN_NOENT, OP_EQ, file_status(fn2));
 139
 140   bytes = (char*) storage_dir_read(d, "1007", 1, NULL);
 141   tt_str_op(bytes, OP_EQ, str1);
 142
 143   // Should have no effect; file already gone.
 144   storage_dir_remove_file(d, "1003.tmp");
 145   tt_int_op(1, OP_EQ, smartlist_len(storage_dir_list(d)));
 146   tt_u64_op(strlen(str1), OP_EQ, storage_dir_get_usage(d));
 147
 148   // Actually remove a file.
 149   storage_dir_remove_file(d, "1007");
 150   tt_int_op(FN_NOENT, OP_EQ, file_status(fn1));
 151   tt_int_op(0, OP_EQ, smartlist_len(storage_dir_list(d)));
 152   tt_u64_op(0, OP_EQ, storage_dir_get_usage(d));
 153
 154  done:
 155   tor_free(dirname);
 156   tor_free(fn1);
 157   tor_free(fn2);
 158   storage_dir_free(d);
 159   tor_free(bytes);
 160 }
 161
 162 static void
 163 test_storagedir_full(void *arg)
 164 {
 165   (void)arg;
 166
 167   char *dirname = tor_strdup(get_fname_rnd("store_dir"));
 168   storage_dir_t *d = NULL;
 169   const char str[] = "enemies of the peephole";
 170   int r;
 171
 172   d = storage_dir_new(dirname, 3);
 173   tt_assert(d);
 174
 175   r = storage_dir_save_string_to_file(d, str, 1, NULL);
 176   tt_int_op(r, OP_EQ, 0);
 177   r = storage_dir_save_string_to_file(d, str, 1, NULL);
 178   tt_int_op(r, OP_EQ, 0);
 179   r = storage_dir_save_string_to_file(d, str, 1, NULL);
 180   tt_int_op(r, OP_EQ, 0);
 181
 182   // These should fail!
 183   r = storage_dir_save_string_to_file(d, str, 1, NULL);
 184   tt_int_op(r, OP_EQ, -1);
 185   r = storage_dir_save_string_to_file(d, str, 1, NULL);
 186   tt_int_op(r, OP_EQ, -1);
 187
 188   tt_u64_op(strlen(str) * 3, OP_EQ, storage_dir_get_usage(d));
 189
 190  done:
 191   tor_free(dirname);
 192   storage_dir_free(d);
 193 }
 194
 195 static void
 196 test_storagedir_cleaning(void *arg)
 197 {
 198   (void)arg;
 199
 200   char *dirname = tor_strdup(get_fname_rnd("store_dir"));
 201   storage_dir_t *d = NULL;
 202   const char str[] =
 203     "On a mountain halfway between Reno and Rome / "
 204     "We have a machine in a plexiglass dome / "
 205     "Which listens and looks into everyone's home."
 206     " -- Dr. Seuss";
 207   char *fns[8];
 208   int r, i;
 209
 210   memset(fns, 0, sizeof(fns));
 211   d = storage_dir_new(dirname, 10);
 212   tt_assert(d);
 213
 214   for (i = 0; i < 8; ++i) {
 215     r = storage_dir_save_string_to_file(d, str+i*2, 1, &fns[i]);
 216     tt_int_op(r, OP_EQ, 0);
 217   }
 218
 219   /* Now we're going to make sure all the files have distinct mtimes. */
 220   time_t now = time(NULL);
 221   struct utimbuf ub;
 222   ub.actime = now;
 223   ub.modtime = now - 1000;
 224   for (i = 0; i < 8; ++i) {
 225     char *f = NULL;
 226     tor_asprintf(&f, "%s/%s", dirname, fns[i]);
 227     r = utime(f, &ub);
 228     tor_free(f);
 229     tt_int_op(r, OP_EQ, 0);
 230     ub.modtime += 5;
 231   }
 232
 233   const uint64_t usage_orig = storage_dir_get_usage(d);
 234   /* No changes needed if we are already under target. */
 235   storage_dir_shrink(d, 1024*1024, 0);
 236   tt_u64_op(usage_orig, OP_EQ, storage_dir_get_usage(d));
 237
 238   /* Get rid of at least one byte.  This will delete fns[0]. */
 239   storage_dir_shrink(d, usage_orig - 1, 0);
 240   tt_u64_op(usage_orig, OP_GT, storage_dir_get_usage(d));
 241   tt_u64_op(usage_orig - strlen(str), OP_EQ, storage_dir_get_usage(d));
 242
 243   /* Get rid of at least two files.  This will delete fns[1] and fns[2]. */
 244   storage_dir_shrink(d, 1024*1024, 2);
 245   tt_u64_op(usage_orig - strlen(str)*3 + 6, OP_EQ, storage_dir_get_usage(d));
 246
 247   /* Get rid of everything. */
 248   storage_dir_remove_all(d);
 249   tt_u64_op(0, OP_EQ, storage_dir_get_usage(d));
 250
 251  done:
 252   tor_free(dirname);
 253   storage_dir_free(d);
 254   for (i = 0; i < 8; ++i) {
 255     tor_free(fns[i]);
 256   }
 257 }
 258
 259 static void
 260 test_storagedir_save_labeled(void *arg)
 261 {
 262   (void)arg;
 263   char *dirname = tor_strdup(get_fname_rnd("store_dir"));
 264   storage_dir_t *d = NULL;
 265   uint8_t *inp = tor_malloc_zero(8192);
 266   config_line_t *labels = NULL;
 267   char *fname = NULL;
 268   uint8_t *saved = NULL;
 269
 270   d = storage_dir_new(dirname, 10);
 271   tt_assert(d);
 272
 273   crypto_rand((char *)inp, 8192);
 274
 275   config_line_append(&labels, "Foo", "bar baz");
 276   config_line_append(&labels, "quux", "quuzXxz");
 277   const char expected[] =
 278     "Foo bar baz\n"
 279     "quux quuzXxz\n";
 280
 281   int r = storage_dir_save_labeled_to_file(d, labels, inp, 8192, &fname);
 282   tt_int_op(r, OP_EQ, 0);
 283
 284   size_t n;
 285   saved = storage_dir_read(d, fname, 1, &n);
 286   tt_assert(memchr(saved, '\0', n));
 287   tt_str_op((char*)saved, OP_EQ, expected); /* NUL guarantees strcmp works */
 288   tt_mem_op(saved+strlen(expected)+1, OP_EQ, inp, 8192);
 289
 290  done:
 291   storage_dir_free(d);
 292   tor_free(dirname);
 293   tor_free(inp);
 294   tor_free(fname);
 295   config_free_lines(labels);
 296   tor_free(saved);
 297 }
 298
 299 static void
 300 test_storagedir_read_labeled(void *arg)
 301 {
 302   (void)arg;
 303   char *dirname = tor_strdup(get_fname_rnd("store_dir"));
 304   storage_dir_t *d = NULL;
 305   uint8_t *inp = tor_malloc_zero(8192);
 306   config_line_t *labels = NULL, *labels2 = NULL;
 307   char *fname = NULL;
 308   tor_mmap_t *map = NULL;
 309   uint8_t *as_read = NULL;
 310
 311   d = storage_dir_new(dirname, 10);
 312   tt_assert(d);
 313
 314   tor_snprintf((char*)inp, 8192,
 315                "Hello world\n"
 316                "This is a test\n"
 317                "Yadda yadda.\n");
 318   size_t bodylen = 8192 - strlen((char*)inp) - 1;
 319   crypto_rand((char *)inp+strlen((char*)inp)+1, bodylen);
 320
 321   int r = storage_dir_save_bytes_to_file(d, inp, 8192, 1, &fname);
 322   tt_int_op(r, OP_EQ, 0);
 323
 324   /* Try mapping */
 325   const uint8_t *datap = NULL;
 326   size_t sz = 0;
 327   map = storage_dir_map_labeled(d, fname, &labels, &datap, &sz);
 328   tt_assert(map);
 329   tt_assert(datap);
 330   tt_u64_op(sz, OP_EQ, bodylen);
 331   tt_mem_op(datap, OP_EQ, inp+strlen((char*)inp)+1, bodylen);
 332   tt_assert(labels);
 333   tt_str_op(labels->key, OP_EQ, "Hello");
 334   tt_str_op(labels->value, OP_EQ, "world");
 335   tt_assert(labels->next);
 336   tt_str_op(labels->next->key, OP_EQ, "This");
 337   tt_str_op(labels->next->value, OP_EQ, "is a test");
 338   tt_assert(labels->next->next);
 339   tt_str_op(labels->next->next->key, OP_EQ, "Yadda");
 340   tt_str_op(labels->next->next->value, OP_EQ, "yadda.");
 341   tt_ptr_op(labels->next->next->next, OP_EQ, NULL);
 342
 343   /* Try reading this time. */
 344   sz = 0;
 345   as_read = storage_dir_read_labeled(d, fname, &labels2, &sz);
 346   tt_assert(as_read);
 347   tt_u64_op(sz, OP_EQ, bodylen);
 348   tt_mem_op(as_read, OP_EQ, inp+strlen((char*)inp)+1, bodylen);
 349   tt_assert(config_lines_eq(labels, labels2));
 350
 351  done:
 352   storage_dir_free(d);
 353   tor_free(dirname);
 354   tor_free(inp);
 355   tor_free(fname);
 356   config_free_lines(labels);
 357   config_free_lines(labels2);
 358   tor_munmap_file(map);
 359   tor_free(as_read);
 360 }
 361
 362 #define ENT(name)                                               \
 363   { #name, test_storagedir_ ## name, TT_FORK, NULL, NULL }
 364
 365 struct testcase_t storagedir_tests[] = {
 366   ENT(empty),
 367   ENT(basic),
 368   ENT(deletion),
 369   ENT(full),
 370   ENT(cleaning),
 371   ENT(save_labeled),
 372   ENT(read_labeled),
 373   END_OF_TESTCASES
 374 };
 375