Annotation of sys/lib/libsa/bootparam.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: bootparam.c,v 1.11 2003/08/11 06:23:09 deraadt Exp $ */
2: /* $NetBSD: bootparam.c,v 1.10 1996/10/14 21:16:55 thorpej Exp $ */
3:
4: /*
5: * Copyright (c) 1995 Gordon W. Ross
6: * All rights reserved.
7: *
8: * Redistribution and use in source and binary forms, with or without
9: * modification, are permitted provided that the following conditions
10: * are met:
11: * 1. Redistributions of source code must retain the above copyright
12: * notice, this list of conditions and the following disclaimer.
13: * 2. Redistributions in binary form must reproduce the above copyright
14: * notice, this list of conditions and the following disclaimer in the
15: * documentation and/or other materials provided with the distribution.
16: * 3. The name of the author may not be used to endorse or promote products
17: * derived from this software without specific prior written permission.
18: * 4. All advertising materials mentioning features or use of this software
19: * must display the following acknowledgement:
20: * This product includes software developed by Gordon W. Ross
21: *
22: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
23: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
24: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
25: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
26: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
27: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
31: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32: */
33:
34: /*
35: * RPC/bootparams
36: */
37:
38: #include <sys/param.h>
39: #include <sys/socket.h>
40:
41: #include <net/if.h>
42:
43: #include <netinet/in.h>
44: #include <netinet/in_systm.h>
45:
46: #include <nfs/rpcv2.h>
47:
48: #include "stand.h"
49: #include "net.h"
50: #include "netif.h"
51: #include "rpc.h"
52: #include "bootparam.h"
53:
54: #ifdef DEBUG_RPC
55: #define RPC_PRINTF(a) printf a
56: #else
57: #define RPC_PRINTF(a) /* printf a */
58: #endif
59:
60: struct in_addr bp_server_addr; /* net order */
61: n_short bp_server_port; /* net order */
62:
63: /*
64: * RPC definitions for bootparamd
65: */
66: #define BOOTPARAM_PROG 100026
67: #define BOOTPARAM_VERS 1
68: #define BOOTPARAM_WHOAMI 1
69: #define BOOTPARAM_GETFILE 2
70:
71: /*
72: * Inet address in RPC messages
73: * (Note, really four ints, NOT chars. Blech.)
74: */
75: struct xdr_inaddr {
76: u_int32_t atype;
77: int32_t addr[4];
78: };
79:
80: int xdr_inaddr_encode(char **p, struct in_addr ia);
81: int xdr_inaddr_decode(char **p, struct in_addr *ia);
82:
83: int xdr_string_encode(char **p, char *str, int len);
84: int xdr_string_decode(char **p, char *str, int *len_p);
85:
86:
87: /*
88: * RPC: bootparam/whoami
89: * Given client IP address, get:
90: * client name (hostname)
91: * domain name (domainname)
92: * gateway address
93: *
94: * The hostname and domainname are set here for convenience.
95: *
96: * Note - bpsin is initialized to the broadcast address,
97: * and will be replaced with the bootparam server address
98: * after this call is complete. Have to use PMAP_PROC_CALL
99: * to make sure we get responses only from a servers that
100: * know about us (don't want to broadcast a getport call).
101: */
102: int
103: bp_whoami(int sockfd)
104: {
105: /* RPC structures for PMAPPROC_CALLIT */
106: struct args {
107: u_int32_t prog;
108: u_int32_t vers;
109: u_int32_t proc;
110: u_int32_t arglen;
111: struct xdr_inaddr xina;
112: } *args;
113: struct repl {
114: u_int16_t _pad;
115: u_int16_t port;
116: u_int32_t encap_len;
117: /* encapsulated data here */
118: n_long capsule[64];
119: } *repl;
120: struct {
121: n_long h[RPC_HEADER_WORDS];
122: struct args d;
123: } sdata;
124: struct {
125: n_long h[RPC_HEADER_WORDS];
126: struct repl d;
127: } rdata;
128: char *send_tail, *recv_head;
129: struct iodesc *d;
130: int len, x;
131:
132: RPC_PRINTF(("bp_whoami: myip=%s\n", inet_ntoa(myip)));
133:
134: if (!(d = socktodesc(sockfd))) {
135: RPC_PRINTF(("bp_whoami: bad socket. %d\n", sockfd));
136: return (-1);
137: }
138: args = &sdata.d;
139: repl = &rdata.d;
140:
141: /*
142: * Build request args for PMAPPROC_CALLIT.
143: */
144: args->prog = htonl(BOOTPARAM_PROG);
145: args->vers = htonl(BOOTPARAM_VERS);
146: args->proc = htonl(BOOTPARAM_WHOAMI);
147: args->arglen = htonl(sizeof(struct xdr_inaddr));
148: send_tail = (char *)&args->xina;
149:
150: /*
151: * append encapsulated data (client IP address)
152: */
153: if (xdr_inaddr_encode(&send_tail, myip))
154: return (-1);
155:
156: /* RPC: portmap/callit */
157: d->myport = htons(--rpc_port);
158: d->destip.s_addr = INADDR_BROADCAST; /* XXX: subnet bcast? */
159: /* rpc_call will set d->destport */
160:
161: len = rpc_call(d, PMAPPROG, PMAPVERS, PMAPPROC_CALLIT,
162: args, send_tail - (char *)args,
163: repl, sizeof(*repl));
164: if (len < 8) {
165: printf("bootparamd: 'whoami' call failed\n");
166: return (-1);
167: }
168:
169: /* Save bootparam server address (from IP header). */
170: rpc_fromaddr(repl, &bp_server_addr, &bp_server_port);
171:
172: /*
173: * Note that bp_server_port is now 111 due to the
174: * indirect call (using PMAPPROC_CALLIT), so get the
175: * actual port number from the reply data.
176: */
177: bp_server_port = repl->port;
178:
179: RPC_PRINTF(("bp_whoami: server at %s:%d\n",
180: inet_ntoa(bp_server_addr), ntohs(bp_server_port)));
181:
182: /* We have just done a portmap call, so cache the portnum. */
183: rpc_pmap_putcache(bp_server_addr, BOOTPARAM_PROG, BOOTPARAM_VERS,
184: (int)ntohs(bp_server_port));
185:
186: /*
187: * Parse the encapsulated results from bootparam/whoami
188: */
189: x = ntohl(repl->encap_len);
190: if (len < x) {
191: printf("bp_whoami: short reply, %d < %d\n", len, x);
192: return (-1);
193: }
194: recv_head = (char *)repl->capsule;
195:
196: /* client name */
197: hostnamelen = MAXHOSTNAMELEN-1;
198: if (xdr_string_decode(&recv_head, hostname, &hostnamelen)) {
199: RPC_PRINTF(("bp_whoami: bad hostname\n"));
200: return (-1);
201: }
202:
203: /* domain name */
204: domainnamelen = MAXHOSTNAMELEN-1;
205: if (xdr_string_decode(&recv_head, domainname, &domainnamelen)) {
206: RPC_PRINTF(("bp_whoami: bad domainname\n"));
207: return (-1);
208: }
209:
210: /* gateway address */
211: if (xdr_inaddr_decode(&recv_head, &gateip)) {
212: RPC_PRINTF(("bp_whoami: bad gateway\n"));
213: return (-1);
214: }
215:
216: /* success */
217: return(0);
218: }
219:
220:
221: /*
222: * RPC: bootparam/getfile
223: * Given client name and file "key", get:
224: * server name
225: * server IP address
226: * server pathname
227: */
228: int
229: bp_getfile(int sockfd, char *key, struct in_addr *serv_addr, char *pathname)
230: {
231: struct {
232: n_long h[RPC_HEADER_WORDS];
233: n_long d[64];
234: } sdata;
235: struct {
236: n_long h[RPC_HEADER_WORDS];
237: n_long d[128];
238: } rdata;
239: char serv_name[FNAME_SIZE];
240: char *send_tail, *recv_head;
241: /* misc... */
242: struct iodesc *d;
243: int sn_len, path_len, rlen;
244:
245: if (!(d = socktodesc(sockfd))) {
246: RPC_PRINTF(("bp_getfile: bad socket. %d\n", sockfd));
247: return (-1);
248: }
249:
250: send_tail = (char *)sdata.d;
251: recv_head = (char *)rdata.d;
252:
253: /*
254: * Build request message.
255: */
256:
257: /* client name (hostname) */
258: if (xdr_string_encode(&send_tail, hostname, hostnamelen)) {
259: RPC_PRINTF(("bp_getfile: bad client\n"));
260: return (-1);
261: }
262:
263: /* key name (root or swap) */
264: if (xdr_string_encode(&send_tail, key, strlen(key))) {
265: RPC_PRINTF(("bp_getfile: bad key\n"));
266: return (-1);
267: }
268:
269: /* RPC: bootparam/getfile */
270: d->myport = htons(--rpc_port);
271: d->destip = bp_server_addr;
272: /* rpc_call will set d->destport */
273:
274: rlen = rpc_call(d,
275: BOOTPARAM_PROG, BOOTPARAM_VERS, BOOTPARAM_GETFILE,
276: sdata.d, send_tail - (char *)sdata.d,
277: rdata.d, sizeof(rdata.d));
278: if (rlen < 4) {
279: RPC_PRINTF(("bp_getfile: short reply\n"));
280: errno = EBADRPC;
281: return (-1);
282: }
283: recv_head = (char *)rdata.d;
284:
285: /*
286: * Parse result message.
287: */
288:
289: /* server name */
290: sn_len = FNAME_SIZE-1;
291: if (xdr_string_decode(&recv_head, serv_name, &sn_len)) {
292: RPC_PRINTF(("bp_getfile: bad server name\n"));
293: return (-1);
294: }
295:
296: /* server IP address (mountd/NFS) */
297: if (xdr_inaddr_decode(&recv_head, serv_addr)) {
298: RPC_PRINTF(("bp_getfile: bad server addr\n"));
299: return (-1);
300: }
301:
302: /* server pathname */
303: path_len = MAXPATHLEN-1;
304: if (xdr_string_decode(&recv_head, pathname, &path_len)) {
305: RPC_PRINTF(("bp_getfile: bad server path\n"));
306: return (-1);
307: }
308:
309: /* success */
310: return(0);
311: }
312:
313:
314: /*
315: * eXternal Data Representation routines.
316: * (but with non-standard args...)
317: */
318:
319: int
320: xdr_string_encode(char **pkt, char *str, int len)
321: {
322: u_int32_t *lenp;
323: char *datap;
324: int padlen = (len + 3) & ~3; /* padded length */
325:
326: /* The data will be int aligned. */
327: lenp = (u_int32_t*) *pkt;
328: *pkt += sizeof(*lenp);
329: *lenp = htonl(len);
330:
331: datap = *pkt;
332: *pkt += padlen;
333: bcopy(str, datap, len);
334:
335: return (0);
336: }
337:
338: int
339: xdr_string_decode(char **pkt, char *str, int *len_p)
340: {
341: u_int32_t *lenp;
342: char *datap;
343: int slen; /* string length */
344: int plen; /* padded length */
345:
346: /* The data will be int aligned. */
347: lenp = (u_int32_t*) *pkt;
348: *pkt += sizeof(*lenp);
349: slen = ntohl(*lenp);
350: plen = (slen + 3) & ~3;
351:
352: if (slen > *len_p)
353: slen = *len_p;
354: datap = *pkt;
355: *pkt += plen;
356: bcopy(datap, str, slen);
357:
358: str[slen] = '\0';
359: *len_p = slen;
360:
361: return (0);
362: }
363:
364: int
365: xdr_inaddr_encode(char **pkt, struct in_addr ia)
366: {
367: struct xdr_inaddr *xi;
368: u_char *cp;
369: int32_t *ip;
370: union {
371: n_long l; /* network order */
372: u_char c[4];
373: } uia;
374:
375: /* The data will be int aligned. */
376: xi = (struct xdr_inaddr *) *pkt;
377: *pkt += sizeof(*xi);
378: xi->atype = htonl(1);
379: uia.l = ia.s_addr;
380: cp = uia.c;
381: ip = xi->addr;
382: /*
383: * Note: the htonl() calls below DO NOT
384: * imply that uia.l is in host order.
385: * In fact this needs it in net order.
386: */
387: *ip++ = htonl((unsigned int)*cp++);
388: *ip++ = htonl((unsigned int)*cp++);
389: *ip++ = htonl((unsigned int)*cp++);
390: *ip++ = htonl((unsigned int)*cp++);
391:
392: return (0);
393: }
394:
395: int
396: xdr_inaddr_decode(char **pkt, struct in_addr *ia)
397: {
398: struct xdr_inaddr *xi;
399: u_char *cp;
400: int32_t *ip;
401: union {
402: n_long l; /* network order */
403: u_char c[4];
404: } uia;
405:
406: /* The data will be int aligned. */
407: xi = (struct xdr_inaddr *) *pkt;
408: *pkt += sizeof(*xi);
409: if (xi->atype != htonl(1)) {
410: RPC_PRINTF(("xdr_inaddr_decode: bad addrtype=%d\n",
411: ntohl(xi->atype)));
412: return(-1);
413: }
414:
415: cp = uia.c;
416: ip = xi->addr;
417: /*
418: * Note: the ntohl() calls below DO NOT
419: * imply that uia.l is in host order.
420: * In fact this needs it in net order.
421: */
422: *cp++ = ntohl(*ip++);
423: *cp++ = ntohl(*ip++);
424: *cp++ = ntohl(*ip++);
425: *cp++ = ntohl(*ip++);
426: ia->s_addr = uia.l;
427:
428: return (0);
429: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to bootparam.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / lib / libsa