/* vi: set sw=4 ts=4: */
/*
- * ifupdown for busybox
- * Copyright (c) 2002 Glenn McGrath
- *
Copyright (c) 2003-2004 Erik Andersen <andersen@codepoet.org>
+ * 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
- *
Copyright (c) 1999 Anthony Towns <aj@azure.humbug.org.au>
+ * Based on ifupdown v 0.6.4 by Anthony Towns
+ * Copyright (c) 1999 Anthony Towns <aj@azure.humbug.org.au>
*
- * Changes to upstream version
- * Remove checks for kernel version, assume kernel version 2.2.0 or better.
- * Lines in the interfaces file cannot wrap.
- * To adhere to the FHS, the default state file is /var/run/ifstate
- * (defined via CONFIG_IFUPDOWN_IFSTATE_PATH) and can be overridden by build
- * configuration.
+ * Changes to upstream version
+ * Remove checks for kernel version, assume kernel version 2.2.0 or better.
+ * Lines in the interfaces file cannot wrap.
+ * To adhere to the FHS, the default state file is /var/run/ifstate
+ * (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.
*/
-
+//config:config IFUP
+//config: bool "ifup (14 kb)"
+//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 (13 kb)"
+//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_ODDNAME:name main location suid_type help
+//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 <net/if.h>
+#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>
-#include <getopt.h>
-
-#include "libbb.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 */
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 { 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
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) {
- static char *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 - why?
- // ubuntu's ifup doesn't do this
+ //free(label_buf);
+ //label_buf = xstrdup(ifd->iface);
+ // Remove virtual iface suffix
//result = strchrnul(label_buf, ':');
//*result = '\0';
- return label_buf;
+ //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 (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) {
}
}
}
-#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 FAST_FUNC manual_up_down6(struct interface_defn_t *ifd UNUSED_PARAM, execfn *exec UNUSED_PARAM)
+{
+ return 1;
}
-static int static_up6(struct interface_defn_t *ifd, execfn *exec)
+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 (!if_nametoindex(ifd->iface))
+ return 1; /* already gone */
+# 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 = {
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 (!if_nametoindex(ifd->iface))
+ return 2; /* already gone */
+# 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;
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%[[ -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
- 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))
+ if (executable_exists(ext_dhcp_clients[i].name))
return execute(ext_dhcp_clients[i].startcmd, ifd, exec);
}
- bb_error_msg("no dhcp clients found");
+ bb_simple_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_simple_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 */
+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 length;
if (word[length] != '\0')
word[length++] = '\0';
- *buf = word + length;
+ *buf = skip_whitespace(word + length);
return word;
}
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.
*
* the last character a backslash.
*
* Seen elsewhere in example config file:
- * A "#" character in the very first column makes the rest of the line
+ * 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 *buf;
char *first_word;
char *rest_of_line;
enum { NONE, IFACE, MAPPING } currently_processing = NONE;
- defn = xzalloc(sizeof(*defn));
- f = xfopen(filename, "r");
+ if (!defn)
+ defn = xzalloc(sizeof(*defn));
+
+ debug_noise("reading %s file:\n", filename);
+ f = xfopen_for_read(filename);
- while ((buf = xmalloc_getline(f)) != 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_getline(f);
+ rest_of_line = xmalloc_fgetline(f);
if (!rest_of_line)
break;
p = xasprintf("%s%s", buf, rest_of_line);
#endif
rest_of_line = buf;
first_word = next_word(&rest_of_line);
- if (!first_word || *buf == '#') {
+ if (!first_word || *first_word == '#') {
free(buf);
continue; /* blank/comment line */
}
currmap = xzalloc(sizeof(*currmap));
while ((first_word = next_word(&rest_of_line)) != NULL) {
- if (currmap->n_matches >= currmap->max_matches) {
- currmap->max_matches = currmap->max_matches * 2 + 1;
- currmap->match = xrealloc(currmap->match,
- sizeof(*currmap->match) * currmap->max_matches);
- }
+ currmap->match = xrealloc_vector(currmap->match, 4, currmap->n_matches);
currmap->match[currmap->n_matches++] = xstrdup(first_word);
}
- /*currmap->max_mappings = 0; - done by xzalloc */
/*currmap->n_mappings = 0;*/
/*currmap->mapping = NULL;*/
/*currmap->script = NULL;*/
#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(*currif));
iface_name = next_word(&rest_of_line);
currif->method = get_method(currif->address_family, method_name);
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)
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);
while ((first_word = next_word(&rest_of_line)) != NULL) {
/* Check the interface isnt already listed */
- if (find_list_string(defn->autointerfaces, first_word)) {
+ if (llist_find_str(defn->autointerfaces, first_word)) {
bb_perror_msg_and_die("interface declared auto twice \"%s\"", buf);
}
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 if (is_prefixed_with(first_word, "source-dir")) {
+ const char *dirpath;
+ DIR *dir;
+ struct dirent *entry;
+
+ dirpath = next_word(&rest_of_line);
+ dir = xopendir(dirpath);
+ while ((entry = readdir(dir)) != NULL) {
+ char *path;
+ if (entry->d_name[0] == '.')
+ continue;
+ path = concat_path_file(dirpath, entry->d_name);
+ read_interfaces(path, defn);
+ free(path);
+ }
+ closedir(dir);
} else {
switch (currently_processing) {
case IFACE:
if (rest_of_line[0] == '\0')
bb_error_msg_and_die("option with empty value \"%s\"", buf);
- if (strcmp(first_word, "up") != 0
- && strcmp(first_word, "down") != 0
- && strcmp(first_word, "pre-up") != 0
- && strcmp(first_word, "post-down") != 0
- ) {
+ if (strcmp(first_word, "post-up") == 0)
+ first_word += 5; /* "up" */
+ else if (strcmp(first_word, "pre-down") == 0)
+ first_word += 4; /* "down" */
+
+ /* 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) {
- currif->max_options += 10;
- currif->option = xrealloc(currif->option,
- sizeof(*currif->option) * currif->max_options);
- }
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++;
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) {
- if (currmap->n_mappings >= currmap->max_mappings) {
- currmap->max_mappings = currmap->max_mappings * 2 + 1;
- currmap->mapping = xrealloc(currmap->mapping,
- sizeof(char *) * currmap->max_mappings);
- }
+ 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_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);
}
safe_waitpid(child, &status, 0);
if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
static int execute_all(struct interface_defn_t *ifd, const char *opt)
{
+ /* 'opt' is always short, the longest value is "post-down".
+ * Can use on-stack buffer instead of xasprintf'ed one.
+ */
+ char buf[sizeof("run-parts /etc/network/if-%s.d")
+ + sizeof("post-down")
+ /*paranoia:*/ + 8
+ ];
int i;
- char *buf;
+
for (i = 0; i < ifd->n_options; i++) {
if (strcmp(ifd->option[i].name, opt) == 0) {
if (!doit(ifd->option[i].value)) {
}
}
- buf = xasprintf("run-parts /etc/network/if-%s.d", opt);
- /* heh, we don't bother free'ing it */
+ /* 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).
+ */
+ sprintf(buf, "run-parts /etc/network/if-%s.d", opt);
return doit(buf);
}
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;
}
xpiped_pair(infd);
xpiped_pair(outfd);
- fflush(NULL);
- pid = fork();
+ fflush_all();
+ pid = xvfork();
- switch (pid) {
- case -1: /* failure */
- bb_perror_msg_and_die("fork");
- case 0: /* child */
+ 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(command, argv);
- _exit(127);
+ BB_EXECVP_or_die(argv);
}
/* parent */
close(infd.rd);
close(outfd.wr);
- *in = fdopen(infd.wr, "w");
- *out = fdopen(outfd.rd, "r");
+ *in = xfdopen_for_write(infd.wr);
+ *out = xfdopen_for_read(outfd.rd);
return pid;
}
/* 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_getline(out);
+ char *new_logical = xmalloc_fgetline(out);
if (new_logical) {
/* If we are able to read a line of output from the script,
static llist_t *find_iface_state(llist_t *state_list, const char *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] == '=')
+ char *after_iface = is_prefixed_with(search->data, iface);
+ if (after_iface
+ && *after_iface == '='
) {
return search;
}
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;
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) MAIN_EXTERNALLY_VISIBLE;
-int ifupdown_main(int argc, char **argv)
+int ifupdown_main(int argc UNUSED_PARAM, char **argv)
{
int (*cmds)(struct interface_defn_t *);
struct interfaces_file_t *defn;
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(argv, OPTION_STR, &interfaces);
- if (argc - optind > 0) {
+ 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);
-
- 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;
+ bool curr_failure = 0;
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);
/* 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;
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);
}
/* 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;
projects / oweals / busybox.git / blobdiff