xref: /titanic_51/usr/src/cmd/ypcmd/ypserv.c (revision 7c478bd95313f5f23a4c958a745db2134aa03244)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*	Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T	*/
/*	  All Rights Reserved  	*/

/*
 * Portions of this source code were derived from Berkeley 4.3 BSD
 * under license from the Regents of the University of California.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*
 * This contains the mainline code for the YP server.  Data
 * structures which are process-global are also in this module.
 */

/* this is so that ypserv will compile under 5.5 */
#define	_SVID_GETTOD
#include <sys/time.h>
extern int gettimeofday(struct timeval *);

#include "ypsym.h"
#include <sys/types.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <rpc/rpc.h>
#include <netconfig.h>
#include <netdir.h>
#include <sys/select.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <stdarg.h>
#include <signal.h>
#include "shim.h"
#include "yptol.h"
#include <syslog.h>

static char register_failed[] = "ypserv:  Unable to register service for ";
bool silent = TRUE;

/*
 * client_setup_failure will be TRUE, if setup of the
 * connection to rpc.nisd_resolv failed
 */
bool client_setup_failure = FALSE;

/* N2L options */
bool init_dit = FALSE;
bool init_containers = FALSE;
bool init_maps = FALSE;
char **ldapCLA = NULL;

/* For DNS forwarding command line option (-d) */
bool dnsforward = FALSE;
int resolv_pid = 0;
CLIENT *resolv_client = NULL;
char *resolv_tp = "ticots";

#ifdef MINUS_C_OPTION
/* For cluster support (-c) */
bool multiflag = FALSE;
#endif

static char logfile[] = "/var/yp/ypserv.log";
void logprintf(char *format, ...);

static void ypexit(void);
static void ypinit(int argc, char **argv);
static void ypdispatch(struct svc_req *rqstp, SVCXPRT *transp);
static void ypolddispatch(struct svc_req *rqstp, SVCXPRT *transp);
static void ypget_command_line_args(int argc, char **argv);
extern void setup_resolv(bool *fwding, int *child,
			CLIENT **client, char *tp_type, long prognum);
static void cleanup_resolv(int);

/*
 * This is the main line code for the yp server.
 */
int
main(int argc, char **argv)
{
	if (geteuid() != 0) {
		fprintf(stderr, "must be root to run %s\n", argv[0]);
		exit(1);
	}

	/* Set up shop */
	ypinit(argc, argv);

	/* If requested set up the N2L maps. May take a while */
	if (init_dit)
		if (FAILURE == dump_maps_to_dit(init_containers)) {
			fprintf(stderr, "Fatal error dumping maps to DIT."
			" See syslog and LDAP server logs for details.\n");
			exit(1);
		}

	if (init_maps)
		if (FAILURE == dump_dit_to_maps()) {
			fprintf(stderr, "Fatal error dumping DIT to maps."
			" See syslog and LDAP server logs for details.\n");
			exit(1);
		}

	/*
	 * If we were asked to init the maps now exit. User will then use
	 * ypstart to restart ypserv and all the other NIS daemons.
	 */
	if (init_dit || init_maps) {
		printf("Map setup complete. Please now restart NIS daemons "
			"with ypstart.\n");
		exit(0);
	}

	svc_run();

	/*
	 * This is stupid, but the compiler likes to warn us about the
	 * absence of returns from main()
	 */
	return (0);
}

typedef struct {
	char		*netid;
	int		fd;
	int		olddispatch;	/* Register on protocol version 1 ? */
	int		class;		/* Other services that must succeed */
	SVCXPRT		*xprt;
	int		ok;		/* Registered successfully ? */
} ypservice_t;

ypservice_t	service[] = {
	{ "udp", -1, 1, 4, 0, 0 },
	{ "tcp", -1, 1, 4, 0, 0 },
	{ "udp6", -1, 0, 6, 0, 0 },
	{ "tcp6", -1, 0, 6, 0, 0 }
};

#define	MAXSERVICES	(sizeof (service)/sizeof (service[0]))

int		service_classes[MAXSERVICES];

/*
 * Does startup processing for the yp server.
 */
static void
ypinit(int argc, char **argv)
{
	int pid;
	int stat, t;
	struct sigaction act;
	int ufd, tfd;
	SVCXPRT *utransp, *ttransp;
	struct netconfig *nconf;
	int connmaxrec = RPC_MAXDATASIZE;
	int i, j, services = 0;


	/*
	 * Init yptol flags. Will get redone by init_lock_system() but we need
	 * to know if we should parse yptol cmd line options.
	 */
	init_yptol_flag();

	ypget_command_line_args(argc, argv);

	if (silent) {
		pid = (int)fork();

		if (pid == -1) {
		    logprintf("ypserv:  ypinit fork failure.\n");
		    ypexit();
		}

		if (pid != 0) {
		    exit(0);
		}
	}

	if (!init_lock_system(FALSE)) {
		ypexit();
	}

	get_secure_nets(argv[0]);

	if (silent) {
		closelog();
		closefrom(3);
	}

	if (yptol_mode) {
		stat = parseConfig(ldapCLA, NTOL_MAP_FILE);
		if (stat == 1) {
			logprintf("NIS to LDAP mapping inactive.\n");
		} else if (stat != 0) {
			logprintf("Aborting after NIS to LDAP mapping "
							"error.\n");
			fflush(stderr);
			exit(-1);
		}
	}

	if (silent) {
		freopen("/dev/null", "r", stdin);
		if (access(logfile, _IOWRT)) {
		    freopen("/dev/null", "w", stdout);
		    freopen("/dev/null", "w", stderr);
		} else {
		    freopen(logfile, "a", stdout);
		    freopen(logfile, "a", stderr);
		}

		t = open("/dev/tty", 2);

		setpgrp();
	}

#ifdef	SYSVCONFIG
	sigset(SIGHUP, (void (*)())sysvconfig);
#else
	sigset(SIGHUP, SIG_IGN);
#endif

	/*
	 * Setting disposition to SIG_IGN will not create zombies when child
	 * processes terminate.
	 */
	sigset(SIGCHLD, SIG_IGN);

	act.sa_handler = cleanup_resolv;
	sigemptyset(&act.sa_mask);
	act.sa_flags = SA_RESETHAND;
	sigaction(SIGTERM, &act, (struct sigaction *)NULL);
	sigaction(SIGQUIT, &act, (struct sigaction *)NULL);
	sigaction(SIGABRT, &act, (struct sigaction *)NULL);
	sigaction(SIGBUS, &act, (struct sigaction *)NULL);
	sigaction(SIGSEGV, &act, (struct sigaction *)NULL);

	/*
	 * Set non-blocking mode and maximum record size for
	 * connection oriented RPC transports.
	 */
	if (!rpc_control(RPC_SVC_CONNMAXREC_SET, &connmaxrec)) {
		logprintf("unable to set maximum RPC record size");
	}

	svc_unreg(YPPROG, YPVERS);
	svc_unreg(YPPROG, YPVERS_ORIG);

	for (i = 0; i < sizeof (service)/sizeof (ypservice_t); i++) {

		service_classes[i] = -1;

		if ((nconf = getnetconfigent(service[i].netid)) == NULL) {
			logprintf("getnetconfigent(\"%s\") failed\n",
					service[i].netid);
			continue;
		}

		if ((service[i].fd = t_open(nconf->nc_device, O_RDWR, NULL)) <
			0) {
			logprintf("t_open failed for %s\n", service[i].netid);
			freenetconfigent(nconf);
			continue;
		}

		if (netdir_options(nconf, ND_SET_RESERVEDPORT, service[i].fd,
			NULL) < 0) {
			logprintf("could not set reserved port for %s\n",
				service[i].netid);
			(void) close(service[i].fd);
			service[i].fd = -1;
			freenetconfigent(nconf);
			continue;
		}

		if ((service[i].xprt = svc_tli_create(service[i].fd, nconf,
			NULL, 0, 0)) == NULL) {
			logprintf("svc_tli_create failed for %s\n",
				service[i].netid);
			(void) close(service[i].fd);
			service[i].fd = -1;
			freenetconfigent(nconf);
			continue;
		}

		if (!svc_reg(service[i].xprt, YPPROG, YPVERS, ypdispatch,
			nconf)) {
			logprintf("%s %s\n", service[i].netid, register_failed);
			svc_destroy(service[i].xprt);
			service[i].xprt = 0;
			(void) close(service[i].fd);
			service[i].fd = -1;
			freenetconfigent(nconf);
			continue;
		}

		if (service[i].olddispatch && !svc_reg(service[i].xprt, YPPROG,
					YPVERS_ORIG, ypolddispatch, nconf)) {
			logprintf("old %s %s\n",
				service[i].netid, register_failed);
			/* Can only unregister prognum/versnum */
			svc_destroy(service[i].xprt);
			service[i].xprt = 0;
			(void) close(service[i].fd);
			service[i].fd = -1;
			freenetconfigent(nconf);
			continue;
		}

		services++;
		service[i].ok = 1;
		service_classes[i] = service[i].class;

		freenetconfigent(nconf);

	}

	/*
	 * Check if we managed to register enough services to continue.
	 * It's OK if we managed to register all IPv4 services but no
	 * IPv6, or the other way around, but not if we (say) registered
	 * IPv4 UDP but not TCP.
	 */
	if (services > 0) {
		for (j = 0; j < MAXSERVICES; j++) {
			if (service_classes[j] >= 0) {
				/*
				 * Must have all services of this class
				 * registered.
				 */
				for (i = 0; i < MAXSERVICES; i++) {
					if (service[i].ok == 0 &&
						service[i].class ==
						service_classes[j]) {
						logprintf(
			"unable to register all services for class %d\n",
							service[i].class);
						ypexit();
					}
				}
			}
		}
	} else {
		logprintf("unable to register any services\n");
		ypexit();
	}

	/* Now we setup circuit_n or yp_all() and yp_update() will not work */
	if (!svc_create(ypdispatch, YPPROG, YPVERS, "circuit_n")) {
		logprintf("circuit_n %s\n", register_failed);
		ypexit();
	}

	if (dnsforward) {
		setup_resolv(&dnsforward, &resolv_pid,
				&resolv_client, resolv_tp, 0);
		if (resolv_client == NULL)
			client_setup_failure = TRUE;
	}
}

void
cleanup_resolv(int sig)
{
	if (resolv_pid)
		kill(resolv_pid, sig);

	kill(getpid(), sig);
}

/*
 * This picks up any command line args passed from the process invocation.
 */
static void
ypget_command_line_args(int argc, char **argv)
{
	for (argv++; --argc; argv++) {

		if ((*argv)[0] == '-') {

			switch ((*argv)[1]) {
#ifdef	MINUS_C_OPTION
			case 'c':
				multiflag = TRUE;
				break;
#endif
			case 'd':
				if (access("/etc/resolv.conf", F_OK) == -1) {
					fprintf(stderr,
			"No /etc/resolv.conf file, -d option ignored\n");
				} else {
					dnsforward = TRUE;
				}
				break;
			case 'I':
				init_containers = TRUE;
				/* ... and also do -i stuff */
			case 'i':
				if (yptol_mode) {
					init_dit = TRUE;
				} else {
					fprintf(stderr, "-%c option is illegal "
					"if not in NIS to LDAP mode. Exiting\n",
						(*argv)[1]);
					fflush(stderr);
					exit(-1);
				}

				/* Handle -ir */
				if ('r' != (*argv)[2])
					break;

			case 'r':
				if (yptol_mode) {
					init_maps = TRUE;
				} else {
					fprintf(stderr, "-r option is illegal "
						"if not in NIS to LDAP mode. "
						"Exiting\n");
					fflush(stderr);
					exit(-1);
				}
				break;
			case 'v':
				silent = FALSE;
				break;
			}
		}
	}

	/* If setting up don't run silent or demonize */
	if (init_dit || init_maps)
		silent = FALSE;

}

/*
 * This dispatches to server action routines based on the input procedure
 * number.  ypdispatch is called from the RPC function svc_run.
 */
static void
ypdispatch(struct svc_req *rqstp, SVCXPRT *transp)
{
	sigset_t set, oset;


#ifdef	SYSVCONFIG
	/* prepare to answer questions about system v filesystem aliases */
	sysvconfig();
#endif

	sigemptyset(&set);
	sigaddset(&set, SIGCHLD);
	sigprocmask(SIG_BLOCK, &set, &oset);

	switch (rqstp->rq_proc) {

	case YPPROC_NULL:

		if (!svc_sendreply(transp, xdr_void, 0))
			logprintf("ypserv:  Can't reply to rpc call.\n");
		break;

	case YPPROC_DOMAIN:
		ypdomain(transp, TRUE);
		break;

	case YPPROC_DOMAIN_NONACK:
		ypdomain(transp, FALSE);
		break;

	case YPPROC_MATCH:
		ypmatch(transp, rqstp);
		break;

	case YPPROC_FIRST:
		ypfirst(transp);
		break;

	case YPPROC_NEXT:
		ypnext(transp);
		break;

	case YPPROC_XFR:
		ypxfr(transp, YPPROC_XFR);
		break;

	case YPPROC_NEWXFR:
		ypxfr(transp, YPPROC_NEWXFR);
		break;

	case YPPROC_CLEAR:
		ypclr_current_map();

		if (!svc_sendreply(transp, xdr_void, 0))
			logprintf("ypserv:  Can't reply to rpc call.\n");
		break;

	case YPPROC_ALL:
		ypall(transp);
		break;

	case YPPROC_MASTER:
		ypmaster(transp);
		break;

	case YPPROC_ORDER:
		yporder(transp);
		break;

	case YPPROC_MAPLIST:
		ypmaplist(transp);
		break;

	default:
		svcerr_noproc(transp);
		break;

	}

	sigprocmask(SIG_SETMASK, &oset, (sigset_t *)NULL);

}

static void
ypolddispatch(struct svc_req *rqstp, SVCXPRT *transp)
{
	sigset_t set, oset;

	sigemptyset(&set);
	sigaddset(&set, SIGCHLD);
	sigprocmask(SIG_BLOCK, &set, &oset);

	switch (rqstp->rq_proc) {

	case YPOLDPROC_NULL:
		if (!svc_sendreply(transp, xdr_void, 0))
			logprintf("ypserv:  Can't replay to rpc call.\n");
		break;

	case YPOLDPROC_DOMAIN:
		ypdomain(transp, TRUE);
		break;

	case YPOLDPROC_DOMAIN_NONACK:
		ypdomain(transp, FALSE);
		break;

	case YPOLDPROC_MATCH:
		ypoldmatch(transp, rqstp);
		break;

	case YPOLDPROC_FIRST:
		ypoldfirst(transp);
		break;

	case YPOLDPROC_NEXT:
		ypoldnext(transp);
		break;

	case YPOLDPROC_POLL:
		ypoldpoll(transp);
		break;

	case YPOLDPROC_PUSH:
		ypoldpush(transp);
		break;

	case YPOLDPROC_PULL:
		ypoldpull(transp);
		break;

	case YPOLDPROC_GET:
		ypoldget(transp);

	default:
		svcerr_noproc(transp);
		break;
	}

	sigprocmask(SIG_SETMASK, &oset, (sigset_t *)NULL);
}

/*
 * This flushes output to stderr, then aborts the server process to leave a
 * core dump.
 */
static void
ypexit(void)
{
	fflush(stderr);
	abort();
}

/*
 * This constructs a logging record.
 */
void
logprintf(char *format, ...)
{
	va_list ap;
	struct timeval t;

	va_start(ap, format);

	if (silent) {
		gettimeofday(&t);
		fseek(stderr, 0, 2);
		fprintf(stderr, "%19.19s: ", ctime(&t.tv_sec));
	}

	vfprintf(stderr, format, ap);
	va_end(ap);
	fflush(stderr);
}