static void
svcauth_null(struct svc_rqst *rqstp, u32 *statp, u32 *authp)
{
struct svc_buf *argp = &rqstp->rq_argbuf;
struct svc_buf *resp = &rqstp->rq_resbuf;
if ((argp->len -= 3) < 0) {
*statp = rpc_garbage_args;
return;
}
if (*(argp->buf)++ != 0) { /* we already skipped the flavor */
dprintk("svc: bad null cred\n");
*authp = rpc_autherr_badcred;
return;
}
if (*(argp->buf)++ != RPC_AUTH_NULL || *(argp->buf)++ != 0) {
dprintk("svc: bad null verf\n");
*authp = rpc_autherr_badverf;
return;
}
/* Signal that mapping to nobody uid/gid is required */
rqstp->rq_cred.cr_uid = (uid_t) -1;
rqstp->rq_cred.cr_gid = (gid_t) -1;
rqstp->rq_cred.cr_groups[0] = NOGROUP;
/* Put NULL verifier */
rqstp->rq_verfed = 1;
svc_putlong(resp, RPC_AUTH_NULL);
svc_putlong(resp, 0);
}
static void
svcauth_unix(struct svc_rqst *rqstp, u32 *statp, u32 *authp)
{
struct svc_buf *argp = &rqstp->rq_argbuf;
struct svc_buf *resp = &rqstp->rq_resbuf;
struct svc_cred *cred = &rqstp->rq_cred;
u32 *bufp = argp->buf;
int len = argp->len;
u32 slen, i;
if ((len -= 3) < 0) {
*statp = rpc_garbage_args;
return;
}
bufp++; /* length */
bufp++; /* time stamp */
slen = (ntohl(*bufp++) + 3) >> 2; /* machname length */
if (slen > 64 || (len -= slen + 3) < 0)
goto badcred;
bufp += slen; /* skip machname */
cred->cr_uid = ntohl(*bufp++); /* uid */
cred->cr_gid = ntohl(*bufp++); /* gid */
slen = ntohl(*bufp++); /* gids length */
if (slen > 16 || (len -= slen + 2) < 0)
goto badcred;
for (i = 0; i < NGROUPS && i < slen; i++)
cred->cr_groups[i] = ntohl(*bufp++);
if (i < NGROUPS)
cred->cr_groups[i] = NOGROUP;
bufp += (slen - i);
if (*bufp++ != RPC_AUTH_NULL || *bufp++ != 0) {
*authp = rpc_autherr_badverf;
return;
}
argp->buf = bufp;
argp->len = len;
/* Put NULL verifier */
rqstp->rq_verfed = 1;
svc_putlong(resp, RPC_AUTH_NULL);
svc_putlong(resp, 0);
return;
badcred:
*authp = rpc_autherr_badcred;
}
/*
* Process the RPC request.
*/
int
svc_process(struct svc_serv *serv, struct svc_rqst *rqstp)
{
struct svc_program *progp;
struct svc_version *versp = NULL; /* compiler food */
struct svc_procedure *procp = NULL;
struct svc_buf * argp = &rqstp->rq_argbuf;
struct svc_buf * resp = &rqstp->rq_resbuf;
kxdrproc_t xdr;
u32 *bufp, *statp;
u32 dir, prog, vers, proc,
auth_stat, rpc_stat;
rpc_stat = rpc_success;
bufp = argp->buf;
if (argp->len < 5)
goto err_short_len;
dir = ntohl(*bufp++);
vers = ntohl(*bufp++);
/* First words of reply: */
svc_putlong(resp, xdr_one); /* REPLY */
svc_putlong(resp, xdr_zero); /* ACCEPT */
if (dir != 0) /* direction != CALL */
goto err_bad_dir;
if (vers != 2) /* RPC version number */
goto err_bad_rpc;
rqstp->rq_prog = prog = ntohl(*bufp++); /* program number */
rqstp->rq_vers = vers = ntohl(*bufp++); /* version number */
rqstp->rq_proc = proc = ntohl(*bufp++); /* procedure number */
argp->buf += 5;
argp->len -= 5;
/* Used by nfsd to only allow the NULL procedure for amd. */
if (rqstp->rq_auth && !rqstp->rq_client && proc) {
auth_stat = rpc_autherr_badcred;
goto err_bad_auth;
}
/*
* Decode auth data, and add verifier to reply buffer.
* We do this before anything else in order to get a decent
* auth verifier.
*/
svc_authenticate(rqstp, &rpc_stat, &auth_stat);
if (rpc_stat != rpc_success)
goto err_garbage;
if (auth_stat != rpc_auth_ok)
goto err_bad_auth;
progp = serv->sv_program;
if (prog != progp->pg_prog)
goto err_bad_prog;
versp = progp->pg_vers[vers];
if (!versp || vers >= progp->pg_nvers)
goto err_bad_vers;
procp = versp->vs_proc + proc;
if (proc >= versp->vs_nproc || !procp->pc_func)
goto err_bad_proc;
rqstp->rq_server = serv;
rqstp->rq_procinfo = procp;
/* Syntactic check complete */
serv->sv_stats->rpccnt++;
/* Build the reply header. */
statp = resp->buf;
svc_putlong(resp, rpc_success); /* RPC_SUCCESS */
/* Bump per-procedure stats counter */
procp->pc_count++;
/* Initialize storage for argp and resp */
memset(rqstp->rq_argp, 0, procp->pc_argsize);
memset(rqstp->rq_resp, 0, procp->pc_ressize);
/* Call the function that processes the request. */
if (!versp->vs_dispatch) {
/* Decode arguments */
xdr = procp->pc_decode;
if (xdr && !xdr(rqstp, rqstp->rq_argbuf.buf, rqstp->rq_argp))
goto err_garbage;
*statp = procp->pc_func(rqstp, rqstp->rq_argp, rqstp->rq_resp);
/* Encode reply */
if (*statp == rpc_success && (xdr = procp->pc_encode)
&& !xdr(rqstp, rqstp->rq_resbuf.buf, rqstp->rq_resp)) {
dprintk("svc: failed to encode reply\n");
/* serv->sv_stats->rpcsystemerr++; */
*statp = rpc_system_err;
}
} else {
dprintk("svc: calling dispatcher\n");
if (!versp->vs_dispatch(rqstp, statp))
goto dropit;
}
/* Check RPC status result */
if (*statp != rpc_success)
resp->len = statp + 1 - resp->base;
/* Release reply info */
if (procp->pc_release)
procp->pc_release(rqstp, NULL, rqstp->rq_resp);
if (procp->pc_encode == NULL)
goto dropit;
sendit:
return svc_send(rqstp);
dropit:
dprintk("svc: svc_process dropit\n");
svc_drop(rqstp);
return 0;
err_short_len:
#ifdef RPC_PARANOIA
printk("svc: short len %d, dropping request\n", argp->len);
#endif
goto dropit; /* drop request */
err_bad_dir:
#ifdef RPC_PARANOIA
printk("svc: bad direction %d, dropping request\n", dir);
#endif
serv->sv_stats->rpcbadfmt++;
goto dropit; /* drop request */
err_bad_rpc:
serv->sv_stats->rpcbadfmt++;
resp->buf[-1] = xdr_one; /* REJECT */
svc_putlong(resp, xdr_zero); /* RPC_MISMATCH */
svc_putlong(resp, xdr_two); /* Only RPCv2 supported */
svc_putlong(resp, xdr_two);
goto sendit;
err_bad_auth:
dprintk("svc: authentication failed (%ld)\n", ntohl(auth_stat));
serv->sv_stats->rpcbadauth++;
resp->buf[-1] = xdr_one; /* REJECT */
svc_putlong(resp, xdr_one); /* AUTH_ERROR */
svc_putlong(resp, auth_stat); /* status */
goto sendit;
err_bad_prog:
#ifdef RPC_PARANOIA
printk("svc: unknown program %d (me %d)\n", prog, progp->pg_prog);
#endif
serv->sv_stats->rpcbadfmt++;
svc_putlong(resp, rpc_prog_unavail);
goto sendit;
err_bad_vers:
#ifdef RPC_PARANOIA
printk("svc: unknown version (%d)\n", vers);
#endif
serv->sv_stats->rpcbadfmt++;
svc_putlong(resp, rpc_prog_mismatch);
svc_putlong(resp, htonl(progp->pg_lovers));
svc_putlong(resp, htonl(progp->pg_hivers));
goto sendit;
err_bad_proc:
#ifdef RPC_PARANOIA
printk("svc: unknown procedure (%d)\n", proc);
#endif
serv->sv_stats->rpcbadfmt++;
svc_putlong(resp, rpc_proc_unavail);
goto sendit;
err_garbage:
#ifdef RPC_PARANOIA
printk("svc: failed to decode args\n");
#endif
serv->sv_stats->rpcbadfmt++;
svc_putlong(resp, rpc_garbage_args);
goto sendit;
}
/*
* Receive the next request on any socket.
*/
int
svc_recv(struct svc_serv *serv, struct svc_rqst *rqstp, long timeout)
{
struct svc_sock *svsk;
int len;
DECLARE_WAITQUEUE(wait, current);
dprintk("svc: server %p waiting for data (to = %ld)\n",
rqstp, timeout);
if (rqstp->rq_sock)
printk(KERN_ERR
"svc_recv: service %p, socket not NULL!\n",
rqstp);
if (waitqueue_active(&rqstp->rq_wait))
printk(KERN_ERR
"svc_recv: service %p, wait queue active!\n",
rqstp);
/* Initialize the buffers */
rqstp->rq_argbuf = rqstp->rq_defbuf;
rqstp->rq_resbuf = rqstp->rq_defbuf;
if (signalled())
return -EINTR;
spin_lock_bh(&serv->sv_lock);
if ((svsk = svc_sock_dequeue(serv)) != NULL) {
rqstp->rq_sock = svsk;
svsk->sk_inuse++;
} else {
/* No data pending. Go to sleep */
svc_serv_enqueue(serv, rqstp);
/*
* We have to be able to interrupt this wait
* to bring down the daemons ...
*/
set_current_state(TASK_INTERRUPTIBLE);
add_wait_queue(&rqstp->rq_wait, &wait);
spin_unlock_bh(&serv->sv_lock);
schedule_timeout(timeout);
spin_lock_bh(&serv->sv_lock);
remove_wait_queue(&rqstp->rq_wait, &wait);
if (!(svsk = rqstp->rq_sock)) {
svc_serv_dequeue(serv, rqstp);
spin_unlock_bh(&serv->sv_lock);
dprintk("svc: server %p, no data yet\n", rqstp);
return signalled()? -EINTR : -EAGAIN;
}
}
spin_unlock_bh(&serv->sv_lock);
dprintk("svc: server %p, socket %p, inuse=%d\n",
rqstp, svsk, svsk->sk_inuse);
len = svsk->sk_recvfrom(rqstp);
dprintk("svc: got len=%d\n", len);
/* No data, incomplete (TCP) read, or accept() */
if (len == 0 || len == -EAGAIN) {
svc_sock_release(rqstp);
return -EAGAIN;
}
rqstp->rq_secure = ntohs(rqstp->rq_addr.sin_port) < 1024;
rqstp->rq_userset = 0;
rqstp->rq_verfed = 0;
svc_getlong(&rqstp->rq_argbuf, rqstp->rq_xid);
svc_putlong(&rqstp->rq_resbuf, rqstp->rq_xid);
/* Assume that the reply consists of a single buffer. */
rqstp->rq_resbuf.nriov = 1;
if (serv->sv_stats)
serv->sv_stats->netcnt++;
return len;
}