1 /* @(#)svc_udp.c 2.2 88/07/29 4.0 RPCSRC */
3 * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
4 * unrestricted use provided that this legend is included on all tape
5 * media and as a part of the software program in whole or part. Users
6 * may copy or modify Sun RPC without charge, but are not authorized
7 * to license or distribute it to anyone else except as part of a product or
8 * program developed by the user.
10 * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
11 * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
12 * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
14 * Sun RPC is provided with no support and without any obligation on the
15 * part of Sun Microsystems, Inc. to assist in its use, correction,
16 * modification or enhancement.
18 * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
19 * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
20 * OR ANY PART THEREOF.
22 * In no event will Sun Microsystems, Inc. be liable for any lost revenue
23 * or profits or other special, indirect and consequential damages, even if
24 * Sun has been advised of the possibility of such damages.
26 * Sun Microsystems, Inc.
28 * Mountain View, California 94043
30 #if !defined(lint) && defined(SCCSIDS)
31 static char sccsid
[] = "@(#)svc_udp.c 1.24 87/08/11 Copyr 1984 Sun Micro";
36 * Server side for UDP/IP based RPC. (Does some caching in the hopes of
37 * achieving execute-at-most-once semantics.)
39 * Copyright (C) 1984, Sun Microsystems, Inc.
47 #include <sys/socket.h>
51 # include <libio/iolibio.h>
52 # define fputs(s, f) _IO_fputs (s, f)
55 #define rpc_buffer(xprt) ((xprt)->xp_p1)
57 #define MAX(a, b) ((a > b) ? a : b)
60 static bool_t
svcudp6_recv (SVCXPRT
*, struct rpc_msg
*);
61 static bool_t
svcudp6_reply (SVCXPRT
*, struct rpc_msg
*);
62 static enum xprt_stat
svcudp6_stat (SVCXPRT
*);
63 static bool_t
svcudp6_getargs (SVCXPRT
*, xdrproc_t
, caddr_t
);
64 static bool_t
svcudp6_freeargs (SVCXPRT
*, xdrproc_t
, caddr_t
);
65 static void svcudp6_destroy (SVCXPRT
*);
67 static const struct xp_ops svcudp6_op
=
77 static int cache_get (SVCXPRT
*, struct rpc_msg
*, char **replyp
,
79 static void cache_set (SVCXPRT
*xprt
, u_long replylen
);
86 u_int su_iosz
; /* byte size of send.recv buffer */
87 u_long su_xid
; /* transaction id */
88 XDR su_xdrs
; /* XDR handle */
89 char su_verfbody
[MAX_AUTH_BYTES
]; /* verifier body */
90 char *su_cache
; /* cached data, NULL if no cache */
92 #define su_data(xprt) ((struct svcudp_data *)(xprt->xp_p2))
96 * xprt = svcudp_create(sock);
98 * If sock<0 then a socket is created, else sock is used.
99 * If the socket, sock is not bound to a port then svcudp_create
100 * binds it to an arbitrary port. In any (successful) case,
101 * xprt->xp_sock is the registered socket number and xprt->xp_port is the
102 * associated port number.
103 * Once *xprt is initialized, it is registered as a transporter;
104 * see (svc.h, xprt_register).
105 * The routines returns NULL if a problem occurred.
108 svcudp6_bufcreate (sock
, sendsz
, recvsz
)
110 u_int sendsz
, recvsz
;
112 bool_t madesock
= FALSE
;
114 struct svcudp_data
*su
;
115 struct sockaddr_in6 addr
;
116 socklen_t len
= sizeof (struct sockaddr_in6
);
118 if (sock
== RPC_ANYSOCK
)
120 if ((sock
= __socket (AF_INET6
, SOCK_DGRAM
, IPPROTO_UDP
)) < 0)
122 perror (_("svcudp_create: socket creation problem"));
123 return (SVCXPRT
*) NULL
;
127 __bzero ((char *) &addr
, sizeof (addr
));
128 addr
.sin6_family
= AF_INET6
;
129 if (bindresvport6 (sock
, &addr
))
132 (void) bind (sock
, (struct sockaddr
*) &addr
, len
);
134 if (getsockname (sock
, (struct sockaddr
*) &addr
, &len
) != 0)
136 perror (_("svcudp_create - cannot getsockname"));
138 (void) __close (sock
);
139 return (SVCXPRT
*) NULL
;
141 xprt
= (SVCXPRT
*) mem_alloc (sizeof (SVCXPRT
));
144 (void) fputs (_("svcudp_create: out of memory\n"), stderr
);
147 su
= (struct svcudp_data
*) mem_alloc (sizeof (*su
));
150 (void) fputs (_("svcudp_create: out of memory\n"), stderr
);
153 su
->su_iosz
= ((MAX (sendsz
, recvsz
) + 3) / 4) * 4;
154 if ((rpc_buffer (xprt
) = mem_alloc (su
->su_iosz
)) == NULL
)
156 (void) fputs (_("svcudp_create: out of memory\n"), stderr
);
159 xdrmem_create (&(su
->su_xdrs
), rpc_buffer (xprt
), su
->su_iosz
, XDR_DECODE
);
161 xprt
->xp_p2
= (caddr_t
) su
;
162 xprt
->xp_verf
.oa_base
= su
->su_verfbody
;
163 xprt
->xp_ops
= &svcudp6_op
;
164 xprt
->xp_port
= ntohs (addr
.sin6_port
);
165 xprt
->xp_sock
= sock
;
166 xprt_register (xprt
);
171 svcudp6_create (sock
)
175 return svcudp6_bufcreate (sock
, UDPMSGSIZE
, UDPMSGSIZE
);
178 static enum xprt_stat
187 svcudp6_recv (xprt
, msg
)
191 struct svcudp_data
*su
= su_data (xprt
);
192 XDR
*xdrs
= &(su
->su_xdrs
);
199 /* FIXME -- should xp_addrlen be a size_t? */
200 len
= (socklen_t
) sizeof(struct sockaddr_in6
);
201 rlen
= recvfrom (xprt
->xp_sock
, rpc_buffer (xprt
), (int) su
->su_iosz
, 0,
202 (struct sockaddr
*) &(xprt
->xp_raddr
), &len
);
203 xprt
->xp_addrlen
= len
;
204 if (rlen
== -1 && errno
== EINTR
)
206 if (rlen
< 16) /* < 4 32-bit ints? */
208 xdrs
->x_op
= XDR_DECODE
;
209 XDR_SETPOS (xdrs
, 0);
210 if (!xdr_callmsg (xdrs
, msg
))
212 su
->su_xid
= msg
->rm_xid
;
213 if (su
->su_cache
!= NULL
)
215 if (cache_get (xprt
, msg
, &reply
, &replylen
))
217 (void) sendto (xprt
->xp_sock
, reply
, (int) replylen
, 0,
218 (struct sockaddr
*) &xprt
->xp_raddr
, len
);
226 svcudp6_reply (xprt
, msg
)
230 struct svcudp_data
*su
= su_data (xprt
);
231 XDR
*xdrs
= &(su
->su_xdrs
);
235 xdrs
->x_op
= XDR_ENCODE
;
236 XDR_SETPOS (xdrs
, 0);
237 msg
->rm_xid
= su
->su_xid
;
238 if (xdr_replymsg (xdrs
, msg
))
240 slen
= (int) XDR_GETPOS (xdrs
);
241 if (sendto (xprt
->xp_sock
, rpc_buffer (xprt
), slen
, 0,
242 (struct sockaddr
*) &(xprt
->xp_raddr
), xprt
->xp_addrlen
)
246 if (su
->su_cache
&& slen
>= 0)
248 cache_set (xprt
, (u_long
) slen
);
256 svcudp6_getargs (xprt
, xdr_args
, args_ptr
)
262 return (*xdr_args
) (&(su_data (xprt
)->su_xdrs
), args_ptr
);
266 svcudp6_freeargs (xprt
, xdr_args
, args_ptr
)
271 XDR
*xdrs
= &(su_data (xprt
)->su_xdrs
);
273 xdrs
->x_op
= XDR_FREE
;
274 return (*xdr_args
) (xdrs
, args_ptr
);
278 svcudp6_destroy (xprt
)
281 struct svcudp_data
*su
= su_data (xprt
);
283 xprt_unregister (xprt
);
284 (void) __close (xprt
->xp_sock
);
285 XDR_DESTROY (&(su
->su_xdrs
));
286 mem_free (rpc_buffer (xprt
), su
->su_iosz
);
287 mem_free ((caddr_t
) su
, sizeof (struct svcudp_data
));
288 mem_free ((caddr_t
) xprt
, sizeof (SVCXPRT
));
292 /***********this could be a separate file*********************/
295 * Fifo cache for udp server
296 * Copies pointers to reply buffers into fifo cache
297 * Buffers are sent again if retransmissions are detected.
300 #define SPARSENESS 4 /* 75% sparse */
302 #define CACHE_PERROR(msg) \
303 (void) fprintf(stderr,"%s\n", msg)
305 #define ALLOC(type, size) \
306 (type *) mem_alloc((unsigned) (sizeof(type) * (size)))
308 #define BZERO(addr, type, size) \
309 __bzero((char *) addr, sizeof(type) * (int) (size))
312 * An entry in the cache
314 typedef struct cache_node
*cache_ptr
;
318 * Index into cache is xid, proc, vers, prog and address
324 struct sockaddr_in6 cache_addr
;
326 * The cached reply and length
329 u_long cache_replylen
;
331 * Next node on the list, if there is a collision
333 cache_ptr cache_next
;
343 u_long uc_size
; /* size of cache */
344 cache_ptr
*uc_entries
; /* hash table of entries in cache */
345 cache_ptr
*uc_fifo
; /* fifo list of entries in cache */
346 u_long uc_nextvictim
; /* points to next victim in fifo list */
347 u_long uc_prog
; /* saved program number */
348 u_long uc_vers
; /* saved version number */
349 u_long uc_proc
; /* saved procedure number */
350 struct sockaddr_in6 uc_addr
; /* saved caller's address */
355 * the hashing function
357 #define CACHE_LOC(transp, xid) \
358 (xid % (SPARSENESS*((struct udp_cache *) su_data(transp)->su_cache)->uc_size))
362 * Enable use of the cache.
363 * Note: there is no disable.
366 svcudp6_enablecache (SVCXPRT
*transp
, u_long size
)
368 struct svcudp_data
*su
= su_data (transp
);
369 struct udp_cache
*uc
;
371 if (su
->su_cache
!= NULL
)
373 CACHE_PERROR (_("enablecache: cache already enabled"));
376 uc
= ALLOC (struct udp_cache
, 1);
379 CACHE_PERROR (_("enablecache: could not allocate cache"));
383 uc
->uc_nextvictim
= 0;
384 uc
->uc_entries
= ALLOC (cache_ptr
, size
* SPARSENESS
);
385 if (uc
->uc_entries
== NULL
)
387 CACHE_PERROR (_("enablecache: could not allocate cache data"));
390 BZERO (uc
->uc_entries
, cache_ptr
, size
* SPARSENESS
);
391 uc
->uc_fifo
= ALLOC (cache_ptr
, size
);
392 if (uc
->uc_fifo
== NULL
)
394 CACHE_PERROR (_("enablecache: could not allocate cache fifo"));
397 BZERO (uc
->uc_fifo
, cache_ptr
, size
);
398 su
->su_cache
= (char *) uc
;
404 * Set an entry in the cache
407 cache_set (SVCXPRT
*xprt
, u_long replylen
)
411 struct svcudp_data
*su
= su_data (xprt
);
412 struct udp_cache
*uc
= (struct udp_cache
*) su
->su_cache
;
417 * Find space for the new entry, either by
418 * reusing an old entry, or by mallocing a new one
420 victim
= uc
->uc_fifo
[uc
->uc_nextvictim
];
423 loc
= CACHE_LOC (xprt
, victim
->cache_xid
);
424 for (vicp
= &uc
->uc_entries
[loc
];
425 *vicp
!= NULL
&& *vicp
!= victim
;
426 vicp
= &(*vicp
)->cache_next
)
430 CACHE_PERROR (_("cache_set: victim not found"));
433 *vicp
= victim
->cache_next
; /* remote from cache */
434 newbuf
= victim
->cache_reply
;
438 victim
= ALLOC (struct cache_node
, 1);
441 CACHE_PERROR (_("cache_set: victim alloc failed"));
444 newbuf
= mem_alloc (su
->su_iosz
);
447 CACHE_PERROR (_("cache_set: could not allocate new rpc_buffer"));
455 victim
->cache_replylen
= replylen
;
456 victim
->cache_reply
= rpc_buffer (xprt
);
457 rpc_buffer (xprt
) = newbuf
;
458 xdrmem_create (&(su
->su_xdrs
), rpc_buffer (xprt
), su
->su_iosz
, XDR_ENCODE
);
459 victim
->cache_xid
= su
->su_xid
;
460 victim
->cache_proc
= uc
->uc_proc
;
461 victim
->cache_vers
= uc
->uc_vers
;
462 victim
->cache_prog
= uc
->uc_prog
;
463 victim
->cache_addr
= uc
->uc_addr
;
464 loc
= CACHE_LOC (xprt
, victim
->cache_xid
);
465 victim
->cache_next
= uc
->uc_entries
[loc
];
466 uc
->uc_entries
[loc
] = victim
;
467 uc
->uc_fifo
[uc
->uc_nextvictim
++] = victim
;
468 uc
->uc_nextvictim
%= uc
->uc_size
;
472 * Try to get an entry from the cache
473 * return 1 if found, 0 if not found
476 cache_get (xprt
, msg
, replyp
, replylenp
)
484 struct svcudp_data
*su
= su_data (xprt
);
485 struct udp_cache
*uc
= (struct udp_cache
*) su
->su_cache
;
487 #define EQADDR(a1, a2) (memcmp((char*)&a1, (char*)&a2, sizeof(a1)) == 0)
489 loc
= CACHE_LOC (xprt
, su
->su_xid
);
490 for (ent
= uc
->uc_entries
[loc
]; ent
!= NULL
; ent
= ent
->cache_next
)
492 if (ent
->cache_xid
== su
->su_xid
&&
493 ent
->cache_proc
== uc
->uc_proc
&&
494 ent
->cache_vers
== uc
->uc_vers
&&
495 ent
->cache_prog
== uc
->uc_prog
&&
496 EQADDR (ent
->cache_addr
, uc
->uc_addr
))
498 *replyp
= ent
->cache_reply
;
499 *replylenp
= ent
->cache_replylen
;
504 * Failed to find entry
505 * Remember a few things so we can do a set later
507 uc
->uc_proc
= msg
->rm_call
.cb_proc
;
508 uc
->uc_vers
= msg
->rm_call
.cb_vers
;
509 uc
->uc_prog
= msg
->rm_call
.cb_prog
;
510 memcpy (&uc
->uc_addr
, &xprt
->xp_raddr
, sizeof (uc
->uc_addr
));