/* vi: set sw=4 ts=4: */
/*
* ifupdown for busybox
- * Copyright (c) 2002 Glenn McGrath <bug1@iinet.net.au>
+ * Copyright (c) 2002 Glenn McGrath
* Copyright (c) 2003-2004 Erik Andersen <andersen@codepoet.org>
*
* Based on ifupdown v 0.6.4 by Anthony Towns
* (defined via CONFIG_IFUPDOWN_IFSTATE_PATH) and can be overridden by build
* configuration.
*
- * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
*/
-#include <sys/utsname.h>
-#include <fnmatch.h>
-#include <getopt.h>
+//usage:#define ifup_trivial_usage
+//usage: "[-an"IF_FEATURE_IFUPDOWN_MAPPING("m")"vf] [-i FILE] IFACE..."
+//usage:#define ifup_full_usage "\n\n"
+//usage: " -a De/configure all interfaces automatically"
+//usage: "\n -i FILE Use FILE for interface definitions"
+//usage: "\n -n Print out what would happen, but don't do it"
+//usage: IF_FEATURE_IFUPDOWN_MAPPING(
+//usage: "\n (note: doesn't disable mappings)"
+//usage: "\n -m Don't run any mappings"
+//usage: )
+//usage: "\n -v Print out what would happen before doing it"
+//usage: "\n -f Force de/configuration"
+//usage:
+//usage:#define ifdown_trivial_usage
+//usage: "[-an"IF_FEATURE_IFUPDOWN_MAPPING("m")"vf] [-i FILE] IFACE..."
+//usage:#define ifdown_full_usage "\n\n"
+//usage: " -a De/configure all interfaces automatically"
+//usage: "\n -i FILE Use FILE for interface definitions"
+//usage: "\n -n Print out what would happen, but don't do it"
+//usage: IF_FEATURE_IFUPDOWN_MAPPING(
+//usage: "\n (note: doesn't disable mappings)"
+//usage: "\n -m Don't run any mappings"
+//usage: )
+//usage: "\n -v Print out what would happen before doing it"
+//usage: "\n -f Force de/configuration"
#include "libbb.h"
+/* After libbb.h, since it needs sys/types.h on some systems */
+#include <sys/utsname.h>
+#include <fnmatch.h>
#define MAX_OPT_DEPTH 10
-#define EUNBALBRACK 10001
-#define EUNDEFVAR 10002
-#define EUNBALPER 10000
#if ENABLE_FEATURE_IFUPDOWN_MAPPING
#define MAX_INTERFACE_LENGTH 10
#endif
+#define UDHCPC_CMD_OPTIONS CONFIG_IFUPDOWN_UDHCPC_CMD_OPTIONS
+
#define debug_noise(args...) /*fprintf(stderr, args)*/
/* Forward declaration */
struct method_t {
const char *name;
- int (*up)(struct interface_defn_t *ifd, execfn *e);
- int (*down)(struct interface_defn_t *ifd, execfn *e);
+ int (*up)(struct interface_defn_t *ifd, execfn *e) FAST_FUNC;
+ int (*down)(struct interface_defn_t *ifd, execfn *e) FAST_FUNC;
};
struct address_family_t {
char *script;
- int max_mappings;
int n_mappings;
char **mapping;
};
const struct method_t *method;
char *iface;
- int max_options;
int n_options;
struct variable_t *option;
};
struct mapping_defn_t *mappings;
};
-#define OPTION_STR "anvf" USE_FEATURE_IFUPDOWN_MAPPING("m") "i:"
+
+#define OPTION_STR "anvf" IF_FEATURE_IFUPDOWN_MAPPING("m") "i:"
enum {
- OPT_do_all = 0x1,
- OPT_no_act = 0x2,
- OPT_verbose = 0x4,
- OPT_force = 0x8,
+ OPT_do_all = 0x1,
+ OPT_no_act = 0x2,
+ OPT_verbose = 0x4,
+ OPT_force = 0x8,
OPT_no_mappings = 0x10,
};
-#define DO_ALL (option_mask32 & OPT_do_all)
-#define NO_ACT (option_mask32 & OPT_no_act)
-#define VERBOSE (option_mask32 & OPT_verbose)
-#define FORCE (option_mask32 & OPT_force)
+#define DO_ALL (option_mask32 & OPT_do_all)
+#define NO_ACT (option_mask32 & OPT_no_act)
+#define VERBOSE (option_mask32 & OPT_verbose)
+#define FORCE (option_mask32 & OPT_force)
#define NO_MAPPINGS (option_mask32 & OPT_no_mappings)
-static char **my_environ;
-static const char *startup_PATH;
+struct globals {
+ char **my_environ;
+ const char *startup_PATH;
+ char *shell;
+} FIX_ALIASING;
+#define G (*(struct globals*)&bb_common_bufsiz1)
+#define INIT_G() do { } while (0)
+
+
+static const char keywords_up_down[] ALIGN1 =
+ "up\0"
+ "down\0"
+ "pre-up\0"
+ "post-down\0"
+;
+
#if ENABLE_FEATURE_IFUPDOWN_IPV4 || ENABLE_FEATURE_IFUPDOWN_IPV6
int i = strncmp(l, r, llen);
if (i == 0)
- return -r[llen];
+ return - (unsigned char)r[llen];
return i;
}
int i;
if (strncmpz(id, "iface", idlen) == 0) {
- char *result;
- static char label_buf[20];
- safe_strncpy(label_buf, ifd->iface, sizeof(label_buf));
- result = strchr(label_buf, ':');
- if (result) {
- *result = '\0';
- }
- return label_buf;
+ // ubuntu's ifup doesn't do this:
+ //static char *label_buf;
+ //char *result;
+ //free(label_buf);
+ //label_buf = xstrdup(ifd->iface);
+ // Remove virtual iface suffix
+ //result = strchrnul(label_buf, ':');
+ //*result = '\0';
+ //return label_buf;
+
+ return ifd->iface;
}
if (strncmpz(id, "label", idlen) == 0) {
return ifd->iface;
return NULL;
}
-#if ENABLE_FEATURE_IFUPDOWN_IP
+# if ENABLE_FEATURE_IFUPDOWN_IP
static int count_netmask_bits(const char *dotted_quad)
{
// int result;
}
return result;
}
-#endif
+# endif
static char *parse(const char *command, struct interface_defn_t *ifd)
{
size_t old_pos[MAX_OPT_DEPTH] = { 0 };
- int okay[MAX_OPT_DEPTH] = { 1 };
+ smallint okay[MAX_OPT_DEPTH] = { 1 };
int opt_depth = 1;
char *result = NULL;
command++;
break;
case '\\':
- if (command[1]) {
- addstr(&result, command + 1, 1);
- command += 2;
- } else {
- addstr(&result, command, 1);
+ if (command[1])
command++;
- }
+ addstr(&result, command, 1);
+ command++;
break;
case '[':
if (command[1] == '[' && opt_depth < MAX_OPT_DEPTH) {
opt_depth++;
command += 2;
} else {
- addstr(&result, "[", 1);
+ addstr(&result, command, 1);
command++;
}
break;
}
command += 2;
} else {
- addstr(&result, "]", 1);
+ addstr(&result, command, 1);
command++;
}
break;
command++;
nextpercent = strchr(command, '%');
if (!nextpercent) {
- errno = EUNBALPER;
+ /* Unterminated %var% */
free(result);
return NULL;
}
varvalue = get_var(command, nextpercent - command, ifd);
if (varvalue) {
+# if ENABLE_FEATURE_IFUPDOWN_IP
+ /* "hwaddress <class> <address>":
+ * unlike ifconfig, ip doesnt want <class>
+ * (usually "ether" keyword). Skip it. */
+ if (strncmp(command, "hwaddress", 9) == 0) {
+ varvalue = skip_whitespace(skip_non_whitespace(varvalue));
+ }
+# endif
addstr(&result, varvalue, strlen(varvalue));
} else {
-#if ENABLE_FEATURE_IFUPDOWN_IP
+# if ENABLE_FEATURE_IFUPDOWN_IP
/* Sigh... Add a special case for 'ip' to convert from
* dotted quad to bit count style netmasks. */
if (strncmp(command, "bnmask", 6) == 0) {
}
}
}
-#endif
+# endif
okay[opt_depth - 1] = 0;
}
}
if (opt_depth > 1) {
- errno = EUNBALBRACK;
+ /* Unbalanced bracket */
free(result);
return NULL;
}
if (!okay[0]) {
- errno = EUNDEFVAR;
+ /* Undefined variable and we aren't in a bracket */
free(result);
return NULL;
}
}
return 1;
}
-#endif
+
+#endif /* FEATURE_IFUPDOWN_IPV4 || FEATURE_IFUPDOWN_IPV6 */
+
#if ENABLE_FEATURE_IFUPDOWN_IPV6
-static int loopback_up6(struct interface_defn_t *ifd, execfn *exec)
+
+static int FAST_FUNC loopback_up6(struct interface_defn_t *ifd, execfn *exec)
{
-#if ENABLE_FEATURE_IFUPDOWN_IP
+# if ENABLE_FEATURE_IFUPDOWN_IP
int result;
result = execute("ip addr add ::1 dev %iface%", ifd, exec);
result += execute("ip link set %iface% up", ifd, exec);
return ((result == 2) ? 2 : 0);
-#else
+# else
return execute("ifconfig %iface% add ::1", ifd, exec);
-#endif
+# endif
}
-static int loopback_down6(struct interface_defn_t *ifd, execfn *exec)
+static int FAST_FUNC loopback_down6(struct interface_defn_t *ifd, execfn *exec)
{
-#if ENABLE_FEATURE_IFUPDOWN_IP
+# if ENABLE_FEATURE_IFUPDOWN_IP
return execute("ip link set %iface% down", ifd, exec);
-#else
+# else
return execute("ifconfig %iface% del ::1", ifd, exec);
-#endif
+# endif
}
-static int static_up6(struct interface_defn_t *ifd, execfn *exec)
+static int FAST_FUNC manual_up_down6(struct interface_defn_t *ifd UNUSED_PARAM, execfn *exec UNUSED_PARAM)
+{
+ return 1;
+}
+
+static int FAST_FUNC static_up6(struct interface_defn_t *ifd, execfn *exec)
{
int result;
-#if ENABLE_FEATURE_IFUPDOWN_IP
+# if ENABLE_FEATURE_IFUPDOWN_IP
result = execute("ip addr add %address%/%netmask% dev %iface%[[ label %label%]]", ifd, exec);
- result += execute("ip link set[[ mtu %mtu%]][[ address %hwaddress%]] %iface% up", ifd, exec);
+ result += execute("ip link set[[ mtu %mtu%]][[ addr %hwaddress%]] %iface% up", ifd, exec);
/* Was: "[[ ip ....%gateway% ]]". Removed extra spaces w/o checking */
- result += execute("[[ip route add ::/0 via %gateway%]]", ifd, exec);
-#else
+ result += execute("[[ip route add ::/0 via %gateway%]][[ prio %metric%]]", ifd, exec);
+# else
result = execute("ifconfig %iface%[[ media %media%]][[ hw %hwaddress%]][[ mtu %mtu%]] up", ifd, exec);
result += execute("ifconfig %iface% add %address%/%netmask%", ifd, exec);
- result += execute("[[route -A inet6 add ::/0 gw %gateway%]]", ifd, exec);
-#endif
+ result += execute("[[route -A inet6 add ::/0 gw %gateway%[[ metric %metric%]]]]", ifd, exec);
+# endif
return ((result == 3) ? 3 : 0);
}
-static int static_down6(struct interface_defn_t *ifd, execfn *exec)
+static int FAST_FUNC static_down6(struct interface_defn_t *ifd, execfn *exec)
{
-#if ENABLE_FEATURE_IFUPDOWN_IP
+# if ENABLE_FEATURE_IFUPDOWN_IP
return execute("ip link set %iface% down", ifd, exec);
-#else
+# else
return execute("ifconfig %iface% down", ifd, exec);
-#endif
+# endif
}
-#if ENABLE_FEATURE_IFUPDOWN_IP
-static int v4tunnel_up(struct interface_defn_t *ifd, execfn *exec)
+# if ENABLE_FEATURE_IFUPDOWN_IP
+static int FAST_FUNC v4tunnel_up(struct interface_defn_t *ifd, execfn *exec)
{
int result;
result = execute("ip tunnel add %iface% mode sit remote "
return ((result == 4) ? 4 : 0);
}
-static int v4tunnel_down(struct interface_defn_t * ifd, execfn * exec)
+static int FAST_FUNC v4tunnel_down(struct interface_defn_t * ifd, execfn * exec)
{
return execute("ip tunnel del %iface%", ifd, exec);
}
-#endif
+# endif
static const struct method_t methods6[] = {
-#if ENABLE_FEATURE_IFUPDOWN_IP
- { "v4tunnel", v4tunnel_up, v4tunnel_down, },
-#endif
- { "static", static_up6, static_down6, },
- { "loopback", loopback_up6, loopback_down6, },
+# if ENABLE_FEATURE_IFUPDOWN_IP
+ { "v4tunnel" , v4tunnel_up , v4tunnel_down , },
+# endif
+ { "static" , static_up6 , static_down6 , },
+ { "manual" , manual_up_down6 , manual_up_down6 , },
+ { "loopback" , loopback_up6 , loopback_down6 , },
};
static const struct address_family_t addr_inet6 = {
ARRAY_SIZE(methods6),
methods6
};
+
#endif /* FEATURE_IFUPDOWN_IPV6 */
+
#if ENABLE_FEATURE_IFUPDOWN_IPV4
-static int loopback_up(struct interface_defn_t *ifd, execfn *exec)
+
+static int FAST_FUNC loopback_up(struct interface_defn_t *ifd, execfn *exec)
{
-#if ENABLE_FEATURE_IFUPDOWN_IP
+# if ENABLE_FEATURE_IFUPDOWN_IP
int result;
result = execute("ip addr add 127.0.0.1/8 dev %iface%", ifd, exec);
result += execute("ip link set %iface% up", ifd, exec);
return ((result == 2) ? 2 : 0);
-#else
+# else
return execute("ifconfig %iface% 127.0.0.1 up", ifd, exec);
-#endif
+# endif
}
-static int loopback_down(struct interface_defn_t *ifd, execfn *exec)
+static int FAST_FUNC loopback_down(struct interface_defn_t *ifd, execfn *exec)
{
-#if ENABLE_FEATURE_IFUPDOWN_IP
+# if ENABLE_FEATURE_IFUPDOWN_IP
int result;
result = execute("ip addr flush dev %iface%", ifd, exec);
result += execute("ip link set %iface% down", ifd, exec);
return ((result == 2) ? 2 : 0);
-#else
+# else
return execute("ifconfig %iface% 127.0.0.1 down", ifd, exec);
-#endif
+# endif
}
-static int static_up(struct interface_defn_t *ifd, execfn *exec)
+static int FAST_FUNC static_up(struct interface_defn_t *ifd, execfn *exec)
{
int result;
-#if ENABLE_FEATURE_IFUPDOWN_IP
+# if ENABLE_FEATURE_IFUPDOWN_IP
result = execute("ip addr add %address%/%bnmask%[[ broadcast %broadcast%]] "
"dev %iface%[[ peer %pointopoint%]][[ label %label%]]", ifd, exec);
- result += execute("ip link set[[ mtu %mtu%]][[ address %hwaddress%]] %iface% up", ifd, exec);
- result += execute("[[ip route add default via %gateway% dev %iface%]]", ifd, exec);
+ result += execute("ip link set[[ mtu %mtu%]][[ addr %hwaddress%]] %iface% up", ifd, exec);
+ result += execute("[[ip route add default via %gateway% dev %iface%[[ prio %metric%]]]]", ifd, exec);
return ((result == 3) ? 3 : 0);
-#else
+# else
/* ifconfig said to set iface up before it processes hw %hwaddress%,
* which then of course fails. Thus we run two separate ifconfig */
result = execute("ifconfig %iface%[[ hw %hwaddress%]][[ media %media%]][[ mtu %mtu%]] up",
result += execute("ifconfig %iface% %address% netmask %netmask%"
"[[ broadcast %broadcast%]][[ pointopoint %pointopoint%]] ",
ifd, exec);
- result += execute("[[route add default gw %gateway% %iface%]]", ifd, exec);
+ result += execute("[[route add default gw %gateway%[[ metric %metric%]] %iface%]]", ifd, exec);
return ((result == 3) ? 3 : 0);
-#endif
+# endif
}
-static int static_down(struct interface_defn_t *ifd, execfn *exec)
+static int FAST_FUNC static_down(struct interface_defn_t *ifd, execfn *exec)
{
int result;
-#if ENABLE_FEATURE_IFUPDOWN_IP
+# if ENABLE_FEATURE_IFUPDOWN_IP
result = execute("ip addr flush dev %iface%", ifd, exec);
result += execute("ip link set %iface% down", ifd, exec);
-#else
- result = execute("[[route del default gw %gateway% %iface%]]", ifd, exec);
+# else
+ /* result = execute("[[route del default gw %gateway% %iface%]]", ifd, exec); */
+ /* Bringing the interface down deletes the routes in itself.
+ Otherwise this fails if we reference 'gateway' when using this from dhcp_down */
+ result = 1;
result += execute("ifconfig %iface% down", ifd, exec);
-#endif
+# endif
return ((result == 2) ? 2 : 0);
}
-#if ENABLE_FEATURE_IFUPDOWN_EXTERNAL_DHCP
-struct dhcp_client_t
-{
+# if ENABLE_FEATURE_IFUPDOWN_EXTERNAL_DHCP
+struct dhcp_client_t {
const char *name;
const char *startcmd;
const char *stopcmd;
static const struct dhcp_client_t ext_dhcp_clients[] = {
{ "dhcpcd",
- "dhcpcd[[ -h %hostname%]][[ -i %vendor%]][[ -I %clientid%]][[ -l %leasetime%]] %iface%",
+ "dhcpcd[[ -h %hostname%]][[ -i %vendor%]][[ -I %client%]][[ -l %leasetime%]] %iface%",
"dhcpcd -k %iface%",
},
{ "dhclient",
"pump -i %iface% -k",
},
{ "udhcpc",
- "udhcpc -R -n -p /var/run/udhcpc.%iface%.pid -i %iface%[[ -H %hostname%]][[ -c %clientid%]][[ -s %script%]]",
+ "udhcpc " UDHCPC_CMD_OPTIONS " -p /var/run/udhcpc.%iface%.pid -i %iface%[[ -H %hostname%]][[ -c %client%]]"
+ "[[ -s %script%]][[ %udhcpc_opts%]]",
"kill `cat /var/run/udhcpc.%iface%.pid` 2>/dev/null",
},
};
-#endif /* ENABLE_FEATURE_IFUPDOWN_EXTERNAL_DHCPC */
+# endif /* FEATURE_IFUPDOWN_EXTERNAL_DHCPC */
-static int dhcp_up(struct interface_defn_t *ifd, execfn *exec)
+# if ENABLE_FEATURE_IFUPDOWN_EXTERNAL_DHCP
+static int FAST_FUNC dhcp_up(struct interface_defn_t *ifd, execfn *exec)
{
-#if ENABLE_FEATURE_IFUPDOWN_EXTERNAL_DHCP
- int i;
-#if ENABLE_FEATURE_IFUPDOWN_IP
+ unsigned i;
+# if ENABLE_FEATURE_IFUPDOWN_IP
/* ip doesn't up iface when it configures it (unlike ifconfig) */
- if (!execute("ip link set %iface% up", ifd, exec))
+ if (!execute("ip link set[[ addr %hwaddress%]] %iface% up", ifd, exec))
return 0;
-#endif
+# else
+ /* needed if we have hwaddress on dhcp iface */
+ if (!execute("ifconfig %iface%[[ hw %hwaddress%]] up", ifd, exec))
+ return 0;
+# endif
for (i = 0; i < ARRAY_SIZE(ext_dhcp_clients); i++) {
if (exists_execable(ext_dhcp_clients[i].name))
return execute(ext_dhcp_clients[i].startcmd, ifd, exec);
}
bb_error_msg("no dhcp clients found");
return 0;
-#elif ENABLE_APP_UDHCPC
-#if ENABLE_FEATURE_IFUPDOWN_IP
+}
+# elif ENABLE_UDHCPC
+static int FAST_FUNC dhcp_up(struct interface_defn_t *ifd, execfn *exec)
+{
+# if ENABLE_FEATURE_IFUPDOWN_IP
/* ip doesn't up iface when it configures it (unlike ifconfig) */
- if (!execute("ip link set %iface% up", ifd, exec))
+ if (!execute("ip link set[[ addr %hwaddress%]] %iface% up", ifd, exec))
return 0;
-#endif
- return execute("udhcpc -R -n -p /var/run/udhcpc.%iface%.pid "
- "-i %iface%[[ -H %hostname%]][[ -c %clientid%]][[ -s %script%]]",
+# else
+ /* needed if we have hwaddress on dhcp iface */
+ if (!execute("ifconfig %iface%[[ hw %hwaddress%]] up", ifd, exec))
+ return 0;
+# endif
+ return execute("udhcpc " UDHCPC_CMD_OPTIONS " -p /var/run/udhcpc.%iface%.pid "
+ "-i %iface%[[ -H %hostname%]][[ -c %client%]][[ -s %script%]][[ %udhcpc_opts%]]",
ifd, exec);
-#else
+}
+# else
+static int FAST_FUNC dhcp_up(struct interface_defn_t *ifd UNUSED_PARAM,
+ execfn *exec UNUSED_PARAM)
+{
return 0; /* no dhcp support */
-#endif
}
+# endif
-static int dhcp_down(struct interface_defn_t *ifd, execfn *exec)
+# if ENABLE_FEATURE_IFUPDOWN_EXTERNAL_DHCP
+static int FAST_FUNC dhcp_down(struct interface_defn_t *ifd, execfn *exec)
{
-#if ENABLE_FEATURE_IFUPDOWN_EXTERNAL_DHCP
- int i;
+ int result = 0;
+ unsigned i;
+
for (i = 0; i < ARRAY_SIZE(ext_dhcp_clients); i++) {
- if (exists_execable(ext_dhcp_clients[i].name))
- return execute(ext_dhcp_clients[i].stopcmd, ifd, exec);
+ if (exists_execable(ext_dhcp_clients[i].name)) {
+ result = execute(ext_dhcp_clients[i].stopcmd, ifd, exec);
+ if (result)
+ break;
+ }
}
- bb_error_msg("no dhcp clients found, using static interface shutdown");
- return static_down(ifd, exec);
-#elif ENABLE_APP_UDHCPC
- return execute("kill "
- "`cat /var/run/udhcpc.%iface%.pid` 2>/dev/null", ifd, exec);
-#else
+
+ if (!result)
+ bb_error_msg("warning: no dhcp clients found and stopped");
+
+ /* Sleep a bit, otherwise static_down tries to bring down interface too soon,
+ and it may come back up because udhcpc is still shutting down */
+ usleep(100000);
+ result += static_down(ifd, exec);
+ return ((result == 3) ? 3 : 0);
+}
+# elif ENABLE_UDHCPC
+static int FAST_FUNC dhcp_down(struct interface_defn_t *ifd, execfn *exec)
+{
+ int result;
+ result = execute(
+ "test -f /var/run/udhcpc.%iface%.pid && "
+ "kill `cat /var/run/udhcpc.%iface%.pid` 2>/dev/null",
+ ifd, exec);
+ /* Also bring the hardware interface down since
+ killing the dhcp client alone doesn't do it.
+ This enables consecutive ifup->ifdown->ifup */
+ /* Sleep a bit, otherwise static_down tries to bring down interface too soon,
+ and it may come back up because udhcpc is still shutting down */
+ usleep(100000);
+ result += static_down(ifd, exec);
+ return ((result == 3) ? 3 : 0);
+}
+# else
+static int FAST_FUNC dhcp_down(struct interface_defn_t *ifd UNUSED_PARAM,
+ execfn *exec UNUSED_PARAM)
+{
return 0; /* no dhcp support */
-#endif
}
+# endif
-static int manual_up_down(struct interface_defn_t *ifd, execfn *exec)
+static int FAST_FUNC manual_up_down(struct interface_defn_t *ifd UNUSED_PARAM, execfn *exec UNUSED_PARAM)
{
return 1;
}
-static int bootp_up(struct interface_defn_t *ifd, execfn *exec)
+static int FAST_FUNC bootp_up(struct interface_defn_t *ifd, execfn *exec)
{
return execute("bootpc[[ --bootfile %bootfile%]] --dev %iface%"
"[[ --server %server%]][[ --hwaddr %hwaddr%]]"
" --returniffail --serverbcast", ifd, exec);
}
-static int ppp_up(struct interface_defn_t *ifd, execfn *exec)
+static int FAST_FUNC ppp_up(struct interface_defn_t *ifd, execfn *exec)
{
return execute("pon[[ %provider%]]", ifd, exec);
}
-static int ppp_down(struct interface_defn_t *ifd, execfn *exec)
+static int FAST_FUNC ppp_down(struct interface_defn_t *ifd, execfn *exec)
{
return execute("poff[[ %provider%]]", ifd, exec);
}
-static int wvdial_up(struct interface_defn_t *ifd, execfn *exec)
+static int FAST_FUNC wvdial_up(struct interface_defn_t *ifd, execfn *exec)
{
return execute("start-stop-daemon --start -x wvdial "
"-p /var/run/wvdial.%iface% -b -m --[[ %provider%]]", ifd, exec);
}
-static int wvdial_down(struct interface_defn_t *ifd, execfn *exec)
+static int FAST_FUNC wvdial_down(struct interface_defn_t *ifd, execfn *exec)
{
return execute("start-stop-daemon --stop -x wvdial "
"-p /var/run/wvdial.%iface% -s 2", ifd, exec);
}
static const struct method_t methods[] = {
- { "manual", manual_up_down, manual_up_down, },
- { "wvdial", wvdial_up, wvdial_down, },
- { "ppp", ppp_up, ppp_down, },
- { "static", static_up, static_down, },
- { "bootp", bootp_up, static_down, },
- { "dhcp", dhcp_up, dhcp_down, },
- { "loopback", loopback_up, loopback_down, },
+ { "manual" , manual_up_down, manual_up_down, },
+ { "wvdial" , wvdial_up , wvdial_down , },
+ { "ppp" , ppp_up , ppp_down , },
+ { "static" , static_up , static_down , },
+ { "bootp" , bootp_up , static_down , },
+ { "dhcp" , dhcp_up , dhcp_down , },
+ { "loopback", loopback_up , loopback_down , },
};
static const struct address_family_t addr_inet = {
methods
};
-#endif /* if ENABLE_FEATURE_IFUPDOWN_IPV4 */
+#endif /* FEATURE_IFUPDOWN_IPV4 */
+
+/* Returns pointer to the next word, or NULL.
+ * In 1st case, advances *buf to the word after this one.
+ */
static char *next_word(char **buf)
{
- unsigned short length;
+ unsigned length;
char *word;
- if (!buf || !*buf || !**buf) {
- return NULL;
- }
-
/* Skip over leading whitespace */
word = skip_whitespace(*buf);
- /* Skip over comments */
- if (*word == '#') {
+ /* Stop on EOL */
+ if (*word == '\0')
return NULL;
- }
- /* Find the length of this word */
+ /* Find the length of this word (can't be 0) */
length = strcspn(word, " \t\n");
- if (length == 0) {
- return NULL;
- }
- *buf = word + length;
- /*DBU:[dave@cray.com] if we are already at EOL dont't increment beyond it */
- if (**buf) {
- **buf = '\0';
- (*buf)++;
- }
+
+ /* Unless we are already at NUL, store NUL and advance */
+ if (word[length] != '\0')
+ word[length++] = '\0';
+
+ *buf = skip_whitespace(word + length);
return word;
}
if (!name)
return NULL;
-
+ /* TODO: use index_in_str_array() */
for (i = 0; i < af->n_methods; i++) {
if (strcmp(af->method[i].name, name) == 0) {
return &af->method[i];
return NULL;
}
-static const llist_t *find_list_string(const llist_t *list, const char *string)
-{
- if (string == NULL)
- return NULL;
-
- while (list) {
- if (strcmp(list->data, string) == 0) {
- return list;
- }
- list = list->link;
- }
- return NULL;
-}
-
-static struct interfaces_file_t *read_interfaces(const char *filename)
+static struct interfaces_file_t *read_interfaces(const char *filename, struct interfaces_file_t *defn)
{
+ /* Let's try to be compatible.
+ *
+ * "man 5 interfaces" says:
+ * Lines starting with "#" are ignored. Note that end-of-line
+ * comments are NOT supported, comments must be on a line of their own.
+ * A line may be extended across multiple lines by making
+ * the last character a backslash.
+ *
+ * Seen elsewhere in example config file:
+ * A first non-blank "#" character makes the rest of the line
+ * be ignored. Blank lines are ignored. Lines may be indented freely.
+ * A "\" character at the very end of the line indicates the next line
+ * should be treated as a continuation of the current one.
+ *
+ * Lines beginning with "source" are used to include stanzas from
+ * other files, so configuration can be split into many files.
+ * The word "source" is followed by the path of file to be sourced.
+ */
#if ENABLE_FEATURE_IFUPDOWN_MAPPING
struct mapping_defn_t *currmap = NULL;
#endif
struct interface_defn_t *currif = NULL;
- struct interfaces_file_t *defn;
FILE *f;
- char *firstword;
char *buf;
-
+ char *first_word;
+ char *rest_of_line;
enum { NONE, IFACE, MAPPING } currently_processing = NONE;
- defn = xzalloc(sizeof(struct interfaces_file_t));
-
- f = xfopen(filename, "r");
+ if (!defn)
+ defn = xzalloc(sizeof(*defn));
- while ((buf = xmalloc_getline(f)) != NULL) {
- char *buf_ptr = buf;
+ debug_noise("reading %s file:\n", filename);
+ f = xfopen_for_read(filename);
- firstword = next_word(&buf_ptr);
- if (firstword == NULL) {
+ while ((buf = xmalloc_fgetline(f)) != NULL) {
+#if ENABLE_DESKTOP
+ /* Trailing "\" concatenates lines */
+ char *p;
+ while ((p = last_char_is(buf, '\\')) != NULL) {
+ *p = '\0';
+ rest_of_line = xmalloc_fgetline(f);
+ if (!rest_of_line)
+ break;
+ p = xasprintf("%s%s", buf, rest_of_line);
+ free(buf);
+ free(rest_of_line);
+ buf = p;
+ }
+#endif
+ rest_of_line = buf;
+ first_word = next_word(&rest_of_line);
+ if (!first_word || *first_word == '#') {
free(buf);
- continue; /* blank line */
+ continue; /* blank/comment line */
}
- if (strcmp(firstword, "mapping") == 0) {
+ if (strcmp(first_word, "mapping") == 0) {
#if ENABLE_FEATURE_IFUPDOWN_MAPPING
- currmap = xzalloc(sizeof(struct mapping_defn_t));
+ currmap = xzalloc(sizeof(*currmap));
- while ((firstword = next_word(&buf_ptr)) != NULL) {
- if (currmap->max_matches == currmap->n_matches) {
- currmap->max_matches = currmap->max_matches * 2 + 1;
- currmap->match = xrealloc(currmap->match, sizeof(currmap->match) * currmap->max_matches);
- }
-
- currmap->match[currmap->n_matches++] = xstrdup(firstword);
+ while ((first_word = next_word(&rest_of_line)) != NULL) {
+ currmap->match = xrealloc_vector(currmap->match, 4, currmap->n_matches);
+ currmap->match[currmap->n_matches++] = xstrdup(first_word);
}
- currmap->max_mappings = 0;
- currmap->n_mappings = 0;
- currmap->mapping = NULL;
- currmap->script = NULL;
+ /*currmap->n_mappings = 0;*/
+ /*currmap->mapping = NULL;*/
+ /*currmap->script = NULL;*/
{
struct mapping_defn_t **where = &defn->mappings;
while (*where != NULL) {
where = &(*where)->next;
}
*where = currmap;
- currmap->next = NULL;
+ /*currmap->next = NULL;*/
}
debug_noise("Added mapping\n");
#endif
currently_processing = MAPPING;
- } else if (strcmp(firstword, "iface") == 0) {
+ } else if (strcmp(first_word, "iface") == 0) {
static const struct address_family_t *const addr_fams[] = {
#if ENABLE_FEATURE_IFUPDOWN_IPV4
&addr_inet,
#endif
NULL
};
-
char *iface_name;
char *address_family_name;
char *method_name;
llist_t *iface_list;
- currif = xzalloc(sizeof(struct interface_defn_t));
- iface_name = next_word(&buf_ptr);
- address_family_name = next_word(&buf_ptr);
- method_name = next_word(&buf_ptr);
+ currif = xzalloc(sizeof(*currif));
+ iface_name = next_word(&rest_of_line);
+ address_family_name = next_word(&rest_of_line);
+ method_name = next_word(&rest_of_line);
- if (buf_ptr == NULL) {
- bb_error_msg("too few parameters for line \"%s\"", buf);
- return NULL;
- }
+ if (method_name == NULL)
+ bb_error_msg_and_die("too few parameters for line \"%s\"", buf);
/* ship any trailing whitespace */
- buf_ptr = skip_whitespace(buf_ptr);
+ rest_of_line = skip_whitespace(rest_of_line);
- if (buf_ptr[0] != '\0') {
- bb_error_msg("too many parameters \"%s\"", buf);
- return NULL;
- }
+ if (rest_of_line[0] != '\0' /* && rest_of_line[0] != '#' */)
+ bb_error_msg_and_die("too many parameters \"%s\"", buf);
currif->iface = xstrdup(iface_name);
currif->address_family = get_address_family(addr_fams, address_family_name);
- if (!currif->address_family) {
- bb_error_msg("unknown address type \"%s\"", address_family_name);
- return NULL;
- }
+ if (!currif->address_family)
+ bb_error_msg_and_die("unknown address type \"%s\"", address_family_name);
currif->method = get_method(currif->address_family, method_name);
- if (!currif->method) {
- bb_error_msg("unknown method \"%s\"", method_name);
- return NULL;
- }
+ if (!currif->method)
+ bb_error_msg_and_die("unknown method \"%s\"", method_name);
for (iface_list = defn->ifaces; iface_list; iface_list = iface_list->link) {
struct interface_defn_t *tmp = (struct interface_defn_t *) iface_list->data;
- if ((strcmp(tmp->iface, currif->iface) == 0) &&
- (tmp->address_family == currif->address_family)) {
- bb_error_msg("duplicate interface \"%s\"", tmp->iface);
- return NULL;
+ if ((strcmp(tmp->iface, currif->iface) == 0)
+ && (tmp->address_family == currif->address_family)
+ ) {
+ bb_error_msg_and_die("duplicate interface \"%s\"", tmp->iface);
}
}
llist_add_to_end(&(defn->ifaces), (char*)currif);
debug_noise("iface %s %s %s\n", currif->iface, address_family_name, method_name);
currently_processing = IFACE;
- } else if (strcmp(firstword, "auto") == 0) {
- while ((firstword = next_word(&buf_ptr)) != NULL) {
+ } else if (strcmp(first_word, "auto") == 0) {
+ while ((first_word = next_word(&rest_of_line)) != NULL) {
/* Check the interface isnt already listed */
- if (find_list_string(defn->autointerfaces, firstword)) {
+ if (llist_find_str(defn->autointerfaces, first_word)) {
bb_perror_msg_and_die("interface declared auto twice \"%s\"", buf);
}
/* Add the interface to the list */
- llist_add_to_end(&(defn->autointerfaces), xstrdup(firstword));
- debug_noise("\nauto %s\n", firstword);
+ llist_add_to_end(&(defn->autointerfaces), xstrdup(first_word));
+ debug_noise("\nauto %s\n", first_word);
}
currently_processing = NONE;
+ } else if (strcmp(first_word, "source") == 0) {
+ read_interfaces(next_word(&rest_of_line), defn);
} else {
switch (currently_processing) {
case IFACE:
- {
- int i;
+ if (rest_of_line[0] == '\0')
+ bb_error_msg_and_die("option with empty value \"%s\"", buf);
- if (strlen(buf_ptr) == 0) {
- bb_error_msg("option with empty value \"%s\"", buf);
- return NULL;
- }
+ if (strcmp(first_word, "post-up") == 0)
+ first_word += 5; /* "up" */
+ else if (strcmp(first_word, "pre-down") == 0)
+ first_word += 4; /* "down" */
- if (strcmp(firstword, "up") != 0
- && strcmp(firstword, "down") != 0
- && strcmp(firstword, "pre-up") != 0
- && strcmp(firstword, "post-down") != 0) {
- for (i = 0; i < currif->n_options; i++) {
- if (strcmp(currif->option[i].name, firstword) == 0) {
- bb_error_msg("duplicate option \"%s\"", buf);
- return NULL;
- }
- }
+ /* If not one of "up", "down",... words... */
+ if (index_in_strings(keywords_up_down, first_word) < 0) {
+ int i;
+ for (i = 0; i < currif->n_options; i++) {
+ if (strcmp(currif->option[i].name, first_word) == 0)
+ bb_error_msg_and_die("duplicate option \"%s\"", buf);
}
}
- if (currif->n_options >= currif->max_options) {
- struct variable_t *opt;
-
- currif->max_options = currif->max_options + 10;
- opt = xrealloc(currif->option, sizeof(*opt) * currif->max_options);
- currif->option = opt;
- }
- currif->option[currif->n_options].name = xstrdup(firstword);
- currif->option[currif->n_options].value = xstrdup(buf_ptr);
- if (!currif->option[currif->n_options].name) {
- perror(filename);
- return NULL;
- }
- if (!currif->option[currif->n_options].value) {
- perror(filename);
- return NULL;
- }
- debug_noise("\t%s=%s\n", currif->option[currif->n_options].name,
- currif->option[currif->n_options].value);
+ debug_noise("\t%s=%s\n", first_word, rest_of_line);
+ currif->option = xrealloc_vector(currif->option, 4, currif->n_options);
+ currif->option[currif->n_options].name = xstrdup(first_word);
+ currif->option[currif->n_options].value = xstrdup(rest_of_line);
currif->n_options++;
break;
case MAPPING:
#if ENABLE_FEATURE_IFUPDOWN_MAPPING
- if (strcmp(firstword, "script") == 0) {
- if (currmap->script != NULL) {
- bb_error_msg("duplicate script in mapping \"%s\"", buf);
- return NULL;
- } else {
- currmap->script = xstrdup(next_word(&buf_ptr));
- }
- } else if (strcmp(firstword, "map") == 0) {
- if (currmap->max_mappings == currmap->n_mappings) {
- currmap->max_mappings = currmap->max_mappings * 2 + 1;
- currmap->mapping = xrealloc(currmap->mapping, sizeof(char *) * currmap->max_mappings);
- }
- currmap->mapping[currmap->n_mappings] = xstrdup(next_word(&buf_ptr));
+ if (strcmp(first_word, "script") == 0) {
+ if (currmap->script != NULL)
+ bb_error_msg_and_die("duplicate script in mapping \"%s\"", buf);
+ currmap->script = xstrdup(next_word(&rest_of_line));
+ } else if (strcmp(first_word, "map") == 0) {
+ currmap->mapping = xrealloc_vector(currmap->mapping, 2, currmap->n_mappings);
+ currmap->mapping[currmap->n_mappings] = xstrdup(next_word(&rest_of_line));
currmap->n_mappings++;
} else {
- bb_error_msg("misplaced option \"%s\"", buf);
- return NULL;
+ bb_error_msg_and_die("misplaced option \"%s\"", buf);
}
#endif
break;
case NONE:
default:
- bb_error_msg("misplaced option \"%s\"", buf);
- return NULL;
+ bb_error_msg_and_die("misplaced option \"%s\"", buf);
}
}
free(buf);
- }
+ } /* while (fgets) */
+
if (ferror(f) != 0) {
/* ferror does NOT set errno! */
bb_error_msg_and_die("%s: I/O error", filename);
}
fclose(f);
+ debug_noise("\ndone reading %s\n\n", filename);
return defn;
}
static char *setlocalenv(const char *format, const char *name, const char *value)
{
char *result;
- char *here;
- char *there;
+ char *dst;
+ char *src;
+ char c;
result = xasprintf(format, name, value);
- for (here = there = result; *there != '=' && *there; there++) {
- if (*there == '-')
- *there = '_';
- if (isalpha(*there))
- *there = toupper(*there);
-
- if (isalnum(*there) || *there == '_') {
- *here = *there;
- here++;
- }
+ for (dst = src = result; (c = *src) != '=' && c; src++) {
+ if (c == '-')
+ c = '_';
+ if (c >= 'a' && c <= 'z')
+ c -= ('a' - 'A');
+ if (isalnum(c) || c == '_')
+ *dst++ = c;
}
- memmove(here, there, strlen(there) + 1);
+ overlapping_strcpy(dst, src);
return result;
}
-static void set_environ(struct interface_defn_t *iface, const char *mode)
+static void set_environ(struct interface_defn_t *iface, const char *mode, const char *opt)
{
- char **environend;
int i;
- const int n_env_entries = iface->n_options + 5;
- char **ppch;
+ char **pp;
- if (my_environ != NULL) {
- for (ppch = my_environ; *ppch; ppch++) {
- free(*ppch);
- *ppch = NULL;
+ if (G.my_environ != NULL) {
+ for (pp = G.my_environ; *pp; pp++) {
+ free(*pp);
}
- free(my_environ);
+ free(G.my_environ);
}
- my_environ = xzalloc(sizeof(char *) * (n_env_entries + 1 /* for final NULL */ ));
- environend = my_environ;
+
+ /* note: last element will stay NULL: */
+ G.my_environ = xzalloc(sizeof(char *) * (iface->n_options + 7));
+ pp = G.my_environ;
for (i = 0; i < iface->n_options; i++) {
- if (strcmp(iface->option[i].name, "up") == 0
- || strcmp(iface->option[i].name, "down") == 0
- || strcmp(iface->option[i].name, "pre-up") == 0
- || strcmp(iface->option[i].name, "post-down") == 0
- ) {
+ if (index_in_strings(keywords_up_down, iface->option[i].name) >= 0) {
continue;
}
- *(environend++) = setlocalenv("IF_%s=%s", iface->option[i].name, iface->option[i].value);
+ *pp++ = setlocalenv("IF_%s=%s", iface->option[i].name, iface->option[i].value);
}
- *(environend++) = setlocalenv("%s=%s", "IFACE", iface->iface);
- *(environend++) = setlocalenv("%s=%s", "ADDRFAM", iface->address_family->name);
- *(environend++) = setlocalenv("%s=%s", "METHOD", iface->method->name);
- *(environend++) = setlocalenv("%s=%s", "MODE", mode);
- *(environend++) = setlocalenv("%s=%s", "PATH", startup_PATH);
+ *pp++ = setlocalenv("%s=%s", "IFACE", iface->iface);
+ *pp++ = setlocalenv("%s=%s", "ADDRFAM", iface->address_family->name);
+ *pp++ = setlocalenv("%s=%s", "METHOD", iface->method->name);
+ *pp++ = setlocalenv("%s=%s", "MODE", mode);
+ *pp++ = setlocalenv("%s=%s", "PHASE", opt);
+ if (G.startup_PATH)
+ *pp++ = setlocalenv("%s=%s", "PATH", G.startup_PATH);
}
static int doit(char *str)
pid_t child;
int status;
- fflush(NULL);
- child = fork();
- switch (child) {
- case -1: /* failure */
+ fflush_all();
+ child = vfork();
+ if (child < 0) /* failure */
return 0;
- case 0: /* child */
- execle(DEFAULT_SHELL, DEFAULT_SHELL, "-c", str, NULL, my_environ);
- exit(127);
+ if (child == 0) { /* child */
+ execle(G.shell, G.shell, "-c", str, (char *) NULL, G.my_environ);
+ _exit(127);
}
- waitpid(child, &status, 0);
+ safe_waitpid(child, &status, 0);
if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
return 0;
}
static int iface_up(struct interface_defn_t *iface)
{
if (!iface->method->up(iface, check)) return -1;
- set_environ(iface, "start");
+ set_environ(iface, "start", "pre-up");
if (!execute_all(iface, "pre-up")) return 0;
if (!iface->method->up(iface, doit)) return 0;
+ set_environ(iface, "start", "post-up");
if (!execute_all(iface, "up")) return 0;
return 1;
}
static int iface_down(struct interface_defn_t *iface)
{
- if (!iface->method->down(iface,check)) return -1;
- set_environ(iface, "stop");
+ if (!iface->method->down(iface, check)) return -1;
+ set_environ(iface, "stop", "pre-down");
if (!execute_all(iface, "down")) return 0;
if (!iface->method->down(iface, doit)) return 0;
+ set_environ(iface, "stop", "post-down");
if (!execute_all(iface, "post-down")) return 0;
return 1;
}
#if ENABLE_FEATURE_IFUPDOWN_MAPPING
-static int popen2(FILE **in, FILE **out, char *command, ...)
+static int popen2(FILE **in, FILE **out, char *command, char *param)
{
- va_list ap;
- char *argv[11] = { command };
- int argc;
- int infd[2], outfd[2];
+ char *argv[3] = { command, param, NULL };
+ struct fd_pair infd, outfd;
pid_t pid;
- argc = 1;
- va_start(ap, command);
- while ((argc < 10) && (argv[argc] = va_arg(ap, char *))) {
- argc++;
- }
- argv[argc] = NULL; /* make sure */
- va_end(ap);
+ xpiped_pair(infd);
+ xpiped_pair(outfd);
- if (pipe(infd) != 0) {
- return 0;
- }
+ fflush_all();
+ pid = xvfork();
- if (pipe(outfd) != 0) {
- close(infd[0]);
- close(infd[1]);
- return 0;
+ if (pid == 0) {
+ /* Child */
+ /* NB: close _first_, then move fds! */
+ close(infd.wr);
+ close(outfd.rd);
+ xmove_fd(infd.rd, 0);
+ xmove_fd(outfd.wr, 1);
+ BB_EXECVP_or_die(argv);
}
-
- fflush(NULL);
- switch (pid = fork()) {
- case -1: /* failure */
- close(infd[0]);
- close(infd[1]);
- close(outfd[0]);
- close(outfd[1]);
- return 0;
- case 0: /* child */
- dup2(infd[0], 0);
- dup2(outfd[1], 1);
- close(infd[0]);
- close(infd[1]);
- close(outfd[0]);
- close(outfd[1]);
- BB_EXECVP(command, argv);
- exit(127);
- default: /* parent */
- *in = fdopen(infd[1], "w");
- *out = fdopen(outfd[0], "r");
- close(infd[0]);
- close(outfd[1]);
- return pid;
- }
- /* unreached */
+ /* parent */
+ close(infd.rd);
+ close(outfd.wr);
+ *in = xfdopen_for_write(infd.wr);
+ *out = xfdopen_for_read(outfd.rd);
+ return pid;
}
-static char *run_mapping(char *physical, struct mapping_defn_t * map)
+static char *run_mapping(char *physical, struct mapping_defn_t *map)
{
FILE *in, *out;
int i, status;
char *logical = xstrdup(physical);
- /* Run the mapping script. */
- pid = popen2(&in, &out, map->script, physical, NULL);
-
- /* popen2() returns 0 on failure. */
- if (pid == 0)
- return logical;
+ /* Run the mapping script. Never fails. */
+ pid = popen2(&in, &out, map->script, physical);
/* Write mappings to stdin of mapping script. */
for (i = 0; i < map->n_mappings; i++) {
fprintf(in, "%s\n", map->mapping[i]);
}
fclose(in);
- waitpid(pid, &status, 0);
+ safe_waitpid(pid, &status, 0);
if (WIFEXITED(status) && WEXITSTATUS(status) == 0) {
/* If the mapping script exited successfully, try to
* grab a line of output and use that as the name of the
* logical interface. */
- char *new_logical = xmalloc(MAX_INTERFACE_LENGTH);
+ char *new_logical = xmalloc_fgetline(out);
- if (fgets(new_logical, MAX_INTERFACE_LENGTH, out)) {
+ if (new_logical) {
/* If we are able to read a line of output from the script,
* remove any trailing whitespace and use this value
* as the name of the logical interface. */
free(logical);
logical = new_logical;
- } else {
- /* If we are UNABLE to read a line of output, discard our
- * freshly allocated memory. */
- free(new_logical);
}
}
static llist_t *find_iface_state(llist_t *state_list, const char *iface)
{
- unsigned short iface_len = strlen(iface);
+ unsigned iface_len = strlen(iface);
llist_t *search = state_list;
while (search) {
if ((strncmp(search->data, iface, iface_len) == 0)
- && (search->data[iface_len] == '=')) {
+ && (search->data[iface_len] == '=')
+ ) {
return search;
}
search = search->link;
static llist_t *read_iface_state(void)
{
llist_t *state_list = NULL;
- FILE *state_fp = fopen(CONFIG_IFUPDOWN_IFSTATE_PATH, "r");
+ FILE *state_fp = fopen_for_read(CONFIG_IFUPDOWN_IFSTATE_PATH);
if (state_fp) {
char *start, *end_ptr;
}
-int ifupdown_main(int argc, char **argv);
-int ifupdown_main(int argc, char **argv)
+int ifupdown_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int ifupdown_main(int argc UNUSED_PARAM, char **argv)
{
- int (*cmds)(struct interface_defn_t *) = NULL;
+ int (*cmds)(struct interface_defn_t *);
struct interfaces_file_t *defn;
llist_t *target_list = NULL;
const char *interfaces = "/etc/network/interfaces";
bool any_failures = 0;
+ INIT_G();
+
+ G.startup_PATH = getenv("PATH");
+ G.shell = xstrdup(get_shell_name());
+
cmds = iface_down;
if (applet_name[2] == 'u') {
/* ifup command */
cmds = iface_up;
}
- getopt32(argc, argv, OPTION_STR, &interfaces);
- if (argc - optind > 0) {
+ getopt32(argv, OPTION_STR, &interfaces);
+ argv += optind;
+ if (argv[0]) {
if (DO_ALL) bb_show_usage();
} else {
if (!DO_ALL) bb_show_usage();
}
- debug_noise("reading %s file:\n", interfaces);
- defn = read_interfaces(interfaces);
- debug_noise("\ndone reading %s\n\n", interfaces);
-
- if (!defn) {
- return EXIT_FAILURE;
- }
-
- startup_PATH = getenv("PATH");
- if (!startup_PATH) startup_PATH = "";
+ defn = read_interfaces(interfaces, NULL);
/* Create a list of interfaces to work on */
if (DO_ALL) {
target_list = defn->autointerfaces;
} else {
- llist_add_to_end(&target_list, argv[optind]);
+ llist_add_to_end(&target_list, argv[0]);
}
/* Update the interfaces */
char *liface;
char *pch;
bool okay = 0;
- unsigned cmds_ret;
+ int cmds_ret;
iface = xstrdup(target_list->data);
target_list = target_list->link;
/* ifup */
if (iface_state) {
bb_error_msg("interface %s already configured", iface);
- continue;
+ goto next;
}
} else {
/* ifdown */
if (!iface_state) {
bb_error_msg("interface %s not configured", iface);
- continue;
+ goto next;
}
}
llist_free(state_list, free);
iface_list = iface_list->link;
}
if (VERBOSE) {
- puts("");
+ bb_putchar('\n');
}
if (!okay && !FORCE) {
llist_t *state_list = read_iface_state();
llist_t *iface_state = find_iface_state(state_list, iface);
- if (cmds == iface_up) {
- char * const newiface = xasprintf("%s=%s", iface, liface);
- if (iface_state == NULL) {
+ if (cmds == iface_up && !any_failures) {
+ char *newiface = xasprintf("%s=%s", iface, liface);
+ if (!iface_state) {
llist_add_to_end(&state_list, newiface);
} else {
free(iface_state->data);
}
/* Actually write the new state */
- state_fp = xfopen(CONFIG_IFUPDOWN_IFSTATE_PATH, "w");
+ state_fp = xfopen_for_write(CONFIG_IFUPDOWN_IFSTATE_PATH);
state = state_list;
while (state) {
if (state->data) {
fclose(state_fp);
llist_free(state_list, free);
}
+ next:
+ free(iface);
+ free(liface);
}
return any_failures;