3 // Copyright (C) 2005 Enrico Scholz <enrico.scholz@informatik.tu-chemnitz.de>
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.
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.
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.
26 #include "lib/internal.h"
27 #include "lib_internal/matchlist.h"
28 #include "lib_internal/unify.h"
29 #include "ensc_vector/vector.h"
31 #include <beecrypt/beecrypt.h>
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
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...
61 # error HASH_MINSIZE must be not '0'
65 #define CMD_HELP 0x8000
66 #define CMD_VERSION 0x8001
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
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' },
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];
92 struct HashDirConfiguration
94 hashFunction const *method;
95 enum { hshALL=0, hshSTART = 1, hshMIDDLE=2,
96 hshEND = 4, hshINVALID = -1 } blocks;
103 struct MatchList dst_list;
104 struct HashDirConfiguration hash_conf;
105 HashDirCollection hash_dirs;
106 size_t hash_dirs_max_size;
108 hashFunctionContext hash_context;
111 int wrapper_exit_code = 1;
112 struct Arguments const *global_args;
113 static struct SkipReason skip_reason;
115 struct WalkdownInfo global_info = {
116 .hash_conf = { .method = 0,
118 .blocksize = 0x10000 }
121 #include "vhashify-init.hc"
123 int Global_getVerbosity() {
124 return global_args->verbosity;
127 int Global_doRenew() {
131 int Global_isVserverRunning() {
133 return global_args->insecure<2;
137 showHelp(char const *cmd)
139 WRITE_MSG(1, "Usage:\n ");
142 " [-nv] [--refresh] <vserver>\n or\n ");
145 " --manually [-nv] [--] <hashdir> <path> <excludelist>\n\n"
146 " --manually ... hashify generic paths; excludelists must be generated\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");
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);
169 HashDirInfo_compareDevice(void const *lhs_v, void const *rhs_v)
171 struct HashDirInfo const * const lhs = lhs_v;
172 dev_t const * const rhs = rhs_v;
174 assert(lhs!=0 && rhs!=0);
175 return lhs->device - *rhs;
179 HashDirInfo_findDevice(HashDirCollection const *coll, dev_t dev)
181 struct HashDirInfo const *res;
183 res = Vector_searchSelfOrg_const(coll, &dev,
184 HashDirInfo_compareDevice, vecSHIFT_ONCE);
186 if (res!=0) return &res->path;
190 #include "vserver-visitdir.hc"
193 checkFstat(PathInfo const * const basename,
194 struct stat * const st)
196 assert(basename->d[0] != '/');
198 // local file does not exist... strange
200 skip_reason.r = rsFSTAT;
201 if (lstat(basename->d, st)==-1) return false;
203 // this is a directory and succeeds everytime
204 if (S_ISDIR(st->st_mode))
208 skip_reason.r = rsSYMLINK;
209 if (S_ISLNK(st->st_mode)) return false;
211 // ignore special files
212 skip_reason.r = rsSPECIAL;
213 if (!S_ISREG(st->st_mode) &&
214 !S_ISDIR(st->st_mode)) return false;
216 // ignore small files
217 skip_reason.r = rsTOOSMALL;
218 if (st->st_size < HASH_MINSIZE) return false;
220 switch (Unify_isIUnlinkable(basename->d)) {
221 case unifyUNSUPPORTED : skip_reason.r = rsUNSUPPORTED; return false;
223 // do an implicit refresh on busy files when there are no active links
224 if (st->st_nlink>1 && !global_args->do_refresh) {
226 skip_reason.r = rsUNIFIED;
236 static sigjmp_buf bus_error_restore;
237 static volatile sig_atomic_t bus_error;
240 handlerSIGBUS(int UNUSED num)
243 siglongjmp(bus_error_restore, 1);
247 convertDigest(HashPath d_path)
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;
253 unsigned char digest[d_size];
256 if (hashFunctionContextDigest(h_ctx, digest)==-1)
260 out+1<sizeof(HashPath)-(sizeof(unsigned int)*2 + 2) && in<d_size;
262 if ((in+254)%(in<=2 ? 1 : 256) == 0 && in>0)
264 d_path[out++] = HEX_DIGIT[digest[in] >> 4];
265 d_path[out++] = HEX_DIGIT[digest[in] & 0x0f];
267 d_path[out++] = '\0';
273 addStatHash(hashFunctionContext *h_ctx, struct stat const * const st)
275 #define DECL_ATTR(X) __typeof__(st->st_##X) X
276 #define SET_ATTR(X) .X = st->st_##X
278 struct __attribute__((__packed__)) {
294 return hashFunctionContextUpdate(h_ctx, (void *)&tmp, sizeof tmp)!=-1;
298 calculateHashFromFD(int fd, HashPath d_path, struct stat const * const st)
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;
306 if (hashFunctionContextReset(h_ctx)==-1 ||
307 !addStatHash(h_ctx, st))
311 if (sigsetjmp(bus_error_restore,1)==0) {
313 off_t size = st->st_size;
315 while (offset < size) {
316 buf_size = size-offset;
317 if (buf_size>HASH_BLOCKSIZE) buf_size = HASH_BLOCKSIZE;
319 if ((buf=mmap(0, buf_size, PROT_READ, MAP_SHARED, fd, offset))==0) {
320 perror("mmap(<hash>)");
325 madvise(const_cast(void *)(buf), buf_size, MADV_SEQUENTIAL); // ignore error...
327 if (hashFunctionContextUpdate(h_ctx, buf, buf_size)==-1) goto out;
329 munmap(const_cast(void *)(buf), buf_size);
333 res = convertDigest(d_path);
337 if (buf!=0) munmap(const_cast(void *)(buf), buf_size);
342 calculateHash(PathInfo const *filename, HashPath d_path, struct stat const * const st)
344 int fd = open(filename->d, O_NOFOLLOW|O_NONBLOCK|O_RDONLY|O_NOCTTY);
350 int old_errno = errno;
351 WRITE_MSG(2, "Failed to open '");
352 WRITE_STR(2, filename->d);
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");
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");
376 if (fd!=-1) close(fd);
380 static enum { mkdirFAIL, mkdirSUCCESS, mkdirSKIP }
381 mkdirSingle(char const *path, char *end_ptr, int good_err)
384 if (mkdir(path, 0700)!=-1 || errno==EEXIST) {
388 else if (errno==good_err) {
393 int old_errno = errno;
394 WRITE_MSG(2, "mkdir('");
403 rstrchr(char *str, char c)
405 while (*str!=c) --str;
410 mkdirRecursive(char const *path)
412 if (path[0]!='/') return false; // only absolute paths
414 char buf[strlen(path)+1];
415 char * ptr = buf + sizeof(buf) - 2;
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;
426 break; // implied by mkdirSUCCESS
432 while ((ptr=strchr(ptr, '/'))!=0) {
433 switch (mkdirSingle(buf, ptr, 0)) {
435 case mkdirFAIL : return false;
436 case mkdirSUCCESS : ++ptr; continue;
444 resolveCollisions(char *result, PathInfo const *root, HashPath d_path,
445 struct stat *st, struct stat *hash_st)
447 strcpy(result, root->d); // 'root' ends on '/' already (see initHashList())
448 strcat(result, d_path);
450 char *ptr = result + strlen(result);
451 unsigned int idx = 0;
452 char buf[sizeof(int)*2 + 1];
456 ptr[sizeof(int)*2+1] = '\0';
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);
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('");
473 else if (Unify_isUnified(st, hash_st)) {
474 skip_reason.r = rsUNIFIED;
477 else if (!Unify_isUnifyable(st, hash_st))
478 continue; // continue with next number*****
480 break; // ok, we finish here
482 if (!global_args->dry_run) {
484 if (!mkdirRecursive(result))
488 int fd = open(result, O_NOFOLLOW|O_EXCL|O_CREAT|O_WRONLY, 0200);
491 int old_errno = errno;
492 WRITE_MSG(2, "open('");
502 // HACK: avoid an additional lstat on the resulting hash-file
503 hash_st->st_size = 0;
511 checkDirEntry(PathInfo const *path, PathInfo const *basename,
513 struct stat *st, struct stat *hash_st,
516 //printf("checkDirEntry(%s, %s, %u)\n", path->d, d_path, is_dir);
518 struct WalkdownInfo const * const info = &global_info;
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;
525 if (checkFstat(basename, st)) {
526 PathInfo const *hash_root_path;
529 *is_dir = S_ISDIR(st->st_mode);
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)))
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();
566 doit(char const *src, char const *dst,
567 struct stat const *src_st, struct stat const *dst_st,
568 PathInfo const *path)
570 if (global_args->dry_run || Global_getVerbosity()>=2) {
571 WRITE_MSG(1, "unifying '");
572 Vwrite(1, path->d, path->l);
575 if (Global_getVerbosity()>=4) {
576 WRITE_MSG(1, " (to '");
584 // abort here in dry-run mode
585 if (global_args->dry_run) return true;
587 if (dst_st->st_size==0) {
588 // file was not unified yet
590 if (Global_isVserverRunning()) {
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))
597 else if (Unify_unify(src, src_st, dst, true))
600 (void)unlink(dst); // cleanup in error-case
602 // there exists already a reference-file
603 else if (Unify_unify(dst, dst_st, src, false))
610 visitDirEntry(struct dirent const *ent)
613 char const * dirname = ent->d_name;
614 PathInfo path = global_info.state;
615 PathInfo tmp_path = {
619 char path_buf[ENSC_PI_APPSZ(path, tmp_path)];
620 char const *match = 0;
623 PathInfo_append(&path, &tmp_path, path_buf);
625 bool is_dotfile = isDotfile(dirname);
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];
632 skip_reason.r = rsDOTFILE;
635 (match=checkDirEntry(&path, &tmp_path,
636 &is_dir, &src_stat, &hash_stat,
639 bool is_link = !is_dotfile && S_ISLNK(src_stat.st_mode);
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);
649 if (Global_getVerbosity()>=2) printSkipReason();
657 res = visitDir(dirname, &src_stat);
659 else if (doit(dirname, match, &src_stat, &hash_stat, &path))
670 int main(int argc, char *argv[])
672 struct Arguments args = {
681 Vector_init(&global_info.hash_dirs, sizeof(struct HashDirInfo));
685 int c = getopt_long(argc, argv, "+nv",
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;
700 WRITE_MSG(2, "Try '");
701 WRITE_STR(2, argv[0]);
702 WRITE_MSG(2, " --help\" for more information.\n");
709 WRITE_MSG(2, "No directory/vserver given\n");
713 if (args.hash_dir==0 && args.mode==mdMANUALLY) {
714 WRITE_MSG(2, "'--manually' requires '--destination'\n");
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;
724 if (hashFunctionContextInit(&global_info.hash_context,
725 global_info.hash_conf.method)==-1) {
726 WRITE_MSG(2, "Failed to initialize hash-context\n");
730 if (Global_getVerbosity()>=1)
731 WRITE_MSG(1, "Starting to traverse directories...\n");
733 signal(SIGBUS, handlerSIGBUS);
735 Echdir(global_info.dst_list.root.d);
739 MatchList_destroy(&global_info.dst_list);
740 freeHashList(&global_info.hash_dirs);
741 hashFunctionContextFree(&global_info.hash_context);