snapraid/cmdline/pool.c
2020-09-11 13:42:22 +02:00

471 lines
12 KiB
C

/*
* Copyright (C) 2013 Andrea Mazzoleni
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "portable.h"
#include "support.h"
#include "elem.h"
#include "state.h"
struct snapraid_pool {
char file[PATH_MAX];
char linkto[PATH_MAX];
int64_t mtime_sec;
int mtime_nsec;
/* nodes for data structures */
tommy_hashdyn_node node;
};
struct snapraid_pool* pool_alloc(const char* dir, const char* name, const char* linkto, const struct stat* st)
{
struct snapraid_pool* pool;
pool = malloc_nofail(sizeof(struct snapraid_pool));
pathprint(pool->file, sizeof(pool->file), "%s%s", dir, name);
pathcpy(pool->linkto, sizeof(pool->linkto), linkto);
pool->mtime_sec = st->st_mtime;
pool->mtime_nsec = STAT_NSEC(st);
return pool;
}
static inline tommy_uint32_t pool_hash(const char* file)
{
return tommy_hash_u32(0, file, strlen(file));
}
void pool_free(struct snapraid_pool* pool)
{
free(pool);
}
int pool_compare(const void* void_arg, const void* void_data)
{
const char* arg = void_arg;
const struct snapraid_pool* pool = void_data;
return strcmp(arg, pool->file);
}
/**
* Remove empty dir.
* Return == 0 if the directory is empty, and it can be removed
*/
static int clean_dir(const char* dir)
{
DIR* d;
int full = 0;
d = opendir(dir);
if (!d) {
/* LCOV_EXCL_START */
log_fatal("Error opening pool directory '%s'. %s.\n", dir, strerror(errno));
exit(EXIT_FAILURE);
/* LCOV_EXCL_STOP */
}
while (1) {
char path_next[PATH_MAX];
struct stat st;
const char* name;
struct dirent* dd;
/* clear errno to detect erroneous conditions */
errno = 0;
dd = readdir(d);
if (dd == 0 && errno != 0) {
/* LCOV_EXCL_START */
log_fatal("Error reading pool directory '%s'. %s.\n", dir, strerror(errno));
exit(EXIT_FAILURE);
/* LCOV_EXCL_STOP */
}
if (dd == 0 && errno == 0) {
break; /* finished */
}
/* skip "." and ".." files */
name = dd->d_name;
if (name[0] == '.' && (name[1] == 0 || (name[1] == '.' && name[2] == 0)))
continue;
pathprint(path_next, sizeof(path_next), "%s%s", dir, name);
#if HAVE_STRUCT_DIRENT_D_STAT
/* convert dirent to lstat result */
dirent_lstat(dd, &st);
/* if the st_mode field is missing, takes care to fill it using normal lstat() */
/* at now this can happen only in Windows */
if (st.st_mode == 0) {
if (lstat(path_next, &st) != 0) {
/* LCOV_EXCL_START */
log_fatal("Error in stat file/directory '%s'. %s.\n", path_next, strerror(errno));
exit(EXIT_FAILURE);
/* LCOV_EXCL_STOP */
}
}
#else
/* get lstat info about the file */
if (lstat(path_next, &st) != 0) {
/* LCOV_EXCL_START */
log_fatal("Error in stat file/directory '%s'. %s.\n", path_next, strerror(errno));
exit(EXIT_FAILURE);
/* LCOV_EXCL_STOP */
}
#endif
if (S_ISDIR(st.st_mode)) {
/* recurse */
pathslash(path_next, sizeof(path_next));
if (clean_dir(path_next) == 0) {
int ret;
/* directory is empty, try to remove it */
ret = rmdir(path_next);
if (ret < 0) {
#ifdef _WIN32
if (errno == EACCES) {
/* in Windows just ignore EACCES errors removing directories */
/* because it could happen that the directory is in use */
/* and it cannot be removed */
log_fatal("Directory '%s' not removed because it's in use.\n", path_next);
full = 1;
} else
#endif
{
/* LCOV_EXCL_START */
log_fatal("Error removing pool directory '%s'. %s.\n", path_next, strerror(errno));
exit(EXIT_FAILURE);
/* LCOV_EXCL_STOP */
}
}
} else {
/* something is present */
full = 1;
}
} else {
/* something is present */
full = 1;
}
}
if (closedir(d) != 0) {
/* LCOV_EXCL_START */
log_fatal("Error closing pool directory '%s'. %s.\n", dir, strerror(errno));
exit(EXIT_FAILURE);
/* LCOV_EXCL_STOP */
}
return full;
}
/**
* Read all the links in a directory tree.
*/
static void read_dir(tommy_hashdyn* poolset, const char* base_dir, const char* sub_dir)
{
char dir[PATH_MAX];
DIR* d;
pathprint(dir, sizeof(dir), "%s%s", base_dir, sub_dir);
d = opendir(dir);
if (!d) {
/* LCOV_EXCL_START */
log_fatal("Error opening pool directory '%s'. %s.\n", dir, strerror(errno));
exit(EXIT_FAILURE);
/* LCOV_EXCL_STOP */
}
while (1) {
char path_next[PATH_MAX];
struct stat st;
const char* name;
struct dirent* dd;
/* clear errno to detect erroneous conditions */
errno = 0;
dd = readdir(d);
if (dd == 0 && errno != 0) {
/* LCOV_EXCL_START */
log_fatal("Error reading pool directory '%s'. %s.\n", dir, strerror(errno));
exit(EXIT_FAILURE);
/* LCOV_EXCL_STOP */
}
if (dd == 0 && errno == 0) {
break; /* finished */
}
/* skip "." and ".." files */
name = dd->d_name;
if (name[0] == '.' && (name[1] == 0 || (name[1] == '.' && name[2] == 0)))
continue;
pathprint(path_next, sizeof(path_next), "%s%s", dir, name);
#if HAVE_STRUCT_DIRENT_D_STAT
/* convert dirent to lstat result */
dirent_lstat(dd, &st);
/* if the st_mode field is missing, takes care to fill it using normal lstat() */
/* at now this can happen only in Windows */
if (st.st_mode == 0) {
if (lstat(path_next, &st) != 0) {
/* LCOV_EXCL_START */
log_fatal("Error in stat file/directory '%s'. %s.\n", path_next, strerror(errno));
exit(EXIT_FAILURE);
/* LCOV_EXCL_STOP */
}
}
#else
/* get lstat info about the file */
if (lstat(path_next, &st) != 0) {
/* LCOV_EXCL_START */
log_fatal("Error in stat file/directory '%s'. %s.\n", path_next, strerror(errno));
exit(EXIT_FAILURE);
/* LCOV_EXCL_STOP */
}
#endif
if (S_ISLNK(st.st_mode)) {
struct snapraid_pool* pool;
char linkto[PATH_MAX];
int ret;
ret = readlink(path_next, linkto, sizeof(linkto));
if (ret < 0 || ret >= PATH_MAX) {
/* LCOV_EXCL_START */
log_fatal("Error in readlink symlink '%s'. %s.\n", path_next, strerror(errno));
exit(EXIT_FAILURE);
/* LCOV_EXCL_STOP */
}
linkto[ret] = 0;
/* store the link info */
pool = pool_alloc(sub_dir, name, linkto, &st);
tommy_hashdyn_insert(poolset, &pool->node, pool, pool_hash(pool->file));
} else if (S_ISDIR(st.st_mode)) {
pathprint(path_next, sizeof(path_next), "%s%s/", sub_dir, name);
read_dir(poolset, base_dir, path_next);
} else {
msg_verbose("Ignoring pool file '%s'\n", path_next);
}
}
if (closedir(d) != 0) {
/* LCOV_EXCL_START */
log_fatal("Error closing pool directory '%s'. %s.\n", dir, strerror(errno));
exit(EXIT_FAILURE);
/* LCOV_EXCL_STOP */
}
}
/**
* Remove the link
*/
static void remove_link(void* void_arg, void* void_pool)
{
char path[PATH_MAX];
const char* arg = void_arg;
struct snapraid_pool* pool = void_pool;
int ret;
pathprint(path, sizeof(path), "%s%s", arg, pool->file);
/* delete the link */
ret = remove(path);
if (ret < 0) {
/* LCOV_EXCL_START */
log_fatal("Error removing symlink '%s'. %s.\n", path, strerror(errno));
exit(EXIT_FAILURE);
/* LCOV_EXCL_STOP */
}
}
/**
* Create a link to the specified disk link.
*/
static void make_link(tommy_hashdyn* poolset, const char* pool_dir, const char* share_dir, struct snapraid_disk* disk, const char* sub, int64_t mtime_sec, int mtime_nsec)
{
char path[PATH_MAX];
char linkto[PATH_MAX];
char linkto_exported[PATH_MAX];
struct snapraid_pool* found;
int ret;
/* make the source path */
pathprint(path, sizeof(path), "%s%s", pool_dir, sub);
/* make the linkto path */
if (share_dir[0] != 0) {
/* with a shared directory, use it */
pathprint(linkto, sizeof(linkto), "%s%s/%s", share_dir, disk->name, sub);
} else {
/* without a share directory, use the local disk paths */
pathprint(linkto, sizeof(linkto), "%s%s", disk->dir, sub);
}
/* search for the sub path */
found = tommy_hashdyn_search(poolset, pool_compare, sub, pool_hash(sub));
if (found) {
/* remove from the set */
tommy_hashdyn_remove_existing(poolset, &found->node);
/* check if the info match */
if (found->mtime_sec == mtime_sec
&& found->mtime_nsec == mtime_nsec
&& strcmp(found->linkto, linkto) == 0
) {
/* nothing to do */
pool_free(found);
return;
}
/* delete the link */
ret = remove(path);
if (ret < 0) {
/* LCOV_EXCL_START */
log_fatal("Error removing symlink '%s'. %s.\n", path, strerror(errno));
exit(EXIT_FAILURE);
/* LCOV_EXCL_STOP */
}
pool_free(found);
}
/* create the ancestor directories */
ret = mkancestor(path);
if (ret != 0) {
/* LCOV_EXCL_START */
exit(EXIT_FAILURE);
/* LCOV_EXCL_STOP */
}
/* convert back slashes */
pathexport(linkto_exported, sizeof(linkto_exported), linkto);
/* create the symlink */
ret = symlink(linkto_exported, path);
if (ret != 0) {
if (errno == EEXIST) {
log_fatal("WARNING! Duplicate pooling for '%s'\n", path);
#ifdef _WIN32
} else if (errno == EPERM) {
/* LCOV_EXCL_START */
log_fatal("You must run as Administrator to be able to create symlinks.\n");
exit(EXIT_FAILURE);
/* LCOV_EXCL_STOP */
#endif
} else {
/* LCOV_EXCL_START */
log_fatal("Error writing symlink '%s'. %s.\n", path, strerror(errno));
exit(EXIT_FAILURE);
/* LCOV_EXCL_STOP */
}
}
if (mtime_sec) {
ret = lmtime(path, mtime_sec, mtime_nsec);
if (ret != 0) {
/* LCOV_EXCL_START */
log_fatal("Error setting time to symlink '%s'. %s.\n", path, strerror(errno));
exit(EXIT_FAILURE);
/* LCOV_EXCL_STOP */
}
}
}
void state_pool(struct snapraid_state* state)
{
tommy_hashdyn poolset;
tommy_node* i;
char pool_dir[PATH_MAX];
char share_dir[PATH_MAX];
unsigned count;
tommy_hashdyn_init(&poolset);
if (state->pool[0] == 0) {
/* LCOV_EXCL_START */
log_fatal("To use the 'pool' command you must set the pool directory in the configuration file\n");
exit(EXIT_FAILURE);
/* LCOV_EXCL_STOP */
}
msg_progress("Reading...\n");
/* pool directory with final slash */
pathprint(pool_dir, sizeof(pool_dir), "%s", state->pool);
pathslash(pool_dir, sizeof(pool_dir));
/* share directory with final slash */
pathprint(share_dir, sizeof(share_dir), "%s", state->share);
pathslash(share_dir, sizeof(share_dir));
/* first read the previous pool tree */
read_dir(&poolset, pool_dir, "");
msg_progress("Writing...\n");
/* for each disk */
count = 0;
for (i = state->disklist; i != 0; i = i->next) {
tommy_node* j;
struct snapraid_disk* disk = i->data;
/* for each file */
for (j = disk->filelist; j != 0; j = j->next) {
struct snapraid_file* file = j->data;
make_link(&poolset, pool_dir, share_dir, disk, file->sub, file->mtime_sec, file->mtime_nsec);
++count;
}
/* for each link */
for (j = disk->linklist; j != 0; j = j->next) {
struct snapraid_link* slink = j->data;
make_link(&poolset, pool_dir, share_dir, disk, slink->sub, 0, 0);
++count;
}
/* we ignore empty dirs in disk->dir */
}
msg_progress("Cleaning...\n");
/* delete all the remaining links */
tommy_hashdyn_foreach_arg(&poolset, (tommy_foreach_arg_func*)remove_link, pool_dir);
/* delete empty dirs */
clean_dir(pool_dir);
tommy_hashdyn_foreach(&poolset, (tommy_foreach_func*)pool_free);
tommy_hashdyn_done(&poolset);
if (count)
msg_status("%u links\n", count);
else
msg_status("No link\n");
log_tag("summary:link_count::%u\n", count);
log_tag("summary:exit:ok\n");
log_flush();
}