/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Copyright (c) 1983 Regents of the University of California.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms are permitted
 * provided that the above copyright notice and this paragraph are
 * duplicated in all such forms and that any documentation,
 * advertising materials, and other materials related to such
 * distribution and use acknowledge that the software was developed
 * by the University of California, Berkeley.  The name of the
 * University may not be used to endorse or promote products derived
 * from this software without specific prior written permission.
 */

#include "defs.h"
#include <string.h>
#include <syslog.h>
#include <k5-int.h>
#include <krb5defs.h>
#include <priv_utils.h>

#define	NHOSTS 100

/*
 * Remote distribution program.
 */

char	*distfile = NULL;
char	Tmpfile[] = "/tmp/rdistXXXXXX";
char	*tmpname = &Tmpfile[5];

int	debug;		/* debugging flag */
int	nflag;		/* NOP flag, just print commands without executing */
int	qflag;		/* Quiet. Don't print messages */
int	options;	/* global options */
int	iamremote;	/* act as remote server for transfering files */

FILE	*fin = NULL;	/* input file pointer */
int	rem = -1;	/* file descriptor to remote source/sink process */
char	host[32];	/* host name */
int	nerrs;		/* number of errors while sending/receiving */
char	user[10];	/* user's name */
char	homedir[128];	/* user's home directory */
char	buf[RDIST_BUFSIZ];	/* general purpose buffer */

struct	passwd *pw;	/* pointer to static area used by getpwent */
struct	group *gr;	/* pointer to static area used by getgrent */

char des_inbuf[2 * RDIST_BUFSIZ];	/* needs to be > largest read size */
char des_outbuf[2 * RDIST_BUFSIZ];	/* needs to be > largest write size */
krb5_data desinbuf, desoutbuf;
krb5_encrypt_block eblock;		/* eblock for encrypt/decrypt */
krb5_context bsd_context = NULL;
krb5_auth_context auth_context;
krb5_creds *cred;
char *krb_cache = NULL;
krb5_flags authopts;
krb5_error_code status;
enum kcmd_proto kcmd_proto = KCMD_NEW_PROTOCOL;

int encrypt_flag = 0;	/* Flag set when encryption is used */
int krb5auth_flag = 0;	/* Flag set, when KERBEROS is enabled */
static profile_options_boolean autologin_option[] = {
	{ "autologin", &krb5auth_flag, 0 },
	{ NULL, NULL, 0 }
};
static int no_krb5auth_flag = 0;

int debug_port = 0;

int retval = 0;
char *krb_realm = NULL;

/* Flag set, if -PN / -PO is specified */
static boolean_t rcmdoption_done = B_FALSE;

static int encrypt_done = 0;	/* Flag set, if -x is specified */
profile_options_boolean option[] = {
	{ "encrypt", &encrypt_flag, 0 },
	{ NULL, NULL, 0 }
};

static char *rcmdproto = NULL;
profile_option_strings rcmdversion[] = {
	{ "rcmd_protocol", &rcmdproto, 0 },
	{ NULL, NULL, 0 }
};

char *realmdef[] = { "realms", NULL, "rdist", NULL };
char *appdef[] = { "appdefaults", "rdist", NULL };

static void usage(void);
static char *prtype(int t);
static void prsubcmd(struct subcmd *s);
static void docmdargs(int nargs, char *args[]);
void prnames();
void prcmd();

int
main(argc, argv)
	int argc;
	char *argv[];
{
	register char *arg;
	int cmdargs = 0;
	char *dhosts[NHOSTS], **hp = dhosts;

	(void) setlocale(LC_ALL, "");

	pw = getpwuid(getuid());
	if (pw == NULL) {
		(void) fprintf(stderr, gettext("%s: Who are you?\n"), argv[0]);
		exit(1);
	}
	strncpy(user, pw->pw_name, sizeof (user));
	user[sizeof (user) - 1] = '\0';
	strncpy(homedir, pw->pw_dir, sizeof (homedir));
	homedir[sizeof (homedir) - 1] = '\0';
	gethostname(host, sizeof (host));

	while (--argc > 0) {
		if ((arg = *++argv)[0] != '-')
			break;
		if ((strcmp(arg, "-Server") == 0))
			iamremote++;
		else while (*++arg) {
			if (strncmp(*argv, "-PO", 3) == 0) {
				if (rcmdoption_done == B_TRUE) {
					(void) fprintf(stderr, gettext("rdist: "
						"Only one of -PN "
						"and -PO allowed.\n"));
					usage();
				}
				kcmd_proto = KCMD_OLD_PROTOCOL;
				krb5auth_flag++;
				rcmdoption_done = B_TRUE;
				break;
			}
			if (strncmp(*argv, "-PN", 3) == 0) {
				if (rcmdoption_done == B_TRUE) {
					(void) fprintf(stderr, gettext("rdist: "
						"Only one of -PN "
						"and -PO allowed.\n"));
					usage();
				}
				kcmd_proto = KCMD_NEW_PROTOCOL;
				krb5auth_flag++;
				rcmdoption_done = B_TRUE;
				break;
			}

			switch (*arg) {
#ifdef DEBUG
			case 'p':
				if (--argc <= 0)
					usage();
				debug_port = htons(atoi(*++argv));
				break;
#endif /* DEBUG */
			case 'k':
				if (--argc <= 0) {
					(void) fprintf(stderr, gettext("rdist: "
						"-k flag must be followed with "
						" a realm name.\n"));
					exit(1);
				}
				if ((krb_realm = strdup(*++argv)) == NULL) {
					(void) fprintf(stderr, gettext("rdist: "
						"Cannot malloc.\n"));
					exit(1);
				}
				krb5auth_flag++;
				break;

			case 'K':
				no_krb5auth_flag++;
				break;

			case 'a':
				krb5auth_flag++;
				break;

			case 'x':
				encrypt_flag++;
				encrypt_done++;
				krb5auth_flag++;
				break;

			case 'f':
				if (--argc <= 0)
					usage();
				distfile = *++argv;
				if (distfile[0] == '-' && distfile[1] == '\0')
					fin = stdin;
				break;

			case 'm':
				if (--argc <= 0)
					usage();
				if (hp >= &dhosts[NHOSTS-2]) {
					(void) fprintf(stderr, gettext("rdist:"
						" too many destination"
						" hosts\n"));
					exit(1);
				}
				*hp++ = *++argv;
				break;

			case 'd':
				if (--argc <= 0)
					usage();
				define(*++argv);
				break;

			case 'D':
				debug++;
				break;

			case 'c':
				cmdargs++;
				break;

			case 'n':
				if (options & VERIFY) {
					printf("rdist: -n overrides -v\n");
					options &= ~VERIFY;
				}
				nflag++;
				break;

			case 'q':
				qflag++;
				break;

			case 'b':
				options |= COMPARE;
				break;

			case 'R':
				options |= REMOVE;
				break;

			case 'v':
				if (nflag) {
					printf("rdist: -n overrides -v\n");
					break;
				}
				options |= VERIFY;
				break;

			case 'w':
				options |= WHOLE;
				break;

			case 'y':
				options |= YOUNGER;
				break;

			case 'h':
				options |= FOLLOW;
				break;

			case 'i':
				options |= IGNLNKS;
				break;

			default:
				usage();
			}
		}
	}
	*hp = NULL;

	mktemp(Tmpfile);

	/*
	 * if the user disables krb5 on the cmdline (-K), then skip
	 * all krb5 setup.
	 *
	 * if the user does not disable krb5 or enable krb5 on the
	 * cmdline, check krb5.conf to see if it should be enabled.
	 */

	if (no_krb5auth_flag) {
		krb5auth_flag = 0;
		encrypt_flag = 0;
	} else if (!krb5auth_flag) {
		/* is autologin set in krb5.conf? */
		status = krb5_init_context(&bsd_context);
		/* don't sweat failure here */
		if (!status) {
			/*
			 * note that the call to profile_get_options_boolean
			 * with autologin_option can affect value of
			 * krb5auth_flag
			 */
			(void) profile_get_options_boolean(bsd_context->profile,
							appdef,
							autologin_option);
		}
	}

	if (krb5auth_flag > 0) {
		if (!bsd_context) {
			status = krb5_init_context(&bsd_context);
			if (status) {
				com_err("rdist", status,
				    gettext("while initializing krb5"));
				exit(1);
			}
		}

		/* Set up des buffers */
		desinbuf.data = des_inbuf;
		desoutbuf.data = des_outbuf;
		desinbuf.length = sizeof (des_inbuf);
		desoutbuf.length = sizeof (des_outbuf);

		/*
		 * Get our local realm to look up local realm options.
		 */
		status = krb5_get_default_realm(bsd_context, &realmdef[1]);
		if (status) {
			com_err("rdist", status,
				gettext("while getting default realm"));
			exit(1);
		}
		/*
		 * See if encryption should be done for this realm
		 */
		profile_get_options_boolean(bsd_context->profile, realmdef,
						option);
		/*
		 * Check the appdefaults section
		 */
		profile_get_options_boolean(bsd_context->profile, appdef,
						option);
		profile_get_options_string(bsd_context->profile, appdef,
						rcmdversion);

		if ((encrypt_done > 0) || (encrypt_flag > 0)) {
			if (krb5_privacy_allowed() == TRUE) {
				encrypt_flag++;
			} else {
				(void) fprintf(stderr, gettext("rdist: "
						"Encryption not supported.\n"));
				exit(1);
			}
		}

		if ((rcmdoption_done == B_FALSE) && (rcmdproto != NULL)) {
			if (strncmp(rcmdproto, "rcmdv2", 6) == 0) {
				kcmd_proto = KCMD_NEW_PROTOCOL;
			} else if (strncmp(rcmdproto, "rcmdv1", 6) == 0) {
				kcmd_proto = KCMD_OLD_PROTOCOL;
			} else {
				(void) fprintf(stderr, gettext("Unrecognized "
					"KCMD protocol (%s)"), rcmdproto);
				exit(1);
			}
		}
	}

	if (iamremote) {
		setreuid(getuid(), getuid());
		server();
		exit(nerrs != 0);
	}
	if (__init_suid_priv(0, PRIV_NET_PRIVADDR, NULL) == -1) {
		(void) fprintf(stderr,
			"rdist needs to run with sufficient privilege\n");
		exit(1);
	}

	if (cmdargs)
		docmdargs(argc, argv);
	else {
		if (fin == NULL) {
			if (distfile == NULL) {
				if ((fin = fopen("distfile", "r")) == NULL)
					fin = fopen("Distfile", "r");
			} else
				fin = fopen(distfile, "r");
			if (fin == NULL) {
				perror(distfile ? distfile : "distfile");
				exit(1);
			}
		}
		yyparse();
		if (nerrs == 0)
			docmds(dhosts, argc, argv);
	}

	return (nerrs != 0);
}

static void
usage()
{
	printf(gettext("Usage: rdist [-nqbhirvwyDax] [-PN / -PO] "
#ifdef DEBUG
	"[-p port] "
#endif /* DEBUG */
	"[-k realm] [-f distfile] [-d var=value] [-m host] [file ...]\n"));
	printf(gettext("or: rdist [-nqbhirvwyDax] [-PN / -PO] [-p port] "
	"[-k realm] -c source [...] machine[:dest]\n"));
	exit(1);
}

/*
 * rcp like interface for distributing files.
 */
static void
docmdargs(nargs, args)
	int nargs;
	char *args[];
{
	register struct namelist *nl, *prev;
	register char *cp;
	struct namelist *files, *hosts;
	struct subcmd *cmds;
	char *dest;
	static struct namelist tnl = { NULL, NULL };
	int i;

	if (nargs < 2)
		usage();

	prev = NULL;
	for (i = 0; i < nargs - 1; i++) {
		nl = makenl(args[i]);
		if (prev == NULL)
			files = prev = nl;
		else {
			prev->n_next = nl;
			prev = nl;
		}
	}

	cp = args[i];
	if ((dest = index(cp, ':')) != NULL)
		*dest++ = '\0';
	tnl.n_name = cp;
	hosts = expand(&tnl, E_ALL);
	if (nerrs)
		exit(1);

	if (dest == NULL || *dest == '\0')
		cmds = NULL;
	else {
		cmds = makesubcmd(INSTALL);
		cmds->sc_options = options;
		cmds->sc_name = dest;
	}

	if (debug) {
		printf("docmdargs()\nfiles = ");
		prnames(files);
		printf("hosts = ");
		prnames(hosts);
	}
	insert(NULL, files, hosts, cmds);
	docmds(NULL, 0, NULL);
}

/*
 * Print a list of NAME blocks (mostly for debugging).
 */
void
prnames(nl)
	register struct namelist *nl;
{
	printf("( ");
	while (nl != NULL) {
		printf("%s ", nl->n_name);
		nl = nl->n_next;
	}
	printf(")\n");
}

void
prcmd(c)
	struct cmd *c;
{
	extern char *prtype();

	while (c) {
		printf("c_type %s, c_name %s, c_label %s, c_files ",
			prtype(c->c_type), c->c_name,
			c->c_label?  c->c_label : "NULL");
		prnames(c->c_files);
		prsubcmd(c->c_cmds);
		c = c->c_next;
	}
}

static void
prsubcmd(s)
	struct subcmd *s;
{
	extern char *prtype();
	extern char *proptions();

	while (s) {
		printf("sc_type %s, sc_options %d%s, sc_name %s, sc_args ",
			prtype(s->sc_type),
			s->sc_options, proptions(s->sc_options),
			s->sc_name ? s->sc_name : "NULL");
		prnames(s->sc_args);
		s = s->sc_next;
	}
}

char *
prtype(t)
	int t;
{
	switch (t) {
		case EQUAL:
			return ("EQUAL");
		case LP:
			return ("LP");
		case RP:
			return ("RP");
		case SM:
			return ("SM");
		case ARROW:
			return ("ARROW");
		case COLON:
			return ("COLON");
		case DCOLON:
			return ("DCOLON");
		case NAME:
			return ("NAME");
		case STRING:
			return ("STRING");
		case INSTALL:
			return ("INSTALL");
		case NOTIFY:
			return ("NOTIFY");
		case EXCEPT:
			return ("EXCEPT");
		case PATTERN:
			return ("PATTERN");
		case SPECIAL:
			return ("SPECIAL");
		case OPTION:
			return ("OPTION");
	}
	return (NULL);
}

char *
proptions(o)
	int o;
{
	return (printb((unsigned short) o, OBITS));
}

char *
printb(v, bits)
	register char *bits;
	register unsigned short v;
{
	register int i, any = 0;
	register char c;
	char *p = buf;

	bits++;
	if (bits) {

		*p++ = '<';
		while ((i = *bits++) != 0) {
			if (v & (1 << (i-1))) {
				if (any)
					*p++ = ',';
				any = 1;
				for (; (c = *bits) > 32; bits++)
					*p++ = c;
			} else
				for (; *bits > 32; bits++)
					;
		}
		*p++ = '>';
	}

	*p = '\0';
	return (buf);
}