src/vhashify.c

   1 // $Id: vhashify.c,v 1.6 2005/03/24 12:46:59 ensc Exp $    --*- c -*--
   2
   3 // Copyright (C) 2005 Enrico Scholz <enrico.scholz@informatik.tu-chemnitz.de>
   4 //
   5 // This program is free software; you can redistribute it and/or modify
   6 // it under the terms of the GNU General Public License as published by
   7 // the Free Software Foundation; version 2 of the License.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU General Public License
  15 // along with this program; if not, write to the Free Software
  16 // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17
  18
  19 #ifdef HAVE_CONFIG_H
  20 #  include <config.h>
  21 #endif
  22
  23 #include "vhashify.h"
  24 #include "util.h"
  25
  26 #include "lib/internal.h"
  27 #include "lib_internal/matchlist.h"
  28 #include "lib_internal/unify.h"
  29 #include "ensc_vector/vector.h"
  30
  31 #include <beecrypt/beecrypt.h>
  32
  33 #include <setjmp.h>
  34 #include <unistd.h>
  35 #include <getopt.h>
  36 #include <string.h>
  37 #include <assert.h>
  38 #include <stdlib.h>
  39 #include <fcntl.h>
  40 #include <dirent.h>
  41 #include <errno.h>
  42 #include <signal.h>
  43 #include <limits.h>
  44 #include <sys/mman.h>
  45 #include <sys/stat.h>
  46
  47 #define ENSC_WRAPPERS_STDLIB    1
  48 #define ENSC_WRAPPERS_UNISTD    1
  49 #define ENSC_WRAPPERS_FCNTL     1
  50 #define ENSC_WRAPPERS_DIRENT    1
  51 #define ENSC_WRAPPERS_IO        1
  52 #include <wrappers.h>
  53
  54
  55 #define HASH_BLOCKSIZE          0x10000000u
  56 #define HASH_MINSIZE            0x10
  57 #define HASH_MAXBITS            256             // we have to take care about
  58                                                 // max filename-length...
  59
  60 #if HASH_MINSIZE<=0
  61 #  error HASH_MINSIZE must be not '0'
  62 #endif
  63
  64
  65 #define CMD_HELP                0x8000
  66 #define CMD_VERSION             0x8001
  67
  68 #define CMD_DESTINATION         0x1000
  69 #define CMD_INSECURE            0x1001
  70 #define CMD_SLEDGE              0x1002
  71 #define CMD_MANUALLY            0x1003
  72 #define CMD_REFRESH             0x1004
  73
  74 struct option const
  75 CMDLINE_OPTIONS[] = {
  76   { "help",         no_argument,        0, CMD_HELP },
  77   { "version",      no_argument,        0, CMD_VERSION },
  78   { "destination",  required_argument,  0, CMD_DESTINATION },
  79   { "insecure",     no_argument,        0, CMD_INSECURE },
  80   { "sledgehammer", no_argument,        0, CMD_SLEDGE },
  81   { "manually",     no_argument,        0, CMD_MANUALLY },
  82   { "refresh",      no_argument,        0, CMD_REFRESH },
  83   { "dry-run",      no_argument,        0, 'n' },
  84   { "verbose",      no_argument,        0, 'v' },
  85   { 0,0,0,0 }
  86 };
  87
  88   // hash digest grouped by 2 digits + hash-collision counter + 2* '/' + NULL
  89 typedef char                    HashPath[HASH_MAXBITS/4 + (HASH_MAXBITS/4/2) +
  90                                          sizeof(unsigned int)*2 + 3];
  91
  92 struct HashDirConfiguration
  93 {
  94     hashFunction const                          *method;
  95     enum { hshALL=0, hshSTART = 1, hshMIDDLE=2,
  96            hshEND = 4, hshINVALID = -1 }        blocks;
  97     size_t                                      blocksize;
  98 };
  99
 100 struct WalkdownInfo
 101 {
 102     PathInfo                    state;
 103     struct MatchList            dst_list;
 104     struct HashDirConfiguration hash_conf;
 105     HashDirCollection           hash_dirs;
 106     size_t                      hash_dirs_max_size;
 107
 108     hashFunctionContext         hash_context;
 109 };
 110
 111 int                             wrapper_exit_code = 1;
 112 struct Arguments const          *global_args;
 113 static struct SkipReason        skip_reason;
 114
 115 struct WalkdownInfo             global_info = {
 116   .hash_conf = { .method     = 0,
 117                  .blocks     = hshALL,
 118                  .blocksize  = 0x10000 }
 119 };
 120
 121 #include "vhashify-init.hc"
 122
 123 int Global_getVerbosity() {
 124   return global_args->verbosity;
 125 }
 126
 127 int Global_doRenew() {
 128   return true;
 129 }
 130
 131 int Global_isVserverRunning() {
 132     // TODO
 133   return global_args->insecure<2;
 134 }
 135
 136 static void
 137 showHelp(char const *cmd)
 138 {
 139   WRITE_MSG(1, "Usage:\n  ");
 140   WRITE_STR(1, cmd);
 141   WRITE_MSG(1,
 142             " [-nv] [--refresh] <vserver>\n    or\n  ");
 143   WRITE_STR(1, cmd);
 144   WRITE_MSG(1,
 145             " --manually [-nv] [--] <hashdir> <path> <excludelist>\n\n"
 146             "  --manually      ...  hashify generic paths; excludelists must be generated\n"
 147             "                       manually\n"
 148             "  --refresh       ...  hashify already hashified files also\n"
 149             "  -n              ...  do not modify anything; just show what there will be\n"
 150             "                       done (in combination with '-v')\n"
 151             "  -v              ...  verbose mode\n"
 152             "Please report bugs to " PACKAGE_BUGREPORT "\n");
 153
 154   exit(0);
 155 }
 156
 157 static void
 158 showVersion()
 159 {
 160   WRITE_MSG(1,
 161             "vhashify " VERSION " -- hashifies vservers and/or directories\n"
 162             "This program is part of " PACKAGE_STRING "\n\n"
 163             "Copyright (C) 2005 Enrico Scholz\n"
 164             VERSION_COPYRIGHT_DISCLAIMER);
 165   exit(0);
 166 }
 167
 168 int
 169 HashDirInfo_compareDevice(void const *lhs_v, void const *rhs_v)
 170 {
 171   struct HashDirInfo const * const      lhs = lhs_v;
 172   dev_t const * const                   rhs = rhs_v;
 173
 174   assert(lhs!=0 && rhs!=0);
 175   return lhs->device - *rhs;
 176 }
 177
 178 PathInfo const *
 179 HashDirInfo_findDevice(HashDirCollection const *coll, dev_t dev)
 180 {
 181   struct HashDirInfo const      *res;
 182
 183   res = Vector_searchSelfOrg_const(coll, &dev,
 184                                    HashDirInfo_compareDevice, vecSHIFT_ONCE);
 185
 186   if (res!=0) return &res->path;
 187   else        return 0;
 188 }
 189
 190 #include "vserver-visitdir.hc"
 191
 192 static bool
 193 checkFstat(PathInfo const * const basename,
 194            struct stat * const st)
 195 {
 196   assert(basename->d[0] != '/');
 197
 198     // local file does not exist... strange
 199     // TODO: message
 200   skip_reason.r = rsFSTAT;
 201   if (lstat(basename->d, st)==-1) return false;
 202
 203     // this is a directory and succeeds everytime
 204   if (S_ISDIR(st->st_mode))
 205     return true;
 206
 207     // ignore symlinks
 208   skip_reason.r = rsSYMLINK;
 209   if (S_ISLNK(st->st_mode))       return false;
 210
 211     // ignore special files
 212   skip_reason.r = rsSPECIAL;
 213   if (!S_ISREG(st->st_mode) &&
 214       !S_ISDIR(st->st_mode))      return false;
 215
 216     // ignore small files
 217   skip_reason.r = rsTOOSMALL;
 218   if (st->st_size < HASH_MINSIZE) return false;
 219
 220   switch (Unify_isIUnlinkable(basename->d)) {
 221     case unifyUNSUPPORTED       :  skip_reason.r = rsUNSUPPORTED; return false;
 222     case unifyBUSY              :
 223         // do an implicit refresh on busy files when there are no active links
 224       if (st->st_nlink>1 && !global_args->do_refresh) {
 225           // TODO: message
 226         skip_reason.r = rsUNIFIED;
 227         return false;
 228       }
 229       break;
 230     default                     :  break;
 231   }
 232
 233   return true;
 234 }
 235
 236 static sigjmp_buf               bus_error_restore;
 237 static volatile sig_atomic_t    bus_error;
 238
 239 static void
 240 handlerSIGBUS(int UNUSED num)
 241 {
 242   bus_error = 1;
 243   siglongjmp(bus_error_restore, 1);
 244 }
 245
 246 static bool
 247 convertDigest(HashPath d_path)
 248 {
 249   static char const             HEX_DIGIT[] = "0123456789abcdef";
 250   hashFunctionContext * const   h_ctx    = &global_info.hash_context;
 251   size_t                        d_size   = h_ctx->algo->digestsize;
 252
 253   unsigned char                 digest[d_size];
 254   size_t                        out = 0;
 255
 256   if (hashFunctionContextDigest(h_ctx, digest)==-1)
 257     return false;
 258
 259   for (size_t in=0;
 260        out+1<sizeof(HashPath)-(sizeof(unsigned int)*2 + 2) && in<d_size;
 261        ++in) {
 262     if ((in+254)%(in<=2 ? 1 : 256) == 0 && in>0)
 263       d_path[out++]='/';
 264     d_path[out++]  = HEX_DIGIT[digest[in] >>    4];
 265     d_path[out++]  = HEX_DIGIT[digest[in] &  0x0f];
 266   }
 267   d_path[out++] = '\0';
 268
 269   return true;
 270 }
 271
 272 static bool
 273 addStatHash(hashFunctionContext *h_ctx, struct stat const * const st)
 274 {
 275 #define DECL_ATTR(X)    __typeof__(st->st_##X)  X
 276 #define SET_ATTR(X)     .X = st->st_##X
 277
 278   struct __attribute__((__packed__)) {
 279     DECL_ATTR(mode);
 280     DECL_ATTR(uid);
 281     DECL_ATTR(gid);
 282     DECL_ATTR(rdev);
 283     DECL_ATTR(size);
 284     DECL_ATTR(mtime);
 285   }             tmp = {
 286     SET_ATTR(mode),
 287     SET_ATTR(uid),
 288     SET_ATTR(gid),
 289     SET_ATTR(rdev),
 290     SET_ATTR(size),
 291     SET_ATTR(mtime)
 292   };
 293
 294   return hashFunctionContextUpdate(h_ctx, (void *)&tmp, sizeof tmp)!=-1;
 295 }
 296
 297 static bool
 298 calculateHashFromFD(int fd, HashPath d_path, struct stat const * const st)
 299 {
 300   hashFunctionContext * const   h_ctx    = &global_info.hash_context;
 301   void const * volatile         buf      = 0;
 302   loff_t volatile               buf_size = 0;
 303   bool   volatile               res      = false;
 304
 305
 306   if (hashFunctionContextReset(h_ctx)==-1 ||
 307       !addStatHash(h_ctx, st))
 308     return false;
 309
 310   bus_error = 0;
 311   if (sigsetjmp(bus_error_restore,1)==0) {
 312     loff_t                      offset   = 0;
 313     off_t                       size     = st->st_size;
 314
 315     while (offset < size) {
 316       buf_size = size-offset;
 317       if (buf_size>HASH_BLOCKSIZE) buf_size = HASH_BLOCKSIZE;
 318
 319       if ((buf=mmap(0, buf_size, PROT_READ, MAP_SHARED, fd, offset))==0) {
 320         perror("mmap(<hash>)");
 321         goto out;
 322       }
 323
 324       offset += buf_size;
 325       madvise(const_cast(void *)(buf), buf_size, MADV_SEQUENTIAL);      // ignore error...
 326
 327       if (hashFunctionContextUpdate(h_ctx, buf, buf_size)==-1) goto out;
 328
 329       munmap(const_cast(void *)(buf), buf_size);
 330       buf = 0;
 331     }
 332
 333     res = convertDigest(d_path);
 334   }
 335
 336   out:
 337   if (buf!=0) munmap(const_cast(void *)(buf), buf_size);
 338   return res;
 339 }
 340
 341 static bool
 342 calculateHash(PathInfo const *filename, HashPath d_path, struct stat const * const st)
 343 {
 344   int           fd  = open(filename->d, O_NOFOLLOW|O_NONBLOCK|O_RDONLY|O_NOCTTY);
 345   struct stat   fst;
 346   bool          res = false;
 347
 348   do {
 349     if (fd==-1) {
 350       int       old_errno = errno;
 351       WRITE_MSG(2, "Failed to open '");
 352       WRITE_STR(2, filename->d);
 353       errno = old_errno;
 354       perror("'");
 355       break;;
 356     }
 357
 358     if (fstat(fd, &fst)==-1 ||
 359         fst.st_dev!=st->st_dev || fst.st_ino!=st->st_ino) {
 360       WRITE_MSG(2, "An unexpected event occured while stating '");
 361       WRITE_STR(2, filename->d);
 362       WRITE_MSG(2, "'.\n");
 363       break;
 364     }
 365
 366     if (!calculateHashFromFD(fd, d_path, st)) {
 367       WRITE_MSG(2, "Failed to calculate hash for '");
 368       WRITE_STR(2, filename->d);
 369       WRITE_MSG(2, "'.\n");
 370       break;
 371     }
 372
 373     res = true;
 374   } while (false);
 375
 376   if (fd!=-1) close(fd);
 377   return res;
 378 }
 379
 380 static enum { mkdirFAIL, mkdirSUCCESS, mkdirSKIP }
 381 mkdirSingle(char const *path, char *end_ptr, int good_err)
 382 {
 383   *end_ptr = '\0';
 384   if (mkdir(path, 0700)!=-1 || errno==EEXIST) {
 385     *end_ptr = '/';
 386     return mkdirSUCCESS;
 387   }
 388   else if (errno==good_err) {
 389     *end_ptr = '/';
 390     return mkdirSKIP;
 391   }
 392   else {
 393     int         old_errno = errno;
 394     WRITE_MSG(2, "mkdir('");
 395     WRITE_STR(2, path);
 396     errno = old_errno;
 397     perror("')");
 398     return mkdirFAIL;
 399   }
 400 }
 401
 402 static char *
 403 rstrchr(char *str, char c)
 404 {
 405   while (*str!=c) --str;
 406   return str;
 407 }
 408
 409 static bool
 410 mkdirRecursive(char const *path)
 411 {
 412   if (path[0]!='/')      return false; // only absolute paths
 413
 414   char                  buf[strlen(path)+1];
 415   char *                ptr = buf + sizeof(buf) - 2;
 416
 417   strcpy(buf, path);
 418
 419   while (ptr>buf && (ptr = rstrchr(ptr, '/'))!=0) {
 420     switch (mkdirSingle(buf, ptr, ENOENT)) {
 421       case mkdirSUCCESS         :  break;
 422       case mkdirSKIP            :  --ptr; continue;
 423       case mkdirFAIL            :  return false;
 424     }
 425
 426     break;      // implied by mkdirSUCCESS
 427   }
 428
 429   assert(ptr!=0);
 430   ++ptr;
 431
 432   while ((ptr=strchr(ptr, '/'))!=0) {
 433     switch (mkdirSingle(buf, ptr, 0)) {
 434       case mkdirSKIP            :
 435       case mkdirFAIL            :  return false;
 436       case mkdirSUCCESS         :  ++ptr; continue;
 437     }
 438   }
 439
 440   return true;
 441 }
 442
 443 static bool
 444 resolveCollisions(char *result, PathInfo const *root, HashPath d_path,
 445                   struct stat *st, struct stat *hash_st)
 446 {
 447   strcpy(result, root->d);      // 'root' ends on '/' already (see initHashList())
 448   strcat(result, d_path);
 449
 450   char                  *ptr = result + strlen(result);
 451   unsigned int          idx  = 0;
 452   char                  buf[sizeof(int)*2 + 1];
 453   size_t                len;
 454
 455   *ptr                 = '-';
 456   ptr[sizeof(int)*2+1] = '\0';
 457
 458   for (;; ++idx) {
 459     len = utilvserver_fmt_xuint(buf, idx);
 460     memset(ptr+1, '0', sizeof(int)*2 - len);
 461     memcpy(ptr+1 + sizeof(int)*2 - len, buf, len);
 462
 463     if (lstat(result, hash_st)==-1) {
 464       if (global_args->dry_run && errno!=ENOENT) {
 465         int             old_errno = errno;
 466         WRITE_MSG(2, "lstat('");
 467         WRITE_STR(2, buf);
 468         errno = old_errno;
 469         perror("')");
 470         return false;
 471       }
 472     }
 473     else if (Unify_isUnified(st, hash_st)) {
 474       skip_reason.r = rsUNIFIED;
 475       return false;
 476     }
 477     else if (!Unify_isUnifyable(st, hash_st))
 478       continue;         // continue with next number*****
 479     else
 480       break;            // ok, we finish here
 481
 482     if (!global_args->dry_run) {
 483       *ptr = '\0';
 484       if (!mkdirRecursive(result))
 485         return false;
 486       *ptr = '-';
 487
 488       int               fd = open(result, O_NOFOLLOW|O_EXCL|O_CREAT|O_WRONLY, 0200);
 489
 490       if (fd==-1) {
 491         int             old_errno = errno;
 492         WRITE_MSG(2, "open('");
 493         WRITE_STR(2, buf);
 494         errno = old_errno;
 495         perror("')");
 496         return false;
 497       }
 498
 499       close(fd);
 500     }
 501
 502       // HACK: avoid an additional lstat on the resulting hash-file
 503     hash_st->st_size = 0;
 504     break;
 505   }
 506
 507   return true;
 508 }
 509
 510 static char const *
 511 checkDirEntry(PathInfo const *path, PathInfo const *basename,
 512               bool *is_dir,
 513               struct stat *st, struct stat *hash_st,
 514               char *result_buf)
 515 {
 516     //printf("checkDirEntry(%s, %s, %u)\n", path->d, d_path, is_dir);
 517
 518   struct WalkdownInfo const * const     info       = &global_info;
 519
 520   // Check if it is in the exclude/include list of the destination vserver and
 521   // abort when it is not matching an allowed entry
 522   skip_reason.r      = rsEXCL;
 523   if (MatchList_compare(&info->dst_list, path->d)!=stINCLUDE) return 0;
 524
 525   if (checkFstat(basename, st)) {
 526     PathInfo const      *hash_root_path;
 527     HashPath            d_path;
 528
 529     *is_dir = S_ISDIR(st->st_mode);
 530
 531     if (!*is_dir &&
 532         !((skip_reason.r = rsWRONGDEV,
 533            (hash_root_path = HashDirInfo_findDevice(&info->hash_dirs, st->st_dev))!=0) &&
 534           (skip_reason.r = rsGENERAL,
 535            calculateHash(basename, d_path, st)) &&
 536           resolveCollisions(result_buf, hash_root_path, d_path, st, hash_st)))
 537       return 0;
 538
 539     return result_buf;
 540   }
 541
 542   return 0;
 543 }
 544
 545 static void
 546 printSkipReason()
 547 {
 548   WRITE_MSG(1, " (");
 549   switch (skip_reason.r) {
 550     case rsDOTFILE      :  WRITE_MSG(1, "dotfile"); break;
 551     case rsEXCL         :  WRITE_MSG(1, "excluded"); break;
 552     case rsTOOSMALL     :  WRITE_MSG(1, "too small"); break;
 553     case rsUNSUPPORTED  :  WRITE_MSG(1, "operation not supported"); break;
 554     case rsFSTAT        :  WRITE_MSG(1, "fstat error"); break;
 555     case rsSYMLINK      :  WRITE_MSG(1, "symlink"); break;
 556     case rsUNIFIED      :  WRITE_MSG(1, "already unified"); break;
 557     case rsSPECIAL      :  WRITE_MSG(1, "non regular file"); break;
 558     case rsWRONGDEV     :  WRITE_MSG(1, "no matching device"); break;
 559     case rsGENERAL      :  WRITE_MSG(1, "general error"); break;
 560     default             :  assert(false); abort();
 561   }
 562   WRITE_MSG(1, ")");
 563 }
 564
 565 static bool
 566 doit(char const *src, char const *dst,
 567      struct stat const *src_st, struct stat const *dst_st,
 568      PathInfo const *path)
 569 {
 570   if (global_args->dry_run || Global_getVerbosity()>=2) {
 571     WRITE_MSG(1, "unifying   '");
 572     Vwrite(1, path->d, path->l);
 573     WRITE_MSG(1, "'");
 574
 575     if (Global_getVerbosity()>=4) {
 576       WRITE_MSG(1, " (to '");
 577       WRITE_STR(1, dst);
 578       WRITE_MSG(1, "')");
 579     }
 580
 581     WRITE_MSG(1, "\n");
 582   }
 583
 584     // abort here in dry-run mode
 585   if (global_args->dry_run) return true;
 586
 587   if (dst_st->st_size==0) {
 588       // file was not unified yet
 589
 590     if (Global_isVserverRunning()) {
 591       (void)unlink(dst);
 592       if (Unify_copy (src, src_st, dst) &&
 593           // the mixed 'dst' and 'src_st' params are intentionally...
 594           Unify_unify(dst, src_st, src, false))
 595         return true;
 596     }
 597     else if (Unify_unify(src, src_st, dst, true))
 598       return true;
 599
 600     (void)unlink(dst);  // cleanup in error-case
 601   }
 602     // there exists already a reference-file
 603   else if (Unify_unify(dst, dst_st, src, false))
 604     return true;
 605
 606   return false;
 607 }
 608
 609 static uint64_t
 610 visitDirEntry(struct dirent const *ent)
 611 {
 612   uint64_t                      res      = 0;
 613   char const *                  dirname  = ent->d_name;
 614   PathInfo                      path     = global_info.state;
 615   PathInfo                      tmp_path = {
 616     .d = dirname,
 617     .l = strlen(dirname)
 618   };
 619   char                          path_buf[ENSC_PI_APPSZ(path, tmp_path)];
 620   char const                    *match = 0;
 621
 622
 623   PathInfo_append(&path, &tmp_path, path_buf);
 624
 625   bool                          is_dotfile    = isDotfile(dirname);
 626   bool                          is_dir;
 627   struct stat                   src_stat = { .st_mode=0 };
 628   struct stat                   hash_stat;
 629   char                          tmpbuf[global_info.hash_dirs_max_size +
 630                                        sizeof(HashPath) + 2];
 631
 632   skip_reason.r = rsDOTFILE;
 633
 634   if (is_dotfile ||
 635       (match=checkDirEntry(&path, &tmp_path,
 636                            &is_dir, &src_stat, &hash_stat,
 637                            tmpbuf))==0) {
 638
 639     bool        is_link = !is_dotfile && S_ISLNK(src_stat.st_mode);
 640
 641     if (Global_getVerbosity()>=1 &&
 642         (Global_getVerbosity()>=3 || skip_reason.r!=rsUNIFIED) &&
 643         ((!is_dotfile && !is_link) ||
 644          (Global_getVerbosity()>=6 && is_dotfile) ||
 645          (Global_getVerbosity()>=6 && is_link)) ) {
 646       WRITE_MSG(1, "  skipping '");
 647       Vwrite(1, path.d, path.l);
 648       WRITE_MSG(1, "'");
 649       if (Global_getVerbosity()>=2) printSkipReason();
 650       WRITE_MSG(1, "\n");
 651     }
 652
 653     return 0;
 654   }
 655
 656   if (is_dir) {
 657     res = visitDir(dirname, &src_stat);
 658   }
 659   else if (doit(dirname, match, &src_stat, &hash_stat, &path))
 660     res = 1;
 661   else {
 662       // TODO: message
 663     res = 0;
 664   }
 665
 666   return res;
 667
 668 }
 669
 670 int main(int argc, char *argv[])
 671 {
 672   struct Arguments      args = {
 673     .mode               =  mdVSERVER,
 674     .hash_dir           =  0,
 675     .verbosity          =  0,
 676     .insecure           =  0,
 677     .dry_run            =  false,
 678     .do_refresh         =  false,
 679   };
 680
 681   Vector_init(&global_info.hash_dirs, sizeof(struct HashDirInfo));
 682
 683   global_args = &args;
 684   while (1) {
 685     int         c = getopt_long(argc, argv, "+nv",
 686                                 CMDLINE_OPTIONS, 0);
 687     if (c==-1) break;
 688
 689     switch (c) {
 690       case CMD_HELP             :  showHelp(argv[0]);
 691       case CMD_VERSION          :  showVersion();
 692       case CMD_DESTINATION      :  args.hash_dir    = optarg; break;
 693       case CMD_MANUALLY         :  args.mode        = mdMANUALLY; break;
 694       case CMD_INSECURE         :  args.insecure    = 1;    break;
 695       case CMD_SLEDGE           :  args.insecure    = 2;    break;
 696       case CMD_REFRESH          :  args.do_refresh  = true; break;
 697       case 'n'                  :  args.dry_run     = true; break;
 698       case 'v'                  :  ++args.verbosity; break;
 699       default           :
 700         WRITE_MSG(2, "Try '");
 701         WRITE_STR(2, argv[0]);
 702         WRITE_MSG(2, " --help\" for more information.\n");
 703         return EXIT_FAILURE;
 704         break;
 705     }
 706   }
 707
 708   if (argc==optind) {
 709     WRITE_MSG(2, "No directory/vserver given\n");
 710     return EXIT_FAILURE;
 711   }
 712
 713   if (args.hash_dir==0 && args.mode==mdMANUALLY) {
 714     WRITE_MSG(2, "'--manually' requires '--destination'\n");
 715     return EXIT_FAILURE;
 716   }
 717
 718   switch (args.mode) {
 719     case mdMANUALLY     :  initModeManually(&args, argc-optind, argv+optind); break;
 720     case mdVSERVER      :  initModeVserver (&args, argc-optind, argv+optind); break;
 721     default             :  assert(false); return EXIT_FAILURE;
 722   };
 723
 724   if (hashFunctionContextInit(&global_info.hash_context,
 725                               global_info.hash_conf.method)==-1) {
 726     WRITE_MSG(2, "Failed to initialize hash-context\n");
 727     return EXIT_FAILURE;
 728   }
 729
 730   if (Global_getVerbosity()>=1)
 731     WRITE_MSG(1, "Starting to traverse directories...\n");
 732
 733   signal(SIGBUS, handlerSIGBUS);
 734
 735   Echdir(global_info.dst_list.root.d);
 736   visitDir("/", 0);
 737
 738 #ifndef NDEBUG
 739   MatchList_destroy(&global_info.dst_list);
 740   freeHashList(&global_info.hash_dirs);
 741   hashFunctionContextFree(&global_info.hash_context);
 742 #endif
 743 }