xref: /illumos-gate/usr/src/cmd/cmd-inet/usr.sbin/hostconfig.c (revision 65a89a64c60f3061bbe2381edaacc81660af9a95)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 /*
23  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 #pragma ident	"%Z%%M%	%I%	%E% SMI"
28 
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <unistd.h>
32 #include <string.h>
33 #include <locale.h>
34 #include <sys/utsname.h>
35 #include <sys/systeminfo.h>
36 #include <netdb.h>
37 #include <sys/types.h>
38 #include <sys/param.h>
39 #include <sys/errno.h>
40 #include <sys/file.h>
41 #include <sys/ioctl.h>
42 #include <sys/signal.h>
43 #include <sys/wait.h>
44 #include <sys/time.h>
45 #include <sys/socket.h>
46 #include <sys/stropts.h>
47 #include <sys/resource.h>
48 #include <net/if.h>
49 #include <net/if_arp.h>
50 #include <sys/stream.h>
51 #include <net/route.h>
52 #include <netinet/in.h>
53 #include <arpa/inet.h>
54 #include <netinet/if_ether.h>
55 #include <netinet/ip_var.h>
56 #include <netinet/udp.h>
57 #include <netinet/udp_var.h>
58 #include <rpc/rpc.h>
59 #include <rpcsvc/bootparam_prot.h>
60 
61 #define	MAXIFS	256
62 
63 /* command line flags */
64 int		debug = 0;		/* do debug printfs */
65 int		echo_host = 0;		/* just echo hostname, don't set it */
66 int		verbose = 0;		/* do verbose printfs */
67 int		safe = 0;		/* don't change anything */
68 int		multiple = 0;		/* take multiple replies */
69 
70 static ulong_t	if_netmask;
71 
72 void		notsupported(), usage(), bp_whoami();
73 int		get_ifdata();		/* get IP addr, subnet mask from IF */
74 extern char	*inet_ntoa();
75 extern int	getopt(), setdomainname();
76 
77 struct prototab {
78 	char *name;
79 	void (*func)();
80 } prototab[] = {
81 	{ "bootparams", bp_whoami },
82 	{ "bootp", notsupported },
83 	{ 0, 0 }
84 };
85 
86 
87 
88 /*
89  * usage: hostconfig [-p <protocol>] [-v] [-n] [-h] [<ifname>] [-f <hostname>]
90  *
91  * options:
92  *	-d		Debug mode.
93  * 	-v		Verbose mode.
94  *	-n		Don't change anything.
95  *	-h		Don't set hostname, just echo to standard out.
96  *	-m		Wait for multiple answers (best used with the "-n"
97  *			and "-v" flags).
98  *	-f <hostname>	Fake mode - get bootparams for <hostname> (also
99  *			best used with the "-n" and "-v" flags).
100  *	<ifname>	Use IP address of <interface> in whoami request.
101  *
102  * If no interface name is specified, bp_whoami will cycle through the
103  * interfaces, using the IP address of each in turn until an answer is
104  * received.  Note that rpc_broadcast() broadcasts the RPC call on all
105  * interfaces, so the <ifname> argument doesn't restrict the request
106  * to that interface, it just uses that interface to determine the IP
107  * address to put into the request.  If "-f <hostname>" is specified,
108  * we put the IP address of <hostname> in the whoami request.  Otherwise,
109  * we put the IP address of the interface in the whoami request.
110  *
111  */
112 
113 
114 int
115 main(argc, argv)
116 	int argc;
117 	char **argv;
118 {
119 	struct ifreq *reqbuf;
120 	struct ifreq *ifr;
121 	struct ifconf ifc;
122 	struct in_addr targetaddr;
123 	struct hostent *hp;
124 	char *targethost = NULL;
125 	char *cmdname;
126 	int c;
127 	int n;
128 	struct prototab *ptp;
129 	void (*protofunc)() = NULL;
130 	int numifs;
131 	unsigned bufsize;
132 
133 	extern char *optarg;
134 	extern int optind;
135 
136 	cmdname = argv[0];
137 
138 	while ((c = getopt(argc, argv, "dhvnmf:p:")) != -1) {
139 
140 		switch ((char)c) {
141 		case 'd':
142 			debug++;
143 			break;
144 
145 		case 'h':
146 			echo_host++;
147 			break;
148 		case 'v':
149 			verbose++;
150 			break;
151 
152 		case 'm':
153 			multiple++;
154 			break;
155 
156 		case 'n':
157 			safe++;
158 			break;
159 
160 		case 'f':
161 			targethost = optarg;
162 			break;
163 
164 		case 'p':
165 			protofunc = NULL;
166 			for (ptp = &prototab[0]; ptp->func; ptp++)
167 				if (strcmp(optarg, ptp->name) == 0) {
168 					protofunc = ptp->func;
169 					break;
170 				}
171 			if (protofunc == NULL)
172 				usage(cmdname);
173 			break;
174 
175 		case '?':
176 			usage(cmdname);
177 		}
178 	}
179 
180 	if (protofunc == NULL)
181 		usage(cmdname);
182 
183 	if (targethost) {
184 		/* we are faking it */
185 		if (debug)
186 			fprintf(stdout, "targethost = %s\n", targethost);
187 
188 		if ((hp = gethostbyname(targethost)) == NULL) {
189 			if ((targetaddr.s_addr = inet_addr(targethost)) ==
190 			    (ulong_t)(-1)) {
191 				(void) fprintf(stderr,
192 					"%s: cannot get IP address for %s\n",
193 					cmdname, targethost);
194 				return (1);
195 			}
196 		} else {
197 			if (hp->h_length != sizeof (targetaddr)) {
198 				(void) fprintf(stderr,
199 					"%s: cannot find host entry for %s\n",
200 					cmdname, targethost);
201 				return (1);
202 			} else
203 				(void) memcpy(&targetaddr.s_addr, hp->h_addr,
204 				    sizeof (targetaddr));
205 		}
206 	} else
207 		targetaddr.s_addr = 0;
208 
209 	if (optind < argc) {
210 		/* interface names were specified */
211 		for (; optind < argc; optind++) {
212 			if (debug)
213 				fprintf(stdout, "Trying arg %s\n",
214 					argv[optind]);
215 			(*protofunc)(argv[optind], targetaddr);
216 		}
217 	} else {
218 		/* no interface names specified - try them all */
219 		int ifcount = 0;	/* count of useable interfaces */
220 		int s;
221 
222 		if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
223 			perror("socket");
224 			return (1);
225 		}
226 #ifdef SIOCGIFNUM
227 		if (ioctl(s, SIOCGIFNUM, (char *)&numifs) < 0) {
228 			numifs = MAXIFS;
229 		}
230 #else
231 		numifs = MAXIFS;
232 #endif
233 		bufsize = numifs * sizeof (struct ifreq);
234 		reqbuf = (struct ifreq *)malloc(bufsize);
235 		if (reqbuf == NULL) {
236 			fprintf(stderr, "out of memory\n");
237 			return (1);
238 		}
239 		ifc.ifc_buf = (caddr_t)&reqbuf[0];
240 		ifc.ifc_len = bufsize;
241 		if (ioctl(s, SIOCGIFCONF, (char *)&ifc) < 0) {
242 			perror("ioctl(SIOCGIFCONF)");
243 			return (1);
244 		}
245 		ifr = ifc.ifc_req;
246 		n = ifc.ifc_len/sizeof (struct ifreq);
247 		for (; n > 0; n--, ifr++) {
248 			if (ioctl(s, SIOCGIFFLAGS, (char *)ifr) < 0) {
249 				perror("ioctl(SIOCGIFFLAGS)");
250 				return (1);
251 			}
252 			if ((ifr->ifr_flags & IFF_LOOPBACK) ||
253 			    !(ifr->ifr_flags & IFF_BROADCAST) ||
254 			    !(ifr->ifr_flags & IFF_UP) ||
255 			    (ifr->ifr_flags & IFF_NOARP) ||
256 			    (ifr->ifr_flags & IFF_POINTOPOINT)) {
257 				if (debug)
258 					fprintf(stdout, "If %s not suitable\n",
259 						ifr->ifr_name);
260 				continue;
261 			} else {
262 				if (debug)
263 					fprintf(stdout, "Trying device %s\n",
264 						ifr->ifr_name);
265 				(*protofunc)(ifr->ifr_name,  targetaddr);
266 				ifcount++;
267 			}
268 		}
269 		if (verbose && ifcount == 0) {
270 			fprintf(stderr, "No useable interfaces found.\n");
271 			return (1);
272 		}
273 		(void) close(s);
274 		(void) free((char *)reqbuf);
275 	}
276 	return (0);
277 }
278 
279 
280 void
281 add_default_route(router_addr)
282 	struct in_addr router_addr;
283 {
284 	struct rtentry route;
285 	struct sockaddr_in *sin;
286 	int s;
287 
288 	(void) memset(&route, 0, sizeof (route));
289 
290 	/* route destination is "default" - zero */
291 	/* LINTED - alignment OK (32bit) */
292 	sin = (struct sockaddr_in *)&route.rt_dst;
293 	sin->sin_family = AF_INET;
294 
295 	/* LINTED - alignment OK (32bit) */
296 	sin = (struct sockaddr_in *)&route.rt_gateway;
297 	sin->sin_family = AF_INET;
298 	sin->sin_addr.s_addr = router_addr.s_addr;
299 
300 	route.rt_flags = RTF_GATEWAY | RTF_UP;
301 
302 	if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
303 		perror("socket");
304 		return;
305 	}
306 	if (ioctl(s, SIOCADDRT, (char *)&route) == -1) {
307 		perror("add default route");
308 		return;
309 	}
310 	(void) close(s);
311 }
312 
313 
314 int
315 bpanswer(res, nb)
316 	struct bp_whoami_res *res;
317 	struct netbuf *nb;
318 {
319 	struct in_addr router_addr;
320 	static int set;
321 	int len;
322 	char errbuf[MAX_MACHINE_NAME + 28];
323 	/* MAX_MACHINE_NAME + strlen ("sysinfo(SI_SET_HOSTNAME)()") + null */
324 
325 	(void) memcpy(&router_addr, &res->router_address.bp_address_u.ip_addr,
326 	    sizeof (router_addr));
327 
328 	if (verbose) {
329 		struct sockaddr_in *addr;
330 
331 		if (nb) {
332 			/* LINTED - alignment (32bit) OK */
333 			addr = (struct sockaddr_in *)nb->buf;
334 			fprintf(stdout, "From [%s]: ",
335 			    inet_ntoa(addr->sin_addr));
336 		} else {
337 			fprintf(stdout, "Reply:\\t\\t");
338 		}
339 		fprintf(stdout, "hostname = %s\n", res->client_name);
340 		fprintf(stdout, "\t\typdomain = %s\n", res->domain_name);
341 		fprintf(stdout, "\t\trouter = %s\n", inet_ntoa(router_addr));
342 	}
343 
344 	if (!safe && !set) {
345 		/*
346 		 * Stuff the values from the RPC reply into the kernel.
347 		 * Only allow one pass through this code; There's no reason
348 		 * why all replies should tweak the kernel.
349 		 */
350 		set++;
351 
352 		len = strlen(res->client_name);
353 		if (len != 0) {
354 			if (!echo_host) {
355 				if (sysinfo(SI_SET_HOSTNAME, res->client_name,
356 				    len) < 0) {
357 					(void) snprintf(errbuf, sizeof (errbuf),
358 					    "sysinfo(SI_SET_HOSTNAME)(%s)",
359 					    res->client_name);
360 					perror(errbuf);
361 				}
362 			} else
363 				(void) fprintf(stdout, "%s\n",
364 				    res->client_name);
365 		}
366 
367 		len = strlen(res->domain_name);
368 		if (len != 0) {
369 			if (setdomainname(res->domain_name, len) == -1) {
370 				(void) snprintf(errbuf, sizeof (errbuf),
371 				    "setdomainname(%s)", res->domain_name);
372 				perror(errbuf);
373 			}
374 		}
375 
376 		/* we really should validate this router value */
377 		if (router_addr.s_addr != 0)
378 			add_default_route(router_addr);
379 	}
380 
381 	if (multiple)
382 		return (NULL);
383 
384 	/* our job is done */
385 	exit(0);
386 	/* NOTREACHED */
387 }
388 
389 void
390 bp_whoami(device, addr)
391 	char *device;
392 	struct in_addr addr;
393 {
394 	struct bp_whoami_arg req;
395 	struct bp_whoami_res res;
396 	struct in_addr lookupaddr;
397 	enum clnt_stat stat;
398 	int val = 1;
399 
400 	if (debug)
401 		fprintf(stdout, "bp_whoami on interface %s addr %s\n", device,
402 		    inet_ntoa(addr));
403 
404 	if (addr.s_addr ==  0) {
405 		if (get_ifdata(device, &lookupaddr, &if_netmask) == -1)
406 			exit(1);
407 	} else
408 		(void) memcpy(&lookupaddr, &addr, sizeof (addr));
409 
410 	lookupaddr.s_addr = ntohl(lookupaddr.s_addr);
411 
412 	if (debug)
413 		fprintf(stdout, "lookup address is %s\n",
414 			inet_ntoa(lookupaddr));
415 
416 	(void) memset(&req, 0, sizeof (req));
417 	(void) memset(&res, 0, sizeof (res));
418 
419 	req.client_address.address_type = IP_ADDR_TYPE;
420 	(void) memcpy(&req.client_address.bp_address_u.ip_addr, &lookupaddr,
421 	    sizeof (lookupaddr));
422 
423 	/*
424 	 * Broadcast using portmap version number 2  ONLY to
425 	 * prevent broadcast storm
426 	 */
427 
428 	(void) __rpc_control(CLCR_SET_LOWVERS, &val);
429 
430 	stat = rpc_broadcast(BOOTPARAMPROG, BOOTPARAMVERS, BOOTPARAMPROC_WHOAMI,
431 	    xdr_bp_whoami_arg, (caddr_t)&req, xdr_bp_whoami_res, (caddr_t)&res,
432 	    (resultproc_t)bpanswer, "udp");
433 
434 	/* Now try version 3 as well */
435 
436 	val = 0;
437 	(void) __rpc_control(CLCR_SET_LOWVERS, &val);
438 
439 	stat = rpc_broadcast(BOOTPARAMPROG, BOOTPARAMVERS,
440 	    BOOTPARAMPROC_WHOAMI, xdr_bp_whoami_arg, (caddr_t)&req,
441 	    xdr_bp_whoami_res, (caddr_t)&res, (resultproc_t)bpanswer, "udp");
442 
443 	if (stat != RPC_SUCCESS) {
444 		clnt_perrno(stat);
445 		exit(1);
446 	}
447 }
448 
449 
450 /*
451  * Get IP address of an interface.  As long as we are looking, get the
452  * netmask as well.
453  */
454 int
455 get_ifdata(dev, ipp, maskp)
456 	char *dev;
457 	ulong_t *ipp, *maskp;
458 {
459 	struct ifreq ifr;
460 	/* LINTED - alignment OK (32bit) */
461 	struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr;
462 	int s;
463 
464 	if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
465 		perror("socket");
466 		return (-1);
467 	}
468 
469 	if (strlcpy(ifr.ifr_name, dev, sizeof (ifr.ifr_name)) >=
470 		sizeof (ifr.ifr_name)) {
471 			(void) fprintf(stderr, "Device name too long %s\n",
472 			    dev);
473 			return (-1);
474 	}
475 
476 	if (ipp) {
477 		if (ioctl(s, SIOCGIFADDR, (caddr_t)&ifr) < 0) {
478 			perror("ioctl(SIOCGIFADDR)");
479 			return (-1);
480 		}
481 		*ipp = ntohl(sin->sin_addr.s_addr);
482 
483 		if (debug)
484 			(void) fprintf(stderr, "Interface '%s' address %s\n",
485 			    dev, inet_ntoa(sin->sin_addr));
486 	}
487 
488 	if (maskp) {
489 		if (ioctl(s, SIOCGIFNETMASK, (caddr_t)&ifr) < 0) {
490 			perror("SIOCGIFNETMASK");
491 			return (-1);
492 		}
493 		*maskp = ntohl(sin->sin_addr.s_addr);
494 
495 		if (debug)
496 			(void) fprintf(stderr,
497 				"Interface '%s' subnet mask %s\n", dev,
498 				inet_ntoa(sin->sin_addr));
499 	}
500 
501 	(void) close(s);
502 	return (0);
503 }
504 
505 void
506 notsupported()
507 {
508 	fprintf(stderr, "requested protocol is not supported\n");
509 	exit(1);
510 }
511 
512 void
513 usage(cmdname)
514 	char *cmdname;
515 {
516 	(void) fprintf(stderr, "usage: %s [-v] [-n] [-m] [-h] [<ifname>] "
517 	    "[-f <hostname>] -p bootparams|bootp\n", cmdname);
518 	(void) fflush(stderr);
519 	exit(1);
520 }
521