X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=networking%2Fifupdown.c;h=78baa66905bda35389b8c562fc2106e254ee589b;hb=11d0096516c0d5395729caba5dfd940a10a6e20c;hp=040bbe38965cbee39050ac3a3df736aae0475d5b;hpb=1caca34aa67b2f267d0049d17e5430ca9c58ac3f;p=oweals%2Fbusybox.git

diff --git a/networking/ifupdown.c b/networking/ifupdown.c
index 040bbe389..78baa6690 100644
--- a/networking/ifupdown.c
+++ b/networking/ifupdown.c
@@ -1,7 +1,7 @@
 /* vi: set sw=4 ts=4: */
 /*
- *  ifupdown for busybox
- *  Copyright (c) 2002 Glenn McGrath <bug1@iinet.net.au>
+ *  ifup/ifdown for busybox
+ *  Copyright (c) 2002 Glenn McGrath
  *  Copyright (c) 2003-2004 Erik Andersen <andersen@codepoet.org>
  *
  *  Based on ifupdown v 0.6.4 by Anthony Towns
@@ -14,24 +14,145 @@
  *  (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>
+//config:config IFUP
+//config:	bool "ifup"
+//config:	default y
+//config:	help
+//config:	  Activate the specified interfaces. This applet makes use
+//config:	  of either "ifconfig" and "route" or the "ip" command to actually
+//config:	  configure network interfaces. Therefore, you will probably also want
+//config:	  to enable either IFCONFIG and ROUTE, or enable
+//config:	  FEATURE_IFUPDOWN_IP and the various IP options. Of
+//config:	  course you could use non-busybox versions of these programs, so
+//config:	  against my better judgement (since this will surely result in plenty
+//config:	  of support questions on the mailing list), I do not force you to
+//config:	  enable these additional options. It is up to you to supply either
+//config:	  "ifconfig", "route" and "run-parts" or the "ip" command, either
+//config:	  via busybox or via standalone utilities.
+//config:
+//config:config IFDOWN
+//config:	bool "ifdown"
+//config:	default y
+//config:	help
+//config:	  Deactivate the specified interfaces.
+//config:
+//config:config IFUPDOWN_IFSTATE_PATH
+//config:	string "Absolute path to ifstate file"
+//config:	default "/var/run/ifstate"
+//config:	depends on IFUP || IFDOWN
+//config:	help
+//config:	  ifupdown keeps state information in a file called ifstate.
+//config:	  Typically it is located in /var/run/ifstate, however
+//config:	  some distributions tend to put it in other places
+//config:	  (debian, for example, uses /etc/network/run/ifstate).
+//config:	  This config option defines location of ifstate.
+//config:
+//config:config FEATURE_IFUPDOWN_IP
+//config:	bool "Use ip tool (else ifconfig/route is used)"
+//config:	default y
+//config:	depends on IFUP || IFDOWN
+//config:	help
+//config:	  Use the iproute "ip" command to implement "ifup" and "ifdown", rather
+//config:	  than the default of using the older "ifconfig" and "route" utilities.
+//config:
+//config:	  If Y: you must install either the full-blown iproute2 package
+//config:	  or enable "ip" applet in Busybox, or the "ifup" and "ifdown" applets
+//config:	  will not work.
+//config:
+//config:	  If N: you must install either the full-blown ifconfig and route
+//config:	  utilities, or enable these applets in Busybox.
+//config:
+//config:config FEATURE_IFUPDOWN_IPV4
+//config:	bool "Support IPv4"
+//config:	default y
+//config:	depends on IFUP || IFDOWN
+//config:	help
+//config:	  If you want ifup/ifdown to talk IPv4, leave this on.
+//config:
+//config:config FEATURE_IFUPDOWN_IPV6
+//config:	bool "Support IPv6"
+//config:	default y
+//config:	depends on (IFUP || IFDOWN) && FEATURE_IPV6
+//config:	help
+//config:	  If you need support for IPv6, turn this option on.
+//config:
+//UNUSED:
+////////:config FEATURE_IFUPDOWN_IPX
+////////:	bool "Support IPX"
+////////:	default y
+////////:	depends on IFUP || IFDOWN
+////////:	help
+////////:	  If this option is selected you can use busybox to work with IPX
+////////:	  networks.
+//config:
+//config:config FEATURE_IFUPDOWN_MAPPING
+//config:	bool "Enable mapping support"
+//config:	default y
+//config:	depends on IFUP || IFDOWN
+//config:	help
+//config:	  This enables support for the "mapping" stanza, unless you have
+//config:	  a weird network setup you don't need it.
+//config:
+//config:config FEATURE_IFUPDOWN_EXTERNAL_DHCP
+//config:	bool "Support external DHCP clients"
+//config:	default n
+//config:	depends on IFUP || IFDOWN
+//config:	help
+//config:	  This enables support for the external dhcp clients. Clients are
+//config:	  tried in the following order: dhcpcd, dhclient, pump and udhcpc.
+//config:	  Otherwise, if udhcpc applet is enabled, it is used.
+//config:	  Otherwise, ifup/ifdown will have no support for DHCP.
+
+//applet:IF_IFUP(APPLET_ODDNAME(ifup, ifupdown, BB_DIR_SBIN, BB_SUID_DROP, ifup))
+//applet:IF_IFDOWN(APPLET_ODDNAME(ifdown, ifupdown, BB_DIR_SBIN, BB_SUID_DROP, ifdown))
+
+//kbuild:lib-$(CONFIG_IFUP) += ifupdown.o
+//kbuild:lib-$(CONFIG_IFDOWN) += ifupdown.o
+
+//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	Configure all interfaces"
+//usage:     "\n	-i FILE	Use FILE instead of /etc/network/interfaces"
+//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 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	Deconfigure all interfaces"
+//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 deconfiguration"
 
 #include "libbb.h"
+#include "common_bufsiz.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 IFSTATE_FILE_PATH  CONFIG_IFUPDOWN_IFSTATE_PATH
+
 #define debug_noise(args...) /*fprintf(stderr, args)*/
 
 /* Forward declaration */
@@ -41,8 +162,8 @@ typedef int execfn(char *command);
 
 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 {
@@ -60,7 +181,6 @@ struct mapping_defn_t {
 
 	char *script;
 
-	int max_mappings;
 	int n_mappings;
 	char **mapping;
 };
@@ -75,7 +195,6 @@ struct interface_defn_t {
 	const struct method_t *method;
 
 	char *iface;
-	int max_options;
 	int n_options;
 	struct variable_t *option;
 };
@@ -86,23 +205,38 @@ struct interfaces_file_t {
 	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 { setup_common_bufsiz(); } 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
 
@@ -125,7 +259,7 @@ static int strncmpz(const char *l, const char *r, size_t llen)
 	int i = strncmp(l, r, llen);
 
 	if (i == 0)
-		return -r[llen];
+		return - (unsigned char)r[llen];
 	return i;
 }
 
@@ -134,14 +268,17 @@ static char *get_var(const char *id, size_t idlen, struct interface_defn_t *ifd)
 	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;
@@ -154,7 +291,7 @@ static char *get_var(const char *id, size_t idlen, struct interface_defn_t *ifd)
 	return NULL;
 }
 
-#if ENABLE_FEATURE_IFUPDOWN_IP
+# if ENABLE_FEATURE_IFUPDOWN_IP
 static int count_netmask_bits(const char *dotted_quad)
 {
 //	int result;
@@ -185,12 +322,12 @@ static int count_netmask_bits(const char *dotted_quad)
 	}
 	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;
 
@@ -201,13 +338,10 @@ static char *parse(const char *command, struct interface_defn_t *ifd)
 			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) {
@@ -216,7 +350,7 @@ static char *parse(const char *command, struct interface_defn_t *ifd)
 				opt_depth++;
 				command += 2;
 			} else {
-				addstr(&result, "[", 1);
+				addstr(&result, command, 1);
 				command++;
 			}
 			break;
@@ -228,7 +362,7 @@ static char *parse(const char *command, struct interface_defn_t *ifd)
 				}
 				command += 2;
 			} else {
-				addstr(&result, "]", 1);
+				addstr(&result, command, 1);
 				command++;
 			}
 			break;
@@ -240,7 +374,7 @@ static char *parse(const char *command, struct interface_defn_t *ifd)
 				command++;
 				nextpercent = strchr(command, '%');
 				if (!nextpercent) {
-					errno = EUNBALPER;
+					/* Unterminated %var% */
 					free(result);
 					return NULL;
 				}
@@ -248,12 +382,20 @@ static char *parse(const char *command, struct interface_defn_t *ifd)
 				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 (is_prefixed_with(command, "hwaddress")) {
+						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) {
+					if (is_prefixed_with(command, "bnmask")) {
 						unsigned res;
 						varvalue = get_var("netmask", 7, ifd);
 						if (varvalue) {
@@ -266,7 +408,7 @@ static char *parse(const char *command, struct interface_defn_t *ifd)
 							}
 						}
 					}
-#endif
+# endif
 					okay[opt_depth - 1] = 0;
 				}
 
@@ -277,13 +419,13 @@ static char *parse(const char *command, struct interface_defn_t *ifd)
 	}
 
 	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;
 	}
@@ -311,79 +453,89 @@ static int execute(const char *command, struct interface_defn_t *ifd, execfn *ex
 	}
 	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);
-	/* Was: "[[ ip ....%gateway% ]]". Removed extra spaces w/o checking */
-	result += execute("[[ip route add ::/0 via %gateway%]]", ifd, exec);
-#else
+	result += execute("ip link set[[ mtu %mtu%]][[ addr %hwaddress%]] %iface% up", ifd, exec);
+	/* Reportedly, IPv6 needs "dev %iface%", but IPv4 does not: */
+	result += execute("[[ip route add ::/0 via %gateway% dev %iface%]][[ metric %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 "
 			"%endpoint%[[ local %local%]][[ ttl %ttl%]]", ifd, exec);
 	result += execute("ip link set %iface% up", ifd, exec);
 	result += execute("ip addr add %address%/%netmask% dev %iface%", ifd, exec);
-	result += execute("[[ip route add ::/0 via %gateway%]]", ifd, exec);
+	/* Reportedly, IPv6 needs "dev %iface%", but IPv4 does not: */
+	result += execute("[[ip route add ::/0 via %gateway% dev %iface%]]", ifd, exec);
 	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 = {
@@ -391,71 +543,79 @@ 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%[[ metric %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",
 				ifd, exec);
 	result += execute("ifconfig %iface% %address% netmask %netmask%"
-				"[[ broadcast %broadcast%]][[ pointopoint %pointopoint%]] ",
+				"[[ 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
-	result = execute("ip addr flush dev %iface%", ifd, exec);
+# if ENABLE_FEATURE_IFUPDOWN_IP
+	/* Optional "label LBL" is necessary if interface is an alias (eth0:0),
+	 * otherwise "ip addr flush dev eth0:0" flushes all addresses on eth0.
+	 */
+	result = execute("ip addr flush dev %iface%[[ label %label%]]", 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;
@@ -463,7 +623,7 @@ struct dhcp_client_t
 
 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",
@@ -475,101 +635,147 @@ static const struct dhcp_client_t ext_dhcp_clients[] = {
 		"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%[[ -x hostname:%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
-#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
-	int i;
+#  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))
+		if (executable_exists(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%[[ -x hostname:%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 (executable_exists(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 = {
@@ -578,36 +784,44 @@ static const struct address_family_t addr_inet = {
 	methods
 };
 
-#endif	/* if ENABLE_FEATURE_IFUPDOWN_IPV4 */
+#endif  /* FEATURE_IFUPDOWN_IPV4 */
+
+static int FAST_FUNC link_up_down(struct interface_defn_t *ifd UNUSED_PARAM, execfn *exec UNUSED_PARAM)
+{
+	return 1;
+}
+
+static const struct method_t link_methods[] = {
+	{ "none", link_up_down, link_up_down }
+};
+
+static const struct address_family_t addr_link = {
+	"link", ARRAY_SIZE(link_methods), link_methods
+};
 
+/* 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;
 }
@@ -633,7 +847,7 @@ static const struct method_t *get_method(const struct address_family_t *af, char
 
 	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];
@@ -642,74 +856,87 @@ static const struct method_t *get_method(const struct address_family_t *af, char
 	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));
-
-			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 = xzalloc(sizeof(*currmap));
 
-				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,
@@ -717,150 +944,132 @@ static struct interfaces_file_t *read_interfaces(const char *filename)
 #if ENABLE_FEATURE_IFUPDOWN_IPV6
 				&addr_inet6,
 #endif
+				&addr_link,
 				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);
+#if 0
+// Allegedly, Debian allows a duplicate definition:
+// iface eth0 inet static
+//     address 192.168.0.15
+//     netmask 255.255.0.0
+//     gateway 192.168.0.1
+//
+// iface eth0 inet static
+//     address 10.0.0.1
+//     netmask 255.255.255.0
+//
+// This adds *two* addresses to eth0 (probably requires use of "ip", not "ifconfig"
+//
+			llist_t *iface_list;
 			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);
 				}
 			}
+#endif
 			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;
 }
@@ -868,60 +1077,55 @@ static struct interfaces_file_t *read_interfaces(const char *filename)
 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)
@@ -933,16 +1137,15 @@ 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;
 		}
@@ -962,6 +1165,11 @@ static int execute_all(struct interface_defn_t *ifd, const char *opt)
 		}
 	}
 
+	/* Tested on Debian Squeeze: "standard" ifup runs this without
+	 * checking that directory exists. If it doesn't, run-parts
+	 * complains, and this message _is_ annoyingly visible.
+	 * Don't "fix" this (unless newer Debian does).
+	 */
 	buf = xasprintf("run-parts /etc/network/if-%s.d", opt);
 	/* heh, we don't bother free'ing it */
 	return doit(buf);
@@ -975,78 +1183,56 @@ static int check(char *str)
 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);
-
-	if (pipe(infd) != 0) {
-		return 0;
-	}
+	xpiped_pair(infd);
+	xpiped_pair(outfd);
 
-	if (pipe(outfd) != 0) {
-		close(infd[0]);
-		close(infd[1]);
-		return 0;
-	}
+	fflush_all();
+	pid = xvfork();
 
-	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;
+	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);
 	}
-	/* 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;
@@ -1054,27 +1240,23 @@ static char *run_mapping(char *physical, struct mapping_defn_t * map)
 
 	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. */
@@ -1085,10 +1267,6 @@ static char *run_mapping(char *physical, struct mapping_defn_t * map)
 
 			free(logical);
 			logical = new_logical;
-		} else {
-			/* If we are UNABLE to read a line of output, discard our
-			 * freshly allocated memory. */
-			free(new_logical);
 		}
 	}
 
@@ -1100,12 +1278,13 @@ static char *run_mapping(char *physical, struct mapping_defn_t * map)
 
 static llist_t *find_iface_state(llist_t *state_list, const char *iface)
 {
-	unsigned short iface_len = strlen(iface);
 	llist_t *search = state_list;
 
 	while (search) {
-		if ((strncmp(search->data, iface, iface_len) == 0)
-		 && (search->data[iface_len] == '=')) {
+		char *after_iface = is_prefixed_with(search->data, iface);
+		if (after_iface
+		 && *after_iface == '='
+		) {
 			return search;
 		}
 		search = search->link;
@@ -1117,7 +1296,7 @@ static llist_t *find_iface_state(llist_t *state_list, const char *iface)
 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(IFSTATE_FILE_PATH);
 
 	if (state_fp) {
 		char *start, *end_ptr;
@@ -1132,45 +1311,76 @@ static llist_t *read_iface_state(void)
 	return state_list;
 }
 
+/* read the previous state from the state file */
+static FILE *open_new_state_file(void)
+{
+	int fd, flags, cnt;
+
+	cnt = 0;
+	flags = (O_WRONLY | O_CREAT | O_EXCL);
+	for (;;) {
+		fd = open(IFSTATE_FILE_PATH".new", flags, 0666);
+		if (fd >= 0)
+			break;
+		if (errno != EEXIST
+		 || flags == (O_WRONLY | O_CREAT | O_TRUNC)
+		) {
+			bb_perror_msg_and_die("can't open '%s'",
+					IFSTATE_FILE_PATH".new");
+		}
+		/* Someone else created the .new file */
+		if (cnt > 30 * 1000) {
+			/* Waited for 30*30/2 = 450 milliseconds, still EEXIST.
+			 * Assuming a stale file, rewriting it.
+			 */
+			flags = (O_WRONLY | O_CREAT | O_TRUNC);
+			continue;
+		}
+		usleep(cnt);
+		cnt += 1000;
+	}
+
+	return xfdopen_for_write(fd);
+}
 
-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;
 
-	cmds = iface_down;
-	if (applet_name[2] == 'u') {
+	INIT_G();
+
+	G.startup_PATH = getenv("PATH");
+	G.shell = xstrdup(get_shell_name());
+
+	if (ENABLE_IFUP
+	 && (!ENABLE_IFDOWN || applet_name[2] == 'u')
+	) {
 		/* ifup command */
 		cmds = iface_up;
+	} else {
+		cmds = iface_down;
 	}
 
-	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 */
@@ -1181,7 +1391,8 @@ int ifupdown_main(int argc, char **argv)
 		char *liface;
 		char *pch;
 		bool okay = 0;
-		unsigned cmds_ret;
+		int cmds_ret;
+		bool curr_failure = 0;
 
 		iface = xstrdup(target_list->data);
 		target_list = target_list->link;
@@ -1202,13 +1413,13 @@ int ifupdown_main(int argc, char **argv)
 				/* 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);
@@ -1247,11 +1458,11 @@ int ifupdown_main(int argc, char **argv)
 				/* Call the cmds function pointer, does either iface_up() or iface_down() */
 				cmds_ret = cmds(currif);
 				if (cmds_ret == -1) {
-					bb_error_msg("don't seem to have all the variables for %s/%s",
+					bb_error_msg("don't have all variables for %s/%s",
 							liface, currif->address_family->name);
-					any_failures = 1;
+					any_failures = curr_failure = 1;
 				} else if (cmds_ret == 0) {
-					any_failures = 1;
+					any_failures = curr_failure = 1;
 				}
 
 				currif->iface = oldiface;
@@ -1259,7 +1470,7 @@ int ifupdown_main(int argc, char **argv)
 			iface_list = iface_list->link;
 		}
 		if (VERBOSE) {
-			puts("");
+			bb_putchar('\n');
 		}
 
 		if (!okay && !FORCE) {
@@ -1267,14 +1478,14 @@ int ifupdown_main(int argc, char **argv)
 			any_failures = 1;
 		} else if (!NO_ACT) {
 			/* update the state file */
-			FILE *state_fp;
+			FILE *new_state_fp = open_new_state_file();
 			llist_t *state;
 			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 && !curr_failure) {
+				char *newiface = xasprintf("%s=%s", iface, liface);
+				if (!iface_state) {
 					llist_add_to_end(&state_list, newiface);
 				} else {
 					free(iface_state->data);
@@ -1287,17 +1498,20 @@ int ifupdown_main(int argc, char **argv)
 			}
 
 			/* Actually write the new state */
-			state_fp = xfopen(CONFIG_IFUPDOWN_IFSTATE_PATH, "w");
 			state = state_list;
 			while (state) {
 				if (state->data) {
-					fprintf(state_fp, "%s\n", state->data);
+					fprintf(new_state_fp, "%s\n", state->data);
 				}
 				state = state->link;
 			}
-			fclose(state_fp);
+			fclose(new_state_fp);
+			xrename(IFSTATE_FILE_PATH".new", IFSTATE_FILE_PATH);
 			llist_free(state_list, free);
 		}
+ next:
+		free(iface);
+		free(liface);
 	}
 
 	return any_failures;