bool_t
pmap_set(u_long program, u_long version, int protocol, int port)
{
bool_t rslt;
struct netbuf *na;
struct netconfig *nconf;
char buf[32];
if ((protocol != IPPROTO_UDP) && (protocol != IPPROTO_TCP)) {
return (FALSE);
}
nconf = __rpc_getconfip(protocol == IPPROTO_UDP ? "udp" : "tcp");
if (nconf == NULL) {
return (FALSE);
}
snprintf(buf, sizeof buf, "0.0.0.0.%d.%d",
(((u_int32_t)port) >> 8) & 0xff, port & 0xff);
na = uaddr2taddr(nconf, buf);
if (na == NULL) {
freenetconfigent(nconf);
return (FALSE);
}
rslt = rpcb_set((rpcprog_t)program, (rpcvers_t)version, nconf, na);
free(na);
freenetconfigent(nconf);
return (rslt);
}
int main(int argn, char *argc[])
{
/*
* argc[1] - HostName or Host IP
* argc[2] - Server Program Number
*/
int test_status = 1;
int progNum = atoi(argc[2]);
SVCXPRT *transp = NULL;
struct netconfig *nconf = NULL;
nconf = getnetconfigent("udp");
if (nconf == (struct netconfig *)NULL) {
printf("err nconf\n");
exit(1);
}
transp = svc_tli_create(RPC_ANYFD, nconf, (struct t_bind *)NULL, 0, 0);
if (transp == NULL) {
printf("svc_tli_create() failed\n");
exit(1);
}
test_status = !rpcb_set(progNum, VERSNUM, nconf, &(transp->xp_ltaddr));
if (!rpcb_unset(progNum, VERSNUM, nconf)) {
printf("rpcb_unset() failed\n");
exit(1);
}
printf("%d\n", test_status);
return test_status;
}
int main(int argn, char *argc[])
{
//Program parameters : argc[1] : HostName or Host IP
// argc[2] : Server Program Number
// other arguments depend on test case
//run_mode can switch into stand alone program or program launch by shell script
//1 : stand alone, debug mode, more screen information
//0 : launch by shell script as test case, only one printf -> result status
int run_mode = 0;
int test_status = 1; //Default test result set to FAILED
int progNum = atoi(argc[2]);
SVCXPRT *transp = NULL;
struct netconfig *nconf = NULL;
struct netbuf svcaddr;
//Initialization
if (run_mode)
{
printf("Before creation\n");
printf("nconf : %d\n", nconf);
}
nconf = getnetconfigent("udp");
if (nconf == (struct netconfig *) NULL)
{
//syslog(LOG_ERR, "getnetconfigent for udp failed");
printf("err nconf\n");
exit(1);
}
transp = svc_tli_create(RPC_ANYFD, nconf,
(struct t_bind *)NULL,
0, 0);
rpcb_set(progNum, VERSNUM, nconf, &svcaddr);
test_status = !rpcb_unset(progNum, VERSNUM, nconf);
//This last printf gives the result status to the tests suite
//normally should be 0: test has passed or 1: test has failed
printf("%d\n", test_status);
return test_status;
}
/*
* Registers with rpcbind the program number with all versions, from low to
* high, with the netid, all specified in 'rpc'. If registration fails,
* returns -1, else 0.
*/
int
register_rpc_service(const char *fmri, const rpc_info_t *rpc)
{
struct netconfig *nconf;
int ver;
debug_msg("Entering register_rpc_service: instance: %s", fmri);
if ((nconf = getnetconfigent(rpc->netid)) == NULL) {
/*
* Check whether getnetconfigent() failed as a result of
* having no IPv6 interfaces configured for a v6 netid, or
* as a result of a 'real' error, and output an appropriate
* message with an appropriate severity.
*/
if (is_v6_netid(rpc->netid) && !can_use_af(AF_INET6)) {
warn_msg(gettext(
"Couldn't register netid %s for RPC instance %s "
"because no IPv6 interfaces are plumbed"),
rpc->netid, fmri);
} else {
error_msg(gettext(
"Failed to lookup netid '%s' for instance %s: %s"),
rpc->netid, fmri, nc_sperror());
}
return (-1);
}
for (ver = rpc->lowver; ver <= rpc->highver; ver++) {
if (!rpcb_set(rpc->prognum, ver, nconf, &(rpc->netbuf))) {
error_msg(gettext("Failed to register version %d "
"of RPC service instance %s, netid %s"), ver,
fmri, rpc->netid);
for (ver--; ver >= rpc->lowver; ver--)
(void) rpcb_unset(rpc->prognum, ver, nconf);
freenetconfigent(nconf);
return (-1);
}
}
freenetconfigent(nconf);
return (0);
}
static int
tryconf(struct conf *cfg, int t, int reregister)
{
struct addrinfo hints;
int ecode;
memset(&hints, 0, sizeof hints);
hints.ai_flags = AI_PASSIVE;
hints.ai_family = cfg_family[t];
hints.ai_socktype = cfg_socktype[t];
hints.ai_protocol = cfg_protocol[t];
ecode = getaddrinfo(NULL, "nfs", &hints, &cfg->ai);
if (ecode != 0) {
logit(LOG_ERR, "getaddrinfo %s: %s", cfg_netconf[t],
gai_strerror(ecode));
return -1;
}
cfg->nc = getnetconfigent(cfg_netconf[t]);
if (cfg->nc == NULL) {
logit(LOG_ERR, "getnetconfigent %s failed: %s",
cfg_netconf[t], strerror(errno));
goto out;
}
cfg->nb.buf = cfg->ai->ai_addr;
cfg->nb.len = cfg->nb.maxlen = cfg->ai->ai_addrlen;
if (reregister)
if (!rpcb_set(RPCPROG_NFS, 2, cfg->nc, &cfg->nb)) {
logit(LOG_ERR, "rpcb_set %s failed", cfg_netconf[t]);
goto out1;
}
return 0;
out1:
freenetconfigent(cfg->nc);
cfg->nc = NULL;
out:
freeaddrinfo(cfg->ai);
cfg->ai = NULL;
return -1;
}
/*
* Nfs server daemon mostly just a user context for nfssvc()
*
* 1 - do file descriptor and signal cleanup
* 2 - fork the nfsd(s)
* 3 - create server socket(s)
* 4 - register socket with rpcbind
*
* For connectionless protocols, just pass the socket into the kernel via.
* nfssvc().
* For connection based sockets, loop doing accepts. When you get a new
* socket from accept, pass the msgsock into the kernel via. nfssvc().
* The arguments are:
* -r - reregister with rpcbind
* -d - unregister with rpcbind
* -t - support tcp nfs clients
* -u - support udp nfs clients
* -e - forces it to run a server that supports nfsv4
* followed by "n" which is the number of nfsds' to fork off
*/
int
main(int argc, char **argv)
{
struct nfsd_addsock_args addsockargs;
struct addrinfo *ai_udp, *ai_tcp, *ai_udp6, *ai_tcp6, hints;
struct netconfig *nconf_udp, *nconf_tcp, *nconf_udp6, *nconf_tcp6;
struct netbuf nb_udp, nb_tcp, nb_udp6, nb_tcp6;
struct sockaddr_in inetpeer;
struct sockaddr_in6 inet6peer;
fd_set ready, sockbits;
fd_set v4bits, v6bits;
int ch, connect_type_cnt, i, maxsock, msgsock;
socklen_t len;
int on = 1, unregister, reregister, sock;
int tcp6sock, ip6flag, tcpflag, tcpsock;
int udpflag, ecode, error, s;
int bindhostc, bindanyflag, rpcbreg, rpcbregcnt;
int nfssvc_addsock;
int longindex = 0;
const char *lopt;
char **bindhost = NULL;
pid_t pid;
nfsdcnt = DEFNFSDCNT;
unregister = reregister = tcpflag = maxsock = 0;
bindanyflag = udpflag = connect_type_cnt = bindhostc = 0;
getopt_shortopts = "ah:n:rdtue";
getopt_usage =
"usage:\n"
" nfsd [-ardtue] [-h bindip]\n"
" [-n numservers] [--minthreads #] [--maxthreads #]\n";
while ((ch = getopt_long(argc, argv, getopt_shortopts, longopts,
&longindex)) != -1)
switch (ch) {
case 'a':
bindanyflag = 1;
break;
case 'n':
set_nfsdcnt(atoi(optarg));
break;
case 'h':
bindhostc++;
bindhost = realloc(bindhost,sizeof(char *)*bindhostc);
if (bindhost == NULL)
errx(1, "Out of memory");
bindhost[bindhostc-1] = strdup(optarg);
if (bindhost[bindhostc-1] == NULL)
errx(1, "Out of memory");
break;
case 'r':
reregister = 1;
break;
case 'd':
unregister = 1;
break;
case 't':
tcpflag = 1;
break;
case 'u':
udpflag = 1;
break;
case 'e':
/* now a no-op, since this is the default */
break;
case 0:
lopt = longopts[longindex].name;
if (!strcmp(lopt, "minthreads")) {
minthreads = atoi(optarg);
} else if (!strcmp(lopt, "maxthreads")) {
maxthreads = atoi(optarg);
}
break;
default:
case '?':
usage();
}
if (!tcpflag && !udpflag)
udpflag = 1;
argv += optind;
argc -= optind;
if (minthreads_set && maxthreads_set && minthreads > maxthreads)
errx(EX_USAGE,
"error: minthreads(%d) can't be greater than "
"maxthreads(%d)", minthreads, maxthreads);
/*
* XXX
* Backward compatibility, trailing number is the count of daemons.
*/
if (argc > 1)
usage();
if (argc == 1)
set_nfsdcnt(atoi(argv[0]));
/*
* Unless the "-o" option was specified, try and run "nfsd".
* If "-o" was specified, try and run "nfsserver".
*/
if (modfind("nfsd") < 0) {
/* Not present in kernel, try loading it */
if (kldload("nfsd") < 0 || modfind("nfsd") < 0)
errx(1, "NFS server is not available");
}
ip6flag = 1;
s = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
if (s == -1) {
if (errno != EPROTONOSUPPORT && errno != EAFNOSUPPORT)
err(1, "socket");
ip6flag = 0;
} else if (getnetconfigent("udp6") == NULL ||
getnetconfigent("tcp6") == NULL) {
ip6flag = 0;
}
if (s != -1)
close(s);
if (bindhostc == 0 || bindanyflag) {
bindhostc++;
bindhost = realloc(bindhost,sizeof(char *)*bindhostc);
if (bindhost == NULL)
errx(1, "Out of memory");
bindhost[bindhostc-1] = strdup("*");
if (bindhost[bindhostc-1] == NULL)
errx(1, "Out of memory");
}
if (unregister) {
unregistration();
exit (0);
}
if (reregister) {
if (udpflag) {
memset(&hints, 0, sizeof hints);
hints.ai_flags = AI_PASSIVE;
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_DGRAM;
hints.ai_protocol = IPPROTO_UDP;
ecode = getaddrinfo(NULL, "nfs", &hints, &ai_udp);
if (ecode != 0)
err(1, "getaddrinfo udp: %s", gai_strerror(ecode));
nconf_udp = getnetconfigent("udp");
if (nconf_udp == NULL)
err(1, "getnetconfigent udp failed");
nb_udp.buf = ai_udp->ai_addr;
nb_udp.len = nb_udp.maxlen = ai_udp->ai_addrlen;
if ((!rpcb_set(NFS_PROGRAM, 2, nconf_udp, &nb_udp)) ||
(!rpcb_set(NFS_PROGRAM, 3, nconf_udp, &nb_udp)))
err(1, "rpcb_set udp failed");
freeaddrinfo(ai_udp);
}
if (udpflag && ip6flag) {
memset(&hints, 0, sizeof hints);
hints.ai_flags = AI_PASSIVE;
hints.ai_family = AF_INET6;
hints.ai_socktype = SOCK_DGRAM;
hints.ai_protocol = IPPROTO_UDP;
ecode = getaddrinfo(NULL, "nfs", &hints, &ai_udp6);
if (ecode != 0)
err(1, "getaddrinfo udp6: %s", gai_strerror(ecode));
nconf_udp6 = getnetconfigent("udp6");
if (nconf_udp6 == NULL)
err(1, "getnetconfigent udp6 failed");
nb_udp6.buf = ai_udp6->ai_addr;
nb_udp6.len = nb_udp6.maxlen = ai_udp6->ai_addrlen;
if ((!rpcb_set(NFS_PROGRAM, 2, nconf_udp6, &nb_udp6)) ||
(!rpcb_set(NFS_PROGRAM, 3, nconf_udp6, &nb_udp6)))
err(1, "rpcb_set udp6 failed");
freeaddrinfo(ai_udp6);
}
if (tcpflag) {
memset(&hints, 0, sizeof hints);
hints.ai_flags = AI_PASSIVE;
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
ecode = getaddrinfo(NULL, "nfs", &hints, &ai_tcp);
if (ecode != 0)
err(1, "getaddrinfo tcp: %s", gai_strerror(ecode));
nconf_tcp = getnetconfigent("tcp");
if (nconf_tcp == NULL)
err(1, "getnetconfigent tcp failed");
nb_tcp.buf = ai_tcp->ai_addr;
nb_tcp.len = nb_tcp.maxlen = ai_tcp->ai_addrlen;
if ((!rpcb_set(NFS_PROGRAM, 2, nconf_tcp, &nb_tcp)) ||
(!rpcb_set(NFS_PROGRAM, 3, nconf_tcp, &nb_tcp)))
err(1, "rpcb_set tcp failed");
freeaddrinfo(ai_tcp);
}
if (tcpflag && ip6flag) {
memset(&hints, 0, sizeof hints);
hints.ai_flags = AI_PASSIVE;
hints.ai_family = AF_INET6;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
ecode = getaddrinfo(NULL, "nfs", &hints, &ai_tcp6);
if (ecode != 0)
err(1, "getaddrinfo tcp6: %s", gai_strerror(ecode));
nconf_tcp6 = getnetconfigent("tcp6");
if (nconf_tcp6 == NULL)
err(1, "getnetconfigent tcp6 failed");
nb_tcp6.buf = ai_tcp6->ai_addr;
nb_tcp6.len = nb_tcp6.maxlen = ai_tcp6->ai_addrlen;
if ((!rpcb_set(NFS_PROGRAM, 2, nconf_tcp6, &nb_tcp6)) ||
(!rpcb_set(NFS_PROGRAM, 3, nconf_tcp6, &nb_tcp6)))
err(1, "rpcb_set tcp6 failed");
freeaddrinfo(ai_tcp6);
}
exit (0);
}
if (debug == 0) {
daemon(0, 0);
(void)signal(SIGHUP, SIG_IGN);
(void)signal(SIGINT, SIG_IGN);
/*
* nfsd sits in the kernel most of the time. It needs
* to ignore SIGTERM/SIGQUIT in order to stay alive as long
* as possible during a shutdown, otherwise loopback
* mounts will not be able to unmount.
*/
(void)signal(SIGTERM, SIG_IGN);
(void)signal(SIGQUIT, SIG_IGN);
}
(void)signal(SIGSYS, nonfs);
(void)signal(SIGCHLD, reapchild);
(void)signal(SIGUSR2, backup_stable);
openlog("nfsd", LOG_PID | (debug ? LOG_PERROR : 0), LOG_DAEMON);
/*
* For V4, we open the stablerestart file and call nfssvc()
* to get it loaded. This is done before the daemons do the
* regular nfssvc() call to service NFS requests.
* (This way the file remains open until the last nfsd is killed
* off.)
* It and the backup copy will be created as empty files
* the first time this nfsd is started and should never be
* deleted/replaced if at all possible. It should live on a
* local, non-volatile storage device that does not do hardware
* level write-back caching. (See SCSI doc for more information
* on how to prevent write-back caching on SCSI disks.)
*/
open_stable(&stablefd, &backupfd);
if (stablefd < 0) {
syslog(LOG_ERR, "Can't open %s: %m\n", NFSD_STABLERESTART);
exit(1);
}
/* This system call will fail for old kernels, but that's ok. */
nfssvc(NFSSVC_BACKUPSTABLE, NULL);
if (nfssvc(NFSSVC_STABLERESTART, (caddr_t)&stablefd) < 0) {
syslog(LOG_ERR, "Can't read stable storage file: %m\n");
exit(1);
}
nfssvc_addsock = NFSSVC_NFSDADDSOCK;
nfssvc_nfsd = NFSSVC_NFSDNFSD;
if (tcpflag) {
/*
* For TCP mode, we fork once to start the first
* kernel nfsd thread. The kernel will add more
* threads as needed.
*/
pid = fork();
if (pid == -1) {
syslog(LOG_ERR, "fork: %m");
nfsd_exit(1);
}
if (pid) {
children[0] = pid;
} else {
(void)signal(SIGUSR1, child_cleanup);
setproctitle("server");
start_server(0);
}
}
(void)signal(SIGUSR1, cleanup);
FD_ZERO(&v4bits);
FD_ZERO(&v6bits);
FD_ZERO(&sockbits);
rpcbregcnt = 0;
/* Set up the socket for udp and rpcb register it. */
if (udpflag) {
rpcbreg = 0;
for (i = 0; i < bindhostc; i++) {
memset(&hints, 0, sizeof hints);
hints.ai_flags = AI_PASSIVE;
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_DGRAM;
hints.ai_protocol = IPPROTO_UDP;
if (setbindhost(&ai_udp, bindhost[i], hints) == 0) {
rpcbreg = 1;
rpcbregcnt++;
if ((sock = socket(ai_udp->ai_family,
ai_udp->ai_socktype,
ai_udp->ai_protocol)) < 0) {
syslog(LOG_ERR,
"can't create udp socket");
nfsd_exit(1);
}
if (bind(sock, ai_udp->ai_addr,
ai_udp->ai_addrlen) < 0) {
syslog(LOG_ERR,
"can't bind udp addr %s: %m",
bindhost[i]);
nfsd_exit(1);
}
freeaddrinfo(ai_udp);
addsockargs.sock = sock;
addsockargs.name = NULL;
addsockargs.namelen = 0;
if (nfssvc(nfssvc_addsock, &addsockargs) < 0) {
syslog(LOG_ERR, "can't Add UDP socket");
nfsd_exit(1);
}
(void)close(sock);
}
}
if (rpcbreg == 1) {
memset(&hints, 0, sizeof hints);
hints.ai_flags = AI_PASSIVE;
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_DGRAM;
hints.ai_protocol = IPPROTO_UDP;
ecode = getaddrinfo(NULL, "nfs", &hints, &ai_udp);
if (ecode != 0) {
syslog(LOG_ERR, "getaddrinfo udp: %s",
gai_strerror(ecode));
nfsd_exit(1);
}
nconf_udp = getnetconfigent("udp");
if (nconf_udp == NULL)
err(1, "getnetconfigent udp failed");
nb_udp.buf = ai_udp->ai_addr;
nb_udp.len = nb_udp.maxlen = ai_udp->ai_addrlen;
if ((!rpcb_set(NFS_PROGRAM, 2, nconf_udp, &nb_udp)) ||
(!rpcb_set(NFS_PROGRAM, 3, nconf_udp, &nb_udp)))
err(1, "rpcb_set udp failed");
freeaddrinfo(ai_udp);
}
}
/* Set up the socket for udp6 and rpcb register it. */
if (udpflag && ip6flag) {
rpcbreg = 0;
for (i = 0; i < bindhostc; i++) {
memset(&hints, 0, sizeof hints);
hints.ai_flags = AI_PASSIVE;
hints.ai_family = AF_INET6;
hints.ai_socktype = SOCK_DGRAM;
hints.ai_protocol = IPPROTO_UDP;
if (setbindhost(&ai_udp6, bindhost[i], hints) == 0) {
rpcbreg = 1;
rpcbregcnt++;
if ((sock = socket(ai_udp6->ai_family,
ai_udp6->ai_socktype,
ai_udp6->ai_protocol)) < 0) {
syslog(LOG_ERR,
"can't create udp6 socket");
nfsd_exit(1);
}
if (setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY,
&on, sizeof on) < 0) {
syslog(LOG_ERR,
"can't set v6-only binding for "
"udp6 socket: %m");
nfsd_exit(1);
}
if (bind(sock, ai_udp6->ai_addr,
ai_udp6->ai_addrlen) < 0) {
syslog(LOG_ERR,
"can't bind udp6 addr %s: %m",
bindhost[i]);
nfsd_exit(1);
}
freeaddrinfo(ai_udp6);
addsockargs.sock = sock;
addsockargs.name = NULL;
addsockargs.namelen = 0;
if (nfssvc(nfssvc_addsock, &addsockargs) < 0) {
syslog(LOG_ERR,
"can't add UDP6 socket");
nfsd_exit(1);
}
(void)close(sock);
}
}
if (rpcbreg == 1) {
memset(&hints, 0, sizeof hints);
hints.ai_flags = AI_PASSIVE;
hints.ai_family = AF_INET6;
hints.ai_socktype = SOCK_DGRAM;
hints.ai_protocol = IPPROTO_UDP;
ecode = getaddrinfo(NULL, "nfs", &hints, &ai_udp6);
if (ecode != 0) {
syslog(LOG_ERR, "getaddrinfo udp6: %s",
gai_strerror(ecode));
nfsd_exit(1);
}
nconf_udp6 = getnetconfigent("udp6");
if (nconf_udp6 == NULL)
err(1, "getnetconfigent udp6 failed");
nb_udp6.buf = ai_udp6->ai_addr;
nb_udp6.len = nb_udp6.maxlen = ai_udp6->ai_addrlen;
if ((!rpcb_set(NFS_PROGRAM, 2, nconf_udp6, &nb_udp6)) ||
(!rpcb_set(NFS_PROGRAM, 3, nconf_udp6, &nb_udp6)))
err(1, "rpcb_set udp6 failed");
freeaddrinfo(ai_udp6);
}
}
/* Set up the socket for tcp and rpcb register it. */
if (tcpflag) {
rpcbreg = 0;
for (i = 0; i < bindhostc; i++) {
memset(&hints, 0, sizeof hints);
hints.ai_flags = AI_PASSIVE;
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
if (setbindhost(&ai_tcp, bindhost[i], hints) == 0) {
rpcbreg = 1;
rpcbregcnt++;
if ((tcpsock = socket(AF_INET, SOCK_STREAM,
0)) < 0) {
syslog(LOG_ERR,
"can't create tcp socket");
nfsd_exit(1);
}
if (setsockopt(tcpsock, SOL_SOCKET,
SO_REUSEADDR,
(char *)&on, sizeof(on)) < 0)
syslog(LOG_ERR,
"setsockopt SO_REUSEADDR: %m");
if (bind(tcpsock, ai_tcp->ai_addr,
ai_tcp->ai_addrlen) < 0) {
syslog(LOG_ERR,
"can't bind tcp addr %s: %m",
bindhost[i]);
nfsd_exit(1);
}
if (listen(tcpsock, -1) < 0) {
syslog(LOG_ERR, "listen failed");
nfsd_exit(1);
}
freeaddrinfo(ai_tcp);
FD_SET(tcpsock, &sockbits);
FD_SET(tcpsock, &v4bits);
maxsock = tcpsock;
connect_type_cnt++;
}
}
if (rpcbreg == 1) {
memset(&hints, 0, sizeof hints);
hints.ai_flags = AI_PASSIVE;
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
ecode = getaddrinfo(NULL, "nfs", &hints,
&ai_tcp);
if (ecode != 0) {
syslog(LOG_ERR, "getaddrinfo tcp: %s",
gai_strerror(ecode));
nfsd_exit(1);
}
nconf_tcp = getnetconfigent("tcp");
if (nconf_tcp == NULL)
err(1, "getnetconfigent tcp failed");
nb_tcp.buf = ai_tcp->ai_addr;
nb_tcp.len = nb_tcp.maxlen = ai_tcp->ai_addrlen;
if ((!rpcb_set(NFS_PROGRAM, 2, nconf_tcp,
&nb_tcp)) || (!rpcb_set(NFS_PROGRAM, 3,
nconf_tcp, &nb_tcp)))
err(1, "rpcb_set tcp failed");
freeaddrinfo(ai_tcp);
}
}
/* Set up the socket for tcp6 and rpcb register it. */
if (tcpflag && ip6flag) {
rpcbreg = 0;
for (i = 0; i < bindhostc; i++) {
memset(&hints, 0, sizeof hints);
hints.ai_flags = AI_PASSIVE;
hints.ai_family = AF_INET6;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
if (setbindhost(&ai_tcp6, bindhost[i], hints) == 0) {
rpcbreg = 1;
rpcbregcnt++;
if ((tcp6sock = socket(ai_tcp6->ai_family,
ai_tcp6->ai_socktype,
ai_tcp6->ai_protocol)) < 0) {
syslog(LOG_ERR,
"can't create tcp6 socket");
nfsd_exit(1);
}
if (setsockopt(tcp6sock, SOL_SOCKET,
SO_REUSEADDR,
(char *)&on, sizeof(on)) < 0)
syslog(LOG_ERR,
"setsockopt SO_REUSEADDR: %m");
if (setsockopt(tcp6sock, IPPROTO_IPV6,
IPV6_V6ONLY, &on, sizeof on) < 0) {
syslog(LOG_ERR,
"can't set v6-only binding for tcp6 "
"socket: %m");
nfsd_exit(1);
}
if (bind(tcp6sock, ai_tcp6->ai_addr,
ai_tcp6->ai_addrlen) < 0) {
syslog(LOG_ERR,
"can't bind tcp6 addr %s: %m",
bindhost[i]);
nfsd_exit(1);
}
if (listen(tcp6sock, -1) < 0) {
syslog(LOG_ERR, "listen failed");
nfsd_exit(1);
}
freeaddrinfo(ai_tcp6);
FD_SET(tcp6sock, &sockbits);
FD_SET(tcp6sock, &v6bits);
if (maxsock < tcp6sock)
maxsock = tcp6sock;
connect_type_cnt++;
}
}
if (rpcbreg == 1) {
memset(&hints, 0, sizeof hints);
hints.ai_flags = AI_PASSIVE;
hints.ai_family = AF_INET6;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
ecode = getaddrinfo(NULL, "nfs", &hints, &ai_tcp6);
if (ecode != 0) {
syslog(LOG_ERR, "getaddrinfo tcp6: %s",
gai_strerror(ecode));
nfsd_exit(1);
}
nconf_tcp6 = getnetconfigent("tcp6");
if (nconf_tcp6 == NULL)
err(1, "getnetconfigent tcp6 failed");
nb_tcp6.buf = ai_tcp6->ai_addr;
nb_tcp6.len = nb_tcp6.maxlen = ai_tcp6->ai_addrlen;
if ((!rpcb_set(NFS_PROGRAM, 2, nconf_tcp6, &nb_tcp6)) ||
(!rpcb_set(NFS_PROGRAM, 3, nconf_tcp6, &nb_tcp6)))
err(1, "rpcb_set tcp6 failed");
freeaddrinfo(ai_tcp6);
}
}
if (rpcbregcnt == 0) {
syslog(LOG_ERR, "rpcb_set() failed, nothing to do: %m");
nfsd_exit(1);
}
if (tcpflag && connect_type_cnt == 0) {
syslog(LOG_ERR, "tcp connects == 0, nothing to do: %m");
nfsd_exit(1);
}
setproctitle("master");
/*
* We always want a master to have a clean way to to shut nfsd down
* (with unregistration): if the master is killed, it unregisters and
* kills all children. If we run for UDP only (and so do not have to
* loop waiting waiting for accept), we instead make the parent
* a "server" too. start_server will not return.
*/
if (!tcpflag)
start_server(1);
/*
* Loop forever accepting connections and passing the sockets
* into the kernel for the mounts.
*/
for (;;) {
ready = sockbits;
if (connect_type_cnt > 1) {
if (select(maxsock + 1,
&ready, NULL, NULL, NULL) < 1) {
error = errno;
if (error == EINTR)
continue;
syslog(LOG_ERR, "select failed: %m");
nfsd_exit(1);
}
}
for (tcpsock = 0; tcpsock <= maxsock; tcpsock++) {
if (FD_ISSET(tcpsock, &ready)) {
if (FD_ISSET(tcpsock, &v4bits)) {
len = sizeof(inetpeer);
if ((msgsock = accept(tcpsock,
(struct sockaddr *)&inetpeer, &len)) < 0) {
error = errno;
syslog(LOG_ERR, "accept failed: %m");
if (error == ECONNABORTED ||
error == EINTR)
continue;
nfsd_exit(1);
}
memset(inetpeer.sin_zero, 0,
sizeof(inetpeer.sin_zero));
if (setsockopt(msgsock, SOL_SOCKET,
SO_KEEPALIVE, (char *)&on, sizeof(on)) < 0)
syslog(LOG_ERR,
"setsockopt SO_KEEPALIVE: %m");
addsockargs.sock = msgsock;
addsockargs.name = (caddr_t)&inetpeer;
addsockargs.namelen = len;
nfssvc(nfssvc_addsock, &addsockargs);
(void)close(msgsock);
} else if (FD_ISSET(tcpsock, &v6bits)) {
len = sizeof(inet6peer);
if ((msgsock = accept(tcpsock,
(struct sockaddr *)&inet6peer,
&len)) < 0) {
error = errno;
syslog(LOG_ERR,
"accept failed: %m");
if (error == ECONNABORTED ||
error == EINTR)
continue;
nfsd_exit(1);
}
if (setsockopt(msgsock, SOL_SOCKET,
SO_KEEPALIVE, (char *)&on,
sizeof(on)) < 0)
syslog(LOG_ERR, "setsockopt "
"SO_KEEPALIVE: %m");
addsockargs.sock = msgsock;
addsockargs.name = (caddr_t)&inet6peer;
addsockargs.namelen = len;
nfssvc(nfssvc_addsock, &addsockargs);
(void)close(msgsock);
}
}
}
}
}
/*
* Called to set up service over a particular transport.
*/
void
do_one(char *provider, NETSELDECL(proto), struct protob *protobp0,
int (*svc)(int, struct netbuf, struct netconfig *))
{
register int sock;
struct protob *protobp;
struct netbuf *retaddr;
struct netconfig *retnconf;
struct netbuf addrmask;
int vers;
int err;
int l;
if (provider)
sock = bind_to_provider(provider, protobp0->serv, &retaddr,
&retnconf);
else
sock = bind_to_proto(proto, protobp0->serv, &retaddr,
&retnconf);
if (sock == -1) {
(void) syslog(LOG_ERR,
"Cannot establish %s service over %s: transport setup problem.",
protobp0->serv, provider ? provider : proto);
return;
}
if (set_addrmask(sock, retnconf, &addrmask) < 0) {
(void) syslog(LOG_ERR,
"Cannot set address mask for %s", retnconf->nc_netid);
return;
}
/*
* Register all versions of the programs in the protocol block list.
*/
l = strlen(NC_UDP);
for (protobp = protobp0; protobp; protobp = protobp->next) {
for (vers = protobp->versmin; vers <= protobp->versmax;
vers++) {
if ((protobp->program == NFS_PROGRAM ||
protobp->program == NFS_ACL_PROGRAM) &&
vers == NFS_V4 &&
strncasecmp(retnconf->nc_proto, NC_UDP, l) == 0)
continue;
(void) rpcb_unset(protobp->program, vers, retnconf);
(void) rpcb_set(protobp->program, vers, retnconf,
retaddr);
}
}
/*
* Register services with CLTS semantics right now.
* Note: services with COTS/COTS_ORD semantics will be
* registered later from cots_listen_event function.
*/
if (retnconf->nc_semantics == NC_TPI_CLTS) {
/* Don't drop core if supporting module(s) aren't loaded. */
(void) signal(SIGSYS, SIG_IGN);
/*
* svc() doesn't block, it returns success or failure.
*/
if (svc == NULL && Mysvc4 != NULL)
err = (*Mysvc4)(sock, &addrmask, retnconf,
NFS4_SETPORT|NFS4_KRPC_START, retaddr);
else
err = (*svc)(sock, addrmask, retnconf);
if (err < 0) {
(void) syslog(LOG_ERR,
"Cannot establish %s service over <file desc."
" %d, protocol %s> : %m. Exiting",
protobp0->serv, sock, retnconf->nc_proto);
exit(1);
}
}
free(addrmask.buf);
/*
* We successfully set up the server over this transport.
* Add this descriptor to the one being polled on.
*/
add_to_poll_list(sock, retnconf);
}
static int
setupsock(struct conf *cfg, struct pollfd *set, int p)
{
int sock;
struct nfsd_args nfsdargs;
struct addrinfo *ai = cfg->ai;
int on = 1;
sock = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
if (sock == -1) {
logit(LOG_ERR, "can't create %s socket: %s", cfg_netconf[p],
strerror(errno));
return -1;
}
if (cfg_family[p] == PF_INET6) {
if (setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, &on,
sizeof(on)) == -1) {
logit(LOG_ERR, "can't set v6-only binding for %s "
"socket: %s", cfg_netconf[p], strerror(errno));
goto out;
}
}
if (cfg_protocol[p] == IPPROTO_TCP) {
if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &on,
sizeof(on)) == -1) {
logit(LOG_ERR, "setsockopt SO_REUSEADDR for %s: %s",
cfg_netconf[p], strerror(errno));
goto out;
}
}
if (bind(sock, ai->ai_addr, ai->ai_addrlen) == -1) {
logit(LOG_ERR, "can't bind %s addr: %s", cfg_netconf[p],
strerror(errno));
goto out;
}
if (cfg_protocol[p] == IPPROTO_TCP) {
if (listen(sock, 5) == -1) {
logit(LOG_ERR, "listen failed");
goto out;
}
}
if (!rpcb_set(RPCPROG_NFS, 2, cfg->nc, &cfg->nb) ||
!rpcb_set(RPCPROG_NFS, 3, cfg->nc, &cfg->nb)) {
logit(LOG_ERR, "can't register with %s portmap",
cfg_netconf[p]);
goto out;
}
if (cfg_protocol[p] == IPPROTO_TCP)
set->fd = sock;
else {
nfsdargs.sock = sock;
nfsdargs.name = NULL;
nfsdargs.namelen = 0;
if (nfssvc(NFSSVC_ADDSOCK, &nfsdargs) < 0) {
logit(LOG_ERR, "can't add %s socket: %s",
cfg_netconf[p], strerror(errno));
goto out;
}
(void)close(sock);
}
return 0;
out:
(void)close(sock);
return -1;
}
/*
* Called to set up service over a particular transport.
*/
void
do_one(char *provider, NETSELDECL(proto), struct protob *protobp0,
int (*svc)(int, struct netbuf, struct netconfig *), int use_pmap)
{
register int sock;
struct protob *protobp;
struct netbuf *retaddr;
struct netconfig *retnconf;
struct netbuf addrmask;
int vers;
int err;
int l;
if (provider)
sock = bind_to_provider(provider, protobp0->serv, &retaddr,
&retnconf);
else
sock = bind_to_proto(proto, protobp0->serv, &retaddr,
&retnconf);
if (sock == -1) {
(void) syslog(LOG_ERR,
"Cannot establish %s service over %s: transport setup problem.",
protobp0->serv, provider ? provider : proto);
return;
}
if (set_addrmask(sock, retnconf, &addrmask) < 0) {
(void) syslog(LOG_ERR,
"Cannot set address mask for %s", retnconf->nc_netid);
return;
}
/*
* Register all versions of the programs in the protocol block list.
*/
l = strlen(NC_UDP);
for (protobp = protobp0; protobp; protobp = protobp->next) {
for (vers = protobp->versmin; vers <= protobp->versmax;
vers++) {
if ((protobp->program == NFS_PROGRAM ||
protobp->program == NFS_ACL_PROGRAM) &&
vers == NFS_V4 &&
strncasecmp(retnconf->nc_proto, NC_UDP, l) == 0)
continue;
if (protobp->flags & PROTOB_NO_REGISTER)
continue;
if (use_pmap) {
/*
* Note that if we're using a portmapper
* instead of rpcbind then we can't do an
* unregister operation here.
*
* The reason is that the portmapper unset
* operation removes all the entries for a
* given program/version regardelss of
* transport protocol.
*
* The caller of this routine needs to ensure
* that __pmap_unset() has been called for all
* program/version service pairs they plan
* to support before they start registering
* each program/version/protocol triplet.
*/
(void) __pmap_set(protobp->program, vers,
retnconf, retaddr);
} else {
(void) rpcb_unset(protobp->program, vers,
retnconf);
(void) rpcb_set(protobp->program, vers,
retnconf, retaddr);
}
}
}
if (retnconf->nc_semantics == NC_TPI_CLTS) {
/* Don't drop core if supporting module(s) aren't loaded. */
(void) signal(SIGSYS, SIG_IGN);
/*
* svc() doesn't block, it returns success or failure.
*/
if (svc == NULL && Mysvc4 != NULL)
err = (*Mysvc4)(sock, &addrmask, retnconf,
NFS4_SETPORT|NFS4_KRPC_START, retaddr);
else
err = (*svc)(sock, addrmask, retnconf);
if (err < 0) {
(void) syslog(LOG_ERR,
"Cannot establish %s service over <file desc."
" %d, protocol %s> : %m. Exiting",
protobp0->serv, sock, retnconf->nc_proto);
exit(1);
}
}
/*
* We successfully set up the server over this transport.
* Add this descriptor to the one being polled on.
*/
add_to_poll_list(sock, retnconf);
}
/*
* Nfs server daemon mostly just a user context for nfssvc()
*
* 1 - do file descriptor and signal cleanup
* 2 - fork the nfsd(s)
* 3 - create server socket(s)
* 4 - register socket with rpcbind
*
* For connectionless protocols, just pass the socket into the kernel via.
* nfssvc().
* For connection based sockets, loop doing accepts. When you get a new
* socket from accept, pass the msgsock into the kernel via. nfssvc().
* The arguments are:
* -r - reregister with rpcbind
* -d - unregister with rpcbind
* -t - support tcp nfs clients
* -u - support udp nfs clients
* followed by "n" which is the number of nfsds' to fork off
*/
int
main(int argc, char **argv)
{
struct nfsd_args nfsdargs;
struct addrinfo *ai_udp, *ai_tcp, *ai_udp6, *ai_tcp6, hints;
struct netconfig *nconf_udp, *nconf_tcp, *nconf_udp6, *nconf_tcp6;
struct netbuf nb_udp, nb_tcp, nb_udp6, nb_tcp6;
struct sockaddr_in inetpeer;
struct sockaddr_in6 inet6peer;
fd_set ready, sockbits;
fd_set v4bits, v6bits;
int ch, connect_type_cnt, i, maxsock, msgsock;
socklen_t len;
int on = 1, unregister, reregister, sock;
int tcp6sock, ip6flag, tcpflag, tcpsock;
int udpflag, ecode, s, srvcnt;
int bindhostc, bindanyflag, rpcbreg, rpcbregcnt;
char **bindhost = NULL;
pid_t pid;
struct vfsconf vfc;
int error;
error = getvfsbyname("nfs", &vfc);
if (error && vfsisloadable("nfs")) {
if (vfsload("nfs"))
err(1, "vfsload(nfs)");
endvfsent(); /* flush cache */
error = getvfsbyname("nfs", &vfc);
}
if (error)
errx(1, "NFS is not available in the running kernel");
nfsdcnt = DEFNFSDCNT;
unregister = reregister = tcpflag = maxsock = 0;
bindanyflag = udpflag = connect_type_cnt = bindhostc = 0;
#define GETOPT "ah:n:rdtu"
#define USAGE "[-ardtu] [-n num_servers] [-h bindip]"
while ((ch = getopt(argc, argv, GETOPT)) != -1)
switch (ch) {
case 'a':
bindanyflag = 1;
break;
case 'n':
nfsdcnt = atoi(optarg);
if (nfsdcnt < 1 || nfsdcnt > MAXNFSDCNT) {
warnx("nfsd count %d; reset to %d", nfsdcnt,
DEFNFSDCNT);
nfsdcnt = DEFNFSDCNT;
}
break;
case 'h':
bindhostc++;
bindhost = realloc(bindhost,sizeof(char *)*bindhostc);
if (bindhost == NULL)
errx(1, "Out of memory");
bindhost[bindhostc-1] = strdup(optarg);
if (bindhost[bindhostc-1] == NULL)
errx(1, "Out of memory");
break;
case 'r':
reregister = 1;
break;
case 'd':
unregister = 1;
break;
case 't':
tcpflag = 1;
break;
case 'u':
udpflag = 1;
break;
default:
case '?':
usage();
};
if (!tcpflag && !udpflag)
udpflag = 1;
argv += optind;
argc -= optind;
/*
* XXX
* Backward compatibility, trailing number is the count of daemons.
*/
if (argc > 1)
usage();
if (argc == 1) {
nfsdcnt = atoi(argv[0]);
if (nfsdcnt < 1 || nfsdcnt > MAXNFSDCNT) {
warnx("nfsd count %d; reset to %d", nfsdcnt,
DEFNFSDCNT);
nfsdcnt = DEFNFSDCNT;
}
}
ip6flag = 1;
s = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
if (s == -1) {
if (errno != EPROTONOSUPPORT)
err(1, "socket");
ip6flag = 0;
} else if (getnetconfigent("udp6") == NULL ||
getnetconfigent("tcp6") == NULL) {
ip6flag = 0;
}
if (s != -1)
close(s);
if (bindhostc == 0 || bindanyflag) {
bindhostc++;
bindhost = realloc(bindhost,sizeof(char *)*bindhostc);
if (bindhost == NULL)
errx(1, "Out of memory");
bindhost[bindhostc-1] = strdup("*");
if (bindhost[bindhostc-1] == NULL)
errx(1, "Out of memory");
}
if (unregister) {
unregistration();
exit (0);
}
if (reregister) {
if (udpflag) {
memset(&hints, 0, sizeof hints);
hints.ai_flags = AI_PASSIVE;
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_DGRAM;
hints.ai_protocol = IPPROTO_UDP;
ecode = getaddrinfo(NULL, "nfs", &hints, &ai_udp);
if (ecode != 0)
err(1, "getaddrinfo udp: %s", gai_strerror(ecode));
nconf_udp = getnetconfigent("udp");
if (nconf_udp == NULL)
err(1, "getnetconfigent udp failed");
nb_udp.buf = ai_udp->ai_addr;
nb_udp.len = nb_udp.maxlen = ai_udp->ai_addrlen;
if ((!rpcb_set(RPCPROG_NFS, 2, nconf_udp, &nb_udp)) ||
(!rpcb_set(RPCPROG_NFS, 3, nconf_udp, &nb_udp)))
err(1, "rpcb_set udp failed");
freeaddrinfo(ai_udp);
}
if (udpflag && ip6flag) {
memset(&hints, 0, sizeof hints);
hints.ai_flags = AI_PASSIVE;
hints.ai_family = AF_INET6;
hints.ai_socktype = SOCK_DGRAM;
hints.ai_protocol = IPPROTO_UDP;
ecode = getaddrinfo(NULL, "nfs", &hints, &ai_udp6);
if (ecode != 0)
err(1, "getaddrinfo udp6: %s", gai_strerror(ecode));
nconf_udp6 = getnetconfigent("udp6");
if (nconf_udp6 == NULL)
err(1, "getnetconfigent udp6 failed");
nb_udp6.buf = ai_udp6->ai_addr;
nb_udp6.len = nb_udp6.maxlen = ai_udp6->ai_addrlen;
if ((!rpcb_set(RPCPROG_NFS, 2, nconf_udp6, &nb_udp6)) ||
(!rpcb_set(RPCPROG_NFS, 3, nconf_udp6, &nb_udp6)))
err(1, "rpcb_set udp6 failed");
freeaddrinfo(ai_udp6);
}
if (tcpflag) {
memset(&hints, 0, sizeof hints);
hints.ai_flags = AI_PASSIVE;
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
ecode = getaddrinfo(NULL, "nfs", &hints, &ai_tcp);
if (ecode != 0)
err(1, "getaddrinfo tcp: %s", gai_strerror(ecode));
nconf_tcp = getnetconfigent("tcp");
if (nconf_tcp == NULL)
err(1, "getnetconfigent tcp failed");
nb_tcp.buf = ai_tcp->ai_addr;
nb_tcp.len = nb_tcp.maxlen = ai_tcp->ai_addrlen;
if ((!rpcb_set(RPCPROG_NFS, 2, nconf_tcp, &nb_tcp)) ||
(!rpcb_set(RPCPROG_NFS, 3, nconf_tcp, &nb_tcp)))
err(1, "rpcb_set tcp failed");
freeaddrinfo(ai_tcp);
}
if (tcpflag && ip6flag) {
memset(&hints, 0, sizeof hints);
hints.ai_flags = AI_PASSIVE;
hints.ai_family = AF_INET6;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
ecode = getaddrinfo(NULL, "nfs", &hints, &ai_tcp6);
if (ecode != 0)
err(1, "getaddrinfo tcp6: %s", gai_strerror(ecode));
nconf_tcp6 = getnetconfigent("tcp6");
if (nconf_tcp6 == NULL)
err(1, "getnetconfigent tcp6 failed");
nb_tcp6.buf = ai_tcp6->ai_addr;
nb_tcp6.len = nb_tcp6.maxlen = ai_tcp6->ai_addrlen;
if ((!rpcb_set(RPCPROG_NFS, 2, nconf_tcp6, &nb_tcp6)) ||
(!rpcb_set(RPCPROG_NFS, 3, nconf_tcp6, &nb_tcp6)))
err(1, "rpcb_set tcp6 failed");
freeaddrinfo(ai_tcp6);
}
exit (0);
}
if (debug == 0) {
daemon(0, 0);
signal(SIGHUP, SIG_IGN);
signal(SIGINT, SIG_IGN);
/*
* nfsd sits in the kernel most of the time. It needs
* to ignore SIGTERM/SIGQUIT in order to stay alive as long
* as possible during a shutdown, otherwise loopback
* mounts will not be able to unmount.
*/
signal(SIGTERM, SIG_IGN);
signal(SIGQUIT, SIG_IGN);
}
signal(SIGSYS, nonfs);
signal(SIGCHLD, reapchild);
openlog("nfsd", LOG_PID, LOG_DAEMON);
/* If we use UDP only, we start the last server below. */
srvcnt = tcpflag ? nfsdcnt : nfsdcnt - 1;
for (i = 0; i < srvcnt; i++) {
switch ((pid = fork())) {
case -1:
syslog(LOG_ERR, "fork: %m");
nfsd_exit(1);
case 0:
break;
default:
children[i] = pid;
continue;
}
signal(SIGUSR1, child_cleanup);
setproctitle("server");
start_server(0);
}
signal(SIGUSR1, cleanup);
FD_ZERO(&v4bits);
FD_ZERO(&v6bits);
FD_ZERO(&sockbits);
rpcbregcnt = 0;
/* Set up the socket for udp and rpcb register it. */
if (udpflag) {
rpcbreg = 0;
for (i = 0; i < bindhostc; i++) {
memset(&hints, 0, sizeof hints);
hints.ai_flags = AI_PASSIVE;
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_DGRAM;
hints.ai_protocol = IPPROTO_UDP;
if (setbindhost(&ai_udp, bindhost[i], hints) == 0) {
rpcbreg = 1;
rpcbregcnt++;
if ((sock = socket(ai_udp->ai_family,
ai_udp->ai_socktype,
ai_udp->ai_protocol)) < 0) {
syslog(LOG_ERR,
"can't create udp socket");
nfsd_exit(1);
}
if (bind(sock, ai_udp->ai_addr,
ai_udp->ai_addrlen) < 0) {
syslog(LOG_ERR,
"can't bind udp addr %s: %m",
bindhost[i]);
nfsd_exit(1);
}
freeaddrinfo(ai_udp);
nfsdargs.sock = sock;
nfsdargs.name = NULL;
nfsdargs.namelen = 0;
if (nfssvc(NFSSVC_ADDSOCK, &nfsdargs) < 0) {
syslog(LOG_ERR, "can't Add UDP socket");
nfsd_exit(1);
}
close(sock);
}
}
if (rpcbreg == 1) {
memset(&hints, 0, sizeof hints);
hints.ai_flags = AI_PASSIVE;
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_DGRAM;
hints.ai_protocol = IPPROTO_UDP;
ecode = getaddrinfo(NULL, "nfs", &hints, &ai_udp);
if (ecode != 0) {
syslog(LOG_ERR, "getaddrinfo udp: %s",
gai_strerror(ecode));
nfsd_exit(1);
}
nconf_udp = getnetconfigent("udp");
if (nconf_udp == NULL)
err(1, "getnetconfigent udp failed");
nb_udp.buf = ai_udp->ai_addr;
nb_udp.len = nb_udp.maxlen = ai_udp->ai_addrlen;
if ((!rpcb_set(RPCPROG_NFS, 2, nconf_udp, &nb_udp)) ||
(!rpcb_set(RPCPROG_NFS, 3, nconf_udp, &nb_udp)))
err(1, "rpcb_set udp failed");
freeaddrinfo(ai_udp);
}
}
/* Set up the socket for udp6 and rpcb register it. */
if (udpflag && ip6flag) {
rpcbreg = 0;
for (i = 0; i < bindhostc; i++) {
memset(&hints, 0, sizeof hints);
hints.ai_flags = AI_PASSIVE;
hints.ai_family = AF_INET6;
hints.ai_socktype = SOCK_DGRAM;
hints.ai_protocol = IPPROTO_UDP;
if (setbindhost(&ai_udp6, bindhost[i], hints) == 0) {
rpcbreg = 1;
rpcbregcnt++;
if ((sock = socket(ai_udp6->ai_family,
ai_udp6->ai_socktype,
ai_udp6->ai_protocol)) < 0) {
syslog(LOG_ERR,
"can't create udp6 socket");
nfsd_exit(1);
}
if (setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY,
&on, sizeof on) < 0) {
syslog(LOG_ERR,
"can't set v6-only binding for "
"udp6 socket: %m");
nfsd_exit(1);
}
if (bind(sock, ai_udp6->ai_addr,
ai_udp6->ai_addrlen) < 0) {
syslog(LOG_ERR,
"can't bind udp6 addr %s: %m",
bindhost[i]);
nfsd_exit(1);
}
freeaddrinfo(ai_udp6);
nfsdargs.sock = sock;
nfsdargs.name = NULL;
nfsdargs.namelen = 0;
if (nfssvc(NFSSVC_ADDSOCK, &nfsdargs) < 0) {
syslog(LOG_ERR,
"can't add UDP6 socket");
nfsd_exit(1);
}
close(sock);
}
}
if (rpcbreg == 1) {
memset(&hints, 0, sizeof hints);
hints.ai_flags = AI_PASSIVE;
hints.ai_family = AF_INET6;
hints.ai_socktype = SOCK_DGRAM;
hints.ai_protocol = IPPROTO_UDP;
ecode = getaddrinfo(NULL, "nfs", &hints, &ai_udp6);
if (ecode != 0) {
syslog(LOG_ERR, "getaddrinfo udp6: %s",
gai_strerror(ecode));
nfsd_exit(1);
}
nconf_udp6 = getnetconfigent("udp6");
if (nconf_udp6 == NULL)
err(1, "getnetconfigent udp6 failed");
nb_udp6.buf = ai_udp6->ai_addr;
nb_udp6.len = nb_udp6.maxlen = ai_udp6->ai_addrlen;
if ((!rpcb_set(RPCPROG_NFS, 2, nconf_udp6, &nb_udp6)) ||
(!rpcb_set(RPCPROG_NFS, 3, nconf_udp6, &nb_udp6)))
err(1, "rpcb_set udp6 failed");
freeaddrinfo(ai_udp6);
}
}
/* Set up the socket for tcp and rpcb register it. */
if (tcpflag) {
rpcbreg = 0;
for (i = 0; i < bindhostc; i++) {
memset(&hints, 0, sizeof hints);
hints.ai_flags = AI_PASSIVE;
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
if (setbindhost(&ai_tcp, bindhost[i], hints) == 0) {
rpcbreg = 1;
rpcbregcnt++;
if ((tcpsock = socket(AF_INET, SOCK_STREAM,
0)) < 0) {
syslog(LOG_ERR,
"can't create tpc socket");
nfsd_exit(1);
}
if (setsockopt(tcpsock, SOL_SOCKET,
SO_REUSEADDR,
(char *)&on, sizeof(on)) < 0)
syslog(LOG_ERR,
"setsockopt SO_REUSEADDR: %m");
if (bind(tcpsock, ai_tcp->ai_addr,
ai_tcp->ai_addrlen) < 0) {
syslog(LOG_ERR,
"can't bind tcp addr %s: %m",
bindhost[i]);
nfsd_exit(1);
}
if (listen(tcpsock, 64) < 0) {
syslog(LOG_ERR, "listen failed");
nfsd_exit(1);
}
freeaddrinfo(ai_tcp);
FD_SET(tcpsock, &sockbits);
FD_SET(tcpsock, &v4bits);
maxsock = tcpsock;
connect_type_cnt++;
}
}
if (rpcbreg == 1) {
memset(&hints, 0, sizeof hints);
hints.ai_flags = AI_PASSIVE;
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
ecode = getaddrinfo(NULL, "nfs", &hints,
&ai_tcp);
if (ecode != 0) {
syslog(LOG_ERR, "getaddrinfo tcp: %s",
gai_strerror(ecode));
nfsd_exit(1);
}
nconf_tcp = getnetconfigent("tcp");
if (nconf_tcp == NULL)
err(1, "getnetconfigent tcp failed");
nb_tcp.buf = ai_tcp->ai_addr;
nb_tcp.len = nb_tcp.maxlen = ai_tcp->ai_addrlen;
if ((!rpcb_set(RPCPROG_NFS, 2, nconf_tcp,
&nb_tcp)) || (!rpcb_set(RPCPROG_NFS, 3,
nconf_tcp, &nb_tcp)))
err(1, "rpcb_set tcp failed");
freeaddrinfo(ai_tcp);
}
}
/* Set up the socket for tcp6 and rpcb register it. */
if (tcpflag && ip6flag) {
rpcbreg = 0;
for (i = 0; i < bindhostc; i++) {
memset(&hints, 0, sizeof hints);
hints.ai_flags = AI_PASSIVE;
hints.ai_family = AF_INET6;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
if (setbindhost(&ai_tcp6, bindhost[i], hints) == 0) {
rpcbreg = 1;
rpcbregcnt++;
if ((tcp6sock = socket(ai_tcp6->ai_family,
ai_tcp6->ai_socktype,
ai_tcp6->ai_protocol)) < 0) {
syslog(LOG_ERR,
"can't create tcp6 socket");
nfsd_exit(1);
}
if (setsockopt(tcp6sock, SOL_SOCKET,
SO_REUSEADDR,
(char *)&on, sizeof(on)) < 0)
syslog(LOG_ERR,
"setsockopt SO_REUSEADDR: %m");
if (setsockopt(tcp6sock, IPPROTO_IPV6,
IPV6_V6ONLY, &on, sizeof on) < 0) {
syslog(LOG_ERR,
"can't set v6-only binding for tcp6 "
"socket: %m");
nfsd_exit(1);
}
if (bind(tcp6sock, ai_tcp6->ai_addr,
ai_tcp6->ai_addrlen) < 0) {
syslog(LOG_ERR,
"can't bind tcp6 addr %s: %m",
bindhost[i]);
nfsd_exit(1);
}
if (listen(tcp6sock, 64) < 0) {
syslog(LOG_ERR, "listen failed");
nfsd_exit(1);
}
freeaddrinfo(ai_tcp6);
FD_SET(tcp6sock, &sockbits);
FD_SET(tcp6sock, &v6bits);
if (maxsock < tcp6sock)
maxsock = tcp6sock;
connect_type_cnt++;
}
}
if (rpcbreg == 1) {
memset(&hints, 0, sizeof hints);
hints.ai_flags = AI_PASSIVE;
hints.ai_family = AF_INET6;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
ecode = getaddrinfo(NULL, "nfs", &hints, &ai_tcp6);
if (ecode != 0) {
syslog(LOG_ERR, "getaddrinfo tcp6: %s",
gai_strerror(ecode));
nfsd_exit(1);
}
nconf_tcp6 = getnetconfigent("tcp6");
if (nconf_tcp6 == NULL)
err(1, "getnetconfigent tcp6 failed");
nb_tcp6.buf = ai_tcp6->ai_addr;
nb_tcp6.len = nb_tcp6.maxlen = ai_tcp6->ai_addrlen;
if ((!rpcb_set(RPCPROG_NFS, 2, nconf_tcp6, &nb_tcp6)) ||
(!rpcb_set(RPCPROG_NFS, 3, nconf_tcp6, &nb_tcp6)))
err(1, "rpcb_set tcp6 failed");
freeaddrinfo(ai_tcp6);
}
}
if (rpcbregcnt == 0) {
syslog(LOG_ERR, "rpcb_set() failed, nothing to do: %m");
nfsd_exit(1);
}
if (tcpflag && connect_type_cnt == 0) {
syslog(LOG_ERR, "tcp connects == 0, nothing to do: %m");
nfsd_exit(1);
}
setproctitle("master");
/*
* We always want a master to have a clean way to to shut nfsd down
* (with unregistration): if the master is killed, it unregisters and
* kills all children. If we run for UDP only (and so do not have to
* loop waiting waiting for accept), we instead make the parent
* a "server" too. start_server will not return.
*/
if (!tcpflag)
start_server(1);
/*
* Loop forever accepting connections and passing the sockets
* into the kernel for the mounts.
*/
for (;;) {
ready = sockbits;
if (connect_type_cnt > 1) {
if (select(maxsock + 1,
&ready, NULL, NULL, NULL) < 1) {
syslog(LOG_ERR, "select failed: %m");
if (errno == EINTR)
continue;
nfsd_exit(1);
}
}
for (tcpsock = 0; tcpsock <= maxsock; tcpsock++) {
if (FD_ISSET(tcpsock, &ready)) {
if (FD_ISSET(tcpsock, &v4bits)) {
len = sizeof(inetpeer);
if ((msgsock = accept(tcpsock,
(struct sockaddr *)&inetpeer, &len)) < 0) {
syslog(LOG_ERR, "accept failed: %m");
if (errno == ECONNABORTED ||
errno == EINTR)
continue;
nfsd_exit(1);
}
memset(inetpeer.sin_zero, 0,
sizeof(inetpeer.sin_zero));
if (setsockopt(msgsock, SOL_SOCKET,
SO_KEEPALIVE, (char *)&on, sizeof(on)) < 0)
syslog(LOG_ERR,
"setsockopt SO_KEEPALIVE: %m");
nfsdargs.sock = msgsock;
nfsdargs.name = (caddr_t)&inetpeer;
nfsdargs.namelen = len;
nfssvc(NFSSVC_ADDSOCK, &nfsdargs);
close(msgsock);
} else if (FD_ISSET(tcpsock, &v6bits)) {
len = sizeof(inet6peer);
if ((msgsock = accept(tcpsock,
(struct sockaddr *)&inet6peer,
&len)) < 0) {
syslog(LOG_ERR,
"accept failed: %m");
if (errno == ECONNABORTED ||
errno == EINTR)
continue;
nfsd_exit(1);
}
if (setsockopt(msgsock, SOL_SOCKET,
SO_KEEPALIVE, (char *)&on,
sizeof(on)) < 0)
syslog(LOG_ERR, "setsockopt "
"SO_KEEPALIVE: %m");
nfsdargs.sock = msgsock;
nfsdargs.name = (caddr_t)&inet6peer;
nfsdargs.namelen = len;
nfssvc(NFSSVC_ADDSOCK, &nfsdargs);
close(msgsock);
}
}
}
}
}
/*
* Called after all the create_service() calls have succeeded, to complete
* the setup and registration.
*/
static void
complete_service(struct netconfig *nconf, char *port_str)
{
struct addrinfo hints, *res = NULL;
struct __rpc_sockinfo si;
struct netbuf servaddr;
SVCXPRT *transp = NULL;
int aicode, fd, nhostsbak;
int registered = 0;
if ((nconf->nc_semantics != NC_TPI_CLTS) &&
(nconf->nc_semantics != NC_TPI_COTS) &&
(nconf->nc_semantics != NC_TPI_COTS_ORD))
return; /* not my type */
/*
* XXX - using RPC library internal functions.
*/
if (!__rpc_nconf2sockinfo(nconf, &si)) {
syslog(LOG_ERR, "cannot get information for %s",
nconf->nc_netid);
return;
}
nhostsbak = nhosts;
while (nhostsbak > 0) {
--nhostsbak;
if (sock_fdpos >= sock_fdcnt) {
/* Should never happen. */
syslog(LOG_ERR, "Ran out of socket fd's");
return;
}
fd = sock_fd[sock_fdpos++];
if (fd < 0)
continue;
if (nconf->nc_semantics != NC_TPI_CLTS)
listen(fd, SOMAXCONN);
transp = svc_tli_create(fd, nconf, NULL,
RPC_MAXDATASIZE, RPC_MAXDATASIZE);
if (transp != (SVCXPRT *) NULL) {
if (!svc_register(transp, SM_PROG, SM_VERS,
sm_prog_1, 0)) {
syslog(LOG_ERR, "can't register on %s",
nconf->nc_netid);
} else {
if (!svc_reg(transp, SM_PROG, SM_VERS,
sm_prog_1, NULL))
syslog(LOG_ERR,
"can't register %s SM_PROG service",
nconf->nc_netid);
}
} else
syslog(LOG_WARNING, "can't create %s services",
nconf->nc_netid);
if (registered == 0) {
registered = 1;
memset(&hints, 0, sizeof hints);
hints.ai_flags = AI_PASSIVE;
hints.ai_family = si.si_af;
hints.ai_socktype = si.si_socktype;
hints.ai_protocol = si.si_proto;
if ((aicode = getaddrinfo(NULL, port_str, &hints,
&res)) != 0) {
syslog(LOG_ERR, "cannot get local address: %s",
gai_strerror(aicode));
exit(1);
}
servaddr.buf = malloc(res->ai_addrlen);
memcpy(servaddr.buf, res->ai_addr, res->ai_addrlen);
servaddr.len = res->ai_addrlen;
rpcb_set(SM_PROG, SM_VERS, nconf, &servaddr);
xcreated++;
freeaddrinfo(res);
}
} /* end while */
}
/*
* Add a service program to the callout list.
* The dispatch routine will be called when a rpc request for this
* program number comes in.
*/
bool
svc_reg(SVCXPRT *xprt, const rpcprog_t prog, const rpcvers_t vers,
void (*dispatch) (struct svc_req *req, SVCXPRT *xprt),
const struct netconfig *nconf)
{
bool dummy;
struct svc_callout *prev;
struct svc_callout *s;
struct netconfig *tnconf;
char *netid = NULL;
int flag = 0;
/* VARIABLES PROTECTED BY svc_lock: s, prev, svc_head */
if (xprt->xp_netid) {
netid = mem_strdup(xprt->xp_netid);
flag = 1;
} else if (nconf) {
netid = mem_strdup(nconf->nc_netid);
flag = 1;
} else {
tnconf = __rpcgettp(xprt->xp_fd);
if (tnconf) {
netid = mem_strdup(tnconf->nc_netid);
flag = 1;
freenetconfigent(tnconf);
}
} /* must have been created with svc_raw_create */
if ((netid == NULL) && (flag == 1))
return (false);
rwlock_wrlock(&svc_lock);
s = svc_find(prog, vers, &prev, netid);
if (s) {
if (netid)
mem_free(netid, 0);
if (s->rec.sc_dispatch == dispatch)
goto rpcb_it; /* he is registering another xptr */
rwlock_unlock(&svc_lock);
return (false);
}
s = mem_alloc(sizeof(struct svc_callout));
s->rec.sc_prog = prog;
s->rec.sc_vers = vers;
s->rec.sc_dispatch = dispatch;
s->rec.sc_netid = netid;
s->sc_next = svc_head;
svc_head = s;
if ((xprt->xp_netid == NULL) && (flag == 1) && netid)
((SVCXPRT *) xprt)->xp_netid = mem_strdup(netid);
rpcb_it:
rwlock_unlock(&svc_lock);
/* now register the information with the local binder service */
if (nconf) {
/*LINTED const castaway */
dummy =
rpcb_set(prog, vers, (struct netconfig *)nconf,
&((SVCXPRT *) xprt)->xp_local.nb);
return (dummy);
}
return (true);
}
static int getprognum(long *prognum, SVCXPRT **xprt, char *fd_str,
char *prog_str, long vers, char *tp_type)
{
static ulong_t start = 0x40000000;
int fd;
#ifdef TDRPC
ushort_t port;
int proto;
#else
struct netconfig *nc;
struct netbuf *nb;
#endif
/* If prognum specified, use it instead of transient hassel. */
if (*prognum) {
*xprt = NULL;
sprintf(fd_str, "-1"); /* have child close all fds */
sprintf(prog_str, "%u", *prognum);
return (TRUE);
}
/*
* Transient hassel:
* - parent must create mapping since someone else could
* steal the transient prognum before child created it
* - pass the child the fd to use for service
* - close the fd (after exec), free xprt, leave mapping intact
*/
#ifdef TDRPC
if (strcmp(tp_type, "udp") != 0) {
proto = IPPROTO_UDP;
*xprt = svcudp_bufcreate(RPC_ANYSOCK, 0, 0);
} else {
proto = IPPROTO_TCP;
*xprt = svctcp_create(RPC_ANYSOCK, 0, 0);
}
if (*xprt == NULL)
return (FALSE);
port = (*xprt)->xp_port;
fd = (*xprt)->xp_sock;
while (!pmap_set(start, vers, proto, port))
start++;
#else
/* tp_type is legit: users choice or a loopback netid */
if ((nc = getnetconfigent(tp_type)) == NULL)
return (FALSE);
if ((*xprt = svc_tli_create(RPC_ANYFD, nc, NULL, 0, 0)) == NULL) {
freenetconfigent(nc);
return (FALSE);
}
nb = &(*xprt)->xp_ltaddr;
fd = (*xprt)->xp_fd;
while (!rpcb_set(start, vers, nc, nb))
start++;
freenetconfigent(nc);
#endif
*prognum = start;
sprintf(fd_str, "%u", fd);
sprintf(prog_str, "%u", *prognum);
return (TRUE);
}
