OpenSolaris_b135/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);
}
}
}