path: root/usr/src/cmd/ypcmd/ypwhich.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 tells which yp server is being used by a
 * given machine, or which yp server is the master for a named map.
 *
 * Usage is:
 *	ypwhich [-d domain] [-m [mname] [-t] | [-Vn] host]
 *	ypwhich -x
 * where:  the -d switch can be used to specify a domain other than the
 * default domain.  -m tells the master of that map.  mname is a mapname
 * If the -m option is used, ypwhich will act like a vanilla yp client,
 * and will not attempt to choose a particular yp server.  On the
 * other hand, if no -m switch is used, ypwhich will talk directly to the yp
 * bind process on the named host, or to the local ypbind process if no host
 * name is specified. -t switch inhibits nickname translation of map names.
 * -x is to dump the nickname translation table from file /var/yp/nicknames.
 *
 */

#include <stdio.h>
#include <ctype.h>
#include <rpc/rpc.h>
#include <rpcsvc/yp_prot.h>
#include <rpcsvc/ypclnt.h>
#include "yp_b.h"
#include "ypv2_bind.h"
#include <string.h>
#include <netdir.h>
#include <unistd.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <inet/ip.h>
#include <inet/ip6.h>
#include <netinet/ip6.h>
#include <sys/utsname.h>

#define	YPSLEEPTIME 5 /* between two tries of bind */

#define	TIMEOUT 30			/* Total seconds for timeout */
#define	INTER_TRY 10			/* Seconds between tries */

static int translate = TRUE;
static int dodump = FALSE;
static char *domain = NULL;
static char default_domain_name[YPMAXDOMAIN];
static char *host = NULL;
static int vers = YPBINDVERS;
static char default_host_name[256];
static bool get_master = FALSE;
static bool get_server = FALSE;
static char *map = NULL;
static char nm[YPMAXMAP+1];
static struct timeval timeout = {
		TIMEOUT,			/* Seconds */
		0				/* Microseconds */
};
static char nullstring[] = "\000";
static char err_usage[] =
"Usage:\n\
	ypwhich [-d domain] [[-t] -m [mname] | [-Vn] host]\n\
	ypwhich -x\n\
where\n\
	mname may be either a mapname or a nickname for a map.\n\
	host if specified, is the machine whose NIS server is to be found.\n\
	-t inhibits map nickname translation.\n\
	-Vn version of ypbind, V3 is default.\n\
	-x dumps the map nickname translation table.\n";
static char err_bad_args[] =
"ypwhich:  %s argument is bad.\n";
static char err_cant_get_kname[] =
"ypwhich:  can't get %s back from system call.\n";
static char err_null_kname[] =
"ypwhich:  the %s hasn't been set on this machine.\n";
static char err_bad_mapname[] = "mapname";
static char err_bad_domainname[] = "domainname";
static char err_bad_hostname[] = "hostname";

static void get_command_line_args();
static void getdomain();
static void getlochost();
static void get_server_name();
static int call_binder();
static void get_map_master();
extern void maketable();
extern int getmapname();
#ifdef DEBUG
static void dump_response();
#endif
static void dump_ypmaps();
static void dumpmaps();

static bool xdr_yp_inaddr();
static bool xdr_old_ypbind_resp();
static bool xdr_old_yp_binding();
static int old_call_binder();
static void print_server();

/* need these for call to (remote) V2 ypbind */
struct old_ypbind_binding {
	struct in_addr ypbind_binding_addr;	/* In network order */
	unsigned short int ypbind_binding_port;	/* In network order */
};

struct old_ypbind_resp {
	enum ypbind_resptype ypbind_status;
	union {
		unsigned long ypbind_error;
		struct old_ypbind_binding ypbind_bindinfo;
	} ypbind_respbody;
};

/*
 * This is the main line for the ypwhich process.
 */
int
main(argc, argv)
char **argv;
{
	get_command_line_args(argc, argv);

	if (dodump) {
		maketable(dodump);
		exit(0);
	}

	if (!domain) {
		getdomain();
	}

	if (map && translate && (strchr(map, '.') == NULL) &&
		(getmapname(map, nm))) {
		map = nm;
	}

	if (get_server) {
		if (!host)
			getlochost();
		get_server_name();
	} else {
		if (map)
			get_map_master();
		else
			dump_ypmaps();
	}

	return (0);
}

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

{
	argv++;

	if (argc == 1) {
		get_server = TRUE;
		return;
	}

	while (--argc) {

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

			switch ((*argv)[1]) {

			case 'V':

				vers = atoi(argv[0]+2);
				if (vers <  1) {
					(void) fprintf(stderr, err_usage);
					exit(1);
				}
				argv++;
				break;

			case 'm':
				get_master = TRUE;
				argv++;

				if (argc > 1) {

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

					argc--;
					map = *argv;
					argv++;

					if ((int)strlen(map) > YPMAXMAP) {
				(void) fprintf(stderr, err_bad_args,
						    err_bad_mapname);
						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;

			case 't':
				translate = FALSE;
				argv++;
				break;

			case 'x':
				dodump = TRUE;
				argv++;
				break;

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

		} else {

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

			get_server = TRUE;
			host = *argv;
			argv++;

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

	if (get_master && get_server) {
		(void) fprintf(stderr, err_usage);
		exit(1);
	}

	if (!get_master && !get_server) {
		get_server = TRUE;
	}
}

/*
 * 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()
{
	struct utsname utsname;

	if (uname(&utsname) != -1) {
		strcpy(default_host_name, utsname.nodename);
		host = default_host_name;
	} else {
		(void) fprintf(stderr, err_cant_get_kname, err_bad_hostname);
		exit(1);
	}

}

/*
 * This tries to find the name of the server to which the binder in question
 * is bound.  If one of the -Vx flags was specified, it will try only for
 * that protocol version, otherwise, it will start with the current version,
 * then drop back to the previous version.
 */
static void
get_server_name()
{
	char *notbound = "Domain %s not bound on %s.\n";

	if (vers >= 3) {
		if (!call_binder(vers))
			(void) fprintf(stderr, notbound, domain, host);
	} else {
		if (!old_call_binder(vers))
			(void) fprintf(stderr, notbound, domain, host);
	}
}

extern CLIENT *__clnt_create_loopback();

/*
 * This sends a message to the ypbind process on the node with
 * the host name
 */
static int
call_binder(vers)
int vers;
{
	CLIENT *client;
	struct ypbind_resp *response;
	struct ypbind_domain ypbd;
	char errstring[256];
	extern struct rpc_createerr rpc_createerr;
	int yperr = 0;
	struct utsname utsname;
	const char *str;

	/*
	 * CAUTION: Do not go to NIS if the host is the same as the local host
	 * XXX: Lots of special magic to distinguish between local and remote
	 * case. We want to make sure the local case doesn't hang.
	 */

	if ((uname(&utsname) != -1) &&
		(strcmp(host, utsname.nodename) == 0))
		client = __clnt_create_loopback(YPBINDPROG, vers, &yperr);
	else
		client = clnt_create(host, YPBINDPROG, vers, "netpath");
	if (client == NULL) {
		if (yperr)
			(void) fprintf(stderr,
				"ypwhich: %s\n", yperr_string(yperr));
		else {
			if (rpc_createerr.cf_stat == RPC_PROGNOTREGISTERED ||
				rpc_createerr.cf_stat == RPC_PROGUNAVAIL) {
				(void) fprintf(stderr,
			"ypwhich: %s is not running ypbind\n", host);
			} else if (rpc_createerr.cf_stat == RPC_PMAPFAILURE) {
				(void) fprintf(stderr,
			"ypwhich: %s is not running rpcbind\n",
					host);
			} else
				(void) clnt_pcreateerror("ypwhich: \
clnt_create error");
		}
		exit(1);
	}
	ypbd.ypbind_domainname = domain;
	ypbd.ypbind_vers = vers;
	response = ypbindproc_domain_3(&ypbd, client);

	if (response == NULL) {
		(void) sprintf(errstring,
		    "ypwhich: can't call ypbind on %s", host);
		(void) clnt_perror(client, errstring);
		exit(1);
	}

	clnt_destroy(client);

	if (response->ypbind_status != YPBIND_SUCC_VAL)  {
		return (FALSE);
	}

	if (response->ypbind_resp_u.ypbind_bindinfo) {
		char *server =
	response->ypbind_resp_u.ypbind_bindinfo->ypbind_servername;

		if (strcmp(server, nullstring) == 0) {
		/* depends on a hack in ypbind */
			struct nd_hostservlist *nhs = NULL;
			struct netconfig *nconf =
		response->ypbind_resp_u.ypbind_bindinfo->ypbind_nconf;
			struct netbuf *svcaddr =
		response->ypbind_resp_u.ypbind_bindinfo->ypbind_svcaddr;

			if (netdir_getbyaddr(nconf, &nhs, svcaddr) != ND_OK) {
				struct sockaddr_in	*sa4;
				struct sockaddr_in6	*sa6;
				char			buf[INET6_ADDRSTRLEN];
				char			xbuf[IPV6_ADDR_LEN];
				int			af;
				void			*addr;
				XDR			xdrs;

				sa4 = (struct sockaddr_in *)svcaddr->buf;
				af = ntohs(sa4->sin_family);
				if (af != sa4->sin_family) {
					xdrmem_create(&xdrs,
						(caddr_t)xbuf, IPV6_ADDR_LEN,
						XDR_DECODE);
					if (af == AF_INET6) {
						xdr_opaque(&xdrs,
							(caddr_t)svcaddr->buf,
							IPV6_ADDR_LEN);
						sa6 = (struct sockaddr_in6 *)
							xbuf;
						addr = &sa6->sin6_addr;
					} else {
						xdr_opaque(&xdrs,
							(caddr_t)svcaddr->buf,
							IPV4_ADDR_LEN);
						sa4 = (struct sockaddr_in *)
							xbuf;
						addr = &sa4->sin_addr;
					}
				} else {
					if (af == AF_INET6) {
						sa6 = (struct sockaddr_in6 *)
							svcaddr->buf;
						addr = &sa6->sin6_addr;
					} else {
						addr = &sa4->sin_addr;
					}
				}
				str = inet_ntop(af, addr, buf, sizeof (buf));
				if (str == NULL)
					perror("inet_ntop");
				else
					fprintf(stdout, "%s\n", str);
			} else {
				str = nhs->h_hostservs->h_host;
				if (str == NULL)
					str = "<unknown>";
				fprintf(stdout, "%s\n", str);
			}
			netdir_free((char *)nhs, ND_HOSTSERVLIST);
		} else {
			fprintf(stdout, "%s\n", server);
		}
	}
#ifdef DEBUG
	dump_response(response);
#endif
	return (TRUE);
}

/*
 * Serializes/deserializes an in_addr struct.
 *
 * Note:  There is a data coupling between the "definition" of a struct
 * in_addr implicit in this xdr routine, and the true data definition in
 * <netinet/in.h>.
 */
static bool xdr_yp_inaddr(xdrs, ps)
	XDR * xdrs;
	struct in_addr *ps;

{
	return (xdr_opaque(xdrs, (caddr_t)&ps->s_addr, 4));
}

/*
 * Serializes/deserializes an old ypbind_binding struct.
 */
static bool xdr_old_yp_binding(xdrs, ps)
	XDR * xdrs;
	struct old_ypbind_binding *ps;

{
	return (xdr_yp_inaddr(xdrs, &ps->ypbind_binding_addr) &&
	    xdr_opaque(xdrs, (caddr_t)&ps->ypbind_binding_port, 2));
}

/*
 * Serializes/deserializes a ypbind_resp structure.
 */
static bool xdr_old_ypbind_resp(xdrs, ps)
	XDR * xdrs;
	struct old_ypbind_resp *ps;

{
	if (!xdr_enum(xdrs, (enum_t *)&ps->ypbind_status)) {
		return (FALSE);
	}
	switch (ps->ypbind_status) {
	case YPBIND_SUCC_VAL:
		return (xdr_old_yp_binding(xdrs,
				&ps->ypbind_respbody.ypbind_bindinfo));
	case YPBIND_FAIL_VAL:
		return (xdr_u_long(xdrs,
				&ps->ypbind_respbody.ypbind_error));
	}
	return (FALSE);
}
/* This sends a message to the old ypbind process on host. */
static int old_call_binder(vers)
	int vers;
{
	CLIENT *client;
	struct hostent *hp;
	int sock = RPC_ANYSOCK;
	enum clnt_stat rpc_stat;
	struct old_ypbind_resp response;
	char errstring[256];
	extern struct rpc_createerr rpc_createerr;
	struct in_addr *server;

	if ((client = clnt_create(host, YPBINDPROG, vers, "udp")) == NULL) {
		if (rpc_createerr.cf_stat == RPC_PROGNOTREGISTERED) {
			(void) printf("ypwhich: %s is not running ypbind\n",
				host);
			exit(1);
		}
		if (rpc_createerr.cf_stat == RPC_PMAPFAILURE) {
		    (void) printf("ypwhich: %s is not running port mapper\n",
				host);
			exit(1);
		}
		(void) clnt_pcreateerror("ypwhich:  clnt_create error");
		exit(1);
	}

	rpc_stat = clnt_call(client, YPBINDPROC_DOMAIN,
			(xdrproc_t)xdr_ypdomain_wrap_string, (caddr_t)&domain,
			(xdrproc_t)xdr_old_ypbind_resp, (caddr_t)&response,
			timeout);

	if ((rpc_stat != RPC_SUCCESS) &&
	    (rpc_stat != RPC_PROGVERSMISMATCH)) {
		(void) sprintf(errstring,
		    "ypwhich: can't call ypbind on %s", host);
		(void) clnt_perror(client, errstring);
		exit(1);
	}

	clnt_destroy(client);
	close(sock);

	if ((rpc_stat != RPC_SUCCESS) ||
	    (response.ypbind_status != YPBIND_SUCC_VAL)) {
		return (FALSE);
	}

	server = &response.ypbind_respbody.ypbind_bindinfo.ypbind_binding_addr;
	print_server  (server);

	return (TRUE);
}

/*
 * For old version:
 * This translates a server address to a name and prints it.
 * We'll get a name by using the standard library routine.
 */
static void print_server(server)
	struct in_addr *server;
{
	char buf[256];
	struct hostent *hp;

	strcpy(buf, inet_ntoa(*server));
	hp = gethostbyaddr((char *)&server->s_addr,
			sizeof (struct in_addr), AF_INET);

	printf("%s\n", hp ? hp->h_name : buf);
}

#ifdef DEBUG
static void
dump_response(which)
ypbind_resp * which;
{
	struct netconfig *nc;
	struct netbuf *ua;
	ypbind_binding * b;

	int i;

	{
		b = which->ypbind_resp_u.ypbind_bindinfo;
		if (b == NULL)
			(void) fprintf(stderr, "???NO Binding information\n");
		else {
			(void) fprintf(stderr,
		"server=%s lovers=%ld hivers=%ld\n",
			    b->ypbind_servername,
				b->ypbind_lo_vers, b->ypbind_hi_vers);
			nc = b->ypbind_nconf;
			ua = b->ypbind_svcaddr;
			if (nc == NULL)
				(void) fprintf(stderr,
			"ypwhich: NO netconfig information\n");
			else {
				(void) fprintf(stderr,
		"ypwhich: id %s device %s flag %x protofmly %s proto %s\n",
		nc->nc_netid, nc->nc_device,
		(int)nc->nc_flag, nc->nc_protofmly,
		nc->nc_proto);
			}
			if (ua == NULL)
				(void) fprintf(stderr,
		"ypwhich: NO netbuf information available from binder\n");
			else {
				(void) fprintf(stderr,
			"maxlen=%d len=%d\naddr=", ua->maxlen, ua->len);
				for (i = 0; i < ua->len; i++) {
					if (i != (ua->len - 1))
						(void) fprintf(stderr,
					"%d.", ua->buf[i]);
					else
						(void) fprintf(stderr,
					"%d\n", ua->buf[i]);
				}
			}
		}
	}

}
#endif

/*
 * This translates a server address to a name and prints it.  If the address
 * is the same as the local address as returned by get_myaddress, the name
 * is that retrieved from the kernel.  If it's any other address (including
 * another ip address for the local machine), we'll get a name by using the
 * standard library routine (which calls the yp).
 */

/*
 * This asks any yp server for the map's master.
 */
static void
get_map_master()
{
	int err;
	char *master;

	err = __yp_master_rsvdport(domain, map, &master);

	if (err) {
		(void) fprintf(stderr,
		    "ypwhich:  Can't find the master of %s.  Reason: %s.\n",
		    map, yperr_string(err));
		exit(1);
	} else {
		(void) printf("%s\n", master);
	}
}

/*
 * This enumerates the entries within map "ypmaps" in the domain at global
 * "domain", and prints them out key and value per single line.  dump_ypmaps
 * just decides whether we are (probably) able to speak the new YP protocol,
 * and dispatches to the appropriate function.
 */
static void
dump_ypmaps()
{
	int err;
	struct dom_binding *binding;

	if (err = __yp_dobind(domain, &binding)) {
		(void) fprintf(stderr,
		    "dump_ypmaps: Can't bind for domain %s.  Reason: %s\n",
		    domain, yperr_string(err));
		return;
	}

	if (binding->dom_binding->ypbind_hi_vers  >= YPVERS) {
		dumpmaps(binding);
	}
}

static void
dumpmaps(binding)
struct dom_binding *binding;
{
	enum clnt_stat rpc_stat;
	int err;
	char *master;
	struct ypmaplist *pmpl;
	struct ypresp_maplist maplist;

	maplist.list = (struct ypmaplist *)NULL;

	rpc_stat = clnt_call(binding->dom_client, YPPROC_MAPLIST,
	    (xdrproc_t)xdr_ypdomain_wrap_string, (caddr_t)&domain,
	    (xdrproc_t)xdr_ypresp_maplist, (caddr_t)&maplist,
	    timeout);

	if (rpc_stat != RPC_SUCCESS) {
		(void) clnt_perror(binding->dom_client,
		    "ypwhich(dumpmaps): can't get maplist");
		__yp_rel_binding(binding);
		exit(1);
	}

	if (maplist.status != YP_TRUE) {
		(void) fprintf(stderr,
		    "ypwhich:  Can't get maplist.  Reason:  %s.\n",
		    yperr_string(ypprot_err(maplist.status)));
		exit(1);
	}
	__yp_rel_binding(binding);

	for (pmpl = maplist.list; pmpl; pmpl = pmpl->ypml_next) {
		(void) printf("%s ", pmpl->ypml_name);

		err = __yp_master_rsvdport(domain, pmpl->ypml_name, &master);

		if (err) {
			(void) printf("????????\n");
			(void) fprintf(stderr,
		"ypwhich:  Can't find the master of %s.  Reason: %s.\n",
		pmpl->ypml_name, yperr_string(err));
		} else {
			(void) printf("%s\n", master);
		}
	}
}