#if defined(LIBC_SCCS) && !defined(lint)
static char *rcsid = "$Id: rpc_extra.c,v 1.2 2001/10/26 15:59:56 majka Exp $";
#endif
#include <NetInfo/config.h>
#include <stdio.h>
#ifdef RPC_SUCCESS
#undef RPC_SUCCESS
#endif
#include <rpc/rpc.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/time.h>
#include <sys/ioctl.h>
#include <errno.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <NetInfo/system_log.h>
#ifdef _OS_NEXT_
#include <libc.h>
#endif
#define rpc_buffer(xprt) ((xprt)->xp_p1)
static bool_t svcudp_recv();
static bool_t svcudp_reply();
static enum xprt_stat svcudp_stat();
static bool_t svcudp_getargs();
static bool_t svcudp_freeargs();
static void svcudp_destroy();
static struct xp_ops svcudp_op = {
svcudp_recv,
svcudp_stat,
svcudp_getargs,
svcudp_reply,
svcudp_freeargs,
svcudp_destroy
};
extern int errno;
struct svcudp_data {
u_int su_iosz;
u_long su_xid;
XDR su_xdrs;
char su_verfbody[MAX_AUTH_BYTES];
char * su_cache;
};
#define su_data(xprt) ((struct svcudp_data *)(xprt->xp_p2))
static bool_t svctcp_recv();
static enum xprt_stat svctcp_stat();
static bool_t svctcp_getargs();
static bool_t svctcp_reply();
static bool_t svctcp_freeargs();
static void svctcp_destroy();
static struct xp_ops svctcp_op = {
svctcp_recv,
svctcp_stat,
svctcp_getargs,
svctcp_reply,
svctcp_freeargs,
svctcp_destroy
};
static bool_t rendezvous_request();
static enum xprt_stat rendezvous_stat();
static struct xp_ops svctcp_rendezvous_op = {
rendezvous_request,
rendezvous_stat,
(bool_t (*)())abort,
(bool_t (*)())abort,
(bool_t (*)())abort,
svctcp_destroy
};
static int readtcp(), writetcp();
static SVCXPRT *makefd_xprt();
extern int bindresvport(int, struct sockaddr_in *);
extern int _rpc_dtablesize();
struct tcp_rendezvous {
u_int sendsize;
u_int recvsize;
};
struct tcp_conn {
enum xprt_stat strm_stat;
u_long x_id;
XDR xdrs;
char verf_body[MAX_AUTH_BYTES];
};
SVCXPRT *
svcudp_bufbind(int sock, struct sockaddr_in addr, u_int sendsz, u_int recvsz)
{
bool_t madesock = FALSE;
SVCXPRT *xprt;
struct svcudp_data *su;
int len, reuse, status;
len = sizeof(struct sockaddr_in);
reuse = 1;
if (sock == RPC_ANYSOCK)
{
sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (sock < 0)
{
system_log(LOG_ERR, "svcudp_bufbind - udp socket: %m");
return NULL;
}
madesock = TRUE;
}
if (addr.sin_port != 0)
{
status = setsockopt(sock, SOL_SOCKET, SO_REUSEPORT, &reuse, sizeof(int));
if (status < 0)
{
system_log(LOG_ERR, "svcudp_bufbind - setsockopt: %m");
if (madesock) close(sock);
return NULL;
}
status = bind(sock, (struct sockaddr *)&addr, len);
if (status < 0)
{
system_log(LOG_ERR, "svcudp_bufbind - bind: %m");
if (madesock) close(sock);
return NULL;
}
}
else if (bindresvport(sock, &addr))
{
addr.sin_port = 0;
status = bind(sock, (struct sockaddr *)&addr, len);
if (status < 0)
{
system_log(LOG_ERR, "svcudp_bufbind - bind: %m");
if (madesock) close(sock);
return NULL;
}
}
if (getsockname(sock, (struct sockaddr *)&addr, &len) != 0)
{
system_log(LOG_ERR, "svcudp_bufbind - getsockname %m");
if (madesock) close(sock);
return NULL;
}
xprt = (SVCXPRT *)mem_alloc(sizeof(SVCXPRT));
if (xprt == NULL)
{
system_log(LOG_ERR, "svcudp_bufbind: out of memory");
return NULL;
}
su = (struct svcudp_data *)mem_alloc(sizeof(*su));
if (su == NULL)
{
system_log(LOG_ERR, "svcudp_bufbind: out of memory");
return NULL;
}
su->su_iosz = ((MAX(sendsz, recvsz) + 3) / 4) * 4;
if ((rpc_buffer(xprt) = mem_alloc(su->su_iosz)) == NULL)
{
system_log(LOG_ERR, "svcudp_bufbind: out of memory");
return NULL;
}
xdrmem_create(&(su->su_xdrs), rpc_buffer(xprt), su->su_iosz, XDR_DECODE);
su->su_cache = NULL;
xprt->xp_p2 = (caddr_t)su;
xprt->xp_verf.oa_base = su->su_verfbody;
xprt->xp_ops = &svcudp_op;
xprt->xp_port = ntohs(addr.sin_port);
xprt->xp_sock = sock;
xprt_register(xprt);
return xprt;
}
SVCXPRT *
svcudp_bind(int sock, struct sockaddr_in addr)
{
return(svcudp_bufbind(sock, addr, UDPMSGSIZE, UDPMSGSIZE));
}
static enum xprt_stat
svcudp_stat(xprt)
SVCXPRT *xprt;
{
return (XPRT_IDLE);
}
static bool_t
svcudp_recv(xprt, msg)
SVCXPRT *xprt;
struct rpc_msg *msg;
{
struct svcudp_data *su = su_data(xprt);
XDR *xdrs = &(su->su_xdrs);
int rlen;
char *reply;
u_long replylen;
static int cache_get();
again:
xprt->xp_addrlen = sizeof(struct sockaddr_in);
rlen = recvfrom(xprt->xp_sock, rpc_buffer(xprt), (int) su->su_iosz,
0, (struct sockaddr *)&(xprt->xp_raddr), &(xprt->xp_addrlen));
if (rlen == -1 && errno == EINTR)
goto again;
if (rlen < 4*sizeof(u_long))
return (FALSE);
xdrs->x_op = XDR_DECODE;
XDR_SETPOS(xdrs, 0);
if (! xdr_callmsg(xdrs, msg))
return (FALSE);
su->su_xid = msg->rm_xid;
if (su->su_cache != NULL) {
if (cache_get(xprt, msg, &reply, &replylen)) {
(void) sendto(xprt->xp_sock, reply, (int) replylen, 0,
(struct sockaddr *) &xprt->xp_raddr, xprt->xp_addrlen);
return (TRUE);
}
}
return (TRUE);
}
static bool_t
svcudp_reply(xprt, msg)
SVCXPRT *xprt;
struct rpc_msg *msg;
{
struct svcudp_data *su = su_data(xprt);
XDR *xdrs = &(su->su_xdrs);
int slen;
bool_t stat = FALSE;
static void cache_set();
xdrs->x_op = XDR_ENCODE;
XDR_SETPOS(xdrs, 0);
msg->rm_xid = su->su_xid;
if (xdr_replymsg(xdrs, msg)) {
slen = (int)XDR_GETPOS(xdrs);
if (sendto(xprt->xp_sock, rpc_buffer(xprt), slen, 0,
(struct sockaddr *)&(xprt->xp_raddr), xprt->xp_addrlen)
== slen) {
stat = TRUE;
if (su->su_cache && slen >= 0) {
cache_set(xprt, (u_long) slen);
}
}
}
return (stat);
}
static bool_t
svcudp_getargs(xprt, xdr_args, args_ptr)
SVCXPRT *xprt;
xdrproc_t xdr_args;
caddr_t args_ptr;
{
return ((*xdr_args)(&(su_data(xprt)->su_xdrs), args_ptr));
}
static bool_t
svcudp_freeargs(xprt, xdr_args, args_ptr)
SVCXPRT *xprt;
xdrproc_t xdr_args;
caddr_t args_ptr;
{
XDR *xdrs = &(su_data(xprt)->su_xdrs);
xdrs->x_op = XDR_FREE;
return ((*xdr_args)(xdrs, args_ptr));
}
static void
svcudp_destroy(xprt)
SVCXPRT *xprt;
{
struct svcudp_data *su = su_data(xprt);
xprt_unregister(xprt);
(void)close(xprt->xp_sock);
XDR_DESTROY(&(su->su_xdrs));
mem_free(rpc_buffer(xprt), su->su_iosz);
mem_free((caddr_t)su, sizeof(struct svcudp_data));
mem_free((caddr_t)xprt, sizeof(SVCXPRT));
}
#define SPARSENESS 4
#define CACHE_PERROR(msg) \
system_log(LOG_ERR, "%s", msg)
#define ALLOC(type, size) \
(type *) mem_alloc((unsigned) (sizeof(type) * (size)))
#define BZERO(addr, type, size) \
bzero((char *) addr, sizeof(type) * (int) (size))
typedef struct cache_node *cache_ptr;
struct cache_node {
u_long cache_xid;
u_long cache_proc;
u_long cache_vers;
u_long cache_prog;
struct sockaddr_in cache_addr;
char * cache_reply;
u_long cache_replylen;
cache_ptr cache_next;
};
struct udp_cache {
u_long uc_size;
cache_ptr *uc_entries;
cache_ptr *uc_fifo;
u_long uc_nextvictim;
u_long uc_prog;
u_long uc_vers;
u_long uc_proc;
struct sockaddr_in uc_addr;
};
#define CACHE_LOC(transp, xid) \
(xid % (SPARSENESS*((struct udp_cache *) su_data(transp)->su_cache)->uc_size))
#ifdef NOTDEF
int
svcudp_enablecache(transp, size)
SVCXPRT *transp;
u_long size;
{
struct svcudp_data *su = su_data(transp);
struct udp_cache *uc;
if (su->su_cache != NULL) {
CACHE_PERROR("enablecache: cache already enabled");
return(0);
}
uc = ALLOC(struct udp_cache, 1);
if (uc == NULL) {
CACHE_PERROR("enablecache: could not allocate cache");
return(0);
}
uc->uc_size = size;
uc->uc_nextvictim = 0;
uc->uc_entries = ALLOC(cache_ptr, size * SPARSENESS);
if (uc->uc_entries == NULL) {
CACHE_PERROR("enablecache: could not allocate cache data");
return(0);
}
BZERO(uc->uc_entries, cache_ptr, size * SPARSENESS);
uc->uc_fifo = ALLOC(cache_ptr, size);
if (uc->uc_fifo == NULL) {
CACHE_PERROR("enablecache: could not allocate cache fifo");
return(0);
}
BZERO(uc->uc_fifo, cache_ptr, size);
su->su_cache = (char *) uc;
return(1);
}
#endif
static void
cache_set(xprt, replylen)
SVCXPRT *xprt;
u_long replylen;
{
cache_ptr victim;
cache_ptr *vicp;
struct svcudp_data *su = su_data(xprt);
struct udp_cache *uc = (struct udp_cache *) su->su_cache;
u_int loc;
char *newbuf;
victim = uc->uc_fifo[uc->uc_nextvictim];
if (victim != NULL) {
loc = CACHE_LOC(xprt, victim->cache_xid);
for (vicp = &uc->uc_entries[loc];
*vicp != NULL && *vicp != victim;
vicp = &(*vicp)->cache_next)
;
if (*vicp == NULL) {
CACHE_PERROR("cache_set: victim not found");
return;
}
*vicp = victim->cache_next;
newbuf = victim->cache_reply;
} else {
victim = ALLOC(struct cache_node, 1);
if (victim == NULL) {
CACHE_PERROR("cache_set: victim alloc failed");
return;
}
newbuf = mem_alloc(su->su_iosz);
if (newbuf == NULL) {
CACHE_PERROR("cache_set: could not allocate new rpc_buffer");
return;
}
}
victim->cache_replylen = replylen;
victim->cache_reply = rpc_buffer(xprt);
rpc_buffer(xprt) = newbuf;
xdrmem_create(&(su->su_xdrs), rpc_buffer(xprt), su->su_iosz, XDR_ENCODE);
victim->cache_xid = su->su_xid;
victim->cache_proc = uc->uc_proc;
victim->cache_vers = uc->uc_vers;
victim->cache_prog = uc->uc_prog;
victim->cache_addr = uc->uc_addr;
loc = CACHE_LOC(xprt, victim->cache_xid);
victim->cache_next = uc->uc_entries[loc];
uc->uc_entries[loc] = victim;
uc->uc_fifo[uc->uc_nextvictim++] = victim;
uc->uc_nextvictim %= uc->uc_size;
}
static int
cache_get(xprt, msg, replyp, replylenp)
SVCXPRT *xprt;
struct rpc_msg *msg;
char **replyp;
u_long *replylenp;
{
u_int loc;
cache_ptr ent;
struct svcudp_data *su = su_data(xprt);
struct udp_cache *uc = (struct udp_cache *) su->su_cache;
# define EQADDR(a1, a2) (bcmp((char*)&a1, (char*)&a2, sizeof(a1)) == 0)
loc = CACHE_LOC(xprt, su->su_xid);
for (ent = uc->uc_entries[loc]; ent != NULL; ent = ent->cache_next) {
if (ent->cache_xid == su->su_xid &&
ent->cache_proc == uc->uc_proc &&
ent->cache_vers == uc->uc_vers &&
ent->cache_prog == uc->uc_prog &&
EQADDR(ent->cache_addr, uc->uc_addr)) {
*replyp = ent->cache_reply;
*replylenp = ent->cache_replylen;
return(1);
}
}
uc->uc_proc = msg->rm_call.cb_proc;
uc->uc_vers = msg->rm_call.cb_vers;
uc->uc_prog = msg->rm_call.cb_prog;
uc->uc_addr = xprt->xp_raddr;
return(0);
}
SVCXPRT *
svctcp_bind(int sock, struct sockaddr_in s, u_int sendsize, u_int recvsize)
{
struct sockaddr_in name;
bool_t madesock = FALSE;
SVCXPRT *xprt;
struct tcp_rendezvous *r;
int len, reuse, status;
reuse = 1;
if (sock == RPC_ANYSOCK)
{
sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (sock < 0)
{
system_log(LOG_ERR, "svctcp_bind - tcp socket: %m");
return NULL;
}
madesock = TRUE;
}
if (s.sin_port != 0)
{
status = setsockopt(sock, SOL_SOCKET, SO_REUSEPORT, &reuse, sizeof(int));
if (status < 0)
{
system_log(LOG_ERR, "svctcp_bind - setsockopt: %m");
if (madesock) close(sock);
return NULL;
}
status = bind(sock, (struct sockaddr *)&s, sizeof(struct sockaddr_in));
if (status < 0)
{
system_log(LOG_ERR, "svctcp_bind - bind: %m");
if (madesock) close(sock);
return NULL;
}
}
else if (bindresvport(sock, &s))
{
s.sin_port = 0;
status = bind(sock, (struct sockaddr *)&s, sizeof(struct sockaddr_in));
{
system_log(LOG_ERR, "svctcp_bind - bind: %m");
if (madesock) close(sock);
return NULL;
}
}
len = sizeof(struct sockaddr_in);
if ((getsockname(sock, (struct sockaddr *)&name, &len) != 0) || (listen(sock, 2) != 0))
{
system_log(LOG_ERR, "svctcp_bind - getsockname / listen: %m");
if (madesock) close(sock);
return NULL;
}
r = (struct tcp_rendezvous *)mem_alloc(sizeof(*r));
if (r == NULL)
{
system_log(LOG_ERR, "svctcp_bind: out of memory");
return NULL;
}
r->sendsize = sendsize;
r->recvsize = recvsize;
xprt = (SVCXPRT *)mem_alloc(sizeof(SVCXPRT));
if (xprt == NULL)
{
system_log(LOG_ERR, "svctcp_bind: out of memory");
return NULL;
}
xprt->xp_p2 = NULL;
xprt->xp_p1 = (caddr_t)r;
xprt->xp_verf = _null_auth;
xprt->xp_ops = &svctcp_rendezvous_op;
xprt->xp_port = ntohs(name.sin_port);
xprt->xp_sock = sock;
xprt_register(xprt);
return xprt;
}
#ifdef NOTDEF
SVCXPRT *
svcfd_create(fd, sendsize, recvsize)
int fd;
u_int sendsize;
u_int recvsize;
{
return (makefd_xprt(fd, sendsize, recvsize));
}
#endif
static SVCXPRT *
makefd_xprt(fd, sendsize, recvsize)
int fd;
u_int sendsize;
u_int recvsize;
{
SVCXPRT *xprt;
struct tcp_conn *cd;
xprt = (SVCXPRT *)mem_alloc(sizeof(SVCXPRT));
if (xprt == (SVCXPRT *)NULL) {
system_log(LOG_ERR, "ni_svc_tcp: makefd_xprt: out of memory");
goto done;
}
cd = (struct tcp_conn *)mem_alloc(sizeof(struct tcp_conn));
if (cd == (struct tcp_conn *)NULL) {
system_log(LOG_ERR, "ni_svc_tcp: makefd_xprt: out of memory");
mem_free((char *) xprt, sizeof(SVCXPRT));
xprt = (SVCXPRT *)NULL;
goto done;
}
cd->strm_stat = XPRT_IDLE;
xdrrec_create(&(cd->xdrs), sendsize, recvsize,
(caddr_t)xprt, readtcp, writetcp);
xprt->xp_p2 = NULL;
xprt->xp_p1 = (caddr_t)cd;
xprt->xp_verf.oa_base = cd->verf_body;
xprt->xp_addrlen = 0;
xprt->xp_ops = &svctcp_op;
xprt->xp_port = 0;
xprt->xp_sock = fd;
xprt_register(xprt);
done:
return (xprt);
}
static bool_t
rendezvous_request(xprt)
SVCXPRT *xprt;
{
int sock;
struct tcp_rendezvous *r;
struct sockaddr_in addr;
int len;
int dontblock;
r = (struct tcp_rendezvous *)xprt->xp_p1;
again:
len = sizeof(struct sockaddr_in);
if ((sock = accept(xprt->xp_sock, (struct sockaddr *)&addr,
&len)) < 0) {
if (errno == EINTR)
goto again;
return (FALSE);
}
dontblock = 1;
(void)ioctl(sock, FIONBIO, &dontblock);
xprt = makefd_xprt(sock, r->sendsize, r->recvsize);
xprt->xp_raddr = addr;
xprt->xp_addrlen = len;
return (FALSE);
}
static enum xprt_stat
rendezvous_stat()
{
return (XPRT_IDLE);
}
static void
svctcp_destroy(SVCXPRT *xprt)
{
struct tcp_conn *cd = (struct tcp_conn *)xprt->xp_p1;
xprt_unregister(xprt);
(void)close(xprt->xp_sock);
if (xprt->xp_port != 0) {
xprt->xp_port = 0;
} else {
XDR_DESTROY(&(cd->xdrs));
}
mem_free((caddr_t)cd, sizeof(struct tcp_conn));
mem_free((caddr_t)xprt, sizeof(SVCXPRT));
}
static struct timeval wait_per_try = { 35, 0 };
static int
readtcp(xprt, buf, len)
SVCXPRT *xprt;
caddr_t buf;
int len;
{
int sock = xprt->xp_sock;
#ifdef FD_SETSIZE
fd_set mask;
fd_set readfds;
if (((struct tcp_conn *)(xprt->xp_p1))->strm_stat == XPRT_DIED) {
return (-1);
}
FD_ZERO(&mask);
FD_SET(sock, &mask);
#else
int mask = 1 << sock;
int readfds;
#endif
do {
readfds = mask;
if (select(_rpc_dtablesize(), &readfds, (fd_set*)NULL, (fd_set*)NULL,
&wait_per_try) <= 0) {
if (errno == EINTR) {
continue;
}
goto fatal_err;
}
#ifdef FD_SETSIZE
} while (!FD_ISSET(sock, &readfds));
#else
} while (readfds != mask);
#endif
if ((len = read(sock, buf, len)) > 0) {
return (len);
}
fatal_err:
((struct tcp_conn *)(xprt->xp_p1))->strm_stat = XPRT_DIED;
return (-1);
}
static int
writetcp(xprt, buf, len)
SVCXPRT *xprt;
caddr_t buf;
int len;
{
int sock = xprt->xp_sock;
int i, cnt;
fd_set mask;
fd_set writefds;
if (((struct tcp_conn *)(xprt->xp_p1))->strm_stat == XPRT_DIED) {
return (-1);
}
for (cnt = len; cnt > 0; cnt -= i, buf += i) {
FD_ZERO(&mask);
FD_SET(sock, &mask);
do {
writefds = mask;
if (select(_rpc_dtablesize(), (fd_set *)NULL, &writefds,
(fd_set*)NULL, &wait_per_try) <= 0) {
if (errno == EINTR) {
continue;
}
goto fatal_err;
}
} while (!FD_ISSET(sock, &writefds));
if ((i = write(xprt->xp_sock, buf, cnt)) < 0) {
goto fatal_err;
}
}
return (len);
fatal_err:
((struct tcp_conn *)(xprt->xp_p1))->strm_stat = XPRT_DIED;
return (-1);
}
static enum xprt_stat
svctcp_stat(xprt)
SVCXPRT *xprt;
{
struct tcp_conn *cd = (struct tcp_conn *)(xprt->xp_p1);
if (cd->strm_stat == XPRT_DIED)
return (XPRT_DIED);
if (! xdrrec_eof(&(cd->xdrs)))
return (XPRT_MOREREQS);
return (XPRT_IDLE);
}
static bool_t
svctcp_recv(xprt, msg)
SVCXPRT *xprt;
struct rpc_msg *msg;
{
struct tcp_conn *cd = (struct tcp_conn *)(xprt->xp_p1);
XDR *xdrs = &(cd->xdrs);
xdrs->x_op = XDR_DECODE;
(void)xdrrec_skiprecord(xdrs);
if (xdr_callmsg(xdrs, msg)) {
cd->x_id = msg->rm_xid;
return (TRUE);
}
return (FALSE);
}
static bool_t
svctcp_getargs(xprt, xdr_args, args_ptr)
SVCXPRT *xprt;
xdrproc_t xdr_args;
caddr_t args_ptr;
{
return ((*xdr_args)(&(((struct tcp_conn *)(xprt->xp_p1))->xdrs), args_ptr));
}
static bool_t
svctcp_freeargs(xprt, xdr_args, args_ptr)
SVCXPRT *xprt;
xdrproc_t xdr_args;
caddr_t args_ptr;
{
XDR *xdrs = &(((struct tcp_conn *)(xprt->xp_p1))->xdrs);
xdrs->x_op = XDR_FREE;
return ((*xdr_args)(xdrs, args_ptr));
}
static bool_t
svctcp_reply(xprt, msg)
SVCXPRT *xprt;
struct rpc_msg *msg;
{
struct tcp_conn *cd = (struct tcp_conn *)(xprt->xp_p1);
XDR *xdrs = &(cd->xdrs);
bool_t stat;
xdrs->x_op = XDR_ENCODE;
msg->rm_xid = cd->x_id;
stat = xdr_replymsg(xdrs, msg);
(void)xdrrec_endofrecord(xdrs, TRUE);
return (stat);
}