/*
* find the IP address that can be used to connect to the local host
*/
void
amu_get_myaddress(struct in_addr *iap)
{
int ret;
voidp handlep;
struct netconfig *ncp;
struct nd_addrlist *addrs = (struct nd_addrlist *) NULL;
struct nd_hostserv service;
handlep = setnetconfig();
ncp = getnetconfig(handlep);
service.h_host = HOST_SELF_CONNECT;
service.h_serv = (char *) NULL;
ret = netdir_getbyname(ncp, &service, &addrs);
if (ret || !addrs || addrs->n_cnt < 1) {
plog(XLOG_FATAL, "cannot get local host address. using 127.0.0.1");
iap->s_addr = 0x7f000001;
} else {
/*
* XXX: there may be more more than one address for this local
* host. Maybe something can be done with those.
*/
struct sockaddr_in *sinp = (struct sockaddr_in *) addrs->n_addrs[0].buf;
iap->s_addr = htonl(sinp->sin_addr.s_addr);
}
endnetconfig(handlep); /* free's up internal resources too */
netdir_free((voidp) addrs, ND_ADDRLIST);
}
/*
* find the IP address that can be used to connect autofs service to.
*/
static int
get_autofs_address(struct netconfig *ncp, struct t_bind *tbp)
{
int ret;
struct nd_addrlist *addrs = (struct nd_addrlist *) NULL;
struct nd_hostserv service;
service.h_host = HOST_SELF_CONNECT;
service.h_serv = "autofs";
ret = netdir_getbyname(ncp, &service, &addrs);
if (ret) {
plog(XLOG_FATAL, "get_autofs_address: cannot get local host address: %s", netdir_sperror());
goto out;
}
/*
* XXX: there may be more more than one address for this local
* host. Maybe something can be done with those.
*/
tbp->addr.len = addrs->n_addrs->len;
tbp->addr.maxlen = addrs->n_addrs->len;
memcpy(tbp->addr.buf, addrs->n_addrs->buf, addrs->n_addrs->len);
tbp->qlen = 8; /* arbitrary? who cares really */
/* all OK */
netdir_free((voidp) addrs, ND_ADDRLIST);
out:
return ret;
}
/*
* find the IP address that can be used to connect to the local host
*/
void
amu_get_myaddress(struct in_addr *iap, const char *preferred_localhost)
{
int ret;
voidp handlep;
struct netconfig *ncp;
struct nd_addrlist *addrs = (struct nd_addrlist *) NULL;
struct nd_hostserv service;
handlep = setnetconfig();
ncp = getnetconfig(handlep);
service.h_host = (preferred_localhost ? (char *) preferred_localhost : HOST_SELF_CONNECT);
service.h_serv = (char *) NULL;
ret = netdir_getbyname(ncp, &service, &addrs);
if (ret || !addrs || addrs->n_cnt < 1) {
plog(XLOG_FATAL, "cannot get local host address. using 127.0.0.1");
iap->s_addr = htonl(INADDR_LOOPBACK);
} else {
/*
* XXX: there may be more more than one address for this local
* host. Maybe something can be done with those.
*/
struct sockaddr_in *sinp = (struct sockaddr_in *) addrs->n_addrs[0].buf;
char dq[20];
if (preferred_localhost)
plog(XLOG_INFO, "localhost_address \"%s\" requested, using %s",
preferred_localhost, inet_dquad(dq, sizeof(dq), iap->s_addr));
iap->s_addr = sinp->sin_addr.s_addr; /* XXX: used to be htonl() */
}
endnetconfig(handlep); /* free's up internal resources too */
netdir_free((voidp) addrs, ND_ADDRLIST);
}
char *
get_uaddr(int fd, struct netconfig *nconf, struct netbuf *nb)
{
struct nfs_svc_args nsa;
char *ua, *ua2, *mua = NULL;
char me[MAXHOSTNAMELEN];
struct nd_addrlist *nas;
struct nd_hostserv hs;
struct nd_mergearg ma;
ua = taddr2uaddr(nconf, nb);
if (ua == NULL) {
#ifdef DEBUG
fprintf(stderr, "taddr2uaddr failed for netid %s\n",
nconf->nc_netid);
#endif
return (NULL);
}
gethostname(me, MAXHOSTNAMELEN);
hs.h_host = me;
hs.h_serv = "nfs";
if (netdir_getbyname(nconf, &hs, &nas)) {
#ifdef DEBUG
netdir_perror("netdir_getbyname");
#endif
return (NULL);
}
ua2 = taddr2uaddr(nconf, nas->n_addrs);
if (ua2 == NULL) {
#ifdef DEBUG
fprintf(stderr, "taddr2uaddr failed for netid %s.\n",
nconf->nc_netid);
#endif
return (NULL);
}
ma.s_uaddr = ua;
ma.c_uaddr = ua2;
ma.m_uaddr = NULL;
if (netdir_options(nconf, ND_MERGEADDR, 0, (char *)&ma)) {
#ifdef DEBUG
netdir_perror("netdir_options");
#endif
return (NULL);
}
mua = ma.m_uaddr;
return (mua);
}
static int
TRANS(TLIAddrToNetbuf)(int tlifamily, char *host, char *port,
struct netbuf *netbufp)
{
struct netconfig *netconfigp;
struct nd_hostserv nd_hostserv;
struct nd_addrlist *nd_addrlistp = NULL;
void *handlep;
long lport;
prmsg(3,"TLIAddrToNetbuf(%d,%s,%s)\n", tlifamily, host, port );
if( (handlep=setnetconfig()) == NULL )
return -1;
lport = strtol (port, (char**)NULL, 10);
if (lport < 1024 || lport > USHRT_MAX)
return -1;
nd_hostserv.h_host = host;
if( port && *port ) {
nd_hostserv.h_serv = port;
} else {
nd_hostserv.h_serv = NULL;
}
while( (netconfigp=getnetconfig(handlep)) != NULL )
{
if( strcmp(netconfigp->nc_protofmly,
TLItrans2devtab[tlifamily].protofamily) != 0 )
continue;
prmsg(5,"TLIAddrToNetbuf: Trying to resolve %s.%s for %s\n",
host, port, TLItrans2devtab[tlifamily].protofamily );
if( netdir_getbyname(netconfigp,&nd_hostserv, &nd_addrlistp) == 0 )
{
/* we have at least one address to use */
prmsg(5, "TLIAddrToNetbuf: found address for %s.%s\n", host, port);
prmsg(5, "TLIAddrToNetbuf: %s\n",taddr2uaddr(netconfigp,nd_addrlistp->n_addrs));
memcpy(netbufp->buf,nd_addrlistp->n_addrs->buf,
nd_addrlistp->n_addrs->len);
netbufp->len=nd_addrlistp->n_addrs->len;
endnetconfig(handlep);
return 0;
}
}
endnetconfig(handlep);
return -1;
}
int
do_connect(const char *host, const char *serv)
{
int tfd, i;
void *handle;
struct t_call tcall;
struct t_discon tdiscon;
struct netconfig *ncp;
struct nd_hostserv hs;
struct nd_addrlist *alp;
struct netbuf *np;
handle = Setnetpath();
hs.h_host = (char *) host;
hs.h_serv = (char *) serv;
while ( (ncp = getnetpath(handle)) != NULL) {
if (strcmp(ncp->nc_netid, "ticotsord") != 0)
continue;
if (netdir_getbyname(ncp, &hs, &alp) != 0)
continue;
/* try each server address */
for (i = 0, np = alp->n_addrs; i < alp->n_cnt; i++, np++) {
printf("device = %s\n", ncp->nc_device);
if ( (tfd = t_open(ncp->nc_device, O_RDWR, NULL)) < 0)
err_xti("t_open error for %s", ncp->nc_device);
if (t_bind(tfd, NULL, NULL) < 0)
err_xti("t_bind error");
tcall.addr.len = np->len;
tcall.addr.buf = np->buf; /* pointer copy */
printf("addr.len = %d\n", tcall.addr.len);
printf("addr.buf = %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
tcall.addr.buf[0], tcall.addr.buf[1],
tcall.addr.buf[2], tcall.addr.buf[3],
tcall.addr.buf[4], tcall.addr.buf[5],
tcall.addr.buf[6], tcall.addr.buf[7],
tcall.addr.buf[8], tcall.addr.buf[9],
tcall.addr.buf[10]);
}
netdir_free(alp, ND_ADDRLIST);
}
endnetpath(handle);
return(-1);
}
int
udp_client(const char *host, const char *serv, void **vptr, socklen_t *lenp)
{
int tfd;
void *handle;
struct netconfig *ncp;
struct nd_hostserv hs;
struct nd_addrlist *alp;
struct netbuf *np;
struct t_unitdata *tudptr;
handle = Setnetpath();
hs.h_host = (char *) host;
hs.h_serv = (char *) serv;
while ( (ncp = getnetpath(handle)) != NULL) {
if (strcmp(ncp->nc_proto, "udp") != 0)
continue;
if (netdir_getbyname(ncp, &hs, &alp) != 0)
continue;
tfd = T_open(ncp->nc_device, O_RDWR, NULL);
T_bind(tfd, NULL, NULL);
tudptr = T_alloc(tfd, T_UNITDATA, T_ADDR);
np = alp->n_addrs; /* use first server address */
tudptr->addr.len = min(tudptr->addr.maxlen, np->len);
memcpy(tudptr->addr.buf, np->buf, tudptr->addr.len);
endnetpath(handle);
netdir_free(alp, ND_ADDRLIST);
*vptr = tudptr; /* return pointer to t_unitdata{} */
*lenp = tudptr->addr.maxlen;/* and size of addresses */
return(tfd);
}
endnetpath(handle);
return(-1);
}
int
udp_server(const char *host, const char *serv, socklen_t *addrlenp)
{
int tfd;
void *handle;
struct t_bind tbind;
struct t_info tinfo;
struct netconfig *ncp;
struct nd_hostserv hs;
struct nd_addrlist *alp;
struct netbuf *np;
handle = Setnetconfig();
hs.h_host = (host == NULL) ? HOST_SELF : (char *) host;
hs.h_serv = (char *) serv;
while ( (ncp = getnetconfig(handle)) != NULL &&
strcmp(ncp->nc_proto, "udp") != 0)
;
if (ncp == NULL)
return(-1);
if (netdir_getbyname(ncp, &hs, &alp) != 0)
return(-2);
np = alp->n_addrs; /* use first address */
tfd = T_open(ncp->nc_device, O_RDWR, &tinfo);
tbind.addr = *np; /* copy entire netbuf{} */
tbind.qlen = 0; /* not used for connectionless server */
T_bind(tfd, &tbind, NULL);
endnetconfig(handle);
netdir_free(alp, ND_ADDRLIST);
if (addrlenp)
*addrlenp = tinfo.addr; /* size of protocol addresses */
return(tfd);
}
static char *
get_uaddr(struct netconfig *nconf, struct netbuf *nb)
{
struct nfs_svc_args nsa;
char *ua, *ua2, *mua = NULL;
char me[MAXHOSTNAMELEN];
struct nd_addrlist *nas;
struct nd_hostserv hs;
struct nd_mergearg ma;
ua = taddr2uaddr(nconf, nb);
if (ua == NULL) {
return (NULL);
}
gethostname(me, MAXHOSTNAMELEN);
hs.h_host = me;
hs.h_serv = "nfs";
if (netdir_getbyname(nconf, &hs, &nas)) {
return (NULL);
}
ua2 = taddr2uaddr(nconf, nas->n_addrs);
if (ua2 == NULL) {
return (NULL);
}
ma.s_uaddr = ua;
ma.c_uaddr = ua2;
ma.m_uaddr = NULL;
if (netdir_options(nconf, ND_MERGEADDR, 0, (char *)&ma)) {
return (NULL);
}
mua = ma.m_uaddr;
return (mua);
}
/*
* This routine is designed to be able to "ping"
* a list of hosts and create a list of responding
* hosts sorted by response time.
* This must be done without any prior
* contact with the host - therefore the "ping"
* must be to a "well-known" address. The outstanding
* candidate here is the address of "rpcbind".
*
* A response to a ping is no guarantee that the host
* is running NFS, has a mount daemon, or exports
* the required filesystem. If the subsequent
* mount attempt fails then the host will be marked
* "ignore" and the host list will be re-pinged
* (sans the bad host). This process continues
* until a successful mount is achieved or until
* there are no hosts left to try.
*/
enum clnt_stat
nfs_cast(struct mapfs *mfs_in, struct mapfs **mfs_out, int timeout)
{
enum clnt_stat stat;
AUTH *sys_auth = authsys_create_default();
XDR xdr_stream;
register XDR *xdrs = &xdr_stream;
int outlen;
int if_inx;
int tsec;
int flag;
int sent, addr_cnt, rcvd, if_cnt;
fd_set readfds, mask;
register ulong_t xid; /* xid - unique per addr */
register int i;
struct rpc_msg msg;
struct timeval t, rcv_timeout;
char outbuf[UDPMSGSIZE], inbuf[UDPMSGSIZE];
struct t_unitdata t_udata, t_rdata;
struct nd_hostserv hs;
struct nd_addrlist *retaddrs;
struct transp *tr_head;
struct transp *trans, *prev_trans;
struct addrs *a, *prev_addr;
struct tstamps *ts, *prev_ts;
NCONF_HANDLE *nc = NULL;
struct netconfig *nconf;
struct rlimit rl;
int dtbsize;
struct mapfs *mfs;
/*
* For each connectionless transport get a list of
* host addresses. Any single host may have
* addresses on several transports.
*/
addr_cnt = sent = rcvd = 0;
tr_head = NULL;
FD_ZERO(&mask);
/*
* Set the default select size to be the maximum FD_SETSIZE, unless
* the current rlimit is lower.
*/
dtbsize = FD_SETSIZE;
if (getrlimit(RLIMIT_NOFILE, &rl) == 0) {
if (rl.rlim_cur < FD_SETSIZE)
dtbsize = rl.rlim_cur;
}
prev_trans = NULL;
prev_addr = NULL;
prev_ts = NULL;
for (mfs = mfs_in; mfs; mfs = mfs->mfs_next) {
if (trace > 2)
trace_prt(1, "nfs_cast: host=%s\n", mfs->mfs_host);
nc = setnetconfig();
if (nc == NULL) {
stat = RPC_CANTSEND;
goto done_broad;
}
while (nconf = getnetconfig(nc)) {
if (!(nconf->nc_flag & NC_VISIBLE) ||
nconf->nc_semantics != NC_TPI_CLTS ||
(strcmp(nconf->nc_protofmly, NC_LOOPBACK) == 0))
continue;
trans = (struct transp *)malloc(sizeof (*trans));
if (trans == NULL) {
syslog(LOG_ERR, "no memory");
stat = RPC_CANTSEND;
goto done_broad;
}
(void) memset(trans, 0, sizeof (*trans));
if (tr_head == NULL)
tr_head = trans;
else
prev_trans->tr_next = trans;
prev_trans = trans;
trans->tr_fd = t_open(nconf->nc_device, O_RDWR, NULL);
if (trans->tr_fd < 0) {
syslog(LOG_ERR, "nfscast: t_open: %s:%m",
nconf->nc_device);
stat = RPC_CANTSEND;
goto done_broad;
}
if (t_bind(trans->tr_fd, (struct t_bind *)NULL,
(struct t_bind *)NULL) < 0) {
syslog(LOG_ERR, "nfscast: t_bind: %m");
stat = RPC_CANTSEND;
goto done_broad;
}
trans->tr_taddr =
/* LINTED pointer alignment */
(struct t_bind *)t_alloc(trans->tr_fd, T_BIND, T_ADDR);
if (trans->tr_taddr == (struct t_bind *)NULL) {
syslog(LOG_ERR, "nfscast: t_alloc: %m");
stat = RPC_SYSTEMERROR;
goto done_broad;
}
trans->tr_device = nconf->nc_device;
FD_SET(trans->tr_fd, &mask);
if_inx = 0;
hs.h_host = mfs->mfs_host;
hs.h_serv = "rpcbind";
if (netdir_getbyname(nconf, &hs, &retaddrs) == ND_OK) {
/*
* If mfs->ignore is previously set for
* this map, clear it. Because a host can
* have either v6 or v4 address
*/
if (mfs->mfs_ignore == 1)
mfs->mfs_ignore = 0;
a = (struct addrs *)malloc(sizeof (*a));
if (a == NULL) {
syslog(LOG_ERR, "no memory");
stat = RPC_CANTSEND;
goto done_broad;
}
(void) memset(a, 0, sizeof (*a));
if (trans->tr_addrs == NULL)
trans->tr_addrs = a;
else
prev_addr->addr_next = a;
prev_addr = a;
a->addr_if_tstamps = NULL;
a->addr_mfs = mfs;
a->addr_addrs = retaddrs;
if_cnt = retaddrs->n_cnt;
while (if_cnt--) {
ts = (struct tstamps *)
malloc(sizeof (*ts));
if (ts == NULL) {
syslog(LOG_ERR, "no memory");
stat = RPC_CANTSEND;
goto done_broad;
}
(void) memset(ts, 0, sizeof (*ts));
ts->ts_penalty = mfs->mfs_penalty;
if (a->addr_if_tstamps == NULL)
a->addr_if_tstamps = ts;
else
prev_ts->ts_next = ts;
prev_ts = ts;
ts->ts_inx = if_inx++;
addr_cnt++;
}
break;
} else {
mfs->mfs_ignore = 1;
if (verbose)
syslog(LOG_ERR,
"%s:%s address not known",
mfs->mfs_host,
strcmp(nconf->nc_proto, NC_INET)?"IPv6":"IPv4");
}
} /* while */
endnetconfig(nc);
nc = NULL;
} /* for */
if (addr_cnt == 0) {
syslog(LOG_ERR, "nfscast: couldn't find addresses");
stat = RPC_CANTSEND;
goto done_broad;
}
(void) gettimeofday(&t, (struct timezone *)0);
xid = (getpid() ^ t.tv_sec ^ t.tv_usec) & ~0xFF;
t.tv_usec = 0;
/* serialize the RPC header */
msg.rm_direction = CALL;
msg.rm_call.cb_rpcvers = RPC_MSG_VERSION;
msg.rm_call.cb_prog = RPCBPROG;
/*
* we can not use RPCBVERS here since it doesn't exist in 4.X,
* the fix to bug 1139883 has made the 4.X portmapper silent to
* version mismatches. This causes the RPC call to the remote
* portmapper to simply be ignored if it's not Version 2.
*/
msg.rm_call.cb_vers = PMAPVERS;
msg.rm_call.cb_proc = NULLPROC;
if (sys_auth == (AUTH *)NULL) {
stat = RPC_SYSTEMERROR;
goto done_broad;
}
msg.rm_call.cb_cred = sys_auth->ah_cred;
msg.rm_call.cb_verf = sys_auth->ah_verf;
xdrmem_create(xdrs, outbuf, sizeof (outbuf), XDR_ENCODE);
if (! xdr_callmsg(xdrs, &msg)) {
stat = RPC_CANTENCODEARGS;
goto done_broad;
}
outlen = (int)xdr_getpos(xdrs);
xdr_destroy(xdrs);
t_udata.opt.len = 0;
t_udata.udata.buf = outbuf;
t_udata.udata.len = outlen;
/*
* Basic loop: send packet to all hosts and wait for response(s).
* The response timeout grows larger per iteration.
* A unique xid is assigned to each address in order to
* correctly match the replies.
*/
for (tsec = 4; timeout > 0; tsec *= 2) {
timeout -= tsec;
if (timeout <= 0)
tsec += timeout;
rcv_timeout.tv_sec = tsec;
rcv_timeout.tv_usec = 0;
sent = 0;
for (trans = tr_head; trans; trans = trans->tr_next) {
for (a = trans->tr_addrs; a; a = a->addr_next) {
struct netbuf *if_netbuf =
a->addr_addrs->n_addrs;
ts = a->addr_if_tstamps;
if_cnt = a->addr_addrs->n_cnt;
while (if_cnt--) {
/*
* xid is the first thing in
* preserialized buffer
*/
/* LINTED pointer alignment */
*((ulong_t *)outbuf) =
htonl(xid + ts->ts_inx);
(void) gettimeofday(&(ts->ts_timeval),
(struct timezone *)0);
/*
* Check if already received
* from a previous iteration.
*/
if (ts->ts_rcvd) {
sent++;
ts = ts->ts_next;
continue;
}
t_udata.addr = *if_netbuf++;
if (t_sndudata(trans->tr_fd,
&t_udata) == 0) {
sent++;
}
ts = ts->ts_next;
}
}
}
if (sent == 0) { /* no packets sent ? */
stat = RPC_CANTSEND;
goto done_broad;
}
/*
* Have sent all the packets. Now collect the responses...
*/
rcvd = 0;
recv_again:
msg.acpted_rply.ar_verf = _null_auth;
msg.acpted_rply.ar_results.proc = xdr_void;
readfds = mask;
switch (select(dtbsize, &readfds,
(fd_set *)NULL, (fd_set *)NULL, &rcv_timeout)) {
case 0: /* Timed out */
/*
* If we got at least one response in the
* last interval, then don't wait for any
* more. In theory we should wait for
* the max weighting (penalty) value so
* that a very slow server has a chance to
* respond but this could take a long time
* if the admin has set a high weighting
* value.
*/
if (rcvd > 0)
goto done_broad;
stat = RPC_TIMEDOUT;
continue;
case -1: /* some kind of error */
if (errno == EINTR)
goto recv_again;
syslog(LOG_ERR, "nfscast: select: %m");
if (rcvd == 0)
stat = RPC_CANTRECV;
goto done_broad;
} /* end of select results switch */
for (trans = tr_head; trans; trans = trans->tr_next) {
if (FD_ISSET(trans->tr_fd, &readfds))
break;
}
if (trans == NULL)
goto recv_again;
try_again:
t_rdata.addr = trans->tr_taddr->addr;
t_rdata.udata.buf = inbuf;
t_rdata.udata.maxlen = sizeof (inbuf);
t_rdata.udata.len = 0;
t_rdata.opt.len = 0;
if (t_rcvudata(trans->tr_fd, &t_rdata, &flag) < 0) {
if (errno == EINTR)
goto try_again;
syslog(LOG_ERR, "nfscast: t_rcvudata: %s:%m",
trans->tr_device);
stat = RPC_CANTRECV;
continue;
}
if (t_rdata.udata.len < sizeof (ulong_t))
goto recv_again;
if (flag & T_MORE) {
syslog(LOG_ERR,
"nfscast: t_rcvudata: %s: buffer overflow",
trans->tr_device);
goto recv_again;
}
/*
* see if reply transaction id matches sent id.
* If so, decode the results.
* Note: received addr is ignored, it could be
* different from the send addr if the host has
* more than one addr.
*/
xdrmem_create(xdrs, inbuf, (uint_t)t_rdata.udata.len,
XDR_DECODE);
if (xdr_replymsg(xdrs, &msg)) {
if (msg.rm_reply.rp_stat == MSG_ACCEPTED &&
(msg.rm_xid & ~0xFF) == xid) {
struct addrs *curr_addr;
i = msg.rm_xid & 0xFF;
for (curr_addr = trans->tr_addrs; curr_addr;
curr_addr = curr_addr->addr_next) {
for (ts = curr_addr->addr_if_tstamps; ts;
ts = ts->ts_next)
if (ts->ts_inx == i && !ts->ts_rcvd) {
ts->ts_rcvd = 1;
calc_resp_time(&ts->ts_timeval);
stat = RPC_SUCCESS;
rcvd++;
break;
}
}
} /* otherwise, we just ignore the errors ... */
}
xdrs->x_op = XDR_FREE;
msg.acpted_rply.ar_results.proc = xdr_void;
(void) xdr_replymsg(xdrs, &msg);
XDR_DESTROY(xdrs);
if (rcvd == sent)
goto done_broad;
else
goto recv_again;
}
if (!rcvd)
stat = RPC_TIMEDOUT;
done_broad:
if (rcvd) {
*mfs_out = sort_responses(tr_head);
stat = RPC_SUCCESS;
}
if (nc)
endnetconfig(nc);
free_transports(tr_head);
AUTH_DESTROY(sys_auth);
return (stat);
}
int
nfslib_bindit(struct netconfig *nconf, struct netbuf **addr,
struct nd_hostserv *hs, int backlog)
{
int fd;
struct t_bind *ntb;
struct t_bind tb;
struct nd_addrlist *addrlist;
struct t_optmgmt req, resp;
struct opthdr *opt;
char reqbuf[128];
bool_t use_any = FALSE;
bool_t gzone = TRUE;
if ((fd = nfslib_transport_open(nconf)) == -1) {
syslog(LOG_ERR, "cannot establish transport service over %s",
nconf->nc_device);
return (-1);
}
addrlist = (struct nd_addrlist *)NULL;
/* nfs4_callback service does not used a fieed port number */
if (strcmp(hs->h_serv, "nfs4_callback") == 0) {
tb.addr.maxlen = 0;
tb.addr.len = 0;
tb.addr.buf = 0;
use_any = TRUE;
gzone = (getzoneid() == GLOBAL_ZONEID);
} else if (netdir_getbyname(nconf, hs, &addrlist) != 0) {
syslog(LOG_ERR,
"Cannot get address for transport %s host %s service %s",
nconf->nc_netid, hs->h_host, hs->h_serv);
(void) t_close(fd);
return (-1);
}
if (strcmp(nconf->nc_proto, "tcp") == 0) {
/*
* If we're running over TCP, then set the
* SO_REUSEADDR option so that we can bind
* to our preferred address even if previously
* left connections exist in FIN_WAIT states.
* This is somewhat bogus, but otherwise you have
* to wait 2 minutes to restart after killing it.
*/
if (reuseaddr(fd) == -1) {
syslog(LOG_WARNING,
"couldn't set SO_REUSEADDR option on transport");
}
} else if (strcmp(nconf->nc_proto, "udp") == 0) {
/*
* In order to run MLP on UDP, we need to handle creds.
*/
if (recvucred(fd) == -1) {
syslog(LOG_WARNING,
"couldn't set SO_RECVUCRED option on transport");
}
}
/*
* Make non global zone nfs4_callback port MLP
*/
if (use_any && is_system_labeled() && !gzone) {
if (anonmlp(fd) == -1) {
/*
* failing to set this option means nfs4_callback
* could fail silently later. So fail it with
* with an error message now.
*/
syslog(LOG_ERR,
"couldn't set SO_ANON_MLP option on transport");
(void) t_close(fd);
return (-1);
}
}
if (nconf->nc_semantics == NC_TPI_CLTS)
tb.qlen = 0;
else
tb.qlen = backlog;
/* LINTED pointer alignment */
ntb = (struct t_bind *)t_alloc(fd, T_BIND, T_ALL);
if (ntb == (struct t_bind *)NULL) {
syslog(LOG_ERR, "t_alloc failed: t_errno %d, %m", t_errno);
(void) t_close(fd);
netdir_free((void *)addrlist, ND_ADDRLIST);
return (-1);
}
/*
* XXX - what about the space tb->addr.buf points to? This should
* be either a memcpy() to/from the buf fields, or t_alloc(fd,T_BIND,)
* should't be called with T_ALL.
*/
if (addrlist)
tb.addr = *(addrlist->n_addrs); /* structure copy */
if (t_bind(fd, &tb, ntb) == -1) {
syslog(LOG_ERR, "t_bind failed: t_errno %d, %m", t_errno);
(void) t_free((char *)ntb, T_BIND);
netdir_free((void *)addrlist, ND_ADDRLIST);
(void) t_close(fd);
return (-1);
}
/* make sure we bound to the right address */
if (use_any == FALSE &&
(tb.addr.len != ntb->addr.len ||
memcmp(tb.addr.buf, ntb->addr.buf, tb.addr.len) != 0)) {
syslog(LOG_ERR, "t_bind to wrong address");
(void) t_free((char *)ntb, T_BIND);
netdir_free((void *)addrlist, ND_ADDRLIST);
(void) t_close(fd);
return (-1);
}
/*
* Call nfs4svc_setport so that the kernel can be
* informed what port number the daemon is listing
* for incoming connection requests.
*/
if ((nconf->nc_semantics == NC_TPI_COTS ||
nconf->nc_semantics == NC_TPI_COTS_ORD) && Mysvc4 != NULL)
(*Mysvc4)(fd, NULL, nconf, NFS4_SETPORT, &ntb->addr);
*addr = &ntb->addr;
netdir_free((void *)addrlist, ND_ADDRLIST);
if (strcmp(nconf->nc_proto, "tcp") == 0) {
/*
* Disable the Nagle algorithm on TCP connections.
* Connections accepted from this listener will
* inherit the listener options.
*/
/* LINTED pointer alignment */
opt = (struct opthdr *)reqbuf;
opt->level = IPPROTO_TCP;
opt->name = TCP_NODELAY;
opt->len = sizeof (int);
/* LINTED pointer alignment */
*(int *)((char *)opt + sizeof (*opt)) = 1;
req.flags = T_NEGOTIATE;
req.opt.len = sizeof (*opt) + opt->len;
req.opt.buf = (char *)opt;
resp.flags = 0;
resp.opt.buf = reqbuf;
resp.opt.maxlen = sizeof (reqbuf);
if (t_optmgmt(fd, &req, &resp) < 0 ||
resp.flags != T_SUCCESS) {
syslog(LOG_ERR,
"couldn't set NODELAY option for proto %s: t_errno = %d, %m",
nconf->nc_proto, t_errno);
}
nfslib_set_sockbuf(fd);
}
return (fd);
}
CreateWellKnownSockets ()
{
struct t_bind bind_addr;
struct netconfig *nconf;
struct nd_hostserv service;
struct nd_addrlist *servaddrs;
char *name, *localHostname();
char bindbuf[15];
int it;
if (request_port == 0)
return;
Debug ("creating UDP stream %d\n", request_port);
nconf = getnetconfigent("udp");
if (!nconf) {
t_error("getnetconfigent udp");
return;
}
xdmcpFd = t_open(nconf->nc_device, O_RDWR, NULL);
if (xdmcpFd == -1) {
LogError ("XDMCP stream creation failed\n");
t_error ("t_open");
return;
}
name = localHostname ();
registerHostname (name, strlen (name));
RegisterCloseOnFork (xdmcpFd);
service.h_host = HOST_SELF;
sprintf(bindbuf, "%d", request_port);
service.h_serv = bindbuf;
netdir_getbyname(nconf, &service, &servaddrs);
freenetconfigent(nconf);
bind_addr.qlen = 5;
bind_addr.addr.buf = servaddrs->n_addrs[0].buf;
bind_addr.addr.len = servaddrs->n_addrs[0].len;
it = t_bind(xdmcpFd, &bind_addr, &bind_addr);
netdir_free(servaddrs, ND_ADDRLIST);
if (it < 0)
{
LogError ("error binding STREAMS address %d\n", request_port);
t_error("t_bind"); /* also goes to log file */
t_close (xdmcpFd);
xdmcpFd = -1;
return;
}
WellKnownSocketsMax = xdmcpFd;
FD_SET (xdmcpFd, &WellKnownSocketsMask);
chooserFd = t_open ("/dev/tcp", O_RDWR, NULL);
Debug ("Created chooser fd %d\n", chooserFd);
if (chooserFd == -1)
{
LogError ("chooser stream creation failed\n");
t_error("t_open chooser");
return;
}
if (chooserFd > WellKnownSocketsMax)
WellKnownSocketsMax = chooserFd;
FD_SET (chooserFd, &WellKnownSocketsMask);
}
/*
* The highest level interface for server creation.
* Copied from svc_generic.c and cmd/keyserv/key_generic.c, but adapted
* to work only for TPI_CLTS semantics, and to be called only once
* from kwarnd.c. Returns 1 (interface created) on success and 0
* (no interfaces created) on failure.
*/
int
svc_create_local_service(void (*dispatch) (), /* Dispatch function */
u_long prognum, /* Program number */
u_long versnum, /* Version number */
char *nettype, /* Networktype token */
char *servname) /* name of the srvc */
{
int num = 0;
SVCXPRT *xprt;
struct netconfig *nconf;
struct t_bind *bind_addr;
void *net;
int fd;
struct nd_hostserv ns;
struct nd_addrlist *nas;
if ((net = __rpc_setconf(nettype)) == 0) {
(void) syslog(LOG_ERR,
gettext("svc_create: could not read netconfig database"));
return (0);
}
while (nconf = __rpc_getconf(net)) {
if ((strcmp(nconf->nc_protofmly, NC_LOOPBACK)) ||
(nconf->nc_semantics != NC_TPI_COTS_ORD))
continue;
if ((fd = t_open(nconf->nc_device, O_RDWR, NULL)) < 0) {
(void) syslog(LOG_ERR,
gettext("svc_create: %s: cannot open connection: %s"),
nconf->nc_netid, t_errlist[t_errno]);
break;
}
/*
* Negotiate for returning the uid of the caller.
* This should be done before enabling the endpoint for
* service via t_bind() (called in svc_tli_create())
* so that requests to kwarnd contain the uid.
*/
if (__rpc_negotiate_uid(fd) != 0) {
syslog(LOG_ERR,
gettext("Could not negotiate for"
" uid with loopback transport %s"),
nconf->nc_netid);
t_close(fd);
break;
}
/* LINTED pointer alignment */
bind_addr = (struct t_bind *) t_alloc(fd, T_BIND, T_ADDR);
if ((bind_addr == NULL)) {
(void) t_close(fd);
(void) syslog(LOG_ERR,
gettext("svc_create: t_alloc failed\n"));
break;
}
ns.h_host = HOST_SELF;
ns.h_serv = servname;
if (!netdir_getbyname(nconf, &ns, &nas)) {
/* Copy the address */
bind_addr->addr.len = nas->n_addrs->len;
(void) memcpy(bind_addr->addr.buf, nas->n_addrs->buf,
(int) nas->n_addrs->len);
bind_addr->qlen = 8;
netdir_free((char *) nas, ND_ADDRLIST);
} else {
(void) syslog(LOG_ERR,
gettext("svc_create: no well known "
"address for %s on %s\n"),
servname, nconf->nc_netid);
(void) t_free((char *) bind_addr, T_BIND);
bind_addr = NULL;
}
xprt = svc_tli_create(fd, nconf, bind_addr, 0, 0);
if (bind_addr)
(void) t_free((char *) bind_addr, T_BIND);
if (xprt == NULL) {
(void) t_close(fd);
(void) syslog(LOG_ERR,
gettext("svc_create: svc_tli_create failed\n"));
break;
} else {
(void) rpcb_unset(prognum, versnum, nconf);
if (svc_reg(xprt, prognum, versnum, dispatch, nconf)
== FALSE) {
(void) syslog(LOG_ERR,
gettext("svc_create: cannot"
" register %d vers %d on %s"),
prognum, versnum, nconf->nc_netid);
SVC_DESTROY(xprt); /* also t_closes fd */
break;
}
num = 1;
break;
}
}
__rpc_endconf(net);
return (num);
}
int
tcp_connect(const char *host, const char *serv)
{
int tfd, i;
void *handle;
struct t_call tcall;
struct t_discon tdiscon;
struct netconfig *ncp;
struct nd_hostserv hs;
struct nd_addrlist *alp;
struct netbuf *np;
struct t_opthdr *topt;
handle = Setnetpath();
hs.h_host = (char *) host;
hs.h_serv = (char *) serv;
while ( (ncp = getnetpath(handle)) != NULL) {
if (strcmp(ncp->nc_proto, "tcp") != 0)
continue;
if (netdir_getbyname(ncp, &hs, &alp) != 0)
continue;
/* try each server address */
for (i = 0, np = alp->n_addrs; i < alp->n_cnt; i++, np++) {
tfd = T_open(ncp->nc_device, O_RDWR, NULL);
T_bind(tfd, NULL, NULL);
tcall.addr.len = np->len;
tcall.addr.buf = np->buf; /* pointer copy */
tcall.opt.len = 0; /* no options */
tcall.udata.len = 0; /* no user data with connect */
if (t_connect(tfd, &tcall, NULL) == 0) {
endnetpath(handle); /* success, connected to server */
netdir_free(alp, ND_ADDRLIST);
req = T_alloc(fd, T_OPTMGMT, T_ALL);
ret = T_alloc(fd, T_OPTMGMT, T_ALL);
topt = (struct t_opthdr *) req->opt.buf;
topt->level = T_INET_TCP;
topt->name = T_TCP_MAXSEG;
topt->len = sizeof(struct t_opthdr) + sizeof(u_long);
req->opt.len = topt->len;
topt = OPT_NEXTHDR(req->opt.buf, req->opt.maxlen, topt);
topt->level = XTI_GENERIC;
topt->name = XTI_SNDBUF;
topt->len = sizeof(struct t_opthdr) + sizeof(u_long);
req->opt.len += topt->len;
return(tfd);
}
if (t_errno == TLOOK && t_look(tfd) == T_DISCONNECT) {
t_rcvdis(tfd, &tdiscon);
errno = tdiscon.reason;
}
t_close(tfd);
}
netdir_free(alp, ND_ADDRLIST);
}
endnetpath(handle);
return(-1);
}