#include <sys/cdefs.h>
#ifndef lint
__RCSID("$NetBSD: lock_proc.c,v 1.7 2000/10/11 20:23:56 is Exp $");
#endif
#include <sys/param.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <stdio.h>
#include <string.h>
#include <syslog.h>
#include <stdlib.h>
#include <sys/queue.h>
#include <rpc/rpc.h>
#include <rpcsvc/sm_inter.h>
#include <rpcsvc/nlm_prot.h>
#include "lockd.h"
#include "lockd_lock.h"
#define CLIENT_CACHE_SIZE 64
#define CLIENT_CACHE_LIFETIME 120
static void log_from_addr(const char *, struct svc_req *);
static void log_netobj(netobj *obj);
static void
log_from_addr(fun_name, req)
const char *fun_name;
struct svc_req *req;
{
struct sockaddr_in *addr;
char hostname_buf[NI_MAXHOST];
addr = svc_getcaller(req->rq_xprt);
if (getnameinfo((struct sockaddr *)addr, sizeof(*addr), hostname_buf, sizeof hostname_buf,
NULL, 0, 0) != 0)
return;
syslog(LOG_DEBUG, "%s from %s", fun_name, hostname_buf);
}
static void
log_netobj(obj)
netobj *obj;
{
char objvalbuffer[(sizeof(char)*2)*MAX_NETOBJ_SZ+2];
char objascbuffer[sizeof(char)*MAX_NETOBJ_SZ+1];
unsigned int i, maxlen;
char *tmp1, *tmp2;
if (obj->n_len > MAX_NETOBJ_SZ) {
syslog(LOG_DEBUG, "SOMEONE IS TRYING TO DO SOMETHING NASTY!\n");
syslog(LOG_DEBUG, "netobj too large! Should be %d was %d\n",
MAX_NETOBJ_SZ, obj->n_len);
}
maxlen = (obj->n_len < MAX_NETOBJ_SZ ? obj->n_len : MAX_NETOBJ_SZ);
for (i=0, tmp1 = objvalbuffer, tmp2 = objascbuffer; i < obj->n_len;
i++, tmp1 +=2, tmp2 +=1) {
sprintf(tmp1,"%02X",*(obj->n_bytes+i));
sprintf(tmp2,"%c",*(obj->n_bytes+i));
}
*tmp1 = '\0';
*tmp2 = '\0';
syslog(LOG_DEBUG,"netobjvals: %s\n",objvalbuffer);
syslog(LOG_DEBUG,"netobjascs: %s\n",objascbuffer);
}
static CLIENT *clnt_cache_ptr[CLIENT_CACHE_SIZE];
static long clnt_cache_time[CLIENT_CACHE_SIZE];
static struct sockaddr_storage clnt_cache_addr[CLIENT_CACHE_SIZE];
static rpcvers_t clnt_cache_vers[CLIENT_CACHE_SIZE];
static int clnt_cache_next_to_use = 0;
struct badhost {
TAILQ_ENTRY(badhost) list;
struct sockaddr_storage addr;
int count;
time_t timelast;
time_t timenext;
};
TAILQ_HEAD(badhostlist_head, badhost);
static struct badhostlist_head badhostlist_head = TAILQ_HEAD_INITIALIZER(badhostlist_head);
#define BADHOST_CLIENT_TOOK_TOO_LONG 5
#define BADHOST_INITIAL_DELAY 120
#define BADHOST_MAXIMUM_DELAY 3600
#define BADHOST_DELAY_INCREMENT 300
int
addrcmp(const struct sockaddr *sa1, const struct sockaddr *sa2)
{
int len;
void *p1, *p2;
if (sa1->sa_family != sa2->sa_family)
return -1;
switch (sa1->sa_family) {
case AF_INET:
p1 = &((struct sockaddr_in *)sa1)->sin_addr;
p2 = &((struct sockaddr_in *)sa2)->sin_addr;
len = 4;
break;
case AF_INET6:
p1 = &((struct sockaddr_in6 *)sa1)->sin6_addr;
p2 = &((struct sockaddr_in6 *)sa2)->sin6_addr;
len = 16;
break;
default:
return -1;
}
return memcmp(p1, p2, len);
}
CLIENT *
get_client(host_addr, vers)
struct sockaddr *host_addr;
rpcvers_t vers;
{
CLIENT *client, *cached_client;
struct timeval retry_time, time_now;
int i;
int sock_no;
time_t time_start, cache_time = 0;
struct badhost *badhost, *nextbadhost;
gettimeofday(&time_now, NULL);
cached_client = NULL;
for (i = 0; i < CLIENT_CACHE_SIZE; i++) {
client = clnt_cache_ptr[i];
if (!client)
continue;
if (clnt_cache_vers[i] != vers)
continue;
if (addrcmp((struct sockaddr *)&clnt_cache_addr[i], host_addr))
continue;
if (((clnt_cache_time[i] + CLIENT_CACHE_LIFETIME) > time_now.tv_sec)) {
if (debug_level > 3)
syslog(LOG_DEBUG, "Found CLIENT* in cache");
return (client);
}
syslog(LOG_DEBUG, "Found expired CLIENT* in cache");
cached_client = client;
cache_time = clnt_cache_time[i];
clnt_cache_time[i] = 0L;
clnt_cache_ptr[i] = NULL;
client = NULL;
break;
}
badhost = TAILQ_FIRST(&badhostlist_head);
while (badhost) {
nextbadhost = TAILQ_NEXT(badhost, list);
if (!addrcmp(host_addr, (struct sockaddr *)&badhost->addr))
break;
if ((badhost->timelast + BADHOST_MAXIMUM_DELAY) < time_now.tv_sec) {
TAILQ_REMOVE(&badhostlist_head, badhost, list);
free(badhost);
}
badhost = nextbadhost;
}
if (badhost && (time_now.tv_sec < badhost->timenext)) {
if (cached_client) {
syslog(LOG_DEBUG, "badhost delayed: stale CLIENT* found in cache");
if (clnt_cache_ptr[clnt_cache_next_to_use]) {
clnt_destroy(clnt_cache_ptr[clnt_cache_next_to_use]);
clnt_cache_ptr[clnt_cache_next_to_use] = NULL;
}
client = cached_client;
goto update_cache_entry;
}
syslog(LOG_DEBUG, "badhost delayed: valid CLIENT* not found in cache");
return NULL;
}
if (debug_level > 3) {
if (!cached_client)
syslog(LOG_DEBUG, "CLIENT* not found in cache, creating");
else
syslog(LOG_DEBUG, "stale CLIENT* found in cache, updating");
}
if (clnt_cache_ptr[clnt_cache_next_to_use]) {
clnt_destroy(clnt_cache_ptr[clnt_cache_next_to_use]);
clnt_cache_ptr[clnt_cache_next_to_use] = NULL;
}
time_start = time_now.tv_sec;
sock_no = RPC_ANYSOCK;
retry_time.tv_sec = 5;
retry_time.tv_usec = 0;
((struct sockaddr_in *)host_addr)->sin_port = 0;
client = clntudp_create((struct sockaddr_in *)host_addr, NLM_PROG, vers, retry_time, &sock_no);
gettimeofday(&time_now, NULL);
if (time_now.tv_sec - time_start >= BADHOST_CLIENT_TOOK_TOO_LONG) {
if (!badhost && (badhost = malloc(sizeof(struct badhost)))) {
memcpy(&badhost->addr, host_addr, host_addr->sa_len);
badhost->count = 0;
TAILQ_INSERT_TAIL(&badhostlist_head, badhost, list);
}
if (badhost) {
badhost->count++;
badhost->timelast = time_now.tv_sec;
if (badhost->count == 1) {
badhost->timenext = time_now.tv_sec + BADHOST_INITIAL_DELAY;
} else {
int delay = (badhost->count - 1) * BADHOST_DELAY_INCREMENT;
if (delay > BADHOST_MAXIMUM_DELAY)
delay = BADHOST_MAXIMUM_DELAY;
badhost->timenext = time_now.tv_sec + delay;
}
TAILQ_REMOVE(&badhostlist_head, badhost, list);
TAILQ_INSERT_TAIL(&badhostlist_head, badhost, list);
}
} else if (badhost) {
TAILQ_REMOVE(&badhostlist_head, badhost, list);
free(badhost);
badhost = NULL;
}
if (!client) {
if (!cached_client) {
syslog(LOG_WARNING, "Unable to contact %s: %s",
inet_ntoa(((struct sockaddr_in *)host_addr)->sin_addr),
clnt_spcreateerror("clntudp_create"));
return NULL;
}
client = cached_client;
syslog(LOG_WARNING, "Unable to update contact info for %s: %s",
inet_ntoa(((struct sockaddr_in *)host_addr)->sin_addr),
clnt_spcreateerror("clntudp_create"));
} else {
if (cached_client)
clnt_destroy(cached_client);
retry_time.tv_sec = -1;
retry_time.tv_usec = -1;
clnt_control(client, CLSET_TIMEOUT, (char *)&retry_time);
if (debug_level > 3)
syslog(LOG_DEBUG, "Created CLIENT* for %s",
inet_ntoa(((struct sockaddr_in *)host_addr)->sin_addr));
cache_time = time_now.tv_sec;
}
update_cache_entry:
clnt_cache_ptr[clnt_cache_next_to_use] = client;
memcpy(&clnt_cache_addr[clnt_cache_next_to_use], host_addr,
host_addr->sa_len);
clnt_cache_vers[clnt_cache_next_to_use] = vers;
clnt_cache_time[clnt_cache_next_to_use] = cache_time;
if (++clnt_cache_next_to_use >= CLIENT_CACHE_SIZE)
clnt_cache_next_to_use = 0;
return client;
}
int
transmit_result(opcode, result, addr)
int opcode;
nlm_res *result;
struct sockaddr *addr;
{
static char dummy;
CLIENT *cli;
struct timeval timeo;
int success;
if ((cli = get_client(addr, NLM_VERS)) != NULL) {
timeo.tv_sec = 0;
timeo.tv_usec = 0;
success = clnt_call(cli, opcode, xdr_nlm_res, result, xdr_void,
&dummy, timeo);
if (debug_level > 2)
syslog(LOG_DEBUG, "clnt_call returns %d(%s)",
success, clnt_sperrno(success));
return (0);
}
return (-1);
}
int
transmit4_result(opcode, result, addr)
int opcode;
nlm4_res *result;
struct sockaddr *addr;
{
static char dummy;
CLIENT *cli;
struct timeval timeo;
int success;
if ((cli = get_client(addr, NLM_VERS4)) != NULL) {
timeo.tv_sec = 0;
timeo.tv_usec = 0;
success = clnt_call(cli, opcode, xdr_nlm4_res, result, xdr_void,
&dummy, timeo);
if (debug_level > 2)
syslog(LOG_DEBUG, "clnt_call returns %d(%s)",
success, clnt_sperrno(success));
return (0);
}
return (-1);
}
static void nlmtonlm4(struct nlm_lock *, struct nlm4_lock *);
static void
nlmtonlm4(arg, arg4)
struct nlm_lock *arg;
struct nlm4_lock *arg4;
{
arg4->caller_name = arg->caller_name;
arg4->fh = arg->fh;
arg4->oh = arg->oh;
arg4->svid = arg->svid;
arg4->l_offset = arg->l_offset;
arg4->l_len = arg->l_len;
}
nlm_testres *
nlm_test_1_svc(arg, rqstp)
nlm_testargs *arg;
struct svc_req *rqstp;
{
static nlm_testres res;
struct nlm4_lock arg4;
struct nlm4_holder *holder;
nlmtonlm4(&arg->alock, &arg4);
if (debug_level)
log_from_addr("nlm_test", rqstp);
holder = testlock(&arg4, arg->exclusive, 0);
res.cookie = arg->cookie;
if (holder == NULL) {
res.stat.stat = nlm_granted;
} else {
res.stat.stat = nlm_denied;
memcpy(&res.stat.nlm_testrply_u.holder, holder,
sizeof(struct nlm_holder));
res.stat.nlm_testrply_u.holder.l_offset = holder->l_offset;
res.stat.nlm_testrply_u.holder.l_len = holder->l_len;
}
return (&res);
}
void *
nlm_test_msg_1_svc(arg, rqstp)
nlm_testargs *arg;
struct svc_req *rqstp;
{
nlm_testres res;
static char dummy;
struct sockaddr *addr;
CLIENT *cli;
int success;
struct timeval timeo;
struct nlm4_lock arg4;
struct nlm4_holder *holder;
nlmtonlm4(&arg->alock, &arg4);
if (debug_level)
log_from_addr("nlm_test_msg", rqstp);
holder = testlock(&arg4, arg->exclusive, 0);
res.cookie = arg->cookie;
if (holder == NULL) {
res.stat.stat = nlm_granted;
} else {
res.stat.stat = nlm_denied;
memcpy(&res.stat.nlm_testrply_u.holder, holder,
sizeof(struct nlm_holder));
res.stat.nlm_testrply_u.holder.l_offset = holder->l_offset;
res.stat.nlm_testrply_u.holder.l_len = holder->l_len;
}
addr = (struct sockaddr *)svc_getcaller(rqstp->rq_xprt);
if ((cli = get_client(addr, NLM_VERS)) != NULL) {
timeo.tv_sec = 0;
timeo.tv_usec = 0;
success = clnt_call(cli, NLM_TEST_RES, xdr_nlm_testres,
&res, xdr_void, &dummy, timeo);
if (debug_level > 2)
syslog(LOG_DEBUG, "clnt_call returns %d", success);
}
return (NULL);
}
nlm_res *
nlm_lock_1_svc(arg, rqstp)
nlm_lockargs *arg;
struct svc_req *rqstp;
{
static nlm_res res;
struct nlm4_lockargs arg4;
nlmtonlm4(&arg->alock, &arg4.alock);
arg4.cookie = arg->cookie;
arg4.block = arg->block;
arg4.exclusive = arg->exclusive;
arg4.reclaim = arg->reclaim;
arg4.state = arg->state;
if (debug_level)
log_from_addr("nlm_lock", rqstp);
res.cookie = arg->cookie;
res.stat.stat = getlock(&arg4, rqstp, LOCK_MON);
return (&res);
}
void *
nlm_lock_msg_1_svc(arg, rqstp)
nlm_lockargs *arg;
struct svc_req *rqstp;
{
static nlm_res res;
struct nlm4_lockargs arg4;
nlmtonlm4(&arg->alock, &arg4.alock);
arg4.cookie = arg->cookie;
arg4.block = arg->block;
arg4.exclusive = arg->exclusive;
arg4.reclaim = arg->reclaim;
arg4.state = arg->state;
if (debug_level)
log_from_addr("nlm_lock_msg", rqstp);
res.cookie = arg->cookie;
res.stat.stat = getlock(&arg4, rqstp, LOCK_ASYNC | LOCK_MON);
if (transmit_result(NLM_LOCK_RES, &res,
(struct sockaddr *)svc_getcaller(rqstp->rq_xprt)) < 0) {
if (res.stat.stat == nlm_granted)
unlock(&arg4.alock, LOCK_V4);
else if (res.stat.stat == nlm_blocked) {
nlm4_cancargs carg;
carg.cookie = arg4.cookie;
carg.block = arg4.block;
carg.exclusive = arg4.exclusive;
carg.alock = arg4.alock;
cancellock(&carg, 0);
}
}
return (NULL);
}
nlm_res *
nlm_cancel_1_svc(arg, rqstp)
nlm_cancargs *arg;
struct svc_req *rqstp;
{
static nlm_res res;
struct nlm4_cancargs arg4;
arg4.cookie = arg->cookie;
arg4.block = arg->block;
arg4.exclusive = arg->exclusive;
nlmtonlm4(&arg->alock, &arg4.alock);
if (debug_level)
log_from_addr("nlm_cancel", rqstp);
res.cookie = arg->cookie;
res.stat.stat = cancellock(&arg4, 0);
return (&res);
}
void *
nlm_cancel_msg_1_svc(arg, rqstp)
nlm_cancargs *arg;
struct svc_req *rqstp;
{
static nlm_res res;
struct nlm4_cancargs arg4;
arg4.cookie = arg->cookie;
arg4.block = arg->block;
arg4.exclusive = arg->exclusive;
nlmtonlm4(&arg->alock, &arg4.alock);
if (debug_level)
log_from_addr("nlm_cancel_msg", rqstp);
res.cookie = arg->cookie;
res.stat.stat = cancellock(&arg4, 0);
if (transmit_result(NLM_CANCEL_RES, &res,
(struct sockaddr *)svc_getcaller(rqstp->rq_xprt)) < 0) {
}
return (NULL);
}
nlm_res *
nlm_unlock_1_svc(arg, rqstp)
nlm_unlockargs *arg;
struct svc_req *rqstp;
{
static nlm_res res;
struct nlm4_lock arg4;
nlmtonlm4(&arg->alock, &arg4);
if (debug_level)
log_from_addr("nlm_unlock", rqstp);
res.stat.stat = unlock(&arg4, 0);
res.cookie = arg->cookie;
return (&res);
}
void *
nlm_unlock_msg_1_svc(arg, rqstp)
nlm_unlockargs *arg;
struct svc_req *rqstp;
{
static nlm_res res;
struct nlm4_lock arg4;
nlmtonlm4(&arg->alock, &arg4);
if (debug_level)
log_from_addr("nlm_unlock_msg", rqstp);
res.stat.stat = unlock(&arg4, 0);
res.cookie = arg->cookie;
if (transmit_result(NLM_UNLOCK_RES, &res,
(struct sockaddr *)svc_getcaller(rqstp->rq_xprt)) < 0) {
}
return (NULL);
}
nlm_res *
nlm_granted_1_svc(arg, rqstp)
nlm_testargs *arg;
struct svc_req *rqstp;
{
static nlm_res res;
nlm4_lock lock4;
int flags;
if (debug_level)
log_from_addr("nlm_granted", rqstp);
lock4.fh = arg->alock.fh;
lock4.svid = arg->alock.svid;
lock4.l_offset = arg->alock.l_offset;
lock4.l_len = arg->alock.l_len;
flags = LOCK_ANSWER_GRANTED;
if (arg->exclusive)
flags |= LOCK_ANSWER_LOCK_EXCL;
if (lock_answer(NLM_VERS, &arg->cookie, &lock4, flags, nlm_granted))
res.stat.stat = nlm_denied;
else
res.stat.stat = nlm_granted;
res.cookie = arg->cookie;
return (&res);
}
void *
nlm_granted_msg_1_svc(arg, rqstp)
nlm_testargs *arg;
struct svc_req *rqstp;
{
static nlm_res res;
nlm4_lock lock4;
int flags;
if (debug_level)
log_from_addr("nlm_granted_msg", rqstp);
lock4.fh = arg->alock.fh;
lock4.svid = arg->alock.svid;
lock4.l_offset = arg->alock.l_offset;
lock4.l_len = arg->alock.l_len;
flags = LOCK_ANSWER_GRANTED;
if (arg->exclusive)
flags |= LOCK_ANSWER_LOCK_EXCL;
if (lock_answer(NLM_VERS, &arg->cookie, &lock4, flags, nlm_granted))
res.stat.stat = nlm_denied;
else
res.stat.stat = nlm_granted;
res.cookie = arg->cookie;
if (transmit_result(NLM_GRANTED_RES, &res,
(struct sockaddr *)svc_getcaller(rqstp->rq_xprt)) < 0) {
}
return (NULL);
}
void *
nlm_test_res_1_svc(arg, rqstp)
nlm_testres *arg;
struct svc_req *rqstp;
{
nlm4_lock lock4;
int flags = 0;
if (debug_level)
log_from_addr("nlm_test_res", rqstp);
if (arg->stat.stat == nlm_denied) {
lock4.fh.n_len = 0;
lock4.svid = arg->stat.nlm_testrply_u.holder.svid;
lock4.l_offset = arg->stat.nlm_testrply_u.holder.l_offset;
lock4.l_len = arg->stat.nlm_testrply_u.holder.l_len;
if (arg->stat.nlm_testrply_u.holder.exclusive)
flags |= LOCK_ANSWER_LOCK_EXCL;
lock_answer(NLM_VERS, &arg->cookie, &lock4, flags, arg->stat.stat);
} else
lock_answer(NLM_VERS, &arg->cookie, NULL, 0, arg->stat.stat);
return (NULL);
}
void *
nlm_lock_res_1_svc(arg, rqstp)
nlm_res *arg;
struct svc_req *rqstp;
{
if (debug_level)
log_from_addr("nlm_lock_res", rqstp);
lock_answer(NLM_VERS, &arg->cookie, NULL, 0, arg->stat.stat);
return (NULL);
}
void *
nlm_cancel_res_1_svc(arg, rqstp)
nlm_res *arg;
struct svc_req *rqstp;
{
if (debug_level)
log_from_addr("nlm_cancel_res", rqstp);
lock_answer(NLM_VERS, &arg->cookie, NULL, 0, arg->stat.stat);
return (NULL);
}
void *
nlm_unlock_res_1_svc(arg, rqstp)
nlm_res *arg;
struct svc_req *rqstp;
{
if (debug_level)
log_from_addr("nlm_unlock_res", rqstp);
lock_answer(NLM_VERS, &arg->cookie, NULL, 0, arg->stat.stat);
return (NULL);
}
void *
nlm_granted_res_1_svc(arg, rqstp)
nlm_res *arg;
struct svc_req *rqstp;
{
if (debug_level)
log_from_addr("nlm_granted_res", rqstp);
if (arg->stat.stat != nlm_granted) {
nlm4_res arg4;
arg4.cookie = arg->cookie;
arg4.stat.stat = arg->stat.stat;
granted_failed(&arg4);
}
return (NULL);
}
nlm_shareres *
nlm_share_3_svc(arg, rqstp)
nlm_shareargs *arg;
struct svc_req *rqstp;
{
static nlm_shareres res;
if (debug_level)
log_from_addr("nlm_share", rqstp);
res.cookie = arg->cookie;
res.sequence = 0;
res.stat = getshare(arg, rqstp, 0);
return (&res);
}
nlm_shareres *
nlm_unshare_3_svc(arg, rqstp)
nlm_shareargs *arg;
struct svc_req *rqstp;
{
static nlm_shareres res;
if (debug_level)
log_from_addr("nlm_unshare", rqstp);
res.cookie = arg->cookie;
res.sequence = 0;
res.stat = unshare(arg, rqstp, 0);
return (&res);
}
nlm_res *
nlm_nm_lock_3_svc(arg, rqstp)
nlm_lockargs *arg;
struct svc_req *rqstp;
{
static nlm_res res;
struct nlm4_lockargs arg4;
nlmtonlm4(&arg->alock, &arg4.alock);
arg4.cookie = arg->cookie;
arg4.block = arg->block;
arg4.exclusive = arg->exclusive;
arg4.reclaim = arg->reclaim;
arg4.state = arg->state;
if (debug_level)
log_from_addr("nlm_nm_lock", rqstp);
res.cookie = arg->cookie;
res.stat.stat = getlock(&arg4, rqstp, 0);
return (&res);
}
void *
nlm_free_all_3_svc(arg, rqstp)
nlm_notify *arg;
struct svc_req *rqstp;
{
static char dummy;
if (debug_level)
log_from_addr("nlm_free_all", rqstp);
do_free_all(arg->name);
return (&dummy);
}
nlm4_testres *
nlm4_test_4_svc(arg, rqstp)
nlm4_testargs *arg;
struct svc_req *rqstp;
{
static nlm4_testres res;
struct nlm4_holder *holder;
if (debug_level)
log_from_addr("nlm4_test", rqstp);
if (debug_level > 5) {
syslog(LOG_DEBUG, "Locking arguments:\n");
log_netobj(&(arg->cookie));
syslog(LOG_DEBUG, "Alock arguments:\n");
syslog(LOG_DEBUG, "Caller Name: %s\n",arg->alock.caller_name);
syslog(LOG_DEBUG, "File Handle:\n");
log_netobj(&(arg->alock.fh));
syslog(LOG_DEBUG, "Owner Handle:\n");
log_netobj(&(arg->alock.oh));
syslog(LOG_DEBUG, "SVID: %d\n", arg->alock.svid);
syslog(LOG_DEBUG, "Lock Offset: %llu\n",
(unsigned long long)arg->alock.l_offset);
syslog(LOG_DEBUG, "Lock Length: %llu\n",
(unsigned long long)arg->alock.l_len);
syslog(LOG_DEBUG, "Exclusive: %s\n",
(arg->exclusive ? "true" : "false"));
}
holder = testlock(&arg->alock, arg->exclusive, LOCK_V4);
res.cookie = arg->cookie;
if (holder == NULL) {
res.stat.stat = nlm4_granted;
} else {
res.stat.stat = nlm4_denied;
memcpy(&res.stat.nlm4_testrply_u.holder, holder,
sizeof(struct nlm4_holder));
}
return (&res);
}
void *
nlm4_test_msg_4_svc(arg, rqstp)
nlm4_testargs *arg;
struct svc_req *rqstp;
{
nlm4_testres res;
static char dummy;
struct sockaddr *addr;
CLIENT *cli;
int success;
struct timeval timeo;
struct nlm4_holder *holder;
if (debug_level)
log_from_addr("nlm4_test_msg", rqstp);
holder = testlock(&arg->alock, arg->exclusive, LOCK_V4);
res.cookie = arg->cookie;
if (holder == NULL) {
res.stat.stat = nlm4_granted;
} else {
res.stat.stat = nlm4_denied;
memcpy(&res.stat.nlm4_testrply_u.holder, holder,
sizeof(struct nlm4_holder));
}
addr = (struct sockaddr *)svc_getcaller(rqstp->rq_xprt);
if ((cli = get_client(addr, NLM_VERS4)) != NULL) {
timeo.tv_sec = 0;
timeo.tv_usec = 0;
success = clnt_call(cli, NLM4_TEST_RES, xdr_nlm4_testres,
&res, xdr_void, &dummy, timeo);
if (debug_level > 2)
syslog(LOG_DEBUG, "clnt_call returns %d", success);
}
return (NULL);
}
nlm4_res *
nlm4_lock_4_svc(arg, rqstp)
nlm4_lockargs *arg;
struct svc_req *rqstp;
{
static nlm4_res res;
if (debug_level)
log_from_addr("nlm4_lock", rqstp);
if (debug_level > 5) {
syslog(LOG_DEBUG, "Locking arguments:\n");
log_netobj(&(arg->cookie));
syslog(LOG_DEBUG, "Alock arguments:\n");
syslog(LOG_DEBUG, "Caller Name: %s\n",arg->alock.caller_name);
syslog(LOG_DEBUG, "File Handle:\n");
log_netobj(&(arg->alock.fh));
syslog(LOG_DEBUG, "Owner Handle:\n");
log_netobj(&(arg->alock.oh));
syslog(LOG_DEBUG, "SVID: %d\n", arg->alock.svid);
syslog(LOG_DEBUG, "Lock Offset: %llu\n",
(unsigned long long)arg->alock.l_offset);
syslog(LOG_DEBUG, "Lock Length: %llu\n",
(unsigned long long)arg->alock.l_len);
syslog(LOG_DEBUG, "Block: %s\n", (arg->block ? "true" : "false"));
syslog(LOG_DEBUG, "Exclusive: %s\n", (arg->exclusive ? "true" : "false"));
syslog(LOG_DEBUG, "Reclaim: %s\n", (arg->reclaim ? "true" : "false"));
syslog(LOG_DEBUG, "State num: %d\n", arg->state);
}
res.cookie = arg->cookie;
res.stat.stat = getlock(arg, rqstp, LOCK_MON | LOCK_V4);
return (&res);
}
void *
nlm4_lock_msg_4_svc(arg, rqstp)
nlm4_lockargs *arg;
struct svc_req *rqstp;
{
static nlm4_res res;
if (debug_level)
log_from_addr("nlm4_lock_msg", rqstp);
res.cookie = arg->cookie;
res.stat.stat = getlock(arg, rqstp, LOCK_MON | LOCK_ASYNC | LOCK_V4);
if (transmit4_result(NLM4_LOCK_RES, &res,
(struct sockaddr *)svc_getcaller(rqstp->rq_xprt)) < 0) {
if (res.stat.stat == nlm4_granted)
unlock(&arg->alock, LOCK_V4);
else if (res.stat.stat == nlm4_blocked) {
nlm4_cancargs carg;
carg.cookie = arg->cookie;
carg.block = arg->block;
carg.exclusive = arg->exclusive;
carg.alock = arg->alock;
cancellock(&carg, LOCK_V4);
}
}
return (NULL);
}
nlm4_res *
nlm4_cancel_4_svc(arg, rqstp)
nlm4_cancargs *arg;
struct svc_req *rqstp;
{
static nlm4_res res;
if (debug_level)
log_from_addr("nlm4_cancel", rqstp);
res.cookie = arg->cookie;
res.stat.stat = cancellock(arg, LOCK_V4);
return (&res);
}
void *
nlm4_cancel_msg_4_svc(arg, rqstp)
nlm4_cancargs *arg;
struct svc_req *rqstp;
{
static nlm4_res res;
if (debug_level)
log_from_addr("nlm4_cancel_msg", rqstp);
res.cookie = arg->cookie;
res.stat.stat = cancellock(arg, LOCK_V4);
if (transmit4_result(NLM4_CANCEL_RES, &res,
(struct sockaddr *)svc_getcaller(rqstp->rq_xprt)) < 0) {
}
return (NULL);
}
nlm4_res *
nlm4_unlock_4_svc(arg, rqstp)
nlm4_unlockargs *arg;
struct svc_req *rqstp;
{
static nlm4_res res;
if (debug_level)
log_from_addr("nlm4_unlock", rqstp);
res.stat.stat = unlock(&arg->alock, LOCK_V4);
res.cookie = arg->cookie;
return (&res);
}
void *
nlm4_unlock_msg_4_svc(arg, rqstp)
nlm4_unlockargs *arg;
struct svc_req *rqstp;
{
static nlm4_res res;
if (debug_level)
log_from_addr("nlm4_unlock_msg", rqstp);
res.stat.stat = unlock(&arg->alock, LOCK_V4);
res.cookie = arg->cookie;
if (transmit4_result(NLM4_UNLOCK_RES, &res,
(struct sockaddr *)svc_getcaller(rqstp->rq_xprt)) < 0) {
}
return (NULL);
}
nlm4_res *
nlm4_granted_4_svc(arg, rqstp)
nlm4_testargs *arg;
struct svc_req *rqstp;
{
static nlm4_res res;
int flags;
if (debug_level)
log_from_addr("nlm4_granted", rqstp);
flags = LOCK_ANSWER_GRANTED;
if (arg->exclusive)
flags |= LOCK_ANSWER_LOCK_EXCL;
if (lock_answer(NLM_VERS4, &arg->cookie, &arg->alock, flags, nlm4_granted))
res.stat.stat = nlm4_denied;
else
res.stat.stat = nlm4_granted;
res.cookie = arg->cookie;
return (&res);
}
void *
nlm4_granted_msg_4_svc(arg, rqstp)
nlm4_testargs *arg;
struct svc_req *rqstp;
{
static nlm4_res res;
int flags;
if (debug_level)
log_from_addr("nlm4_granted_msg", rqstp);
flags = LOCK_ANSWER_GRANTED;
if (arg->exclusive)
flags |= LOCK_ANSWER_LOCK_EXCL;
if (lock_answer(NLM_VERS4, &arg->cookie, &arg->alock, flags, nlm4_granted))
res.stat.stat = nlm4_denied;
else
res.stat.stat = nlm4_granted;
res.cookie = arg->cookie;
if (transmit4_result(NLM4_GRANTED_RES, &res,
(struct sockaddr *)svc_getcaller(rqstp->rq_xprt)) < 0) {
}
return (NULL);
}
void *
nlm4_test_res_4_svc(arg, rqstp)
nlm4_testres *arg;
struct svc_req *rqstp;
{
nlm4_lock lock4;
int flags = 0;
if (debug_level)
log_from_addr("nlm4_test_res", rqstp);
if (arg->stat.stat == nlm4_denied) {
lock4.fh.n_len = 0;
lock4.svid = arg->stat.nlm4_testrply_u.holder.svid;
lock4.l_offset = arg->stat.nlm4_testrply_u.holder.l_offset;
lock4.l_len = arg->stat.nlm4_testrply_u.holder.l_len;
if (arg->stat.nlm4_testrply_u.holder.exclusive)
flags |= LOCK_ANSWER_LOCK_EXCL;
lock_answer(NLM_VERS4, &arg->cookie, &lock4, flags, arg->stat.stat);
} else
lock_answer(NLM_VERS4, &arg->cookie, NULL, 0, arg->stat.stat);
return (NULL);
}
void *
nlm4_lock_res_4_svc(arg, rqstp)
nlm4_res *arg;
struct svc_req *rqstp;
{
if (debug_level)
log_from_addr("nlm4_lock_res", rqstp);
lock_answer(NLM_VERS4, &arg->cookie, NULL, 0, arg->stat.stat);
return (NULL);
}
void *
nlm4_cancel_res_4_svc(arg, rqstp)
nlm4_res *arg;
struct svc_req *rqstp;
{
if (debug_level)
log_from_addr("nlm4_cancel_res", rqstp);
lock_answer(NLM_VERS4, &arg->cookie, NULL, 0, arg->stat.stat);
return (NULL);
}
void *
nlm4_unlock_res_4_svc(arg, rqstp)
nlm4_res *arg __unused;
struct svc_req *rqstp;
{
if (debug_level)
log_from_addr("nlm4_unlock_res", rqstp);
lock_answer(NLM_VERS4, &arg->cookie, NULL, 0, arg->stat.stat);
return (NULL);
}
void *
nlm4_granted_res_4_svc(arg, rqstp)
nlm4_res *arg __unused;
struct svc_req *rqstp;
{
if (debug_level)
log_from_addr("nlm4_granted_res", rqstp);
if (arg->stat.stat != nlm4_granted)
granted_failed(arg);
return (NULL);
}
nlm4_shareres *
nlm4_share_4_svc(arg, rqstp)
nlm4_shareargs *arg;
struct svc_req *rqstp;
{
static nlm4_shareres res;
if (debug_level)
log_from_addr("nlm4_share", rqstp);
res.cookie = arg->cookie;
res.sequence = 0;
res.stat = getshare((nlm_shareargs*)arg, rqstp, LOCK_V4);
return (&res);
}
nlm4_shareres *
nlm4_unshare_4_svc(arg, rqstp)
nlm4_shareargs *arg;
struct svc_req *rqstp;
{
static nlm4_shareres res;
if (debug_level)
log_from_addr("nlm4_unshare", rqstp);
res.cookie = arg->cookie;
res.sequence = 0;
res.stat = unshare((nlm_shareargs*)arg, rqstp, LOCK_V4);
return (&res);
}
nlm4_res *
nlm4_nm_lock_4_svc(arg, rqstp)
nlm4_lockargs *arg;
struct svc_req *rqstp;
{
static nlm4_res res;
if (debug_level)
log_from_addr("nlm4_nm_lock", rqstp);
res.cookie = arg->cookie;
res.stat.stat = getlock(arg, rqstp, LOCK_V4);
return (&res);
}
void *
nlm4_free_all_4_svc(arg, rqstp)
struct nlm4_notify *arg;
struct svc_req *rqstp;
{
static char dummy;
if (debug_level)
log_from_addr("nlm4_free_all", rqstp);
do_free_all(arg->name);
return (&dummy);
}
void *
nlm_sm_notify_0_svc(arg, rqstp)
struct nlm_sm_status *arg;
struct svc_req *rqstp __unused;
{
static char dummy;
notify(arg->mon_name, arg->state);
return (&dummy);
}