![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pmap_rmt.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / new / sunrpc|
Return to pmap_rmt.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / sunrpc |
1.1 root 1: /*
2: * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
3: * unrestricted use provided that this legend is included on all tape
4: * media and as a part of the software program in whole or part. Users
5: * may copy or modify Sun RPC without charge, but are not authorized
6: * to license or distribute it to anyone else except as part of a product or
7: * program developed by the user.
8: *
9: * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
10: * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
11: * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
12: *
13: * Sun RPC is provided with no support and without any obligation on the
14: * part of Sun Microsystems, Inc. to assist in its use, correction,
15: * modification or enhancement.
16: *
17: * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
18: * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
19: * OR ANY PART THEREOF.
20: *
21: * In no event will Sun Microsystems, Inc. be liable for any lost revenue
22: * or profits or other special, indirect and consequential damages, even if
23: * Sun has been advised of the possibility of such damages.
24: *
25: * Sun Microsystems, Inc.
26: * 2550 Garcia Avenue
27: * Mountain View, California 94043
28: */
29: #ifndef lint
30: static char sccsid[] = "@(#)pmap_rmt.c 1.5 85/04/08 Copyr 1984 Sun Micro";
31: #endif
32:
33: /*
34: * pmap_rmt.c
35: * Client interface to pmap rpc service.
36: * remote call and broadcast service
37: *
38: * Copyright (C) 1984, Sun Microsystems, Inc.
39: */
40:
41: #include "types.h"
42: #include <netinet/in.h>
43: #include "xdr.h"
44: #include "auth.h"
45: #include "clnt.h"
46: #include "rpc_msg.h"
47: #include "pmap_prot.h"
48: #include "pmap_clnt.h"
49: #include <sys/socket.h>
50: #include <sys/time.h>
51: #include <stdio.h>
52: #include <errno.h>
53: #include <net/if.h>
54: #include <sys/ioctl.h>
55: #include <arpa/inet.h>
56: #define MAX_BROADCAST_SIZE 1400
57:
58: extern int errno;
59: static struct timeval timeout = { 3, 0 };
60:
61: /*
62: * Structures and XDR routines for parameters to and replys from
63: * the pmapper remote-call-service.
64: */
65:
66: struct rmtcallargs {
67: u_long prog, vers, proc, arglen;
68: caddr_t args_ptr;
69: xdrproc_t xdr_args;
70: };
71: static bool_t xdr_rmtcall_args();
72:
73: struct rmtcallres {
74: u_long *port_ptr;
75: u_long resultslen;
76: caddr_t results_ptr;
77: xdrproc_t xdr_results;
78: };
79: static bool_t xdr_rmtcallres();
80:
81: /*
82: * pmapper remote-call-service interface.
83: * This routine is used to call the pmapper remote call service
84: * which will look up a service program in the port maps, and then
85: * remotely call that routine with the given parameters. This allows
86: * programs to do a lookup and call in one step.
87: */
88: enum clnt_stat
89: pmap_rmtcall(addr, prog, vers, proc, xdrargs, argsp, xdrres, resp, tout, port_ptr)
90: struct sockaddr_in *addr;
91: u_long prog, vers, proc;
92: xdrproc_t xdrargs, xdrres;
93: caddr_t argsp, resp;
94: struct timeval tout;
95: u_long *port_ptr;
96: {
97: int socket = -1;
98: register CLIENT *client;
99: struct rmtcallargs a;
100: struct rmtcallres r;
101: enum clnt_stat stat;
102:
103: addr->sin_port = htons(PMAPPORT);
104: client = clntudp_create(addr, PMAPPROG, PMAPVERS, timeout, &socket);
105: if (client != (CLIENT *)NULL) {
106: a.prog = prog;
107: a.vers = vers;
108: a.proc = proc;
109: a.args_ptr = argsp;
110: a.xdr_args = xdrargs;
111: r.port_ptr = port_ptr;
112: r.results_ptr = resp;
113: r.xdr_results = xdrres;
114: stat = CLNT_CALL(client, PMAPPROC_CALLIT, xdr_rmtcall_args, &a,
115: xdr_rmtcallres, &r, tout);
116: CLNT_DESTROY(client);
117: } else {
118: stat = RPC_FAILED;
119: }
120: (void)close(socket);
121: addr->sin_port = 0;
122: return (stat);
123: }
124:
125: /*
126: * XDR remote call arguments
127: * written for XDR_ENCODE direction only
128: */
129: static bool_t
130: xdr_rmtcall_args(xdrs, cap)
131: register XDR *xdrs;
132: register struct rmtcallargs *cap;
133: {
134: u_int lenposition, argposition, position;
135:
136: if (xdr_u_long(xdrs, &(cap->prog)) &&
137: xdr_u_long(xdrs, &(cap->vers)) &&
138: xdr_u_long(xdrs, &(cap->proc))) {
139: lenposition = XDR_GETPOS(xdrs);
140: if (! xdr_u_long(xdrs, &(cap->arglen)))
141: return (FALSE);
142: argposition = XDR_GETPOS(xdrs);
143: if (! (*(cap->xdr_args))(xdrs, cap->args_ptr))
144: return (FALSE);
145: position = XDR_GETPOS(xdrs);
146: cap->arglen = (u_long)position - (u_long)argposition;
147: XDR_SETPOS(xdrs, lenposition);
148: if (! xdr_u_long(xdrs, &(cap->arglen)))
149: return (FALSE);
150: XDR_SETPOS(xdrs, position);
151: return (TRUE);
152: }
153: return (FALSE);
154: }
155:
156: /*
157: * XDR remote call results
158: * written for XDR_DECODE direction only
159: */
160: static bool_t
161: xdr_rmtcallres(xdrs, crp)
162: register XDR *xdrs;
163: register struct rmtcallres *crp;
164: {
165:
166: if (xdr_reference(xdrs, &crp->port_ptr, sizeof (u_long), xdr_u_long) &&
167: xdr_u_long(xdrs, &crp->resultslen))
168: return ((*(crp->xdr_results))(xdrs, crp->results_ptr));
169: return (FALSE);
170: }
171:
172: /*
173: * The following is kludged-up support for simple rpc broadcasts.
174: * Someday a large, complicated system will replace these trivial
175: * routines which only support udp/ip .
176: */
177:
178: static int
179: getbroadcastnets(addrs, sock, buf)
180: struct in_addr *addrs;
181: int sock; /* any valid socket will do */
182: char *buf; /* why allocxate more when we can use existing... */
183: {
184: struct ifconf ifc;
185: struct ifreq ifreq, *ifr;
186: struct sockaddr_in *sin;
187: int n, i;
188:
189: ifc.ifc_len = MAX_BROADCAST_SIZE;
190: ifc.ifc_buf = buf;
191: if (ioctl(sock, SIOCGIFCONF, (char *)&ifc) < 0) {
192: perror("broadcast: ioctl (get interface configuration)");
193: return (0);
194: }
195: ifr = ifc.ifc_req;
196: for (i = 0, n = ifc.ifc_len/sizeof (struct ifreq); n > 0; n--, ifr++) {
197: ifreq = *ifr;
198: if (ioctl(sock, SIOCGIFFLAGS, (char *)&ifreq) < 0) {
199: perror("broadcast: ioctl (get interface flags)");
200: continue;
201: }
202: if ((ifreq.ifr_flags & IFF_BROADCAST) &&
203: (ifreq.ifr_flags & IFF_UP) &&
204: ifr->ifr_addr.sa_family == AF_INET) {
205: sin = (struct sockaddr_in *)&ifr->ifr_addr;
206: addrs[i++] = inet_makeaddr(inet_netof
207: (sin->sin_addr.s_addr), INADDR_ANY);
208: }
209: }
210: return (i);
211: }
212:
213: typedef bool_t (*resultproc_t)();
214:
215: enum clnt_stat
216: clnt_broadcast(prog, vers, proc, xargs, argsp, xresults, resultsp, eachresult)
217: u_long prog; /* program number */
218: u_long vers; /* version number */
219: u_long proc; /* procedure number */
220: xdrproc_t xargs; /* xdr routine for args */
221: caddr_t argsp; /* pointer to args */
222: xdrproc_t xresults; /* xdr routine for results */
223: caddr_t resultsp; /* pointer to results */
224: resultproc_t eachresult; /* call with each result obtained */
225: {
226: enum clnt_stat stat;
227: AUTH *unix_auth = authunix_create_default();
228: XDR xdr_stream;
229: register XDR *xdrs = &xdr_stream;
230: int outlen, inlen, fromlen, readfds, nets;
231: register int sock, mask, i;
232: bool_t done = FALSE;
233: register u_long xid;
234: u_long port;
235: struct in_addr addrs[20];
236: struct sockaddr_in baddr, raddr; /* broadcast and response addresses */
237: struct rmtcallargs a;
238: struct rmtcallres r;
239: struct rpc_msg msg;
240: struct timeval t;
241: char outbuf[MAX_BROADCAST_SIZE], inbuf[MAX_BROADCAST_SIZE];
242:
243: /*
244: * initialization: create a socket, a broadcast address, and
245: * preserialize the arguments into a send buffer.
246: */
247: if ((sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
248: perror("Cannot create socket for broadcast rpc");
249: stat = RPC_CANTSEND;
250: goto done_broad;
251: }
252: mask = (1 << sock);
253: nets = getbroadcastnets(addrs, sock, inbuf);
254: bzero(&baddr, sizeof (baddr));
255: baddr.sin_family = AF_INET;
256: baddr.sin_port = htons(PMAPPORT);
257: baddr.sin_addr.s_addr = htonl(INADDR_ANY);
258: (void)gettimeofday(&t, (struct timezone *)0);
259: msg.rm_xid = xid = getpid() ^ t.tv_sec ^ t.tv_usec;
260: t.tv_usec = 0;
261: msg.rm_direction = CALL;
262: msg.rm_call.cb_rpcvers = RPC_MSG_VERSION;
263: msg.rm_call.cb_prog = PMAPPROG;
264: msg.rm_call.cb_vers = PMAPVERS;
265: msg.rm_call.cb_proc = PMAPPROC_CALLIT;
266: msg.rm_call.cb_cred = unix_auth->ah_cred;
267: msg.rm_call.cb_verf = unix_auth->ah_verf;
268: a.prog = prog;
269: a.vers = vers;
270: a.proc = proc;
271: a.xdr_args = xargs;
272: a.args_ptr = argsp;
273: r.port_ptr = &port;
274: r.xdr_results = xresults;
275: r.results_ptr = resultsp;
276: xdrmem_create(xdrs, outbuf, MAX_BROADCAST_SIZE, XDR_ENCODE);
277: if ((! xdr_callmsg(xdrs, &msg)) || (! xdr_rmtcall_args(xdrs, &a))) {
278: stat = RPC_CANTENCODEARGS;
279: goto done_broad;
280: }
281: outlen = (int)xdr_getpos(xdrs);
282: xdr_destroy(xdrs);
283: /*
284: * Basic loop: broadcast a packet and wait a while for response(s).
285: * The response timeout grows larger per iteration.
286: */
287: for (t.tv_sec = 2; t.tv_sec <= 6; t.tv_sec += 2) {
288: for (i = 0; i < nets; i++) {
289: baddr.sin_addr = addrs[i];
290: if (sendto(sock, outbuf, outlen, 0,
291: (struct socketaddr *)&baddr,
292: sizeof (struct sockaddr)) != outlen) {
293: perror("Cannot send broadcast packet");
294: stat = RPC_CANTSEND;
295: goto done_broad;
296: }
297: }
298: recv_again:
299: msg.acpted_rply.ar_verf = _null_auth;
300: msg.acpted_rply.ar_results.where = (caddr_t)&r;
301: msg.acpted_rply.ar_results.proc = xdr_rmtcallres;
302: readfds = mask;
303: switch (select(32, &readfds, (int *)NULL, (int *)NULL, &t)) {
304:
305: case 0: /* timed out */
306: stat = RPC_TIMEDOUT;
307: continue;
308:
309: case -1: /* some kind of error */
310: if (errno == EINTR)
311: goto recv_again;
312: perror("Broadcast select problem");
313: stat = RPC_CANTRECV;
314: goto done_broad;
315:
316: } /* end of select results switch */
317: if ((readfds & mask) == 0)
318: goto recv_again;
319: try_again:
320: fromlen = sizeof(struct sockaddr);
321: inlen = recvfrom(sock, inbuf, MAX_BROADCAST_SIZE, 0,
322: (struct sockaddr *)&raddr, &fromlen);
323: if (inlen < 0) {
324: if (errno == EINTR)
325: goto try_again;
326: perror("Cannot receive reply to broadcast");
327: stat = RPC_CANTRECV;
328: goto done_broad;
329: }
330: if (inlen < sizeof(u_long))
331: goto recv_again;
332: /*
333: * see if reply transaction id matches sent id.
334: * If so, decode the results.
335: */
336: xdrmem_create(xdrs, inbuf, inlen, XDR_DECODE);
337: if (xdr_replymsg(xdrs, &msg)) {
338: if ((msg.rm_xid == xid) &&
339: (msg.rm_reply.rp_stat == MSG_ACCEPTED) &&
340: (msg.acpted_rply.ar_stat == SUCCESS)) {
341: raddr.sin_port = htons((u_short)port);
342: done = (*eachresult)(resultsp, &raddr);
343: }
344: /* otherwise, we just ignore the errors ... */
345: } else {
346: /* some kind of deserialization problem ... */
347: if (msg.rm_xid == xid)
348: fprintf(stderr, "Broadcast deserialization problem");
349: /* otherwise, just random garbage */
350: }
351: xdrs->x_op = XDR_FREE;
352: msg.acpted_rply.ar_results.proc = xdr_void;
353: (void)xdr_replymsg(xdrs, &msg);
354: (void)(*xresults)(xdrs, resultsp);
355: xdr_destroy(xdrs);
356: if (done) {
357: stat = RPC_SUCCESS;
358: goto done_broad;
359: } else {
360: goto recv_again;
361: }
362: }
363: done_broad:
364: (void)close(sock);
365: AUTH_DESTROY(unix_auth);
366: return (stat);
367: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.