/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2025 Oxide Computer Company
 */

/*
 * Parse a "Manlink" file and create the symlinks described within under a
 * specified destination directory.
 */


#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <ctype.h>
#include <err.h>
#include <errno.h>
#include <string.h>
#include <stdbool.h>
#include <libgen.h>
#include <sys/debug.h>
#include <sys/sysmacros.h>
#include <sys/stat.h>

static const char *progname = NULL;

static void
usage(const char *fmt, ...)
{
	if (fmt != NULL) {
		va_list ap;

		va_start(ap, fmt);
		vwarnx(fmt, ap);
		va_end(ap);
	}

	(void) fprintf(stderr,
	    "Usage: %s [opts] -d <destdir> <input(s)>\n\n"
	    "Options:\n"
	    "\t-n\tdry run\n",
	    progname);
}

typedef struct manlink_iter {
	FILE	*mi_fp;
	size_t	mi_cap;
	char	*mi_line;
	char	*mi_tok_saveptr;
	char	*mi_target;
} manlink_iter_t;

typedef struct manlink_iter_result {
	const char	*mir_name;
	const char	*mir_target;
} manlink_iter_res_t;

static bool
valid_name(const char *name)
{
	for (char c; (c = *name) != '\0'; name++) {
		if (c == '/') {
			/* Link names expected to be in base directory */
			return (false);
		}
		if (c == '#') {
			/* Should not contain comment character */
			return (false);
		}
		if (!isalnum(c) && !ispunct(c)) {
			/* Expect "normal" man page names */
			return (false);
		}
	}
	return (true);
}

static bool
valid_target(const char *target)
{
	for (char c; (c = *target) != '\0'; target++) {
		if (isalnum(c)) {
			continue;
		}
		switch (c) {
		case '.':
		case '_':
		case '-':
		case '/':
			break;
		default:
			return (false);
		}
	}
	return (true);
}

static void
link_iter_init(FILE *ifp, manlink_iter_t *itr)
{
	itr->mi_fp = ifp;
	itr->mi_cap = 0;
	itr->mi_line = NULL;
	itr->mi_target = NULL;
}

static void
link_iter_fini(manlink_iter_t *itr)
{
	(void) fclose(itr->mi_fp);
	free(itr->mi_line);
	free(itr->mi_target);
}

static bool
link_iter_next(manlink_iter_t *itr, const char **namep, const char **targetp)
{
	ssize_t len;

	while ((len = getline(&itr->mi_line, &itr->mi_cap, itr->mi_fp)) >= 1) {
		char *line = itr->mi_line;

		/* Nuke the trailing newline (if any) */
		if (line[len - 1] == '\n') {
			line[len - 1] = '\0';
		}

		if (*line == '\0' || *line == '#') {
			/* Skip empty lines and comments */
			continue;
		} else if (*line == '\t') {
			const char *name = line + 1;

			if (!valid_name(name)) {
				err(EXIT_FAILURE,
				    "Invalid link name: \"%s\"", name);
			} else if (itr->mi_target == NULL) {
				err(EXIT_FAILURE,
				    "Link without preceding target");
			} else {
				*namep = name;
				*targetp = itr->mi_target;
				return (true);
			}
		} else {
			if (!valid_target(line)) {
				errx(EXIT_FAILURE,
				    "Invalid link target \"%s\"", line);
			} else {
				free(itr->mi_target);
				itr->mi_target = strdup(line);
				continue;
			}
		}
	}

	return (false);
}

static void
do_links(const char *dest_dir, const char *input_file, bool dry_run)
{
	int dfd = open(dest_dir, O_DIRECTORY | O_RDONLY, 0);
	if (dfd < 0) {
		err(EXIT_FAILURE, "Could not open destination dir %s",
		    dest_dir);
	}

	FILE *ifp = fopen(input_file, "r");
	if (ifp == NULL) {
		err(EXIT_FAILURE, "Could not open input file %s", input_file);
	}

	manlink_iter_t iter;
	link_iter_init(ifp, &iter);

	const char *name, *target;
	while (link_iter_next(&iter, &name, &target)) {
		struct stat st;

		const int res = fstatat(dfd, name, &st, AT_SYMLINK_NOFOLLOW);
		if (res == 0) {
			if (S_ISLNK(st.st_mode)) {
				char buf[MAXPATHLEN];

				buf[0] = '\0';
				ssize_t len = readlinkat(dfd, name, buf,
				    sizeof (buf));
				if (len > 0) {
					/* NUL terminate */
					buf[MIN(len, sizeof (buf) - 1)] = '\0';
				}

				if (strncmp(buf, target, sizeof (buf)) == 0) {
					continue;
				}
			}
			(void) printf("unlink %s/%s\n", dest_dir, name);
			if (!dry_run && unlinkat(dfd, name, 0) != 0) {
				err(EXIT_FAILURE,
				    "Could not unlink conflicting file %s/%s",
				    dest_dir, name);
			}
		} else if (errno != ENOENT) {
			err(EXIT_FAILURE, "stat() failure for link %s/%s",
			    dest_dir, name);
		}

		(void) printf("link %s/%s -> %s\n", dest_dir, name, target);
		if (!dry_run && symlinkat(target, dfd, name) != 0) {
			err(EXIT_FAILURE, "failure to create link at %s/%s",
			    dest_dir, name);
		}
	}
	link_iter_fini(&iter);
}

int
main(int argc, char *argv[])
{
	char *dest_dir = NULL;
	bool do_dry_run = false;
	progname = basename(argv[0]);

	int c;
	while ((c = getopt(argc, argv, "nd:")) != -1) {
		switch (c) {
		case 'd':
			dest_dir = optarg;
			break;
		case 'n':
			do_dry_run = true;
			break;
		case '?':
			usage("unknown option: -%c", optopt);
			exit(EXIT_FAILURE);
		}
	}
	argc -= optind;
	argv += optind;

	if (argc < 1) {
		usage("input file(s)");
		exit(EXIT_FAILURE);
	}
	for (uint_t i = 0; i < (uint_t)argc; i++) {
		do_links(dest_dir, argv[i], do_dry_run);
	}

	return (EXIT_SUCCESS);
}