#ifndef LINT
static char rcsid[] = "$Id: ypbind.c,v 1.1 1999/05/02 03:59:00 wsanchez Exp $";
#endif
#include <sys/cdefs.h>
#include <sys/param.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <sys/signal.h>
#include <sys/socket.h>
#include <sys/file.h>
#include <sys/fcntl.h>
#include <sys/uio.h>
#include <syslog.h>
#include <sys/stat.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <errno.h>
#include <ctype.h>
#include <dirent.h>
#include <netdb.h>
#include <string.h>
#include <err.h>
#include <rpc/rpc.h>
#include <rpc/xdr.h>
#include <net/if.h>
#include <arpa/inet.h>
#include <rpc/pmap_clnt.h>
#include <rpc/pmap_prot.h>
#include <rpc/pmap_rmt.h>
#include <unistd.h>
#include <rpcsvc/yp.h>
#define _PATH_YPBIND_LOCK "/var/run/ypbind.lock"
#define YPSERVERSSUFF ".ypservers"
#define BINDINGDIR "/var/yp/binding"
#ifndef O_SHLOCK
#define O_SHLOCK 0
#endif
#define BUFSIZE 1400
struct _dom_binding
{
struct _dom_binding *dom_pnext;
char dom_domain[YPMAXDOMAIN + 1];
struct sockaddr_in dom_server_addr;
unsigned short int dom_server_port;
int dom_socket;
CLIENT *dom_client;
long dom_vers;
time_t dom_check_t;
time_t dom_ask_t;
int dom_lockfd;
int dom_alive;
u_int32_t dom_xid;
};
static char *dname;
static struct _dom_binding *ypbindlist;
static int check;
typedef enum
{
YPBIND_DIRECT,
YPBIND_BROADCAST,
YPBIND_SETLOCAL,
YPBIND_SETALL
} ypbind_mode_t;
ypbind_mode_t ypbindmode;
int been_ypset;
static int insecure;
static int rpcsock, pingsock;
static struct rmtcallargs rmtca;
static struct rmtcallres rmtcr;
static bool_t rmtcr_outval;
static u_long rmtcr_port;
static SVCXPRT *udptransp, *tcptransp;
int main __P((int, char *[]));
static void usage __P((void));
static struct _dom_binding *makebinding __P((const char *));
static int makelock __P((struct _dom_binding *));
static void removelock __P((struct _dom_binding *));
static void checkwork __P((void));
static int ping __P((struct _dom_binding *));
static int nag_servers __P((struct _dom_binding *));
static enum clnt_stat handle_replies __P((void));
static enum clnt_stat handle_ping __P((void));
static void rpc_received __P((char *, struct sockaddr_in *, int));
static struct _dom_binding *xid2ypdb __P((u_int32_t));
static u_int32_t unique_xid __P((struct _dom_binding *));
static int broadcast __P((char *, int));
static int direct __P((char *, int));
static int direct_set __P((char *, int, struct _dom_binding *));
#define DEBUG_NONE 0
#define DEBUG_STDERR 1
#define DEBUG_SYSLOG 2
static int debug;
static char *msg_str = NULL;
void
sys_openlog(int debug, char *str, int flags, int facility)
{
if (msg_str != NULL) free(msg_str);
msg_str = NULL;
if (str != NULL)
{
msg_str = malloc(strlen(str) + 1);
strcpy(msg_str, str);
}
if (debug & DEBUG_SYSLOG) openlog(msg_str, flags, facility);
}
void
sys_msg(int debug, int priority, char *message, ...)
{
va_list ap;
va_start(ap, message);
if (debug & DEBUG_SYSLOG) vsyslog(priority, message, ap);
if (debug & DEBUG_STDERR)
{
if (msg_str != NULL) fprintf(stderr, "%s: ", msg_str);
vfprintf(stderr, message, ap);
fprintf(stderr, "\n");
fflush(stderr);
}
va_end(ap);
}
static void
usage()
{
fprintf(stderr,
"Usage: ypbind [-broadcast] [-insecure] [-ypset] [-ypsetme] [-d]\n");
exit(1);
}
static struct _dom_binding *
makebinding(const char *dm)
{
struct _dom_binding *ypdb;
ypdb = (struct _dom_binding *)malloc(sizeof *ypdb);
memset(ypdb, 0, sizeof *ypdb);
strncpy(ypdb->dom_domain, dm, sizeof ypdb->dom_domain);
ypdb->dom_domain[sizeof(ypdb->dom_domain) - 1] = '\0';
return ypdb;
}
static int
makelock(struct _dom_binding *ypdb)
{
int fd;
char path[MAXPATHLEN];
snprintf(path, sizeof(path), "%s/%s.%ld", BINDINGDIR,
ypdb->dom_domain, ypdb->dom_vers);
fd = open(path, O_CREAT|O_SHLOCK|O_RDWR|O_TRUNC, 0644);
if (fd == -1)
{
mkdir(BINDINGDIR, 0755);
fd = open(path, O_CREAT|O_SHLOCK|O_RDWR|O_TRUNC, 0644);
if (fd == -1) return -1;
}
#if O_SHLOCK == 0
flock(fd, LOCK_SH);
#endif
return fd;
}
static void
removelock(struct _dom_binding *ypdb)
{
char path[MAXPATHLEN];
snprintf(path, sizeof(path), "%s/%s.%ld",
BINDINGDIR, ypdb->dom_domain, ypdb->dom_vers);
unlink(path);
}
static void *
svc_ypbindproc_null_2(void *argp, SVCXPRT *transp)
{
static char res;
sys_msg(debug, LOG_DEBUG, "ypbindproc_null_2");
memset(&res, 0, sizeof(res));
return (void *)&res;
}
static void *
svc_ypbindproc_domain_2(void *argp, SVCXPRT *transp)
{
static struct ypbind_resp res;
struct _dom_binding *ypdb;
char *arg = *(char **) argp;
int count;
sys_msg(debug, LOG_DEBUG, "ypbindproc_domain_2 %s", arg);
memset(&res, 0, sizeof res);
res.ypbind_status = YPBIND_FAIL_VAL;
for (count = 0, ypdb = ypbindlist;
ypdb != NULL;
ypdb = ypdb->dom_pnext, count++)
{
if (count > 100) return NULL;
if (!strcmp(ypdb->dom_domain, arg)) break;
}
if (ypdb == NULL)
{
ypdb = makebinding(arg);
ypdb->dom_vers = YPVERS;
ypdb->dom_alive = 0;
ypdb->dom_lockfd = -1;
removelock(ypdb);
ypdb->dom_xid = unique_xid(ypdb);
ypdb->dom_pnext = ypbindlist;
ypbindlist = ypdb;
check++;
sys_msg(debug, LOG_ERR, "unknown domain %s", arg);
return NULL;
}
if (ypdb->dom_alive == 0)
{
sys_msg(debug, LOG_ERR, "dead domain %s", arg);
return NULL;
}
#ifdef HEURISTIC
time(&now);
if (now < ypdb->dom_ask_t + 5)
{
if (ypdb->dom_check_t >= now)
{
ypdb->dom_check_t = 0;
check++;
}
}
ypdb->dom_ask_t = now;
#endif
res.ypbind_status = YPBIND_SUCC_VAL;
bcopy(&ypdb->dom_server_addr.sin_addr.s_addr,
res.ypbind_resp_u.ypbind_bindinfo.ypbind_binding_addr, 4);
bcopy(&ypdb->dom_server_port,
res.ypbind_resp_u.ypbind_bindinfo.ypbind_binding_port, 2);
sys_msg(debug, LOG_DEBUG, "domain %s at %s/%d", ypdb->dom_domain,
inet_ntoa(ypdb->dom_server_addr.sin_addr),
ntohs(ypdb->dom_server_addr.sin_port));
return &res;
}
static void *
svc_ypbindproc_setdom_2(void *argp, SVCXPRT *transp)
{
struct ypbind_setdom *sd = argp;
struct sockaddr_in *fromsin, bindsin;
static bool_t res;
memset(&bindsin, 0, sizeof bindsin);
bindsin.sin_family = AF_INET;
bindsin.sin_len = sizeof(bindsin);
bcopy(&sd->ypsetdom_binding.ypbind_binding_addr,
&bindsin.sin_addr.s_addr, 4);
bcopy(&sd->ypsetdom_binding.ypbind_binding_port,
&bindsin.sin_port, 2);
fromsin = svc_getcaller(transp);
memset(&res, 0, sizeof(res));
switch (ypbindmode)
{
case YPBIND_SETLOCAL:
if (fromsin->sin_addr.s_addr != htonl(INADDR_LOOPBACK))
{
sys_msg(debug, LOG_ERR, "ypset from %s denied",
inet_ntoa(fromsin->sin_addr));
return NULL;
}
case YPBIND_SETALL:
been_ypset = 1;
break;
case YPBIND_DIRECT:
case YPBIND_BROADCAST:
default:
sys_msg(debug, LOG_ERR, "ypset denied");
return NULL;
}
if (ntohs(fromsin->sin_port) >= IPPORT_RESERVED)
{
sys_msg(debug, LOG_ERR, "ypset from unpriviledged port denied");
return &res;
}
if (sd->ypsetdom_vers != YPVERS)
{
sys_msg(debug, LOG_ERR, "ypset with wrong version denied");
sys_msg(debug, LOG_DEBUG, "ypsetdom_vers = %lu YPVERS = %lu",
sd->ypsetdom_vers, YPVERS);
return &res;
}
rpc_received(sd->ypsetdom_domain, &bindsin, 1);
sys_msg(debug, LOG_DEBUG, "ypset to %s succeeded",
inet_ntoa(bindsin.sin_addr));
res = 1;
return &res;
}
static void
ypbindprog_2(struct svc_req *rqstp, register SVCXPRT *transp)
{
union
{
char ypbindproc_domain_2_arg[YPMAXDOMAIN + 1];
struct ypbind_setdom ypbindproc_setdom_2_arg;
} argument;
struct authunix_parms *creds;
char *result;
xdrproc_t xdr_argument, xdr_result;
void *(*local) __P((void *, SVCXPRT *));
switch (rqstp->rq_proc)
{
case YPBINDPROC_NULL:
xdr_argument = xdr_void;
xdr_result = xdr_void;
local = svc_ypbindproc_null_2;
break;
case YPBINDPROC_DOMAIN:
xdr_argument = xdr_domainname;
xdr_result = xdr_ypbind_resp;
local = svc_ypbindproc_domain_2;
break;
case YPBINDPROC_SETDOM:
switch (rqstp->rq_cred.oa_flavor)
{
case AUTH_UNIX:
creds = (struct authunix_parms *)rqstp->rq_clntcred;
if (creds->aup_uid != 0)
{
svcerr_auth(transp, AUTH_BADCRED);
return;
}
break;
default:
svcerr_auth(transp, AUTH_TOOWEAK);
return;
}
xdr_argument = xdr_ypbind_setdom;
xdr_result = xdr_void;
local = svc_ypbindproc_setdom_2;
break;
default:
svcerr_noproc(transp);
return;
}
memset(&argument, 0, sizeof(argument));
if (!svc_getargs(transp, xdr_argument, (caddr_t)&argument))
{
svcerr_decode(transp);
return;
}
result = (*local)(&argument, transp);
if (result != NULL && !svc_sendreply(transp, xdr_result, result))
{
svcerr_systemerr(transp);
}
return;
}
int
main(int argc, char *argv[])
{
struct timeval tv;
fd_set fdsr;
int width, lockfd;
int evil = 0, one, i;
char pathname[MAXPATHLEN];
struct stat st;
yp_get_default_domain(&dname);
if (dname[0] == '\0')
{
fprintf(stderr, "Domainname not set. Aborting.\n");
exit(1);
}
debug = DEBUG_SYSLOG;
ypbindmode = YPBIND_DIRECT;
for (i = 1; i < argc; i++)
{
if (!strcmp(argv[i], "-insecure"))
insecure = 1;
else if (!strcmp(argv[i], "-ypset"))
ypbindmode = YPBIND_SETALL;
else if (!strcmp(argv[i], "-ypsetme"))
ypbindmode = YPBIND_SETLOCAL;
else if (!strcmp(argv[i], "-broadcast"))
ypbindmode = YPBIND_BROADCAST;
else if (!strcmp(argv[i], "-d"))
debug = DEBUG_STDERR;
else
usage();
}
sys_openlog(debug, "ypbind", LOG_NDELAY | LOG_PID, LOG_DAEMON);
snprintf(pathname, sizeof(pathname), "%s/%s%s",
BINDINGDIR, dname, YPSERVERSSUFF);
if ((ypbindmode == YPBIND_DIRECT) && (stat(pathname, &st) < 0))
{
sys_msg(debug, LOG_DEBUG, "%s does not exist, defaulting to broadcast.",
pathname);
ypbindmode = YPBIND_BROADCAST;
}
lockfd = open(_PATH_YPBIND_LOCK, O_CREAT|O_SHLOCK|O_RDWR|O_TRUNC, 0644);
if (lockfd == -1)
{
sys_msg(debug, LOG_ERR, "Cannot create %s", _PATH_YPBIND_LOCK);
exit(1);
}
#if O_SHLOCK == 0
flock(lockfd, LOCK_SH);
#endif
pmap_unset(YPBINDPROG, YPBINDVERS);
udptransp = svcudp_create(RPC_ANYSOCK);
if (udptransp == NULL)
{
sys_msg(debug, LOG_ERR, "Cannot create udp service.");
exit(1);
}
if (!svc_register(udptransp, YPBINDPROG, YPBINDVERS, ypbindprog_2,
IPPROTO_UDP))
{
sys_msg(debug, LOG_ERR,
"Unable to register (YPBINDPROG, YPBINDVERS, udp).");
exit(1);
}
tcptransp = svctcp_create(RPC_ANYSOCK, 0, 0);
if (tcptransp == NULL)
{
sys_msg(debug, LOG_ERR, "Cannot create tcp service.");
exit(1);
}
if (!svc_register(tcptransp, YPBINDPROG, YPBINDVERS, ypbindprog_2,
IPPROTO_TCP))
{
sys_msg(debug, LOG_ERR,
"Unable to register (YPBINDPROG, YPBINDVERS, tcp).");
exit(1);
}
rpcsock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (rpcsock == -1)
{
sys_msg(debug, LOG_ERR, "rpc socket() failed.");
exit(1);
}
pingsock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (pingsock == -1)
{
sys_msg(debug, LOG_ERR, "ping socket() failed.");
exit(1);
}
fcntl(rpcsock, F_SETFL, fcntl(rpcsock, F_GETFL, 0) | FNDELAY);
fcntl(pingsock, F_SETFL, fcntl(pingsock, F_GETFL, 0) | FNDELAY);
one = 1;
setsockopt(rpcsock, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one));
rmtca.prog = YPPROG;
rmtca.vers = YPVERS;
rmtca.proc = YPPROC_DOMAIN_NONACK;
rmtca.xdr_args = NULL;
rmtca.args_ptr = NULL;
rmtcr.port_ptr = &rmtcr_port;
rmtcr.xdr_results = xdr_bool;
rmtcr.results_ptr = (caddr_t)&rmtcr_outval;
ypbindlist = makebinding(dname);
ypbindlist->dom_vers = YPVERS;
ypbindlist->dom_alive = 0;
ypbindlist->dom_lockfd = -1;
removelock(ypbindlist);
checkwork();
width = FD_SETSIZE;
width = 32;
if (rpcsock > width)
width = rpcsock;
if (pingsock > width)
width = pingsock;
width++;
for (;;)
{
fdsr = svc_fdset;
FD_SET(rpcsock, &fdsr);
FD_SET(pingsock, &fdsr);
tv.tv_sec = 1;
tv.tv_usec = 0;
switch (select(width, &fdsr, NULL, NULL, &tv))
{
case 0:
checkwork();
break;
case -1:
sys_msg(debug, LOG_WARNING, "select: %s", strerror(errno));
break;
default:
if (FD_ISSET(rpcsock, &fdsr)) handle_replies();
if (FD_ISSET(pingsock, &fdsr)) handle_ping();
svc_getreqset(&fdsr);
if (check) checkwork();
break;
}
if ((evil == 0) && (ypbindlist->dom_alive != 0))
{
evil = 1;
if (debug == DEBUG_SYSLOG) daemon(0, 0);
}
}
}
void
checkwork()
{
struct _dom_binding *ypdb;
time_t t;
check = 0;
time(&t);
for (ypdb = ypbindlist; ypdb; ypdb = ypdb->dom_pnext)
{
if (ypdb->dom_check_t < t)
{
if (ypdb->dom_alive == 1) ping(ypdb);
else nag_servers(ypdb);
time(&t);
ypdb->dom_check_t = t + 5;
}
}
}
int
ping(struct _dom_binding *ypdb)
{
char *dom = ypdb->dom_domain;
struct rpc_msg msg;
char buf[BUFSIZE];
enum clnt_stat st;
int outlen;
AUTH *rpcua;
XDR xdr;
memset(&xdr, 0, sizeof xdr);
memset(&msg, 0, sizeof msg);
rpcua = authunix_create_default();
if (rpcua == NULL)
{
sys_msg(debug, LOG_ERR, "ping: cannot get unix auth");
return RPC_SYSTEMERROR;
}
msg.rm_direction = CALL;
msg.rm_call.cb_rpcvers = RPC_MSG_VERSION;
msg.rm_call.cb_prog = YPPROG;
msg.rm_call.cb_vers = YPVERS;
msg.rm_call.cb_proc = YPPROC_DOMAIN_NONACK;
msg.rm_call.cb_cred = rpcua->ah_cred;
msg.rm_call.cb_verf = rpcua->ah_verf;
msg.rm_xid = ypdb->dom_xid;
xdrmem_create(&xdr, buf, sizeof buf, XDR_ENCODE);
if (!xdr_callmsg(&xdr, &msg))
{
st = RPC_CANTENCODEARGS;
AUTH_DESTROY(rpcua);
return st;
}
if (!xdr_domainname(&xdr, (void *)&dom))
{
st = RPC_CANTENCODEARGS;
AUTH_DESTROY(rpcua);
return st;
}
outlen = (int)xdr_getpos(&xdr);
xdr_destroy(&xdr);
if (outlen < 1)
{
st = RPC_CANTENCODEARGS;
AUTH_DESTROY(rpcua);
return st;
}
AUTH_DESTROY(rpcua);
ypdb->dom_alive = 2;
if (sendto(pingsock, buf, outlen, 0,
(struct sockaddr *)&ypdb->dom_server_addr,
sizeof ypdb->dom_server_addr) == -1)
sys_msg(debug, LOG_WARNING, "ping: sendto");
return 0;
}
static int
nag_servers(struct _dom_binding *ypdb)
{
char *dom = ypdb->dom_domain;
struct rpc_msg msg;
char buf[BUFSIZE];
enum clnt_stat st;
int outlen;
AUTH *rpcua;
XDR xdr;
rmtca.xdr_args = xdr_domainname;
rmtca.args_ptr = (char *)&dom;
memset(&xdr, 0, sizeof xdr);
memset(&msg, 0, sizeof msg);
rpcua = authunix_create_default();
if (rpcua == NULL)
{
sys_msg(debug, LOG_ERR, "ping: cannot get unix auth");
return RPC_SYSTEMERROR;
}
msg.rm_direction = CALL;
msg.rm_call.cb_rpcvers = RPC_MSG_VERSION;
msg.rm_call.cb_prog = PMAPPROG;
msg.rm_call.cb_vers = PMAPVERS;
msg.rm_call.cb_proc = PMAPPROC_CALLIT;
msg.rm_call.cb_cred = rpcua->ah_cred;
msg.rm_call.cb_verf = rpcua->ah_verf;
msg.rm_xid = ypdb->dom_xid;
xdrmem_create(&xdr, buf, sizeof buf, XDR_ENCODE);
if (!xdr_callmsg(&xdr, &msg))
{
st = RPC_CANTENCODEARGS;
AUTH_DESTROY(rpcua);
return st;
}
if (!xdr_rmtcall_args(&xdr, &rmtca))
{
st = RPC_CANTENCODEARGS;
AUTH_DESTROY(rpcua);
return st;
}
outlen = (int)xdr_getpos(&xdr);
xdr_destroy(&xdr);
if (outlen < 1)
{
st = RPC_CANTENCODEARGS;
AUTH_DESTROY(rpcua);
return st;
}
AUTH_DESTROY(rpcua);
if (ypdb->dom_lockfd != -1)
{
close(ypdb->dom_lockfd);
ypdb->dom_lockfd = -1;
removelock(ypdb);
}
if (ypdb->dom_alive == 2)
{
struct sockaddr_in bindsin;
memset(&bindsin, 0, sizeof bindsin);
bindsin.sin_family = AF_INET;
bindsin.sin_len = sizeof(bindsin);
bindsin.sin_port = htons(PMAPPORT);
bindsin.sin_addr = ypdb->dom_server_addr.sin_addr;
if (sendto(rpcsock, buf, outlen, 0, (struct sockaddr *)&bindsin,
sizeof bindsin) == -1)
sys_msg(debug, LOG_WARNING, "broadcast: sendto");
}
switch (ypbindmode)
{
case YPBIND_SETALL:
case YPBIND_SETLOCAL:
if (been_ypset) return direct_set(buf, outlen, ypdb);
case YPBIND_BROADCAST:
return broadcast(buf, outlen);
case YPBIND_DIRECT:
return direct(buf, outlen);
}
return -1;
}
static int
broadcast(char *buf, int outlen)
{
struct ifconf ifc;
struct ifreq *ifr;
int offset, addrlen;
struct in_addr in;
int sock;
char inbuf[8192];
struct sockaddr_in bindsin;
sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (sock == -1)
{
sys_msg(debug, LOG_WARNING, "broadcast: socket: %s", strerror(errno));
return -1;
}
memset(&bindsin, 0, sizeof bindsin);
bindsin.sin_family = AF_INET;
bindsin.sin_len = sizeof(bindsin);
bindsin.sin_port = htons(PMAPPORT);
ifc.ifc_len = sizeof inbuf;
ifc.ifc_buf = inbuf;
if (ioctl(sock, SIOCGIFCONF, &ifc) < 0)
{
close(sock);
sys_msg(debug, LOG_WARNING, "broadcast: ioctl(SIOCGIFCONF): %s",
strerror(errno));
return -1;
}
addrlen = sizeof(struct ifreq) - IFNAMSIZ;
offset = 0;
while (offset <= ifc.ifc_len)
{
ifr = (struct ifreq *)(ifc.ifc_buf + offset);
offset += IFNAMSIZ;
if (ifr->ifr_addr.sa_len > addrlen) offset += ifr->ifr_addr.sa_len;
else offset += addrlen;
if (ifr->ifr_addr.sa_family != AF_INET) continue;
if (ioctl(sock, SIOCGIFFLAGS, ifr) < 0) continue;
if ((ifr->ifr_flags & IFF_UP) == 0) continue;
if (ifr->ifr_flags & IFF_BROADCAST)
{
if (ioctl(sock, SIOCGIFBRDADDR, ifr) < 0)
{
sys_msg(debug, LOG_WARNING,
"broadcast: ioctl(SIOCGIFBRDADDR): %s", strerror(errno));
continue;
}
}
else if (ifr->ifr_flags & IFF_LOOPBACK)
{
if (ioctl(sock, SIOCGIFADDR, ifr) < 0)
{
sys_msg(debug, LOG_WARNING,
"broadcast: ioctl(SIOCGIFADDR): %s", strerror(errno));
continue;
}
}
else continue;
in = ((struct sockaddr_in *)&(ifr->ifr_addr))->sin_addr;
bindsin.sin_addr = in;
if (sendto(rpcsock, buf, outlen, 0, (struct sockaddr *)&bindsin,
sizeof bindsin) == -1)
sys_msg(debug, LOG_WARNING, "broadcast: sendto: %s",
strerror(errno));
}
close(sock);
return 0;
}
static int
direct(char *buf, int outlen)
{
static FILE *df;
static char ypservers_path[MAXPATHLEN];
char line[_POSIX2_LINE_MAX];
char *p;
struct hostent *hp;
struct sockaddr_in bindsin;
int i, count = 0;
if (df) rewind(df);
else {
snprintf(ypservers_path, sizeof(ypservers_path),
"%s/%s%s", BINDINGDIR, dname, YPSERVERSSUFF);
df = fopen(ypservers_path, "r");
if (df == NULL)
{
sys_msg(debug, LOG_ALERT, "Missing file %s, aborting.",
ypservers_path);
exit(1);
}
}
memset(&bindsin, 0, sizeof bindsin);
bindsin.sin_family = AF_INET;
bindsin.sin_len = sizeof(bindsin);
bindsin.sin_port = htons(PMAPPORT);
while(fgets(line, sizeof(line), df) != NULL)
{
p = strchr(line, '\n');
if (p == NULL)
{
int c;
while ((c = getc(df)) != '\n' && c != EOF);
continue;
}
*p = '\0';
p = line;
while (isspace(*p)) p++;
if (*p == '#') continue;
hp = gethostbyname(p);
if (hp == NULL)
{
sys_msg(debug, LOG_ERR, "Can't find host: %s", p);
continue;
}
for (i = 0; hp->h_addr_list[i]; i++)
{
memmove(&bindsin.sin_addr, hp->h_addr_list[0],
hp->h_length);
if (sendto(rpcsock, buf, outlen, 0,
(struct sockaddr *)&bindsin, sizeof bindsin) < 0)
{
sys_msg(debug, LOG_WARNING, "direct: sendto: %s",
strerror(errno));
continue;
}
else count++;
}
}
if (count == 0)
{
sys_msg(debug, LOG_ALERT,
"Can't contact any servers listed in %s. Aborting", ypservers_path);
exit(1);
}
return 0;
}
static int
direct_set(char *buf, int outlen, struct _dom_binding *ypdb)
{
struct sockaddr_in bindsin;
char path[MAXPATHLEN];
struct iovec iov[2];
struct ypbind_resp ybr;
SVCXPRT dummy_svc;
int fd, bytes;
snprintf(path, sizeof(path), "%s/%s.%ld", BINDINGDIR,
ypdb->dom_domain, ypdb->dom_vers);
if ((fd = open(path, O_SHLOCK|O_RDONLY, 0644)) == -1)
{
sys_msg(debug, LOG_WARNING, "Can't open file %s", path);
been_ypset = 0;
return -1;
}
#if O_SHLOCK == 0
flock(fd, LOCK_SH);
#endif
iov[0].iov_base = (caddr_t)&(dummy_svc.xp_port);
iov[0].iov_len = sizeof(dummy_svc.xp_port);
iov[1].iov_base = (caddr_t)&ybr;
iov[1].iov_len = sizeof(ybr);
bytes = readv(fd, iov, 2);
close(fd);
if (bytes != (iov[0].iov_len + iov[1].iov_len))
{
sys_msg(debug, LOG_WARNING, "Can't parse file %s", path);
been_ypset = 0;
return -1;
}
bcopy(&ybr.ypbind_resp_u.ypbind_bindinfo.ypbind_binding_addr,
&bindsin.sin_addr, 4);
if (sendto(rpcsock, buf, outlen, 0, (struct sockaddr *)&bindsin,
sizeof(bindsin)) < 0)
{
sys_msg(debug, LOG_WARNING, "direct_set: sendto: %s", strerror(errno));
return -1;
}
return 0;
}
static enum clnt_stat
handle_replies()
{
char buf[BUFSIZE];
int fromlen, inlen;
struct _dom_binding *ypdb;
struct sockaddr_in raddr;
struct rpc_msg msg;
XDR xdr;
recv_again:
memset(&xdr, 0, sizeof(xdr));
memset(&msg, 0, sizeof(msg));
msg.acpted_rply.ar_verf = _null_auth;
msg.acpted_rply.ar_results.where = (caddr_t)&rmtcr;
msg.acpted_rply.ar_results.proc = xdr_rmtcallres;
try_again:
fromlen = sizeof (struct sockaddr);
inlen = recvfrom(rpcsock, buf, sizeof buf, 0,
(struct sockaddr *)&raddr, &fromlen);
if (inlen < 0)
{
if (errno == EINTR) goto try_again;
return RPC_CANTRECV;
}
if (inlen < sizeof(u_int32_t)) goto recv_again;
xdrmem_create(&xdr, buf, (u_int)inlen, XDR_DECODE);
if (xdr_replymsg(&xdr, &msg))
{
if ((msg.rm_reply.rp_stat == MSG_ACCEPTED) &&
(msg.acpted_rply.ar_stat == SUCCESS)) {
raddr.sin_port = htons((u_short)rmtcr_port);
ypdb = xid2ypdb(msg.rm_xid);
if (ypdb != NULL) rpc_received(ypdb->dom_domain, &raddr, 0);
}
}
xdr.x_op = XDR_FREE;
msg.acpted_rply.ar_results.proc = xdr_void;
xdr_destroy(&xdr);
return RPC_SUCCESS;
}
static enum clnt_stat
handle_ping()
{
char buf[BUFSIZE];
int fromlen, inlen;
struct _dom_binding *ypdb;
struct sockaddr_in raddr;
struct rpc_msg msg;
XDR xdr;
bool_t res;
recv_again:
memset(&xdr, 0, sizeof(xdr));
memset(&msg, 0, sizeof(msg));
msg.acpted_rply.ar_verf = _null_auth;
msg.acpted_rply.ar_results.where = (caddr_t)&res;
msg.acpted_rply.ar_results.proc = xdr_bool;
try_again:
fromlen = sizeof (struct sockaddr);
inlen = recvfrom(pingsock, buf, sizeof buf, 0,
(struct sockaddr *)&raddr, &fromlen);
if (inlen < 0)
{
if (errno == EINTR) goto try_again;
return RPC_CANTRECV;
}
if (inlen < sizeof(u_int32_t)) goto recv_again;
xdrmem_create(&xdr, buf, (u_int)inlen, XDR_DECODE);
if (xdr_replymsg(&xdr, &msg))
{
if ((msg.rm_reply.rp_stat == MSG_ACCEPTED) &&
(msg.acpted_rply.ar_stat == SUCCESS))
{
ypdb = xid2ypdb(msg.rm_xid);
if (ypdb != NULL) rpc_received(ypdb->dom_domain, &raddr, 0);
}
}
xdr.x_op = XDR_FREE;
msg.acpted_rply.ar_results.proc = xdr_void;
xdr_destroy(&xdr);
return RPC_SUCCESS;
}
void
rpc_received(char *dom, struct sockaddr_in *raddrp, int force)
{
struct _dom_binding *ypdb;
struct iovec iov[2];
struct ypbind_resp ybr;
int fd;
sys_msg(debug, LOG_DEBUG, "returned from %s about %s",
inet_ntoa(raddrp->sin_addr), dom);
if (dom == NULL) return;
if (!insecure && ntohs(raddrp->sin_port) >= IPPORT_RESERVED) return;
for (ypdb = ypbindlist; ypdb; ypdb = ypdb->dom_pnext)
{
if (!strcmp(ypdb->dom_domain, dom)) break;
}
if (ypdb == NULL)
{
if (force == 0) return;
ypdb = makebinding(dom);
ypdb->dom_lockfd = -1;
ypdb->dom_pnext = ypbindlist;
ypbindlist = ypdb;
}
if (ypdb->dom_alive == 1 && force == 0)
{
if (!memcmp(&ypdb->dom_server_addr, raddrp,
sizeof ypdb->dom_server_addr))
{
ypdb->dom_alive = 1;
ypdb->dom_check_t = time(NULL) + 60;
}
return;
}
memcpy(&ypdb->dom_server_addr, raddrp, sizeof ypdb->dom_server_addr);
ypdb->dom_check_t = time(NULL) + 60;
ypdb->dom_vers = YPVERS;
ypdb->dom_alive = 1;
if (ypdb->dom_lockfd != -1) close(ypdb->dom_lockfd);
if ((fd = makelock(ypdb)) == -1) return;
ypdb->dom_lockfd = fd;
iov[0].iov_base = (caddr_t)&(udptransp->xp_port);
iov[0].iov_len = sizeof udptransp->xp_port;
iov[1].iov_base = (caddr_t)&ybr;
iov[1].iov_len = sizeof ybr;
memset(&ybr, 0, sizeof ybr);
ybr.ypbind_status = YPBIND_SUCC_VAL;
bcopy(&raddrp->sin_addr.s_addr,
ybr.ypbind_resp_u.ypbind_bindinfo.ypbind_binding_addr, 4);
bcopy(&raddrp->sin_port,
ybr.ypbind_resp_u.ypbind_bindinfo.ypbind_binding_port, 2);
if (writev(ypdb->dom_lockfd, iov, 2) !=
iov[0].iov_len + iov[1].iov_len)
{
sys_msg(debug, LOG_WARNING, "writev: %s", strerror(errno));
close(ypdb->dom_lockfd);
removelock(ypdb);
ypdb->dom_lockfd = -1;
}
}
static struct _dom_binding *
xid2ypdb(u_int32_t xid)
{
struct _dom_binding *ypdb;
for (ypdb = ypbindlist; ypdb; ypdb = ypdb->dom_pnext)
{
if (ypdb->dom_xid == xid) break;
}
return (ypdb);
}
static u_int32_t
unique_xid(struct _dom_binding *ypdb)
{
u_int32_t tmp_xid;
tmp_xid = (u_int32_t)(((u_long)ypdb) & 0xffffffff);
while (xid2ypdb(tmp_xid) != NULL) tmp_xid++;
return tmp_xid;
}