linkup

linkup.c (5839B)

#include <linux/limits.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <dirent.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>

static bool force = false;
static bool install = true;
static bool nodirs = false;
static bool verbose = false;

static const char **excluded = NULL;
static size_t excludecnt = 0;
static size_t excludecap = 0;

static void
info(const char *fmt, ...)
{
	va_list ap;

	if (!verbose) return;

	va_start(ap, fmt);
	vfprintf(stderr, fmt, ap);
	va_end(ap);
}

static void
die(const char *fmt, ...)
{
	va_list ap;

	va_start(ap, fmt);
	fputs("linkup: ", stderr);
	vfprintf(stderr, fmt, ap);
	if (*fmt && fmt[strlen(fmt)-1] == ':') {
		fputc(' ', stderr);
		perror(NULL);
	} else {
		fputc('\n', stderr);
	}
	va_end(ap);

	exit(1);
}

void
normalize(const char *src, char *dst)
{
	const char *sep, *tok;
	char *end;
	size_t len;

	end = dst;
	*end = '\0';

	tok = src;
	while (tok) {
		sep = strchr(tok, '/');
		len = sep ? (size_t) (sep - tok) : strlen(tok);
		if (len && strncmp(tok, ".", len)) {
			if (!strncmp(tok, "..", len)) {
				end = strrchr(dst, '/');
				if (!end) end = dst;
				*end = '\0';
			} else {
				*end++ = '/';
				strncpy(end, tok, len);
				end += len;
				*end = '\0';
			}
		}
		tok = sep ? sep + 1 : NULL;
	}
}


static void
realparent(int dirfd, const char *dirpath, const char *file, char *parent)
{
	char tmpbuf[PATH_MAX];
	ssize_t len;
	char *sep;

	if ((len = readlinkat(dirfd, file, tmpbuf, PATH_MAX-1)) == -1)
		die("readlink '%s/%s':", dirpath, file);
	tmpbuf[len] = '\0';

	if (tmpbuf[0] != '/') { /* relative path */
		strncpy(parent, tmpbuf, PATH_MAX);
		snprintf(tmpbuf, PATH_MAX, "%s/%s", dirpath, parent);
	}

	normalize(tmpbuf, parent);
	if ((sep = strrchr(parent, '/')))
		*sep = '\0';
}

static void
exclude(const char *arg)
{
	if (excludecnt == excludecap) {
		excludecap = (excludecap + 1) * 2;
		excluded = realloc(excluded, excludecap * sizeof(const char *));
	}
	excluded[excludecnt] = arg;
	excludecnt++;
}

static void
do_install(const char *src_path, const char *dst_path)
{
	char src_fpath[PATH_MAX], dst_fpath[PATH_MAX];
	struct dirent *ent;
	struct stat attr;
	DIR *src_dir, *dst_dir;
	int i;

	src_dir = opendir(src_path);
	if (!src_dir) die("opendir '%s'", src_path);

	dst_dir = opendir(dst_path);
	if (!dst_dir) die("opendir '%s'", dst_path);

	while ((ent = readdir(src_dir))) {
		if (!strcmp(ent->d_name, "."))
			continue;
		if (!strcmp(ent->d_name, ".."))
			continue;

		for (i = 0; i < excludecnt; i++) {
			if (!strcmp(excluded[i], ent->d_name))
				break;
		}
		if (i != excludecnt) {
			info("skip %s/%s\n", src_path, ent->d_name);
			continue;
		}

		snprintf(src_fpath, PATH_MAX, "%s/%s", src_path, ent->d_name);
		snprintf(dst_fpath, PATH_MAX, "%s/%s", dst_path, ent->d_name);

		/* ensure link destination does not exist */
		if (!fstatat(dirfd(dst_dir), ent->d_name,
				&attr, AT_SYMLINK_NOFOLLOW)) {
			if (ent->d_type == DT_DIR && (attr.st_mode & S_IFMT) == S_IFDIR) {
				info("skip %s\n", src_fpath);
				continue;
			}
			if (!force && (attr.st_mode & S_IFMT) != S_IFLNK)
				die("dst '%s' already exists", dst_fpath);
			// TODO: skip if points to src_fpath already
			info("rm %s\n", dst_fpath);
			if (remove(dst_fpath)) // TODO: removeall
				die("remove '%s' failed:", dst_fpath);
		} else {
			if (nodirs && ent->d_type == DT_DIR) {
				info("skip %s\n", src_fpath);
				continue;
			}
		}

		info("link %s\n", src_fpath, dst_fpath);
		if (symlink(src_fpath, dst_fpath) < 0)
			die("linking '%s' failed:", dst_fpath);
	}

	/* cleanup dangling symlinks */
	while ((ent = readdir(dst_dir))) {
		if (ent->d_type != DT_LNK)
			continue;

		/* must point into src */
		realparent(dirfd(dst_dir), dst_path, ent->d_name, dst_fpath);
		if (strcmp(dst_fpath, src_path))
			continue;

		/* with missing destination */
		if (faccessat(dirfd(dst_dir), ent->d_name, F_OK, 0)) {
			info(" unlink %s/%s\n", dst_path, ent->d_name);
			if (unlinkat(dirfd(dst_dir), ent->d_name, 0))
				die("unlinking '%s/%s' failed:", dst_path, ent->d_name);
		}
	}

	closedir(dst_dir);
	closedir(src_dir);
}

static void
do_uninstall(const char *src_path, const char *dst_path)
{
	struct dirent *ent;
	char dst_fpath[PATH_MAX];
	DIR *dst_dir;

	dst_dir = opendir(dst_path);
	if (!dst_dir) die("opendir '%s':", dst_path);

	while ((ent = readdir(dst_dir))) {
		if (ent->d_type != DT_LNK)
			continue;

		/* must point into src */
		realparent(dirfd(dst_dir), dst_path, ent->d_name, dst_fpath);
		if (strcmp(dst_fpath, src_path))
			continue;

		if (unlinkat(dirfd(dst_dir), ent->d_name, 0))
			die("failed to remove '%s/%s':", dst_path, ent->d_name);
	}

	closedir(dst_dir);
}

int
main(int argc, const char **argv)
{
	char src_path[PATH_MAX], dst_path[PATH_MAX];
	const char *src_arg, *dst_arg;
	const char **arg;

	src_arg = dst_arg = NULL;
	for (arg = &argv[1]; *arg; arg++) {
		if (!strcmp(*arg, "-x") || !strcmp(*arg, "--exclude")) {
			exclude(*++arg);
		} else if (!strcmp(*arg, "-u") || !strcmp(*arg, "--uninstall")) {
			install = false;
		} else if (!strcmp(*arg, "-f") || !strcmp(*arg, "--force")) {
			force = true;
		} else if (!strcmp(*arg, "-v") || !strcmp(*arg, "--verbose")) {
			verbose = true;
		} else if (!strcmp(*arg, "--xdirs")) {
			nodirs = true;
		} else if (!src_arg) {
			src_arg = *arg;
		} else if (!dst_arg) {
			dst_arg = *arg;
		} else {
			break;
		}
	}

	if (!src_arg || !dst_arg || *arg) {
		fprintf(stderr, "Usage: linkup [-h] [-x FILE..] SRC DST\n");
		return 1;
	}

	if (!realpath(src_arg, src_path))
		die("realpath '%s':", src_path);

	if (!realpath(dst_arg, dst_path))
		die("realpath '%s':", dst_path);

	if (install) {
		do_install(src_path, dst_path);
	} else {
		do_uninstall(src_path, dst_path);
	}

	free(excluded);
}