1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
|
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2004 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* This program does the following:
*
* a) Returns:
* 0 - if the program successfully determined the net strategy.
* !0 - if an error occurred.
*
* b) If the program is successful, it prints three tokens to
* stdout: <root fs type> <interface name> <net config strategy>.
* where:
* <root fs type> - "nfs" or "ufs"
* <interface name> - "hme0" or "none"
* <net config strategy> - "dhcp", "rarp", or "none"
*
* Eg:
* # /sbin/netstrategy
* ufs hme0 dhcp
*
* <root fs type> identifies the system's root file system type.
*
* <interface name> is the 16 char name of the root interface, and is only
* set if rarp/dhcp was used to configure the interface.
*
* <net config strategy> can be either "rarp", "dhcp", or "none" depending
* on which strategy was used to configure the interface. Is "none" if
* no interface was configured using a net-based strategy.
*
* CAVEATS: what about autoclient systems? XXX
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <errno.h>
#include <alloca.h>
#include <sys/systeminfo.h>
#include <sys/socket.h>
#include <sys/sockio.h>
#include <net/if.h>
#include <sys/statvfs.h>
/* ARGSUSED */
int
main(int argc, char *argv[])
{
struct statvfs vfs;
char *root, *interface, *strategy, dummy;
long len;
int fd, numifs;
struct ifreq *ifr;
struct ifconf ifconf;
/* root location */
if (statvfs("/", &vfs) < 0)
root = "none";
else {
if (strncmp(vfs.f_basetype, "nfs", sizeof ("nfs") - 1) == 0)
vfs.f_basetype[sizeof ("nfs") - 1] = '\0';
root = vfs.f_basetype;
}
/*
* Handle the simple case where diskless dhcp tells us everything
* we need to know.
*/
if ((len = sysinfo(SI_DHCP_CACHE, &dummy, sizeof (dummy))) > 1) {
/* interface is first thing in cache. */
strategy = "dhcp";
interface = alloca(len);
(void) sysinfo(SI_DHCP_CACHE, interface, len);
(void) printf("%s %s %s\n", root, interface, strategy);
return (0);
}
/*
* We're not "nfs dhcp", "nfs none" is impossible, and we don't handle
* "ufs rarp" (consumers are coded to deal with this reality), so
* there are three possible situations:
*
* 1. We're "ufs dhcp" if there are any interfaces which have
* obtained their addresses through DHCP. That is, if there
* are any IFF_UP and non-IFF_VIRTUAL interfaces also have
* IFF_DHCPRUNNING set.
*
* 2. We're "ufs none" if our filesystem is local and there
* are no interfaces which have obtained their addresses
* through DHCP.
*
* 3. We're "nfs rarp" if our filesystem is remote and there's
* at least IFF_UP non-IFF_VIRTUAL interface (which there
* *must* be, since we're running over NFS somehow), then
* it must be RARP since SI_DHCP_CACHE call above failed.
* It's too bad there isn't an IFF_RARPRUNNING flag.
*/
if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
(void) fprintf(stderr, "%s: socket: %s\n", argv[0],
strerror(errno));
return (2);
}
if (ioctl(fd, SIOCGIFNUM, &numifs) < 0) {
(void) fprintf(stderr, "%s: SIOCGIFNUM: %s\n", argv[0],
strerror(errno));
(void) close(fd);
return (2);
}
ifconf.ifc_len = numifs * sizeof (struct ifreq);
ifconf.ifc_buf = alloca(ifconf.ifc_len);
if (ioctl(fd, SIOCGIFCONF, &ifconf) < 0) {
(void) fprintf(stderr, "%s: SIOCGIFCONF: %s\n", argv[0],
strerror(errno));
(void) close(fd);
return (2);
}
strategy = NULL;
interface = NULL;
for (ifr = ifconf.ifc_req; ifr < &ifconf.ifc_req[ifconf.ifc_len /
sizeof (struct ifreq)]; ifr++) {
if (strchr(ifr->ifr_name, ':') != NULL)
continue; /* skip virtual interfaces */
if (ioctl(fd, SIOCGIFFLAGS, ifr) < 0) {
(void) fprintf(stderr, "%s: SIOCGIFFLAGS: %s\n",
argv[0], strerror(errno));
continue;
}
if (ifr->ifr_flags & (IFF_VIRTUAL|IFF_POINTOPOINT))
continue;
if (ifr->ifr_flags & IFF_UP) {
/*
* For the "nfs rarp" case, we assume that the first
* IFF_UP interface is the one using RARP, so stash
* away the first interface in case we need it.
*
* Since the order of the interfaces retrieved via
* SIOCGLIFCONF is not deterministic, this is largely
* silliness, but (a) "it's always been this way", (b)
* machines booted via diskless RARP typically only
* have one interface, and (c) no one consumes the
* interface name in the RARP case anyway.
*/
if (interface == NULL)
interface = ifr->ifr_name;
if (ifr->ifr_flags & IFF_DHCPRUNNING) {
interface = ifr->ifr_name;
strategy = "dhcp";
break;
}
}
}
(void) close(fd);
if (strcmp(root, "nfs") == 0 || strcmp(root, "cachefs") == 0) {
if (interface == NULL) {
(void) fprintf(stderr,
"%s: cannot identify root interface.\n", argv[0]);
return (2);
}
if (strategy == NULL)
strategy = "rarp"; /* must be rarp/bootparams */
} else {
if (interface == NULL || strategy == NULL)
interface = strategy = "none";
}
(void) printf("%s %s %s\n", root, interface, strategy);
return (0);
}
|
