xref: /freebsd/lib/libc/rpc/svc_dg.c (revision 282a3889ebf826db9839be296ff1dd903f6d6d6e)
1 /*	$NetBSD: svc_dg.c,v 1.4 2000/07/06 03:10:35 christos Exp $	*/
2 
3 /*
4  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
5  * unrestricted use provided that this legend is included on all tape
6  * media and as a part of the software program in whole or part.  Users
7  * may copy or modify Sun RPC without charge, but are not authorized
8  * to license or distribute it to anyone else except as part of a product or
9  * program developed by the user.
10  *
11  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
12  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
13  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
14  *
15  * Sun RPC is provided with no support and without any obligation on the
16  * part of Sun Microsystems, Inc. to assist in its use, correction,
17  * modification or enhancement.
18  *
19  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
20  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
21  * OR ANY PART THEREOF.
22  *
23  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
24  * or profits or other special, indirect and consequential damages, even if
25  * Sun has been advised of the possibility of such damages.
26  *
27  * Sun Microsystems, Inc.
28  * 2550 Garcia Avenue
29  * Mountain View, California  94043
30  */
31 
32 /*
33  * Copyright (c) 1986-1991 by Sun Microsystems Inc.
34  */
35 
36 #if defined(LIBC_SCCS) && !defined(lint)
37 #ident	"@(#)svc_dg.c	1.17	94/04/24 SMI"
38 #endif
39 #include <sys/cdefs.h>
40 __FBSDID("$FreeBSD$");
41 
42 /*
43  * svc_dg.c, Server side for connectionless RPC.
44  *
45  * Does some caching in the hopes of achieving execute-at-most-once semantics.
46  */
47 
48 #include "namespace.h"
49 #include "reentrant.h"
50 #include <sys/types.h>
51 #include <sys/socket.h>
52 #include <rpc/rpc.h>
53 #include <rpc/svc_dg.h>
54 #include <errno.h>
55 #include <unistd.h>
56 #include <stdio.h>
57 #include <stdlib.h>
58 #include <string.h>
59 #ifdef RPC_CACHE_DEBUG
60 #include <netconfig.h>
61 #include <netdir.h>
62 #endif
63 #include <err.h>
64 #include "un-namespace.h"
65 
66 #include "rpc_com.h"
67 #include "mt_misc.h"
68 
69 #define	su_data(xprt)	((struct svc_dg_data *)(xprt->xp_p2))
70 #define	rpc_buffer(xprt) ((xprt)->xp_p1)
71 
72 #ifndef MAX
73 #define	MAX(a, b)	(((a) > (b)) ? (a) : (b))
74 #endif
75 
76 static void svc_dg_ops(SVCXPRT *);
77 static enum xprt_stat svc_dg_stat(SVCXPRT *);
78 static bool_t svc_dg_recv(SVCXPRT *, struct rpc_msg *);
79 static bool_t svc_dg_reply(SVCXPRT *, struct rpc_msg *);
80 static bool_t svc_dg_getargs(SVCXPRT *, xdrproc_t, void *);
81 static bool_t svc_dg_freeargs(SVCXPRT *, xdrproc_t, void *);
82 static void svc_dg_destroy(SVCXPRT *);
83 static bool_t svc_dg_control(SVCXPRT *, const u_int, void *);
84 static int cache_get(SVCXPRT *, struct rpc_msg *, char **, size_t *);
85 static void cache_set(SVCXPRT *, size_t);
86 int svc_dg_enablecache(SVCXPRT *, u_int);
87 
88 /*
89  * Usage:
90  *	xprt = svc_dg_create(sock, sendsize, recvsize);
91  * Does other connectionless specific initializations.
92  * Once *xprt is initialized, it is registered.
93  * see (svc.h, xprt_register). If recvsize or sendsize are 0 suitable
94  * system defaults are chosen.
95  * The routines returns NULL if a problem occurred.
96  */
97 static const char svc_dg_str[] = "svc_dg_create: %s";
98 static const char svc_dg_err1[] = "could not get transport information";
99 static const char svc_dg_err2[] = " transport does not support data transfer";
100 static const char __no_mem_str[] = "out of memory";
101 
102 SVCXPRT *
103 svc_dg_create(fd, sendsize, recvsize)
104 	int fd;
105 	u_int sendsize;
106 	u_int recvsize;
107 {
108 	SVCXPRT *xprt;
109 	struct svc_dg_data *su = NULL;
110 	struct __rpc_sockinfo si;
111 	struct sockaddr_storage ss;
112 	socklen_t slen;
113 
114 	if (!__rpc_fd2sockinfo(fd, &si)) {
115 		warnx(svc_dg_str, svc_dg_err1);
116 		return (NULL);
117 	}
118 	/*
119 	 * Find the receive and the send size
120 	 */
121 	sendsize = __rpc_get_t_size(si.si_af, si.si_proto, (int)sendsize);
122 	recvsize = __rpc_get_t_size(si.si_af, si.si_proto, (int)recvsize);
123 	if ((sendsize == 0) || (recvsize == 0)) {
124 		warnx(svc_dg_str, svc_dg_err2);
125 		return (NULL);
126 	}
127 
128 	xprt = mem_alloc(sizeof (SVCXPRT));
129 	if (xprt == NULL)
130 		goto freedata;
131 	memset(xprt, 0, sizeof (SVCXPRT));
132 
133 	su = mem_alloc(sizeof (*su));
134 	if (su == NULL)
135 		goto freedata;
136 	su->su_iosz = ((MAX(sendsize, recvsize) + 3) / 4) * 4;
137 	if ((rpc_buffer(xprt) = mem_alloc(su->su_iosz)) == NULL)
138 		goto freedata;
139 	xdrmem_create(&(su->su_xdrs), rpc_buffer(xprt), su->su_iosz,
140 		XDR_DECODE);
141 	su->su_cache = NULL;
142 	xprt->xp_fd = fd;
143 	xprt->xp_p2 = su;
144 	xprt->xp_verf.oa_base = su->su_verfbody;
145 	svc_dg_ops(xprt);
146 	xprt->xp_rtaddr.maxlen = sizeof (struct sockaddr_storage);
147 
148 	slen = sizeof ss;
149 	if (_getsockname(fd, (struct sockaddr *)(void *)&ss, &slen) < 0)
150 		goto freedata;
151 	xprt->xp_ltaddr.buf = mem_alloc(sizeof (struct sockaddr_storage));
152 	xprt->xp_ltaddr.maxlen = sizeof (struct sockaddr_storage);
153 	xprt->xp_ltaddr.len = slen;
154 	memcpy(xprt->xp_ltaddr.buf, &ss, slen);
155 
156 	xprt_register(xprt);
157 	return (xprt);
158 freedata:
159 	(void) warnx(svc_dg_str, __no_mem_str);
160 	if (xprt) {
161 		if (su)
162 			(void) mem_free(su, sizeof (*su));
163 		(void) mem_free(xprt, sizeof (SVCXPRT));
164 	}
165 	return (NULL);
166 }
167 
168 /*ARGSUSED*/
169 static enum xprt_stat
170 svc_dg_stat(xprt)
171 	SVCXPRT *xprt;
172 {
173 	return (XPRT_IDLE);
174 }
175 
176 static bool_t
177 svc_dg_recv(xprt, msg)
178 	SVCXPRT *xprt;
179 	struct rpc_msg *msg;
180 {
181 	struct svc_dg_data *su = su_data(xprt);
182 	XDR *xdrs = &(su->su_xdrs);
183 	char *reply;
184 	struct sockaddr_storage ss;
185 	socklen_t alen;
186 	size_t replylen;
187 	ssize_t rlen;
188 
189 again:
190 	alen = sizeof (struct sockaddr_storage);
191 	rlen = _recvfrom(xprt->xp_fd, rpc_buffer(xprt), su->su_iosz, 0,
192 	    (struct sockaddr *)(void *)&ss, &alen);
193 	if (rlen == -1 && errno == EINTR)
194 		goto again;
195 	if (rlen == -1 || (rlen < (ssize_t)(4 * sizeof (u_int32_t))))
196 		return (FALSE);
197 	if (xprt->xp_rtaddr.len < alen) {
198 		if (xprt->xp_rtaddr.len != 0)
199 			mem_free(xprt->xp_rtaddr.buf, xprt->xp_rtaddr.len);
200 		xprt->xp_rtaddr.buf = mem_alloc(alen);
201 		xprt->xp_rtaddr.len = alen;
202 	}
203 	memcpy(xprt->xp_rtaddr.buf, &ss, alen);
204 #ifdef PORTMAP
205 	if (ss.ss_family == AF_INET) {
206 		xprt->xp_raddr = *(struct sockaddr_in *)xprt->xp_rtaddr.buf;
207 		xprt->xp_addrlen = sizeof (struct sockaddr_in);
208 	}
209 #endif				/* PORTMAP */
210 	xdrs->x_op = XDR_DECODE;
211 	XDR_SETPOS(xdrs, 0);
212 	if (! xdr_callmsg(xdrs, msg)) {
213 		return (FALSE);
214 	}
215 	su->su_xid = msg->rm_xid;
216 	if (su->su_cache != NULL) {
217 		if (cache_get(xprt, msg, &reply, &replylen)) {
218 			(void)_sendto(xprt->xp_fd, reply, replylen, 0,
219 			    (struct sockaddr *)(void *)&ss, alen);
220 			return (FALSE);
221 		}
222 	}
223 	return (TRUE);
224 }
225 
226 static bool_t
227 svc_dg_reply(xprt, msg)
228 	SVCXPRT *xprt;
229 	struct rpc_msg *msg;
230 {
231 	struct svc_dg_data *su = su_data(xprt);
232 	XDR *xdrs = &(su->su_xdrs);
233 	bool_t stat = FALSE;
234 	size_t slen;
235 
236 	xdrs->x_op = XDR_ENCODE;
237 	XDR_SETPOS(xdrs, 0);
238 	msg->rm_xid = su->su_xid;
239 	if (xdr_replymsg(xdrs, msg)) {
240 		slen = XDR_GETPOS(xdrs);
241 		if (_sendto(xprt->xp_fd, rpc_buffer(xprt), slen, 0,
242 		    (struct sockaddr *)xprt->xp_rtaddr.buf,
243 		    (socklen_t)xprt->xp_rtaddr.len) == (ssize_t) slen) {
244 			stat = TRUE;
245 			if (su->su_cache)
246 				cache_set(xprt, slen);
247 		}
248 	}
249 	return (stat);
250 }
251 
252 static bool_t
253 svc_dg_getargs(xprt, xdr_args, args_ptr)
254 	SVCXPRT *xprt;
255 	xdrproc_t xdr_args;
256 	void *args_ptr;
257 {
258 	return (*xdr_args)(&(su_data(xprt)->su_xdrs), args_ptr);
259 }
260 
261 static bool_t
262 svc_dg_freeargs(xprt, xdr_args, args_ptr)
263 	SVCXPRT *xprt;
264 	xdrproc_t xdr_args;
265 	void *args_ptr;
266 {
267 	XDR *xdrs = &(su_data(xprt)->su_xdrs);
268 
269 	xdrs->x_op = XDR_FREE;
270 	return (*xdr_args)(xdrs, args_ptr);
271 }
272 
273 static void
274 svc_dg_destroy(xprt)
275 	SVCXPRT *xprt;
276 {
277 	struct svc_dg_data *su = su_data(xprt);
278 
279 	xprt_unregister(xprt);
280 	if (xprt->xp_fd != -1)
281 		(void)_close(xprt->xp_fd);
282 	XDR_DESTROY(&(su->su_xdrs));
283 	(void) mem_free(rpc_buffer(xprt), su->su_iosz);
284 	(void) mem_free(su, sizeof (*su));
285 	if (xprt->xp_rtaddr.buf)
286 		(void) mem_free(xprt->xp_rtaddr.buf, xprt->xp_rtaddr.maxlen);
287 	if (xprt->xp_ltaddr.buf)
288 		(void) mem_free(xprt->xp_ltaddr.buf, xprt->xp_ltaddr.maxlen);
289 	if (xprt->xp_tp)
290 		(void) free(xprt->xp_tp);
291 	(void) mem_free(xprt, sizeof (SVCXPRT));
292 }
293 
294 static bool_t
295 /*ARGSUSED*/
296 svc_dg_control(xprt, rq, in)
297 	SVCXPRT *xprt;
298 	const u_int	rq;
299 	void		*in;
300 {
301 	return (FALSE);
302 }
303 
304 static void
305 svc_dg_ops(xprt)
306 	SVCXPRT *xprt;
307 {
308 	static struct xp_ops ops;
309 	static struct xp_ops2 ops2;
310 
311 /* VARIABLES PROTECTED BY ops_lock: ops */
312 
313 	mutex_lock(&ops_lock);
314 	if (ops.xp_recv == NULL) {
315 		ops.xp_recv = svc_dg_recv;
316 		ops.xp_stat = svc_dg_stat;
317 		ops.xp_getargs = svc_dg_getargs;
318 		ops.xp_reply = svc_dg_reply;
319 		ops.xp_freeargs = svc_dg_freeargs;
320 		ops.xp_destroy = svc_dg_destroy;
321 		ops2.xp_control = svc_dg_control;
322 	}
323 	xprt->xp_ops = &ops;
324 	xprt->xp_ops2 = &ops2;
325 	mutex_unlock(&ops_lock);
326 }
327 
328 /*  The CACHING COMPONENT */
329 
330 /*
331  * Could have been a separate file, but some part of it depends upon the
332  * private structure of the client handle.
333  *
334  * Fifo cache for cl server
335  * Copies pointers to reply buffers into fifo cache
336  * Buffers are sent again if retransmissions are detected.
337  */
338 
339 #define	SPARSENESS 4	/* 75% sparse */
340 
341 #define	ALLOC(type, size)	\
342 	(type *) mem_alloc((sizeof (type) * (size)))
343 
344 #define	MEMZERO(addr, type, size)	 \
345 	(void) memset((void *) (addr), 0, sizeof (type) * (int) (size))
346 
347 #define	FREE(addr, type, size)	\
348 	mem_free((addr), (sizeof (type) * (size)))
349 
350 /*
351  * An entry in the cache
352  */
353 typedef struct cache_node *cache_ptr;
354 struct cache_node {
355 	/*
356 	 * Index into cache is xid, proc, vers, prog and address
357 	 */
358 	u_int32_t cache_xid;
359 	rpcproc_t cache_proc;
360 	rpcvers_t cache_vers;
361 	rpcprog_t cache_prog;
362 	struct netbuf cache_addr;
363 	/*
364 	 * The cached reply and length
365 	 */
366 	char *cache_reply;
367 	size_t cache_replylen;
368 	/*
369 	 * Next node on the list, if there is a collision
370 	 */
371 	cache_ptr cache_next;
372 };
373 
374 /*
375  * The entire cache
376  */
377 struct cl_cache {
378 	u_int uc_size;		/* size of cache */
379 	cache_ptr *uc_entries;	/* hash table of entries in cache */
380 	cache_ptr *uc_fifo;	/* fifo list of entries in cache */
381 	u_int uc_nextvictim;	/* points to next victim in fifo list */
382 	rpcprog_t uc_prog;	/* saved program number */
383 	rpcvers_t uc_vers;	/* saved version number */
384 	rpcproc_t uc_proc;	/* saved procedure number */
385 };
386 
387 
388 /*
389  * the hashing function
390  */
391 #define	CACHE_LOC(transp, xid)	\
392 	(xid % (SPARSENESS * ((struct cl_cache *) \
393 		su_data(transp)->su_cache)->uc_size))
394 
395 /*
396  * Enable use of the cache. Returns 1 on success, 0 on failure.
397  * Note: there is no disable.
398  */
399 static const char cache_enable_str[] = "svc_enablecache: %s %s";
400 static const char alloc_err[] = "could not allocate cache ";
401 static const char enable_err[] = "cache already enabled";
402 
403 int
404 svc_dg_enablecache(transp, size)
405 	SVCXPRT *transp;
406 	u_int size;
407 {
408 	struct svc_dg_data *su = su_data(transp);
409 	struct cl_cache *uc;
410 
411 	mutex_lock(&dupreq_lock);
412 	if (su->su_cache != NULL) {
413 		(void) warnx(cache_enable_str, enable_err, " ");
414 		mutex_unlock(&dupreq_lock);
415 		return (0);
416 	}
417 	uc = ALLOC(struct cl_cache, 1);
418 	if (uc == NULL) {
419 		warnx(cache_enable_str, alloc_err, " ");
420 		mutex_unlock(&dupreq_lock);
421 		return (0);
422 	}
423 	uc->uc_size = size;
424 	uc->uc_nextvictim = 0;
425 	uc->uc_entries = ALLOC(cache_ptr, size * SPARSENESS);
426 	if (uc->uc_entries == NULL) {
427 		warnx(cache_enable_str, alloc_err, "data");
428 		FREE(uc, struct cl_cache, 1);
429 		mutex_unlock(&dupreq_lock);
430 		return (0);
431 	}
432 	MEMZERO(uc->uc_entries, cache_ptr, size * SPARSENESS);
433 	uc->uc_fifo = ALLOC(cache_ptr, size);
434 	if (uc->uc_fifo == NULL) {
435 		warnx(cache_enable_str, alloc_err, "fifo");
436 		FREE(uc->uc_entries, cache_ptr, size * SPARSENESS);
437 		FREE(uc, struct cl_cache, 1);
438 		mutex_unlock(&dupreq_lock);
439 		return (0);
440 	}
441 	MEMZERO(uc->uc_fifo, cache_ptr, size);
442 	su->su_cache = (char *)(void *)uc;
443 	mutex_unlock(&dupreq_lock);
444 	return (1);
445 }
446 
447 /*
448  * Set an entry in the cache.  It assumes that the uc entry is set from
449  * the earlier call to cache_get() for the same procedure.  This will always
450  * happen because cache_get() is calle by svc_dg_recv and cache_set() is called
451  * by svc_dg_reply().  All this hoopla because the right RPC parameters are
452  * not available at svc_dg_reply time.
453  */
454 
455 static const char cache_set_str[] = "cache_set: %s";
456 static const char cache_set_err1[] = "victim not found";
457 static const char cache_set_err2[] = "victim alloc failed";
458 static const char cache_set_err3[] = "could not allocate new rpc buffer";
459 
460 static void
461 cache_set(xprt, replylen)
462 	SVCXPRT *xprt;
463 	size_t replylen;
464 {
465 	cache_ptr victim;
466 	cache_ptr *vicp;
467 	struct svc_dg_data *su = su_data(xprt);
468 	struct cl_cache *uc = (struct cl_cache *) su->su_cache;
469 	u_int loc;
470 	char *newbuf;
471 #ifdef RPC_CACHE_DEBUG
472 	struct netconfig *nconf;
473 	char *uaddr;
474 #endif
475 
476 	mutex_lock(&dupreq_lock);
477 	/*
478 	 * Find space for the new entry, either by
479 	 * reusing an old entry, or by mallocing a new one
480 	 */
481 	victim = uc->uc_fifo[uc->uc_nextvictim];
482 	if (victim != NULL) {
483 		loc = CACHE_LOC(xprt, victim->cache_xid);
484 		for (vicp = &uc->uc_entries[loc];
485 			*vicp != NULL && *vicp != victim;
486 			vicp = &(*vicp)->cache_next)
487 			;
488 		if (*vicp == NULL) {
489 			warnx(cache_set_str, cache_set_err1);
490 			mutex_unlock(&dupreq_lock);
491 			return;
492 		}
493 		*vicp = victim->cache_next;	/* remove from cache */
494 		newbuf = victim->cache_reply;
495 	} else {
496 		victim = ALLOC(struct cache_node, 1);
497 		if (victim == NULL) {
498 			warnx(cache_set_str, cache_set_err2);
499 			mutex_unlock(&dupreq_lock);
500 			return;
501 		}
502 		newbuf = mem_alloc(su->su_iosz);
503 		if (newbuf == NULL) {
504 			warnx(cache_set_str, cache_set_err3);
505 			FREE(victim, struct cache_node, 1);
506 			mutex_unlock(&dupreq_lock);
507 			return;
508 		}
509 	}
510 
511 	/*
512 	 * Store it away
513 	 */
514 #ifdef RPC_CACHE_DEBUG
515 	if (nconf = getnetconfigent(xprt->xp_netid)) {
516 		uaddr = taddr2uaddr(nconf, &xprt->xp_rtaddr);
517 		freenetconfigent(nconf);
518 		printf(
519 	"cache set for xid= %x prog=%d vers=%d proc=%d for rmtaddr=%s\n",
520 			su->su_xid, uc->uc_prog, uc->uc_vers,
521 			uc->uc_proc, uaddr);
522 		free(uaddr);
523 	}
524 #endif
525 	victim->cache_replylen = replylen;
526 	victim->cache_reply = rpc_buffer(xprt);
527 	rpc_buffer(xprt) = newbuf;
528 	xdrmem_create(&(su->su_xdrs), rpc_buffer(xprt),
529 			su->su_iosz, XDR_ENCODE);
530 	victim->cache_xid = su->su_xid;
531 	victim->cache_proc = uc->uc_proc;
532 	victim->cache_vers = uc->uc_vers;
533 	victim->cache_prog = uc->uc_prog;
534 	victim->cache_addr = xprt->xp_rtaddr;
535 	victim->cache_addr.buf = ALLOC(char, xprt->xp_rtaddr.len);
536 	(void) memcpy(victim->cache_addr.buf, xprt->xp_rtaddr.buf,
537 	    (size_t)xprt->xp_rtaddr.len);
538 	loc = CACHE_LOC(xprt, victim->cache_xid);
539 	victim->cache_next = uc->uc_entries[loc];
540 	uc->uc_entries[loc] = victim;
541 	uc->uc_fifo[uc->uc_nextvictim++] = victim;
542 	uc->uc_nextvictim %= uc->uc_size;
543 	mutex_unlock(&dupreq_lock);
544 }
545 
546 /*
547  * Try to get an entry from the cache
548  * return 1 if found, 0 if not found and set the stage for cache_set()
549  */
550 static int
551 cache_get(xprt, msg, replyp, replylenp)
552 	SVCXPRT *xprt;
553 	struct rpc_msg *msg;
554 	char **replyp;
555 	size_t *replylenp;
556 {
557 	u_int loc;
558 	cache_ptr ent;
559 	struct svc_dg_data *su = su_data(xprt);
560 	struct cl_cache *uc = (struct cl_cache *) su->su_cache;
561 #ifdef RPC_CACHE_DEBUG
562 	struct netconfig *nconf;
563 	char *uaddr;
564 #endif
565 
566 	mutex_lock(&dupreq_lock);
567 	loc = CACHE_LOC(xprt, su->su_xid);
568 	for (ent = uc->uc_entries[loc]; ent != NULL; ent = ent->cache_next) {
569 		if (ent->cache_xid == su->su_xid &&
570 			ent->cache_proc == msg->rm_call.cb_proc &&
571 			ent->cache_vers == msg->rm_call.cb_vers &&
572 			ent->cache_prog == msg->rm_call.cb_prog &&
573 			ent->cache_addr.len == xprt->xp_rtaddr.len &&
574 			(memcmp(ent->cache_addr.buf, xprt->xp_rtaddr.buf,
575 				xprt->xp_rtaddr.len) == 0)) {
576 #ifdef RPC_CACHE_DEBUG
577 			if (nconf = getnetconfigent(xprt->xp_netid)) {
578 				uaddr = taddr2uaddr(nconf, &xprt->xp_rtaddr);
579 				freenetconfigent(nconf);
580 				printf(
581 	"cache entry found for xid=%x prog=%d vers=%d proc=%d for rmtaddr=%s\n",
582 					su->su_xid, msg->rm_call.cb_prog,
583 					msg->rm_call.cb_vers,
584 					msg->rm_call.cb_proc, uaddr);
585 				free(uaddr);
586 			}
587 #endif
588 			*replyp = ent->cache_reply;
589 			*replylenp = ent->cache_replylen;
590 			mutex_unlock(&dupreq_lock);
591 			return (1);
592 		}
593 	}
594 	/*
595 	 * Failed to find entry
596 	 * Remember a few things so we can do a set later
597 	 */
598 	uc->uc_proc = msg->rm_call.cb_proc;
599 	uc->uc_vers = msg->rm_call.cb_vers;
600 	uc->uc_prog = msg->rm_call.cb_prog;
601 	mutex_unlock(&dupreq_lock);
602 	return (0);
603 }
604