xref: /titanic_50/usr/src/cmd/ypcmd/yppoll.c (revision a506a34ceb0e9dcc6c61bf0560202f8538928650)

/*
 * 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 asks a particular ypserv which version of a
 * map it is using.  Usage is:
 *
 * yppoll [-h <host>] [-d <domainname>] mapname
 *
 * If the host is ommitted, the local host will be used.  If host is specified
 * as an internet address, no yp services need to be locally available.
 *
 */
#include <stdio.h>
#include <ctype.h>
#include <rpc/rpc.h>
#include <rpcsvc/ypclnt.h>
#include <rpcsvc/yp_prot.h>
#include <netdir.h>
#include <arpa/inet.h>
#include "yp_b.h"

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

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

static int status = 0;				/* exit status */
static char *domain = NULL;
static char default_domain_name[YPMAXDOMAIN];
static char *map = NULL;
static char *host = NULL;
static char default_host_name[256];

static char err_usage[] =
"Usage:\n\
	yppoll [ -h host ] [ -d domainname ] mapname\n\n";
static char err_bad_args[] =
	"Bad %s argument.\n";
static char err_cant_get_kname[] =
	"Can't get %s back from system call.\n";
static char err_null_kname[] =
	"%s hasn't been set on this machine.\n";
static char err_bad_hostname[] = "hostname";
static char err_bad_mapname[] = "mapname";
static char err_bad_domainname[] = "domainname";
static char err_bad_resp[] =
	"Ill-formed response returned from ypserv on host %s.\n";

static void get_command_line_args();
static void getdomain();
static void getlochost();
static void getmapparms();
static void newresults();
static void getypserv();

extern void exit();
extern int getdomainname();
extern int gethostname();
extern unsigned int strlen();
extern int strcmp();

/*
 * This is the mainline for the yppoll process.
 */

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

{
	get_command_line_args(argc, argv);

	if (!domain) {
		getdomain();
	}

	if (!host) {
		getypserv();
	}

	getmapparms();
	return (status);
}

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

{
	argv++;

	while (--argc) {

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

			switch ((*argv)[1]) {

			case 'h':

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

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

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

				break;

			case 'd':

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

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

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

				break;

			default:
				(void) fprintf(stderr, err_usage);
				exit(1);

			}

		} else {
			if (!map) {
				map = *argv;

				if ((int)strlen(map) > YPMAXMAP) {
					(void) fprintf(stderr, err_bad_args,
					    err_bad_mapname);
					exit(1);
				}

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

	if (!map) {
		(void) fprintf(stderr, err_usage);
		exit(1);
	}
}

/*
 * This gets the local default domainname, and makes sure that it's set
 * to something reasonable.  domain is set here.
 */
static void
getdomain()
{
	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);
	}
}

/*
 * This gets the local hostname back from the kernel
 */
static void
getlochost()
{

	if (! gethostname(default_host_name, 256)) {
		host = default_host_name;
	} else {
		(void) fprintf(stderr, err_cant_get_kname, err_bad_hostname);
		exit(1);
	}
}

static void
getmapparms()
{
	CLIENT * map_clnt;
	struct ypresp_order oresp;
	struct ypreq_nokey req;
	struct ypresp_master mresp;
	struct ypresp_master *mresults = (struct ypresp_master *)NULL;
	struct ypresp_order *oresults = (struct ypresp_order *)NULL;

	struct timeval timeout;
	enum clnt_stat s;

	if ((map_clnt = clnt_create(host, YPPROG, YPVERS,
	    "netpath"))  == NULL) {
		(void) fprintf(stderr,
		    "Can't create connection to %s.\n", host);
		clnt_pcreateerror("Reason");
		exit(1);
	}

	timeout.tv_sec = TIMEOUT;
	timeout.tv_usec = 0;
	req.domain = domain;
	req.map = map;
	mresp.master = NULL;

	if (clnt_call(map_clnt, YPPROC_MASTER,  (xdrproc_t)xdr_ypreq_nokey,
		    (caddr_t)&req, (xdrproc_t)xdr_ypresp_master,
		    (caddr_t)&mresp, timeout) == RPC_SUCCESS) {
		mresults = &mresp;
		s = (enum clnt_stat) clnt_call(map_clnt, YPPROC_ORDER,
		    (xdrproc_t)xdr_ypreq_nokey, (char *)&req,
			(xdrproc_t)xdr_ypresp_order, (char *)&oresp, timeout);

		if (s == RPC_SUCCESS) {
			oresults = &oresp;
			newresults(mresults, oresults);
		} else {
			(void) fprintf(stderr,
		"Can't make YPPROC_ORDER call to ypserv at %s.\n	",
				host);
			clnt_perror(map_clnt, "Reason");
			exit(1);
		}

	} else {
		clnt_destroy(map_clnt);
	}
}

static void
newresults(m, o)
	struct ypresp_master *m;
	struct ypresp_order *o;
{
	char *s_domok = "Domain %s is supported.\n";
	char *s_ook = "Map %s has order number %d.\n";
	char *s_mok = "The master server is %s.\n";
	char *s_mbad = "Can't get master for map %s.\n	Reason:  %s\n";
	char *s_obad = "Can't get order number for map %s.\n	Reason:  %s\n";

	if (m->status == YP_TRUE && o->status == YP_TRUE) {
		(void) printf(s_domok, domain);
		(void) printf(s_ook, map, o->ordernum);
		(void) printf(s_mok, m->master);
	} else if (o->status == YP_TRUE)  {
		(void) printf(s_domok, domain);
		(void) printf(s_ook, map, o->ordernum);
		(void) fprintf(stderr, s_mbad, map,
		    yperr_string(ypprot_err(m->status)));
		status = 1;
	} else if (m->status == YP_TRUE)  {
		(void) printf(s_domok, domain);
		(void) fprintf(stderr, s_obad, map,
		    yperr_string(ypprot_err(o->status)));
		(void) printf(s_mok, m->master);
		status = 1;
	} else {
		(void) fprintf(stderr,
			"Can't get any map parameter information.\n");
		(void) fprintf(stderr, s_obad, map,
		    yperr_string(ypprot_err(o->status)));
		(void) fprintf(stderr, s_mbad, map,
		    yperr_string(ypprot_err(m->status)));
		status = 1;
	}
}

static void
getypserv()
{
	struct ypbind_resp response;
	struct ypbind_domain ypdomain;
	struct ypbind_binding *binding;
	static char hostbuf[256];

	getlochost();

	(void) memset((char *)&response, 0, sizeof (response));
	ypdomain.ypbind_domainname = domain;
	ypdomain.ypbind_vers = YPBINDVERS;
	(void) rpc_call(host, YPBINDPROG, YPBINDVERS, YPBINDPROC_DOMAIN,
	    xdr_ypbind_domain, (char *)&ypdomain, xdr_ypbind_resp,
	    (char *)&response, "netpath");
	if (response.ypbind_status != YPBIND_SUCC_VAL) {
		(void) fprintf(stderr, "couldn't get yp server - status %u\n",
		    response.ypbind_status);
		exit(1);
	}
	binding = response.ypbind_resp_u.ypbind_bindinfo;
	host = binding->ypbind_servername;

	/*
	 *  When ypbind is running in broadcast mode, it sets the
	 *  servername to "".  To get the real name of the server,
	 *  we need to do a host lookup on the svcaddr.  This code
	 *  is similar to code in ypwhich.
	 */
	if (strcmp(host, "") == 0) {
		struct nd_hostservlist *nhs;
		struct netconfig *nconf = binding->ypbind_nconf;
		struct netbuf *svcaddr = binding->ypbind_svcaddr;

		if (netdir_getbyaddr(nconf, &nhs, svcaddr) != ND_OK) {
			struct sockaddr_in *sa;

			sa = (struct sockaddr_in *)svcaddr->buf;

			strcpy(hostbuf, inet_ntoa(sa->sin_addr));
		} else {
			sprintf(hostbuf, "%s", nhs->h_hostservs->h_host);
		}
		host = hostbuf;
		netdir_free((char *)nhs, ND_HOSTSERVLIST);
	}
}