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