blob: 1806a6ccc858e503f4c11dcf9abf43f1c7c91ca1
1 | /* vi: set sw=4 ts=4: */ |
2 | /* |
3 | * ifup/ifdown for busybox |
4 | * Copyright (c) 2002 Glenn McGrath |
5 | * Copyright (c) 2003-2004 Erik Andersen <andersen@codepoet.org> |
6 | * |
7 | * Based on ifupdown v 0.6.4 by Anthony Towns |
8 | * Copyright (c) 1999 Anthony Towns <aj@azure.humbug.org.au> |
9 | * |
10 | * Changes to upstream version |
11 | * Remove checks for kernel version, assume kernel version 2.2.0 or better. |
12 | * Lines in the interfaces file cannot wrap. |
13 | * To adhere to the FHS, the default state file is /var/run/ifstate |
14 | * (defined via CONFIG_IFUPDOWN_IFSTATE_PATH) and can be overridden by build |
15 | * configuration. |
16 | * |
17 | * Licensed under GPLv2 or later, see file LICENSE in this source tree. |
18 | */ |
19 | |
20 | //config:config IFUP |
21 | //config: bool "ifup" |
22 | //config: default y |
23 | //config: help |
24 | //config: Activate the specified interfaces. This applet makes use |
25 | //config: of either "ifconfig" and "route" or the "ip" command to actually |
26 | //config: configure network interfaces. Therefore, you will probably also want |
27 | //config: to enable either IFCONFIG and ROUTE, or enable |
28 | //config: FEATURE_IFUPDOWN_IP and the various IP options. Of |
29 | //config: course you could use non-busybox versions of these programs, so |
30 | //config: against my better judgement (since this will surely result in plenty |
31 | //config: of support questions on the mailing list), I do not force you to |
32 | //config: enable these additional options. It is up to you to supply either |
33 | //config: "ifconfig", "route" and "run-parts" or the "ip" command, either |
34 | //config: via busybox or via standalone utilities. |
35 | //config: |
36 | //config:config IFDOWN |
37 | //config: bool "ifdown" |
38 | //config: default y |
39 | //config: help |
40 | //config: Deactivate the specified interfaces. |
41 | //config: |
42 | //config:config IFUPDOWN_IFSTATE_PATH |
43 | //config: string "Absolute path to ifstate file" |
44 | //config: default "/var/run/ifstate" |
45 | //config: depends on IFUP || IFDOWN |
46 | //config: help |
47 | //config: ifupdown keeps state information in a file called ifstate. |
48 | //config: Typically it is located in /var/run/ifstate, however |
49 | //config: some distributions tend to put it in other places |
50 | //config: (debian, for example, uses /etc/network/run/ifstate). |
51 | //config: This config option defines location of ifstate. |
52 | //config: |
53 | //config:config FEATURE_IFUPDOWN_IP |
54 | //config: bool "Use ip tool (else ifconfig/route is used)" |
55 | //config: default y |
56 | //config: depends on IFUP || IFDOWN |
57 | //config: help |
58 | //config: Use the iproute "ip" command to implement "ifup" and "ifdown", rather |
59 | //config: than the default of using the older "ifconfig" and "route" utilities. |
60 | //config: |
61 | //config: If Y: you must install either the full-blown iproute2 package |
62 | //config: or enable "ip" applet in Busybox, or the "ifup" and "ifdown" applets |
63 | //config: will not work. |
64 | //config: |
65 | //config: If N: you must install either the full-blown ifconfig and route |
66 | //config: utilities, or enable these applets in Busybox. |
67 | //config: |
68 | //config:config FEATURE_IFUPDOWN_IPV4 |
69 | //config: bool "Support for IPv4" |
70 | //config: default y |
71 | //config: depends on IFUP || IFDOWN |
72 | //config: help |
73 | //config: If you want ifup/ifdown to talk IPv4, leave this on. |
74 | //config: |
75 | //config:config FEATURE_IFUPDOWN_IPV6 |
76 | //config: bool "Support for IPv6" |
77 | //config: default y |
78 | //config: depends on (IFUP || IFDOWN) && FEATURE_IPV6 |
79 | //config: help |
80 | //config: If you need support for IPv6, turn this option on. |
81 | //config: |
82 | //UNUSED: |
83 | ////////:config FEATURE_IFUPDOWN_IPX |
84 | ////////: bool "Support for IPX" |
85 | ////////: default y |
86 | ////////: depends on IFUP || IFDOWN |
87 | ////////: help |
88 | ////////: If this option is selected you can use busybox to work with IPX |
89 | ////////: networks. |
90 | //config: |
91 | //config:config FEATURE_IFUPDOWN_MAPPING |
92 | //config: bool "Enable mapping support" |
93 | //config: default y |
94 | //config: depends on IFUP || IFDOWN |
95 | //config: help |
96 | //config: This enables support for the "mapping" stanza, unless you have |
97 | //config: a weird network setup you don't need it. |
98 | //config: |
99 | //config:config FEATURE_IFUPDOWN_EXTERNAL_DHCP |
100 | //config: bool "Support for external dhcp clients" |
101 | //config: default n |
102 | //config: depends on IFUP || IFDOWN |
103 | //config: help |
104 | //config: This enables support for the external dhcp clients. Clients are |
105 | //config: tried in the following order: dhcpcd, dhclient, pump and udhcpc. |
106 | //config: Otherwise, if udhcpc applet is enabled, it is used. |
107 | //config: Otherwise, ifup/ifdown will have no support for DHCP. |
108 | |
109 | //applet:IF_IFUP(APPLET_ODDNAME(ifup, ifupdown, BB_DIR_SBIN, BB_SUID_DROP, ifup)) |
110 | //applet:IF_IFDOWN(APPLET_ODDNAME(ifdown, ifupdown, BB_DIR_SBIN, BB_SUID_DROP, ifdown)) |
111 | |
112 | //kbuild:lib-$(CONFIG_IFUP) += ifupdown.o |
113 | //kbuild:lib-$(CONFIG_IFDOWN) += ifupdown.o |
114 | |
115 | //usage:#define ifup_trivial_usage |
116 | //usage: "[-an"IF_FEATURE_IFUPDOWN_MAPPING("m")"vf] [-i FILE] IFACE..." |
117 | //usage:#define ifup_full_usage "\n\n" |
118 | //usage: " -a Configure all interfaces" |
119 | //usage: "\n -i FILE Use FILE instead of /etc/network/interfaces" |
120 | //usage: "\n -n Print out what would happen, but don't do it" |
121 | //usage: IF_FEATURE_IFUPDOWN_MAPPING( |
122 | //usage: "\n (note: doesn't disable mappings)" |
123 | //usage: "\n -m Don't run any mappings" |
124 | //usage: ) |
125 | //usage: "\n -v Print out what would happen before doing it" |
126 | //usage: "\n -f Force configuration" |
127 | //usage: |
128 | //usage:#define ifdown_trivial_usage |
129 | //usage: "[-an"IF_FEATURE_IFUPDOWN_MAPPING("m")"vf] [-i FILE] IFACE..." |
130 | //usage:#define ifdown_full_usage "\n\n" |
131 | //usage: " -a Deconfigure all interfaces" |
132 | //usage: "\n -i FILE Use FILE for interface definitions" |
133 | //usage: "\n -n Print out what would happen, but don't do it" |
134 | //usage: IF_FEATURE_IFUPDOWN_MAPPING( |
135 | //usage: "\n (note: doesn't disable mappings)" |
136 | //usage: "\n -m Don't run any mappings" |
137 | //usage: ) |
138 | //usage: "\n -v Print out what would happen before doing it" |
139 | //usage: "\n -f Force deconfiguration" |
140 | |
141 | #include "libbb.h" |
142 | #include "common_bufsiz.h" |
143 | /* After libbb.h, since it needs sys/types.h on some systems */ |
144 | #include <sys/utsname.h> |
145 | #include <fnmatch.h> |
146 | |
147 | #define MAX_OPT_DEPTH 10 |
148 | |
149 | #if ENABLE_FEATURE_IFUPDOWN_MAPPING |
150 | #define MAX_INTERFACE_LENGTH 10 |
151 | #endif |
152 | |
153 | #define UDHCPC_CMD_OPTIONS CONFIG_IFUPDOWN_UDHCPC_CMD_OPTIONS |
154 | #define IFSTATE_FILE_PATH CONFIG_IFUPDOWN_IFSTATE_PATH |
155 | |
156 | #define debug_noise(args...) /*fprintf(stderr, args)*/ |
157 | |
158 | /* Forward declaration */ |
159 | struct interface_defn_t; |
160 | |
161 | typedef int execfn(char *command); |
162 | |
163 | struct method_t { |
164 | const char *name; |
165 | int (*up)(struct interface_defn_t *ifd, execfn *e) FAST_FUNC; |
166 | int (*down)(struct interface_defn_t *ifd, execfn *e) FAST_FUNC; |
167 | }; |
168 | |
169 | struct address_family_t { |
170 | const char *name; |
171 | int n_methods; |
172 | const struct method_t *method; |
173 | }; |
174 | |
175 | struct mapping_defn_t { |
176 | struct mapping_defn_t *next; |
177 | |
178 | int max_matches; |
179 | int n_matches; |
180 | char **match; |
181 | |
182 | char *script; |
183 | |
184 | int n_mappings; |
185 | char **mapping; |
186 | }; |
187 | |
188 | struct variable_t { |
189 | char *name; |
190 | char *value; |
191 | }; |
192 | |
193 | struct interface_defn_t { |
194 | const struct address_family_t *address_family; |
195 | const struct method_t *method; |
196 | |
197 | char *iface; |
198 | int n_options; |
199 | struct variable_t *option; |
200 | }; |
201 | |
202 | struct interfaces_file_t { |
203 | llist_t *autointerfaces; |
204 | llist_t *ifaces; |
205 | struct mapping_defn_t *mappings; |
206 | }; |
207 | |
208 | |
209 | #define OPTION_STR "anvf" IF_FEATURE_IFUPDOWN_MAPPING("m") "i:" |
210 | enum { |
211 | OPT_do_all = 0x1, |
212 | OPT_no_act = 0x2, |
213 | OPT_verbose = 0x4, |
214 | OPT_force = 0x8, |
215 | OPT_no_mappings = 0x10, |
216 | }; |
217 | #define DO_ALL (option_mask32 & OPT_do_all) |
218 | #define NO_ACT (option_mask32 & OPT_no_act) |
219 | #define VERBOSE (option_mask32 & OPT_verbose) |
220 | #define FORCE (option_mask32 & OPT_force) |
221 | #define NO_MAPPINGS (option_mask32 & OPT_no_mappings) |
222 | |
223 | |
224 | struct globals { |
225 | char **my_environ; |
226 | const char *startup_PATH; |
227 | char *shell; |
228 | } FIX_ALIASING; |
229 | #define G (*(struct globals*)bb_common_bufsiz1) |
230 | #define INIT_G() do { setup_common_bufsiz(); } while (0) |
231 | |
232 | |
233 | static const char keywords_up_down[] ALIGN1 = |
234 | "up\0" |
235 | "down\0" |
236 | "pre-up\0" |
237 | "post-down\0" |
238 | ; |
239 | |
240 | |
241 | #if ENABLE_FEATURE_IFUPDOWN_IPV4 || ENABLE_FEATURE_IFUPDOWN_IPV6 |
242 | |
243 | static void addstr(char **bufp, const char *str, size_t str_length) |
244 | { |
245 | /* xasprintf trick will be smaller, but we are often |
246 | * called with str_length == 1 - don't want to have |
247 | * THAT much of malloc/freeing! */ |
248 | char *buf = *bufp; |
249 | int len = (buf ? strlen(buf) : 0); |
250 | str_length++; |
251 | buf = xrealloc(buf, len + str_length); |
252 | /* copies at most str_length-1 chars! */ |
253 | safe_strncpy(buf + len, str, str_length); |
254 | *bufp = buf; |
255 | } |
256 | |
257 | static int strncmpz(const char *l, const char *r, size_t llen) |
258 | { |
259 | int i = strncmp(l, r, llen); |
260 | |
261 | if (i == 0) |
262 | return - (unsigned char)r[llen]; |
263 | return i; |
264 | } |
265 | |
266 | static char *get_var(const char *id, size_t idlen, struct interface_defn_t *ifd) |
267 | { |
268 | int i; |
269 | |
270 | if (strncmpz(id, "iface", idlen) == 0) { |
271 | // ubuntu's ifup doesn't do this: |
272 | //static char *label_buf; |
273 | //char *result; |
274 | //free(label_buf); |
275 | //label_buf = xstrdup(ifd->iface); |
276 | // Remove virtual iface suffix |
277 | //result = strchrnul(label_buf, ':'); |
278 | //*result = '\0'; |
279 | //return label_buf; |
280 | |
281 | return ifd->iface; |
282 | } |
283 | if (strncmpz(id, "label", idlen) == 0) { |
284 | return ifd->iface; |
285 | } |
286 | for (i = 0; i < ifd->n_options; i++) { |
287 | if (strncmpz(id, ifd->option[i].name, idlen) == 0) { |
288 | return ifd->option[i].value; |
289 | } |
290 | } |
291 | return NULL; |
292 | } |
293 | |
294 | # if ENABLE_FEATURE_IFUPDOWN_IP |
295 | static int count_netmask_bits(const char *dotted_quad) |
296 | { |
297 | // int result; |
298 | // unsigned a, b, c, d; |
299 | // /* Found a netmask... Check if it is dotted quad */ |
300 | // if (sscanf(dotted_quad, "%u.%u.%u.%u", &a, &b, &c, &d) != 4) |
301 | // return -1; |
302 | // if ((a|b|c|d) >> 8) |
303 | // return -1; /* one of numbers is >= 256 */ |
304 | // d |= (a << 24) | (b << 16) | (c << 8); /* IP */ |
305 | // d = ~d; /* 11110000 -> 00001111 */ |
306 | |
307 | /* Shorter version */ |
308 | int result; |
309 | struct in_addr ip; |
310 | unsigned d; |
311 | |
312 | if (inet_aton(dotted_quad, &ip) == 0) |
313 | return -1; /* malformed dotted IP */ |
314 | d = ntohl(ip.s_addr); /* IP in host order */ |
315 | d = ~d; /* 11110000 -> 00001111 */ |
316 | if (d & (d+1)) /* check that it is in 00001111 form */ |
317 | return -1; /* no it is not */ |
318 | result = 32; |
319 | while (d) { |
320 | d >>= 1; |
321 | result--; |
322 | } |
323 | return result; |
324 | } |
325 | # endif |
326 | |
327 | static char *parse(const char *command, struct interface_defn_t *ifd) |
328 | { |
329 | size_t old_pos[MAX_OPT_DEPTH] = { 0 }; |
330 | smallint okay[MAX_OPT_DEPTH] = { 1 }; |
331 | int opt_depth = 1; |
332 | char *result = NULL; |
333 | |
334 | while (*command) { |
335 | switch (*command) { |
336 | default: |
337 | addstr(&result, command, 1); |
338 | command++; |
339 | break; |
340 | case '\\': |
341 | if (command[1]) |
342 | command++; |
343 | addstr(&result, command, 1); |
344 | command++; |
345 | break; |
346 | case '[': |
347 | if (command[1] == '[' && opt_depth < MAX_OPT_DEPTH) { |
348 | old_pos[opt_depth] = result ? strlen(result) : 0; |
349 | okay[opt_depth] = 1; |
350 | opt_depth++; |
351 | command += 2; |
352 | } else { |
353 | addstr(&result, command, 1); |
354 | command++; |
355 | } |
356 | break; |
357 | case ']': |
358 | if (command[1] == ']' && opt_depth > 1) { |
359 | opt_depth--; |
360 | if (!okay[opt_depth]) { |
361 | result[old_pos[opt_depth]] = '\0'; |
362 | } |
363 | command += 2; |
364 | } else { |
365 | addstr(&result, command, 1); |
366 | command++; |
367 | } |
368 | break; |
369 | case '%': |
370 | { |
371 | char *nextpercent; |
372 | char *varvalue; |
373 | |
374 | command++; |
375 | nextpercent = strchr(command, '%'); |
376 | if (!nextpercent) { |
377 | /* Unterminated %var% */ |
378 | free(result); |
379 | return NULL; |
380 | } |
381 | |
382 | varvalue = get_var(command, nextpercent - command, ifd); |
383 | |
384 | if (varvalue) { |
385 | # if ENABLE_FEATURE_IFUPDOWN_IP |
386 | /* "hwaddress <class> <address>": |
387 | * unlike ifconfig, ip doesnt want <class> |
388 | * (usually "ether" keyword). Skip it. */ |
389 | if (is_prefixed_with(command, "hwaddress")) { |
390 | varvalue = skip_whitespace(skip_non_whitespace(varvalue)); |
391 | } |
392 | # endif |
393 | addstr(&result, varvalue, strlen(varvalue)); |
394 | } else { |
395 | # if ENABLE_FEATURE_IFUPDOWN_IP |
396 | /* Sigh... Add a special case for 'ip' to convert from |
397 | * dotted quad to bit count style netmasks. */ |
398 | if (is_prefixed_with(command, "bnmask")) { |
399 | unsigned res; |
400 | varvalue = get_var("netmask", 7, ifd); |
401 | if (varvalue) { |
402 | res = count_netmask_bits(varvalue); |
403 | if (res > 0) { |
404 | const char *argument = utoa(res); |
405 | addstr(&result, argument, strlen(argument)); |
406 | command = nextpercent + 1; |
407 | break; |
408 | } |
409 | } |
410 | } |
411 | # endif |
412 | okay[opt_depth - 1] = 0; |
413 | } |
414 | |
415 | command = nextpercent + 1; |
416 | } |
417 | break; |
418 | } |
419 | } |
420 | |
421 | if (opt_depth > 1) { |
422 | /* Unbalanced bracket */ |
423 | free(result); |
424 | return NULL; |
425 | } |
426 | |
427 | if (!okay[0]) { |
428 | /* Undefined variable and we aren't in a bracket */ |
429 | free(result); |
430 | return NULL; |
431 | } |
432 | |
433 | return result; |
434 | } |
435 | |
436 | /* execute() returns 1 for success and 0 for failure */ |
437 | static int execute(const char *command, struct interface_defn_t *ifd, execfn *exec) |
438 | { |
439 | char *out; |
440 | int ret; |
441 | |
442 | out = parse(command, ifd); |
443 | if (!out) { |
444 | /* parse error? */ |
445 | return 0; |
446 | } |
447 | /* out == "": parsed ok but not all needed variables known, skip */ |
448 | ret = out[0] ? (*exec)(out) : 1; |
449 | |
450 | free(out); |
451 | if (ret != 1) { |
452 | return 0; |
453 | } |
454 | return 1; |
455 | } |
456 | |
457 | #endif /* FEATURE_IFUPDOWN_IPV4 || FEATURE_IFUPDOWN_IPV6 */ |
458 | |
459 | |
460 | #if ENABLE_FEATURE_IFUPDOWN_IPV6 |
461 | |
462 | static int FAST_FUNC loopback_up6(struct interface_defn_t *ifd, execfn *exec) |
463 | { |
464 | # if ENABLE_FEATURE_IFUPDOWN_IP |
465 | int result; |
466 | result = execute("ip addr add ::1 dev %iface%", ifd, exec); |
467 | result += execute("ip link set %iface% up", ifd, exec); |
468 | return ((result == 2) ? 2 : 0); |
469 | # else |
470 | return execute("ifconfig %iface% add ::1", ifd, exec); |
471 | # endif |
472 | } |
473 | |
474 | static int FAST_FUNC loopback_down6(struct interface_defn_t *ifd, execfn *exec) |
475 | { |
476 | # if ENABLE_FEATURE_IFUPDOWN_IP |
477 | return execute("ip link set %iface% down", ifd, exec); |
478 | # else |
479 | return execute("ifconfig %iface% del ::1", ifd, exec); |
480 | # endif |
481 | } |
482 | |
483 | static int FAST_FUNC manual_up_down6(struct interface_defn_t *ifd UNUSED_PARAM, execfn *exec UNUSED_PARAM) |
484 | { |
485 | return 1; |
486 | } |
487 | |
488 | static int FAST_FUNC static_up6(struct interface_defn_t *ifd, execfn *exec) |
489 | { |
490 | int result; |
491 | # if ENABLE_FEATURE_IFUPDOWN_IP |
492 | result = execute("ip addr add %address%/%netmask% dev %iface%[[ label %label%]]", ifd, exec); |
493 | result += execute("ip link set[[ mtu %mtu%]][[ addr %hwaddress%]] %iface% up", ifd, exec); |
494 | /* Reportedly, IPv6 needs "dev %iface%", but IPv4 does not: */ |
495 | result += execute("[[ip route add ::/0 via %gateway% dev %iface%]][[ metric %metric%]]", ifd, exec); |
496 | # else |
497 | result = execute("ifconfig %iface%[[ media %media%]][[ hw %hwaddress%]][[ mtu %mtu%]] up", ifd, exec); |
498 | result += execute("ifconfig %iface% add %address%/%netmask%", ifd, exec); |
499 | result += execute("[[route -A inet6 add ::/0 gw %gateway%[[ metric %metric%]]]]", ifd, exec); |
500 | # endif |
501 | return ((result == 3) ? 3 : 0); |
502 | } |
503 | |
504 | static int FAST_FUNC static_down6(struct interface_defn_t *ifd, execfn *exec) |
505 | { |
506 | # if ENABLE_FEATURE_IFUPDOWN_IP |
507 | return execute("ip link set %iface% down", ifd, exec); |
508 | # else |
509 | return execute("ifconfig %iface% down", ifd, exec); |
510 | # endif |
511 | } |
512 | |
513 | # if ENABLE_FEATURE_IFUPDOWN_IP |
514 | static int FAST_FUNC v4tunnel_up(struct interface_defn_t *ifd, execfn *exec) |
515 | { |
516 | int result; |
517 | result = execute("ip tunnel add %iface% mode sit remote " |
518 | "%endpoint%[[ local %local%]][[ ttl %ttl%]]", ifd, exec); |
519 | result += execute("ip link set %iface% up", ifd, exec); |
520 | result += execute("ip addr add %address%/%netmask% dev %iface%", ifd, exec); |
521 | /* Reportedly, IPv6 needs "dev %iface%", but IPv4 does not: */ |
522 | result += execute("[[ip route add ::/0 via %gateway% dev %iface%]]", ifd, exec); |
523 | return ((result == 4) ? 4 : 0); |
524 | } |
525 | |
526 | static int FAST_FUNC v4tunnel_down(struct interface_defn_t * ifd, execfn * exec) |
527 | { |
528 | return execute("ip tunnel del %iface%", ifd, exec); |
529 | } |
530 | # endif |
531 | |
532 | static const struct method_t methods6[] = { |
533 | # if ENABLE_FEATURE_IFUPDOWN_IP |
534 | { "v4tunnel" , v4tunnel_up , v4tunnel_down , }, |
535 | # endif |
536 | { "static" , static_up6 , static_down6 , }, |
537 | { "manual" , manual_up_down6 , manual_up_down6 , }, |
538 | { "loopback" , loopback_up6 , loopback_down6 , }, |
539 | }; |
540 | |
541 | static const struct address_family_t addr_inet6 = { |
542 | "inet6", |
543 | ARRAY_SIZE(methods6), |
544 | methods6 |
545 | }; |
546 | |
547 | #endif /* FEATURE_IFUPDOWN_IPV6 */ |
548 | |
549 | |
550 | #if ENABLE_FEATURE_IFUPDOWN_IPV4 |
551 | |
552 | static int FAST_FUNC loopback_up(struct interface_defn_t *ifd, execfn *exec) |
553 | { |
554 | # if ENABLE_FEATURE_IFUPDOWN_IP |
555 | int result; |
556 | result = execute("ip addr add 127.0.0.1/8 dev %iface%", ifd, exec); |
557 | result += execute("ip link set %iface% up", ifd, exec); |
558 | return ((result == 2) ? 2 : 0); |
559 | # else |
560 | return execute("ifconfig %iface% 127.0.0.1 up", ifd, exec); |
561 | # endif |
562 | } |
563 | |
564 | static int FAST_FUNC loopback_down(struct interface_defn_t *ifd, execfn *exec) |
565 | { |
566 | # if ENABLE_FEATURE_IFUPDOWN_IP |
567 | int result; |
568 | result = execute("ip addr flush dev %iface%", ifd, exec); |
569 | result += execute("ip link set %iface% down", ifd, exec); |
570 | return ((result == 2) ? 2 : 0); |
571 | # else |
572 | return execute("ifconfig %iface% 127.0.0.1 down", ifd, exec); |
573 | # endif |
574 | } |
575 | |
576 | static int FAST_FUNC static_up(struct interface_defn_t *ifd, execfn *exec) |
577 | { |
578 | int result; |
579 | # if ENABLE_FEATURE_IFUPDOWN_IP |
580 | result = execute("ip addr add %address%/%bnmask%[[ broadcast %broadcast%]] " |
581 | "dev %iface%[[ peer %pointopoint%]][[ label %label%]]", ifd, exec); |
582 | result += execute("ip link set[[ mtu %mtu%]][[ addr %hwaddress%]] %iface% up", ifd, exec); |
583 | result += execute("[[ip route add default via %gateway% dev %iface%[[ metric %metric%]]]]", ifd, exec); |
584 | return ((result == 3) ? 3 : 0); |
585 | # else |
586 | /* ifconfig said to set iface up before it processes hw %hwaddress%, |
587 | * which then of course fails. Thus we run two separate ifconfig */ |
588 | result = execute("ifconfig %iface%[[ hw %hwaddress%]][[ media %media%]][[ mtu %mtu%]] up", |
589 | ifd, exec); |
590 | result += execute("ifconfig %iface% %address% netmask %netmask%" |
591 | "[[ broadcast %broadcast%]][[ pointopoint %pointopoint%]]", |
592 | ifd, exec); |
593 | result += execute("[[route add default gw %gateway%[[ metric %metric%]] %iface%]]", ifd, exec); |
594 | return ((result == 3) ? 3 : 0); |
595 | # endif |
596 | } |
597 | |
598 | static int FAST_FUNC static_down(struct interface_defn_t *ifd, execfn *exec) |
599 | { |
600 | int result; |
601 | # if ENABLE_FEATURE_IFUPDOWN_IP |
602 | /* Optional "label LBL" is necessary if interface is an alias (eth0:0), |
603 | * otherwise "ip addr flush dev eth0:0" flushes all addresses on eth0. |
604 | */ |
605 | result = execute("ip addr flush dev %iface%[[ label %label%]]", ifd, exec); |
606 | result += execute("ip link set %iface% down", ifd, exec); |
607 | # else |
608 | /* result = execute("[[route del default gw %gateway% %iface%]]", ifd, exec); */ |
609 | /* Bringing the interface down deletes the routes in itself. |
610 | Otherwise this fails if we reference 'gateway' when using this from dhcp_down */ |
611 | result = 1; |
612 | result += execute("ifconfig %iface% down", ifd, exec); |
613 | # endif |
614 | return ((result == 2) ? 2 : 0); |
615 | } |
616 | |
617 | # if ENABLE_FEATURE_IFUPDOWN_EXTERNAL_DHCP |
618 | struct dhcp_client_t { |
619 | const char *name; |
620 | const char *startcmd; |
621 | const char *stopcmd; |
622 | }; |
623 | |
624 | static const struct dhcp_client_t ext_dhcp_clients[] = { |
625 | { "dhcpcd", |
626 | "dhcpcd[[ -h %hostname%]][[ -i %vendor%]][[ -I %client%]][[ -l %leasetime%]] %iface%", |
627 | "dhcpcd -k %iface%", |
628 | }, |
629 | { "dhclient", |
630 | "dhclient -pf /var/run/dhclient.%iface%.pid %iface%", |
631 | "kill -9 `cat /var/run/dhclient.%iface%.pid` 2>/dev/null", |
632 | }, |
633 | { "pump", |
634 | "pump -i %iface%[[ -h %hostname%]][[ -l %leasehours%]]", |
635 | "pump -i %iface% -k", |
636 | }, |
637 | { "udhcpc", |
638 | "udhcpc " UDHCPC_CMD_OPTIONS " -p /var/run/udhcpc.%iface%.pid -i %iface%[[ -x hostname:%hostname%]][[ -c %client%]]" |
639 | "[[ -s %script%]][[ %udhcpc_opts%]]", |
640 | "kill `cat /var/run/udhcpc.%iface%.pid` 2>/dev/null", |
641 | }, |
642 | }; |
643 | # endif /* FEATURE_IFUPDOWN_EXTERNAL_DHCPC */ |
644 | |
645 | # if ENABLE_FEATURE_IFUPDOWN_EXTERNAL_DHCP |
646 | static int FAST_FUNC dhcp_up(struct interface_defn_t *ifd, execfn *exec) |
647 | { |
648 | unsigned i; |
649 | # if ENABLE_FEATURE_IFUPDOWN_IP |
650 | /* ip doesn't up iface when it configures it (unlike ifconfig) */ |
651 | if (!execute("ip link set[[ addr %hwaddress%]] %iface% up", ifd, exec)) |
652 | return 0; |
653 | # else |
654 | /* needed if we have hwaddress on dhcp iface */ |
655 | if (!execute("ifconfig %iface%[[ hw %hwaddress%]] up", ifd, exec)) |
656 | return 0; |
657 | # endif |
658 | for (i = 0; i < ARRAY_SIZE(ext_dhcp_clients); i++) { |
659 | if (executable_exists(ext_dhcp_clients[i].name)) |
660 | return execute(ext_dhcp_clients[i].startcmd, ifd, exec); |
661 | } |
662 | bb_error_msg("no dhcp clients found"); |
663 | return 0; |
664 | } |
665 | # elif ENABLE_UDHCPC |
666 | static int FAST_FUNC dhcp_up(struct interface_defn_t *ifd, execfn *exec) |
667 | { |
668 | # if ENABLE_FEATURE_IFUPDOWN_IP |
669 | /* ip doesn't up iface when it configures it (unlike ifconfig) */ |
670 | if (!execute("ip link set[[ addr %hwaddress%]] %iface% up", ifd, exec)) |
671 | return 0; |
672 | # else |
673 | /* needed if we have hwaddress on dhcp iface */ |
674 | if (!execute("ifconfig %iface%[[ hw %hwaddress%]] up", ifd, exec)) |
675 | return 0; |
676 | # endif |
677 | return execute("udhcpc " UDHCPC_CMD_OPTIONS " -p /var/run/udhcpc.%iface%.pid " |
678 | "-i %iface%[[ -x hostname:%hostname%]][[ -c %client%]][[ -s %script%]][[ %udhcpc_opts%]]", |
679 | ifd, exec); |
680 | } |
681 | # else |
682 | static int FAST_FUNC dhcp_up(struct interface_defn_t *ifd UNUSED_PARAM, |
683 | execfn *exec UNUSED_PARAM) |
684 | { |
685 | return 0; /* no dhcp support */ |
686 | } |
687 | # endif |
688 | |
689 | # if ENABLE_FEATURE_IFUPDOWN_EXTERNAL_DHCP |
690 | static int FAST_FUNC dhcp_down(struct interface_defn_t *ifd, execfn *exec) |
691 | { |
692 | int result = 0; |
693 | unsigned i; |
694 | |
695 | for (i = 0; i < ARRAY_SIZE(ext_dhcp_clients); i++) { |
696 | if (executable_exists(ext_dhcp_clients[i].name)) { |
697 | result = execute(ext_dhcp_clients[i].stopcmd, ifd, exec); |
698 | if (result) |
699 | break; |
700 | } |
701 | } |
702 | |
703 | if (!result) |
704 | bb_error_msg("warning: no dhcp clients found and stopped"); |
705 | |
706 | /* Sleep a bit, otherwise static_down tries to bring down interface too soon, |
707 | and it may come back up because udhcpc is still shutting down */ |
708 | usleep(100000); |
709 | result += static_down(ifd, exec); |
710 | return ((result == 3) ? 3 : 0); |
711 | } |
712 | # elif ENABLE_UDHCPC |
713 | static int FAST_FUNC dhcp_down(struct interface_defn_t *ifd, execfn *exec) |
714 | { |
715 | int result; |
716 | result = execute( |
717 | "test -f /var/run/udhcpc.%iface%.pid && " |
718 | "kill `cat /var/run/udhcpc.%iface%.pid` 2>/dev/null", |
719 | ifd, exec); |
720 | /* Also bring the hardware interface down since |
721 | killing the dhcp client alone doesn't do it. |
722 | This enables consecutive ifup->ifdown->ifup */ |
723 | /* Sleep a bit, otherwise static_down tries to bring down interface too soon, |
724 | and it may come back up because udhcpc is still shutting down */ |
725 | usleep(100000); |
726 | result += static_down(ifd, exec); |
727 | return ((result == 3) ? 3 : 0); |
728 | } |
729 | # else |
730 | static int FAST_FUNC dhcp_down(struct interface_defn_t *ifd UNUSED_PARAM, |
731 | execfn *exec UNUSED_PARAM) |
732 | { |
733 | return 0; /* no dhcp support */ |
734 | } |
735 | # endif |
736 | |
737 | static int FAST_FUNC manual_up_down(struct interface_defn_t *ifd UNUSED_PARAM, execfn *exec UNUSED_PARAM) |
738 | { |
739 | return 1; |
740 | } |
741 | |
742 | static int FAST_FUNC bootp_up(struct interface_defn_t *ifd, execfn *exec) |
743 | { |
744 | return execute("bootpc[[ --bootfile %bootfile%]] --dev %iface%" |
745 | "[[ --server %server%]][[ --hwaddr %hwaddr%]]" |
746 | " --returniffail --serverbcast", ifd, exec); |
747 | } |
748 | |
749 | static int FAST_FUNC ppp_up(struct interface_defn_t *ifd, execfn *exec) |
750 | { |
751 | return execute("pon[[ %provider%]]", ifd, exec); |
752 | } |
753 | |
754 | static int FAST_FUNC ppp_down(struct interface_defn_t *ifd, execfn *exec) |
755 | { |
756 | return execute("poff[[ %provider%]]", ifd, exec); |
757 | } |
758 | |
759 | static int FAST_FUNC wvdial_up(struct interface_defn_t *ifd, execfn *exec) |
760 | { |
761 | return execute("start-stop-daemon --start -x wvdial " |
762 | "-p /var/run/wvdial.%iface% -b -m --[[ %provider%]]", ifd, exec); |
763 | } |
764 | |
765 | static int FAST_FUNC wvdial_down(struct interface_defn_t *ifd, execfn *exec) |
766 | { |
767 | return execute("start-stop-daemon --stop -x wvdial " |
768 | "-p /var/run/wvdial.%iface% -s 2", ifd, exec); |
769 | } |
770 | |
771 | static const struct method_t methods[] = { |
772 | { "manual" , manual_up_down, manual_up_down, }, |
773 | { "wvdial" , wvdial_up , wvdial_down , }, |
774 | { "ppp" , ppp_up , ppp_down , }, |
775 | { "static" , static_up , static_down , }, |
776 | { "bootp" , bootp_up , static_down , }, |
777 | { "dhcp" , dhcp_up , dhcp_down , }, |
778 | { "loopback", loopback_up , loopback_down , }, |
779 | }; |
780 | |
781 | static const struct address_family_t addr_inet = { |
782 | "inet", |
783 | ARRAY_SIZE(methods), |
784 | methods |
785 | }; |
786 | |
787 | #endif /* FEATURE_IFUPDOWN_IPV4 */ |
788 | |
789 | static int FAST_FUNC link_up_down(struct interface_defn_t *ifd UNUSED_PARAM, execfn *exec UNUSED_PARAM) |
790 | { |
791 | return 1; |
792 | } |
793 | |
794 | static const struct method_t link_methods[] = { |
795 | { "none", link_up_down, link_up_down } |
796 | }; |
797 | |
798 | static const struct address_family_t addr_link = { |
799 | "link", ARRAY_SIZE(link_methods), link_methods |
800 | }; |
801 | |
802 | /* Returns pointer to the next word, or NULL. |
803 | * In 1st case, advances *buf to the word after this one. |
804 | */ |
805 | static char *next_word(char **buf) |
806 | { |
807 | unsigned length; |
808 | char *word; |
809 | |
810 | /* Skip over leading whitespace */ |
811 | word = skip_whitespace(*buf); |
812 | |
813 | /* Stop on EOL */ |
814 | if (*word == '\0') |
815 | return NULL; |
816 | |
817 | /* Find the length of this word (can't be 0) */ |
818 | length = strcspn(word, " \t\n"); |
819 | |
820 | /* Unless we are already at NUL, store NUL and advance */ |
821 | if (word[length] != '\0') |
822 | word[length++] = '\0'; |
823 | |
824 | *buf = skip_whitespace(word + length); |
825 | |
826 | return word; |
827 | } |
828 | |
829 | static const struct address_family_t *get_address_family(const struct address_family_t *const af[], char *name) |
830 | { |
831 | int i; |
832 | |
833 | if (!name) |
834 | return NULL; |
835 | |
836 | for (i = 0; af[i]; i++) { |
837 | if (strcmp(af[i]->name, name) == 0) { |
838 | return af[i]; |
839 | } |
840 | } |
841 | return NULL; |
842 | } |
843 | |
844 | static const struct method_t *get_method(const struct address_family_t *af, char *name) |
845 | { |
846 | int i; |
847 | |
848 | if (!name) |
849 | return NULL; |
850 | /* TODO: use index_in_str_array() */ |
851 | for (i = 0; i < af->n_methods; i++) { |
852 | if (strcmp(af->method[i].name, name) == 0) { |
853 | return &af->method[i]; |
854 | } |
855 | } |
856 | return NULL; |
857 | } |
858 | |
859 | static struct interfaces_file_t *read_interfaces(const char *filename, struct interfaces_file_t *defn) |
860 | { |
861 | /* Let's try to be compatible. |
862 | * |
863 | * "man 5 interfaces" says: |
864 | * Lines starting with "#" are ignored. Note that end-of-line |
865 | * comments are NOT supported, comments must be on a line of their own. |
866 | * A line may be extended across multiple lines by making |
867 | * the last character a backslash. |
868 | * |
869 | * Seen elsewhere in example config file: |
870 | * A first non-blank "#" character makes the rest of the line |
871 | * be ignored. Blank lines are ignored. Lines may be indented freely. |
872 | * A "\" character at the very end of the line indicates the next line |
873 | * should be treated as a continuation of the current one. |
874 | * |
875 | * Lines beginning with "source" are used to include stanzas from |
876 | * other files, so configuration can be split into many files. |
877 | * The word "source" is followed by the path of file to be sourced. |
878 | */ |
879 | #if ENABLE_FEATURE_IFUPDOWN_MAPPING |
880 | struct mapping_defn_t *currmap = NULL; |
881 | #endif |
882 | struct interface_defn_t *currif = NULL; |
883 | FILE *f; |
884 | char *buf; |
885 | char *first_word; |
886 | char *rest_of_line; |
887 | enum { NONE, IFACE, MAPPING } currently_processing = NONE; |
888 | |
889 | if (!defn) |
890 | defn = xzalloc(sizeof(*defn)); |
891 | |
892 | debug_noise("reading %s file:\n", filename); |
893 | f = xfopen_for_read(filename); |
894 | |
895 | while ((buf = xmalloc_fgetline(f)) != NULL) { |
896 | #if ENABLE_DESKTOP |
897 | /* Trailing "\" concatenates lines */ |
898 | char *p; |
899 | while ((p = last_char_is(buf, '\\')) != NULL) { |
900 | *p = '\0'; |
901 | rest_of_line = xmalloc_fgetline(f); |
902 | if (!rest_of_line) |
903 | break; |
904 | p = xasprintf("%s%s", buf, rest_of_line); |
905 | free(buf); |
906 | free(rest_of_line); |
907 | buf = p; |
908 | } |
909 | #endif |
910 | rest_of_line = buf; |
911 | first_word = next_word(&rest_of_line); |
912 | if (!first_word || *first_word == '#') { |
913 | free(buf); |
914 | continue; /* blank/comment line */ |
915 | } |
916 | |
917 | if (strcmp(first_word, "mapping") == 0) { |
918 | #if ENABLE_FEATURE_IFUPDOWN_MAPPING |
919 | currmap = xzalloc(sizeof(*currmap)); |
920 | |
921 | while ((first_word = next_word(&rest_of_line)) != NULL) { |
922 | currmap->match = xrealloc_vector(currmap->match, 4, currmap->n_matches); |
923 | currmap->match[currmap->n_matches++] = xstrdup(first_word); |
924 | } |
925 | /*currmap->n_mappings = 0;*/ |
926 | /*currmap->mapping = NULL;*/ |
927 | /*currmap->script = NULL;*/ |
928 | { |
929 | struct mapping_defn_t **where = &defn->mappings; |
930 | while (*where != NULL) { |
931 | where = &(*where)->next; |
932 | } |
933 | *where = currmap; |
934 | /*currmap->next = NULL;*/ |
935 | } |
936 | debug_noise("Added mapping\n"); |
937 | #endif |
938 | currently_processing = MAPPING; |
939 | } else if (strcmp(first_word, "iface") == 0) { |
940 | static const struct address_family_t *const addr_fams[] = { |
941 | #if ENABLE_FEATURE_IFUPDOWN_IPV4 |
942 | &addr_inet, |
943 | #endif |
944 | #if ENABLE_FEATURE_IFUPDOWN_IPV6 |
945 | &addr_inet6, |
946 | #endif |
947 | &addr_link, |
948 | NULL |
949 | }; |
950 | char *iface_name; |
951 | char *address_family_name; |
952 | char *method_name; |
953 | |
954 | currif = xzalloc(sizeof(*currif)); |
955 | iface_name = next_word(&rest_of_line); |
956 | address_family_name = next_word(&rest_of_line); |
957 | method_name = next_word(&rest_of_line); |
958 | |
959 | if (method_name == NULL) |
960 | bb_error_msg_and_die("too few parameters for line \"%s\"", buf); |
961 | |
962 | /* ship any trailing whitespace */ |
963 | rest_of_line = skip_whitespace(rest_of_line); |
964 | |
965 | if (rest_of_line[0] != '\0' /* && rest_of_line[0] != '#' */) |
966 | bb_error_msg_and_die("too many parameters \"%s\"", buf); |
967 | |
968 | currif->iface = xstrdup(iface_name); |
969 | |
970 | currif->address_family = get_address_family(addr_fams, address_family_name); |
971 | if (!currif->address_family) |
972 | bb_error_msg_and_die("unknown address type \"%s\"", address_family_name); |
973 | |
974 | currif->method = get_method(currif->address_family, method_name); |
975 | if (!currif->method) |
976 | bb_error_msg_and_die("unknown method \"%s\"", method_name); |
977 | #if 0 |
978 | // Allegedly, Debian allows a duplicate definition: |
979 | // iface eth0 inet static |
980 | // address 192.168.0.15 |
981 | // netmask 255.255.0.0 |
982 | // gateway 192.168.0.1 |
983 | // |
984 | // iface eth0 inet static |
985 | // address 10.0.0.1 |
986 | // netmask 255.255.255.0 |
987 | // |
988 | // This adds *two* addresses to eth0 (probably requires use of "ip", not "ifconfig" |
989 | // |
990 | llist_t *iface_list; |
991 | for (iface_list = defn->ifaces; iface_list; iface_list = iface_list->link) { |
992 | struct interface_defn_t *tmp = (struct interface_defn_t *) iface_list->data; |
993 | if ((strcmp(tmp->iface, currif->iface) == 0) |
994 | && (tmp->address_family == currif->address_family) |
995 | ) { |
996 | bb_error_msg_and_die("duplicate interface \"%s\"", tmp->iface); |
997 | } |
998 | } |
999 | #endif |
1000 | llist_add_to_end(&(defn->ifaces), (char*)currif); |
1001 | |
1002 | debug_noise("iface %s %s %s\n", currif->iface, address_family_name, method_name); |
1003 | currently_processing = IFACE; |
1004 | } else if (strcmp(first_word, "auto") == 0) { |
1005 | while ((first_word = next_word(&rest_of_line)) != NULL) { |
1006 | |
1007 | /* Check the interface isnt already listed */ |
1008 | if (llist_find_str(defn->autointerfaces, first_word)) { |
1009 | bb_perror_msg_and_die("interface declared auto twice \"%s\"", buf); |
1010 | } |
1011 | |
1012 | /* Add the interface to the list */ |
1013 | llist_add_to_end(&(defn->autointerfaces), xstrdup(first_word)); |
1014 | debug_noise("\nauto %s\n", first_word); |
1015 | } |
1016 | currently_processing = NONE; |
1017 | } else if (strcmp(first_word, "source") == 0) { |
1018 | read_interfaces(next_word(&rest_of_line), defn); |
1019 | } else { |
1020 | switch (currently_processing) { |
1021 | case IFACE: |
1022 | if (rest_of_line[0] == '\0') |
1023 | bb_error_msg_and_die("option with empty value \"%s\"", buf); |
1024 | |
1025 | if (strcmp(first_word, "post-up") == 0) |
1026 | first_word += 5; /* "up" */ |
1027 | else if (strcmp(first_word, "pre-down") == 0) |
1028 | first_word += 4; /* "down" */ |
1029 | |
1030 | /* If not one of "up", "down",... words... */ |
1031 | if (index_in_strings(keywords_up_down, first_word) < 0) { |
1032 | int i; |
1033 | for (i = 0; i < currif->n_options; i++) { |
1034 | if (strcmp(currif->option[i].name, first_word) == 0) |
1035 | bb_error_msg_and_die("duplicate option \"%s\"", buf); |
1036 | } |
1037 | } |
1038 | debug_noise("\t%s=%s\n", first_word, rest_of_line); |
1039 | currif->option = xrealloc_vector(currif->option, 4, currif->n_options); |
1040 | currif->option[currif->n_options].name = xstrdup(first_word); |
1041 | currif->option[currif->n_options].value = xstrdup(rest_of_line); |
1042 | currif->n_options++; |
1043 | break; |
1044 | case MAPPING: |
1045 | #if ENABLE_FEATURE_IFUPDOWN_MAPPING |
1046 | if (strcmp(first_word, "script") == 0) { |
1047 | if (currmap->script != NULL) |
1048 | bb_error_msg_and_die("duplicate script in mapping \"%s\"", buf); |
1049 | currmap->script = xstrdup(next_word(&rest_of_line)); |
1050 | } else if (strcmp(first_word, "map") == 0) { |
1051 | currmap->mapping = xrealloc_vector(currmap->mapping, 2, currmap->n_mappings); |
1052 | currmap->mapping[currmap->n_mappings] = xstrdup(next_word(&rest_of_line)); |
1053 | currmap->n_mappings++; |
1054 | } else { |
1055 | bb_error_msg_and_die("misplaced option \"%s\"", buf); |
1056 | } |
1057 | #endif |
1058 | break; |
1059 | case NONE: |
1060 | default: |
1061 | bb_error_msg_and_die("misplaced option \"%s\"", buf); |
1062 | } |
1063 | } |
1064 | free(buf); |
1065 | } /* while (fgets) */ |
1066 | |
1067 | if (ferror(f) != 0) { |
1068 | /* ferror does NOT set errno! */ |
1069 | bb_error_msg_and_die("%s: I/O error", filename); |
1070 | } |
1071 | fclose(f); |
1072 | debug_noise("\ndone reading %s\n\n", filename); |
1073 | |
1074 | return defn; |
1075 | } |
1076 | |
1077 | static char *setlocalenv(const char *format, const char *name, const char *value) |
1078 | { |
1079 | char *result; |
1080 | char *dst; |
1081 | char *src; |
1082 | char c; |
1083 | |
1084 | result = xasprintf(format, name, value); |
1085 | |
1086 | for (dst = src = result; (c = *src) != '=' && c; src++) { |
1087 | if (c == '-') |
1088 | c = '_'; |
1089 | if (c >= 'a' && c <= 'z') |
1090 | c -= ('a' - 'A'); |
1091 | if (isalnum(c) || c == '_') |
1092 | *dst++ = c; |
1093 | } |
1094 | overlapping_strcpy(dst, src); |
1095 | |
1096 | return result; |
1097 | } |
1098 | |
1099 | static void set_environ(struct interface_defn_t *iface, const char *mode, const char *opt) |
1100 | { |
1101 | int i; |
1102 | char **pp; |
1103 | |
1104 | if (G.my_environ != NULL) { |
1105 | for (pp = G.my_environ; *pp; pp++) { |
1106 | free(*pp); |
1107 | } |
1108 | free(G.my_environ); |
1109 | } |
1110 | |
1111 | /* note: last element will stay NULL: */ |
1112 | G.my_environ = xzalloc(sizeof(char *) * (iface->n_options + 7)); |
1113 | pp = G.my_environ; |
1114 | |
1115 | for (i = 0; i < iface->n_options; i++) { |
1116 | if (index_in_strings(keywords_up_down, iface->option[i].name) >= 0) { |
1117 | continue; |
1118 | } |
1119 | *pp++ = setlocalenv("IF_%s=%s", iface->option[i].name, iface->option[i].value); |
1120 | } |
1121 | |
1122 | *pp++ = setlocalenv("%s=%s", "IFACE", iface->iface); |
1123 | *pp++ = setlocalenv("%s=%s", "ADDRFAM", iface->address_family->name); |
1124 | *pp++ = setlocalenv("%s=%s", "METHOD", iface->method->name); |
1125 | *pp++ = setlocalenv("%s=%s", "MODE", mode); |
1126 | *pp++ = setlocalenv("%s=%s", "PHASE", opt); |
1127 | if (G.startup_PATH) |
1128 | *pp++ = setlocalenv("%s=%s", "PATH", G.startup_PATH); |
1129 | } |
1130 | |
1131 | static int doit(char *str) |
1132 | { |
1133 | if (option_mask32 & (OPT_no_act|OPT_verbose)) { |
1134 | puts(str); |
1135 | } |
1136 | if (!(option_mask32 & OPT_no_act)) { |
1137 | pid_t child; |
1138 | int status; |
1139 | |
1140 | fflush_all(); |
1141 | child = vfork(); |
1142 | if (child < 0) /* failure */ |
1143 | return 0; |
1144 | if (child == 0) { /* child */ |
1145 | execle(G.shell, G.shell, "-c", str, (char *) NULL, G.my_environ); |
1146 | _exit(127); |
1147 | } |
1148 | safe_waitpid(child, &status, 0); |
1149 | if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) { |
1150 | return 0; |
1151 | } |
1152 | } |
1153 | return 1; |
1154 | } |
1155 | |
1156 | static int execute_all(struct interface_defn_t *ifd, const char *opt) |
1157 | { |
1158 | int i; |
1159 | char *buf; |
1160 | for (i = 0; i < ifd->n_options; i++) { |
1161 | if (strcmp(ifd->option[i].name, opt) == 0) { |
1162 | if (!doit(ifd->option[i].value)) { |
1163 | return 0; |
1164 | } |
1165 | } |
1166 | } |
1167 | |
1168 | /* Tested on Debian Squeeze: "standard" ifup runs this without |
1169 | * checking that directory exists. If it doesn't, run-parts |
1170 | * complains, and this message _is_ annoyingly visible. |
1171 | * Don't "fix" this (unless newer Debian does). |
1172 | */ |
1173 | buf = xasprintf("run-parts /etc/network/if-%s.d", opt); |
1174 | /* heh, we don't bother free'ing it */ |
1175 | return doit(buf); |
1176 | } |
1177 | |
1178 | static int check(char *str) |
1179 | { |
1180 | return str != NULL; |
1181 | } |
1182 | |
1183 | static int iface_up(struct interface_defn_t *iface) |
1184 | { |
1185 | if (!iface->method->up(iface, check)) return -1; |
1186 | set_environ(iface, "start", "pre-up"); |
1187 | if (!execute_all(iface, "pre-up")) return 0; |
1188 | if (!iface->method->up(iface, doit)) return 0; |
1189 | set_environ(iface, "start", "post-up"); |
1190 | if (!execute_all(iface, "up")) return 0; |
1191 | return 1; |
1192 | } |
1193 | |
1194 | static int iface_down(struct interface_defn_t *iface) |
1195 | { |
1196 | if (!iface->method->down(iface, check)) return -1; |
1197 | set_environ(iface, "stop", "pre-down"); |
1198 | if (!execute_all(iface, "down")) return 0; |
1199 | if (!iface->method->down(iface, doit)) return 0; |
1200 | set_environ(iface, "stop", "post-down"); |
1201 | if (!execute_all(iface, "post-down")) return 0; |
1202 | return 1; |
1203 | } |
1204 | |
1205 | #if ENABLE_FEATURE_IFUPDOWN_MAPPING |
1206 | static int popen2(FILE **in, FILE **out, char *command, char *param) |
1207 | { |
1208 | char *argv[3] = { command, param, NULL }; |
1209 | struct fd_pair infd, outfd; |
1210 | pid_t pid; |
1211 | |
1212 | xpiped_pair(infd); |
1213 | xpiped_pair(outfd); |
1214 | |
1215 | fflush_all(); |
1216 | pid = xvfork(); |
1217 | |
1218 | if (pid == 0) { |
1219 | /* Child */ |
1220 | /* NB: close _first_, then move fds! */ |
1221 | close(infd.wr); |
1222 | close(outfd.rd); |
1223 | xmove_fd(infd.rd, 0); |
1224 | xmove_fd(outfd.wr, 1); |
1225 | BB_EXECVP_or_die(argv); |
1226 | } |
1227 | /* parent */ |
1228 | close(infd.rd); |
1229 | close(outfd.wr); |
1230 | *in = xfdopen_for_write(infd.wr); |
1231 | *out = xfdopen_for_read(outfd.rd); |
1232 | return pid; |
1233 | } |
1234 | |
1235 | static char *run_mapping(char *physical, struct mapping_defn_t *map) |
1236 | { |
1237 | FILE *in, *out; |
1238 | int i, status; |
1239 | pid_t pid; |
1240 | |
1241 | char *logical = xstrdup(physical); |
1242 | |
1243 | /* Run the mapping script. Never fails. */ |
1244 | pid = popen2(&in, &out, map->script, physical); |
1245 | |
1246 | /* Write mappings to stdin of mapping script. */ |
1247 | for (i = 0; i < map->n_mappings; i++) { |
1248 | fprintf(in, "%s\n", map->mapping[i]); |
1249 | } |
1250 | fclose(in); |
1251 | safe_waitpid(pid, &status, 0); |
1252 | |
1253 | if (WIFEXITED(status) && WEXITSTATUS(status) == 0) { |
1254 | /* If the mapping script exited successfully, try to |
1255 | * grab a line of output and use that as the name of the |
1256 | * logical interface. */ |
1257 | char *new_logical = xmalloc_fgetline(out); |
1258 | |
1259 | if (new_logical) { |
1260 | /* If we are able to read a line of output from the script, |
1261 | * remove any trailing whitespace and use this value |
1262 | * as the name of the logical interface. */ |
1263 | char *pch = new_logical + strlen(new_logical) - 1; |
1264 | |
1265 | while (pch >= new_logical && isspace(*pch)) |
1266 | *(pch--) = '\0'; |
1267 | |
1268 | free(logical); |
1269 | logical = new_logical; |
1270 | } |
1271 | } |
1272 | |
1273 | fclose(out); |
1274 | |
1275 | return logical; |
1276 | } |
1277 | #endif /* FEATURE_IFUPDOWN_MAPPING */ |
1278 | |
1279 | static llist_t *find_iface_state(llist_t *state_list, const char *iface) |
1280 | { |
1281 | llist_t *search = state_list; |
1282 | |
1283 | while (search) { |
1284 | char *after_iface = is_prefixed_with(search->data, iface); |
1285 | if (after_iface |
1286 | && *after_iface == '=' |
1287 | ) { |
1288 | return search; |
1289 | } |
1290 | search = search->link; |
1291 | } |
1292 | return NULL; |
1293 | } |
1294 | |
1295 | /* read the previous state from the state file */ |
1296 | static llist_t *read_iface_state(void) |
1297 | { |
1298 | llist_t *state_list = NULL; |
1299 | FILE *state_fp = fopen_for_read(IFSTATE_FILE_PATH); |
1300 | |
1301 | if (state_fp) { |
1302 | char *start, *end_ptr; |
1303 | while ((start = xmalloc_fgets(state_fp)) != NULL) { |
1304 | /* We should only need to check for a single character */ |
1305 | end_ptr = start + strcspn(start, " \t\n"); |
1306 | *end_ptr = '\0'; |
1307 | llist_add_to(&state_list, start); |
1308 | } |
1309 | fclose(state_fp); |
1310 | } |
1311 | return state_list; |
1312 | } |
1313 | |
1314 | /* read the previous state from the state file */ |
1315 | static FILE *open_new_state_file(void) |
1316 | { |
1317 | int fd, flags, cnt; |
1318 | |
1319 | cnt = 0; |
1320 | flags = (O_WRONLY | O_CREAT | O_EXCL); |
1321 | for (;;) { |
1322 | fd = open(IFSTATE_FILE_PATH".new", flags, 0666); |
1323 | if (fd >= 0) |
1324 | break; |
1325 | if (errno != EEXIST |
1326 | || flags == (O_WRONLY | O_CREAT | O_TRUNC) |
1327 | ) { |
1328 | bb_perror_msg_and_die("can't open '%s'", |
1329 | IFSTATE_FILE_PATH".new"); |
1330 | } |
1331 | /* Someone else created the .new file */ |
1332 | if (cnt > 30 * 1000) { |
1333 | /* Waited for 30*30/2 = 450 milliseconds, still EEXIST. |
1334 | * Assuming a stale file, rewriting it. |
1335 | */ |
1336 | flags = (O_WRONLY | O_CREAT | O_TRUNC); |
1337 | continue; |
1338 | } |
1339 | usleep(cnt); |
1340 | cnt += 1000; |
1341 | } |
1342 | |
1343 | return xfdopen_for_write(fd); |
1344 | } |
1345 | |
1346 | int ifupdown_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; |
1347 | int ifupdown_main(int argc UNUSED_PARAM, char **argv) |
1348 | { |
1349 | int (*cmds)(struct interface_defn_t *); |
1350 | struct interfaces_file_t *defn; |
1351 | llist_t *target_list = NULL; |
1352 | const char *interfaces = "/etc/network/interfaces"; |
1353 | bool any_failures = 0; |
1354 | |
1355 | INIT_G(); |
1356 | |
1357 | G.startup_PATH = getenv("PATH"); |
1358 | G.shell = xstrdup(get_shell_name()); |
1359 | |
1360 | if (ENABLE_IFUP |
1361 | && (!ENABLE_IFDOWN || applet_name[2] == 'u') |
1362 | ) { |
1363 | /* ifup command */ |
1364 | cmds = iface_up; |
1365 | } else { |
1366 | cmds = iface_down; |
1367 | } |
1368 | |
1369 | getopt32(argv, OPTION_STR, &interfaces); |
1370 | argv += optind; |
1371 | if (argv[0]) { |
1372 | if (DO_ALL) bb_show_usage(); |
1373 | } else { |
1374 | if (!DO_ALL) bb_show_usage(); |
1375 | } |
1376 | |
1377 | defn = read_interfaces(interfaces, NULL); |
1378 | |
1379 | /* Create a list of interfaces to work on */ |
1380 | if (DO_ALL) { |
1381 | target_list = defn->autointerfaces; |
1382 | } else { |
1383 | llist_add_to_end(&target_list, argv[0]); |
1384 | } |
1385 | |
1386 | /* Update the interfaces */ |
1387 | while (target_list) { |
1388 | llist_t *iface_list; |
1389 | struct interface_defn_t *currif; |
1390 | char *iface; |
1391 | char *liface; |
1392 | char *pch; |
1393 | bool okay = 0; |
1394 | int cmds_ret; |
1395 | bool curr_failure = 0; |
1396 | |
1397 | iface = xstrdup(target_list->data); |
1398 | target_list = target_list->link; |
1399 | |
1400 | pch = strchr(iface, '='); |
1401 | if (pch) { |
1402 | *pch = '\0'; |
1403 | liface = xstrdup(pch + 1); |
1404 | } else { |
1405 | liface = xstrdup(iface); |
1406 | } |
1407 | |
1408 | if (!FORCE) { |
1409 | llist_t *state_list = read_iface_state(); |
1410 | const llist_t *iface_state = find_iface_state(state_list, iface); |
1411 | |
1412 | if (cmds == iface_up) { |
1413 | /* ifup */ |
1414 | if (iface_state) { |
1415 | bb_error_msg("interface %s already configured", iface); |
1416 | goto next; |
1417 | } |
1418 | } else { |
1419 | /* ifdown */ |
1420 | if (!iface_state) { |
1421 | bb_error_msg("interface %s not configured", iface); |
1422 | goto next; |
1423 | } |
1424 | } |
1425 | llist_free(state_list, free); |
1426 | } |
1427 | |
1428 | #if ENABLE_FEATURE_IFUPDOWN_MAPPING |
1429 | if ((cmds == iface_up) && !NO_MAPPINGS) { |
1430 | struct mapping_defn_t *currmap; |
1431 | |
1432 | for (currmap = defn->mappings; currmap; currmap = currmap->next) { |
1433 | int i; |
1434 | for (i = 0; i < currmap->n_matches; i++) { |
1435 | if (fnmatch(currmap->match[i], liface, 0) != 0) |
1436 | continue; |
1437 | if (VERBOSE) { |
1438 | printf("Running mapping script %s on %s\n", currmap->script, liface); |
1439 | } |
1440 | liface = run_mapping(iface, currmap); |
1441 | break; |
1442 | } |
1443 | } |
1444 | } |
1445 | #endif |
1446 | |
1447 | iface_list = defn->ifaces; |
1448 | while (iface_list) { |
1449 | currif = (struct interface_defn_t *) iface_list->data; |
1450 | if (strcmp(liface, currif->iface) == 0) { |
1451 | char *oldiface = currif->iface; |
1452 | |
1453 | okay = 1; |
1454 | currif->iface = iface; |
1455 | |
1456 | debug_noise("\nConfiguring interface %s (%s)\n", liface, currif->address_family->name); |
1457 | |
1458 | /* Call the cmds function pointer, does either iface_up() or iface_down() */ |
1459 | cmds_ret = cmds(currif); |
1460 | if (cmds_ret == -1) { |
1461 | bb_error_msg("don't have all variables for %s/%s", |
1462 | liface, currif->address_family->name); |
1463 | any_failures = curr_failure = 1; |
1464 | } else if (cmds_ret == 0) { |
1465 | any_failures = curr_failure = 1; |
1466 | } |
1467 | |
1468 | currif->iface = oldiface; |
1469 | } |
1470 | iface_list = iface_list->link; |
1471 | } |
1472 | if (VERBOSE) { |
1473 | bb_putchar('\n'); |
1474 | } |
1475 | |
1476 | if (!okay && !FORCE) { |
1477 | bb_error_msg("ignoring unknown interface %s", liface); |
1478 | any_failures = 1; |
1479 | } else if (!NO_ACT) { |
1480 | /* update the state file */ |
1481 | FILE *new_state_fp = open_new_state_file(); |
1482 | llist_t *state; |
1483 | llist_t *state_list = read_iface_state(); |
1484 | llist_t *iface_state = find_iface_state(state_list, iface); |
1485 | |
1486 | if (cmds == iface_up && !curr_failure) { |
1487 | char *newiface = xasprintf("%s=%s", iface, liface); |
1488 | if (!iface_state) { |
1489 | llist_add_to_end(&state_list, newiface); |
1490 | } else { |
1491 | free(iface_state->data); |
1492 | iface_state->data = newiface; |
1493 | } |
1494 | } else { |
1495 | /* Remove an interface from state_list */ |
1496 | llist_unlink(&state_list, iface_state); |
1497 | free(llist_pop(&iface_state)); |
1498 | } |
1499 | |
1500 | /* Actually write the new state */ |
1501 | state = state_list; |
1502 | while (state) { |
1503 | if (state->data) { |
1504 | fprintf(new_state_fp, "%s\n", state->data); |
1505 | } |
1506 | state = state->link; |
1507 | } |
1508 | fclose(new_state_fp); |
1509 | xrename(IFSTATE_FILE_PATH".new", IFSTATE_FILE_PATH); |
1510 | llist_free(state_list, free); |
1511 | } |
1512 | next: |
1513 | free(iface); |
1514 | free(liface); |
1515 | } |
1516 | |
1517 | return any_failures; |
1518 | } |
1519 |