#include <sys/param.h>
#include <sys/conf.h>
#include <sys/ioctl.h>
#include <sys/proc.h>
#include <sys/mount.h>
#include <sys/mbuf.h>
#include <sys/malloc.h>
#include <sys/socket.h>
#include <sys/socketvar.h>
#include <sys/systm.h>
#include <sys/reboot.h>
#include <net/if.h>
#include <netinet/in.h>
#include <nfs/rpcv2.h>
#include <nfs/krpc.h>
struct auth_info {
u_int32_t rp_atype;
u_int32_t rp_alen;
};
struct rpc_call {
u_int32_t rp_xid;
int32_t rp_direction;
u_int32_t rp_rpcvers;
u_int32_t rp_prog;
u_int32_t rp_vers;
u_int32_t rp_proc;
struct auth_info rp_auth;
struct auth_info rp_verf;
};
struct rpc_reply {
u_int32_t rp_xid;
int32_t rp_direction;
int32_t rp_astatus;
union {
u_int32_t rpu_errno;
struct {
struct auth_info rp_auth;
u_int32_t rp_rstatus;
} rpu_ok;
} rp_u;
};
#define MIN_REPLY_HDR 16
#define MAX_RESEND_DELAY 5
#define IP_FORMAT "%d.%d.%d.%d"
#define IP_CH(ip) ((u_char *)ip)
#define IP_LIST(ip) IP_CH(ip)[0],IP_CH(ip)[1],IP_CH(ip)[2],IP_CH(ip)[3]
int
krpc_portmap(sin, prog, vers, portp)
struct sockaddr_in *sin;
u_int prog, vers;
u_int16_t *portp;
{
struct sdata {
u_int32_t prog;
u_int32_t vers;
u_int32_t proto;
u_int32_t port;
} *sdata;
struct rdata {
u_int16_t pad;
u_int16_t port;
} *rdata;
struct mbuf *m;
int error;
if (prog == PMAPPROG) {
*portp = htons(PMAPPORT);
return 0;
}
m = m_gethdr(M_WAIT, MT_DATA);
if (m == NULL)
return ENOBUFS;
m->m_len = sizeof(*sdata);
m->m_pkthdr.len = m->m_len;
sdata = mtod(m, struct sdata *);
sdata->prog = htonl(prog);
sdata->vers = htonl(vers);
sdata->proto = htonl(IPPROTO_UDP);
sdata->port = 0;
sin->sin_port = htons(PMAPPORT);
error = krpc_call(sin, PMAPPROG, PMAPVERS,
PMAPPROC_GETPORT, &m, NULL);
if (error)
return error;
rdata = mtod(m, struct rdata *);
*portp = rdata->port;
m_freem(m);
return 0;
}
int
krpc_call(sa, prog, vers, func, data, from_p)
struct sockaddr_in *sa;
u_int prog, vers, func;
struct mbuf **data;
struct sockaddr_in **from_p;
{
struct socket *so;
struct sockaddr_in *sin;
struct mbuf *m, *nam, *mhead, *mhck;
struct rpc_call *call;
struct rpc_reply *reply;
struct uio auio;
int error, rcvflg, timo, secs, len;
static u_int32_t xid = ~0xFF;
u_int16_t tport;
struct sockopt sopt;
if (sa->sin_family != AF_INET)
return (EAFNOSUPPORT);
nam = mhead = NULL;
if (from_p)
*from_p = 0;
if ((error = socreate(AF_INET, &so, SOCK_DGRAM, 0)))
goto out;
{
struct timeval tv;
tv.tv_sec = 1;
tv.tv_usec = 0;
bzero(&sopt, sizeof sopt);
sopt.sopt_dir = SOPT_SET;
sopt.sopt_level = SOL_SOCKET;
sopt.sopt_name = SO_RCVTIMEO;
sopt.sopt_val = &tv;
sopt.sopt_valsize = sizeof tv;
if (error = sosetopt(so, &sopt))
goto out;
}
if (from_p) {
int on = 1;
sopt.sopt_name = SO_BROADCAST;
sopt.sopt_val = &on;
sopt.sopt_valsize = sizeof on;
if (error = sosetopt(so, &sopt))
goto out;
}
m = m_getclr(M_WAIT, MT_SONAME);
sin = mtod(m, struct sockaddr_in *);
sin->sin_len = m->m_len = sizeof(*sin);
sin->sin_family = AF_INET;
sin->sin_addr.s_addr = INADDR_ANY;
tport = IPPORT_RESERVED;
do {
tport--;
sin->sin_port = htons(tport);
error = sobind(so, mtod(m, struct sockaddr *));
} while (error == EADDRINUSE &&
tport > IPPORT_RESERVED / 2);
m_freem(m);
if (error) {
printf("bind failed\n");
goto out;
}
nam = m_get(M_WAIT, MT_SONAME);
if (nam == NULL) {
error = ENOBUFS;
goto out;
}
sin = mtod(nam, struct sockaddr_in *);
bcopy((caddr_t)sa, (caddr_t)sin, (nam->m_len = sa->sin_len));
m = *data;
*data = NULL;
#if DIAGNOSTIC
if ((m->m_flags & M_PKTHDR) == 0)
panic("krpc_call: send data w/o pkthdr");
if (m->m_pkthdr.len < m->m_len)
panic("krpc_call: pkthdr.len not set");
#endif
mhead = m_prepend(m, sizeof(*call), M_WAIT);
if (mhead == NULL) {
error = ENOBUFS;
goto out;
}
mhead->m_pkthdr.len += sizeof(*call);
mhead->m_pkthdr.rcvif = NULL;
call = mtod(mhead, struct rpc_call *);
bzero((caddr_t)call, sizeof(*call));
xid++;
call->rp_xid = htonl(xid);
call->rp_rpcvers = htonl(2);
call->rp_prog = htonl(prog);
call->rp_vers = htonl(vers);
call->rp_proc = htonl(func);
timo = 0;
for (;;) {
m = m_copym(mhead, 0, M_COPYALL, M_WAIT);
if (m == NULL) {
error = ENOBUFS;
goto out;
}
error = sosend(so, mtod(nam, struct sockaddr *), NULL, m, NULL, 0);
if (error) {
printf("krpc_call: sosend: %d\n", error);
goto out;
}
m = NULL;
if (timo < MAX_RESEND_DELAY)
timo++;
else
printf("RPC timeout for server " IP_FORMAT "\n",
IP_LIST(&(sin->sin_addr.s_addr)));
auio.uio_procp = NULL;
secs = timo;
while (secs > 0) {
if ((from_p) && (*from_p)){
FREE(*from_p, M_SONAME);
*from_p = NULL;
}
if (m) {
m_freem(m);
m = NULL;
}
auio.uio_resid = len = 1<<16;
rcvflg = 0;
error = soreceive(so, (struct sockaddr **) from_p, &auio, &m, NULL, &rcvflg);
if (error == EWOULDBLOCK) {
secs--;
continue;
}
if (error)
goto out;
len -= auio.uio_resid;
if (len < MIN_REPLY_HDR)
continue;
if (m->m_len < MIN_REPLY_HDR)
continue;
reply = mtod(m, struct rpc_reply *);
if (reply->rp_direction != htonl(RPC_REPLY))
continue;
if (reply->rp_xid != htonl(xid))
continue;
if (reply->rp_astatus != 0) {
error = ntohl(reply->rp_u.rpu_errno);
printf("rpc denied, error=%d\n", error);
switch (error) {
case RPC_MISMATCH:
error = ERPCMISMATCH;
break;
case RPC_AUTHERR:
error = EAUTH;
break;
}
goto out;
}
if ((error = ntohl(reply->rp_u.rpu_ok.rp_rstatus)) != 0) {
printf("rpc status=%d\n", error);
switch (error) {
case RPC_PROGUNAVAIL:
error = EPROGUNAVAIL;
break;
case RPC_PROGMISMATCH:
error = EPROGMISMATCH;
break;
case RPC_PROCUNAVAIL:
error = EPROCUNAVAIL;
break;
case RPC_GARBAGE:
error = EINVAL;
break;
case RPC_SYSTEM_ERR:
error = EIO;
break;
}
goto out;
}
goto gotreply;
}
}
error = ETIMEDOUT;
goto out;
gotreply:
#if DIAGNOSTIC
if ((m->m_flags & M_PKTHDR) == 0)
panic("krpc_call: received pkt w/o header?");
#endif
len = m->m_pkthdr.len;
if (m->m_len < len) {
m = m_pullup(m, len);
if (m == NULL) {
error = ENOBUFS;
goto out;
}
reply = mtod(m, struct rpc_reply *);
}
len = sizeof(*reply);
if (reply->rp_u.rpu_ok.rp_auth.rp_atype != 0) {
len += ntohl(reply->rp_u.rpu_ok.rp_auth.rp_alen);
len = (len + 3) & ~3;
}
m_adj(m, len);
*data = m;
out:
if (nam) m_freem(nam);
if (mhead) m_freem(mhead);
soclose(so);
return error;
}