path: root/qpkg.c

/*
 * Copyright 2005-2024 Gentoo Foundation
 * Distributed under the terms of the GNU General Public License v2
 *
 * Copyright 2005-2010 Ned Ludd	       - <solar@gentoo.org>
 * Copyright 2005-2014 Mike Frysinger  - <vapier@gentoo.org>
 * Copyright 2018-     Fabian Groffen  - <grobian@gentoo.org>
 */

#include "main.h"
#include "applets.h"

#include <stdio.h>
#include <string.h>
#include <fnmatch.h>
#include <dirent.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>

#include "atom.h"
#include "basename.h"
#include "contents.h"
#include "hash.h"
#include "human_readable.h"
#include "scandirat.h"
#include "set.h"
#include "tree.h"
#include "xarray.h"
#include "xasprintf.h"
#include "xchdir.h"
#include "xmkdir.h"
#include "xpak.h"

#define QPKG_FLAGS "cEpP:" COMMON_FLAGS
static struct option const qpkg_long_opts[] = {
	{"clean",    no_argument, NULL, 'c'},
	{"eclean",   no_argument, NULL, 'E'},
	{"pretend",  no_argument, NULL, 'p'},
	{"pkgdir",    a_argument, NULL, 'P'},
	COMMON_LONG_OPTS
};
static const char * const qpkg_opts_help[] = {
	"clean pkgdir of files that are not installed",
	"clean pkgdir of files that are not in the tree anymore",
	"pretend only",
	"alternate package directory",
	COMMON_OPTS_HELP
};
#define qpkg_usage(ret) usage(ret, QPKG_FLAGS, qpkg_long_opts, qpkg_opts_help, NULL, lookup_applet_idx("qpkg"))

extern char pretend;

static char *qpkg_bindir = NULL;
static int eclean = 0;

/* figure out what dirs we want to process for cleaning and display results. */
static int
qpkg_clean(char *dirp)
{
	size_t n;
	size_t disp_units = 0;
	uint64_t num_all_bytes = 0;
	set *known_pkgs = NULL;
	set *bin_pkgs = NULL;
	DECLARE_ARRAY(bins);
	tree_ctx *t;
	tree_ctx *pkgs;
	char *binatomstr;
	depend_atom *atom;
	char buf[_Q_PATH_MAX];
	struct stat st;

	pkgs = tree_open_binpkg(portroot, dirp);
	if (pkgs == NULL)
		return 1;

	bin_pkgs = tree_get_atoms(pkgs, true, bin_pkgs);
	if (bin_pkgs == NULL)
		return 1;
	array_set(bin_pkgs, bins);

	if (eclean) {
		const char *overlay;

		array_for_each(overlays, n, overlay) {
			t = tree_open(portroot, overlay);
			if (t != NULL) {
				known_pkgs = tree_get_atoms(t, true, known_pkgs);
				tree_close(t);
			}
		}
	} else {
		t = tree_open_vdb(portroot, portvdb);
		if (t != NULL) {
			known_pkgs = tree_get_atoms(t, true, known_pkgs);
			tree_close(t);
		}
	}

	if (known_pkgs != NULL) {
		/* check which binpkgs exist in the known_pkgs (vdb or trees), such
		 * that the remainder is what we would clean */
		array_for_each(bins, n, binatomstr) {
			if (contains_set(binatomstr, known_pkgs))
				xarraydelete_ptr(bins, n--);
		}

		free_set(known_pkgs);
	}

	array_for_each(bins, n, binatomstr) {
		snprintf(buf, sizeof(buf), "%s/%s.tbz2", dirp, binatomstr);
		atom = atom_explode(binatomstr);
		if (lstat(buf, &st) != -1) {
			if (S_ISREG(st.st_mode)) {
				disp_units = KILOBYTE;
				if ((st.st_size / KILOBYTE) > 1000)
					disp_units = MEGABYTE;
				num_all_bytes += st.st_size;
				qprintf(" %s[%s %3s %s %s]%s %s\n",
						DKBLUE, GREEN,
						make_human_readable_str(st.st_size, 1, disp_units),
						disp_units == MEGABYTE ? "MiB" : "KiB",
						DKBLUE, NORM, atom_format("%[CAT]/%[PF]", atom));
			}
			if (!pretend)
				unlink(buf);
		}
		atom_implode(atom);
	}

	xarrayfree_int(bins);
	free_set(bin_pkgs);

	disp_units = KILOBYTE;
	if ((num_all_bytes / KILOBYTE) > 1000)
		disp_units = MEGABYTE;
	qprintf(" %s*%s Total space %sfreed in packages "
			"directory: %s%s %ciB%s\n", GREEN, NORM,
			pretend ? "that would be " : "", RED,
			make_human_readable_str(num_all_bytes, 1, disp_units),
			disp_units == MEGABYTE ? 'M' : 'K', NORM);

	return 0;
}

static int
check_pkg_install_mask(char *name)
{
	int i, iargc, ret;
	char **iargv;

	i = iargc = ret = 0;

	if (*name != '/')
		return ret;

	makeargv(pkg_install_mask, &iargc, &iargv);

	for (i = 1; i < iargc; i++) {
		if (fnmatch(iargv[i], name, 0) != 0)
			continue;
		ret = 1;
		break;
	}
	freeargv(iargc, iargv);
	return ret;
}

static int
qpkg_make(tree_pkg_ctx *pkg)
{
	FILE *out;
	FILE *fp;
	char tmpdir[BUFSIZE];
	char filelist[BUFSIZE + 32];
	char tbz2[BUFSIZE + 32];
	char buf[BUFSIZE * 4];
	size_t xpaksize;
	char *line;
	char *savep;
	int i;
	char *xpak_argv[2];
	struct stat st;
	mode_t mask;
	depend_atom *atom = tree_get_atom(pkg, false);

	if (pretend) {
		printf(" %s-%s %s:\n",
				GREEN, NORM, atom_format("%[CATEGORY]%[PF]", atom));
		return 0;
	}

	line = tree_pkg_meta_get(pkg, CONTENTS);
	if (line == NULL)
		return -1;

	snprintf(tmpdir, sizeof(tmpdir), "%s/qpkg.XXXXXX", qpkg_bindir);
	mask = umask(0077);
	i = mkstemp(tmpdir);
	umask(mask);
	if (i == -1)
		return -2;
	close(i);
	unlink(tmpdir);
	if (mkdir(tmpdir, 0750))
		return -3;

	snprintf(filelist, sizeof(filelist), "%s/filelist", tmpdir);
	if ((out = fopen(filelist, "w")) == NULL)
		return -4;

	for (; (line = strtok_r(line, "\n", &savep)) != NULL; line = NULL) {
		contents_entry *e;
		e = contents_parse_line(line);
		if (!e || e->type == CONTENTS_DIR)
			continue;
		if (check_pkg_install_mask(e->name) != 0)
			continue;
		fprintf(out, "%s\n", e->name+1); /* don't output leading / */
		if (e->type == CONTENTS_OBJ && verbose) {
			char *hash = hash_file(e->name, HASH_MD5);
			if (hash != NULL) {
				if (strcmp(e->digest, hash) != 0)
					warn("MD5: mismatch expected %s got %s for %s",
							e->digest, hash, e->name);
			}
		}
	}

	fclose(out);

	printf(" %s-%s %s: ", GREEN, NORM,
			atom_format("%[CATEGORY]%[PF]", atom));
	fflush(stdout);

	snprintf(tbz2, sizeof(tbz2), "%s/bin.tbz2", tmpdir);
	if (snprintf(buf, sizeof(buf), "tar jcf '%s' --files-from='%s' "
			"--no-recursion >/dev/null 2>&1", tbz2, filelist) >
			(int)sizeof(buf) || (fp = popen(buf, "r")) == NULL)
		return 2;
	pclose(fp);

	if ((i = open(tbz2, O_WRONLY)) < 0) {
		warnp("failed to open '%s': %s", tbz2, strerror(errno));
		return 1;
	}

	/* get offset where xpak will start */
	if (fstat(i, &st) == -1) {
		warnp("could not stat '%s': %s", tbz2, strerror(errno));
		close(i);
		return 1;
	}
	xpaksize = st.st_size;

	snprintf(buf, sizeof(buf), "%s%s/%s/%s",
			portroot, portvdb, atom->CATEGORY, atom->PF);
	xpak_argv[0] = buf;
	xpak_argv[1] = NULL;
	xpak_create(AT_FDCWD, tbz2, 1, xpak_argv, 1, verbose);

	/* calculate the number of bytes taken by the xpak archive */
	if (fstat(i, &st) == -1) {
		warnp("could not stat '%s': %s", tbz2, strerror(errno));
		close(i);
		return 1;
	}
	xpaksize = st.st_size - xpaksize;

	/* save tbz2 tail: OOOOSTOP */
	if ((fp = fdopen(i, "a")) == NULL) {
		warnp("could not open '%s': %s", tbz2, strerror(errno));
		close(i);
		return 1;
	}

	WRITE_BE_INT32(buf, xpaksize);
	fwrite(buf, 1, 4, fp);
	fwrite("STOP", 1, 4, fp);
	fclose(fp);

	unlink(filelist);

	/* create dirs, if necessary */
	snprintf(buf, sizeof(buf), "%s/%s", qpkg_bindir, atom->CATEGORY);
	mkdir_p(buf, 0755);

	snprintf(buf, sizeof(buf), "%s/%s/%s.tbz2",
			qpkg_bindir, atom->CATEGORY, atom->PF);
	if (rename(tbz2, buf)) {
		warnp("could not move '%s' to '%s'", tbz2, buf);
		return 1;
	}

	rmdir(tmpdir);

	if (stat(buf, &st) == -1) {
		warnp("could not stat '%s': %s", buf, strerror(errno));
		return 1;
	}

	printf("%s%s%s KiB\n",
			RED, make_human_readable_str(st.st_size, 1, KILOBYTE), NORM);

	return 0;
}

static int
qpkg_cb(tree_pkg_ctx *pkg, void *priv)
{
	size_t *pkgs_made = priv;

	if (qpkg_make(pkg) == 0)
		(*pkgs_made)++;

	return 0;
}

int qpkg_main(int argc, char **argv)
{
	tree_ctx *ctx;
	size_t s, pkgs_made;
	int i;
	struct stat st;
	depend_atom *atom;
	int restrict_chmod = 0;
	int qclean = 0;
	int fd;

	qpkg_bindir = pkgdir;
	while ((i = GETOPT_LONG(QPKG, qpkg, "")) != -1) {
		switch (i) {
		case 'E': eclean = qclean = 1; break;
		case 'c': qclean = 1; break;
		case 'p': pretend = 1; break;
		case 'P':
			restrict_chmod = 1;
			qpkg_bindir = optarg;
			if (access(qpkg_bindir, W_OK) != 0)
				errp("%s", qpkg_bindir);
			break;
		COMMON_GETOPTS_CASES(qpkg)
		}
	}
	if (qclean)
		return qpkg_clean(qpkg_bindir);

	if (argc == optind)
		qpkg_usage(EXIT_FAILURE);

	/* setup temp dirs */
	if (qpkg_bindir[0] != '/')
		err("'%s' is not a valid package destination", qpkg_bindir);
	/* brute force just unlink any file or symlink, if this fails, it's
	 * actually good :) */
	unlink(qpkg_bindir);
	fd = open(qpkg_bindir, O_RDONLY);
	if ((fd == -1 && mkdir(qpkg_bindir, 0750) == -1) ||
			(fd != -1 && (fstat(fd, &st) == -1 || !S_ISDIR(st.st_mode))))
	{
		errp("could not create temp bindir '%s'", qpkg_bindir);
	}
	if (fd >= 0) {
		/* fd is valid, pointing to a directory */
		if (!restrict_chmod)
			if (fchmod(fd, 0750) < 0)
				errp("could not chmod(0750) temp bindir '%s'", qpkg_bindir);
		close(fd);
	}

	/* we have to change to the root so that we can feed the full paths
	 * to tar when we create the binary package. */
	xchdir(portroot);

	ctx = tree_open_vdb(portroot, portvdb);
	if (!ctx)
		return EXIT_FAILURE;

	/* first process any arguments which point to /var/db/pkg, an
	 * undocumented method to allow easily tab-completing into vdb as
	 * arguments, the trailing / needs to be present for this (as tab
	 * completion would do) */
	pkgs_made = 0;
	s = strlen(portvdb);
	for (i = optind; i < argc; ++i) {
		size_t asize = strlen(argv[i]);
		if (asize == 0) {
			argv[i] = NULL;
			continue;
		}
		if (asize > s && argv[i][0] == '/' && argv[i][asize - 1] == '/') {
			char *path = argv[i];

			/* chop off trailing / */
			argv[i][asize - 1] = '\0';

			/* eliminate duplicate leading /, we know it starts with / */
			while (path[1] == '/')
				path++;

			if (strncmp(portvdb, path, s) == 0) {
				path += s + 1 /* also eat / after portvdb */;
				argv[i] = path;
			} else {
				argv[i][asize - 1] = '/';  /* restore, it may be a cat match */
			}
		}
	}

	/* now try to run through vdb and locate matches for user inputs */
	for (i = optind; i < argc; ++i) {
		if (argv[i] == NULL)
			continue;
		if (strcmp(argv[i], "world") == 0) {
			/* this is a crude hack, we include all packages for this,
			 * which isn't exactly @world, but all its deps too */
			tree_foreach_pkg_fast(ctx, qpkg_cb, &pkgs_made, NULL);
			break;  /* no point in continuing since we did everything */
		}
		atom = atom_explode(argv[i]);
		if (atom == NULL)
			continue;

		s = pkgs_made;
		tree_foreach_pkg_fast(ctx, qpkg_cb, &pkgs_made, atom);
		if (s == pkgs_made)
			warn("no match for '%s'", argv[i]);
		atom_implode(atom);
	}
	tree_close(ctx);

	if (pkgs_made)
		qprintf(" %s*%s Packages can be found in %s\n",
				GREEN, NORM, qpkg_bindir);

	return (pkgs_made ? EXIT_SUCCESS : EXIT_FAILURE);
}