path: root/usr/src/cmd/ypcmd/ypset.c

/*
 * 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 2005 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
 * under license from the Regents of the University of
 * California.
 */

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

/*
 * This is a user command which issues a "Set domain binding" command to a
 * YP binder (ypbind) process
 *
 *	ypset [-h <host>] [-d <domainname>] server_to_use
 *
 * where host and server_to_use may be either names or internet addresses.
 */
#include <stdio.h>
#include <ctype.h>
#include <rpc/rpc.h>
#include <rpcsvc/ypclnt.h>
#include <rpcsvc/yp_prot.h>
#include "yp_b.h"
#include <sys/utsname.h>
extern CLIENT *__clnt_create_loopback();

#ifdef NULL
#undef NULL
#endif
#define	NULL 0

#define	TIMEOUT 30			/* Total seconds for timeout */

static char *pusage;
static char *domain = NULL;
static char default_domain_name[YPMAXDOMAIN];
static char default_host_name[256];
static char *host = NULL;
static char *server_to_use;
static struct timeval timeout = {
	TIMEOUT,			/* Seconds */
	0				/* Microseconds */
	};

static char err_usage_set[] =
"Usage:\n\
	ypset [ -h host ] [ -d domainname ] server_to_use\n\n";
static char err_bad_args[] =
	"Sorry, the %s argument is bad.\n";
static char err_cant_get_kname[] =
	"Sorry, can't get %s back from system call.\n";
static char err_null_kname[] =
	"Sorry, the %s hasn't been set on this machine.\n";
static char err_bad_hostname[] = "hostname";
static char err_bad_domainname[] = "domainname";
static char err_bad_server[] = "server_to_use";
static char err_tp_failure[] =
	"Sorry, I can't set up a connection to host %s.\n";
static char err_rpc_failure[] =
	"Sorry, I couldn't send my rpc message to ypbind on host %s.\n";
static char err_access_failure[] =
	"ypset: Sorry, ypbind on host %s has rejected your request.\n";

static void get_command_line_args();
static void send_message();

extern void exit();
extern int getdomainname();
extern int gethostname();
extern struct netconfig *getnetconfigent();
extern unsigned int strlen();

/*
 * This is the mainline for the ypset process.  It pulls whatever arguments
 * have been passed from the command line, and uses defaults for the rest.
 */

int
main(argc, argv)
	int argc;
	char **argv;

{
	get_command_line_args(argc, argv);

	if (!domain) {

		if (!getdomainname(default_domain_name, YPMAXDOMAIN)) {
			domain = default_domain_name;
		} else {
			(void) fprintf(stderr,
				err_cant_get_kname,
				err_bad_domainname);
			exit(1);
		}

		if ((int)strlen(domain) == 0) {
			(void) fprintf(stderr,
				err_null_kname,
				err_bad_domainname);
			exit(1);
		}
	}
	send_message();
	return (0);
}

/*
 * This does the command line argument processing.
 */
static void
get_command_line_args(argc, argv)
	int argc;
	char **argv;
{
	pusage = err_usage_set;
	argv++;

	while (--argc > 1) {

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

			switch ((*argv)[1]) {

			case 'h': {

				if (argc > 1) {
					struct utsname utsname;

					argv++;
					argc--;
					(void) uname(&utsname);
					if (strcasecmp(utsname.nodename,
						*argv) != 0) {
						host = *argv;

						if ((int)strlen(host) > 256) {
							(void) fprintf(stderr,
	err_bad_args,
	err_bad_hostname);
							exit(1);
						}
					}
					argv++;

				} else {
					(void) fprintf(stderr, pusage);
					exit(1);
				}

				break;
			}

			case 'd': {

				if (argc > 1) {
					argv++;
					argc--;
					domain = *argv;
					argv++;

					if (strlen(domain) > YPMAXDOMAIN) {
						(void) fprintf(stderr,
	err_bad_args,
	err_bad_domainname);
						exit(1);
					}

				} else {
					(void) fprintf(stderr, pusage);
					exit(1);
				}

				break;
			}

			default: {
				(void) fprintf(stderr, pusage);
				exit(1);
			}

			}

		} else {
			(void) fprintf(stderr, pusage);
			exit(1);
		}
	}

	if (argc == 1) {

		if ((*argv)[0] == '-') {
			(void) fprintf(stderr, pusage);
			exit(1);
		}

		server_to_use = *argv;

		if ((int)strlen(server_to_use) > 256) {
			(void) fprintf(stderr, err_bad_args,
			    err_bad_server);
			exit(1);
		}

	} else {
		(void) fprintf(stderr, pusage);
		exit(1);
	}
}

/*
 * This takes the name of the YP host of interest, and fires off
 * the "set domain binding" message to the ypbind process.
 */

static void
send_message()
{
	CLIENT *server, *client;
	struct ypbind_setdom req;
	struct ypbind_binding ypbind_info;
	enum clnt_stat clnt_stat;
	struct netconfig *nconf;
	struct netbuf nbuf;
	int err;

	/*
	 * Open up a path to the server
	 */

	if ((server = clnt_create(server_to_use, YPPROG, YPVERS,
	    "datagram_n")) == NULL) {
		(void) fprintf(stderr, err_tp_failure, server_to_use);
		exit(1);
	}

	/* get nconf, netbuf structures */
	nconf = getnetconfigent(server->cl_netid);
	clnt_control(server, CLGET_SVC_ADDR, (char *)&nbuf);

	/*
	 * Open a path to host
	 */

	if (!host) {
		client = __clnt_create_loopback(YPBINDPROG, YPBINDVERS, &err);
		if (client == (CLIENT *)NULL) {
			clnt_pcreateerror("ypset: clnt_create");
			exit(1);
		}
		client->cl_auth = authsys_create("", geteuid(), 0, 0, NULL);
		if (client->cl_auth == NULL) {
			clnt_pcreateerror("ypset: clnt_create");
			exit(1);
		}
	} else {
		client = clnt_create(host, YPBINDPROG,
			YPBINDVERS, "datagram_n");
		if (client == (CLIENT *)NULL) {
			clnt_pcreateerror("ypset: clnt_create");
			exit(1);
		}
	}

	/*
	 * Load up the message structure and fire it off.
	 */
	ypbind_info.ypbind_nconf = nconf;
	ypbind_info.ypbind_svcaddr = (struct netbuf *)(&nbuf);
	ypbind_info.ypbind_servername = server_to_use;
	ypbind_info.ypbind_hi_vers = YPVERS;
	ypbind_info.ypbind_lo_vers = YPVERS;
	req.ypsetdom_bindinfo = &ypbind_info;
	req.ypsetdom_domain =  domain;

	clnt_stat = (enum clnt_stat) clnt_call(client,
	    YPBINDPROC_SETDOM, xdr_ypbind_setdom, (char *)&req, xdr_void, 0,
	    timeout);
	if (clnt_stat != RPC_SUCCESS) {
		if (clnt_stat == RPC_PROGUNAVAIL)
			(void) fprintf(stderr,
	err_access_failure, host ? host : "localhost");
		else
			(void) fprintf(stderr,
	err_rpc_failure, host ? host : "localhost");
		exit(1);
	}
	if (!host)
		auth_destroy((client)->cl_auth);
	(void) clnt_destroy(server);
	(void) clnt_destroy(client);
}