rdup-tr.c

/*
 * Copyright (c) 2009 - 2011 Miek Gieben
 * License: GPLv3(+), see LICENSE for details
 * rdup-tr -- rdup translate, transform an
 * rdup filelist to an tar/cpio archive with
 * per file compression and/or encryption or whatever
 */

/* stdio is only used for errors
 * the rest is all read, write and pipe
 */

#include "rdup-tr.h"
#include "protocol.h"
#include "io.h"

char *PROGNAME = "rdup-tr";
/* options */
char *template;
gboolean opt_tty = FALSE;	/* force write to tty */
#ifdef HAVE_LIBNETTLE
gchar *opt_crypt_key = NULL;	/* encryption key */
gchar *opt_decrypt_key = NULL;	/* decryption key */
struct aes_ctx *aes_ctx = NULL;
#endif				/* HAVE_LIBNETTLE */
gint opt_verbose = 0;		/* be more verbose */
gint opt_output = O_RDUP;	/* default output */
gint opt_input = I_RDUP;	/* default intput */

int sig = 0;
char *o_fmt[] = { "", "tar", "cpio", "pax", "rdup" };	/* O_NONE, O_TAR, O_CPIO, O_PAX, O_RDUP */

#ifdef __CYGWIN__
extern int __declspec(dllimport) opterr;
#else
extern int opterr;
int opterr = 0;
#endif

/* common.c */
struct rdup *entry_dup(struct rdup *f);
void entry_free(struct rdup *f);

#ifdef HAVE_LIBNETTLE
/* encrypt an rdup_entry (just the path of course) */
static struct rdup *crypt_entry(struct rdup *e, GHashTable * tr)
{
	gchar *crypt, *dest;
	if (!(crypt = crypt_path(aes_ctx, e->f_name, tr))) {
		msg(_("Failed to encrypt path `%s\'"), e->f_name);
		return NULL;
	}

	e->f_name = crypt;
	e->f_name_size = strlen(crypt);

	/* links are special */
	if (S_ISLNK(e->f_mode) || e->f_lnk == 1) {
		dest = crypt_path(aes_ctx, e->f_target, tr);
		e->f_target = dest;
		e->f_size = strlen(crypt);	/* use crypt here */
	}
	return e;
}

/* decrypt an rdup_entry */
static struct rdup *decrypt_entry(struct rdup *e, GHashTable * tr)
{
	gchar *plain, *dest;

	if (!(plain = decrypt_path(aes_ctx, e->f_name, tr))) {
		msg(_("Failed to decrypt path `%s\'"), e->f_name);
		return NULL;
	}

	e->f_name = plain;
	e->f_name_size = strlen(plain);

	/* links are special */
	if (S_ISLNK(e->f_mode) || e->f_lnk == 1) {
		dest = decrypt_path(aes_ctx, e->f_target, tr);
		g_free(e->f_target);
		e->f_target = dest;
		e->f_size = strlen(plain);
	}
	return e;
}
#endif				/* HAVE_LIBNETTLE */

void tmpclean(int opt_output, int f, char *name)
{
	if (opt_output != O_RDUP) {
		if (f != -1)
			close(f);
		unlink(name);
		g_free(name);
	}
}

/* read filenames from stdin, put them through
 * the childeren, collect the output from the last
 * child and create the archive on stdout
 */
static void stdin2archive(void)
{
	char *buf, *fbuf, *readbuf, *n, *pathbuf;
	char *tmpname = NULL;
	char delim;
	size_t i, line, pathsize;
	ssize_t bytes;
	int j, k;
	int tmpfd = -1;
	struct archive *archive;
	struct archive_entry *entry;
	struct stat *s;
	struct rdup *rdup_entry = NULL;
	GSList *hlinks = NULL;
	GSList *hl = NULL;
#ifdef HAVE_LIBNETTLE
	GHashTable *trhash;	/* look up for encrypted/decrypted strs */
	trhash = g_hash_table_new(g_str_hash, g_str_equal);
#endif				/* HAVE_LIBNETTLE */

	delim = '\n';
	i = BUFSIZE;
	buf = g_malloc(BUFSIZE + 1);
	fbuf = g_malloc(BUFSIZE + 1);
	readbuf = g_malloc(BUFSIZE + 1);
	pathbuf = g_malloc(BUFSIZE + 1);
	j = ARCHIVE_OK;
	entry = NULL;
	line = 0;

	if (opt_output == O_RDUP) {
		archive = NULL;
	} else {
		if ((archive = archive_write_new()) == NULL) {
			msg(_("Failed to create archive"));
			exit(EXIT_FAILURE);
		}

		switch (opt_output) {
		case O_TAR:
			j = archive_write_set_format_ustar(archive);
			break;
		case O_CPIO:
			j = archive_write_set_format_cpio(archive);
			break;
		case O_PAX:
			j = archive_write_set_format_pax(archive);
			break;
		case O_RDUP:
			j = ARCHIVE_OK;
			break;
		}

		if (j != ARCHIVE_OK) {
			msg(_("Failed to set archive type to %s"),
			    o_fmt[opt_output]);
			exit(EXIT_FAILURE);
		} else {
			archive_write_open_fd(archive, 1);
		}
	}

	char *tmpenv = getenv("TMPDIR");
	if (!tmpenv) {
		tmpenv = "/tmp";
	}

	while ((rdup_getdelim(&buf, &i, delim, stdin)) != -1) {
		if (opt_output != O_RDUP) {
			tmpname =
			    g_strdup_printf("%s/%s", tmpenv, "rdup-XXXXXX");
			tmpfd = mkstemp(tmpname);
			if (tmpfd == -1) {
				msg(_
				    ("Failure to open temporary file `%s\': %s\n"),
				    tmpname, strerror(errno));
				exit(EXIT_FAILURE);
			}
		}
		line++;
		n = strrchr(buf, '\n');
		if (n)
			*n = '\0';

		if (sig != 0) {
			tmpclean(opt_output, tmpfd, tmpname);
			signal_abort(sig);
		}

		if (!(rdup_entry = parse_entry(buf, line))) {
			/* msgs from entry.c */
			tmpclean(opt_output, tmpfd, tmpname);
			exit(EXIT_FAILURE);
		}

		/* we have a valid entry, read the filename */
		pathsize =
		    fread(pathbuf, sizeof(char), rdup_entry->f_name_size,
			  stdin);

		if (pathsize != rdup_entry->f_name_size) {
			msg(_
			    ("Reported name size (%zd) does not match actual name size (%zd)"),
			    rdup_entry->f_name_size, pathsize);
			tmpclean(opt_output, tmpfd, tmpname);
			exit(EXIT_FAILURE);
		}
		pathbuf[pathsize] = '\0';
		if (pathbuf[0] != '/') {
			msg(_("Pathname does not start with /: `%s\'"),
			    pathbuf);
			tmpclean(opt_output, tmpfd, tmpname);
			exit(EXIT_FAILURE);
		}

		g_free(rdup_entry->f_name);
		rdup_entry->f_name = pathbuf;

		/* extract target from rdup_entry */
		if (S_ISLNK(rdup_entry->f_mode) || rdup_entry->f_lnk) {
			// filesize is spot where to cut and set new size
			rdup_entry->f_name[rdup_entry->f_size] = '\0';
			rdup_entry->f_name_size = strlen(rdup_entry->f_name);
			g_free(rdup_entry->f_target);
			rdup_entry->f_target = rdup_entry->f_name +
			    rdup_entry->f_size + 4;
		} else {
			rdup_entry->f_target = NULL;
		}

		if (opt_verbose > 0) {
			if (S_ISLNK(rdup_entry->f_mode) || rdup_entry->f_lnk) {
				fprintf(stderr, "%s -> %s\n",
					rdup_entry->f_name,
					rdup_entry->f_target);
			} else {
				fprintf(stderr, "%s\n", rdup_entry->f_name);
			}
		}

		if (sig != 0) {
			tmpclean(opt_output, tmpfd, tmpname);
			signal_abort(sig);
		}
#ifdef HAVE_LIBNETTLE
		if (opt_crypt_key)
			rdup_entry = crypt_entry(rdup_entry, trhash);
		if (opt_decrypt_key)
			rdup_entry = decrypt_entry(rdup_entry, trhash);

		if (!rdup_entry) {
			tmpclean(opt_output, tmpfd, tmpname);
			exit(EXIT_FAILURE);	/* encryption problem */
		}
#endif				/* HAVE_LIBNETTLE */

		if (rdup_entry->plusmin == MINUS) {
			if (opt_output == O_RDUP) {
				(void)rdup_write_header(rdup_entry);
				goto not_s_isreg;
			}
			g_free(rdup_entry);
			continue;
		}

		if (opt_output != O_RDUP) {
			if (rdup_entry->f_lnk == 1) {
				/* hardlinks must come last */
				hlinks =
				    g_slist_append(hlinks,
						   entry_dup(rdup_entry));
				g_free(rdup_entry);
				tmpclean(opt_output, tmpfd, tmpname);
				continue;
			}

			s = stat_from_rdup(rdup_entry);
			entry = archive_entry_new();
			archive_entry_copy_stat(entry, s);
			archive_entry_copy_pathname(entry, rdup_entry->f_name);

			if (S_ISLNK(rdup_entry->f_mode))
				archive_entry_copy_symlink(entry,
							   rdup_entry->f_target);
			g_free(s);
		}

		if (opt_output == O_RDUP)
			(void)rdup_write_header(rdup_entry);

		/* bail out for non regular files */
		if (!S_ISREG(rdup_entry->f_mode) || rdup_entry->f_lnk == 1) {
			// We haven't written a header yet for != O_RDUP
			if (opt_output != O_RDUP) {
				archive_write_header(archive, entry);
			}
			goto not_s_isreg;
		}

		/* regular files */
		ssize_t totalbytes = 0;
		while ((bytes = block_in_header(stdin)) > 0) {
			totalbytes += bytes;
			if (block_in(stdin, bytes, fbuf) == -1) {
				msg(_("Failure to read from stdin: %s"),
				    strerror(errno));
				tmpclean(opt_output, tmpfd, tmpname);
				exit(EXIT_FAILURE);
			}

			if (sig != 0) {
				tmpclean(opt_output, tmpfd, tmpname);
				signal_abort(sig);
			}

			if (opt_output == O_RDUP)
				(void)rdup_write_data(rdup_entry, fbuf, bytes);

			if (opt_output != O_RDUP) {
				// Write to temp file
				if (write(tmpfd, fbuf, bytes) != bytes) {
					msg(_
					    ("Failure to write to temporary file `%s\': %s"),
					    tmpname, strerror(errno));
					tmpclean(opt_output, tmpfd, tmpname);
					exit(EXIT_FAILURE);
				}
			}
		}
		/* final block for rdup output */
		if (opt_output == O_RDUP)
			block_out_header(NULL, 0, 1);

		if (opt_output != O_RDUP) {
			// For output that is not O_RDUP we saved the data in a temporary file.
			// Read back this data and output the archive with the correct size.
			archive_entry_set_size(entry, totalbytes);
			archive_write_header(archive, entry);
			if (lseek(tmpfd, 0, SEEK_SET) == -1) {
				msg(_
				    ("Failure to rewind temporary file `%s\': %s"),
				    tmpname, strerror(errno));
				tmpclean(opt_output, tmpfd, tmpname);
				exit(EXIT_FAILURE);
			}

			k = read(tmpfd, fbuf, BUFSIZE);
			while (k > 0) {
				archive_write_data(archive, fbuf, k);
				k = read(tmpfd, fbuf, BUFSIZE);
				if (sig != 0) {
					tmpclean(opt_output, tmpfd, tmpname);
					signal_abort(sig);
				}
			}
		}

 not_s_isreg:
		if (opt_output != O_RDUP)
			archive_entry_free(entry);

#if HAVE_LIBNETTLE
                if (opt_crypt_key) {
                        g_free(rdup_entry->f_name);
                        g_free(rdup_entry->f_target);
                }
#endif
		g_free(rdup_entry->f_user);
		g_free(rdup_entry->f_group);
		g_free(rdup_entry);
		tmpclean(opt_output, tmpfd, tmpname);
	}
	/* output hardlinks -- if any, is zero for O_RDUP */
	for (hl = g_slist_nth(hlinks, 0); hl; hl = hl->next) {
		s = stat_from_rdup((struct rdup *)hl->data);
		entry = archive_entry_new();
		archive_entry_copy_stat(entry, s);
		archive_entry_copy_pathname(entry,
					    ((struct rdup *)hl->data)->f_name);
		archive_entry_copy_hardlink(entry,
					    ((struct rdup *)hl->
					     data)->f_target);
		archive_write_header(archive, entry);
		archive_entry_free(entry);
		g_free(s);
	}

	if (opt_output != O_RDUP) {
		archive_write_close(archive);
		archive_write_free(archive);
	}
	g_free(readbuf);
	g_free(buf);
}

int main(int argc, char **argv)
{
	struct sigaction sa;
	char pwd[BUFSIZE + 1];
	int c;

#ifdef ENABLE_NLS
	if (!setlocale(LC_MESSAGES, ""))
		msg(_("Locale could not be set"));
	bindtextdomain(PACKAGE_NAME, LOCALEROOTDIR);
	(void)textdomain(PACKAGE_NAME);
#endif				/* ENABLE_NLS */

	/* setup our signal handling */
	sa.sa_flags = 0;
	sigfillset(&sa.sa_mask);

	sa.sa_handler = got_sig;
	sigaction(SIGPIPE, &sa, NULL);
	sigaction(SIGINT, &sa, NULL);

	if (((getuid() != geteuid()) || (getgid() != getegid()))) {
		msg(_("Will not run suid/sgid for safety reasons"));
		exit(EXIT_FAILURE);
	}

	if (!getcwd(pwd, BUFSIZE)) {
		msg(_("Could not get current working directory"));
		exit(EXIT_FAILURE);
	}

	for (c = 0; c < argc; c++) {
		if (strlen(argv[c]) > BUFSIZE) {
			msg(_("Argument length overrun"));
			exit(EXIT_FAILURE);
		}
	}

	while ((c = getopt(argc, argv, "cP:O:t:LhVvX:Y:")) != -1) {
		switch (c) {
		case 'c':
			opt_tty = TRUE;
			break;
		case 'v':
			opt_verbose++;
			break;
		case 'L':
			opt_input = I_LIST;
			break;
		case 'P':
			msg(_("Functionality moved to rdup"));
			break;
		case 'O':
			opt_output = O_NONE;

			if (strcmp(optarg, o_fmt[O_TAR]) == 0)
				opt_output = O_TAR;
			if (strcmp(optarg, o_fmt[O_CPIO]) == 0)
				opt_output = O_CPIO;
			if (strcmp(optarg, o_fmt[O_PAX]) == 0)
				opt_output = O_PAX;
			if (strcmp(optarg, o_fmt[O_RDUP]) == 0)
				opt_output = O_RDUP;

			if (opt_output == O_NONE) {
				msg(_("Invalid output format: `%s\'"), optarg);
				exit(EXIT_FAILURE);
			}
			break;
		case 'X':
#ifdef HAVE_LIBNETTLE
			if (opt_decrypt_key) {
				msg(_
				    ("Will not do both encryption and decryption"));
				exit(EXIT_FAILURE);
			}
			if (!(opt_crypt_key = crypt_key(optarg)))
				exit(EXIT_FAILURE);

			aes_ctx = crypt_init(opt_crypt_key, TRUE);
			if (!aes_ctx)
				exit(EXIT_FAILURE);
#else
			msg(_("Compiled without encryption, can not encrypt"));
			exit(EXIT_FAILURE);
#endif				/* HAVE_LIBNETTLE */
			break;
		case 'Y':
#ifdef HAVE_LIBNETTLE
			if (opt_crypt_key) {
				msg(_
				    ("Can not do both encryption and decryption"));
				exit(EXIT_FAILURE);
			}
			if (!(opt_decrypt_key = crypt_key(optarg)))
				exit(EXIT_FAILURE);

			aes_ctx = crypt_init(opt_decrypt_key, FALSE);
			if (!aes_ctx)
				exit(EXIT_FAILURE);
#else
			msg(_("Compiled without encryption, can not decrypt"));
			exit(EXIT_FAILURE);
#endif				/* HAVE_LIBNETTLE */
			break;
		case 'h':
			usage_tr(stdout);
			exit(EXIT_SUCCESS);
		case 'V':
#ifdef DEBUG
			fprintf(stdout, "%s %s (with --enable-debug)\n",
				PROGNAME, VERSION);
#else
			fprintf(stdout, "%s %s\n", PROGNAME, VERSION);
#endif				/* DEBUG */
			exit(EXIT_SUCCESS);
		default:
			msg(_("Unknown option seen `%c\'"), optopt);
			exit(EXIT_FAILURE);
		}
	}
	argc -= optind;
	argv += optind;

	if (!opt_tty && isatty(1) == 1) {
		msg(_("Will not write to a tty"));
		exit(EXIT_FAILURE);
	}

	/* read stdin and (re)make an archive */
	stdin2archive();
	exit(EXIT_SUCCESS);
}