Correcting tag name to be like previous ones1_3_0

81 files changed, 26725 insertions, 0 deletions

diff --git a/networking/Config.in b/networking/Config.in
new file mode 100644
index 0000000..e671107
--- /dev/null
+++ b/networking/Config.in
@@ -0,0 +1,720 @@
+#
+# For a description of the syntax of this configuration file,
+# see scripts/kbuild/config-language.txt.
+#
+
+menu "Networking Utilities"
+
+config FEATURE_IPV6
+	bool "Enable IPv6 support"
+	default n
+	help
+	  Enable IPv6 support in busybox.
+	  This adds IPv6 support in the networking applets.
+
+config ARPING
+	bool "arping"
+	default n
+	help
+	  Ping hosts by ARP packets
+
+config DNSD
+	bool "dnsd"
+	default n
+	help
+	  Small and static DNS server daemon.
+
+config ETHER_WAKE
+	bool "ether-wake"
+	default n
+	help
+	  Send a magic packet to wake up sleeping machines.
+
+config FAKEIDENTD
+	bool "fakeidentd"
+	default n
+	select FEATURE_SYSLOG
+	help
+	  fakeidentd listens on the ident port and returns a predefined
+	  fake value on any query.
+
+config FTPGET
+	bool "ftpget"
+	default n
+	help
+	  Retrieve a remote file via FTP.
+
+config FTPPUT
+	bool "ftpput"
+	default n
+	help
+	  Store a remote file via FTP.
+
+config FEATURE_FTPGETPUT_LONG_OPTIONS
+	bool "Enable long options in ftpget/ftpput"
+	default n
+	depends on GETOPT_LONG && (FTPGET || FTPPUT)
+	help
+	  Support long options for the ftpget/ftpput applet.
+
+config HOSTNAME
+	bool "hostname"
+	default n
+	help
+	  Show or set the system's host name
+
+config HTTPD
+	bool "httpd"
+	default n
+	help
+	  Serve web pages via an HTTP server.
+
+config FEATURE_HTTPD_RELOAD_CONFIG_SIGHUP
+	bool "Support reloading the global config file using hup signal"
+	default n
+	depends on HTTPD && FEATURE_HTTPD_WITHOUT_INETD
+	help
+	  This option enables processing of SIGHUP to reload cached
+	  configuration settings.
+
+config FEATURE_HTTPD_SETUID
+	bool "Enable support -u <user> option"
+	default n
+	depends on HTTPD && FEATURE_HTTPD_WITHOUT_INETD
+	help
+	  This option allows the server to run as a specific user
+	  rather than defaulting to the user that starts the server.
+	  Use of this option requires special privileges to change to a
+	  different user.
+
+config FEATURE_HTTPD_BASIC_AUTH
+	bool "Enable Basic http Authentication"
+	default y
+	depends on HTTPD
+	help
+	  Utilizes password settings from /etc/httpd.conf for basic
+	  authentication on a per url basis.
+
+config FEATURE_HTTPD_AUTH_MD5
+	bool "Support MD5 crypted passwords for http Authentication"
+	default n
+	depends on FEATURE_HTTPD_BASIC_AUTH
+	help
+	  Enables basic per URL authentication from /etc/httpd.conf
+	  using md5 passwords.
+
+config FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES
+	bool "Support loading additional MIME types at run-time"
+	default n
+	depends on HTTPD
+	help
+	  This option enables support for additional MIME types at
+	  run-time to be specified in the configuration file.
+
+config FEATURE_HTTPD_CGI
+	bool "Support Common Gateway Interface (CGI)"
+	default y
+	depends on HTTPD
+	help
+	  This option allows scripts and executables to be invoked
+	  when specific URLs are requested.
+
+config FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
+	bool "Enable support for running scripts through an interpreter"
+	default n
+	depends on FEATURE_HTTPD_CGI
+	help
+	  This option enables support for running scripts through an
+	  interpreter. Turn this on if you want PHP scripts to work
+	  properly. You need to supply an addition line in your httpd
+	  config file:
+	  *.php:/path/to/your/php
+
+config FEATURE_HTTPD_SET_REMOTE_PORT_TO_ENV
+	bool "Support the REMOTE_PORT environment variable for CGI"
+	default n
+	depends on FEATURE_HTTPD_CGI
+	help
+	  Use of this option can assist scripts in generating
+	  references that contain a unique port number.
+
+config FEATURE_HTTPD_ENCODE_URL_STR
+	bool "Enable the -e option for shell script CGI simplification."
+	default y
+	depends on HTTPD
+	help
+	  This option allows html encoding arbitrary
+	  strings for display of the browser.  Output goes to stdout.
+	  For example, httpd -e "<Hello World>" as
+	  "&#60Hello&#32World&#62".
+
+config IFCONFIG
+	bool "ifconfig"
+	default n
+	help
+	  Ifconfig is used to configure the kernel-resident network interfaces.
+
+config FEATURE_IFCONFIG_STATUS
+	bool "Enable status reporting output (+7k)"
+	default y
+	depends on IFCONFIG
+	help
+	  If ifconfig is called with no arguments it will display the status
+	  of the currently active interfaces.
+
+config FEATURE_IFCONFIG_SLIP
+	bool "Enable slip-specific options \"keepalive\" and \"outfill\""
+	default n
+	depends on IFCONFIG
+	help
+	  Allow "keepalive" and "outfill" support for SLIP.  If you're not
+	  planning on using serial lines, leave this unchecked.
+
+config FEATURE_IFCONFIG_MEMSTART_IOADDR_IRQ
+	bool "Enable options \"mem_start\", \"io_addr\", and \"irq\""
+	default n
+	depends on IFCONFIG
+	help
+	  Allow the start address for shared memory, start address for I/O,
+	  and/or the interrupt line used by the specified device.
+
+config FEATURE_IFCONFIG_HW
+	bool "Enable option \"hw\" (ether only)"
+	default y
+	depends on IFCONFIG
+	help
+	  Set the hardware address of this interface, if the device driver
+	  supports  this  operation.  Currently, we only support the 'ether'
+	  class.
+
+config FEATURE_IFCONFIG_BROADCAST_PLUS
+	bool "Set the broadcast automatically"
+	default n
+	depends on IFCONFIG
+	help
+	  Setting this will make ifconfig attempt to find the broadcast
+	  automatically if the value '+' is used.
+
+config IFUPDOWN
+	bool "ifupdown"
+	default n
+	select RUN_PARTS
+	help
+	  Activate or deactivate the specified interfaces.  This applet makes
+	  use of either "ifconfig" and "route" or the "ip" command to actually
+	  configure network interfaces.  Therefore, you will probably also want
+	  to enable either IFCONFIG and ROUTE, or enable
+	  FEATURE_IFUPDOWN_IP and the various IP options.  Of
+	  course you could use non-busybox versions of these programs, so
+	  against my better judgement (since this will surely result in plenty
+	  of support questions on the mailing list), I do not force you to
+	  enable these additional options.  It is up to you to supply either
+	  "ifconfig" and "route" or the "ip" command, either via busybox or via
+	  standalone utilities.
+
+config FEATURE_IFUPDOWN_IP
+	bool "Use ip applet"
+	default n
+	depends on IFUPDOWN
+	help
+	  Use the iproute "ip" command to implement "ifup" and "ifdown", rather
+	  than the default of using the older 'ifconfig' and 'route' utilities.
+
+config FEATURE_IFUPDOWN_IP_BUILTIN
+	bool "Use busybox ip applet"
+	default y
+	depends on FEATURE_IFUPDOWN_IP
+	select IP
+	select FEATURE_IP_ADDRESS
+	select FEATURE_IP_LINK
+	select FEATURE_IP_ROUTE
+	help
+	  Use the busybox iproute "ip" applet to implement "ifupdown".
+
+	  If left disabled, you must install the full-blown iproute2
+	  utility or the  "ifup" and "ifdown" applets will not work.
+
+config FEATURE_IFUPDOWN_IFCONFIG_BUILTIN
+	bool "Use busybox ifconfig and route applets"
+	default y
+	depends on IFUPDOWN && !FEATURE_IFUPDOWN_IP
+	select IFCONFIG
+	select ROUTE
+	help
+	  Use the busybox iproute "ifconfig" and "route" applets to
+	  implement the "ifup" and "ifdown" utilities.
+
+	  If left disabled, you must install the full-blown ifconfig
+	  and route utilities, or the  "ifup" and "ifdown" applets will not
+	  work.
+
+config FEATURE_IFUPDOWN_IPV4
+	bool "Enable support for IPv4"
+	default y
+	depends on IFUPDOWN
+	help
+	  If you want busybox to talk IPv4, leave this on.
+
+config FEATURE_IFUPDOWN_IPV6
+	bool "Enable support for IPv6"
+	default n
+	depends on IFUPDOWN && FEATURE_IPV6
+	help
+	  If you need support for IPv6, turn this option on.
+
+config FEATURE_IFUPDOWN_IPX
+	bool "Enable support for IPX"
+	default n
+	depends on IFUPDOWN
+	help
+	  If this option is selected you can use busybox to work with IPX
+	  networks.
+
+config FEATURE_IFUPDOWN_MAPPING
+	bool "Enable mapping support"
+	default n
+	depends on IFUPDOWN
+	help
+	  This enables support for the "mapping" stanza, unless you have
+	  a weird network setup you don't need it.
+
+config INETD
+	bool "inetd"
+	default n
+	select FEATURE_SYSLOG
+	help
+	  Internet superserver daemon
+
+config FEATURE_INETD_SUPPORT_BUILTIN_ECHO
+	bool "Support echo service"
+	default y
+	depends on INETD
+	help
+	  Echo received data internal inetd service
+
+config FEATURE_INETD_SUPPORT_BUILTIN_DISCARD
+	bool "Support discard service"
+	default y
+	depends on INETD
+	help
+	  Internet /dev/null internal inetd service
+
+config FEATURE_INETD_SUPPORT_BUILTIN_TIME
+	bool "Support time service"
+	default y
+	depends on INETD
+	help
+	  Return 32 bit time since 1900 internal inetd service
+
+config FEATURE_INETD_SUPPORT_BUILTIN_DAYTIME
+	bool "Support daytime service"
+	default y
+	depends on INETD
+	help
+	  Return human-readable time internal inetd service
+
+config FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN
+	bool "Support chargen service"
+	default y
+	depends on INETD
+	help
+	  Familiar character generator internal inetd service
+
+config FEATURE_INETD_RPC
+	bool "Support RPC services"
+	default n
+	depends on INETD
+	depends on FEATURE_HAVE_RPC
+	help
+	  Support Sun-RPC based services
+
+config IP
+	bool "ip"
+	default n
+	help
+	  The "ip" applet is a TCP/IP interface configuration and routing
+	  utility.  You generally don't need "ip" to use busybox with
+	  TCP/IP.
+
+config FEATURE_IP_ADDRESS
+	bool "ip address"
+	default y
+	depends on IP
+	help
+	  Address manipulation support for the "ip" applet.
+
+config FEATURE_IP_LINK
+	bool "ip link"
+	default y
+	depends on IP
+	help
+	  Configure network devices with "ip".
+
+config FEATURE_IP_ROUTE
+	bool "ip route"
+	default y
+	depends on IP
+	help
+	  Add support for routing table management to "ip".
+
+config FEATURE_IP_TUNNEL
+	bool "ip tunnel"
+	default n
+	depends on IP
+	help
+	  Add support for tunneling commands to "ip".
+
+config FEATURE_IP_RULE
+	bool "ip rule"
+	default n
+	depends on IP
+	help
+	  Add support for rule commands to "ip".
+
+config FEATURE_IP_SHORT_FORMS
+	bool "Support short forms of ip commands."
+	default n
+	depends on IP
+	help
+	  Also support short-form of ip <OBJECT> commands:
+	  ip addr   -> ipaddr
+	  ip link   -> iplink
+	  ip route  -> iproute
+	  ip tunnel -> iptunnel
+
+	  Say N unless you desparately need the short form of the ip
+	  object commands.
+
+config IPADDR
+	bool
+	default y
+	depends on FEATURE_IP_SHORT_FORMS && FEATURE_IP_ADDRESS
+
+config IPLINK
+	bool
+	default y
+	depends on FEATURE_IP_SHORT_FORMS && FEATURE_IP_LINK
+
+config IPROUTE
+	bool
+	default y
+	depends on FEATURE_IP_SHORT_FORMS && FEATURE_IP_ROUTE
+
+config IPTUNNEL
+	bool
+	default y
+	depends on FEATURE_IP_SHORT_FORMS && FEATURE_IP_TUNNEL
+
+config IPRULE
+	bool
+	default y
+	depends on FEATURE_IP_SHORT_FORMS && FEATURE_IP_RULE
+
+config IPCALC
+	bool "ipcalc"
+	default n
+	help
+	  ipcalc takes an IP address and netmask and calculates the
+	  resulting broadcast, network, and host range.
+
+config FEATURE_IPCALC_FANCY
+	bool "Fancy IPCALC, more options, adds 1 kbyte"
+	default y
+	depends on IPCALC
+	help
+	  Adds the options hostname, prefix and silent to the output of "ipcalc".
+
+config FEATURE_IPCALC_LONG_OPTIONS
+	bool "Enable long options"
+	default n
+	depends on IPCALC && GETOPT_LONG
+	help
+	  Support long options for the ipcalc applet.
+
+config NAMEIF
+	bool "nameif"
+	default n
+	select FEATURE_SYSLOG
+	help
+	  nameif is used to rename network interface by its MAC address.
+	  Renamed interfaces MUST be in the down state.
+	  It is possible to use a file (default: /etc/mactab)
+	  with list of new interface names and MACs.
+	  Maximum interface name length: IF_NAMESIZE = 16
+	  File fields are separated by space or tab.
+	  File format:
+	  # Comment
+	  new_interface_name    XX:XX:XX:XX:XX:XX
+
+config NC
+	bool "nc"
+	default n
+	help
+	  A simple Unix utility which reads and writes data across network
+	  connections.
+
+config NC_SERVER
+	bool "Netcat server options (-lp)"
+	default n
+	depends on NC
+	help
+	  Allow netcat to act as a server.
+
+config NC_EXTRA
+	bool "Netcat extensions (-eiw and filename)"
+	default n
+	depends on NC
+	help
+	  Add -e (support for executing the rest of the command line after
+	  making or receiving a successful connection), -i (delay interval for
+	  lines sent), -w (timeout for initial connection).
+
+config NETSTAT
+	bool "netstat"
+	default n
+	help
+	  netstat prints information about the Linux networking subsystem.
+
+config NSLOOKUP
+	bool "nslookup"
+	default n
+	help
+	  nslookup is a tool to query Internet name servers.
+
+config PING
+	bool "ping"
+	default n
+	help
+	  ping uses the ICMP protocol's mandatory ECHO_REQUEST datagram to
+	  elicit an ICMP ECHO_RESPONSE from a host or gateway.
+
+config FEATURE_FANCY_PING
+	bool "Enable fancy ping output"
+	default y
+	depends on PING
+	help
+	  Make the output from the ping applet include statistics, and at the
+	  same time provide full support for ICMP packets.
+
+config PING6
+	bool "ping6"
+	default n
+	depends on FEATURE_IPV6
+	help
+	  This will give you a ping that can talk IPv6.
+
+config FEATURE_FANCY_PING6
+	bool "Enable fancy ping6 output"
+	default y
+	depends on PING6
+	help
+	  Make the output from the ping6 applet include statistics, and at the
+	  same time provide full support for ICMP packets.
+
+config ROUTE
+	bool "route"
+	default n
+	help
+	  Route displays or manipulates the kernel's IP routing tables.
+
+config TELNET
+	bool "telnet"
+	default n
+	help
+	  Telnet is an interface to the TELNET protocol, but is also commonly
+	  used to test other simple protocols.
+
+config FEATURE_TELNET_TTYPE
+	bool "Pass TERM type to remote host"
+	default y
+	depends on TELNET
+	help
+	  Setting this option will forward the TERM environment variable to the
+	  remote host you are connecting to.  This is useful to make sure that
+	  things like ANSI colors and other control sequences behave.
+
+config FEATURE_TELNET_AUTOLOGIN
+	bool "Pass USER type to remote host"
+	default y
+	depends on TELNET
+	help
+	  Setting this option will forward the USER environment variable to the
+	  remote host you are connecting to. This is useful when you need to
+	  log into a machine without telling the username (autologin). This
+	  option enables `-a' and `-l USER' arguments.
+
+config TELNETD
+	bool "telnetd"
+	default n
+	select FEATURE_SYSLOG
+	help
+	  A daemon for the TELNET protocol, allowing you to log onto the host
+	  running the daemon.  Please keep in mind that the TELNET protocol
+	  sends passwords in plain text.  If you can't afford the space for an
+	  SSH daemon and you trust your network, you may say 'y' here.  As a
+	  more secure alternative, you should seriously consider installing the
+	  very small Dropbear SSH daemon instead:
+		http://matt.ucc.asn.au/dropbear/dropbear.html
+
+	  Note that for busybox telnetd to work you need several things:
+	  First of all, your kernel needs:
+		  UNIX98_PTYS=y
+		  DEVPTS_FS=y
+
+	  Next, you need a /dev/pts directory on your root filesystem:
+
+		  $ ls -ld /dev/pts
+		  drwxr-xr-x  2 root root 0 Sep 23 13:21 /dev/pts/
+
+	  Next you need the pseudo terminal master multiplexer /dev/ptmx:
+
+		  $ ls -la /dev/ptmx
+		  crw-rw-rw-  1 root tty 5, 2 Sep 23 13:55 /dev/ptmx
+
+	  Any /dev/ttyp[0-9]* files you may have can be removed.
+	  Next, you need to mount the devpts filesystem on /dev/pts using:
+
+		  mount -t devpts devpts /dev/pts
+
+	  You need to be sure that Busybox has LOGIN and
+	  FEATURE_SUID enabled.  And finally, you should make
+	  certain that Busybox has been installed setuid root:
+
+		chown root.root /bin/busybox
+		chmod 4755 /bin/busybox
+
+	  with all that done, telnetd _should_ work....
+
+
+config FEATURE_TELNETD_STANDALONE
+	bool "Support standalone telnetd (not inetd only)"
+	default n
+	depends on TELNETD
+	help
+	  Selecting this will make telnetd able to run standalone.
+
+config TFTP
+	bool "tftp"
+	default n
+	help
+	  This enables the Trivial File Transfer Protocol client program.  TFTP
+	  is usually used for simple, small transfers such as a root image
+	  for a network-enabled bootloader.
+
+config FEATURE_TFTP_GET
+	bool "Enable \"get\" command"
+	default y
+	depends on TFTP
+	help
+	  Add support for the GET command within the TFTP client.  This allows
+	  a client to retrieve a file from a TFTP server.
+
+config FEATURE_TFTP_PUT
+	bool "Enable \"put\" command"
+	default y
+	depends on TFTP
+	help
+	  Add support for the PUT command within the TFTP client.  This allows
+	  a client to transfer a file to a TFTP server.
+
+config FEATURE_TFTP_BLOCKSIZE
+	bool "Enable \"blocksize\" command"
+	default n
+	depends on TFTP
+	help
+	  Allow the client to specify the desired block size for transfers.
+
+config DEBUG_TFTP
+	bool "Enable debug"
+	default n
+	depends on TFTP
+	help
+	  Enable debug settings for tftp.  This is useful if you're running
+	  into problems with tftp as the protocol doesn't help you much when
+	  you run into problems.
+
+config TRACEROUTE
+	bool "traceroute"
+	default n
+	help
+	  Utility to trace the route of IP packets
+
+config FEATURE_TRACEROUTE_VERBOSE
+	bool "Enable verbose output"
+	default n
+	depends on TRACEROUTE
+	help
+	  Add some verbosity to traceroute.  This includes amongst other things
+	  hostnames and ICMP response types.
+
+config FEATURE_TRACEROUTE_SOURCE_ROUTE
+	bool "Enable loose source route"
+	default n
+	depends on TRACEROUTE
+	help
+	  Add option to specify a loose source route gateway
+	  (8 maximum).
+
+config FEATURE_TRACEROUTE_USE_ICMP
+	bool "Use ICMP instead of UDP"
+	default n
+	depends on TRACEROUTE
+	help
+	  Add feature to allow for ICMP ECHO instead of UDP datagrams.
+
+source networking/udhcp/Config.in
+
+config VCONFIG
+	bool "vconfig"
+	default n
+	help
+	  Creates, removes, and configures VLAN interfaces
+
+config WGET
+	bool "wget"
+	default n
+	help
+	  wget is a utility for non-interactive download of files from HTTP,
+	  HTTPS, and FTP servers.
+
+config FEATURE_WGET_STATUSBAR
+	bool "Enable a nifty process meter (+2k)"
+	default y
+	depends on WGET
+	help
+	  Enable the transfer progress bar for wget transfers.
+
+config FEATURE_WGET_AUTHENTICATION
+	bool "Enable HTTP authentication"
+	default y
+	depends on WGET
+	help
+	  Support authenticated HTTP transfers.
+
+config FEATURE_WGET_IP6_LITERAL
+	bool "Enable IPv6 literal addresses"
+	default y
+	depends on WGET && FEATURE_IPV6
+	help
+	  Support IPv6 address literal notation in URLs.
+
+config FEATURE_WGET_LONG_OPTIONS
+	bool "Enable long options"
+	default n
+	depends on WGET && GETOPT_LONG
+	help
+	  Support long options for the wget applet.
+
+config ZCIP
+	bool "zcip"
+	default n
+	select FEATURE_SYSLOG
+	help
+	  ZCIP provides ZeroConf IPv4 address selection, according to RFC 3927.
+	  It's a daemon that allocates and defends a dynamically assigned
+	  address on the 169.254/16 network, requiring no system administrator.
+
+	  See http://www.zeroconf.org for further details, and "zcip.script"
+	  in the busybox examples.
+
+endmenu
diff --git a/networking/Kbuild b/networking/Kbuild
new file mode 100644
index 0000000..a9a51fc
--- /dev/null
+++ b/networking/Kbuild
@@ -0,0 +1,39 @@
+# Makefile for busybox
+#
+# Copyright (C) 1999-2005 by Erik Andersen <andersen@codepoet.org>
+#
+# Licensed under the GPL v2, see the file LICENSE in this tarball.
+
+lib-y:=
+lib-$(CONFIG_ARPING)       += arping.o
+lib-$(CONFIG_DNSD)         += dnsd.o
+lib-$(CONFIG_ETHER_WAKE)   += ether-wake.o
+lib-$(CONFIG_FAKEIDENTD)   += fakeidentd.o
+lib-$(CONFIG_FTPGET)       += ftpgetput.o
+lib-$(CONFIG_FTPPUT)       += ftpgetput.o
+lib-$(CONFIG_HOSTNAME)     += hostname.o
+lib-$(CONFIG_HTTPD)        += httpd.o
+lib-$(CONFIG_IFCONFIG)     += ifconfig.o interface.o
+lib-$(CONFIG_IFUPDOWN)     += ifupdown.o
+lib-$(CONFIG_INETD)        += inetd.o
+lib-$(CONFIG_IP)           += ip.o
+lib-$(CONFIG_IPCALC)       += ipcalc.o
+lib-$(CONFIG_IPADDR)       += ipaddr.o
+lib-$(CONFIG_IPLINK)       += iplink.o
+lib-$(CONFIG_IPROUTE)      += iproute.o
+lib-$(CONFIG_IPRULE)       += iprule.o
+lib-$(CONFIG_IPTUNNEL)     += iptunnel.o
+lib-$(CONFIG_NAMEIF)       += nameif.o
+lib-$(CONFIG_NC)           += nc.o
+lib-$(CONFIG_NETSTAT)      += netstat.o
+lib-$(CONFIG_NSLOOKUP)     += nslookup.o
+lib-$(CONFIG_PING)         += ping.o
+lib-$(CONFIG_PING6)        += ping6.o
+lib-$(CONFIG_ROUTE)        += route.o
+lib-$(CONFIG_TELNET)       += telnet.o
+lib-$(CONFIG_TELNETD)      += telnetd.o
+lib-$(CONFIG_TFTP)         += tftp.o
+lib-$(CONFIG_TRACEROUTE)   += traceroute.o
+lib-$(CONFIG_VCONFIG)      += vconfig.o
+lib-$(CONFIG_WGET)         += wget.o
+lib-$(CONFIG_ZCIP)         += zcip.o
diff --git a/networking/arping.c b/networking/arping.c
new file mode 100644
index 0000000..2d92bf4
--- /dev/null
+++ b/networking/arping.c
@@ -0,0 +1,446 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * arping.c - Ping hosts by ARP requests/replies
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ *
+ * Author:	Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
+ * Busybox port: Nick Fedchik <nick@fedchik.org.ua>
+ */
+
+#include <sys/ioctl.h>
+#include <signal.h>
+
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <arpa/inet.h>
+#include <net/if.h>
+#include <netinet/ether.h>
+#include <netpacket/packet.h>
+
+#include "busybox.h"
+
+static struct in_addr src;
+static struct in_addr dst;
+static struct sockaddr_ll me;
+static struct sockaddr_ll he;
+static struct timeval last;
+
+enum cfg_e {
+	dad = 1,
+	unsolicited = 2,
+	advert = 4,
+	quiet = 8,
+	quit_on_reply = 16,
+	broadcast_only = 32,
+	unicasting = 64
+};
+static int cfg;
+
+static int s;
+static unsigned count = UINT_MAX;
+static unsigned timeout;
+static int sent;
+static int brd_sent;
+static int received;
+static int brd_recv;
+static int req_recv;
+
+
+#define MS_TDIFF(tv1,tv2) ( ((tv1).tv_sec-(tv2).tv_sec)*1000 + \
+			   ((tv1).tv_usec-(tv2).tv_usec)/1000 )
+static int send_pack(int sock, struct in_addr *src_addr,
+					 struct in_addr *dst_addr, struct sockaddr_ll *ME,
+					 struct sockaddr_ll *HE)
+{
+	int err;
+	struct timeval now;
+	RESERVE_CONFIG_UBUFFER(buf, 256);
+	struct arphdr *ah = (struct arphdr *) buf;
+	unsigned char *p = (unsigned char *) (ah + 1);
+
+	ah->ar_hrd = htons(ME->sll_hatype);
+	ah->ar_hrd = htons(ARPHRD_ETHER);
+	ah->ar_pro = htons(ETH_P_IP);
+	ah->ar_hln = ME->sll_halen;
+	ah->ar_pln = 4;
+	ah->ar_op = cfg&advert ? htons(ARPOP_REPLY) : htons(ARPOP_REQUEST);
+
+	memcpy(p, &ME->sll_addr, ah->ar_hln);
+	p += ME->sll_halen;
+
+	memcpy(p, src_addr, 4);
+	p += 4;
+
+	if (cfg&advert)
+		memcpy(p, &ME->sll_addr, ah->ar_hln);
+	else
+		memcpy(p, &HE->sll_addr, ah->ar_hln);
+	p += ah->ar_hln;
+
+	memcpy(p, dst_addr, 4);
+	p += 4;
+
+	gettimeofday(&now, NULL);
+	err = sendto(sock, buf, p - buf, 0, (struct sockaddr *) HE, sizeof(*HE));
+	if (err == p - buf) {
+		last = now;
+		sent++;
+		if (!(cfg&unicasting))
+			brd_sent++;
+	}
+	RELEASE_CONFIG_BUFFER(buf);
+	return err;
+}
+
+static void finish(void)
+{
+	if (!(cfg&quiet)) {
+		printf("Sent %d probes (%d broadcast(s))\n"
+			"Received %d repl%s",
+			sent, brd_sent,
+			received, (received > 1) ? "ies" : "y");
+		if (brd_recv || req_recv) {
+			printf(" (");
+			if (req_recv)
+				printf("%d request(s)", req_recv);
+			if (brd_recv)
+				printf("%s%d broadcast(s)", req_recv ? ", " : "", brd_recv);
+			putchar(')');
+		}
+		putchar('\n');
+		fflush(stdout);
+	}
+	if (cfg&dad)
+		exit(!!received);
+	if (cfg&unsolicited)
+		exit(0);
+	exit(!received);
+}
+
+static void catcher(void)
+{
+	struct timeval tv;
+	static struct timeval start;
+
+	gettimeofday(&tv, NULL);
+
+	if (start.tv_sec == 0)
+		start = tv;
+
+	if (count-- == 0
+		|| (timeout && MS_TDIFF(tv, start) > timeout * 1000 + 500))
+		finish();
+
+	if (last.tv_sec == 0 || MS_TDIFF(tv, last) > 500) {
+		send_pack(s, &src, &dst, &me, &he);
+		if (count == 0 && cfg&unsolicited)
+			finish();
+	}
+	alarm(1);
+}
+
+static int recv_pack(unsigned char *buf, int len, struct sockaddr_ll *FROM)
+{
+	struct arphdr *ah = (struct arphdr *) buf;
+	unsigned char *p = (unsigned char *) (ah + 1);
+	struct in_addr src_ip, dst_ip;
+
+	/* Filter out wild packets */
+	if (FROM->sll_pkttype != PACKET_HOST &&
+		FROM->sll_pkttype != PACKET_BROADCAST &&
+		FROM->sll_pkttype != PACKET_MULTICAST)
+		return 0;
+
+	/* Only these types are recognised */
+	if (ah->ar_op != htons(ARPOP_REQUEST) && ah->ar_op != htons(ARPOP_REPLY))
+		return 0;
+
+	/* ARPHRD check and this darned FDDI hack here :-( */
+	if (ah->ar_hrd != htons(FROM->sll_hatype) &&
+		(FROM->sll_hatype != ARPHRD_FDDI
+		 || ah->ar_hrd != htons(ARPHRD_ETHER)))
+		return 0;
+
+	/* Protocol must be IP. */
+	if (ah->ar_pro != htons(ETH_P_IP))
+		return 0;
+	if (ah->ar_pln != 4)
+		return 0;
+	if (ah->ar_hln != me.sll_halen)
+		return 0;
+	if (len < sizeof(*ah) + 2 * (4 + ah->ar_hln))
+		return 0;
+	memcpy(&src_ip, p + ah->ar_hln, 4);
+	memcpy(&dst_ip, p + ah->ar_hln + 4 + ah->ar_hln, 4);
+	if (!(cfg&dad)) {
+		if (src_ip.s_addr != dst.s_addr)
+			return 0;
+		if (src.s_addr != dst_ip.s_addr)
+			return 0;
+		if (memcmp(p + ah->ar_hln + 4, &me.sll_addr, ah->ar_hln))
+			return 0;
+	} else {
+		/* DAD packet was:
+		   src_ip = 0 (or some src)
+		   src_hw = ME
+		   dst_ip = tested address
+		   dst_hw = <unspec>
+
+		   We fail, if receive request/reply with:
+		   src_ip = tested_address
+		   src_hw != ME
+		   if src_ip in request was not zero, check
+		   also that it matches to dst_ip, otherwise
+		   dst_ip/dst_hw do not matter.
+		 */
+		if (src_ip.s_addr != dst.s_addr)
+			return 0;
+		if (memcmp(p, &me.sll_addr, me.sll_halen) == 0)
+			return 0;
+		if (src.s_addr && src.s_addr != dst_ip.s_addr)
+			return 0;
+	}
+	if (!(cfg&quiet)) {
+		int s_printed = 0;
+		struct timeval tv;
+
+		gettimeofday(&tv, NULL);
+
+		printf("%s %s from %s [%s]",
+			FROM->sll_pkttype == PACKET_HOST ? "Unicast" : "Broadcast",
+			ah->ar_op == htons(ARPOP_REPLY) ? "reply" : "request",
+			inet_ntoa(src_ip),
+			ether_ntoa((struct ether_addr *) p));
+		if (dst_ip.s_addr != src.s_addr) {
+			printf("for %s ", inet_ntoa(dst_ip));
+			s_printed = 1;
+		}
+		if (memcmp(p + ah->ar_hln + 4, me.sll_addr, ah->ar_hln)) {
+			if (!s_printed)
+				printf("for ");
+			printf("[%s]",
+				   ether_ntoa((struct ether_addr *) p + ah->ar_hln + 4));
+		}
+
+		if (last.tv_sec) {
+			long usecs = (tv.tv_sec - last.tv_sec) * 1000000 +
+				tv.tv_usec - last.tv_usec;
+			long msecs = (usecs + 500) / 1000;
+
+			usecs -= msecs * 1000 - 500;
+			printf(" %ld.%03ldms\n", msecs, usecs);
+		} else {
+			printf(" UNSOLICITED?\n");
+		}
+		fflush(stdout);
+	}
+	received++;
+	if (FROM->sll_pkttype != PACKET_HOST)
+		brd_recv++;
+	if (ah->ar_op == htons(ARPOP_REQUEST))
+		req_recv++;
+	if (cfg&quit_on_reply)
+		finish();
+	if (!(cfg&broadcast_only)) {
+		memcpy(he.sll_addr, p, me.sll_halen);
+		cfg |= unicasting;
+	}
+	return 1;
+}
+
+int arping_main(int argc, char **argv)
+{
+	char *device = "eth0";
+	int ifindex;
+	char *source = NULL;
+	char *target;
+
+	s = xsocket(PF_PACKET, SOCK_DGRAM, 0);
+
+	// Drop suid root privileges
+	xsetuid(getuid());
+
+	{
+		unsigned opt;
+		char *_count, *_timeout;
+
+		/* Dad also sets quit_on_reply.
+		 * Advert also sets unsolicited.
+		 */
+		opt_complementary = "Df:AU";
+		opt = getopt32(argc, argv, "DUAqfbc:w:i:s:",
+					&_count, &_timeout, &device, &source);
+		cfg |= opt & 0x3f; /* set respective flags */
+		if (opt & 0x40) /* -c: count */
+			count = xatou(_count);
+		if (opt & 0x80) /* -w: timeout */
+			timeout = xatoul_range(_timeout, 0, INT_MAX/2000);
+		if (opt & 0x100) { /* -i: interface */
+			if (strlen(device) > IF_NAMESIZE) {
+				bb_error_msg_and_die("interface name '%s' is too long",
+								device);
+			}
+		}
+		//if (opt & 0x200) /* -s: source */
+	}
+	argc -= optind;
+	argv += optind;
+
+	if (argc != 1)
+		bb_show_usage();
+
+	target = *argv;
+
+	xfunc_error_retval = 2;
+
+	{
+		struct ifreq ifr;
+
+		memset(&ifr, 0, sizeof(ifr));
+		strncpy(ifr.ifr_name, device, IFNAMSIZ - 1);
+		if (ioctl(s, SIOCGIFINDEX, &ifr) < 0) {
+			bb_error_msg_and_die("interface %s not found", device);
+		}
+		ifindex = ifr.ifr_ifindex;
+
+		if (ioctl(s, SIOCGIFFLAGS, (char *) &ifr)) {
+			bb_error_msg_and_die("SIOCGIFFLAGS");
+		}
+		if (!(ifr.ifr_flags & IFF_UP)) {
+			bb_error_msg_and_die("interface %s is down", device);
+		}
+		if (ifr.ifr_flags & (IFF_NOARP | IFF_LOOPBACK)) {
+			bb_error_msg("interface %s is not ARPable", device);
+			exit(cfg&dad ? 0 : 2);
+		}
+	}
+
+	if (!inet_aton(target, &dst)) {
+		struct hostent *hp;
+
+		hp = gethostbyname2(target, AF_INET);
+		if (!hp) {
+			bb_error_msg_and_die("invalid or unknown target %s", target);
+		}
+		memcpy(&dst, hp->h_addr, 4);
+	}
+
+	if (source && !inet_aton(source, &src)) {
+		bb_error_msg_and_die("invalid source address %s", source);
+	}
+
+	if (!(cfg&dad) && cfg&unsolicited && src.s_addr == 0)
+		src = dst;
+
+	if (!(cfg&dad) || src.s_addr) {
+		struct sockaddr_in saddr;
+		int probe_fd = xsocket(AF_INET, SOCK_DGRAM, 0);
+
+		if (device) {
+			if (setsockopt
+				(probe_fd, SOL_SOCKET, SO_BINDTODEVICE, device,
+				 strlen(device) + 1) == -1)
+				bb_error_msg("warning: interface %s is ignored", device);
+		}
+		memset(&saddr, 0, sizeof(saddr));
+		saddr.sin_family = AF_INET;
+		if (src.s_addr) {
+			saddr.sin_addr = src;
+			if (bind(probe_fd, (struct sockaddr *) &saddr, sizeof(saddr)) == -1) {
+				bb_error_msg_and_die("bind");
+			}
+		} else if (!(cfg&dad)) {
+			static const int on = 1;
+			socklen_t alen = sizeof(saddr);
+
+			saddr.sin_port = htons(1025);
+			saddr.sin_addr = dst;
+
+			if (setsockopt
+				(probe_fd, SOL_SOCKET, SO_DONTROUTE, (char *) &on,
+				 sizeof(on)) == -1)
+				bb_perror_msg("warning: setsockopt(SO_DONTROUTE)");
+			if (connect(probe_fd, (struct sockaddr *) &saddr, sizeof(saddr))
+				== -1) {
+				bb_error_msg_and_die("connect");
+			}
+			if (getsockname(probe_fd, (struct sockaddr *) &saddr, &alen) ==
+				-1) {
+				bb_error_msg_and_die("getsockname");
+			}
+			src = saddr.sin_addr;
+		}
+		close(probe_fd);
+	};
+
+	me.sll_family = AF_PACKET;
+	me.sll_ifindex = ifindex;
+	me.sll_protocol = htons(ETH_P_ARP);
+	if (bind(s, (struct sockaddr *) &me, sizeof(me)) == -1) {
+		bb_error_msg_and_die("bind");
+	}
+
+	{
+		socklen_t alen = sizeof(me);
+
+		if (getsockname(s, (struct sockaddr *) &me, &alen) == -1) {
+			bb_error_msg_and_die("getsockname");
+		}
+	}
+	if (me.sll_halen == 0) {
+		bb_error_msg("interface \"%s\" is not ARPable (no ll address)", device);
+		exit(cfg&dad ? 0 : 2);
+	}
+	he = me;
+	memset(he.sll_addr, -1, he.sll_halen);
+
+	if (!(cfg&quiet)) {
+		printf("ARPING to %s from %s via %s\n",
+			inet_ntoa(dst), inet_ntoa(src),
+			device ? device : "unknown");
+	}
+
+	if (!src.s_addr && !(cfg&dad)) {
+		bb_error_msg_and_die("no src address in the non-DAD mode");
+	}
+
+	{
+		struct sigaction sa;
+
+		memset(&sa, 0, sizeof(sa));
+		sa.sa_flags = SA_RESTART;
+
+		sa.sa_handler = (void (*)(int)) finish;
+		sigaction(SIGINT, &sa, NULL);
+
+		sa.sa_handler = (void (*)(int)) catcher;
+		sigaction(SIGALRM, &sa, NULL);
+	}
+
+	catcher();
+
+	while (1) {
+		sigset_t sset, osset;
+		RESERVE_CONFIG_UBUFFER(packet, 4096);
+		struct sockaddr_ll from;
+		socklen_t alen = sizeof(from);
+		int cc;
+
+		if ((cc = recvfrom(s, packet, 4096, 0,
+						   (struct sockaddr *) &from, &alen)) < 0) {
+			bb_perror_msg("recvfrom");
+			continue;
+		}
+		sigemptyset(&sset);
+		sigaddset(&sset, SIGALRM);
+		sigaddset(&sset, SIGINT);
+		sigprocmask(SIG_BLOCK, &sset, &osset);
+		recv_pack(packet, cc, &from);
+		sigprocmask(SIG_SETMASK, &osset, NULL);
+		RELEASE_CONFIG_BUFFER(packet);
+	}
+}
diff --git a/networking/dnsd.c b/networking/dnsd.c
new file mode 100644
index 0000000..5e9cf52
--- /dev/null
+++ b/networking/dnsd.c
@@ -0,0 +1,456 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Mini DNS server implementation for busybox
+ *
+ * Copyright (C) 2005 Roberto A. Foglietta (me@roberto.foglietta.name)
+ * Copyright (C) 2005 Odd Arild Olsen (oao at fibula dot no)
+ * Copyright (C) 2003 Paul Sheer
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ *
+ * Odd Arild Olsen started out with the sheerdns [1] of Paul Sheer and rewrote
+ * it into a shape which I believe is both easier to understand and maintain.
+ * I also reused the input buffer for output and removed services he did not
+ * need.  [1] http://threading.2038bug.com/sheerdns/
+ *
+ * Some bugfix and minor changes was applied by Roberto A. Foglietta who made
+ * the first porting of oao' scdns to busybox also.
+ */
+
+#include "busybox.h"
+
+static char *fileconf = "/etc/dnsd.conf";
+#define LOCK_FILE       "/var/run/dnsd.lock"
+#define LOG_FILE        "/var/log/dnsd.log"
+
+// Must matct getopt32 call
+#define OPT_daemon  (option_mask32 & 0x10)
+#define OPT_verbose (option_mask32 & 0x20)
+
+//#define DEBUG 1
+
+enum {
+	MAX_HOST_LEN = 16,      // longest host name allowed is 15
+	IP_STRING_LEN = 18,     // .xxx.xxx.xxx.xxx\0
+
+//must be strlen('.in-addr.arpa') larger than IP_STRING_LEN
+	MAX_NAME_LEN = (IP_STRING_LEN + 13),
+
+/* Cannot get bigger packets than 512 per RFC1035
+   In practice this can be set considerably smaller:
+   Length of response packet is  header (12B) + 2*type(4B) + 2*class(4B) +
+   ttl(4B) + rlen(2B) + r (MAX_NAME_LEN =21B) +
+   2*querystring (2 MAX_NAME_LEN= 42B), all together 90 Byte
+*/
+	MAX_PACK_LEN = 512 + 1,
+
+	DEFAULT_TTL = 30,       // increase this when not testing?
+
+	REQ_A = 1,
+	REQ_PTR = 12
+};
+
+struct dns_repl {		// resource record, add 0 or 1 to accepted dns_msg in resp
+	uint16_t rlen;
+	uint8_t *r;		// resource
+	uint16_t flags;
+};
+
+struct dns_head {		// the message from client and first part of response mag
+	uint16_t id;
+	uint16_t flags;
+	uint16_t nquer;		// accepts 0
+	uint16_t nansw;		// 1 in response
+	uint16_t nauth;		// 0
+	uint16_t nadd;		// 0
+};
+struct dns_prop {
+	uint16_t type;
+	uint16_t class;
+};
+struct dns_entry {		// element of known name, ip address and reversed ip address
+	struct dns_entry *next;
+	char ip[IP_STRING_LEN];		// dotted decimal IP
+	char rip[IP_STRING_LEN];	// length decimal reversed IP
+	char name[MAX_HOST_LEN];
+};
+
+static struct dns_entry *dnsentry = NULL;
+// FIXME! unused! :(
+static int daemonmode;
+static uint32_t ttl = DEFAULT_TTL;
+
+/*
+ * Convert host name from C-string to dns length/string.
+ */
+static void convname(char *a, uint8_t *q)
+{
+	int i = (q[0] == '.') ? 0 : 1;
+	for (; i < MAX_HOST_LEN-1 && *q; i++, q++)
+		a[i] = tolower(*q);
+	a[0] = i - 1;
+	a[i] = 0;
+}
+
+/*
+ * Insert length of substrings instead of dots
+ */
+static void undot(uint8_t * rip)
+{
+	int i = 0, s = 0;
+	while (rip[i])
+		i++;
+	for (--i; i >= 0; i--) {
+		if (rip[i] == '.') {
+			rip[i] = s;
+			s = 0;
+		} else s++;
+	}
+}
+
+/*
+ * Append message to log file
+ */
+static void log_message(char *filename, char *message)
+{
+	FILE *logfile;
+	if (!daemonmode)
+		return;
+	logfile = fopen(filename, "a");
+	if (!logfile)
+		return;
+	fprintf(logfile, "%s\n", message);
+	fclose(logfile);
+}
+
+/*
+ * Read one line of hostname/IP from file
+ * Returns 0 for each valid entry read, -1 at EOF
+ * Assumes all host names are lower case only
+ * Hostnames with more than one label is not handled correctly.
+ * Presently the dot is copied into name without
+ * converting to a length/string substring for that label.
+ */
+
+static int getfileentry(FILE * fp, struct dns_entry *s)
+{
+	unsigned int a,b,c,d;
+	char *r, *name;
+
+ restart:
+	r = xmalloc_fgets(fp);
+	if (!r)
+		return -1;
+	while (*r == ' ' || *r == '\t') {
+		r++;
+		if (!*r || *r == '#' || *r == '\n')
+			goto restart; /* skipping empty/blank and commented lines  */
+	}
+	name = r;
+	while (*r != ' ' && *r != '\t')
+		r++;
+	*r++ = 0;
+	if (sscanf(r, "%u.%u.%u.%u", &a, &b, &c, &d) != 4)
+		goto restart; /* skipping wrong lines */
+
+	sprintf(s->ip, "%u.%u.%u.%u", a, b, c, d);
+	sprintf(s->rip, ".%u.%u.%u.%u", d, c, b, a);
+	undot((uint8_t*)s->rip);
+	convname(s->name,(uint8_t*)name);
+
+	if (OPT_verbose)
+		fprintf(stderr, "\tname:%s, ip:%s\n", &(s->name[1]),s->ip);
+
+	return 0;
+}
+
+/*
+ * Read hostname/IP records from file
+ */
+static void dnsentryinit(void)
+{
+	FILE *fp;
+	struct dns_entry *m, *prev;
+	prev = dnsentry = NULL;
+
+	fp = xfopen(fileconf, "r");
+
+	while (1) {
+		m = xmalloc(sizeof(struct dns_entry));
+
+		m->next = NULL;
+		if (getfileentry(fp, m))
+			break;
+
+		if (prev == NULL)
+			dnsentry = m;
+		else
+			prev->next = m;
+		prev = m;
+	}
+	fclose(fp);
+}
+
+
+/*
+ * Set up UDP socket
+ */
+static int listen_socket(char *iface_addr, int listen_port)
+{
+	struct sockaddr_in a;
+	char msg[100];
+	int s;
+	s = xsocket(PF_INET, SOCK_DGRAM, 0);
+	if (setsockopt_reuseaddr(s) < 0)
+		bb_perror_msg_and_die("setsockopt() failed");
+	memset(&a, 0, sizeof(a));
+	a.sin_port = htons(listen_port);
+	a.sin_family = AF_INET;
+	if (!inet_aton(iface_addr, &a.sin_addr))
+		bb_perror_msg_and_die("bad iface address");
+	xbind(s, (struct sockaddr *)&a, sizeof(a));
+	xlisten(s, 50);
+	sprintf(msg, "accepting UDP packets on addr:port %s:%d\n",
+		iface_addr, (int)listen_port);
+	log_message(LOG_FILE, msg);
+	return s;
+}
+
+/*
+ * Look query up in dns records and return answer if found
+ * qs is the query string, first byte the string length
+ */
+static int table_lookup(uint16_t type, uint8_t * as, uint8_t * qs)
+{
+	int i;
+	struct dns_entry *d=dnsentry;
+
+	do {
+#ifdef DEBUG
+		char *p,*q;
+		q = (char *)&(qs[1]);
+		p = &(d->name[1]);
+		fprintf(stderr, "\n%s: %d/%d p:%s q:%s %d", 
+			__FUNCTION__, strlen(p), (int)(d->name[0]), p, q, strlen(q));
+#endif
+		if (type == REQ_A) { /* search by host name */
+			for (i = 1; i <= (int)(d->name[0]); i++)
+				if (tolower(qs[i]) != d->name[i])
+					break;
+			if (i > (int)(d->name[0])) {
+#ifdef DEBUG
+				fprintf(stderr, " OK");
+#endif
+				strcpy((char *)as, d->ip);
+#ifdef DEBUG
+				fprintf(stderr, " as:%s\n", as);
+#endif
+					return 0;
+			}
+		} else 
+		if (type == REQ_PTR) { /* search by IP-address */
+			if (!strncmp((char*)&d->rip[1], (char*)&qs[1], strlen(d->rip)-1)) {
+				strcpy((char *)as, d->name);
+				return 0;
+			}
+		}
+		d = d->next;
+	} while (d);
+	return -1;
+}
+
+
+/*
+ * Decode message and generate answer
+ */
+#define eret(s) do { fputs(s, stderr); return -1; } while (0)
+static int process_packet(uint8_t * buf)
+{
+	struct dns_head *head;
+	struct dns_prop *qprop;
+	struct dns_repl outr;
+	void *next, *from, *answb;
+
+	uint8_t answstr[MAX_NAME_LEN + 1];
+	int lookup_result, type, len, packet_len;
+	uint16_t flags;
+
+	answstr[0] = '\0';
+
+	head = (struct dns_head *)buf;
+	if (head->nquer == 0)
+		eret("no queries\n");
+
+	if (head->flags & 0x8000)
+		eret("ignoring response packet\n");
+
+	from = (void *)&head[1];	//  start of query string
+	next = answb = from + strlen((char *)from) + 1 + sizeof(struct dns_prop);   // where to append answer block
+
+	outr.rlen = 0;			// may change later
+	outr.r = NULL;
+	outr.flags = 0;
+
+	qprop = (struct dns_prop *)(answb - 4);
+	type = ntohs(qprop->type);
+
+	// only let REQ_A and REQ_PTR pass
+	if (!(type == REQ_A || type == REQ_PTR)) {
+		goto empty_packet;	/* we can't handle the query type */
+	}
+
+	if (ntohs(qprop->class) != 1 /* class INET */ ) {
+		outr.flags = 4; /* not supported */
+		goto empty_packet;
+	}
+	/* we only support standard queries */
+
+	if ((ntohs(head->flags) & 0x7800) != 0)
+		goto empty_packet;
+
+	// We have a standard query
+	log_message(LOG_FILE, (char *)from);
+	lookup_result = table_lookup(type, answstr, (uint8_t*)from);
+	if (lookup_result != 0) {
+		outr.flags = 3 | 0x0400;	//name do not exist and auth
+		goto empty_packet;
+	}
+	if (type == REQ_A) {    // return an address
+		struct in_addr a;
+		if (!inet_aton((char*)answstr, &a)) {//dotted dec to long conv
+			outr.flags = 1; /* Frmt err */
+			goto empty_packet;
+		}
+		memcpy(answstr, &a.s_addr, 4);	// save before a disappears
+		outr.rlen = 4;			// uint32_t IP
+	}
+	else
+		outr.rlen = strlen((char *)answstr) + 1;	// a host name
+	outr.r = answstr;			// 32 bit ip or a host name
+	outr.flags |= 0x0400;			/* authority-bit */
+	// we have an answer
+	head->nansw = htons(1);
+
+	// copy query block to answer block
+	len = answb - from;
+	memcpy(answb, from, len);
+	next += len;
+
+	// and append answer rr
+	*(uint32_t *) next = htonl(ttl);
+	next += 4;
+	*(uint16_t *) next = htons(outr.rlen);
+	next += 2;
+	memcpy(next, (void *)answstr, outr.rlen);
+	next += outr.rlen;
+
+ empty_packet:
+
+	flags = ntohs(head->flags);
+	// clear rcode and RA, set responsebit and our new flags
+	flags |= (outr.flags & 0xff80) | 0x8000;
+	head->flags = htons(flags);
+	head->nauth = head->nadd = htons(0);
+	head->nquer = htons(1);
+
+	packet_len = next - (void *)buf;
+	return packet_len;
+}
+
+/*
+ * Exit on signal
+ */
+static void interrupt(int x)
+{
+	unlink(LOCK_FILE);
+	write(2, "interrupt exiting\n", 18);
+	exit(2);
+}
+
+int dnsd_main(int argc, char **argv)
+{
+	int udps;
+	uint16_t port = 53;
+	uint8_t buf[MAX_PACK_LEN];
+	char *listen_interface = "0.0.0.0";
+	char *sttl, *sport;
+
+	getopt32(argc, argv, "i:c:t:p:dv", &listen_interface, &fileconf, &sttl, &sport);
+	//if (option_mask32 & 0x1) // -i
+	//if (option_mask32 & 0x2) // -c
+	if (option_mask32 & 0x4) // -t
+		if (!(ttl = atol(sttl)))
+			bb_show_usage();
+	if (option_mask32 & 0x8) // -p
+		if (!(port = atol(sport)))
+			bb_show_usage();
+
+	if (OPT_verbose) {
+		bb_info_msg("listen_interface: %s", listen_interface);
+		bb_info_msg("ttl: %d, port: %d", ttl, port);
+		bb_info_msg("fileconf: %s", fileconf);
+	}
+
+	if (OPT_daemon)
+#ifdef BB_NOMMU
+		/* reexec for vfork() do continue parent */
+		vfork_daemon_rexec(1, 0, argc, argv, "-d");
+#else
+		xdaemon(1, 0);
+#endif
+
+	dnsentryinit();
+
+	signal(SIGINT, interrupt);
+	signal(SIGPIPE, SIG_IGN);
+	signal(SIGHUP, SIG_IGN);
+#ifdef SIGTSTP
+	signal(SIGTSTP, SIG_IGN);
+#endif
+#ifdef SIGURG
+	signal(SIGURG, SIG_IGN);
+#endif
+
+	udps = listen_socket(listen_interface, port);
+	if (udps < 0)
+		exit(1);
+
+	while (1) {
+		fd_set fdset;
+		int r;
+
+		FD_ZERO(&fdset);
+		FD_SET(udps, &fdset);
+		// Block until a message arrives
+		r = select(udps + 1, &fdset, NULL, NULL, NULL);
+		if (r < 0)
+			bb_perror_msg_and_die("select error");
+		if (r == 0)
+			bb_perror_msg_and_die("select spurious return");
+
+		/* Can this test ever be false? - yes */
+		if (FD_ISSET(udps, &fdset)) {
+			struct sockaddr_in from;
+			int fromlen = sizeof(from);
+			r = recvfrom(udps, buf, sizeof(buf), 0,
+				     (struct sockaddr *)&from,
+				     (void *)&fromlen);
+			if (OPT_verbose)
+				fprintf(stderr, "\n--- Got UDP  ");
+			log_message(LOG_FILE, "\n--- Got UDP  ");
+
+			if (r < 12 || r > 512) {
+				bb_error_msg("invalid packet size");
+				continue;
+			}
+			if (r > 0) {
+				r = process_packet(buf);
+				if (r > 0)
+					sendto(udps, buf,
+					       r, 0, (struct sockaddr *)&from,
+					       fromlen);
+			}
+		} // end if
+	} // end while
+	return 0;
+}
diff --git a/networking/ether-wake.c b/networking/ether-wake.c
new file mode 100644
index 0000000..e205ffc
--- /dev/null
+++ b/networking/ether-wake.c
@@ -0,0 +1,284 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * ether-wake.c - Send a magic packet to wake up sleeping machines.
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ *
+ * Author:      Donald Becker, http://www.scyld.com/"; http://www.scyld.com/wakeonlan.html
+ * Busybox port: Christian Volkmann <haveaniceday@online.de>
+ *               Used version of ether-wake.c: v1.09 11/12/2003 Donald Becker, http://www.scyld.com/";
+ */
+
+/* full usage according Donald Becker
+ * usage: ether-wake [-i <ifname>] [-p aa:bb:cc:dd[:ee:ff]] 00:11:22:33:44:55\n"
+ *
+ *	This program generates and transmits a Wake-On-LAN (WOL)\n"
+ *	\"Magic Packet\", used for restarting machines that have been\n"
+ *	soft-powered-down (ACPI D3-warm state).\n"
+ *	It currently generates the standard AMD Magic Packet format, with\n"
+ *	an optional password appended.\n"
+ *
+ *	The single required parameter is the Ethernet MAC (station) address\n"
+ *	of the machine to wake or a host ID with known NSS 'ethers' entry.\n"
+ *	The MAC address may be found with the 'arp' program while the target\n"
+ *	machine is awake.\n"
+ *
+ *	Options:\n"
+ *		-b	Send wake-up packet to the broadcast address.\n"
+ *		-D	Increase the debug level.\n"
+ *		-i ifname	Use interface IFNAME instead of the default 'eth0'.\n"
+ *		-p <pw>		Append the four or six byte password PW to the packet.\n"
+ *					A password is only required for a few adapter types.\n"
+ *					The password may be specified in ethernet hex format\n"
+ *					or dotted decimal (Internet address)\n"
+ *		-p 00:22:44:66:88:aa\n"
+ *		-p 192.168.1.1\n";
+ *
+ *
+ *	This program generates and transmits a Wake-On-LAN (WOL) "Magic Packet",
+ *	used for restarting machines that have been soft-powered-down
+ *	(ACPI D3-warm state).  It currently generates the standard AMD Magic Packet
+ *	format, with an optional password appended.
+ *
+ *	This software may be used and distributed according to the terms
+ *	of the GNU Public License, incorporated herein by reference.
+ *	Contact the author for use under other terms.
+ *
+ *	This source file was originally part of the network tricks package, and
+ *	is now distributed to support the Scyld Beowulf system.
+ *	Copyright 1999-2003 Donald Becker and Scyld Computing Corporation.
+ *
+ *	The author may be reached as becker@scyld, or C/O
+ *	 Scyld Computing Corporation
+ *	 914 Bay Ridge Road, Suite 220
+ *	 Annapolis MD 21403
+ *
+ *   Notes:
+ *   On some systems dropping root capability allows the process to be
+ *   dumped, traced or debugged.
+ *   If someone traces this program, they get control of a raw socket.
+ *   Linux handles this safely, but beware when porting this program.
+ *
+ *   An alternative to needing 'root' is using a UDP broadcast socket, however
+ *   doing so only works with adapters configured for unicast+broadcast Rx
+ *   filter.  That configuration consumes more power.
+*/
+
+
+#include <netpacket/packet.h>
+#include <net/ethernet.h>
+#include <netinet/ether.h>
+#include <linux/if.h>
+
+#include "busybox.h"
+
+/* Note: PF_INET, SOCK_DGRAM, IPPROTO_UDP would allow SIOCGIFHWADDR to
+ * work as non-root, but we need SOCK_PACKET to specify the Ethernet
+ * destination address.
+ */
+#ifdef PF_PACKET
+# define whereto_t sockaddr_ll
+# define make_socket() xsocket(PF_PACKET, SOCK_RAW, 0)
+#else
+# define whereto_t sockaddr
+# define make_socket() xsocket(AF_INET, SOCK_PACKET, SOCK_PACKET)
+#endif
+
+#ifdef DEBUG
+# define bb_debug_msg(fmt, args...) fprintf(stderr, fmt, ## args)
+void bb_debug_dump_packet(unsigned char *outpack, int pktsize)
+{
+	int i;
+	printf("packet dump:\n");
+	for (i = 0; i < pktsize; ++i) {
+		printf("%2.2x ", outpack[i]);
+		if (i % 20 == 19) puts("");
+	}
+	printf("\n\n");
+}
+#else
+# define bb_debug_msg(fmt, args...)
+# define bb_debug_dump_packet(outpack, pktsize)
+#endif
+
+static inline void get_dest_addr(const char *arg, struct ether_addr *eaddr);
+static inline int get_fill(unsigned char *pkt, struct ether_addr *eaddr, int broadcast);
+static inline int get_wol_pw(const char *ethoptarg, unsigned char *wol_passwd);
+
+int ether_wake_main(int argc, char *argv[])
+{
+	char *ifname = "eth0", *pass = NULL;
+	unsigned long flags;
+	unsigned char wol_passwd[6];
+	int wol_passwd_sz = 0;
+
+	int s;						/* Raw socket */
+	int pktsize;
+	unsigned char outpack[1000];
+
+	struct ether_addr eaddr;
+	struct whereto_t whereto;	/* who to wake up */
+
+	/* handle misc user options */
+	flags = getopt32(argc, argv, "bi:p:", &ifname, &pass);
+	if (optind == argc)
+		bb_show_usage();
+	if (pass)
+		wol_passwd_sz = get_wol_pw(pass, wol_passwd);
+
+	/* create the raw socket */
+	s = make_socket();
+
+	/* now that we have a raw socket we can drop root */
+	xsetuid(getuid());
+
+	/* look up the dest mac address */
+	get_dest_addr(argv[optind], &eaddr);
+
+	/* fill out the header of the packet */
+	pktsize = get_fill(outpack, &eaddr, flags /*& 1 [OPT_BROADCAST]*/);
+
+	bb_debug_dump_packet(outpack, pktsize);
+
+	/* Fill in the source address, if possible. */
+#ifdef __linux__
+	{
+		struct ifreq if_hwaddr;
+
+		strncpy(if_hwaddr.ifr_name, ifname, sizeof(if_hwaddr.ifr_name));
+		if (ioctl(s, SIOCGIFHWADDR, &if_hwaddr) < 0)
+			bb_perror_msg_and_die("SIOCGIFHWADDR on %s failed", ifname);
+
+		memcpy(outpack+6, if_hwaddr.ifr_hwaddr.sa_data, 6);
+
+# ifdef DEBUG
+		{
+			unsigned char *hwaddr = if_hwaddr.ifr_hwaddr.sa_data;
+			printf("The hardware address (SIOCGIFHWADDR) of %s is type %d  "
+				   "%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x\n\n", ifname,
+				   if_hwaddr.ifr_hwaddr.sa_family, hwaddr[0], hwaddr[1],
+				   hwaddr[2], hwaddr[3], hwaddr[4], hwaddr[5]);
+		}
+# endif
+	}
+#endif /* __linux__ */
+
+	bb_debug_dump_packet(outpack, pktsize);
+
+	/* append the password if specified */
+	if (wol_passwd_sz > 0) {
+		memcpy(outpack+pktsize, wol_passwd, wol_passwd_sz);
+		pktsize += wol_passwd_sz;
+	}
+
+	bb_debug_dump_packet(outpack, pktsize);
+
+	/* This is necessary for broadcasts to work */
+	if (flags /*& 1 [OPT_BROADCAST]*/) {
+		if (setsockopt_broadcast(s) < 0)
+			bb_perror_msg("SO_BROADCAST");
+	}
+
+#if defined(PF_PACKET)
+	{
+		struct ifreq ifr;
+		strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
+		if (ioctl(s, SIOCGIFINDEX, &ifr) == -1)
+			bb_perror_msg_and_die("SIOCGIFINDEX");
+		memset(&whereto, 0, sizeof(whereto));
+		whereto.sll_family = AF_PACKET;
+		whereto.sll_ifindex = ifr.ifr_ifindex;
+		/* The manual page incorrectly claims the address must be filled.
+		   We do so because the code may change to match the docs. */
+		whereto.sll_halen = ETH_ALEN;
+		memcpy(whereto.sll_addr, outpack, ETH_ALEN);
+	}
+#else
+	whereto.sa_family = 0;
+	strcpy(whereto.sa_data, ifname);
+#endif
+
+	if (sendto(s, outpack, pktsize, 0, (struct sockaddr *)&whereto, sizeof(whereto)) < 0)
+		bb_perror_msg(bb_msg_write_error);
+
+	close(s);
+
+	return EXIT_SUCCESS;
+}
+
+/* Convert the host ID string to a MAC address.
+ * The string may be a:
+ *    Host name
+ *    IP address string
+ *    MAC address string
+*/
+static inline void get_dest_addr(const char *hostid, struct ether_addr *eaddr)
+{
+	struct ether_addr *eap;
+
+	eap = ether_aton(hostid);
+	if (eap) {
+		*eaddr = *eap;
+		bb_debug_msg("The target station address is %s\n\n", ether_ntoa(eaddr));
+#if !defined(__UCLIBC__)
+	} else if (ether_hostton(hostid, eaddr) == 0) {
+		bb_debug_msg("Station address for hostname %s is %s\n\n", hostid, ether_ntoa(eaddr));
+#else
+# warning Need to implement ether_hostton() for uClibc
+#endif
+	} else
+		bb_show_usage();
+}
+
+static inline int get_fill(unsigned char *pkt, struct ether_addr *eaddr, int broadcast)
+{
+	int offset, i;
+	unsigned char *station_addr = eaddr->ether_addr_octet;
+
+	if (broadcast)
+		memset(pkt+0, 0xff, 6);
+	else
+		memcpy(pkt, station_addr, 6);
+	memcpy(pkt+6, station_addr, 6);
+	pkt[12] = 0x08;				/* Or 0x0806 for ARP, 0x8035 for RARP */
+	pkt[13] = 0x42;
+	offset = 14;
+
+	memset(pkt+offset, 0xff, 6);
+	offset += 6;
+
+	for (i = 0; i < 16; ++i) {
+		memcpy(pkt+offset, station_addr, 6);
+		offset += 6;
+	}
+
+	return offset;
+}
+
+static inline int get_wol_pw(const char *ethoptarg, unsigned char *wol_passwd)
+{
+	int passwd[6];
+	int byte_cnt, i;
+
+	/* handle MAC format */
+	byte_cnt = sscanf(ethoptarg, "%2x:%2x:%2x:%2x:%2x:%2x",
+	                  &passwd[0], &passwd[1], &passwd[2],
+	                  &passwd[3], &passwd[4], &passwd[5]);
+	/* handle IP format */
+	if (byte_cnt < 4)
+		byte_cnt = sscanf(ethoptarg, "%d.%d.%d.%d",
+		                  &passwd[0], &passwd[1], &passwd[2], &passwd[3]);
+	if (byte_cnt < 4) {
+		bb_error_msg("cannot read Wake-On-LAN pass");
+		return 0;
+	}
+
+	for (i = 0; i < byte_cnt; ++i)
+		wol_passwd[i] = passwd[i];
+
+	bb_debug_msg("password: %2.2x %2.2x %2.2x %2.2x (%d)\n\n",
+	             wol_passwd[0], wol_passwd[1], wol_passwd[2], wol_passwd[3],
+	             byte_cnt);
+
+	return byte_cnt;
+}
diff --git a/networking/fakeidentd.c b/networking/fakeidentd.c
new file mode 100644
index 0000000..04138cc
--- /dev/null
+++ b/networking/fakeidentd.c
@@ -0,0 +1,387 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * A fake identd server
+ *
+ * Adapted to busybox by Thomas Lundquist <thomasez@zelow.no>
+ * Original Author: Tomi Ollila <too@iki.fi>
+ *                  http://www.guru-group.fi/~too/sw/
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ */
+
+#include "busybox.h"
+#include <sys/syslog.h>
+#include <sys/uio.h>
+
+
+#define IDENT_PORT  113
+#define MAXCONNS    20
+#define MAXIDLETIME 45
+
+static const char ident_substr[] = " : USERID : UNIX : ";
+enum { ident_substr_len = sizeof(ident_substr) - 1 };
+#define PIDFILE "/var/run/identd.pid"
+
+/*
+ * We have to track the 'first connection socket' so that we
+ * don't go around closing file descriptors for non-clients.
+ *
+ * descriptor setup normally
+ *  0 = server socket
+ *  1 = syslog fd (hopefully -- otherwise this won't work)
+ *  2 = connection socket after detached from tty. standard error before that
+ *  3 - 2 + MAXCONNS = rest connection sockets
+ *
+ * To try to make sure that syslog fd is what is "requested", the that fd
+ * is closed before openlog() call.  It can only severely fail if fd 0
+ * is initially closed.
+ */
+#define FCS 2
+
+/*
+ * FD of the connection is always the index of the connection structure
+ * in `conns' array + FCS
+ */
+static struct {
+	char buf[20];
+	int len;
+	time_t lasttime;
+} conns[MAXCONNS];
+
+/* When using global variables, bind those at least to a structure. */
+static struct {
+	const char *identuser;
+	fd_set readfds;
+	int conncnt;
+} G;
+
+/*
+ * Prototypes
+ */
+static void reply(int s, char *buf);
+static void replyError(int s, char *buf);
+
+static const char *nobodystr = "nobody"; /* this needs to be declared like this */
+static char *bind_ip_address = "0.0.0.0";
+
+static void movefd(int from, int to)
+{
+	if (from != to) {
+		dup2(from, to);
+		close(from);
+	}
+}
+
+static void inetbind(void)
+{
+	int s, port;
+	struct sockaddr_in addr;
+	int len = sizeof(addr);
+	struct servent *se;
+
+	se = getservbyname("identd", "tcp");
+	port = IDENT_PORT;
+	if (se)
+		port = se->s_port;
+
+	s = xsocket(AF_INET, SOCK_STREAM, 0);
+
+	setsockopt_reuseaddr(s);
+
+	memset(&addr, 0, sizeof(addr));
+	addr.sin_addr.s_addr = inet_addr(bind_ip_address);
+	addr.sin_family = AF_INET;
+	addr.sin_port = htons(port);
+
+	xbind(s, (struct sockaddr *)&addr, len);
+	xlisten(s, 5);
+
+	movefd(s, 0);
+}
+
+static void handlexitsigs(int signum)
+{
+	if (unlink(PIDFILE) < 0)
+		close(open(PIDFILE, O_WRONLY|O_CREAT|O_TRUNC, 0644));
+	exit(0);
+}
+
+/* May succeed. If not, won't care. */
+static void writepid(uid_t nobody, uid_t nogrp)
+{
+	char buf[sizeof(int)*3 + 2];
+	int fd = open(PIDFILE, O_WRONLY|O_CREAT|O_TRUNC, 0664);
+
+	if (fd < 0)
+		return;
+
+	sprintf(buf, "%d\n", getpid());
+	write(fd, buf, strlen(buf));
+	fchown(fd, nobody, nogrp);
+	close(fd);
+
+	/* should this handle ILL, ... (see signal(7)) */
+	signal(SIGTERM, handlexitsigs);
+	signal(SIGINT,  handlexitsigs);
+	signal(SIGQUIT, handlexitsigs);
+}
+
+/* return 0 as parent, 1 as child */
+static int godaemon(void)
+{
+	uid_t nobody, nogrp;
+	struct passwd *pw;
+
+	switch (fork()) {
+	case -1:
+		bb_perror_msg_and_die("fork");
+
+	case 0:
+		pw = getpwnam(nobodystr);
+		if (pw == NULL)
+			bb_error_msg_and_die("cannot find uid/gid of user '%s'", nobodystr);
+		nobody = pw->pw_uid;
+		nogrp = pw->pw_gid;
+		writepid(nobody, nogrp);
+
+		close(0);
+		inetbind();
+		xsetgid(nogrp);
+		xsetuid(nobody);
+		close(1);
+		close(2);
+
+		signal(SIGHUP, SIG_IGN);
+		signal(SIGPIPE, SIG_IGN); /* connection closed when writing (raises ???) */
+
+		setsid();
+
+		return 1;
+	}
+
+	return 0;
+}
+
+static void deleteConn(int s)
+{
+	int i = s - FCS;
+
+	close(s);
+
+	G.conncnt--;
+
+	/*
+	 * Most of the time there is 0 connections. Most often that there
+	 * is connections, there is just one connection. When this one connection
+	 * closes, i == G.conncnt = 0 -> no copying.
+	 * When there is more than one connection, the oldest connections closes
+	 * earlier on average. When this happens, the code below starts copying
+	 * the connection structure w/ highest index to the place which which is
+	 * just deleted. This means that the connection structures are no longer
+	 * in chronological order. I'd quess this means that when there is more
+	 * than 1 connection, on average every other connection structure needs
+	 * to be copied over the time all these connections are deleted.
+	 */
+	if (i != G.conncnt) {
+		memcpy(&conns[i], &conns[G.conncnt], sizeof(conns[0]));
+		movefd(G.conncnt + FCS, s);
+	}
+
+	FD_CLR(G.conncnt + FCS, &G.readfds);
+}
+
+static int closeOldest(void)
+{
+	time_t min = conns[0].lasttime;
+	int idx = 0;
+	int i;
+
+	for (i = 1; i < MAXCONNS; i++)
+		if (conns[i].lasttime < min)
+			idx = i;
+
+	replyError(idx + FCS, "X-SERVER-TOO-BUSY");
+	close(idx + FCS);
+
+	return idx;
+}
+
+static int checkInput(char *buf, int len, int l)
+{
+	int i;
+	for (i = len; i < len + l; ++i)
+		if (buf[i] == '\n')
+			return 1;
+	return 0;
+}
+
+int fakeidentd_main(int argc, char **argv)
+{
+	/* This applet is an inetd-style daemon */
+	openlog(applet_name, 0, LOG_DAEMON);
+	logmode = LOGMODE_SYSLOG;
+
+	memset(conns, 0, sizeof(conns));
+	memset(&G, 0, sizeof(G));
+	FD_ZERO(&G.readfds);
+	FD_SET(0, &G.readfds);
+
+	/* handle -b <ip> parameter */
+	getopt32(argc, argv, "b:", &bind_ip_address);
+	/* handle optional REPLY STRING */
+	if (optind < argc)
+		G.identuser = argv[optind];
+	else
+		G.identuser = nobodystr;
+
+	/* daemonize and have the parent return */
+	if (godaemon() == 0)
+		return 0;
+
+	/* main loop where we process all events and never exit */
+	while (1) {
+	fd_set rfds = G.readfds;
+	struct timeval tv = { 15, 0 };
+	int i;
+	int tim = time(NULL);
+
+	select(G.conncnt + FCS, &rfds, NULL, NULL, G.conncnt? &tv: NULL);
+
+	for (i = G.conncnt - 1; i >= 0; i--) {
+		int s = i + FCS;
+
+		if (FD_ISSET(s, &rfds)) {
+			char *buf = conns[i].buf;
+			unsigned int len = conns[i].len;
+			unsigned int l;
+
+			if ((l = read(s, buf + len, sizeof(conns[0].buf) - len)) > 0) {
+				if (checkInput(buf, len, l)) {
+					reply(s, buf);
+					goto deleteconn;
+				} else if (len + l >= sizeof(conns[0].buf)) {
+					replyError(s, "X-INVALID-REQUEST");
+					goto deleteconn;
+				} else {
+					conns[i].len += l;
+				}
+			} else {
+				goto deleteconn;
+			}
+
+			conns[i].lasttime = tim;
+			continue;
+
+deleteconn:
+			deleteConn(s);
+		} else {
+			/* implement as time_after() in linux kernel sources ... */
+			if (conns[i].lasttime + MAXIDLETIME <= tim) {
+				replyError(s, "X-TIMEOUT");
+				deleteConn(s);
+			}
+		}
+	}
+
+	if (FD_ISSET(0, &rfds)) {
+		int s = accept(0, NULL, 0);
+
+		if (s < 0) {
+			if (errno != EINTR) /* EINTR */
+				bb_perror_msg("accept");
+		} else {
+			if (G.conncnt == MAXCONNS)
+				i = closeOldest();
+			else
+				i = G.conncnt++;
+
+			movefd(s, i + FCS); /* move if not already there */
+			FD_SET(i + FCS, &G.readfds);
+
+			conns[i].len = 0;
+			conns[i].lasttime = time(NULL);
+		}
+	}
+	} /* end of while(1) */
+
+	return 0;
+}
+
+static int parseAddrs(char *ptr, char **myaddr, char **heraddr);
+static void reply(int s, char *buf)
+{
+	char *myaddr, *heraddr;
+
+	myaddr = heraddr = NULL;
+
+	if (parseAddrs(buf, &myaddr, &heraddr))
+		replyError(s, "X-INVALID-REQUEST");
+	else {
+		struct iovec iv[6];
+		iv[0].iov_base = myaddr;               iv[0].iov_len = strlen(myaddr);
+		iv[1].iov_base = ", ";                 iv[1].iov_len = 2;
+		iv[2].iov_base = heraddr;              iv[2].iov_len = strlen(heraddr);
+		iv[3].iov_base = (void *)ident_substr; iv[3].iov_len = ident_substr_len;
+		iv[4].iov_base = (void *)G.identuser;  iv[4].iov_len = strlen(G.identuser);
+		iv[5].iov_base = "\r\n";               iv[5].iov_len = 2;
+		writev(s, iv, 6);
+	}
+}
+
+static void replyError(int s, char *buf)
+{
+	struct iovec iv[3];
+	iv[0].iov_base = "0, 0 : ERROR : ";   iv[0].iov_len = 15;
+	iv[1].iov_base = buf;                 iv[1].iov_len = strlen(buf);
+	iv[2].iov_base = "\r\n";              iv[2].iov_len = 2;
+	writev(s, iv, 3);
+}
+
+static int chmatch(char c, char *chars)
+{
+	for (; *chars; chars++)
+		if (c == *chars)
+			return 1;
+	return 0;
+}
+
+static int skipchars(char **p, char *chars)
+{
+	while (chmatch(**p, chars))
+		(*p)++;
+	if (**p == '\r' || **p == '\n')
+		return 0;
+	return 1;
+}
+
+static int parseAddrs(char *ptr, char **myaddr, char **heraddr)
+{
+	/* parse <port-on-server> , <port-on-client> */
+
+	if (!skipchars(&ptr, " \t"))
+		return -1;
+
+	*myaddr = ptr;
+
+	if (!skipchars(&ptr, "1234567890"))
+		return -1;
+
+	if (!chmatch(*ptr, " \t,"))
+		return -1;
+
+	*ptr++ = '\0';
+
+	if (!skipchars(&ptr, " \t,") )
+		return -1;
+
+	*heraddr = ptr;
+
+	skipchars(&ptr, "1234567890");
+
+	if (!chmatch(*ptr, " \n\r"))
+		return -1;
+
+	*ptr = '\0';
+
+	return 0;
+}
diff --git a/networking/ftpgetput.c b/networking/ftpgetput.c
new file mode 100644
index 0000000..223d243
--- /dev/null
+++ b/networking/ftpgetput.c
@@ -0,0 +1,340 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * ftpget
+ *
+ * Mini implementation of FTP to retrieve a remote file.
+ *
+ * Copyright (C) 2002 Jeff Angielski, The PTR Group <jeff@theptrgroup.com>
+ * Copyright (C) 2002 Glenn McGrath <bug1@iinet.net.au>
+ *
+ * Based on wget.c by Chip Rosenthal Covad Communications
+ * <chip@laserlink.net>
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ */
+
+#include "busybox.h"
+#include <getopt.h>
+
+typedef struct ftp_host_info_s {
+	char *user;
+	char *password;
+	struct sockaddr_in *s_in;
+} ftp_host_info_t;
+
+static char verbose_flag = 0;
+static char do_continue = 0;
+
+static int ftpcmd(const char *s1, const char *s2, FILE *stream, char *buf)
+{
+	if (verbose_flag) {
+		bb_error_msg("cmd %s%s", s1, s2);
+	}
+
+	if (s1) {
+		if (s2) {
+			fprintf(stream, "%s%s\r\n", s1, s2);
+		} else {
+			fprintf(stream, "%s\r\n", s1);
+		}
+	}
+	do {
+		char *buf_ptr;
+
+		if (fgets(buf, 510, stream) == NULL) {
+			bb_perror_msg_and_die("fgets");
+		}
+		buf_ptr = strstr(buf, "\r\n");
+		if (buf_ptr) {
+			*buf_ptr = '\0';
+		}
+	} while (!isdigit(buf[0]) || buf[3] != ' ');
+
+	return xatou(buf);
+}
+
+static int xconnect_ftpdata(ftp_host_info_t *server, const char *buf)
+{
+	char *buf_ptr;
+	unsigned short port_num;
+
+	buf_ptr = strrchr(buf, ',');
+	*buf_ptr = '\0';
+	port_num = xatoul_range(buf_ptr + 1, 0, 255);
+
+	buf_ptr = strrchr(buf, ',');
+	*buf_ptr = '\0';
+	port_num += xatoul_range(buf_ptr + 1, 0, 255) * 256;
+
+	server->s_in->sin_port = htons(port_num);
+	return xconnect_tcp_v4(server->s_in);
+}
+
+static FILE *ftp_login(ftp_host_info_t *server)
+{
+	FILE *control_stream;
+	char buf[512];
+
+	/* Connect to the command socket */
+	control_stream = fdopen(xconnect_tcp_v4(server->s_in), "r+");
+	if (control_stream == NULL) {
+		bb_perror_msg_and_die("cannot open control stream");
+	}
+
+	if (ftpcmd(NULL, NULL, control_stream, buf) != 220) {
+		bb_error_msg_and_die("%s", buf + 4);
+	}
+
+	/*  Login to the server */
+	switch (ftpcmd("USER ", server->user, control_stream, buf)) {
+	case 230:
+		break;
+	case 331:
+		if (ftpcmd("PASS ", server->password, control_stream, buf) != 230) {
+			bb_error_msg_and_die("PASS error: %s", buf + 4);
+		}
+		break;
+	default:
+		bb_error_msg_and_die("USER error: %s", buf + 4);
+	}
+
+	ftpcmd("TYPE I", NULL, control_stream, buf);
+
+	return control_stream;
+}
+
+#if !ENABLE_FTPGET
+int ftp_receive(ftp_host_info_t *server, FILE *control_stream,
+		const char *local_path, char *server_path);
+#else
+static
+int ftp_receive(ftp_host_info_t *server, FILE *control_stream,
+		const char *local_path, char *server_path)
+{
+	char buf[512];
+	off_t filesize = 0;
+	int fd_data;
+	int fd_local = -1;
+	off_t beg_range = 0;
+
+	/* Connect to the data socket */
+	if (ftpcmd("PASV", NULL, control_stream, buf) != 227) {
+		bb_error_msg_and_die("PASV error: %s", buf + 4);
+	}
+	fd_data = xconnect_ftpdata(server, buf);
+
+	if (ftpcmd("SIZE ", server_path, control_stream, buf) == 213) {
+		filesize = BB_STRTOOFF(buf + 4, NULL, 10);
+		if (errno || filesize < 0)
+			bb_error_msg_and_die("SIZE error: %s", buf + 4);
+	} else {
+		filesize = -1;
+		do_continue = 0;
+	}
+
+	if ((local_path[0] == '-') && (local_path[1] == '\0')) {
+		fd_local = STDOUT_FILENO;
+		do_continue = 0;
+	}
+
+	if (do_continue) {
+		struct stat sbuf;
+		if (lstat(local_path, &sbuf) < 0) {
+			bb_perror_msg_and_die("lstat");
+		}
+		if (sbuf.st_size > 0) {
+			beg_range = sbuf.st_size;
+		} else {
+			do_continue = 0;
+		}
+	}
+
+	if (do_continue) {
+		sprintf(buf, "REST %"OFF_FMT"d", beg_range);
+		if (ftpcmd(buf, NULL, control_stream, buf) != 350) {
+			do_continue = 0;
+		} else {
+			filesize -= beg_range;
+		}
+	}
+
+	if (ftpcmd("RETR ", server_path, control_stream, buf) > 150) {
+		bb_error_msg_and_die("RETR error: %s", buf + 4);
+	}
+
+	/* only make a local file if we know that one exists on the remote server */
+	if (fd_local == -1) {
+		if (do_continue) {
+			fd_local = xopen(local_path, O_APPEND | O_WRONLY);
+		} else {
+			fd_local = xopen(local_path, O_CREAT | O_TRUNC | O_WRONLY);
+		}
+	}
+
+	/* Copy the file */
+	if (filesize != -1) {
+		if (-1 == bb_copyfd_size(fd_data, fd_local, filesize))
+			exit(EXIT_FAILURE);
+	} else {
+		if (-1 == bb_copyfd_eof(fd_data, fd_local))
+			exit(EXIT_FAILURE);
+	}
+
+	/* close it all down */
+	close(fd_data);
+	if (ftpcmd(NULL, NULL, control_stream, buf) != 226) {
+		bb_error_msg_and_die("ftp error: %s", buf + 4);
+	}
+	ftpcmd("QUIT", NULL, control_stream, buf);
+
+	return EXIT_SUCCESS;
+}
+#endif
+
+#if !ENABLE_FTPPUT
+int ftp_send(ftp_host_info_t *server, FILE *control_stream,
+		const char *server_path, char *local_path);
+#else
+static
+int ftp_send(ftp_host_info_t *server, FILE *control_stream,
+		const char *server_path, char *local_path)
+{
+	struct stat sbuf;
+	char buf[512];
+	int fd_data;
+	int fd_local;
+	int response;
+
+	/*  Connect to the data socket */
+	if (ftpcmd("PASV", NULL, control_stream, buf) != 227) {
+		bb_error_msg_and_die("PASV error: %s", buf + 4);
+	}
+	fd_data = xconnect_ftpdata(server, buf);
+
+	/* get the local file */
+	if ((local_path[0] == '-') && (local_path[1] == '\0')) {
+		fd_local = STDIN_FILENO;
+	} else {
+		fd_local = xopen(local_path, O_RDONLY);
+		fstat(fd_local, &sbuf);
+
+		sprintf(buf, "ALLO %lu", (unsigned long)sbuf.st_size);
+		response = ftpcmd(buf, NULL, control_stream, buf);
+		switch (response) {
+		case 200:
+		case 202:
+			break;
+		default:
+			close(fd_local);
+			bb_error_msg_and_die("ALLO error: %s", buf + 4);
+			break;
+		}
+	}
+	response = ftpcmd("STOR ", server_path, control_stream, buf);
+	switch (response) {
+	case 125:
+	case 150:
+		break;
+	default:
+		close(fd_local);
+		bb_error_msg_and_die("STOR error: %s", buf + 4);
+	}
+
+	/* transfer the file  */
+	if (bb_copyfd_eof(fd_local, fd_data) == -1) {
+		exit(EXIT_FAILURE);
+	}
+
+	/* close it all down */
+	close(fd_data);
+	if (ftpcmd(NULL, NULL, control_stream, buf) != 226) {
+		bb_error_msg_and_die("error: %s", buf + 4);
+	}
+	ftpcmd("QUIT", NULL, control_stream, buf);
+
+	return EXIT_SUCCESS;
+}
+#endif
+
+#define FTPGETPUT_OPT_CONTINUE	1
+#define FTPGETPUT_OPT_VERBOSE	2
+#define FTPGETPUT_OPT_USER	4
+#define FTPGETPUT_OPT_PASSWORD	8
+#define FTPGETPUT_OPT_PORT	16
+
+#if ENABLE_FEATURE_FTPGETPUT_LONG_OPTIONS
+static const struct option ftpgetput_long_options[] = {
+	{ "continue", 1, NULL, 'c' },
+	{ "verbose", 0, NULL, 'v' },
+	{ "username", 1, NULL, 'u' },
+	{ "password", 1, NULL, 'p' },
+	{ "port", 1, NULL, 'P' },
+	{ 0, 0, 0, 0 }
+};
+#endif
+
+int ftpgetput_main(int argc, char **argv)
+{
+	/* content-length of the file */
+	unsigned opt;
+	char *port = "ftp";
+
+	/* socket to ftp server */
+	FILE *control_stream;
+	struct sockaddr_in s_in;
+
+	/* continue a prev transfer (-c) */
+	ftp_host_info_t *server;
+
+	int (*ftp_action)(ftp_host_info_t *, FILE *, const char *, char *) = NULL;
+
+	/* Check to see if the command is ftpget or ftput */
+	if (ENABLE_FTPPUT && (!ENABLE_FTPGET || applet_name[3] == 'p')) {
+		ftp_action = ftp_send;
+	}
+	if (ENABLE_FTPGET && (!ENABLE_FTPPUT || applet_name[3] == 'g')) {
+		ftp_action = ftp_receive;
+	}
+
+	/* Set default values */
+	server = xmalloc(sizeof(ftp_host_info_t));
+	server->user = "anonymous";
+	server->password = "busybox@";
+	verbose_flag = 0;
+
+	/*
+	 * Decipher the command line
+	 */
+#if ENABLE_FEATURE_FTPGETPUT_LONG_OPTIONS
+	applet_long_options = ftpgetput_long_options;
+#endif
+	opt = getopt32(argc, argv, "cvu:p:P:", &server->user, &server->password, &port);
+
+	/* Process the non-option command line arguments */
+	if (argc - optind != 3) {
+		bb_show_usage();
+	}
+
+	if (opt & FTPGETPUT_OPT_CONTINUE) {
+		do_continue = 1;
+	}
+	if (opt & FTPGETPUT_OPT_VERBOSE) {
+		verbose_flag = 1;
+	}
+
+	/* We want to do exactly _one_ DNS lookup, since some
+	 * sites (i.e. ftp.us.debian.org) use round-robin DNS
+	 * and we want to connect to only one IP... */
+	server->s_in = &s_in;
+	bb_lookup_host(&s_in, argv[optind]);
+	s_in.sin_port = bb_lookup_port(port, "tcp", 21);
+	if (verbose_flag) {
+		printf("Connecting to %s[%s]:%d\n",
+				argv[optind], inet_ntoa(s_in.sin_addr), ntohs(s_in.sin_port));
+	}
+
+	/*  Connect/Setup/Configure the FTP session */
+	control_stream = ftp_login(server);
+
+	return ftp_action(server, control_stream, argv[optind + 1], argv[optind + 2]);
+}
diff --git a/networking/hostname.c b/networking/hostname.c
new file mode 100644
index 0000000..4fe28d7
--- /dev/null
+++ b/networking/hostname.c
@@ -0,0 +1,102 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * $Id: hostname.c,v 1.36 2003/07/14 21:21:01 andersen Exp $
+ * Mini hostname implementation for busybox
+ *
+ * Copyright (C) 1999 by Randolph Chung <tausq@debian.org>
+ *
+ * adjusted by Erik Andersen <andersen@codepoet.org> to remove
+ * use of long options and GNU getopt.  Improved the usage info.
+ *
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ */
+
+#include "busybox.h"
+
+static void do_sethostname(char *s, int isfile)
+{
+	FILE *f;
+	char buf[256];
+
+	if (!s)
+		return;
+	if (!isfile) {
+		if (sethostname(s, strlen(s)) < 0) {
+			if (errno == EPERM)
+				bb_error_msg_and_die("you must be root to change the hostname");
+			else
+				bb_perror_msg_and_die("sethostname");
+		}
+	} else {
+		f = xfopen(s, "r");
+		while (fgets(buf, sizeof(buf), f) != NULL) {
+			if (buf[0] =='#') {
+				continue;
+			}
+			chomp(buf);
+			do_sethostname(buf, 0);
+		}
+#ifdef CONFIG_FEATURE_CLEAN_UP
+		fclose(f);
+#endif
+	}
+}
+
+int hostname_main(int argc, char **argv)
+{
+	enum {
+		OPT_d = 0x1,
+		OPT_f = 0x2,
+		OPT_i = 0x4,
+		OPT_s = 0x8,
+		OPT_dfis = 0xf,
+	};
+
+	char buf[256];
+	unsigned opt;
+	char *hostname_str = NULL;
+
+	if (argc < 1)
+		bb_show_usage();
+
+	opt = getopt32(argc, argv, "dfisF:", &hostname_str);
+
+	/* Output in desired format */
+	if (opt & OPT_dfis) {
+		struct hostent *hp;
+		char *p;
+		gethostname(buf, sizeof(buf));
+		hp = xgethostbyname(buf);
+		p = strchr(hp->h_name, '.');
+		if (opt & OPT_f) {
+			puts(hp->h_name);
+		} else if (opt & OPT_s) {
+			if (p != NULL) {
+				*p = 0;
+			}
+			puts(hp->h_name);
+		} else if (opt & OPT_d) {
+			if (p) puts(p + 1);
+		} else if (opt & OPT_i) {
+			while (hp->h_addr_list[0]) {
+				printf("%s ", inet_ntoa(*(struct in_addr *) (*hp->h_addr_list++)));
+			}
+			puts("");
+		}
+	}
+	/* Set the hostname */
+	else if (hostname_str != NULL) {
+		do_sethostname(hostname_str, 1);
+	} else if (optind < argc) {
+		do_sethostname(argv[optind], 0);
+	}
+	/* Or if all else fails,
+	 * just print the current hostname */
+	else {
+		gethostname(buf, sizeof(buf));
+		puts(buf);
+	}
+	return 0;
+}
diff --git a/networking/httpd.c b/networking/httpd.c
new file mode 100644
index 0000000..49c2c76
--- /dev/null
+++ b/networking/httpd.c
@@ -0,0 +1,1970 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * httpd implementation for busybox
+ *
+ * Copyright (C) 2002,2003 Glenn Engel <glenne@engel.org>
+ * Copyright (C) 2003-2006 Vladimir Oleynik <dzo@simtreas.ru>
+ *
+ * simplify patch stolen from libbb without using strdup
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ *
+ *****************************************************************************
+ *
+ * Typical usage:
+ *   for non root user
+ * httpd -p 8080 -h $HOME/public_html
+ *   or for daemon start from rc script with uid=0:
+ * httpd -u www
+ * This is equivalent if www user have uid=80 to
+ * httpd -p 80 -u 80 -h /www -c /etc/httpd.conf -r "Web Server Authentication"
+ *
+ *
+ * When a url contains "cgi-bin" it is assumed to be a cgi script.  The
+ * server changes directory to the location of the script and executes it
+ * after setting QUERY_STRING and other environment variables.
+ *
+ * Doc:
+ * "CGI Environment Variables": http://hoohoo.ncsa.uiuc.edu/cgi/env.html
+ *
+ * The server can also be invoked as a url arg decoder and html text encoder
+ * as follows:
+ *  foo=`httpd -d $foo`           # decode "Hello%20World" as "Hello World"
+ *  bar=`httpd -e "<Hello World>"`  # encode as "&#60Hello&#32World&#62"
+ * Note that url encoding for arguments is not the same as html encoding for
+ * presentation.  -d decodes a url-encoded argument while -e encodes in html
+ * for page display.
+ *
+ * httpd.conf has the following format:
+ *
+ * A:172.20.         # Allow address from 172.20.0.0/16
+ * A:10.0.0.0/25     # Allow any address from 10.0.0.0-10.0.0.127
+ * A:10.0.0.0/255.255.255.128  # Allow any address that previous set
+ * A:127.0.0.1       # Allow local loopback connections
+ * D:*               # Deny from other IP connections
+ * /cgi-bin:foo:bar  # Require user foo, pwd bar on urls starting with /cgi-bin/
+ * /adm:admin:setup  # Require user admin, pwd setup on urls starting with /adm/
+ * /adm:toor:PaSsWd  # or user toor, pwd PaSsWd on urls starting with /adm/
+ * .au:audio/basic   # additional mime type for audio.au files
+ * *.php:/path/php   # running cgi.php scripts through an interpreter
+ *
+ * A/D may be as a/d or allow/deny - first char case insensitive
+ * Deny IP rules take precedence over allow rules.
+ *
+ *
+ * The Deny/Allow IP logic:
+ *
+ *  - Default is to allow all.  No addresses are denied unless
+ *         denied with a D: rule.
+ *  - Order of Deny/Allow rules is significant
+ *  - Deny rules take precedence over allow rules.
+ *  - If a deny all rule (D:*) is used it acts as a catch-all for unmatched
+ *       addresses.
+ *  - Specification of Allow all (A:*) is a no-op
+ *
+ * Example:
+ *   1. Allow only specified addresses
+ *     A:172.20          # Allow any address that begins with 172.20.
+ *     A:10.10.          # Allow any address that begins with 10.10.
+ *     A:127.0.0.1       # Allow local loopback connections
+ *     D:*               # Deny from other IP connections
+ *
+ *   2. Only deny specified addresses
+ *     D:1.2.3.        # deny from 1.2.3.0 - 1.2.3.255
+ *     D:2.3.4.        # deny from 2.3.4.0 - 2.3.4.255
+ *     A:*             # (optional line added for clarity)
+ *
+ * If a sub directory contains a config file it is parsed and merged with
+ * any existing settings as if it was appended to the original configuration.
+ *
+ * subdir paths are relative to the containing subdir and thus cannot
+ * affect the parent rules.
+ *
+ * Note that since the sub dir is parsed in the forked thread servicing the
+ * subdir http request, any merge is discarded when the process exits.  As a
+ * result, the subdir settings only have a lifetime of a single request.
+ *
+ *
+ * If -c is not set, an attempt will be made to open the default
+ * root configuration file.  If -c is set and the file is not found, the
+ * server exits with an error.
+ *
+*/
+
+
+#include "busybox.h"
+
+
+static const char httpdVersion[] = "busybox httpd/1.35 6-Oct-2004";
+static const char default_path_httpd_conf[] = "/etc";
+static const char httpd_conf[] = "httpd.conf";
+static const char home[] = "./";
+
+#define TIMEOUT 60
+
+// Note: busybox xfuncs are not used because we want the server to keep running
+//       if something bad happens due to a malformed user request.
+//       As a result, all memory allocation after daemonize
+//       is checked rigorously
+
+//#define DEBUG 1
+
+#ifndef DEBUG
+# define DEBUG 0
+#endif
+
+#define MAX_MEMORY_BUFF 8192    /* IO buffer */
+
+typedef struct HT_ACCESS {
+	char *after_colon;
+	struct HT_ACCESS *next;
+	char before_colon[1];         /* really bigger, must last */
+} Htaccess;
+
+typedef struct HT_ACCESS_IP {
+	unsigned int ip;
+	unsigned int mask;
+	int allow_deny;
+	struct HT_ACCESS_IP *next;
+} Htaccess_IP;
+
+typedef struct {
+	char buf[MAX_MEMORY_BUFF];
+
+	USE_FEATURE_HTTPD_BASIC_AUTH(const char *realm;)
+	USE_FEATURE_HTTPD_BASIC_AUTH(char *remoteuser;)
+
+	const char *query;
+
+	USE_FEATURE_HTTPD_CGI(char *referer;)
+
+	const char *configFile;
+
+	unsigned int rmt_ip;
+#if ENABLE_FEATURE_HTTPD_CGI || DEBUG
+	char rmt_ip_str[16];     /* for set env REMOTE_ADDR */
+#endif
+	unsigned port;           /* server initial port and for
+						      set env REMOTE_PORT */
+	const char *found_mime_type;
+	const char *found_moved_temporarily;
+
+	off_t ContentLength;          /* -1 - unknown */
+	time_t last_mod;
+
+	Htaccess_IP *ip_a_d;          /* config allow/deny lines */
+	int flg_deny_all;
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
+	Htaccess *auth;               /* config user:password lines */
+#endif
+#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES
+	Htaccess *mime_a;             /* config mime types */
+#endif
+
+	int server_socket;
+	int accepted_socket;
+	volatile int alarm_signaled;
+
+#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
+	Htaccess *script_i;           /* config script interpreters */
+#endif
+} HttpdConfig;
+
+static HttpdConfig *config;
+
+static const char request_GET[] = "GET";    /* size algorithmic optimize */
+
+static const char* const suffixTable [] = {
+/* Warning: shorted equivalent suffix in one line must be first */
+	".htm.html", "text/html",
+	".jpg.jpeg", "image/jpeg",
+	".gif", "image/gif",
+	".png", "image/png",
+	".txt.h.c.cc.cpp", "text/plain",
+	".css", "text/css",
+	".wav", "audio/wav",
+	".avi", "video/x-msvideo",
+	".qt.mov", "video/quicktime",
+	".mpe.mpeg", "video/mpeg",
+	".mid.midi", "audio/midi",
+	".mp3", "audio/mpeg",
+#if 0                        /* unpopular */
+	".au", "audio/basic",
+	".pac", "application/x-ns-proxy-autoconfig",
+	".vrml.wrl", "model/vrml",
+#endif
+	0, "application/octet-stream" /* default */
+};
+
+typedef enum {
+	HTTP_OK = 200,
+	HTTP_MOVED_TEMPORARILY = 302,
+	HTTP_BAD_REQUEST = 400,       /* malformed syntax */
+	HTTP_UNAUTHORIZED = 401, /* authentication needed, respond with auth hdr */
+	HTTP_NOT_FOUND = 404,
+	HTTP_FORBIDDEN = 403,
+	HTTP_REQUEST_TIMEOUT = 408,
+	HTTP_NOT_IMPLEMENTED = 501,   /* used for unrecognized requests */
+	HTTP_INTERNAL_SERVER_ERROR = 500,
+#if 0 /* future use */
+	HTTP_CONTINUE = 100,
+	HTTP_SWITCHING_PROTOCOLS = 101,
+	HTTP_CREATED = 201,
+	HTTP_ACCEPTED = 202,
+	HTTP_NON_AUTHORITATIVE_INFO = 203,
+	HTTP_NO_CONTENT = 204,
+	HTTP_MULTIPLE_CHOICES = 300,
+	HTTP_MOVED_PERMANENTLY = 301,
+	HTTP_NOT_MODIFIED = 304,
+	HTTP_PAYMENT_REQUIRED = 402,
+	HTTP_BAD_GATEWAY = 502,
+	HTTP_SERVICE_UNAVAILABLE = 503, /* overload, maintenance */
+	HTTP_RESPONSE_SETSIZE = 0xffffffff
+#endif
+} HttpResponseNum;
+
+typedef struct {
+	HttpResponseNum type;
+	const char *name;
+	const char *info;
+} HttpEnumString;
+
+static const HttpEnumString httpResponseNames[] = {
+	{ HTTP_OK, "OK", NULL },
+	{ HTTP_MOVED_TEMPORARILY, "Found", "Directories must end with a slash." },
+	{ HTTP_REQUEST_TIMEOUT, "Request Timeout",
+		"No request appeared within a reasonable time period." },
+	{ HTTP_NOT_IMPLEMENTED, "Not Implemented",
+		"The requested method is not recognized by this server." },
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
+	{ HTTP_UNAUTHORIZED, "Unauthorized", "" },
+#endif
+	{ HTTP_NOT_FOUND, "Not Found",
+		"The requested URL was not found on this server." },
+	{ HTTP_BAD_REQUEST, "Bad Request", "Unsupported method." },
+	{ HTTP_FORBIDDEN, "Forbidden", "" },
+	{ HTTP_INTERNAL_SERVER_ERROR, "Internal Server Error",
+		"Internal Server Error" },
+#if 0                               /* not implemented */
+	{ HTTP_CREATED, "Created" },
+	{ HTTP_ACCEPTED, "Accepted" },
+	{ HTTP_NO_CONTENT, "No Content" },
+	{ HTTP_MULTIPLE_CHOICES, "Multiple Choices" },
+	{ HTTP_MOVED_PERMANENTLY, "Moved Permanently" },
+	{ HTTP_NOT_MODIFIED, "Not Modified" },
+	{ HTTP_BAD_GATEWAY, "Bad Gateway", "" },
+	{ HTTP_SERVICE_UNAVAILABLE, "Service Unavailable", "" },
+#endif
+};
+
+
+static const char RFC1123FMT[] = "%a, %d %b %Y %H:%M:%S GMT";
+
+
+#define STRNCASECMP(a, str) strncasecmp((a), (str), sizeof(str)-1)
+
+
+static int scan_ip(const char **ep, unsigned int *ip, unsigned char endc)
+{
+	const char *p = *ep;
+	int auto_mask = 8;
+	int j;
+
+	*ip = 0;
+	for (j = 0; j < 4; j++) {
+		unsigned int octet;
+
+		if ((*p < '0' || *p > '9') && (*p != '/' || j == 0) && *p != 0)
+			return -auto_mask;
+		octet = 0;
+		while (*p >= '0' && *p <= '9') {
+			octet *= 10;
+			octet += *p - '0';
+			if (octet > 255)
+				return -auto_mask;
+			p++;
+		}
+		if (*p == '.')
+			p++;
+		if (*p != '/' && *p != 0)
+			auto_mask += 8;
+		*ip = ((*ip) << 8) | octet;
+	}
+	if (*p != 0) {
+		if (*p != endc)
+			return -auto_mask;
+		p++;
+		if (*p == 0)
+			return -auto_mask;
+	}
+	*ep = p;
+	return auto_mask;
+}
+
+static int scan_ip_mask(const char *ipm, unsigned int *ip, unsigned int *mask)
+{
+	int i;
+	unsigned int msk;
+
+	i = scan_ip(&ipm, ip, '/');
+	if (i < 0)
+		return i;
+	if (*ipm) {
+		const char *p = ipm;
+
+		i = 0;
+		while (*p) {
+			if (*p < '0' || *p > '9') {
+				if (*p == '.') {
+					i = scan_ip(&ipm, mask, 0);
+					return i != 32;
+				}
+				return -1;
+			}
+			i *= 10;
+			i += *p - '0';
+			p++;
+		}
+	}
+	if (i > 32 || i < 0)
+		return -1;
+	msk = 0x80000000;
+	*mask = 0;
+	while (i > 0) {
+		*mask |= msk;
+		msk >>= 1;
+		i--;
+	}
+	return 0;
+}
+
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH || ENABLE_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES
+static void free_config_lines(Htaccess **pprev)
+{
+	Htaccess *prev = *pprev;
+
+	while (prev) {
+		Htaccess *cur = prev;
+
+		prev = cur->next;
+		free(cur);
+	}
+	*pprev = NULL;
+}
+#endif
+
+/* flag */
+#define FIRST_PARSE          0
+#define SUBDIR_PARSE         1
+#define SIGNALED_PARSE       2
+#define FIND_FROM_HTTPD_ROOT 3
+/****************************************************************************
+ *
+ > $Function: parse_conf()
+ *
+ * $Description: parse configuration file into in-memory linked list.
+ *
+ * The first non-white character is examined to determine if the config line
+ * is one of the following:
+ *    .ext:mime/type   # new mime type not compiled into httpd
+ *    [adAD]:from      # ip address allow/deny, * for wildcard
+ *    /path:user:pass  # username/password
+ *
+ * Any previous IP rules are discarded.
+ * If the flag argument is not SUBDIR_PARSE then all /path and mime rules
+ * are also discarded.  That is, previous settings are retained if flag is
+ * SUBDIR_PARSE.
+ *
+ * $Parameters:
+ *      (const char *) path . . null for ip address checks, path for password
+ *                              checks.
+ *      (int) flag  . . . . . . the source of the parse request.
+ *
+ * $Return: (None)
+ *
+ ****************************************************************************/
+static void parse_conf(const char *path, int flag)
+{
+	FILE *f;
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
+	Htaccess *prev, *cur;
+#elif ENABLE_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES
+	Htaccess *cur;
+#endif
+
+	const char *cf = config->configFile;
+	char buf[160];
+	char *p0 = NULL;
+	char *c, *p;
+
+	/* free previous ip setup if present */
+	Htaccess_IP *pip = config->ip_a_d;
+
+	while (pip) {
+		Htaccess_IP *cur_ipl = pip;
+
+		pip = cur_ipl->next;
+		free(cur_ipl);
+	}
+	config->ip_a_d = NULL;
+
+	config->flg_deny_all = 0;
+
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH || ENABLE_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES || ENABLE_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
+	/* retain previous auth and mime config only for subdir parse */
+	if (flag != SUBDIR_PARSE) {
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
+		free_config_lines(&config->auth);
+#endif
+#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES
+		free_config_lines(&config->mime_a);
+#endif
+#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
+		free_config_lines(&config->script_i);
+#endif
+	}
+#endif
+
+	if (flag == SUBDIR_PARSE || cf == NULL) {
+		cf = alloca(strlen(path) + sizeof(httpd_conf) + 2);
+		if (cf == NULL) {
+			if (flag == FIRST_PARSE)
+			bb_error_msg_and_die(bb_msg_memory_exhausted);
+			return;
+		}
+		sprintf((char *)cf, "%s/%s", path, httpd_conf);
+	}
+
+	while ((f = fopen(cf, "r")) == NULL) {
+		if (flag == SUBDIR_PARSE || flag == FIND_FROM_HTTPD_ROOT) {
+			/* config file not found, no changes to config */
+			return;
+		}
+		if (config->configFile && flag == FIRST_PARSE) /* if -c option given */
+			bb_perror_msg_and_die("%s", cf);
+		flag = FIND_FROM_HTTPD_ROOT;
+		cf = httpd_conf;
+	}
+
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
+		prev = config->auth;
+#endif
+		/* This could stand some work */
+	while ((p0 = fgets(buf, sizeof(buf), f)) != NULL) {
+		c = NULL;
+		for (p = p0; *p0 != 0 && *p0 != '#'; p0++) {
+			if (!isspace(*p0)) {
+				*p++ = *p0;
+				if (*p0 == ':' && c == NULL)
+				c = p;
+			}
+		}
+		*p = 0;
+
+		/* test for empty or strange line */
+		if (c == NULL || *c == 0)
+			continue;
+		p0 = buf;
+		if (*p0 == 'd')
+				*p0 = 'D';
+		if (*c == '*') {
+			if (*p0 == 'D') {
+				/* memorize deny all */
+				config->flg_deny_all++;
+			}
+			/* skip default other "word:*" config lines */
+			continue;
+		}
+
+		if (*p0 == 'a')
+			*p0 = 'A';
+		else if (*p0 != 'D' && *p0 != 'A'
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
+			 && *p0 != '/'
+#endif
+#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES
+			 && *p0 != '.'
+#endif
+#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
+			 && *p0 != '*'
+#endif
+			)
+			 continue;
+		if (*p0 == 'A' || *p0 == 'D') {
+			/* storing current config IP line */
+			pip = calloc(1, sizeof(Htaccess_IP));
+			if (pip) {
+				if (scan_ip_mask(c, &(pip->ip), &(pip->mask))) {
+					/* syntax IP{/mask} error detected, protect all */
+					*p0 = 'D';
+					pip->mask = 0;
+				}
+				pip->allow_deny = *p0;
+				if (*p0 == 'D') {
+					/* Deny:form_IP move top */
+					pip->next = config->ip_a_d;
+					config->ip_a_d = pip;
+				} else {
+					/* add to bottom A:form_IP config line */
+					Htaccess_IP *prev_IP = config->ip_a_d;
+
+					if (prev_IP == NULL) {
+						config->ip_a_d = pip;
+					} else {
+						while (prev_IP->next)
+							prev_IP = prev_IP->next;
+						prev_IP->next = pip;
+					}
+				}
+			}
+			continue;
+		}
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
+		if (*p0 == '/') {
+			/* make full path from httpd root / curent_path / config_line_path */
+			cf = flag == SUBDIR_PARSE ? path : "";
+			p0 = malloc(strlen(cf) + (c - buf) + 2 + strlen(c));
+			if (p0 == NULL)
+				continue;
+			c[-1] = 0;
+			sprintf(p0, "/%s%s", cf, buf);
+
+			/* another call bb_simplify_path */
+			cf = p = p0;
+
+			do {
+				if (*p == '/') {
+					if (*cf == '/') {    /* skip duplicate (or initial) slash */
+						continue;
+					} else if (*cf == '.') {
+						if (cf[1] == '/' || cf[1] == 0) { /* remove extra '.' */
+							continue;
+						} else if ((cf[1] == '.') && (cf[2] == '/' || cf[2] == 0)) {
+							++cf;
+							if (p > p0) {
+								while (*--p != '/') /* omit previous dir */;
+							}
+							continue;
+						}
+					}
+				}
+				*++p = *cf;
+			} while (*++cf);
+
+			if ((p == p0) || (*p != '/')) {      /* not a trailing slash */
+				++p;                             /* so keep last character */
+			}
+			*p = 0;
+			sprintf(p0, "%s:%s", p0, c);
+		}
+#endif
+
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH || ENABLE_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES || ENABLE_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
+		/* storing current config line */
+		cur = calloc(1, sizeof(Htaccess) + strlen(p0));
+		if (cur) {
+			cf = strcpy(cur->before_colon, p0);
+			c = strchr(cf, ':');
+			*c++ = 0;
+			cur->after_colon = c;
+#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES
+			if (*cf == '.') {
+				/* config .mime line move top for overwrite previous */
+				cur->next = config->mime_a;
+				config->mime_a = cur;
+				continue;
+			}
+#endif
+#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
+			if (*cf == '*' && cf[1] == '.') {
+				/* config script interpreter line move top for overwrite previous */
+				cur->next = config->script_i;
+				config->script_i = cur;
+				continue;
+			}
+#endif
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
+			free(p0);
+			if (prev == NULL) {
+				/* first line */
+				config->auth = prev = cur;
+			} else {
+				/* sort path, if current lenght eq or bigger then move up */
+				Htaccess *prev_hti = config->auth;
+				size_t l = strlen(cf);
+				Htaccess *hti;
+
+				for (hti = prev_hti; hti; hti = hti->next) {
+					if (l >= strlen(hti->before_colon)) {
+						/* insert before hti */
+						cur->next = hti;
+						if (prev_hti != hti) {
+							prev_hti->next = cur;
+						} else {
+							/* insert as top */
+							config->auth = cur;
+						}
+						break;
+					}
+					if (prev_hti != hti)
+						prev_hti = prev_hti->next;
+				}
+				if (!hti) {       /* not inserted, add to bottom */
+					prev->next = cur;
+					prev = cur;
+				}
+			}
+#endif
+		}
+#endif
+	 }
+	 fclose(f);
+}
+
+#if ENABLE_FEATURE_HTTPD_ENCODE_URL_STR
+/****************************************************************************
+ *
+ > $Function: encodeString()
+ *
+ * $Description: Given a string, html encode special characters.
+ *   This is used for the -e command line option to provide an easy way
+ *   for scripts to encode result data without confusing browsers.  The
+ *   returned string pointer is memory allocated by malloc().
+ *
+ * $Parameters:
+ *      (const char *) string . . The first string to encode.
+ *
+ * $Return: (char *) . . . .. . . A pointer to the encoded string.
+ *
+ * $Errors: Returns a null string ("") if memory is not available.
+ *
+ ****************************************************************************/
+static char *encodeString(const char *string)
+{
+	/* take the simple route and encode everything */
+	/* could possibly scan once to get length.     */
+	int len = strlen(string);
+	char *out = malloc(len * 6 + 1);
+	char *p = out;
+	char ch;
+
+	if (!out) return "";
+	while ((ch = *string++)) {
+		// very simple check for what to encode
+		if (isalnum(ch)) *p++ = ch;
+		else p += sprintf(p, "&#%d;", (unsigned char) ch);
+	}
+	*p = 0;
+	return out;
+}
+#endif          /* FEATURE_HTTPD_ENCODE_URL_STR */
+
+/****************************************************************************
+ *
+ > $Function: decodeString()
+ *
+ * $Description: Given a URL encoded string, convert it to plain ascii.
+ *   Since decoding always makes strings smaller, the decode is done in-place.
+ *   Thus, callers should strdup() the argument if they do not want the
+ *   argument modified.  The return is the original pointer, allowing this
+ *   function to be easily used as arguments to other functions.
+ *
+ * $Parameters:
+ *      (char *) string . . . The first string to decode.
+ *      (int)    option_d . . 1 if called for httpd -d
+ *
+ * $Return: (char *)  . . . . A pointer to the decoded string (same as input).
+ *
+ * $Errors: None
+ *
+ ****************************************************************************/
+static char *decodeString(char *orig, int option_d)
+{
+	/* note that decoded string is always shorter than original */
+	char *string = orig;
+	char *ptr = string;
+	char c;
+
+	while ((c = *ptr++) != '\0') {
+		unsigned value1, value2;
+
+		if (option_d && c == '+') {
+			*string++ = ' ';
+			continue;
+		}
+		if (c != '%') {
+			*string++ = c;
+			continue;
+		}
+		if (sscanf(ptr, "%1X", &value1) != 1
+		 || sscanf(ptr+1, "%1X", &value2) != 1
+		) {
+			if (!option_d)
+				return NULL;
+			*string++ = '%';
+			continue;
+		}
+		value1 = value1 * 16 + value2;
+		if (!option_d && (value1 == '/' || value1 == '\0')) {
+			/* caller takes it as indication of invalid 
+			 * (dangerous wrt exploits) chars */
+			return orig + 1;
+		}
+		*string++ = value1;
+		ptr += 2;
+	}
+	*string = '\0';
+	return orig;
+}
+
+
+#if ENABLE_FEATURE_HTTPD_CGI
+/****************************************************************************
+ * setenv helpers
+ ****************************************************************************/
+static void setenv1(const char *name, const char *value)
+{
+	if (!value)
+		value = "";
+	setenv(name, value, 1);
+}
+static void setenv_long(const char *name, long value)
+{
+	char buf[sizeof(value)*3 + 1];
+	sprintf(buf, "%ld", value);
+	setenv(name, buf, 1);
+}
+#endif
+
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
+/****************************************************************************
+ *
+ > $Function: decodeBase64()
+ *
+ > $Description: Decode a base 64 data stream as per rfc1521.
+ *    Note that the rfc states that none base64 chars are to be ignored.
+ *    Since the decode always results in a shorter size than the input, it is
+ *    OK to pass the input arg as an output arg.
+ *
+ * $Parameter:
+ *      (char *) Data . . . . A pointer to a base64 encoded string.
+ *                            Where to place the decoded data.
+ *
+ * $Return: void
+ *
+ * $Errors: None
+ *
+ ****************************************************************************/
+static void decodeBase64(char *Data)
+{
+
+	const unsigned char *in = (const unsigned char *)Data;
+	// The decoded size will be at most 3/4 the size of the encoded
+	unsigned long ch = 0;
+	int i = 0;
+
+	while (*in) {
+		int t = *in++;
+
+		if (t >= '0' && t <= '9')
+			t = t - '0' + 52;
+		else if (t >= 'A' && t <= 'Z')
+			t = t - 'A';
+		else if (t >= 'a' && t <= 'z')
+			t = t - 'a' + 26;
+		else if (t == '+')
+			t = 62;
+		else if (t == '/')
+			t = 63;
+		else if (t == '=')
+			t = 0;
+		else
+			continue;
+
+		ch = (ch << 6) | t;
+		i++;
+		if (i == 4) {
+			*Data++ = (char) (ch >> 16);
+			*Data++ = (char) (ch >> 8);
+			*Data++ = (char) ch;
+			i = 0;
+		}
+	}
+	*Data = 0;
+}
+#endif
+
+
+/****************************************************************************
+ *
+ > $Function: openServer()
+ *
+ * $Description: create a listen server socket on the designated port.
+ *
+ * $Return: (int)  . . . A connection socket. -1 for errors.
+ *
+ * $Errors: None
+ *
+ ****************************************************************************/
+static int openServer(void)
+{
+	struct sockaddr_in lsocket;
+	int fd;
+
+	/* create the socket right now */
+	/* inet_addr() returns a value that is already in network order */
+	memset(&lsocket, 0, sizeof(lsocket));
+	lsocket.sin_family = AF_INET;
+	lsocket.sin_addr.s_addr = INADDR_ANY;
+	lsocket.sin_port = htons(config->port);
+	fd = xsocket(AF_INET, SOCK_STREAM, 0);
+	/* tell the OS it's OK to reuse a previous address even though */
+	/* it may still be in a close down state.  Allows bind to succeed. */
+#ifdef SO_REUSEPORT
+	{
+		static const int on = 1;
+		setsockopt(fd, SOL_SOCKET, SO_REUSEPORT,
+				(void *)&on, sizeof(on));
+	}
+#else
+	setsockopt_reuseaddr(fd);
+#endif
+	xbind(fd, (struct sockaddr *)&lsocket, sizeof(lsocket));
+	xlisten(fd, 9);
+	signal(SIGCHLD, SIG_IGN);   /* prevent zombie (defunct) processes */
+	return fd;
+}
+
+/****************************************************************************
+ *
+ > $Function: sendHeaders()
+ *
+ * $Description: Create and send HTTP response headers.
+ *   The arguments are combined and sent as one write operation.  Note that
+ *   IE will puke big-time if the headers are not sent in one packet and the
+ *   second packet is delayed for any reason.
+ *
+ * $Parameter:
+ *      (HttpResponseNum) responseNum . . . The result code to send.
+ *
+ * $Return: (int)  . . . . writing errors
+ *
+ ****************************************************************************/
+static int sendHeaders(HttpResponseNum responseNum)
+{
+	char *buf = config->buf;
+	const char *responseString = "";
+	const char *infoString = 0;
+	const char *mime_type;
+	unsigned int i;
+	time_t timer = time(0);
+	char timeStr[80];
+	int len;
+	enum {
+		numNames = sizeof(httpResponseNames) / sizeof(httpResponseNames[0])
+	};
+
+	for (i = 0; i < numNames; i++) {
+		if (httpResponseNames[i].type == responseNum) {
+			responseString = httpResponseNames[i].name;
+			infoString = httpResponseNames[i].info;
+			break;
+		}
+	}
+	/* error message is HTML */
+	mime_type = responseNum == HTTP_OK ?
+				config->found_mime_type : "text/html";
+
+	/* emit the current date */
+	strftime(timeStr, sizeof(timeStr), RFC1123FMT, gmtime(&timer));
+	len = sprintf(buf,
+		"HTTP/1.0 %d %s\r\nContent-type: %s\r\n"
+		"Date: %s\r\nConnection: close\r\n",
+			responseNum, responseString, mime_type, timeStr);
+
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
+	if (responseNum == HTTP_UNAUTHORIZED) {
+		len += sprintf(buf+len, "WWW-Authenticate: Basic realm=\"%s\"\r\n",
+						      		    config->realm);
+	}
+#endif
+	if (responseNum == HTTP_MOVED_TEMPORARILY) {
+		len += sprintf(buf+len, "Location: %s/%s%s\r\n",
+				config->found_moved_temporarily,
+				(config->query ? "?" : ""),
+				(config->query ? config->query : ""));
+	}
+
+	if (config->ContentLength != -1) {    /* file */
+		strftime(timeStr, sizeof(timeStr), RFC1123FMT, gmtime(&config->last_mod));
+		len += sprintf(buf+len, "Last-Modified: %s\r\n%s %"OFF_FMT"d\r\n",
+			timeStr, "Content-length:", config->ContentLength);
+	}
+	strcat(buf, "\r\n");
+	len += 2;
+	if (infoString) {
+		len += sprintf(buf+len,
+				"<HEAD><TITLE>%d %s</TITLE></HEAD>\n"
+				"<BODY><H1>%d %s</H1>\n%s\n</BODY>\n",
+				responseNum, responseString,
+				responseNum, responseString, infoString);
+	}
+	if (DEBUG)
+		fprintf(stderr, "headers: '%s'\n", buf);
+	return full_write(config->accepted_socket, buf, len);
+}
+
+/****************************************************************************
+ *
+ > $Function: getLine()
+ *
+ * $Description: Read from the socket until an end of line char found.
+ *
+ *   Characters are read one at a time until an eol sequence is found.
+ *
+ * $Return: (int) . . . . number of characters read.  -1 if error.
+ *
+ ****************************************************************************/
+static int getLine(void)
+{
+	int count = 0;
+	char *buf = config->buf;
+
+	while (read(config->accepted_socket, buf + count, 1) == 1) {
+		if (buf[count] == '\r') continue;
+		if (buf[count] == '\n') {
+			buf[count] = 0;
+			return count;
+		}
+		if (count < (MAX_MEMORY_BUFF-1))      /* check overflow */
+			count++;
+	}
+	if (count) return count;
+	else return -1;
+}
+
+#if ENABLE_FEATURE_HTTPD_CGI
+/****************************************************************************
+ *
+ > $Function: sendCgi()
+ *
+ * $Description: Execute a CGI script and send it's stdout back
+ *
+ *   Environment variables are set up and the script is invoked with pipes
+ *   for stdin/stdout.  If a post is being done the script is fed the POST
+ *   data in addition to setting the QUERY_STRING variable (for GETs or POSTs).
+ *
+ * $Parameters:
+ *      (const char *) url . . . . . . The requested URL (with leading /).
+ *      (int bodyLen)  . . . . . . . . Length of the post body.
+ *      (const char *cookie) . . . . . For set HTTP_COOKIE.
+ *      (const char *content_type) . . For set CONTENT_TYPE.
+
+ *
+ * $Return: (char *)  . . . . A pointer to the decoded string (same as input).
+ *
+ * $Errors: None
+ *
+ ****************************************************************************/
+static int sendCgi(const char *url,
+		const char *request, int bodyLen, const char *cookie,
+		const char *content_type)
+{
+	int fromCgi[2];  /* pipe for reading data from CGI */
+	int toCgi[2];    /* pipe for sending data to CGI */
+
+	static char * argp[] = { 0, 0 };
+	int pid = 0;
+	int inFd;
+	int outFd;
+	int firstLine = 1;
+	int status;
+	size_t post_readed_size, post_readed_idx;
+
+	if (pipe(fromCgi) != 0)
+		return 0;
+	if (pipe(toCgi) != 0)
+		return 0;
+
+	pid = fork();
+	if (pid < 0)
+		return 0;
+	
+	if (!pid) {
+		/* child process */
+		char *script;
+		char *purl = strdup(url);
+		char realpath_buff[MAXPATHLEN];
+
+		if (purl == NULL)
+			_exit(242);
+
+		inFd = toCgi[0];
+		outFd = fromCgi[1];
+
+		dup2(inFd, 0);  // replace stdin with the pipe
+		dup2(outFd, 1);  // replace stdout with the pipe
+		if (!DEBUG)
+			dup2(outFd, 2);  // replace stderr with the pipe
+
+		close(toCgi[0]);
+		close(toCgi[1]);
+		close(fromCgi[0]);
+		close(fromCgi[1]);
+
+		close(config->accepted_socket);
+		close(config->server_socket);
+
+		/*
+		 * Find PATH_INFO.
+		 */
+		script = purl;
+		while ((script = strchr(script + 1, '/')) != NULL) {
+			/* have script.cgi/PATH_INFO or dirs/script.cgi[/PATH_INFO] */
+			struct stat sb;
+
+			*script = '\0';
+			if (is_directory(purl + 1, 1, &sb) == 0) {
+				/* not directory, found script.cgi/PATH_INFO */
+				*script = '/';
+				break;
+			}
+			*script = '/';          /* is directory, find next '/' */
+		}
+		setenv1("PATH_INFO", script);   /* set /PATH_INFO or "" */
+		/* setenv1("PATH", getenv("PATH")); redundant */
+		setenv1("REQUEST_METHOD", request);
+		if (config->query) {
+			char *uri = alloca(strlen(purl) + 2 + strlen(config->query));
+			if (uri)
+				sprintf(uri, "%s?%s", purl, config->query);
+			setenv1("REQUEST_URI", uri);
+		} else {
+			setenv1("REQUEST_URI", purl);
+		}
+		if (script != NULL)
+			*script = '\0';         /* cut off /PATH_INFO */
+		 /* SCRIPT_FILENAME required by PHP in CGI mode */
+		if (!realpath(purl + 1, realpath_buff))
+			goto error_execing_cgi;
+		setenv1("SCRIPT_FILENAME", realpath_buff);
+		/* set SCRIPT_NAME as full path: /cgi-bin/dirs/script.cgi */
+		setenv1("SCRIPT_NAME", purl);
+		/* http://hoohoo.ncsa.uiuc.edu/cgi/env.html:
+		 * QUERY_STRING: The information which follows the ? in the URL
+		 * which referenced this script. This is the query information.
+		 * It should not be decoded in any fashion. This variable
+		 * should always be set when there is query information,
+		 * regardless of command line decoding. */
+		/* (Older versions of bbox seemed to do some decoding) */
+		setenv1("QUERY_STRING", config->query);
+		setenv1("SERVER_SOFTWARE", httpdVersion);
+		putenv("SERVER_PROTOCOL=HTTP/1.0");
+		putenv("GATEWAY_INTERFACE=CGI/1.1");
+		setenv1("REMOTE_ADDR", config->rmt_ip_str);
+#if ENABLE_FEATURE_HTTPD_SET_REMOTE_PORT_TO_ENV
+		setenv_long("REMOTE_PORT", config->port);
+#endif
+		if (bodyLen)
+			setenv_long("CONTENT_LENGTH", bodyLen);
+		if (cookie)
+			setenv1("HTTP_COOKIE", cookie);
+		if (content_type)
+			setenv1("CONTENT_TYPE", content_type);
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
+		if (config->remoteuser) {
+			setenv1("REMOTE_USER", config->remoteuser);
+			putenv("AUTH_TYPE=Basic");
+		}
+#endif
+		if (config->referer)
+			setenv1("HTTP_REFERER", config->referer);
+
+		/* set execve argp[0] without path */
+		argp[0] = strrchr(purl, '/') + 1;
+		/* but script argp[0] must have absolute path and chdiring to this */
+		script = strrchr(realpath_buff, '/');
+		if (!script)
+			goto error_execing_cgi;
+		*script = '\0';
+		if (chdir(realpath_buff) == 0) {
+			// now run the program.  If it fails,
+			// use _exit() so no destructors
+			// get called and make a mess.
+#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
+			char *interpr = NULL;
+			char *suffix = strrchr(purl, '.');
+
+			if (suffix) {
+				Htaccess *cur;
+				for (cur = config->script_i; cur; cur = cur->next) {
+					if (strcmp(cur->before_colon + 1, suffix) == 0) {
+						interpr = cur->after_colon;
+						break;
+					}
+				}
+			}
+#endif
+			*script = '/';
+#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
+			if (interpr)
+				execv(interpr, argp);
+			else
+#endif
+				execv(realpath_buff, argp);
+		}
+ error_execing_cgi:
+		/* send to stdout (even if we are not from inetd) */
+		config->accepted_socket = 1;
+		sendHeaders(HTTP_NOT_FOUND);
+		_exit(242);
+	} /* end child */
+
+	/* parent process */
+
+	post_readed_size = 0;
+	post_readed_idx = 0;
+	inFd = fromCgi[0];
+	outFd = toCgi[1];
+	close(fromCgi[1]);
+	close(toCgi[0]);
+	signal(SIGPIPE, SIG_IGN);
+
+	while (1) {
+		fd_set readSet;
+		fd_set writeSet;
+		char wbuf[128];
+		int nfound;
+		int count;
+
+		FD_ZERO(&readSet);
+		FD_ZERO(&writeSet);
+		FD_SET(inFd, &readSet);
+		if (bodyLen > 0 || post_readed_size > 0) {
+			FD_SET(outFd, &writeSet);
+			nfound = outFd > inFd ? outFd : inFd;
+			if (post_readed_size == 0) {
+				FD_SET(config->accepted_socket, &readSet);
+				if (nfound < config->accepted_socket)
+					nfound = config->accepted_socket;
+			}
+			/* Now wait on the set of sockets! */
+			nfound = select(nfound + 1, &readSet, &writeSet, 0, NULL);
+		} else {
+			if (!bodyLen) {
+				close(outFd);
+				bodyLen = -1;
+			}
+			nfound = select(inFd + 1, &readSet, 0, 0, NULL);
+		}
+
+		if (nfound <= 0) {
+			if (waitpid(pid, &status, WNOHANG) > 0) {
+				close(inFd);
+				if (DEBUG && WIFEXITED(status))
+					bb_error_msg("piped has exited with status=%d", WEXITSTATUS(status));
+				if (DEBUG && WIFSIGNALED(status))
+					bb_error_msg("piped has exited with signal=%d", WTERMSIG(status));
+				break;
+			}
+		} else if (post_readed_size > 0 && FD_ISSET(outFd, &writeSet)) {
+			count = full_write(outFd, wbuf + post_readed_idx, post_readed_size);
+			if (count > 0) {
+				post_readed_size -= count;
+				post_readed_idx += count;
+				if (post_readed_size == 0)
+					post_readed_idx = 0;
+			} else {
+				post_readed_size = post_readed_idx = bodyLen = 0; /* broken pipe to CGI */
+			}
+		} else if (bodyLen > 0 && post_readed_size == 0 && FD_ISSET(config->accepted_socket, &readSet)) {
+			count = bodyLen > (int)sizeof(wbuf) ? (int)sizeof(wbuf) : bodyLen;
+			count = safe_read(config->accepted_socket, wbuf, count);
+			if (count > 0) {
+				post_readed_size += count;
+				bodyLen -= count;
+			} else {
+				bodyLen = 0;    /* closed */
+			}
+		}
+		if (FD_ISSET(inFd, &readSet)) {
+			int s = config->accepted_socket;
+			char *rbuf = config->buf;
+
+#ifndef PIPE_BUF
+# define PIPESIZE 4096          /* amount of buffering in a pipe */
+#else
+# define PIPESIZE PIPE_BUF
+#endif
+#if PIPESIZE >= MAX_MEMORY_BUFF
+# error "PIPESIZE >= MAX_MEMORY_BUFF"
+#endif
+
+			/* There is something to read */
+			count = safe_read(inFd, rbuf, PIPESIZE);
+			if (count == 0)
+				break;  /* closed */
+			if (count > 0) {
+				if (firstLine) {
+					rbuf[count] = 0;
+					/* check to see if the user script added headers */
+					if (strncmp(rbuf, "HTTP/1.0 200 OK\r\n", 4) != 0) {
+						full_write(s, "HTTP/1.0 200 OK\r\n", 17);
+					}
+					/* Sometimes CGI is writing to pipe in small chunks
+					 * and we don't see Content-type (because the read
+					 * is too short) and we emit bogus "text/plain"!
+					 * Is it a bug or CGI *has to* write it in one piece? */
+					if (strstr(rbuf, "ontent-") == 0) {
+						full_write(s, "Content-type: text/plain\r\n\r\n", 28);
+					}
+					firstLine = 0;
+				}
+				if (full_write(s, rbuf, count) != count)
+					break;
+
+				if (DEBUG)
+					fprintf(stderr, "cgi read %d bytes: '%.*s'\n", count, count, rbuf);
+			}
+		}
+	}
+	return 0;
+}
+#endif          /* FEATURE_HTTPD_CGI */
+
+/****************************************************************************
+ *
+ > $Function: sendFile()
+ *
+ * $Description: Send a file response to a HTTP request
+ *
+ * $Parameter:
+ *      (const char *) url . . The URL requested.
+ *
+ * $Return: (int)  . . . . . . Always 0.
+ *
+ ****************************************************************************/
+static int sendFile(const char *url)
+{
+	char * suffix;
+	int  f;
+	const char * const * table;
+	const char * try_suffix;
+
+	suffix = strrchr(url, '.');
+
+	for (table = suffixTable; *table; table += 2)
+		if (suffix != NULL && (try_suffix = strstr(*table, suffix)) != 0) {
+			try_suffix += strlen(suffix);
+			if (*try_suffix == 0 || *try_suffix == '.')
+				break;
+		}
+	/* also, if not found, set default as "application/octet-stream";  */
+	config->found_mime_type = table[1];
+#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES
+	if (suffix) {
+		Htaccess * cur;
+
+		for (cur = config->mime_a; cur; cur = cur->next) {
+			if (strcmp(cur->before_colon, suffix) == 0) {
+				config->found_mime_type = cur->after_colon;
+				break;
+			}
+		}
+	}
+#endif  /* FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES */
+
+	if (DEBUG)
+		fprintf(stderr, "sending file '%s' content-type: %s\n",
+			url, config->found_mime_type);
+
+	f = open(url, O_RDONLY);
+	if (f >= 0) {
+		int count;
+		char *buf = config->buf;
+
+		sendHeaders(HTTP_OK);
+		/* TODO: sendfile() */
+		while ((count = full_read(f, buf, MAX_MEMORY_BUFF)) > 0) {
+			if (full_write(config->accepted_socket, buf, count) != count)
+				break;
+		}
+		close(f);
+	} else {
+		if (DEBUG)
+			bb_perror_msg("cannot open '%s'", url);
+		sendHeaders(HTTP_NOT_FOUND);
+	}
+
+	return 0;
+}
+
+static int checkPermIP(void)
+{
+	Htaccess_IP * cur;
+
+	/* This could stand some work */
+	for (cur = config->ip_a_d; cur; cur = cur->next) {
+		if (DEBUG)
+			fprintf(stderr, "checkPermIP: '%s' ? ", config->rmt_ip_str);
+		if (DEBUG)
+			fprintf(stderr, "'%u.%u.%u.%u/%u.%u.%u.%u'\n",
+				(unsigned char)(cur->ip >> 24),
+				(unsigned char)(cur->ip >> 16),
+				(unsigned char)(cur->ip >> 8),
+				                cur->ip & 0xff,
+				(unsigned char)(cur->mask >> 24),
+				(unsigned char)(cur->mask >> 16),
+				(unsigned char)(cur->mask >> 8),
+				                cur->mask & 0xff);
+		if ((config->rmt_ip & cur->mask) == cur->ip)
+			return cur->allow_deny == 'A';   /* Allow/Deny */
+	}
+
+	/* if unconfigured, return 1 - access from all */
+	return !config->flg_deny_all;
+}
+
+/****************************************************************************
+ *
+ > $Function: checkPerm()
+ *
+ * $Description: Check the permission file for access password protected.
+ *
+ *   If config file isn't present, everything is allowed.
+ *   Entries are of the form you can see example from header source
+ *
+ * $Parameters:
+ *      (const char *) path  . . . . The file path.
+ *      (const char *) request . . . User information to validate.
+ *
+ * $Return: (int)  . . . . . . . . . 1 if request OK, 0 otherwise.
+ *
+ ****************************************************************************/
+
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
+static int checkPerm(const char *path, const char *request)
+{
+	Htaccess * cur;
+	const char *p;
+	const char *p0;
+
+	const char *prev = NULL;
+
+	/* This could stand some work */
+	for (cur = config->auth; cur; cur = cur->next) {
+		size_t l;
+
+		p0 = cur->before_colon;
+		if (prev != NULL && strcmp(prev, p0) != 0)
+			continue;       /* find next identical */
+		p = cur->after_colon;
+		if (DEBUG)
+			fprintf(stderr, "checkPerm: '%s' ? '%s'\n", p0, request);
+
+		l = strlen(p0);
+		if (strncmp(p0, path, l) == 0
+		 && (l == 1 || path[l] == '/' || path[l] == '\0')
+		) {
+			char *u;
+			/* path match found.  Check request */
+			/* for check next /path:user:password */
+			prev = p0;
+			u = strchr(request, ':');
+			if (u == NULL) {
+				/* bad request, ':' required */
+				break;
+			}
+
+			if (ENABLE_FEATURE_HTTPD_AUTH_MD5) {
+				char *cipher;
+				char *pp;
+
+				if (strncmp(p, request, u-request) != 0) {
+					/* user uncompared */
+					continue;
+				}
+				pp = strchr(p, ':');
+				if (pp && pp[1] == '$' && pp[2] == '1' &&
+						pp[3] == '$' && pp[4]) {
+					pp++;
+					cipher = pw_encrypt(u+1, pp);
+					if (strcmp(cipher, pp) == 0)
+						goto set_remoteuser_var;   /* Ok */
+					/* unauthorized */
+					continue;
+				}
+			}
+
+			if (strcmp(p, request) == 0) {
+set_remoteuser_var:
+				config->remoteuser = strdup(request);
+				if (config->remoteuser)
+					config->remoteuser[(u - request)] = 0;
+				return 1;   /* Ok */
+			}
+			/* unauthorized */
+		}
+	}   /* for */
+
+	return prev == NULL;
+}
+
+#endif  /* FEATURE_HTTPD_BASIC_AUTH */
+
+/****************************************************************************
+ *
+ > $Function: handle_sigalrm()
+ *
+ * $Description: Handle timeouts
+ *
+ ****************************************************************************/
+
+static void handle_sigalrm(int sig)
+{
+	sendHeaders(HTTP_REQUEST_TIMEOUT);
+	config->alarm_signaled = sig;
+}
+
+/****************************************************************************
+ *
+ > $Function: handleIncoming()
+ *
+ * $Description: Handle an incoming http request.
+ *
+ ****************************************************************************/
+static void handleIncoming(void)
+{
+	char *buf = config->buf;
+	char *url;
+	char *purl;
+	int  blank = -1;
+	char *test;
+	struct stat sb;
+	int ip_allowed;
+#if ENABLE_FEATURE_HTTPD_CGI
+	const char *prequest = request_GET;
+	unsigned long length = 0;
+	char *cookie = 0;
+	char *content_type = 0;
+#endif
+	fd_set s_fd;
+	struct timeval tv;
+	int retval;
+	struct sigaction sa;
+
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
+	int credentials = -1;  /* if not required this is Ok */
+#endif
+
+	sa.sa_handler = handle_sigalrm;
+	sigemptyset(&sa.sa_mask);
+	sa.sa_flags = 0; /* no SA_RESTART */
+	sigaction(SIGALRM, &sa, NULL);
+
+	do {
+		int count;
+
+		(void) alarm(TIMEOUT);
+		if (getLine() <= 0)
+			break;  /* closed */
+
+		purl = strpbrk(buf, " \t");
+		if (purl == NULL) {
+ BAD_REQUEST:
+			sendHeaders(HTTP_BAD_REQUEST);
+			break;
+		}
+		*purl = '\0';
+#if ENABLE_FEATURE_HTTPD_CGI
+		if (strcasecmp(buf, prequest) != 0) {
+			prequest = "POST";
+			if (strcasecmp(buf, prequest) != 0) {
+				sendHeaders(HTTP_NOT_IMPLEMENTED);
+				break;
+			}
+		}
+#else
+		if (strcasecmp(buf, request_GET) != 0) {
+			sendHeaders(HTTP_NOT_IMPLEMENTED);
+			break;
+		}
+#endif
+		*purl = ' ';
+		count = sscanf(purl, " %[^ ] HTTP/%d.%*d", buf, &blank);
+
+		if (count < 1 || buf[0] != '/') {
+			/* Garbled request/URL */
+			goto BAD_REQUEST;
+		}
+		url = alloca(strlen(buf) + sizeof("/index.html"));
+		if (url == NULL) {
+			sendHeaders(HTTP_INTERNAL_SERVER_ERROR);
+			break;
+		}
+		strcpy(url, buf);
+		/* extract url args if present */
+		test = strchr(url, '?');
+		config->query = NULL;
+		if (test) {
+			*test++ = '\0';
+			config->query = test;
+		}
+
+		test = decodeString(url, 0);
+		if (test == NULL)
+			goto BAD_REQUEST;
+		if (test == url+1) {
+			/* '/' or NUL is encoded */
+			sendHeaders(HTTP_NOT_FOUND);
+			break;
+		}
+
+		/* algorithm stolen from libbb bb_simplify_path(),
+			 but don't strdup and reducing trailing slash and protect out root */
+		purl = test = url;
+		do {
+			if (*purl == '/') {
+				/* skip duplicate (or initial) slash */
+				if (*test == '/') {
+					continue;
+				}
+				if (*test == '.') {
+					/* skip extra '.' */
+					if (test[1] == '/' || test[1] == 0) {
+						continue;
+					} else
+					/* '..': be careful */
+					if (test[1] == '.' && (test[2] == '/' || test[2] == 0)) {
+						++test;
+						if (purl == url) {
+							/* protect out root */
+							goto BAD_REQUEST;
+						}
+						while (*--purl != '/') /* omit previous dir */;
+						continue;
+					}
+				}
+			}
+			*++purl = *test;
+		} while (*++test);
+		*++purl = '\0';       /* so keep last character */
+		test = purl;          /* end ptr */
+
+		/* If URL is directory, adding '/' */
+		if (test[-1] != '/') {
+			if (is_directory(url + 1, 1, &sb)) {
+				config->found_moved_temporarily = url;
+			}
+		}
+		if (DEBUG)
+			fprintf(stderr, "url='%s', args=%s\n", url, config->query);
+
+		test = url;
+		ip_allowed = checkPermIP();
+		while (ip_allowed && (test = strchr(test + 1, '/')) != NULL) {
+			/* have path1/path2 */
+			*test = '\0';
+			if (is_directory(url + 1, 1, &sb)) {
+				/* may be having subdir config */
+				parse_conf(url + 1, SUBDIR_PARSE);
+				ip_allowed = checkPermIP();
+			}
+			*test = '/';
+		}
+		if (blank >= 0) {
+			/* read until blank line for HTTP version specified, else parse immediate */
+			while (1) {
+				alarm(TIMEOUT);
+				count = getLine();
+				if (count <= 0)
+					break;
+
+				if (DEBUG)
+					fprintf(stderr, "header: '%s'\n", buf);
+
+#if ENABLE_FEATURE_HTTPD_CGI
+				/* try and do our best to parse more lines */
+				if ((STRNCASECMP(buf, "Content-length:") == 0)) {
+					/* extra read only for POST */
+					if (prequest != request_GET) {
+						test = buf + sizeof("Content-length:")-1;
+						if (!test[0]) goto bail_out;
+						errno = 0;
+						/* not using strtoul: it ignores leading munis! */
+						length = strtol(test, &test, 10);
+						/* length is "ulong", but we need to pass it to int later */
+						/* so we check for negative or too large values in one go: */
+						/* (long -> ulong conv caused negatives to be seen as > INT_MAX) */
+						if (test[0] || errno || length > INT_MAX)
+							goto bail_out;
+					}
+				} else if ((STRNCASECMP(buf, "Cookie:") == 0)) {
+					cookie = strdup(skip_whitespace(buf + sizeof("Cookie:")-1));
+				} else if ((STRNCASECMP(buf, "Content-Type:") == 0)) {
+					content_type = strdup(skip_whitespace(buf + sizeof("Content-Type:")-1));
+				} else if ((STRNCASECMP(buf, "Referer:") == 0)) {
+					config->referer = strdup(skip_whitespace(buf + sizeof("Referer:")-1));
+				}
+#endif
+
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
+				if (STRNCASECMP(buf, "Authorization:") == 0) {
+					/* We only allow Basic credentials.
+					 * It shows up as "Authorization: Basic <userid:password>" where
+					 * the userid:password is base64 encoded.
+					 */
+					test = skip_whitespace(buf + sizeof("Authorization:")-1);
+					if (STRNCASECMP(test, "Basic") != 0)
+						continue;
+					test += sizeof("Basic")-1;
+					/* decodeBase64() skips whitespace itself */
+					decodeBase64(test);
+					credentials = checkPerm(url, test);
+				}
+#endif          /* FEATURE_HTTPD_BASIC_AUTH */
+
+			} /* while extra header reading */
+		}
+		alarm(0);
+		if (config->alarm_signaled)
+			break;
+
+		if (strcmp(strrchr(url, '/') + 1, httpd_conf) == 0 || ip_allowed == 0) {
+			/* protect listing [/path]/httpd_conf or IP deny */
+#if ENABLE_FEATURE_HTTPD_CGI
+ FORBIDDEN:		/* protect listing /cgi-bin */
+#endif
+			sendHeaders(HTTP_FORBIDDEN);
+			break;
+		}
+
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
+		if (credentials <= 0 && checkPerm(url, ":") == 0) {
+			sendHeaders(HTTP_UNAUTHORIZED);
+			break;
+		}
+#endif
+
+		if (config->found_moved_temporarily) {
+			sendHeaders(HTTP_MOVED_TEMPORARILY);
+			/* clear unforked memory flag */
+			config->found_moved_temporarily = NULL;
+			break;
+		}
+
+		test = url + 1;      /* skip first '/' */
+
+#if ENABLE_FEATURE_HTTPD_CGI
+		if (strncmp(test, "cgi-bin", 7) == 0) {
+			if (test[7] == '/' && test[8] == 0)
+				goto FORBIDDEN;     /* protect listing cgi-bin/ */
+			sendCgi(url, prequest, length, cookie, content_type);
+			break;
+		}
+		if (prequest != request_GET) {
+			sendHeaders(HTTP_NOT_IMPLEMENTED);
+			break;
+		}
+#endif  /* FEATURE_HTTPD_CGI */
+		if (purl[-1] == '/')
+			strcpy(purl, "index.html");
+		if (stat(test, &sb) == 0) {
+			/* It's a dir URL and there is index.html */
+			config->ContentLength = sb.st_size;
+			config->last_mod = sb.st_mtime;
+		}
+#if ENABLE_FEATURE_HTTPD_CGI
+		else if (purl[-1] == '/') {
+			/* It's a dir URL and there is no index.html
+			 * Try cgi-bin/index.cgi */
+			if (access("/cgi-bin/index.cgi"+1, X_OK) == 0) {
+				purl[0] = '\0';
+				config->query = url;
+				sendCgi("/cgi-bin/index.cgi", prequest, length, cookie, content_type);
+				break;
+			}
+		}
+#endif  /* FEATURE_HTTPD_CGI */
+		sendFile(test);
+		config->ContentLength = -1;
+	} while (0);
+
+ bail_out:
+
+	if (DEBUG)
+		fprintf(stderr, "closing socket\n\n");
+#if ENABLE_FEATURE_HTTPD_CGI
+	free(cookie);
+	free(content_type);
+	free(config->referer);
+	config->referer = NULL;
+# if ENABLE_FEATURE_HTTPD_BASIC_AUTH
+	free(config->remoteuser);
+	config->remoteuser = NULL;
+# endif
+#endif
+	shutdown(config->accepted_socket, SHUT_WR);
+
+	/* Properly wait for remote to closed */
+	FD_ZERO(&s_fd);
+	FD_SET(config->accepted_socket, &s_fd);
+
+	do {
+		tv.tv_sec = 2;
+		tv.tv_usec = 0;
+		retval = select(config->accepted_socket + 1, &s_fd, NULL, NULL, &tv);
+	} while (retval > 0 && read(config->accepted_socket, buf, sizeof(config->buf) > 0));
+
+	shutdown(config->accepted_socket, SHUT_RD);
+	/* In inetd case, we close fd 1 (stdout) here. We will exit soon anyway */
+	close(config->accepted_socket);
+}
+
+/****************************************************************************
+ *
+ > $Function: miniHttpd()
+ *
+ * $Description: The main http server function.
+ *
+ *   Given an open socket fildes, listen for new connections and farm out
+ *   the processing as a forked process.
+ *
+ * $Parameters:
+ *      (int) server. . . The server socket fildes.
+ *
+ * $Return: (int) . . . . Always 0.
+ *
+ ****************************************************************************/
+static int miniHttpd(int server)
+{
+	fd_set readfd, portfd;
+
+	FD_ZERO(&portfd);
+	FD_SET(server, &portfd);
+
+	/* copy the ports we are watching to the readfd set */
+	while (1) {
+		int on, s;
+		socklen_t fromAddrLen;
+		struct sockaddr_in fromAddr;
+
+		/* Now wait INDEFINITELY on the set of sockets! */
+		readfd = portfd;
+		if (select(server + 1, &readfd, 0, 0, 0) <= 0)
+			continue;
+		if (!FD_ISSET(server, &readfd))
+			continue;
+		fromAddrLen = sizeof(fromAddr);
+		s = accept(server, (struct sockaddr *)&fromAddr, &fromAddrLen);
+		if (s < 0)
+			continue;
+		config->accepted_socket = s;
+		config->rmt_ip = ntohl(fromAddr.sin_addr.s_addr);
+#if ENABLE_FEATURE_HTTPD_CGI || DEBUG
+		sprintf(config->rmt_ip_str, "%u.%u.%u.%u",
+				(unsigned char)(config->rmt_ip >> 24),
+				(unsigned char)(config->rmt_ip >> 16),
+				(unsigned char)(config->rmt_ip >> 8),
+				config->rmt_ip & 0xff);
+		config->port = ntohs(fromAddr.sin_port);
+#if DEBUG
+		bb_error_msg("connection from IP=%s, port %u",
+				config->rmt_ip_str, config->port);
+#endif
+#endif /* FEATURE_HTTPD_CGI */
+
+		/* set the KEEPALIVE option to cull dead connections */
+		on = 1;
+		setsockopt(s, SOL_SOCKET, SO_KEEPALIVE, (void *)&on, sizeof(on));
+
+		if (DEBUG || fork() == 0) {
+			/* child */
+#if ENABLE_FEATURE_HTTPD_RELOAD_CONFIG_SIGHUP
+			/* protect reload config, may be confuse checking */
+			signal(SIGHUP, SIG_IGN);
+#endif
+			handleIncoming();
+			if (!DEBUG)
+				exit(0);
+		}
+		close(s);
+	} /* while (1) */
+	return 0;
+}
+
+/* from inetd */
+static int miniHttpd_inetd(void)
+{
+	struct sockaddr_in fromAddrLen;
+	socklen_t sinlen = sizeof(struct sockaddr_in);
+
+	getpeername(0, (struct sockaddr *)&fromAddrLen, &sinlen);
+	config->rmt_ip = ntohl(fromAddrLen.sin_addr.s_addr);
+#if ENABLE_FEATURE_HTTPD_CGI
+	sprintf(config->rmt_ip_str, "%u.%u.%u.%u",
+				(unsigned char)(config->rmt_ip >> 24),
+				(unsigned char)(config->rmt_ip >> 16),
+				(unsigned char)(config->rmt_ip >> 8),
+				                config->rmt_ip & 0xff);
+#endif
+	config->port = ntohs(fromAddrLen.sin_port);
+	handleIncoming();
+	return 0;
+}
+
+#if ENABLE_FEATURE_HTTPD_RELOAD_CONFIG_SIGHUP
+static void sighup_handler(int sig)
+{
+	/* set and reset */
+	struct sigaction sa;
+
+	parse_conf(default_path_httpd_conf, sig == SIGHUP ? SIGNALED_PARSE : FIRST_PARSE);
+	sa.sa_handler = sighup_handler;
+	sigemptyset(&sa.sa_mask);
+	sa.sa_flags = SA_RESTART;
+	sigaction(SIGHUP, &sa, NULL);
+}
+#endif
+
+enum {
+	c_opt_config_file = 0,
+	d_opt_decode_url,
+	h_opt_home_httpd,
+	USE_FEATURE_HTTPD_ENCODE_URL_STR(e_opt_encode_url,)
+	USE_FEATURE_HTTPD_BASIC_AUTH(    r_opt_realm     ,)
+	USE_FEATURE_HTTPD_AUTH_MD5(      m_opt_md5       ,)
+	USE_FEATURE_HTTPD_SETUID(        u_opt_setuid    ,)
+	p_opt_port      ,
+	p_opt_inetd     ,
+	p_opt_foreground,
+	OPT_CONFIG_FILE = 1 << c_opt_config_file,
+	OPT_DECODE_URL  = 1 << d_opt_decode_url,
+	OPT_HOME_HTTPD  = 1 << h_opt_home_httpd,
+	OPT_ENCODE_URL  = USE_FEATURE_HTTPD_ENCODE_URL_STR((1 << e_opt_encode_url)) + 0,
+	OPT_REALM       = USE_FEATURE_HTTPD_BASIC_AUTH(    (1 << r_opt_realm     )) + 0,
+	OPT_MD5         = USE_FEATURE_HTTPD_AUTH_MD5(      (1 << m_opt_md5       )) + 0,
+	OPT_SETUID      = USE_FEATURE_HTTPD_SETUID(        (1 << u_opt_setuid    )) + 0,
+	OPT_PORT        = 1 << p_opt_port,
+	OPT_INETD       = 1 << p_opt_inetd,
+	OPT_FOREGROUND  = 1 << p_opt_foreground,
+};
+
+static const char httpd_opts[] = "c:d:h:"
+	USE_FEATURE_HTTPD_ENCODE_URL_STR("e:")
+	USE_FEATURE_HTTPD_BASIC_AUTH("r:")
+	USE_FEATURE_HTTPD_AUTH_MD5("m:")
+	USE_FEATURE_HTTPD_SETUID("u:")
+	"p:if";
+
+
+int httpd_main(int argc, char *argv[])
+{
+	unsigned opt;
+	const char *home_httpd = home;
+	char *url_for_decode;
+	USE_FEATURE_HTTPD_ENCODE_URL_STR(const char *url_for_encode;)
+	const char *s_port;
+	USE_FEATURE_HTTPD_SETUID(const char *s_ugid = NULL;)
+	USE_FEATURE_HTTPD_SETUID(struct bb_uidgid_t ugid;)
+	USE_FEATURE_HTTPD_AUTH_MD5(const char *pass;)
+
+#if ENABLE_LOCALE_SUPPORT
+	/* Undo busybox.c: we want to speak English in http (dates etc) */
+	setlocale(LC_TIME, "C");
+#endif
+
+	config = xzalloc(sizeof(*config));
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
+	config->realm = "Web Server Authentication";
+#endif
+	config->port = 80;
+	config->ContentLength = -1;
+
+	opt = getopt32(argc, argv, httpd_opts,
+			&(config->configFile), &url_for_decode, &home_httpd
+			USE_FEATURE_HTTPD_ENCODE_URL_STR(, &url_for_encode)
+			USE_FEATURE_HTTPD_BASIC_AUTH(, &(config->realm))
+			USE_FEATURE_HTTPD_AUTH_MD5(, &pass)
+			USE_FEATURE_HTTPD_SETUID(, &s_ugid)
+			, &s_port
+		);
+	if (opt & OPT_DECODE_URL) {
+		printf("%s", decodeString(url_for_decode, 1));
+		return 0;
+	}
+#if ENABLE_FEATURE_HTTPD_ENCODE_URL_STR
+	if (opt & OPT_ENCODE_URL) {
+		printf("%s", encodeString(url_for_encode));
+		return 0;
+	}
+#endif
+#if ENABLE_FEATURE_HTTPD_AUTH_MD5
+	if (opt & OPT_MD5) {
+		puts(pw_encrypt(pass, "$1$"));
+		return 0;
+	}
+#endif
+	if (opt & OPT_PORT)
+		config->port = xatou16(s_port);
+
+#if ENABLE_FEATURE_HTTPD_SETUID
+	if (opt & OPT_SETUID) {
+		char *e;
+		// FIXME: what the default group should be?
+		ugid.gid = -1;
+		ugid.uid = bb_strtoul(s_ugid, &e, 0);
+		if (*e == ':') {
+			e++;
+			ugid.gid = bb_strtoul(e, NULL, 0);
+		}
+		if (errno) {
+			/* not integer */
+			if (!uidgid_get(&ugid, s_ugid))
+				bb_error_msg_and_die("unrecognized user[:group] "
+						"name '%s'", s_ugid);
+		}
+	}
+#endif
+
+	xchdir(home_httpd);
+	if (!(opt & OPT_INETD)) {
+		config->server_socket = openServer();
+#if ENABLE_FEATURE_HTTPD_SETUID
+		/* drop privileges */
+		if (opt & OPT_SETUID) {
+			if (ugid.gid != (gid_t)-1) {
+				if (setgroups(1, &ugid.gid) == -1)
+	            			bb_perror_msg_and_die("setgroups");
+				xsetgid(ugid.gid);
+			}
+			xsetuid(ugid.uid);
+		}
+#endif
+	}
+
+#if ENABLE_FEATURE_HTTPD_CGI
+	{
+		char *p = getenv("PATH");
+		p = xstrdup(p); /* if gets NULL, returns NULL */
+		clearenv();
+		if (p)
+			setenv1("PATH", p);
+		if (!(opt & OPT_INETD))
+			setenv_long("SERVER_PORT", config->port);
+	}
+#endif
+
+#if ENABLE_FEATURE_HTTPD_RELOAD_CONFIG_SIGHUP
+	sighup_handler(0);
+#else
+	parse_conf(default_path_httpd_conf, FIRST_PARSE);
+#endif
+
+	if (opt & OPT_INETD)
+		return miniHttpd_inetd();
+
+	if (!(opt & OPT_FOREGROUND))
+		xdaemon(1, 0);     /* don't change current directory */
+	return miniHttpd(config->server_socket);
+}
diff --git a/networking/httpd_index_cgi_example b/networking/httpd_index_cgi_example
new file mode 100644
index 0000000..31e768c
--- /dev/null
+++ b/networking/httpd_index_cgi_example
@@ -0,0 +1,55 @@
+#!/bin/sh
+# This CGI creates directory index.
+# Put it into cgi-bin/index.cgi and chmod 0755.
+#
+# Problems:
+# * Unsafe wrt weird filenames with <>"'& etc...
+# * Not efficient: calls stat (program, not syscall) for each file
+# * Probably requires bash
+#
+# If you want speed and safety, you need to code it in C
+
+# Must start with '/'
+test "${QUERY_STRING:0:1}" = "/" || exit 1
+# /../ is not allowed
+test "${QUERY_STRING%/../*}" = "$QUERY_STRING" || exit 1
+test "${QUERY_STRING%/..}" = "$QUERY_STRING" || exit 1
+
+# Outta cgi-bin...
+cd .. 2>/dev/null || exit 1
+# Strip leading '/', go to target dir
+cd "${QUERY_STRING:1}" 2>/dev/null || exit 1
+
+f=`dirname "$QUERY_STRING"`
+test "$f" = "/" && f=""
+
+# Pipe thru dd (need to write header as single write(),
+# or else httpd doesn't see "Content-type: text/html"
+# in first read() and decides that it is not html)
+{
+printf "%s" \
+$'HTTP/1.0 200 OK\r\n'\
+$'Content-type: text/html\r\n\r\n'\
+"<html><head><title>Index of $QUERY_STRING</title></head>"$'\r\n'\
+"<body><h1>Index of $QUERY_STRING</h1><pre>"$'\r\n'\
+$'<table width=100%>\r\n'\
+$'<col><col><col width=0*>\r\n'\
+$'<tr><th>Name<th align=right>Last modified<th align=right>Size\r\n'\
+\
+"<tr><td><a href='$f/'>..</a><td><td>"$'\r\n'
+
+IFS='#'
+for f in *; do
+    # Guard against empty dirs...
+    test -e "$f" && \
+    stat -c "%F#%s#%z" "$f" | {
+	read type size cdt junk
+	dir=''
+	test "$type" = "directory" && dir='/'
+	cdt="${cdt//.*}" # no fractional seconds
+	cdt="${cdt// /&nbsp;}" # prevent wrapping around space
+	printf "%s" "<tr><td><a href='$f$dir'>$f</a><td align=right>$cdt<td align=right>$size"$'\r\n'
+    }
+done
+printf "</table></pre><hr></body></html>"$'\r\n'
+} | dd bs=4k
diff --git a/networking/ifconfig.c b/networking/ifconfig.c
new file mode 100644
index 0000000..ae5b468
--- /dev/null
+++ b/networking/ifconfig.c
@@ -0,0 +1,548 @@
+/* vi: set sw=4 ts=4: */
+/* ifconfig
+ *
+ * Similar to the standard Unix ifconfig, but with only the necessary
+ * parts for AF_INET, and without any printing of if info (for now).
+ *
+ * Bjorn Wesen, Axis Communications AB
+ *
+ *
+ * Authors of the original ifconfig was:
+ *              Fred N. van Kempen, <waltje@uwalt.nl.mugnet.org>
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ */
+
+/*
+ * Heavily modified by Manuel Novoa III       Mar 6, 2001
+ *
+ * From initial port to busybox, removed most of the redundancy by
+ * converting to a table-driven approach.  Added several (optional)
+ * args missing from initial port.
+ *
+ * Still missing:  media, tunnel.
+ *
+ * 2002-04-20
+ * IPV6 support added by Bart Visscher <magick@linux-fan.com>
+ */
+
+#include <net/if.h>
+#include <net/if_arp.h>
+#include <netinet/in.h>
+#if __GLIBC__ >=2 && __GLIBC_MINOR__ >= 1
+#include <netpacket/packet.h>
+#include <net/ethernet.h>
+#else
+#include <sys/types.h>
+#include <netinet/if_ether.h>
+#endif
+#include "inet_common.h"
+#include "busybox.h"
+
+#if ENABLE_FEATURE_IFCONFIG_SLIP
+# include <net/if_slip.h>
+#endif
+
+/* I don't know if this is needed for busybox or not.  Anyone? */
+#define QUESTIONABLE_ALIAS_CASE
+
+
+/* Defines for glibc2.0 users. */
+#ifndef SIOCSIFTXQLEN
+# define SIOCSIFTXQLEN      0x8943
+# define SIOCGIFTXQLEN      0x8942
+#endif
+
+/* ifr_qlen is ifru_ivalue, but it isn't present in 2.0 kernel headers */
+#ifndef ifr_qlen
+# define ifr_qlen        ifr_ifru.ifru_mtu
+#endif
+
+#ifndef IFF_DYNAMIC
+# define IFF_DYNAMIC     0x8000	/* dialup device with changing addresses */
+#endif
+
+#if ENABLE_FEATURE_IPV6
+struct in6_ifreq {
+	struct in6_addr ifr6_addr;
+	uint32_t ifr6_prefixlen;
+	int ifr6_ifindex;
+};
+#endif
+
+/*
+ * Here are the bit masks for the "flags" member of struct options below.
+ * N_ signifies no arg prefix; M_ signifies arg prefixed by '-'.
+ * CLR clears the flag; SET sets the flag; ARG signifies (optional) arg.
+ */
+#define N_CLR            0x01
+#define M_CLR            0x02
+#define N_SET            0x04
+#define M_SET            0x08
+#define N_ARG            0x10
+#define M_ARG            0x20
+
+#define M_MASK           (M_CLR | M_SET | M_ARG)
+#define N_MASK           (N_CLR | N_SET | N_ARG)
+#define SET_MASK         (N_SET | M_SET)
+#define CLR_MASK         (N_CLR | M_CLR)
+#define SET_CLR_MASK     (SET_MASK | CLR_MASK)
+#define ARG_MASK         (M_ARG | N_ARG)
+
+/*
+ * Here are the bit masks for the "arg_flags" member of struct options below.
+ */
+
+/*
+ * cast type:
+ *   00 int
+ *   01 char *
+ *   02 HOST_COPY in_ether
+ *   03 HOST_COPY INET_resolve
+ */
+#define A_CAST_TYPE      0x03
+/*
+ * map type:
+ *   00 not a map type (mem_start, io_addr, irq)
+ *   04 memstart (unsigned long)
+ *   08 io_addr  (unsigned short)
+ *   0C irq      (unsigned char)
+ */
+#define A_MAP_TYPE       0x0C
+#define A_ARG_REQ        0x10	/* Set if an arg is required. */
+#define A_NETMASK        0x20	/* Set if netmask (check for multiple sets). */
+#define A_SET_AFTER      0x40	/* Set a flag at the end. */
+#define A_COLON_CHK      0x80	/* Is this needed?  See below. */
+#if ENABLE_FEATURE_IFCONFIG_BROADCAST_PLUS
+#define A_HOSTNAME      0x100	/* Set if it is ip addr. */
+#define A_BROADCAST     0x200	/* Set if it is broadcast addr. */
+#else
+#define A_HOSTNAME          0
+#define A_BROADCAST         0
+#endif
+
+/*
+ * These defines are for dealing with the A_CAST_TYPE field.
+ */
+#define A_CAST_CHAR_PTR  0x01
+#define A_CAST_RESOLVE   0x01
+#define A_CAST_HOST_COPY 0x02
+#define A_CAST_HOST_COPY_IN_ETHER    A_CAST_HOST_COPY
+#define A_CAST_HOST_COPY_RESOLVE     (A_CAST_HOST_COPY | A_CAST_RESOLVE)
+
+/*
+ * These defines are for dealing with the A_MAP_TYPE field.
+ */
+#define A_MAP_ULONG      0x04	/* memstart */
+#define A_MAP_USHORT     0x08	/* io_addr */
+#define A_MAP_UCHAR      0x0C	/* irq */
+
+/*
+ * Define the bit masks signifying which operations to perform for each arg.
+ */
+
+#define ARG_METRIC       (A_ARG_REQ /*| A_CAST_INT*/)
+#define ARG_MTU          (A_ARG_REQ /*| A_CAST_INT*/)
+#define ARG_TXQUEUELEN   (A_ARG_REQ /*| A_CAST_INT*/)
+#define ARG_MEM_START    (A_ARG_REQ | A_MAP_ULONG)
+#define ARG_IO_ADDR      (A_ARG_REQ | A_MAP_ULONG)
+#define ARG_IRQ          (A_ARG_REQ | A_MAP_UCHAR)
+#define ARG_DSTADDR      (A_ARG_REQ | A_CAST_HOST_COPY_RESOLVE)
+#define ARG_NETMASK      (A_ARG_REQ | A_CAST_HOST_COPY_RESOLVE | A_NETMASK)
+#define ARG_BROADCAST    (A_ARG_REQ | A_CAST_HOST_COPY_RESOLVE | A_SET_AFTER | A_BROADCAST)
+#define ARG_HW           (A_ARG_REQ | A_CAST_HOST_COPY_IN_ETHER)
+#define ARG_POINTOPOINT  (A_ARG_REQ | A_CAST_HOST_COPY_RESOLVE | A_SET_AFTER)
+#define ARG_KEEPALIVE    (A_ARG_REQ | A_CAST_CHAR_PTR)
+#define ARG_OUTFILL      (A_ARG_REQ | A_CAST_CHAR_PTR)
+#define ARG_HOSTNAME     (A_CAST_HOST_COPY_RESOLVE | A_SET_AFTER | A_COLON_CHK | A_HOSTNAME)
+#define ARG_ADD_DEL      (A_CAST_HOST_COPY_RESOLVE | A_SET_AFTER)
+
+
+/*
+ * Set up the tables.  Warning!  They must have corresponding order!
+ */
+
+struct arg1opt {
+	const char *name;
+	int selector;
+	unsigned short ifr_offset;
+};
+
+struct options {
+	const char *name;
+#if ENABLE_FEATURE_IFCONFIG_BROADCAST_PLUS
+	const unsigned int flags:6;
+	const unsigned int arg_flags:10;
+#else
+	const unsigned char flags;
+	const unsigned char arg_flags;
+#endif
+	const unsigned short selector;
+};
+
+#define ifreq_offsetof(x)  offsetof(struct ifreq, x)
+
+static const struct arg1opt Arg1Opt[] = {
+	{"SIOCSIFMETRIC",  SIOCSIFMETRIC,  ifreq_offsetof(ifr_metric)},
+	{"SIOCSIFMTU",     SIOCSIFMTU,     ifreq_offsetof(ifr_mtu)},
+	{"SIOCSIFTXQLEN",  SIOCSIFTXQLEN,  ifreq_offsetof(ifr_qlen)},
+	{"SIOCSIFDSTADDR", SIOCSIFDSTADDR, ifreq_offsetof(ifr_dstaddr)},
+	{"SIOCSIFNETMASK", SIOCSIFNETMASK, ifreq_offsetof(ifr_netmask)},
+	{"SIOCSIFBRDADDR", SIOCSIFBRDADDR, ifreq_offsetof(ifr_broadaddr)},
+#if ENABLE_FEATURE_IFCONFIG_HW
+	{"SIOCSIFHWADDR",  SIOCSIFHWADDR,  ifreq_offsetof(ifr_hwaddr)},
+#endif
+	{"SIOCSIFDSTADDR", SIOCSIFDSTADDR, ifreq_offsetof(ifr_dstaddr)},
+#ifdef SIOCSKEEPALIVE
+	{"SIOCSKEEPALIVE", SIOCSKEEPALIVE, ifreq_offsetof(ifr_data)},
+#endif
+#ifdef SIOCSOUTFILL
+	{"SIOCSOUTFILL",   SIOCSOUTFILL,   ifreq_offsetof(ifr_data)},
+#endif
+#if ENABLE_FEATURE_IFCONFIG_MEMSTART_IOADDR_IRQ
+	{"SIOCSIFMAP",     SIOCSIFMAP,     ifreq_offsetof(ifr_map.mem_start)},
+	{"SIOCSIFMAP",     SIOCSIFMAP,     ifreq_offsetof(ifr_map.base_addr)},
+	{"SIOCSIFMAP",     SIOCSIFMAP,     ifreq_offsetof(ifr_map.irq)},
+#endif
+	/* Last entry if for unmatched (possibly hostname) arg. */
+#if ENABLE_FEATURE_IPV6
+	{"SIOCSIFADDR",    SIOCSIFADDR,    ifreq_offsetof(ifr_addr)}, /* IPv6 version ignores the offset */
+	{"SIOCDIFADDR",    SIOCDIFADDR,    ifreq_offsetof(ifr_addr)}, /* IPv6 version ignores the offset */
+#endif
+	{"SIOCSIFADDR",    SIOCSIFADDR,    ifreq_offsetof(ifr_addr)},
+};
+
+static const struct options OptArray[] = {
+	{"metric",      N_ARG,         ARG_METRIC,      0},
+	{"mtu",         N_ARG,         ARG_MTU,         0},
+	{"txqueuelen",  N_ARG,         ARG_TXQUEUELEN,  0},
+	{"dstaddr",     N_ARG,         ARG_DSTADDR,     0},
+	{"netmask",     N_ARG,         ARG_NETMASK,     0},
+	{"broadcast",   N_ARG | M_CLR, ARG_BROADCAST,   IFF_BROADCAST},
+#if ENABLE_FEATURE_IFCONFIG_HW
+	{"hw",          N_ARG, ARG_HW,                  0},
+#endif
+	{"pointopoint", N_ARG | M_CLR, ARG_POINTOPOINT, IFF_POINTOPOINT},
+#ifdef SIOCSKEEPALIVE
+	{"keepalive",   N_ARG,         ARG_KEEPALIVE,   0},
+#endif
+#ifdef SIOCSOUTFILL
+	{"outfill",     N_ARG,         ARG_OUTFILL,     0},
+#endif
+#if ENABLE_FEATURE_IFCONFIG_MEMSTART_IOADDR_IRQ
+	{"mem_start",   N_ARG,         ARG_MEM_START,   0},
+	{"io_addr",     N_ARG,         ARG_IO_ADDR,     0},
+	{"irq",         N_ARG,         ARG_IRQ,         0},
+#endif
+#if ENABLE_FEATURE_IPV6
+	{"add",         N_ARG,         ARG_ADD_DEL,     0},
+	{"del",         N_ARG,         ARG_ADD_DEL,     0},
+#endif
+	{"arp",         N_CLR | M_SET, 0,               IFF_NOARP},
+	{"trailers",    N_CLR | M_SET, 0,               IFF_NOTRAILERS},
+	{"promisc",     N_SET | M_CLR, 0,               IFF_PROMISC},
+	{"multicast",   N_SET | M_CLR, 0,               IFF_MULTICAST},
+	{"allmulti",    N_SET | M_CLR, 0,               IFF_ALLMULTI},
+	{"dynamic",     N_SET | M_CLR, 0,               IFF_DYNAMIC},
+	{"up",          N_SET,         0,               (IFF_UP | IFF_RUNNING)},
+	{"down",        N_CLR,         0,               IFF_UP},
+	{NULL,          0,             ARG_HOSTNAME,    (IFF_UP | IFF_RUNNING)}
+};
+
+/*
+ * A couple of prototypes.
+ */
+
+#if ENABLE_FEATURE_IFCONFIG_HW
+static int in_ether(const char *bufp, struct sockaddr *sap);
+#endif
+
+#if ENABLE_FEATURE_IFCONFIG_STATUS
+extern int interface_opt_a;
+extern int display_interfaces(char *ifname);
+#endif
+
+/*
+ * Our main function.
+ */
+
+int ifconfig_main(int argc, char **argv)
+{
+	struct ifreq ifr;
+	struct sockaddr_in sai;
+#if ENABLE_FEATURE_IPV6
+	struct sockaddr_in6 sai6;
+#endif
+#if ENABLE_FEATURE_IFCONFIG_HW
+	struct sockaddr sa;
+#endif
+	const struct arg1opt *a1op;
+	const struct options *op;
+	int sockfd;			/* socket fd we use to manipulate stuff with */
+	int selector;
+#if ENABLE_FEATURE_IFCONFIG_BROADCAST_PLUS
+	unsigned int mask;
+	unsigned int did_flags;
+	unsigned int sai_hostname, sai_netmask;
+#else
+	unsigned char mask;
+	unsigned char did_flags;
+#endif
+	char *p;
+	/*char host[128];*/
+	const char *host = NULL; /* make gcc happy */
+
+	did_flags = 0;
+#if ENABLE_FEATURE_IFCONFIG_BROADCAST_PLUS
+	sai_hostname = 0;
+	sai_netmask = 0;
+#endif
+
+	/* skip argv[0] */
+	++argv;
+	--argc;
+
+#if ENABLE_FEATURE_IFCONFIG_STATUS
+	if (argc > 0 && (argv[0][0] == '-' && argv[0][1] == 'a' && !argv[0][2])) {
+		interface_opt_a = 1;
+		--argc;
+		++argv;
+	}
+#endif
+
+	if (argc <= 1) {
+#if ENABLE_FEATURE_IFCONFIG_STATUS
+		return display_interfaces(argc ? *argv : NULL);
+#else
+		bb_error_msg_and_die("no support for status display");
+#endif
+	}
+
+	/* Create a channel to the NET kernel. */
+	sockfd = xsocket(AF_INET, SOCK_DGRAM, 0);
+
+	/* get interface name */
+	safe_strncpy(ifr.ifr_name, *argv, IFNAMSIZ);
+
+	/* Process the remaining arguments. */
+	while (*++argv != (char *) NULL) {
+		p = *argv;
+		mask = N_MASK;
+		if (*p == '-') {	/* If the arg starts with '-'... */
+			++p;		/*    advance past it and */
+			mask = M_MASK;	/*    set the appropriate mask. */
+		}
+		for (op = OptArray; op->name; op++) {	/* Find table entry. */
+			if (strcmp(p, op->name) == 0) {	/* If name matches... */
+				mask &= op->flags;
+				if (mask)	/* set the mask and go. */
+					goto FOUND_ARG;
+				/* If we get here, there was a valid arg with an */
+				/* invalid '-' prefix. */
+				bb_error_msg_and_die("bad: '%s'", p-1);
+			}
+		}
+
+		/* We fell through, so treat as possible hostname. */
+		a1op = Arg1Opt + (sizeof(Arg1Opt) / sizeof(Arg1Opt[0])) - 1;
+		mask = op->arg_flags;
+		goto HOSTNAME;
+
+ FOUND_ARG:
+		if (mask & ARG_MASK) {
+			mask = op->arg_flags;
+			a1op = Arg1Opt + (op - OptArray);
+			if (mask & A_NETMASK & did_flags)
+				bb_show_usage();
+			if (*++argv == NULL) {
+				if (mask & A_ARG_REQ)
+					bb_show_usage();
+				--argv;
+				mask &= A_SET_AFTER;	/* just for broadcast */
+			} else {	/* got an arg so process it */
+ HOSTNAME:
+				did_flags |= (mask & (A_NETMASK|A_HOSTNAME));
+				if (mask & A_CAST_HOST_COPY) {
+#if ENABLE_FEATURE_IFCONFIG_HW
+					if (mask & A_CAST_RESOLVE) {
+#endif
+#if ENABLE_FEATURE_IPV6
+						char *prefix;
+						int prefix_len = 0;
+#endif
+						/*safe_strncpy(host, *argv, (sizeof host));*/
+						host = *argv;
+#if ENABLE_FEATURE_IPV6
+						prefix = strchr(host, '/');
+						if (prefix) {
+							prefix_len = xatou_range(prefix + 1, 0, 128);
+							*prefix = '\0';
+						}
+#endif
+						sai.sin_family = AF_INET;
+						sai.sin_port = 0;
+						if (!strcmp(host, bb_str_default)) {
+							/* Default is special, meaning 0.0.0.0. */
+							sai.sin_addr.s_addr = INADDR_ANY;
+						}
+#if ENABLE_FEATURE_IFCONFIG_BROADCAST_PLUS
+						else if ((host[0] == '+' && !host[1]) && (mask & A_BROADCAST)
+						 && (did_flags & (A_NETMASK|A_HOSTNAME)) == (A_NETMASK|A_HOSTNAME)
+						) {
+							/* + is special, meaning broadcast is derived. */
+							sai.sin_addr.s_addr = (~sai_netmask) | (sai_hostname & sai_netmask);
+						}
+#endif
+#if ENABLE_FEATURE_IPV6
+						else if (inet_pton(AF_INET6, host, &sai6.sin6_addr) > 0) {
+							int sockfd6;
+							struct in6_ifreq ifr6;
+
+							memcpy((char *) &ifr6.ifr6_addr,
+									(char *) &sai6.sin6_addr,
+									sizeof(struct in6_addr));
+
+							/* Create a channel to the NET kernel. */
+							sockfd6 = xsocket(AF_INET6, SOCK_DGRAM, 0);
+							if (ioctl(sockfd6, SIOGIFINDEX, &ifr) < 0)
+								bb_perror_msg_and_die("SIOGIFINDEX");
+							ifr6.ifr6_ifindex = ifr.ifr_ifindex;
+							ifr6.ifr6_prefixlen = prefix_len;
+							if (ioctl(sockfd6, a1op->selector, &ifr6) < 0)
+								bb_perror_msg_and_die(a1op->name);
+							continue;
+						}
+#endif
+						else if (inet_aton(host, &sai.sin_addr) == 0) {
+							/* It's not a dotted quad. */
+							struct hostent *hp = xgethostbyname(host);
+							memcpy((char *) &sai.sin_addr, (char *) hp->h_addr_list[0],
+									sizeof(struct in_addr));
+						}
+#if ENABLE_FEATURE_IFCONFIG_BROADCAST_PLUS
+						if (mask & A_HOSTNAME)
+							sai_hostname = sai.sin_addr.s_addr;
+						if (mask & A_NETMASK)
+							sai_netmask = sai.sin_addr.s_addr;
+#endif
+						p = (char *) &sai;
+#if ENABLE_FEATURE_IFCONFIG_HW
+					} else {	/* A_CAST_HOST_COPY_IN_ETHER */
+						/* This is the "hw" arg case. */
+						if (strcmp("ether", *argv) || !*++argv)
+							bb_show_usage();
+						/*safe_strncpy(host, *argv, sizeof(host));*/
+						host = *argv;
+						if (in_ether(host, &sa))
+							bb_error_msg_and_die("invalid hw-addr %s", host);
+						p = (char *) &sa;
+					}
+#endif
+					memcpy( (((char *)&ifr) + a1op->ifr_offset),
+						   p, sizeof(struct sockaddr));
+				} else {
+					/* FIXME: error check?? */
+					unsigned long i = strtoul(*argv, NULL, 0);
+					p = ((char *)&ifr) + a1op->ifr_offset;
+#if ENABLE_FEATURE_IFCONFIG_MEMSTART_IOADDR_IRQ
+					if (mask & A_MAP_TYPE) {
+						if (ioctl(sockfd, SIOCGIFMAP, &ifr) < 0)
+							bb_perror_msg_and_die("SIOCGIFMAP");
+						if ((mask & A_MAP_UCHAR) == A_MAP_UCHAR)
+							*((unsigned char *) p) = i;
+						else if (mask & A_MAP_USHORT)
+							*((unsigned short *) p) = i;
+						else
+							*((unsigned long *) p) = i;
+					} else
+#endif
+					if (mask & A_CAST_CHAR_PTR)
+						*((caddr_t *) p) = (caddr_t) i;
+					else	/* A_CAST_INT */
+						*((int *) p) = i;
+				}
+
+				if (ioctl(sockfd, a1op->selector, &ifr) < 0)
+					bb_perror_msg_and_die(a1op->name);
+#ifdef QUESTIONABLE_ALIAS_CASE
+				if (mask & A_COLON_CHK) {
+					/*
+					 * Don't do the set_flag() if the address is an alias with
+					 * a '-' at the end, since it's deleted already! - Roman
+					 *
+					 * Should really use regex.h here, not sure though how well
+					 * it'll go with the cross-platform support etc.
+					 */
+					char *ptr;
+					short int found_colon = 0;
+					for (ptr = ifr.ifr_name; *ptr; ptr++)
+						if (*ptr == ':')
+							found_colon++;
+					if (found_colon && ptr[-1] == '-')
+						continue;
+				}
+#endif
+			}
+			if (!(mask & A_SET_AFTER))
+				continue;
+			mask = N_SET;
+		}
+
+		if (ioctl(sockfd, SIOCGIFFLAGS, &ifr) < 0)
+			bb_perror_msg_and_die("SIOCGIFFLAGS");
+		selector = op->selector;
+		if (mask & SET_MASK)
+			ifr.ifr_flags |= selector;
+		else
+			ifr.ifr_flags &= ~selector;
+		if (ioctl(sockfd, SIOCSIFFLAGS, &ifr) < 0)
+			bb_perror_msg_and_die("SIOCSIFFLAGS");
+	} /* while() */
+
+	if (ENABLE_FEATURE_CLEAN_UP)
+		close(sockfd);
+	return 0;
+}
+
+#if ENABLE_FEATURE_IFCONFIG_HW
+/* Input an Ethernet address and convert to binary. */
+static int in_ether(const char *bufp, struct sockaddr *sap)
+{
+	char *ptr;
+	int i, j;
+	unsigned char val;
+	unsigned char c;
+
+	sap->sa_family = ARPHRD_ETHER;
+	ptr = sap->sa_data;
+
+	i = 0;
+	do {
+		j = val = 0;
+
+		/* We might get a semicolon here - not required. */
+		if (i && (*bufp == ':')) {
+			bufp++;
+		}
+
+		do {
+			c = *bufp;
+			if (((unsigned char)(c - '0')) <= 9) {
+				c -= '0';
+			} else if (((unsigned char)((c|0x20) - 'a')) <= 5) {
+				c = (c|0x20) - ('a'-10);
+			} else if (j && (c == ':' || c == 0)) {
+				break;
+			} else {
+				return -1;
+			}
+			++bufp;
+			val <<= 4;
+			val += c;
+		} while (++j < 2);
+		*ptr++ = val;
+	} while (++i < ETH_ALEN);
+
+	return *bufp; /* Error if we don't end at end of string. */
+}
+#endif
diff --git a/networking/ifupdown.c b/networking/ifupdown.c
new file mode 100644
index 0000000..76ff2a8
--- /dev/null
+++ b/networking/ifupdown.c
@@ -0,0 +1,1270 @@
+/* vi: set sw=4 ts=4: */
+/*
+ *  ifupdown for busybox
+ *  Copyright (c) 2002 Glenn McGrath <bug1@iinet.net.au>
+ *  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>
+ *
+ *  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.
+ *
+ * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+ */
+
+#include "busybox.h"
+#include <sys/utsname.h>
+#include <fnmatch.h>
+#include <getopt.h>
+
+#define MAX_OPT_DEPTH 10
+#define EUNBALBRACK 10001
+#define EUNDEFVAR   10002
+#define EUNBALPER   10000
+
+#ifdef CONFIG_FEATURE_IFUPDOWN_MAPPING
+#define MAX_INTERFACE_LENGTH 10
+#endif
+
+#define debug_noise(fmt, args...)
+
+/* Forward declaration */
+struct interface_defn_t;
+
+typedef int execfn(char *command);
+
+struct method_t
+{
+	char *name;
+	int (*up)(struct interface_defn_t *ifd, execfn *e);
+	int (*down)(struct interface_defn_t *ifd, execfn *e);
+};
+
+struct address_family_t
+{
+	char *name;
+	int n_methods;
+	const struct method_t *method;
+};
+
+struct mapping_defn_t
+{
+	struct mapping_defn_t *next;
+
+	int max_matches;
+	int n_matches;
+	char **match;
+
+	char *script;
+
+	int max_mappings;
+	int n_mappings;
+	char **mapping;
+};
+
+struct variable_t
+{
+	char *name;
+	char *value;
+};
+
+struct interface_defn_t
+{
+	const struct address_family_t *address_family;
+	const struct method_t *method;
+
+	char *iface;
+	int max_options;
+	int n_options;
+	struct variable_t *option;
+};
+
+struct interfaces_file_t
+{
+	llist_t *autointerfaces;
+	llist_t *ifaces;
+	struct mapping_defn_t *mappings;
+};
+
+#define OPTION_STR "anvf" USE_FEATURE_IFUPDOWN_MAPPING("m") "i:"
+enum {
+	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 NO_MAPPINGS (option_mask32 & OPT_no_mappings)
+
+static char **__myenviron;
+
+static char *startup_PATH;
+
+#if ENABLE_FEATURE_IFUPDOWN_IPV4 || ENABLE_FEATURE_IFUPDOWN_IPV6
+
+#ifdef CONFIG_FEATURE_IFUPDOWN_IP
+
+static unsigned count_bits(unsigned a)
+{
+	unsigned result;
+	result = (a & 0x55) + ((a >> 1) & 0x55);
+	result = (result & 0x33) + ((result >> 2) & 0x33);
+	return (result & 0x0F) + ((result >> 4) & 0x0F);
+}
+
+static int count_netmask_bits(char *dotted_quad)
+{
+	unsigned result, a, b, c, d;
+	/* Found a netmask...  Check if it is dotted quad */
+	if (sscanf(dotted_quad, "%u.%u.%u.%u", &a, &b, &c, &d) != 4)
+		return -1;
+	// FIXME: will be confused by e.g. 255.0.255.0
+	result = count_bits(a);
+	result += count_bits(b);
+	result += count_bits(c);
+	result += count_bits(d);
+	return (int)result;
+}
+#endif
+
+static void addstr(char **bufp, const char *str, size_t str_length)
+{
+	/* xasprintf trick will be smaller, but we are often
+	 * called with str_length == 1 - don't want to have
+	 * THAT much of malloc/freeing! */
+	char *buf = *bufp;
+	int len = (buf ? strlen(buf) : 0);
+	str_length++;
+	buf = xrealloc(buf, len + str_length);
+	/* copies at most str_length-1 chars! */
+	safe_strncpy(buf + len, str, str_length);
+	*bufp = buf;
+}
+
+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 i;
+}
+
+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;
+	}
+	if (strncmpz(id, "label", idlen) == 0) {
+		return ifd->iface;
+	}
+	for (i = 0; i < ifd->n_options; i++) {
+		if (strncmpz(id, ifd->option[i].name, idlen) == 0) {
+			return ifd->option[i].value;
+		}
+	}
+	return NULL;
+}
+
+static char *parse(const char *command, struct interface_defn_t *ifd)
+{
+	char *result = NULL;
+	size_t old_pos[MAX_OPT_DEPTH] = { 0 };
+	int okay[MAX_OPT_DEPTH] = { 1 };
+	int opt_depth = 1;
+
+	while (*command) {
+		switch (*command) {
+		default:
+			addstr(&result, command, 1);
+			command++;
+			break;
+		case '\\':
+			if (command[1]) {
+				addstr(&result, command + 1, 1);
+				command += 2;
+			} else {
+				addstr(&result, command, 1);
+				command++;
+			}
+			break;
+		case '[':
+			if (command[1] == '[' && opt_depth < MAX_OPT_DEPTH) {
+				old_pos[opt_depth] = strlen(result);
+				okay[opt_depth] = 1;
+				opt_depth++;
+				command += 2;
+			} else {
+				addstr(&result, "[", 1);
+				command++;
+			}
+			break;
+		case ']':
+			if (command[1] == ']' && opt_depth > 1) {
+				opt_depth--;
+				if (!okay[opt_depth]) {
+					result[old_pos[opt_depth]] = '\0';
+				}
+				command += 2;
+			} else {
+				addstr(&result, "]", 1);
+				command++;
+			}
+			break;
+		case '%':
+			{
+				char *nextpercent;
+				char *varvalue;
+
+				command++;
+				nextpercent = strchr(command, '%');
+				if (!nextpercent) {
+					errno = EUNBALPER;
+					free(result);
+					return NULL;
+				}
+
+				varvalue = get_var(command, nextpercent - command, ifd);
+
+				if (varvalue) {
+					addstr(&result, varvalue, strlen(varvalue));
+				} else {
+#ifdef CONFIG_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) {
+						unsigned res;
+						varvalue = get_var("netmask", 7, ifd);
+						if (varvalue && (res = count_netmask_bits(varvalue)) > 0) {
+							const char *argument = utoa(res);
+							addstr(&result, argument, strlen(argument));
+							command = nextpercent + 1;
+							break;
+						}
+					}
+#endif
+					okay[opt_depth - 1] = 0;
+				}
+
+				command = nextpercent + 1;
+			}
+			break;
+		}
+	}
+
+	if (opt_depth > 1) {
+		errno = EUNBALBRACK;
+		free(result);
+		return NULL;
+	}
+
+	if (!okay[0]) {
+		errno = EUNDEFVAR;
+		free(result);
+		return NULL;
+	}
+
+	return result;
+}
+
+/* execute() returns 1 for success and 0 for failure */
+static int execute(const char *command, struct interface_defn_t *ifd, execfn *exec)
+{
+	char *out;
+	int ret;
+
+	out = parse(command, ifd);
+	if (!out) {
+		return 0;
+	}
+	ret = (*exec)(out);
+
+	free(out);
+	if (ret != 1) {
+		return 0;
+	}
+	return 1;
+}
+#endif
+
+#ifdef CONFIG_FEATURE_IFUPDOWN_IPV6
+static int loopback_up6(struct interface_defn_t *ifd, execfn *exec)
+{
+#ifdef CONFIG_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
+	return execute("ifconfig %iface% add ::1", ifd, exec);
+#endif
+}
+
+static int loopback_down6(struct interface_defn_t *ifd, execfn *exec)
+{
+#ifdef CONFIG_FEATURE_IFUPDOWN_IP
+	return execute("ip link set %iface% down", ifd, exec);
+#else
+	return execute("ifconfig %iface% del ::1", ifd, exec);
+#endif
+}
+
+static int static_up6(struct interface_defn_t *ifd, execfn *exec)
+{
+	int result;
+#ifdef CONFIG_FEATURE_IFUPDOWN_IP
+	result = execute("ip addr add %address%/%netmask% dev %iface% [[label %label%]]", ifd, exec);
+	result += execute("ip link set [[mtu %mtu%]] [[address %hwaddress%]] %iface% up", ifd, exec);
+	result += execute("[[ ip route add ::/0 via %gateway% ]]", 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
+	return ((result == 3) ? 3 : 0);
+}
+
+static int static_down6(struct interface_defn_t *ifd, execfn *exec)
+{
+#ifdef CONFIG_FEATURE_IFUPDOWN_IP
+	return execute("ip link set %iface% down", ifd, exec);
+#else
+	return execute("ifconfig %iface% down", ifd, exec);
+#endif
+}
+
+#ifdef CONFIG_FEATURE_IFUPDOWN_IP
+static int 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);
+	return ((result == 4) ? 4 : 0);
+}
+
+static int v4tunnel_down(struct interface_defn_t * ifd, execfn * exec)
+{
+	return execute("ip tunnel del %iface%", ifd, exec);
+}
+#endif
+
+static const struct method_t methods6[] = {
+#ifdef CONFIG_FEATURE_IFUPDOWN_IP
+	{ "v4tunnel", v4tunnel_up, v4tunnel_down, },
+#endif
+	{ "static", static_up6, static_down6, },
+	{ "loopback", loopback_up6, loopback_down6, },
+};
+
+static const struct address_family_t addr_inet6 = {
+	"inet6",
+	sizeof(methods6) / sizeof(struct method_t),
+	methods6
+};
+#endif /* CONFIG_FEATURE_IFUPDOWN_IPV6 */
+
+#ifdef CONFIG_FEATURE_IFUPDOWN_IPV4
+static int loopback_up(struct interface_defn_t *ifd, execfn *exec)
+{
+#ifdef CONFIG_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
+	return execute("ifconfig %iface% 127.0.0.1 up", ifd, exec);
+#endif
+}
+
+static int loopback_down(struct interface_defn_t *ifd, execfn *exec)
+{
+#ifdef CONFIG_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
+	return execute("ifconfig %iface% 127.0.0.1 down", ifd, exec);
+#endif
+}
+
+static int static_up(struct interface_defn_t *ifd, execfn *exec)
+{
+	int result;
+#ifdef CONFIG_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);
+	return ((result == 3) ? 3 : 0);
+#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%]] ",
+				ifd, exec);
+ 	result += execute("[[ route add default gw %gateway% %iface% ]]", ifd, exec);
+	return ((result == 3) ? 3 : 0);
+#endif
+}
+
+static int static_down(struct interface_defn_t *ifd, execfn *exec)
+{
+	int result;
+#ifdef CONFIG_FEATURE_IFUPDOWN_IP
+	result = execute("ip addr flush dev %iface%", ifd, exec);
+	result += execute("ip link set %iface% down", ifd, exec);
+#else
+	result = execute("[[ route del default gw %gateway% %iface% ]]", ifd, exec);
+	result += execute("ifconfig %iface% down", ifd, exec);
+#endif
+	return ((result == 2) ? 2 : 0);
+}
+
+#ifndef CONFIG_APP_UDHCPC
+struct dhcp_client_t
+{
+	const char *name;
+	const char *startcmd;
+	const char *stopcmd;
+};
+
+static const struct dhcp_client_t ext_dhcp_clients[] = {
+	{ "udhcpc",
+		"udhcpc -R -n -p /var/run/udhcpc.%iface%.pid -i %iface% [[-H %hostname%]] [[-c %clientid%]] [[-s %script%]]",
+		"kill -TERM `cat /var/run/udhcpc.%iface%.pid` 2>/dev/null",
+	},
+	{ "pump",
+		"pump -i %iface% [[-h %hostname%]] [[-l %leasehours%]]",
+		"pump -i %iface% -k",
+	},
+	{ "dhclient",
+		"dhclient -pf /var/run/dhclient.%iface%.pid %iface%",
+		"kill -9 `cat /var/run/dhclient.%iface%.pid` 2>/dev/null",
+	},
+	{ "dhcpcd",
+		"dhcpcd [[-h %hostname%]] [[-i %vendor%]] [[-I %clientid%]] [[-l %leasetime%]] %iface%",
+		"dhcpcd -k %iface%",
+	},
+};
+#endif
+
+static int dhcp_up(struct interface_defn_t *ifd, execfn *exec)
+{
+#ifdef CONFIG_APP_UDHCPC
+	return execute("udhcpc -R -n -p /var/run/udhcpc.%iface%.pid "
+			"-i %iface% [[-H %hostname%]] [[-c %clientid%]] [[-s %script%]]",
+			ifd, exec);
+#else
+	int i, nclients = sizeof(ext_dhcp_clients) / sizeof(ext_dhcp_clients[0]);
+	for (i = 0; i < nclients; i++) {
+		if (exists_execable(ext_dhcp_clients[i].name))
+			return execute(ext_dhcp_clients[i].startcmd, ifd, exec);
+	}
+	bb_error_msg("no dhcp clients found");
+	return 0;
+#endif
+}
+
+static int dhcp_down(struct interface_defn_t *ifd, execfn *exec)
+{
+#ifdef CONFIG_APP_UDHCPC
+	return execute("kill -TERM "
+	               "`cat /var/run/udhcpc.%iface%.pid` 2>/dev/null", ifd, exec);
+#else
+	int i, nclients = sizeof(ext_dhcp_clients) / sizeof(ext_dhcp_clients[0]);
+	for (i = 0; i < nclients; i++) {
+		if (exists_execable(ext_dhcp_clients[i].name))
+			return execute(ext_dhcp_clients[i].stopcmd, ifd, exec);
+	}
+	bb_error_msg("no dhcp clients found, using static interface shutdown");
+	return static_down(ifd, exec);
+#endif
+}
+
+static int manual_up_down(struct interface_defn_t *ifd, execfn *exec)
+{
+	return 1;
+}
+
+static int 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)
+{
+	return execute("pon [[%provider%]]", ifd, exec);
+}
+
+static int 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)
+{
+	return execute("/sbin/start-stop-daemon --start -x /usr/bin/wvdial "
+		"-p /var/run/wvdial.%iface% -b -m -- [[ %provider% ]]", ifd, exec);
+}
+
+static int wvdial_down(struct interface_defn_t *ifd, execfn *exec)
+{
+	return execute("/sbin/start-stop-daemon --stop -x /usr/bin/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, },
+};
+
+static const struct address_family_t addr_inet = {
+	"inet",
+	sizeof(methods) / sizeof(struct method_t),
+	methods
+};
+
+#endif	/* ifdef CONFIG_FEATURE_IFUPDOWN_IPV4 */
+
+static char *next_word(char **buf)
+{
+	unsigned short length;
+	char *word;
+
+	if (!buf || !*buf || !**buf) {
+		return NULL;
+	}
+
+	/* Skip over leading whitespace */
+	word = skip_whitespace(*buf);
+
+	/* Skip over comments */
+	if (*word == '#') {
+		return NULL;
+	}
+
+	/* Find the length of this word */
+	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)++;
+	}
+
+	return word;
+}
+
+static const struct address_family_t *get_address_family(const struct address_family_t *const af[], char *name)
+{
+	int i;
+
+	if (!name)
+		return NULL;
+
+	for (i = 0; af[i]; i++) {
+		if (strcmp(af[i]->name, name) == 0) {
+			return af[i];
+		}
+	}
+	return NULL;
+}
+
+static const struct method_t *get_method(const struct address_family_t *af, char *name)
+{
+	int i;
+
+	if (!name)
+		return NULL;
+
+	for (i = 0; i < af->n_methods; i++) {
+		if (strcmp(af->method[i].name, name) == 0) {
+			return &af->method[i];
+		}
+	}
+	return NULL;
+}
+
+static const llist_t *find_list_string(const llist_t *list, const char *string)
+{
+	if (string == NULL)
+		return NULL;
+
+	while (list) {
+		if (strcmp(list->data, string) == 0) {
+			return list;
+		}
+		list = list->link;
+	}
+	return NULL;
+}
+
+static struct interfaces_file_t *read_interfaces(const char *filename)
+{
+#ifdef CONFIG_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;
+
+	enum { NONE, IFACE, MAPPING } currently_processing = NONE;
+
+	defn = xzalloc(sizeof(struct interfaces_file_t));
+
+	f = xfopen(filename, "r");
+
+	while ((buf = xmalloc_getline(f)) != NULL) {
+		char *buf_ptr = buf;
+
+		firstword = next_word(&buf_ptr);
+		if (firstword == NULL) {
+			free(buf);
+			continue;	/* blank line */
+		}
+
+		if (strcmp(firstword, "mapping") == 0) {
+#ifdef CONFIG_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->match[currmap->n_matches++] = xstrdup(firstword);
+			}
+			currmap->max_mappings = 0;
+			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;
+			}
+			debug_noise("Added mapping\n");
+#endif
+			currently_processing = MAPPING;
+		} else if (strcmp(firstword, "iface") == 0) {
+			static const struct address_family_t *const addr_fams[] = {
+#ifdef CONFIG_FEATURE_IFUPDOWN_IPV4
+				&addr_inet,
+#endif
+#ifdef CONFIG_FEATURE_IFUPDOWN_IPV6
+				&addr_inet6,
+#endif
+				NULL
+			};
+
+			char *iface_name;
+			char *address_family_name;
+			char *method_name;
+			llist_t *iface_list;
+
+			currif = xzalloc(sizeof(struct interface_defn_t));
+			iface_name = next_word(&buf_ptr);
+			address_family_name = next_word(&buf_ptr);
+			method_name = next_word(&buf_ptr);
+
+			if (buf_ptr == NULL) {
+				bb_error_msg("too few parameters for line \"%s\"", buf);
+				return NULL;
+			}
+
+			/* ship any trailing whitespace */
+			buf_ptr = skip_whitespace(buf_ptr);
+
+			if (buf_ptr[0] != '\0') {
+				bb_error_msg("too many parameters \"%s\"", buf);
+				return NULL;
+			}
+
+			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;
+			}
+
+			currif->method = get_method(currif->address_family, method_name);
+			if (!currif->method) {
+				bb_error_msg("unknown method \"%s\"", method_name);
+				return NULL;
+			}
+
+			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;
+				}
+			}
+			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) {
+
+				/* Check the interface isnt already listed */
+				if (find_list_string(defn->autointerfaces, firstword)) {
+					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);
+			}
+			currently_processing = NONE;
+		} else {
+			switch (currently_processing) {
+			case IFACE:
+				{
+					int i;
+
+					if (strlen(buf_ptr) == 0) {
+						bb_error_msg("option with empty value \"%s\"", buf);
+						return NULL;
+					}
+
+					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 (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);
+				currif->n_options++;
+				break;
+			case MAPPING:
+#ifdef CONFIG_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));
+					currmap->n_mappings++;
+				} else {
+					bb_error_msg("misplaced option \"%s\"", buf);
+					return NULL;
+				}
+#endif
+				break;
+			case NONE:
+			default:
+				bb_error_msg("misplaced option \"%s\"", buf);
+				return NULL;
+			}
+		}
+		free(buf);
+	}
+	if (ferror(f) != 0) {
+		bb_perror_msg_and_die("%s", filename);
+	}
+	fclose(f);
+
+	return defn;
+}
+
+static char *setlocalenv(char *format, const char *name, const char *value)
+{
+	char *result;
+	char *here;
+	char *there;
+
+	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++;
+		}
+	}
+	memmove(here, there, strlen(there) + 1);
+
+	return result;
+}
+
+static void set_environ(struct interface_defn_t *iface, const char *mode)
+{
+	char **environend;
+	int i;
+	const int n_env_entries = iface->n_options + 5;
+	char **ppch;
+
+	if (__myenviron != NULL) {
+		for (ppch = __myenviron; *ppch; ppch++) {
+			free(*ppch);
+			*ppch = NULL;
+		}
+		free(__myenviron);
+	}
+	__myenviron = xzalloc(sizeof(char *) * (n_env_entries + 1 /* for final NULL */ ));
+	environend = __myenviron;
+
+	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) {
+			continue;
+		}
+		*(environend++) = 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);
+}
+
+static int doit(char *str)
+{
+	if (option_mask32 & (OPT_no_act|OPT_verbose)) {
+		puts(str);
+	}
+	if (!(option_mask32 & OPT_no_act)) {
+		pid_t child;
+		int status;
+
+		fflush(NULL);
+		switch (child = fork()) {
+		case -1:		/* failure */
+			return 0;
+		case 0:		/* child */
+			execle(DEFAULT_SHELL, DEFAULT_SHELL, "-c", str, NULL, __myenviron);
+			exit(127);
+		}
+		waitpid(child, &status, 0);
+		if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
+			return 0;
+		}
+	}
+	return 1;
+}
+
+static int execute_all(struct interface_defn_t *ifd, const char *opt)
+{
+	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)) {
+				return 0;
+			}
+		}
+	}
+
+	buf = xasprintf("run-parts /etc/network/if-%s.d", opt);
+	if (doit(buf) != 1) {
+		return 0;
+	}
+	return 1;
+}
+
+static int check(char *str) {
+	return str != NULL;
+}
+
+static int iface_up(struct interface_defn_t *iface)
+{
+	if (!iface->method->up(iface,check)) return -1;
+	set_environ(iface, "start");
+	if (!execute_all(iface, "pre-up")) return 0;
+	if (!iface->method->up(iface, doit)) return 0;
+	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 (!execute_all(iface, "down")) return 0;
+	if (!iface->method->down(iface, doit)) return 0;
+	if (!execute_all(iface, "post-down")) return 0;
+	return 1;
+}
+
+#ifdef CONFIG_FEATURE_IFUPDOWN_MAPPING
+static int popen2(FILE **in, FILE **out, char *command, ...)
+{
+	va_list ap;
+	char *argv[11] = { command };
+	int argc;
+	int infd[2], outfd[2];
+	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;
+	}
+
+	if (pipe(outfd) != 0) {
+		close(infd[0]);
+		close(infd[1]);
+		return 0;
+	}
+
+	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]);
+		execvp(command, argv);
+		exit(127);
+	default:			/* parent */
+		*in = fdopen(infd[1], "w");
+		*out = fdopen(outfd[0], "r");
+		close(infd[0]);
+		close(outfd[1]);
+		return pid;
+	}
+	/* unreached */
+}
+
+static char *run_mapping(char *physical, struct mapping_defn_t * map)
+{
+	FILE *in, *out;
+	int i, status;
+	pid_t pid;
+
+	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;
+
+	/* 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);
+
+	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 = (char *)xmalloc(MAX_INTERFACE_LENGTH);
+
+		if (fgets(new_logical, MAX_INTERFACE_LENGTH, out)) {
+			/* 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. */
+			char *pch = new_logical + strlen(new_logical) - 1;
+
+			while (pch >= new_logical && isspace(*pch))
+				*(pch--) = '\0';
+
+			free(logical);
+			logical = new_logical;
+		} else {
+			/* If we are UNABLE to read a line of output, discard our
+			 * freshly allocated memory. */
+			free(new_logical);
+		}
+	}
+
+	fclose(out);
+
+	return logical;
+}
+#endif /* CONFIG_FEATURE_IFUPDOWN_MAPPING */
+
+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] == '=')) {
+			return search;
+		}
+		search = search->link;
+	}
+	return NULL;
+}
+
+int ifupdown_main(int argc, char **argv)
+{
+	static const char statefile[] = "/var/run/ifstate";
+
+	int (*cmds)(struct interface_defn_t *) = NULL;
+	struct interfaces_file_t *defn;
+	llist_t *state_list = NULL;
+	llist_t *target_list = NULL;
+	const char *interfaces = "/etc/network/interfaces";
+	int any_failures = 0;
+
+	if (applet_name[2] == 'u') {
+		/* ifup command */
+		cmds = iface_up;
+	} else {
+		/* ifdown command */
+		cmds = iface_down;
+	}
+
+	getopt32(argc, argv, OPTION_STR, &interfaces);
+	if (argc - optind > 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) {
+		exit(EXIT_FAILURE);
+	}
+
+	startup_PATH = getenv("PATH");
+	if (!startup_PATH) startup_PATH = "";
+
+	/* Create a list of interfaces to work on */
+	if (DO_ALL) {
+		if (cmds == iface_up) {
+			target_list = defn->autointerfaces;
+		} else {
+			/* iface_down */
+			const llist_t *list = state_list;
+			while (list) {
+				llist_add_to_end(&target_list, xstrdup(list->data));
+				list = list->link;
+			}
+			target_list = defn->autointerfaces;
+		}
+	} else {
+		llist_add_to_end(&target_list, argv[optind]);
+	}
+
+
+	/* Update the interfaces */
+	while (target_list) {
+		llist_t *iface_list;
+		struct interface_defn_t *currif;
+		char *iface;
+		char *liface;
+		char *pch;
+		int okay = 0;
+		int cmds_ret;
+
+		iface = xstrdup(target_list->data);
+		target_list = target_list->link;
+
+		pch = strchr(iface, '=');
+		if (pch) {
+			*pch = '\0';
+			liface = xstrdup(pch + 1);
+		} else {
+			liface = xstrdup(iface);
+		}
+
+		if (!FORCE) {
+			const llist_t *iface_state = find_iface_state(state_list, iface);
+
+			if (cmds == iface_up) {
+				/* ifup */
+				if (iface_state) {
+					bb_error_msg("interface %s already configured", iface);
+					continue;
+				}
+			} else {
+				/* ifdown */
+				if (iface_state) {
+					bb_error_msg("interface %s not configured", iface);
+					continue;
+				}
+			}
+		}
+
+#ifdef CONFIG_FEATURE_IFUPDOWN_MAPPING
+		if ((cmds == iface_up) && !NO_MAPPINGS) {
+			struct mapping_defn_t *currmap;
+
+			for (currmap = defn->mappings; currmap; currmap = currmap->next) {
+				int i;
+				for (i = 0; i < currmap->n_matches; i++) {
+					if (fnmatch(currmap->match[i], liface, 0) != 0)
+						continue;
+					if (VERBOSE) {
+						printf("Running mapping script %s on %s\n", currmap->script, liface);
+					}
+					liface = run_mapping(iface, currmap);
+					break;
+				}
+			}
+		}
+#endif
+
+
+		iface_list = defn->ifaces;
+		while (iface_list) {
+			currif = (struct interface_defn_t *) iface_list->data;
+			if (strcmp(liface, currif->iface) == 0) {
+				char *oldiface = currif->iface;
+
+				okay = 1;
+				currif->iface = iface;
+
+				debug_noise("\nConfiguring interface %s (%s)\n", liface, currif->address_family->name);
+
+				/* 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",
+							liface, currif->address_family->name);
+					any_failures += 1;
+				} else if (cmds_ret == 0) {
+					any_failures += 1;
+				}
+
+				currif->iface = oldiface;
+			}
+			iface_list = iface_list->link;
+		}
+		if (VERBOSE) {
+			puts("");
+		}
+
+		if (!okay && !FORCE) {
+			bb_error_msg("ignoring unknown interface %s", liface);
+			any_failures += 1;
+		} else {
+			llist_t *iface_state = find_iface_state(state_list, iface);
+
+			if (cmds == iface_up) {
+				char *newiface = xasprintf("%s=%s", iface, liface);
+				if (iface_state == NULL) {
+					llist_add_to_end(&state_list, newiface);
+				} else {
+					free(iface_state->data);
+					iface_state->data = newiface;
+				}
+			} else {
+				/* Remove an interface from the linked list */
+				free(llist_pop(&iface_state));
+			}
+		}
+	}
+
+	/* Actually write the new state */
+	if (!NO_ACT) {
+		FILE *state_fp = NULL;
+
+		state_fp = xfopen(statefile, "w");
+		while (state_list) {
+			if (state_list->data) {
+				fputs(state_list->data, state_fp);
+				fputc('\n', state_fp);
+			}
+			state_list = state_list->link;
+		}
+		fclose(state_fp);
+	}
+
+	if (any_failures)
+		return 1;
+	return 0;
+}
diff --git a/networking/inetd.c b/networking/inetd.c
new file mode 100644
index 0000000..ec7b2e8
--- /dev/null
+++ b/networking/inetd.c
@@ -0,0 +1,1767 @@
+/* vi: set sw=4 ts=4: */
+/*      $Slackware: inetd.c 1.79s 2001/02/06 13:18:00 volkerdi Exp $    */
+/*      $OpenBSD: inetd.c,v 1.79 2001/01/30 08:30:57 deraadt Exp $      */
+/*      $NetBSD: inetd.c,v 1.11 1996/02/22 11:14:41 mycroft Exp $       */
+/* Busybox port by Vladimir Oleynik (C) 2001-2005 <dzo@simtreas.ru>     */
+/*
+ * Copyright (c) 1983,1991 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by the University of
+ *      California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/*
+ * Inetd - Internet super-server
+ *
+ * This program invokes all internet services as needed.
+ * connection-oriented services are invoked each time a
+ * connection is made, by creating a process.  This process
+ * is passed the connection as file descriptor 0 and is
+ * expected to do a getpeername to find out the source host
+ * and port.
+ *
+ * Datagram oriented services are invoked when a datagram
+ * arrives; a process is created and passed a pending message
+ * on file descriptor 0.  Datagram servers may either connect
+ * to their peer, freeing up the original socket for inetd
+ * to receive further messages on, or ``take over the socket'',
+ * processing all arriving datagrams and, eventually, timing
+ * out.  The first type of server is said to be ``multi-threaded'';
+ * the second type of server ``single-threaded''.
+ *
+ * Inetd uses a configuration file which is read at startup
+ * and, possibly, at some later time in response to a hangup signal.
+ * The configuration file is ``free format'' with fields given in the
+ * order shown below.  Continuation lines for an entry must begin with
+ * a space or tab.  All fields must be present in each entry.
+ *
+ *      service name                    must be in /etc/services
+ *      socket type                     stream/dgram/raw/rdm/seqpacket
+ *      protocol                        must be in /etc/protocols
+ *      wait/nowait[.max]               single-threaded/multi-threaded, max #
+ *      user[.group] or user[:group]    user/group to run daemon as
+ *      server program                  full path name
+ *      server program arguments        maximum of MAXARGS (20)
+ *
+ * For RPC services
+ *      service name/version            must be in /etc/rpc
+ *      socket type                     stream/dgram/raw/rdm/seqpacket
+ *      protocol                        must be in /etc/protocols
+ *      wait/nowait[.max]               single-threaded/multi-threaded
+ *      user[.group] or user[:group]    user to run daemon as
+ *      server program                  full path name
+ *      server program arguments        maximum of MAXARGS (20)
+ *
+ * For non-RPC services, the "service name" can be of the form
+ * hostaddress:servicename, in which case the hostaddress is used
+ * as the host portion of the address to listen on.  If hostaddress
+ * consists of a single `*' character, INADDR_ANY is used.
+ *
+ * A line can also consist of just
+ *      hostaddress:
+ * where hostaddress is as in the preceding paragraph.  Such a line must
+ * have no further fields; the specified hostaddress is remembered and
+ * used for all further lines that have no hostaddress specified,
+ * until the next such line (or EOF).  (This is why * is provided to
+ * allow explicit specification of INADDR_ANY.)  A line
+ *      *:
+ * is implicitly in effect at the beginning of the file.
+ *
+ * The hostaddress specifier may (and often will) contain dots;
+ * the service name must not.
+ *
+ * For RPC services, host-address specifiers are accepted and will
+ * work to some extent; however, because of limitations in the
+ * portmapper interface, it will not work to try to give more than
+ * one line for any given RPC service, even if the host-address
+ * specifiers are different.
+ *
+ * Comment lines are indicated by a `#' in column 1.
+ */
+
+/*
+ * Here's the scoop concerning the user[.:]group feature:
+ *
+ * 1) set-group-option off.
+ *
+ *      a) user = root: NO setuid() or setgid() is done
+ *
+ *      b) other:       setgid(primary group as found in passwd)
+ *                      initgroups(name, primary group)
+ *                      setuid()
+ *
+ * 2) set-group-option on.
+ *
+ *      a) user = root: setgid(specified group)
+ *                      NO initgroups()
+ *                      NO setuid()
+ *
+ *      b) other:       setgid(specified group)
+ *                      initgroups(name, specified group)
+ *                      setuid()
+ *
+ */
+
+#include "busybox.h"
+#include <syslog.h>
+#include <sys/un.h>
+
+//#define CONFIG_FEATURE_INETD_RPC
+//#define CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_ECHO
+//#define CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_DISCARD
+//#define CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_TIME
+//#define CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_DAYTIME
+//#define CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN
+//#define CONFIG_FEATURE_IPV6
+
+#ifdef CONFIG_FEATURE_INETD_RPC
+#include <rpc/rpc.h>
+#include <rpc/pmap_clnt.h>
+#endif
+
+#define _PATH_INETDCONF "/etc/inetd.conf"
+#define _PATH_INETDPID  "/var/run/inetd.pid"
+
+
+#define CNT_INTVL       60              /* servers in CNT_INTVL sec. */
+#define RETRYTIME       (60*10)         /* retry after bind or server fail */
+
+#ifndef RLIMIT_NOFILE
+#define RLIMIT_NOFILE   RLIMIT_OFILE
+#endif
+
+#ifndef OPEN_MAX
+#define OPEN_MAX        64
+#endif
+
+/* Reserve some descriptors, 3 stdio + at least: 1 log, 1 conf. file */
+#define FD_MARGIN       (8)
+static rlim_t rlim_ofile_cur = OPEN_MAX;
+static struct rlimit rlim_ofile;
+
+
+/* Check unsupporting builtin */
+#if defined CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_ECHO || \
+		defined CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_DISCARD || \
+		defined CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_TIME || \
+		defined CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_DAYTIME || \
+		defined CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN
+# define INETD_FEATURE_ENABLED
+#endif
+
+#if defined CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_ECHO || \
+		defined CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_DISCARD || \
+		defined CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN
+# define INETD_SETPROCTITLE
+#endif
+
+typedef struct servtab {
+	char *se_hostaddr;                    /* host address to listen on */
+	char *se_service;                     /* name of service */
+	int se_socktype;                      /* type of socket to use */
+	int se_family;                        /* address family */
+	char *se_proto;                       /* protocol used */
+#ifdef CONFIG_FEATURE_INETD_RPC
+	int se_rpcprog;                       /* rpc program number */
+	int se_rpcversl;                      /* rpc program lowest version */
+	int se_rpcversh;                      /* rpc program highest version */
+#define isrpcservice(sep)       ((sep)->se_rpcversl != 0)
+#else
+#define isrpcservice(sep)       0
+#endif
+	pid_t se_wait;                        /* single threaded server */
+	short se_checked;                     /* looked at during merge */
+	char *se_user;                        /* user name to run as */
+	char *se_group;                       /* group name to run as */
+#ifdef INETD_FEATURE_ENABLED
+	const struct builtin *se_bi;          /* if built-in, description */
+#endif
+	char *se_server;                      /* server program */
+#define MAXARGV 20
+	char *se_argv[MAXARGV + 1];           /* program arguments */
+	int se_fd;                            /* open descriptor */
+	union {
+		struct sockaddr se_un_ctrladdr;
+		struct sockaddr_in se_un_ctrladdr_in;
+#ifdef CONFIG_FEATURE_IPV6
+		struct sockaddr_in6 se_un_ctrladdr_in6;
+#endif
+		struct sockaddr_un se_un_ctrladdr_un;
+	} se_un;                              /* bound address */
+#define se_ctrladdr     se_un.se_un_ctrladdr
+#define se_ctrladdr_in  se_un.se_un_ctrladdr_in
+#define se_ctrladdr_in6 se_un.se_un_ctrladdr_in6
+#define se_ctrladdr_un  se_un.se_un_ctrladdr_un
+	int se_ctrladdr_size;
+	int se_max;                           /* max # of instances of this service */
+	int se_count;                         /* number started since se_time */
+	struct timeval se_time;               /* start of se_count */
+	struct servtab *se_next;
+} servtab_t;
+
+static servtab_t *servtab;
+
+#ifdef INETD_FEATURE_ENABLED
+struct builtin {
+	const char *bi_service;               /* internally provided service name */
+	int bi_socktype;                      /* type of socket supported */
+	short bi_fork;                        /* 1 if should fork before call */
+	short bi_wait;                        /* 1 if should wait for child */
+	void (*bi_fn) (int, servtab_t *);
+};
+
+		/* Echo received data */
+#ifdef CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_ECHO
+static void echo_stream(int, servtab_t *);
+static void echo_dg(int, servtab_t *);
+#endif
+		/* Internet /dev/null */
+#ifdef CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_DISCARD
+static void discard_stream(int, servtab_t *);
+static void discard_dg(int, servtab_t *);
+#endif
+		/* Return 32 bit time since 1900 */
+#ifdef CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_TIME
+static void machtime_stream(int, servtab_t *);
+static void machtime_dg(int, servtab_t *);
+#endif
+		/* Return human-readable time */
+#ifdef CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_DAYTIME
+static void daytime_stream(int, servtab_t *);
+static void daytime_dg(int, servtab_t *);
+#endif
+		/* Familiar character generator */
+#ifdef CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN
+static void chargen_stream(int, servtab_t *);
+static void chargen_dg(int, servtab_t *);
+#endif
+
+static const struct builtin builtins[] = {
+#ifdef CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_ECHO
+	/* Echo received data */
+	{"echo", SOCK_STREAM, 1, 0, echo_stream,},
+	{"echo", SOCK_DGRAM, 0, 0, echo_dg,},
+#endif
+#ifdef CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_DISCARD
+	/* Internet /dev/null */
+	{"discard", SOCK_STREAM, 1, 0, discard_stream,},
+	{"discard", SOCK_DGRAM, 0, 0, discard_dg,},
+#endif
+#ifdef CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_TIME
+	/* Return 32 bit time since 1900 */
+	{"time", SOCK_STREAM, 0, 0, machtime_stream,},
+	{"time", SOCK_DGRAM, 0, 0, machtime_dg,},
+#endif
+#ifdef CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_DAYTIME
+	/* Return human-readable time */
+	{"daytime", SOCK_STREAM, 0, 0, daytime_stream,},
+	{"daytime", SOCK_DGRAM, 0, 0, daytime_dg,},
+#endif
+#ifdef CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN
+	/* Familiar character generator */
+	{"chargen", SOCK_STREAM, 1, 0, chargen_stream,},
+	{"chargen", SOCK_DGRAM, 0, 0, chargen_dg,},
+#endif
+	{NULL, 0, 0, 0, NULL}
+};
+#endif /* INETD_FEATURE_ENABLED */
+
+static int global_queuelen = 128;
+static int nsock, maxsock;
+static fd_set allsock;
+static int toomany;
+static int timingout;
+static struct servent *sp;
+static uid_t uid;
+
+static char *CONFIG = _PATH_INETDCONF;
+
+static FILE *fconfig;
+static char line[1024];
+static char *defhost;
+
+/* xstrdup(NULL) returns NULL, but this one
+ * will return newly-allocated "" if called with NULL arg
+ * TODO: audit whether this makes any real difference
+ */
+static char *xxstrdup(char *cp)
+{
+	return xstrdup(cp ? cp : "");
+}
+
+static int setconfig(void)
+{
+	free(defhost);
+	defhost = xstrdup("*");
+	if (fconfig != NULL) {
+		fseek(fconfig, 0L, SEEK_SET);
+		return 1;
+	}
+	fconfig = fopen(CONFIG, "r");
+	return (fconfig != NULL);
+}
+
+static void endconfig(void)
+{
+	if (fconfig) {
+		(void) fclose(fconfig);
+		fconfig = NULL;
+	}
+	free(defhost);
+	defhost = 0;
+}
+
+#ifdef CONFIG_FEATURE_INETD_RPC
+static void register_rpc(servtab_t *sep)
+{
+	int n;
+	struct sockaddr_in ir_sin;
+	struct protoent *pp;
+	socklen_t size;
+
+	if ((pp = getprotobyname(sep->se_proto + 4)) == NULL) {
+		bb_perror_msg("%s: getproto", sep->se_proto);
+		return;
+	}
+	size = sizeof ir_sin;
+	if (getsockname(sep->se_fd, (struct sockaddr *) &ir_sin, &size) < 0) {
+		bb_perror_msg("%s/%s: getsockname",
+				sep->se_service, sep->se_proto);
+		return;
+	}
+
+	for (n = sep->se_rpcversl; n <= sep->se_rpcversh; n++) {
+		(void) pmap_unset(sep->se_rpcprog, n);
+		if (!pmap_set(sep->se_rpcprog, n, pp->p_proto, ntohs(ir_sin.sin_port)))
+			bb_perror_msg("%s %s: pmap_set: %u %u %u %u",
+					sep->se_service, sep->se_proto,
+					sep->se_rpcprog, n, pp->p_proto, ntohs(ir_sin.sin_port));
+	}
+}
+
+static void unregister_rpc(servtab_t *sep)
+{
+	int n;
+
+	for (n = sep->se_rpcversl; n <= sep->se_rpcversh; n++) {
+		if (!pmap_unset(sep->se_rpcprog, n))
+			bb_error_msg("pmap_unset(%u, %u)", sep->se_rpcprog, n);
+	}
+}
+#endif /* CONFIG_FEATURE_INETD_RPC */
+
+static void freeconfig(servtab_t *cp)
+{
+	int i;
+
+	free(cp->se_hostaddr);
+	free(cp->se_service);
+	free(cp->se_proto);
+	free(cp->se_user);
+	free(cp->se_group);
+	free(cp->se_server);
+	for (i = 0; i < MAXARGV; i++)
+		free(cp->se_argv[i]);
+}
+
+static int bump_nofile (void)
+{
+#define FD_CHUNK        32
+
+	struct rlimit rl;
+
+	if (getrlimit (RLIMIT_NOFILE, &rl) < 0) {
+		bb_perror_msg("getrlimit");
+		return -1;
+	}
+	rl.rlim_cur = MIN(rl.rlim_max, rl.rlim_cur + FD_CHUNK);
+	rl.rlim_cur = MIN(FD_SETSIZE, rl.rlim_cur + FD_CHUNK);
+	if (rl.rlim_cur <= rlim_ofile_cur) {
+		bb_error_msg("bump_nofile: cannot extend file limit, max = %d",
+						(int) rl.rlim_cur);
+		return -1;
+	}
+
+	if (setrlimit(RLIMIT_NOFILE, &rl) < 0) {
+		bb_perror_msg("setrlimit");
+		return -1;
+	}
+
+	rlim_ofile_cur = rl.rlim_cur;
+	return 0;
+}
+
+static void setup(servtab_t *sep)
+{
+	int r;
+
+	sep->se_fd = socket(sep->se_family, sep->se_socktype, 0);
+	if (sep->se_fd < 0) {
+		bb_perror_msg("%s/%s: socket", sep->se_service, sep->se_proto);
+		return;
+	}
+	if (setsockopt_reuseaddr(sep->se_fd) < 0)
+		bb_perror_msg("setsockopt(SO_REUSEADDR)");
+
+#ifdef CONFIG_FEATURE_INETD_RPC
+	if (isrpcservice(sep)) {
+		struct passwd *pwd;
+
+		/*
+		 * for RPC services, attempt to use a reserved port
+		 * if they are going to be running as root.
+		 *
+		 * Also, zero out the port for all RPC services; let bind()
+		 * find one.
+		 */
+		sep->se_ctrladdr_in.sin_port = 0;
+		if (sep->se_user && (pwd = getpwnam(sep->se_user)) &&
+				pwd->pw_uid == 0 && uid == 0)
+			r = bindresvport(sep->se_fd, &sep->se_ctrladdr_in);
+		else {
+			r = bind(sep->se_fd, &sep->se_ctrladdr, sep->se_ctrladdr_size);
+			if (r == 0) {
+				socklen_t len = sep->se_ctrladdr_size;
+				int saveerrno = errno;
+
+				/* update se_ctrladdr_in.sin_port */
+				r = getsockname(sep->se_fd, &sep->se_ctrladdr, &len);
+				if (r <= 0)
+					errno = saveerrno;
+			}
+		}
+	} else
+#endif
+		r = bind(sep->se_fd, &sep->se_ctrladdr, sep->se_ctrladdr_size);
+	if (r < 0) {
+		bb_perror_msg("%s/%s (%d): bind",
+				sep->se_service, sep->se_proto, sep->se_ctrladdr.sa_family);
+		close(sep->se_fd);
+		sep->se_fd = -1;
+		if (!timingout) {
+			timingout = 1;
+			alarm(RETRYTIME);
+		}
+		return;
+	}
+	if (sep->se_socktype == SOCK_STREAM)
+		listen(sep->se_fd, global_queuelen);
+
+	FD_SET(sep->se_fd, &allsock);
+	nsock++;
+	if (sep->se_fd > maxsock) {
+		maxsock = sep->se_fd;
+		if ((rlim_t)maxsock > rlim_ofile_cur - FD_MARGIN)
+			bump_nofile();
+	}
+}
+
+static char *nextline(void)
+{
+	char *cp;
+	FILE *fd = fconfig;
+
+	if (fgets(line, sizeof(line), fd) == NULL)
+		return NULL;
+	cp = strchr(line, '\n');
+	if (cp)
+		*cp = '\0';
+	return line;
+}
+
+static char *skip(char **cpp) /* int report; */
+{
+	char *cp = *cpp;
+	char *start;
+
+/* erp: */
+	if (*cpp == NULL) {
+		/* if (report) */
+		/* bb_error_msg("syntax error in inetd config file"); */
+		return NULL;
+	}
+
+again:
+	while (*cp == ' ' || *cp == '\t')
+		cp++;
+	if (*cp == '\0') {
+		int c;
+
+		c = getc(fconfig);
+		(void) ungetc(c, fconfig);
+		if (c == ' ' || c == '\t')
+			if ((cp = nextline()))
+				goto again;
+		*cpp = NULL;
+		/* goto erp; */
+		return NULL;
+	}
+	start = cp;
+	while (*cp && *cp != ' ' && *cp != '\t')
+		cp++;
+	if (*cp != '\0')
+		*cp++ = '\0';
+	/* if ((*cpp = cp) == NULL) */
+	/* goto erp; */
+
+	*cpp = cp;
+	return start;
+}
+
+static servtab_t *new_servtab(void)
+{
+	return xmalloc(sizeof(servtab_t));
+}
+
+static servtab_t *dupconfig(servtab_t *sep)
+{
+	servtab_t *newtab;
+	int argc;
+
+	newtab = new_servtab();
+	memset(newtab, 0, sizeof(servtab_t));
+	newtab->se_service = xstrdup(sep->se_service);
+	newtab->se_socktype = sep->se_socktype;
+	newtab->se_family = sep->se_family;
+	newtab->se_proto = xstrdup(sep->se_proto);
+#ifdef CONFIG_FEATURE_INETD_RPC
+	newtab->se_rpcprog = sep->se_rpcprog;
+	newtab->se_rpcversl = sep->se_rpcversl;
+	newtab->se_rpcversh = sep->se_rpcversh;
+#endif
+	newtab->se_wait = sep->se_wait;
+	newtab->se_user = xstrdup(sep->se_user);
+	newtab->se_group = xstrdup(sep->se_group);
+#ifdef INETD_FEATURE_ENABLED
+	newtab->se_bi = sep->se_bi;
+#endif
+	newtab->se_server = xstrdup(sep->se_server);
+
+	for (argc = 0; argc <= MAXARGV; argc++)
+		newtab->se_argv[argc] = xstrdup(sep->se_argv[argc]);
+	newtab->se_max = sep->se_max;
+
+	return newtab;
+}
+
+static servtab_t *getconfigent(void)
+{
+	servtab_t *sep;
+	int argc;
+	char *cp, *arg;
+	char *hostdelim;
+	servtab_t *nsep;
+	servtab_t *psep;
+
+	sep = new_servtab();
+
+	/* memset(sep, 0, sizeof *sep); */
+ more:
+	/* freeconfig(sep); */
+
+	while ((cp = nextline()) && *cp == '#') /* skip comment line */;
+	if (cp == NULL) {
+		/* free(sep); */
+		return NULL;
+	}
+
+	memset((char *) sep, 0, sizeof *sep);
+	arg = skip(&cp);
+	if (arg == NULL) {
+		/* A blank line. */
+		goto more;
+	}
+
+	/* Check for a host name. */
+	hostdelim = strrchr(arg, ':');
+	if (hostdelim) {
+		*hostdelim = '\0';
+		sep->se_hostaddr = xstrdup(arg);
+		arg = hostdelim + 1;
+		/*
+		 * If the line is of the form `host:', then just change the
+		 * default host for the following lines.
+		 */
+		if (*arg == '\0') {
+			arg = skip(&cp);
+			if (cp == NULL) {
+				free(defhost);
+				defhost = sep->se_hostaddr;
+				goto more;
+			}
+		}
+	} else
+		sep->se_hostaddr = xxstrdup(defhost);
+
+	sep->se_service = xxstrdup(arg);
+	arg = skip(&cp);
+
+	if (strcmp(arg, "stream") == 0)
+		sep->se_socktype = SOCK_STREAM;
+	else if (strcmp(arg, "dgram") == 0)
+		sep->se_socktype = SOCK_DGRAM;
+	else if (strcmp(arg, "rdm") == 0)
+		sep->se_socktype = SOCK_RDM;
+	else if (strcmp(arg, "seqpacket") == 0)
+		sep->se_socktype = SOCK_SEQPACKET;
+	else if (strcmp(arg, "raw") == 0)
+		sep->se_socktype = SOCK_RAW;
+	else
+		sep->se_socktype = -1;
+
+	sep->se_proto = xxstrdup(skip(&cp));
+
+	if (strcmp(sep->se_proto, "unix") == 0) {
+		sep->se_family = AF_UNIX;
+	} else {
+		sep->se_family = AF_INET;
+		if (sep->se_proto[strlen(sep->se_proto) - 1] == '6')
+#ifdef CONFIG_FEATURE_IPV6
+			sep->se_family = AF_INET6;
+#else
+			bb_error_msg("%s: IPV6 not supported", sep->se_proto);
+#endif
+		if (strncmp(sep->se_proto, "rpc/", 4) == 0) {
+#ifdef CONFIG_FEATURE_INETD_RPC
+			char *p, *ccp;
+			long l;
+
+			p = strchr(sep->se_service, '/');
+			if (p == 0) {
+				bb_error_msg("%s: no rpc version", sep->se_service);
+				goto more;
+			}
+			*p++ = '\0';
+			l = strtol(p, &ccp, 0);
+			if (ccp == p || l < 0 || l > INT_MAX) {
+			badafterall:
+				bb_error_msg("%s/%s: bad rpc version", sep->se_service, p);
+				goto more;
+			}
+			sep->se_rpcversl = sep->se_rpcversh = l;
+			if (*ccp == '-') {
+				p = ccp + 1;
+				l = strtol(p, &ccp, 0);
+				if (ccp == p || l < 0 || l > INT_MAX || l < sep->se_rpcversl || *ccp)
+					goto badafterall;
+				sep->se_rpcversh = l;
+			} else if (*ccp != '\0')
+				goto badafterall;
+#else
+			bb_error_msg("%s: rpc services not supported", sep->se_service);
+#endif
+		}
+	}
+	arg = skip(&cp);
+	if (arg == NULL)
+		goto more;
+
+	{
+		char *s = strchr(arg, '.');
+		if (s) {
+			*s++ = '\0';
+			sep->se_max = xatoi(s);
+		} else
+			sep->se_max = toomany;
+	}
+	sep->se_wait = strcmp(arg, "wait") == 0;
+	/* if ((arg = skip(&cp, 1)) == NULL) */
+	/* goto more; */
+	sep->se_user = xxstrdup(skip(&cp));
+	arg = strchr(sep->se_user, '.');
+	if (arg == NULL)
+		arg = strchr(sep->se_user, ':');
+	if (arg) {
+		*arg++ = '\0';
+		sep->se_group = xstrdup(arg);
+	}
+	/* if ((arg = skip(&cp, 1)) == NULL) */
+	/* goto more; */
+
+	sep->se_server = xxstrdup(skip(&cp));
+	if (strcmp(sep->se_server, "internal") == 0) {
+#ifdef INETD_FEATURE_ENABLED
+		const struct builtin *bi;
+
+		for (bi = builtins; bi->bi_service; bi++)
+			if (bi->bi_socktype == sep->se_socktype &&
+					strcmp(bi->bi_service, sep->se_service) == 0)
+				break;
+		if (bi->bi_service == 0) {
+			bb_error_msg("internal service %s unknown", sep->se_service);
+			goto more;
+		}
+		sep->se_bi = bi;
+		sep->se_wait = bi->bi_wait;
+#else
+		bb_perror_msg("internal service %s unknown", sep->se_service);
+		goto more;
+#endif
+	}
+#ifdef INETD_FEATURE_ENABLED
+		else
+		sep->se_bi = NULL;
+#endif
+	argc = 0;
+	for (arg = skip(&cp); cp; arg = skip(&cp)) {
+		if (argc < MAXARGV)
+			sep->se_argv[argc++] = xxstrdup(arg);
+	}
+	while (argc <= MAXARGV)
+		sep->se_argv[argc++] = NULL;
+
+	/*
+	 * Now that we've processed the entire line, check if the hostname
+	 * specifier was a comma separated list of hostnames. If so
+	 * we'll make new entries for each address.
+	 */
+	while ((hostdelim = strrchr(sep->se_hostaddr, ',')) != NULL) {
+		nsep = dupconfig(sep);
+
+		/*
+		 * NULL terminate the hostname field of the existing entry,
+		 * and make a dup for the new entry.
+		 */
+		*hostdelim++ = '\0';
+		nsep->se_hostaddr = xstrdup(hostdelim);
+
+		nsep->se_next = sep->se_next;
+		sep->se_next = nsep;
+	}
+
+	nsep = sep;
+	while (nsep != NULL) {
+		nsep->se_checked = 1;
+		if (nsep->se_family == AF_INET) {
+			if (!strcmp(nsep->se_hostaddr, "*"))
+				nsep->se_ctrladdr_in.sin_addr.s_addr = INADDR_ANY;
+			else if (!inet_aton(nsep->se_hostaddr, &nsep->se_ctrladdr_in.sin_addr)) {
+				struct hostent *hp;
+
+				hp = gethostbyname(nsep->se_hostaddr);
+				if (hp == 0) {
+					bb_error_msg("%s: unknown host", nsep->se_hostaddr);
+					nsep->se_checked = 0;
+					goto skip;
+				} else if (hp->h_addrtype != AF_INET) {
+					bb_error_msg("%s: address isn't an Internet "
+								  "address", nsep->se_hostaddr);
+					nsep->se_checked = 0;
+					goto skip;
+				} else {
+					int i = 1;
+
+					memmove(&nsep->se_ctrladdr_in.sin_addr,
+								   hp->h_addr_list[0], sizeof(struct in_addr));
+					while (hp->h_addr_list[i] != NULL) {
+						psep = dupconfig(nsep);
+						psep->se_hostaddr = xxstrdup(nsep->se_hostaddr);
+						psep->se_checked = 1;
+						memmove(&psep->se_ctrladdr_in.sin_addr,
+								     hp->h_addr_list[i], sizeof(struct in_addr));
+						psep->se_ctrladdr_size = sizeof(psep->se_ctrladdr_in);
+						i++;
+						/* Prepend to list, don't want to look up */
+						/* its hostname again. */
+						psep->se_next = sep;
+						sep = psep;
+					}
+				}
+			}
+		}
+/* XXX BUG?: is this skip: label supposed to remain? */
+	skip:
+		nsep = nsep->se_next;
+	}
+
+	/*
+	 * Finally, free any entries which failed the gethostbyname
+	 * check.
+	 */
+	psep = NULL;
+	nsep = sep;
+	while (nsep != NULL) {
+		servtab_t *tsep;
+
+		if (nsep->se_checked == 0) {
+			tsep = nsep;
+			if (psep == NULL) {
+				sep = nsep->se_next;
+				nsep = sep;
+			} else {
+				nsep = nsep->se_next;
+				psep->se_next = nsep;
+			}
+			freeconfig(tsep);
+		} else {
+			nsep->se_checked = 0;
+			psep = nsep;
+			nsep = nsep->se_next;
+		}
+	}
+
+	return sep;
+}
+
+#define Block_Using_Signals(m) do { \
+	sigemptyset(&m); \
+	sigaddset(&m, SIGCHLD); \
+	sigaddset(&m, SIGHUP); \
+	sigaddset(&m, SIGALRM); \
+	sigprocmask(SIG_BLOCK, &m, NULL); \
+} while(0)
+
+static servtab_t *enter(servtab_t *cp)
+{
+	servtab_t *sep;
+	sigset_t omask;
+
+	sep = new_servtab();
+	*sep = *cp;
+	sep->se_fd = -1;
+#ifdef CONFIG_FEATURE_INETD_RPC
+	sep->se_rpcprog = -1;
+#endif
+	Block_Using_Signals(omask);
+	sep->se_next = servtab;
+	servtab = sep;
+	sigprocmask(SIG_UNBLOCK, &omask, NULL);
+	return sep;
+}
+
+static int matchconf(servtab_t *old, servtab_t *new)
+{
+	if (strcmp(old->se_service, new->se_service) != 0)
+		return 0;
+
+	if (strcmp(old->se_hostaddr, new->se_hostaddr) != 0)
+		return 0;
+
+	if (strcmp(old->se_proto, new->se_proto) != 0)
+		return 0;
+
+	/*
+	 * If the new servtab is bound to a specific address, check that the
+	 * old servtab is bound to the same entry. If the new service is not
+	 * bound to a specific address then the check of se_hostaddr above
+	 * is sufficient.
+	 */
+
+	if (old->se_family == AF_INET && new->se_family == AF_INET &&
+			memcmp(&old->se_ctrladdr_in.sin_addr,
+					&new->se_ctrladdr_in.sin_addr,
+					sizeof(new->se_ctrladdr_in.sin_addr)) != 0)
+		return 0;
+
+#ifdef CONFIG_FEATURE_IPV6
+	if (old->se_family == AF_INET6 && new->se_family == AF_INET6 &&
+			memcmp(&old->se_ctrladdr_in6.sin6_addr,
+					&new->se_ctrladdr_in6.sin6_addr,
+					sizeof(new->se_ctrladdr_in6.sin6_addr)) != 0)
+		return 0;
+#endif
+	return 1;
+}
+
+static void config(int sig ATTRIBUTE_UNUSED)
+{
+	servtab_t *sep, *cp, **sepp;
+	sigset_t omask;
+	size_t n;
+	char protoname[10];
+
+	if (!setconfig()) {
+		bb_perror_msg("%s", CONFIG);
+		return;
+	}
+	for (sep = servtab; sep; sep = sep->se_next)
+		sep->se_checked = 0;
+	cp = getconfigent();
+	while (cp != NULL) {
+		for (sep = servtab; sep; sep = sep->se_next)
+			if (matchconf(sep, cp))
+				break;
+
+		if (sep != 0) {
+			int i;
+
+#define SWAP(type, a, b) do {type c=(type)a; a=(type)b; b=(type)c;} while (0)
+
+			Block_Using_Signals(omask);
+			/*
+			 * sep->se_wait may be holding the pid of a daemon
+			 * that we're waiting for.  If so, don't overwrite
+			 * it unless the config file explicitly says don't
+			 * wait.
+			 */
+			if (
+#ifdef INETD_FEATURE_ENABLED
+				cp->se_bi == 0 &&
+#endif
+				(sep->se_wait == 1 || cp->se_wait == 0))
+				sep->se_wait = cp->se_wait;
+			SWAP(int, cp->se_max, sep->se_max);
+			SWAP(char *, sep->se_user, cp->se_user);
+			SWAP(char *, sep->se_group, cp->se_group);
+			SWAP(char *, sep->se_server, cp->se_server);
+			for (i = 0; i < MAXARGV; i++)
+				SWAP(char *, sep->se_argv[i], cp->se_argv[i]);
+#undef SWAP
+
+#ifdef CONFIG_FEATURE_INETD_RPC
+			if (isrpcservice(sep))
+				unregister_rpc(sep);
+			sep->se_rpcversl = cp->se_rpcversl;
+			sep->se_rpcversh = cp->se_rpcversh;
+#endif
+			sigprocmask(SIG_UNBLOCK, &omask, NULL);
+			freeconfig(cp);
+		} else {
+			sep = enter(cp);
+		}
+		sep->se_checked = 1;
+
+		switch (sep->se_family) {
+		case AF_UNIX:
+			if (sep->se_fd != -1)
+				break;
+			(void) unlink(sep->se_service);
+			n = strlen(sep->se_service);
+			if (n > sizeof sep->se_ctrladdr_un.sun_path - 1)
+				n = sizeof sep->se_ctrladdr_un.sun_path - 1;
+			safe_strncpy(sep->se_ctrladdr_un.sun_path, sep->se_service, n + 1);
+			sep->se_ctrladdr_un.sun_family = AF_UNIX;
+			sep->se_ctrladdr_size = n + sizeof sep->se_ctrladdr_un.sun_family;
+			setup(sep);
+			break;
+		case AF_INET:
+			sep->se_ctrladdr_in.sin_family = AF_INET;
+			/* se_ctrladdr_in was set in getconfigent */
+			sep->se_ctrladdr_size = sizeof sep->se_ctrladdr_in;
+
+#ifdef CONFIG_FEATURE_INETD_RPC
+			if (isrpcservice(sep)) {
+				struct rpcent *rp;
+				// FIXME: atoi_or_else(str, 0) would be handy here
+				sep->se_rpcprog = atoi(sep->se_service);
+				if (sep->se_rpcprog == 0) {
+					rp = getrpcbyname(sep->se_service);
+					if (rp == 0) {
+						bb_error_msg("%s: unknown rpc service", sep->se_service);
+						goto serv_unknown;
+					}
+					sep->se_rpcprog = rp->r_number;
+				}
+				if (sep->se_fd == -1)
+					setup(sep);
+				if (sep->se_fd != -1)
+					register_rpc(sep);
+			} else
+#endif
+			{
+				u_short port = htons(atoi(sep->se_service));
+				// FIXME: atoi_or_else(str, 0) would be handy here
+				if (!port) {
+					 /*XXX*/ strncpy(protoname, sep->se_proto, sizeof(protoname));
+					if (isdigit(protoname[strlen(protoname) - 1]))
+						protoname[strlen(protoname) - 1] = '\0';
+					sp = getservbyname(sep->se_service, protoname);
+					if (sp == 0) {
+						bb_error_msg("%s/%s: unknown service",
+								sep->se_service, sep->se_proto);
+						goto serv_unknown;
+					}
+					port = sp->s_port;
+				}
+				if (port != sep->se_ctrladdr_in.sin_port) {
+					sep->se_ctrladdr_in.sin_port = port;
+					if (sep->se_fd != -1) {
+						FD_CLR(sep->se_fd, &allsock);
+						nsock--;
+						(void) close(sep->se_fd);
+					}
+					sep->se_fd = -1;
+				}
+				if (sep->se_fd == -1)
+					setup(sep);
+			}
+			break;
+#ifdef CONFIG_FEATURE_IPV6
+		case AF_INET6:
+			sep->se_ctrladdr_in6.sin6_family = AF_INET6;
+			/* se_ctrladdr_in was set in getconfigent */
+			sep->se_ctrladdr_size = sizeof sep->se_ctrladdr_in6;
+
+#ifdef CONFIG_FEATURE_INETD_RPC
+			if (isrpcservice(sep)) {
+				struct rpcent *rp;
+
+				sep->se_rpcprog = atoi(sep->se_service);
+				if (sep->se_rpcprog == 0) {
+					rp = getrpcbyname(sep->se_service);
+					if (rp == 0) {
+						bb_error_msg("%s: unknown rpc service", sep->se_service);
+						goto serv_unknown;
+					}
+					sep->se_rpcprog = rp->r_number;
+				}
+				if (sep->se_fd == -1)
+					setup(sep);
+				if (sep->se_fd != -1)
+					register_rpc(sep);
+			} else
+#endif
+				{
+				u_short port = htons(atoi(sep->se_service));
+
+				if (!port) {
+					 /*XXX*/ strncpy(protoname, sep->se_proto, sizeof(protoname));
+					if (isdigit(protoname[strlen(protoname) - 1]))
+						protoname[strlen(protoname) - 1] = '\0';
+					sp = getservbyname(sep->se_service, protoname);
+					if (sp == 0) {
+						bb_error_msg("%s/%s: unknown service",
+								sep->se_service, sep->se_proto);
+						goto serv_unknown;
+					}
+					port = sp->s_port;
+				}
+				if (port != sep->se_ctrladdr_in6.sin6_port) {
+					sep->se_ctrladdr_in6.sin6_port = port;
+					if (sep->se_fd != -1) {
+						FD_CLR(sep->se_fd, &allsock);
+						nsock--;
+						(void) close(sep->se_fd);
+					}
+					sep->se_fd = -1;
+				}
+				if (sep->se_fd == -1)
+					setup(sep);
+			}
+			break;
+#endif /* CONFIG_FEATURE_IPV6 */
+		}
+	serv_unknown:
+		if (cp->se_next != NULL) {
+			servtab_t *tmp = cp;
+
+			cp = cp->se_next;
+			free(tmp);
+		} else {
+			free(cp);
+			cp = getconfigent();
+		}
+	}
+	endconfig();
+	/*
+	 * Purge anything not looked at above.
+	 */
+	Block_Using_Signals(omask);
+	sepp = &servtab;
+	while ((sep = *sepp)) {
+		if (sep->se_checked) {
+			sepp = &sep->se_next;
+			continue;
+		}
+		*sepp = sep->se_next;
+		if (sep->se_fd != -1) {
+			FD_CLR(sep->se_fd, &allsock);
+			nsock--;
+			(void) close(sep->se_fd);
+		}
+#ifdef CONFIG_FEATURE_INETD_RPC
+		if (isrpcservice(sep))
+			unregister_rpc(sep);
+#endif
+		if (sep->se_family == AF_UNIX)
+			(void) unlink(sep->se_service);
+		freeconfig(sep);
+		free(sep);
+	}
+	sigprocmask(SIG_UNBLOCK, &omask, NULL);
+}
+
+
+static void reapchild(int sig ATTRIBUTE_UNUSED)
+{
+	pid_t pid;
+	int save_errno = errno, status;
+	servtab_t *sep;
+
+	for (;;) {
+		pid = wait3(&status, WNOHANG, NULL);
+		if (pid <= 0)
+			break;
+		for (sep = servtab; sep; sep = sep->se_next)
+			if (sep->se_wait == pid) {
+				if (WIFEXITED(status) && WEXITSTATUS(status))
+					bb_error_msg("%s: exit status 0x%x",
+							sep->se_server, WEXITSTATUS(status));
+				else if (WIFSIGNALED(status))
+					bb_error_msg("%s: exit signal 0x%x",
+							sep->se_server, WTERMSIG(status));
+				sep->se_wait = 1;
+				FD_SET(sep->se_fd, &allsock);
+				nsock++;
+			}
+	}
+	errno = save_errno;
+}
+
+static void retry(int sig ATTRIBUTE_UNUSED)
+{
+	servtab_t *sep;
+
+	timingout = 0;
+	for (sep = servtab; sep; sep = sep->se_next) {
+		if (sep->se_fd == -1) {
+			switch (sep->se_family) {
+			case AF_UNIX:
+			case AF_INET:
+#ifdef CONFIG_FEATURE_IPV6
+			case AF_INET6:
+#endif
+				setup(sep);
+#ifdef CONFIG_FEATURE_INETD_RPC
+				if (sep->se_fd != -1 && isrpcservice(sep))
+					register_rpc(sep);
+#endif
+				break;
+			}
+		}
+	}
+}
+
+static void goaway(int sig ATTRIBUTE_UNUSED)
+{
+	servtab_t *sep;
+
+	/* XXX signal race walking sep list */
+	for (sep = servtab; sep; sep = sep->se_next) {
+		if (sep->se_fd == -1)
+			continue;
+
+		switch (sep->se_family) {
+		case AF_UNIX:
+			(void) unlink(sep->se_service);
+			break;
+		case AF_INET:
+#ifdef CONFIG_FEATURE_IPV6
+		case AF_INET6:
+#endif
+#ifdef CONFIG_FEATURE_INETD_RPC
+			if (sep->se_wait == 1 && isrpcservice(sep))
+				unregister_rpc(sep);   /* XXX signal race */
+#endif
+			break;
+		}
+		(void) close(sep->se_fd);
+	}
+	(void) unlink(_PATH_INETDPID);
+	exit(0);
+}
+
+
+#ifdef INETD_SETPROCTITLE
+static char **Argv;
+static char *LastArg;
+
+static void
+inetd_setproctitle(char *a, int s)
+{
+	socklen_t size;
+	char *cp;
+	struct sockaddr_in prt_sin;
+	char buf[80];
+
+	cp = Argv[0];
+	size = sizeof(prt_sin);
+	(void) snprintf(buf, sizeof buf, "-%s", a);
+	if (getpeername(s, (struct sockaddr *) &prt_sin, &size) == 0) {
+		char *sa = inet_ntoa(prt_sin.sin_addr);
+
+		buf[sizeof(buf) - 1 - strlen(sa) - 3] = '\0';
+		strcat(buf, " [");
+		strcat(buf, sa);
+		strcat(buf, "]");
+	}
+	strncpy(cp, buf, LastArg - cp);
+	cp += strlen(cp);
+	while (cp < LastArg)
+		*cp++ = ' ';
+}
+#endif
+
+
+int
+inetd_main(int argc, char *argv[])
+{
+	servtab_t *sep;
+	struct passwd *pwd;
+	struct group *grp = NULL;
+	int tmpint;
+	struct sigaction sa, sapipe;
+	int opt;
+	pid_t pid;
+	char buf[50];
+	char *stoomany;
+	sigset_t omask, wait_mask;
+
+#ifdef INETD_SETPROCTITLE
+	extern char **environ;
+	char **envp = environ;
+
+	Argv = argv;
+	if (envp == 0 || *envp == 0)
+		envp = argv;
+	while (*envp)
+		envp++;
+	LastArg = envp[-1] + strlen(envp[-1]);
+#endif
+
+	openlog(applet_name, LOG_PID | LOG_NOWAIT, LOG_DAEMON);
+
+	opt = getopt32(argc, argv, "R:f", &stoomany);
+	if(opt & 1) {
+		toomany = xatoi_u(stoomany);
+	}
+	argc -= optind;
+	argv += optind;
+
+	uid = getuid();
+	if (uid != 0)
+		CONFIG = NULL;
+	if (argc > 0)
+		CONFIG = argv[0];
+	if (CONFIG == NULL)
+		bb_error_msg_and_die("non-root must specify a config file");
+
+	if (!(opt & 2)) {
+#ifdef BB_NOMMU
+		/* reexec for vfork() do continue parent */
+		vfork_daemon_rexec(0, 0, argc, argv, "-f");
+#else
+		xdaemon(0, 0);
+#endif
+	} else {
+		setsid();
+	}
+	logmode = LOGMODE_SYSLOG;
+
+	if (uid == 0) {
+		gid_t gid = getgid();
+
+		/* If run by hand, ensure groups vector gets trashed */
+		setgroups(1, &gid);
+	}
+
+	{
+		FILE *fp = fopen(_PATH_INETDPID, "w");
+
+		if (fp != NULL) {
+			fprintf(fp, "%u\n", getpid());
+			(void) fclose(fp);
+		}
+	}
+
+	if (getrlimit(RLIMIT_NOFILE, &rlim_ofile) < 0) {
+		bb_perror_msg("getrlimit");
+	} else {
+		rlim_ofile_cur = rlim_ofile.rlim_cur;
+		if (rlim_ofile_cur == RLIM_INFINITY)    /* ! */
+			rlim_ofile_cur = OPEN_MAX;
+	}
+
+	memset((char *) &sa, 0, sizeof(sa));
+	sigemptyset(&sa.sa_mask);
+	sigaddset(&sa.sa_mask, SIGALRM);
+	sigaddset(&sa.sa_mask, SIGCHLD);
+	sigaddset(&sa.sa_mask, SIGHUP);
+	sa.sa_handler = retry;
+	sigaction(SIGALRM, &sa, NULL);
+	config(SIGHUP);
+	sa.sa_handler = config;
+	sigaction(SIGHUP, &sa, NULL);
+	sa.sa_handler = reapchild;
+	sigaction(SIGCHLD, &sa, NULL);
+	sa.sa_handler = goaway;
+	sigaction(SIGTERM, &sa, NULL);
+	sa.sa_handler = goaway;
+	sigaction(SIGINT, &sa, NULL);
+	sa.sa_handler = SIG_IGN;
+	sigaction(SIGPIPE, &sa, &sapipe);
+	memset(&wait_mask, 0, sizeof(wait_mask));
+	{
+		/* space for daemons to overwrite environment for ps */
+#define DUMMYSIZE       100
+		char dummy[DUMMYSIZE];
+
+		(void) memset(dummy, 'x', DUMMYSIZE - 1);
+		dummy[DUMMYSIZE - 1] = '\0';
+
+		(void) setenv("inetd_dummy", dummy, 1);
+	}
+
+	for (;;) {
+		int n, ctrl = -1;
+		fd_set readable;
+
+		if (nsock == 0) {
+			Block_Using_Signals(omask);
+			while (nsock == 0)
+				sigsuspend(&wait_mask);
+			sigprocmask(SIG_UNBLOCK, &omask, NULL);
+		}
+
+		readable = allsock;
+		n = select(maxsock + 1, &readable, NULL, NULL, NULL);
+		if (n <= 0) {
+			if (n < 0 && errno != EINTR) {
+				bb_perror_msg("select");
+				sleep(1);
+			}
+			continue;
+		}
+
+		for (sep = servtab; n && sep; sep = sep->se_next) {
+			if (sep->se_fd == -1 || !FD_ISSET(sep->se_fd, &readable))
+				continue;
+
+			n--;
+			if (!sep->se_wait && sep->se_socktype == SOCK_STREAM) {
+				ctrl = accept(sep->se_fd, NULL, NULL);
+				if (ctrl < 0) {
+					if (errno == EINTR)
+						continue;
+					bb_perror_msg("accept (for %s)", sep->se_service);
+					continue;
+				}
+				if (sep->se_family == AF_INET && sep->se_socktype == SOCK_STREAM) {
+					struct sockaddr_in peer;
+					socklen_t plen = sizeof(peer);
+
+					if (getpeername(ctrl, (struct sockaddr *) &peer, &plen) < 0) {
+						bb_error_msg("cannot getpeername");
+						close(ctrl);
+						continue;
+					}
+					if (ntohs(peer.sin_port) == 20) {
+						/* XXX ftp bounce */
+						close(ctrl);
+						continue;
+					}
+				}
+			} else
+				ctrl = sep->se_fd;
+
+			Block_Using_Signals(omask);
+			pid = 0;
+#ifdef INETD_FEATURE_ENABLED
+			if (sep->se_bi == 0 || sep->se_bi->bi_fork)
+#endif
+			{
+				if (sep->se_count++ == 0)
+					(void) gettimeofday(&sep->se_time, NULL);
+				else if (toomany > 0 && sep->se_count >= sep->se_max) {
+					struct timeval now;
+
+					(void) gettimeofday(&now, NULL);
+					if (now.tv_sec - sep->se_time.tv_sec > CNT_INTVL) {
+						sep->se_time = now;
+						sep->se_count = 1;
+					} else {
+						if (!sep->se_wait && sep->se_socktype == SOCK_STREAM)
+							close(ctrl);
+						if (sep->se_family == AF_INET &&
+							  ntohs(sep->se_ctrladdr_in.sin_port) >= IPPORT_RESERVED) {
+							/*
+							 * Cannot close it -- there are
+							 * thieves on the system.
+							 * Simply ignore the connection.
+							 */
+							--sep->se_count;
+							continue;
+						}
+						bb_error_msg("%s/%s server failing (looping), service terminated",
+							      sep->se_service, sep->se_proto);
+						if (!sep->se_wait && sep->se_socktype == SOCK_STREAM)
+							close(ctrl);
+						FD_CLR(sep->se_fd, &allsock);
+						(void) close(sep->se_fd);
+						sep->se_fd = -1;
+						sep->se_count = 0;
+						nsock--;
+						sigprocmask(SIG_UNBLOCK, &omask, NULL);
+						if (!timingout) {
+							timingout = 1;
+							alarm(RETRYTIME);
+						}
+						continue;
+					}
+				}
+				pid = fork();
+			}
+			if (pid < 0) {
+				bb_perror_msg("fork");
+				if (!sep->se_wait && sep->se_socktype == SOCK_STREAM)
+					close(ctrl);
+				sigprocmask(SIG_UNBLOCK, &omask, NULL);
+				sleep(1);
+				continue;
+			}
+			if (pid && sep->se_wait) {
+				sep->se_wait = pid;
+				FD_CLR(sep->se_fd, &allsock);
+				nsock--;
+			}
+			sigprocmask(SIG_UNBLOCK, &omask, NULL);
+			if (pid == 0) {
+#ifdef INETD_FEATURE_ENABLED
+				if (sep->se_bi) {
+					(*sep->se_bi->bi_fn)(ctrl, sep);
+				} else
+#endif
+					{
+					pwd = getpwnam(sep->se_user);
+					if (pwd == NULL) {
+						bb_error_msg("getpwnam: %s: no such user", sep->se_user);
+						goto do_exit1;
+					}
+					if (setsid() < 0)
+						bb_perror_msg("%s: setsid", sep->se_service);
+					if (sep->se_group && (grp = getgrnam(sep->se_group)) == NULL) {
+						bb_error_msg("getgrnam: %s: no such group", sep->se_group);
+						goto do_exit1;
+					}
+					if (uid != 0) {
+						/* a user running private inetd */
+						if (uid != pwd->pw_uid)
+							_exit(1);
+					} else if (pwd->pw_uid) {
+						if (sep->se_group)
+							pwd->pw_gid = grp->gr_gid;
+						xsetgid((gid_t) pwd->pw_gid);
+						initgroups(pwd->pw_name, pwd->pw_gid);
+						xsetuid((uid_t) pwd->pw_uid);
+					} else if (sep->se_group) {
+						xsetgid(grp->gr_gid);
+						setgroups(1, &grp->gr_gid);
+					}
+					dup2(ctrl, 0);
+					if (ctrl) close(ctrl);
+					dup2(0, 1);
+					dup2(0, 2);
+					if (rlim_ofile.rlim_cur != rlim_ofile_cur)
+						if (setrlimit(RLIMIT_NOFILE, &rlim_ofile) < 0)
+							bb_perror_msg("setrlimit");
+					closelog();
+					for (tmpint = rlim_ofile_cur - 1; --tmpint > 2;)
+						(void) close(tmpint);
+					sigaction(SIGPIPE, &sapipe, NULL);
+					execv(sep->se_server, sep->se_argv);
+					bb_perror_msg("execv %s", sep->se_server);
+do_exit1:
+					if (sep->se_socktype != SOCK_STREAM)
+						recv(0, buf, sizeof(buf), 0);
+					_exit(1);
+				}
+			}
+			if (!sep->se_wait && sep->se_socktype == SOCK_STREAM)
+				close(ctrl);
+		} /* for (sep = servtab...) */
+	} /* for(;;) */
+}
+
+/*
+ * Internet services provided internally by inetd:
+ */
+#define BUFSIZE 4096
+
+#if defined(CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_ECHO) || \
+		defined(CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN) || \
+		defined(CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_DAYTIME)
+static int dg_badinput(struct sockaddr_in *dg_sin)
+{
+	if (ntohs(dg_sin->sin_port) < IPPORT_RESERVED)
+		return 1;
+	if (dg_sin->sin_addr.s_addr == htonl(INADDR_BROADCAST))
+		return 1;
+	/* XXX compare against broadcast addresses in SIOCGIFCONF list? */
+	return 0;
+}
+#endif
+
+#ifdef CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_ECHO
+/* Echo service -- echo data back */
+/* ARGSUSED */
+static void
+echo_stream(int s, servtab_t *sep)
+{
+	char buffer[BUFSIZE];
+	int i;
+
+	inetd_setproctitle(sep->se_service, s);
+	while (1) {
+		i = read(s, buffer, sizeof(buffer));
+		if (i <= 0) break;
+		/* FIXME: this isnt correct - safe_write()? */
+		if (write(s, buffer, i) <= 0) break;
+	}
+	exit(0);
+}
+
+/* Echo service -- echo data back */
+/* ARGSUSED */
+static void
+echo_dg(int s, servtab_t *sep ATTRIBUTE_UNUSED)
+{
+	char buffer[BUFSIZE];
+	int i;
+	socklen_t size;
+	/* struct sockaddr_storage ss; */
+	struct sockaddr sa;
+
+	size = sizeof(sa);
+	i = recvfrom(s, buffer, sizeof(buffer), 0, &sa, &size);
+	if (i < 0)
+		return;
+	if (dg_badinput((struct sockaddr_in *) &sa))
+		return;
+	(void) sendto(s, buffer, i, 0, &sa, sizeof(sa));
+}
+#endif  /* CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_ECHO */
+
+#ifdef CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_DISCARD
+/* Discard service -- ignore data */
+/* ARGSUSED */
+static void
+discard_stream(int s, servtab_t *sep)
+{
+	char buffer[BUFSIZE];
+
+	inetd_setproctitle(sep->se_service, s);
+	while (1) {
+		errno = 0;
+		if (read(s, buffer, sizeof(buffer)) <= 0 && errno != EINTR)
+			exit(0);
+	}
+}
+
+/* Discard service -- ignore data */
+/* ARGSUSED */
+static void
+discard_dg(int s, servtab_t *sep ATTRIBUTE_UNUSED)
+{
+	char buffer[BUFSIZE];
+
+	(void) read(s, buffer, sizeof(buffer));
+}
+#endif /* CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_DISCARD */
+
+
+#ifdef CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN
+#define LINESIZ 72
+static char ring[128];
+static char *endring;
+
+static void
+initring(void)
+{
+	int i;
+
+	endring = ring;
+
+	for (i = 0; i <= 128; ++i)
+		if (isprint(i))
+			*endring++ = i;
+}
+
+/* Character generator */
+/* ARGSUSED */
+static void
+chargen_stream(int s, servtab_t *sep)
+{
+	char *rs;
+	int len;
+	char text[LINESIZ + 2];
+
+	inetd_setproctitle(sep->se_service, s);
+
+	if (!endring) {
+		initring();
+		rs = ring;
+	}
+
+	text[LINESIZ] = '\r';
+	text[LINESIZ + 1] = '\n';
+	rs = ring;
+	for (;;) {
+		len = endring - rs;
+		if (len >= LINESIZ)
+			memmove(text, rs, LINESIZ);
+		else {
+			memmove(text, rs, len);
+			memmove(text + len, ring, LINESIZ - len);
+		}
+		if (++rs == endring)
+			rs = ring;
+		if (write(s, text, sizeof(text)) != sizeof(text))
+			break;
+	}
+	exit(0);
+}
+
+/* Character generator */
+/* ARGSUSED */
+static void
+chargen_dg(int s, servtab_t *sep ATTRIBUTE_UNUSED)
+{
+	/* struct sockaddr_storage ss; */
+	struct sockaddr sa;
+	static char *rs;
+	int len;
+	char text[LINESIZ + 2];
+	socklen_t size;
+
+	if (endring == 0) {
+		initring();
+		rs = ring;
+	}
+
+	size = sizeof(sa);
+	if (recvfrom(s, text, sizeof(text), 0, &sa, &size) < 0)
+		return;
+	if (dg_badinput((struct sockaddr_in *) &sa))
+		return;
+
+	if ((len = endring - rs) >= LINESIZ)
+		memmove(text, rs, LINESIZ);
+	else {
+		memmove(text, rs, len);
+		memmove(text + len, ring, LINESIZ - len);
+	}
+	if (++rs == endring)
+		rs = ring;
+	text[LINESIZ] = '\r';
+	text[LINESIZ + 1] = '\n';
+	(void) sendto(s, text, sizeof(text), 0, &sa, sizeof(sa));
+}
+#endif /* CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN */
+
+
+#ifdef CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_TIME
+/*
+ * Return a machine readable date and time, in the form of the
+ * number of seconds since midnight, Jan 1, 1900.  Since gettimeofday
+ * returns the number of seconds since midnight, Jan 1, 1970,
+ * we must add 2208988800 seconds to this figure to make up for
+ * some seventy years Bell Labs was asleep.
+ */
+
+static u_int machtime(void)
+{
+	struct timeval tv;
+
+	if (gettimeofday(&tv, NULL) < 0) {
+		fprintf(stderr, "Unable to get time of day\n");
+		return 0L;
+	}
+	return htonl((u_int) tv.tv_sec + 2208988800UL);
+}
+
+/* ARGSUSED */
+static void
+machtime_stream(int s, servtab_t *sep ATTRIBUTE_UNUSED)
+{
+	u_int result;
+
+	result = machtime();
+	(void) write(s, (char *) &result, sizeof(result));
+}
+
+/* ARGSUSED */
+static void
+machtime_dg(int s, servtab_t *sep ATTRIBUTE_UNUSED)
+{
+	u_int result;
+	/* struct sockaddr_storage ss; */
+	struct sockaddr sa;
+	struct sockaddr_in *dg_sin;
+	socklen_t size;
+
+	size = sizeof(sa);
+	if (recvfrom(s, (char *) &result, sizeof(result), 0, &sa, &size) < 0)
+		return;
+	/* if (dg_badinput((struct sockaddr *)&ss)) */
+	dg_sin = (struct sockaddr_in *) &sa;
+	if (dg_sin->sin_addr.s_addr == htonl(INADDR_BROADCAST) ||
+			ntohs(dg_sin->sin_port) < IPPORT_RESERVED / 2)
+		return;
+	result = machtime();
+	(void) sendto(s, (char *) &result, sizeof(result), 0, &sa, sizeof(sa));
+}
+#endif /* CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_TIME */
+
+
+#ifdef CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_DAYTIME
+/* Return human-readable time of day */
+/* ARGSUSED */
+static void daytime_stream(int s, servtab_t *sep ATTRIBUTE_UNUSED)
+{
+	char buffer[256];
+	time_t t;
+
+	t = time(NULL);
+
+	(void) sprintf(buffer, "%.24s\r\n", ctime(&t));
+	(void) write(s, buffer, strlen(buffer));
+}
+
+/* Return human-readable time of day */
+/* ARGSUSED */
+void
+daytime_dg(int s, servtab_t *sep ATTRIBUTE_UNUSED)
+{
+	char buffer[256];
+	time_t t;
+	/* struct sockaddr_storage ss; */
+	struct sockaddr sa;
+	socklen_t size;
+
+	t = time(NULL);
+
+	size = sizeof(sa);
+	if (recvfrom(s, buffer, sizeof(buffer), 0, &sa, &size) < 0)
+		return;
+	if (dg_badinput((struct sockaddr_in *) &sa))
+		return;
+	(void) sprintf(buffer, "%.24s\r\n", ctime(&t));
+	(void) sendto(s, buffer, strlen(buffer), 0, &sa, sizeof(sa));
+}
+#endif /* CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_DAYTIME */
diff --git a/networking/interface.c b/networking/interface.c
new file mode 100644
index 0000000..dd45582
--- /dev/null
+++ b/networking/interface.c
@@ -0,0 +1,1152 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * stolen from net-tools-1.59 and stripped down for busybox by
+ *			Erik Andersen <andersen@codepoet.org>
+ *
+ * Heavily modified by Manuel Novoa III       Mar 12, 2001
+ *
+ * Added print_bytes_scaled function to reduce code size.
+ * Added some (potentially) missing defines.
+ * Improved display support for -a and for a named interface.
+ *
+ * -----------------------------------------------------------
+ *
+ * ifconfig   This file contains an implementation of the command
+ *              that either displays or sets the characteristics of
+ *              one or more of the system's networking interfaces.
+ *
+ * Version:     $Id: interface.c,v 1.25 2004/08/26 21:45:21 andersen Exp $
+ *
+ * Author:      Fred N. van Kempen, <waltje@uwalt.nl.mugnet.org>
+ *              and others.  Copyright 1993 MicroWalt Corporation
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ *
+ * Patched to support 'add' and 'del' keywords for INET(4) addresses
+ * by Mrs. Brisby <mrs.brisby@nimh.org>
+ *
+ * {1.34} - 19980630 - Arnaldo Carvalho de Melo <acme@conectiva.com.br>
+ *                     - gettext instead of catgets for i18n
+ *          10/1998  - Andi Kleen. Use interface list primitives.
+ *	    20001008 - Bernd Eckenfels, Patch from RH for setting mtu
+ *			(default AF was wrong)
+ */
+
+#include "inet_common.h"
+#include <stdio.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <ctype.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <net/if.h>
+#include <net/if_arp.h>
+#include "busybox.h"
+
+#ifdef CONFIG_FEATURE_IPV6
+# define HAVE_AFINET6 1
+#else
+# undef HAVE_AFINET6
+#endif
+
+#define _PATH_PROCNET_DEV               "/proc/net/dev"
+#define _PATH_PROCNET_IFINET6           "/proc/net/if_inet6"
+
+#ifdef HAVE_AFINET6
+
+#ifndef _LINUX_IN6_H
+/*
+ *    This is in linux/include/net/ipv6.h.
+ */
+
+struct in6_ifreq {
+	struct in6_addr ifr6_addr;
+	uint32_t ifr6_prefixlen;
+	unsigned int ifr6_ifindex;
+};
+
+#endif
+
+#endif /* HAVE_AFINET6 */
+
+/* Defines for glibc2.0 users. */
+#ifndef SIOCSIFTXQLEN
+#define SIOCSIFTXQLEN      0x8943
+#define SIOCGIFTXQLEN      0x8942
+#endif
+
+/* ifr_qlen is ifru_ivalue, but it isn't present in 2.0 kernel headers */
+#ifndef ifr_qlen
+#define ifr_qlen        ifr_ifru.ifru_mtu
+#endif
+
+#ifndef HAVE_TXQUEUELEN
+#define HAVE_TXQUEUELEN 1
+#endif
+
+#ifndef IFF_DYNAMIC
+#define IFF_DYNAMIC     0x8000	/* dialup device with changing addresses */
+#endif
+
+/* This structure defines protocol families and their handlers. */
+struct aftype {
+	const char *name;
+	const char *title;
+	int af;
+	int alen;
+	char *(*print) (unsigned char *);
+	char *(*sprint) (struct sockaddr *, int numeric);
+	int (*input) (int type, char *bufp, struct sockaddr *);
+	void (*herror) (char *text);
+	int (*rprint) (int options);
+	int (*rinput) (int typ, int ext, char **argv);
+
+	/* may modify src */
+	int (*getmask) (char *src, struct sockaddr * mask, char *name);
+
+	int fd;
+	char *flag_file;
+};
+
+/* Display an Internet socket address. */
+static char *INET_sprint(struct sockaddr *sap, int numeric)
+{
+	static char buff[128];
+
+	if (sap->sa_family == 0xFFFF || sap->sa_family == 0)
+		return safe_strncpy(buff, "[NONE SET]", sizeof(buff));
+
+	if (INET_rresolve(buff, sizeof(buff), (struct sockaddr_in *) sap,
+					  numeric, 0xffffff00) != 0)
+		return NULL;
+
+	return buff;
+}
+
+static struct aftype inet_aftype = {
+	.name =		"inet",
+	.title =	"DARPA Internet",
+	.af =		AF_INET,
+	.alen =		4,
+	.sprint =	INET_sprint,
+	.fd =		-1
+};
+
+#ifdef HAVE_AFINET6
+
+/* Display an Internet socket address. */
+/* dirty! struct sockaddr usually doesn't suffer for inet6 addresses, fst. */
+static char *INET6_sprint(struct sockaddr *sap, int numeric)
+{
+	static char buff[128];
+
+	if (sap->sa_family == 0xFFFF || sap->sa_family == 0)
+		return safe_strncpy(buff, "[NONE SET]", sizeof(buff));
+	if (INET6_rresolve
+		(buff, sizeof(buff), (struct sockaddr_in6 *) sap, numeric) != 0)
+		return safe_strncpy(buff, "[UNKNOWN]", sizeof(buff));
+	return buff;
+}
+
+static struct aftype inet6_aftype = {
+	.name =		"inet6",
+	.title =	"IPv6",
+	.af =		AF_INET6,
+	.alen =		sizeof(struct in6_addr),
+	.sprint =	INET6_sprint,
+	.fd =		-1
+};
+
+#endif /* HAVE_AFINET6 */
+
+/* Display an UNSPEC address. */
+static char *UNSPEC_print(unsigned char *ptr)
+{
+	static char buff[sizeof(struct sockaddr) * 3 + 1];
+	char *pos;
+	unsigned int i;
+
+	pos = buff;
+	for (i = 0; i < sizeof(struct sockaddr); i++) {
+		/* careful -- not every libc's sprintf returns # bytes written */
+		sprintf(pos, "%02X-", (*ptr++ & 0377));
+		pos += 3;
+	}
+	/* Erase trailing "-".  Works as long as sizeof(struct sockaddr) != 0 */
+	*--pos = '\0';
+	return buff;
+}
+
+/* Display an UNSPEC socket address. */
+static char *UNSPEC_sprint(struct sockaddr *sap, int numeric)
+{
+	static char buf[64];
+
+	if (sap->sa_family == 0xFFFF || sap->sa_family == 0)
+		return safe_strncpy(buf, "[NONE SET]", sizeof(buf));
+	return UNSPEC_print((unsigned char *)sap->sa_data);
+}
+
+static struct aftype unspec_aftype = {
+	"unspec", "UNSPEC", AF_UNSPEC, 0,
+	UNSPEC_print, UNSPEC_sprint, NULL, NULL,
+	NULL,
+};
+
+static struct aftype * const aftypes[] = {
+	&inet_aftype,
+#ifdef HAVE_AFINET6
+	&inet6_aftype,
+#endif
+	&unspec_aftype,
+	NULL
+};
+
+/* Check our protocol family table for this family. */
+static struct aftype *get_afntype(int af)
+{
+	struct aftype * const *afp;
+
+	afp = aftypes;
+	while (*afp != NULL) {
+		if ((*afp)->af == af)
+			return *afp;
+		afp++;
+	}
+	return NULL;
+}
+
+/* Check our protocol family table for this family and return its socket */
+static int get_socket_for_af(int af)
+{
+	struct aftype * const *afp;
+
+	afp = aftypes;
+	while (*afp != NULL) {
+		if ((*afp)->af == af)
+			return (*afp)->fd;
+		afp++;
+	}
+	return -1;
+}
+
+struct user_net_device_stats {
+	unsigned long long rx_packets;	/* total packets received       */
+	unsigned long long tx_packets;	/* total packets transmitted    */
+	unsigned long long rx_bytes;	/* total bytes received         */
+	unsigned long long tx_bytes;	/* total bytes transmitted      */
+	unsigned long rx_errors;	/* bad packets received         */
+	unsigned long tx_errors;	/* packet transmit problems     */
+	unsigned long rx_dropped;	/* no space in linux buffers    */
+	unsigned long tx_dropped;	/* no space available in linux  */
+	unsigned long rx_multicast;	/* multicast packets received   */
+	unsigned long rx_compressed;
+	unsigned long tx_compressed;
+	unsigned long collisions;
+
+	/* detailed rx_errors: */
+	unsigned long rx_length_errors;
+	unsigned long rx_over_errors;	/* receiver ring buff overflow  */
+	unsigned long rx_crc_errors;	/* recved pkt with crc error    */
+	unsigned long rx_frame_errors;	/* recv'd frame alignment error */
+	unsigned long rx_fifo_errors;	/* recv'r fifo overrun          */
+	unsigned long rx_missed_errors;	/* receiver missed packet     */
+	/* detailed tx_errors */
+	unsigned long tx_aborted_errors;
+	unsigned long tx_carrier_errors;
+	unsigned long tx_fifo_errors;
+	unsigned long tx_heartbeat_errors;
+	unsigned long tx_window_errors;
+};
+
+struct interface {
+	struct interface *next, *prev;
+	char name[IFNAMSIZ];	/* interface name        */
+	short type;			/* if type               */
+	short flags;		/* various flags         */
+	int metric;			/* routing metric        */
+	int mtu;			/* MTU value             */
+	int tx_queue_len;	/* transmit queue length */
+	struct ifmap map;	/* hardware setup        */
+	struct sockaddr addr;	/* IP address            */
+	struct sockaddr dstaddr;	/* P-P IP address        */
+	struct sockaddr broadaddr;	/* IP broadcast address  */
+	struct sockaddr netmask;	/* IP network mask       */
+	int has_ip;
+	char hwaddr[32];	/* HW address            */
+	int statistics_valid;
+	struct user_net_device_stats stats;	/* statistics            */
+	int keepalive;		/* keepalive value for SLIP */
+	int outfill;		/* outfill value for SLIP */
+};
+
+
+int interface_opt_a;	/* show all interfaces          */
+
+static struct interface *int_list, *int_last;
+static int skfd = -1;	/* generic raw socket desc.     */
+
+
+static int sockets_open(int family)
+{
+	struct aftype * const *aft;
+	int sfd = -1;
+	static int force = -1;
+
+	if (force < 0) {
+		force = 0;
+		if (get_linux_version_code() < KERNEL_VERSION(2,1,0))
+			force = 1;
+		if (access("/proc/net", R_OK))
+			force = 1;
+	}
+	for (aft = aftypes; *aft; aft++) {
+		struct aftype *af = *aft;
+		int type = SOCK_DGRAM;
+
+		if (af->af == AF_UNSPEC)
+			continue;
+		if (family && family != af->af)
+			continue;
+		if (af->fd != -1) {
+			sfd = af->fd;
+			continue;
+		}
+		/* Check some /proc file first to not stress kmod */
+		if (!family && !force && af->flag_file) {
+			if (access(af->flag_file, R_OK))
+				continue;
+		}
+		af->fd = socket(af->af, type, 0);
+		if (af->fd >= 0)
+			sfd = af->fd;
+	}
+	if (sfd < 0) {
+		bb_error_msg("no usable address families found");
+	}
+	return sfd;
+}
+
+#ifdef CONFIG_FEATURE_CLEAN_UP
+static void sockets_close(void)
+{
+	struct aftype * const *aft;
+	for (aft = aftypes; *aft != NULL; aft++) {
+		struct aftype *af = *aft;
+		if( af->fd != -1 ) {
+			close(af->fd);
+			af->fd = -1;
+		}
+	}
+}
+#endif
+#if 0
+/* like strcmp(), but knows about numbers */
+except that the freshly added calls to xatoul() brf on ethernet aliases with
+uClibc with e.g.: ife->name='lo'  name='eth0:1'
+static int nstrcmp(const char *a, const char *b)
+{
+	const char *a_ptr = a;
+	const char *b_ptr = b;
+
+	while (*a == *b) {
+		if (*a == '\0') {
+			return 0;
+		}
+		if (!isdigit(*a) && isdigit(*(a+1))) {
+			a_ptr = a+1;
+			b_ptr = b+1;
+		}
+		a++;
+		b++;
+	}
+
+	if (isdigit(*a) && isdigit(*b)) {
+		return xatoul(a_ptr) > xatoul(b_ptr) ? 1 : -1;
+	}
+	return *a - *b;
+}
+#endif
+
+static struct interface *add_interface(char *name)
+{
+	struct interface *ife, **nextp, *new;
+
+	for (ife = int_last; ife; ife = ife->prev) {
+		int n = /*n*/strcmp(ife->name, name);
+
+		if (n == 0)
+			return ife;
+		if (n < 0)
+			break;
+	}
+
+	new = xzalloc(sizeof(*new));
+	safe_strncpy(new->name, name, IFNAMSIZ);
+	nextp = ife ? &ife->next : &int_list;
+	new->prev = ife;
+	new->next = *nextp;
+	if (new->next)
+		new->next->prev = new;
+	else
+		int_last = new;
+	*nextp = new;
+	return new;
+}
+
+
+static int if_readconf(void)
+{
+	int numreqs = 30;
+	struct ifconf ifc;
+	struct ifreq *ifr;
+	int n, err = -1;
+	int skfd2;
+
+	/* SIOCGIFCONF currently seems to only work properly on AF_INET sockets
+	   (as of 2.1.128) */
+	skfd2 = get_socket_for_af(AF_INET);
+	if (skfd2 < 0) {
+		bb_perror_msg(("warning: no inet socket available"));
+		/* Try to soldier on with whatever socket we can get hold of.  */
+		skfd2 = sockets_open(0);
+		if (skfd2 < 0)
+			return -1;
+	}
+
+	ifc.ifc_buf = NULL;
+	for (;;) {
+		ifc.ifc_len = sizeof(struct ifreq) * numreqs;
+		ifc.ifc_buf = xrealloc(ifc.ifc_buf, ifc.ifc_len);
+
+		if (ioctl(skfd2, SIOCGIFCONF, &ifc) < 0) {
+			perror("SIOCGIFCONF");
+			goto out;
+		}
+		if (ifc.ifc_len == sizeof(struct ifreq) * numreqs) {
+			/* assume it overflowed and try again */
+			numreqs += 10;
+			continue;
+		}
+		break;
+	}
+
+	ifr = ifc.ifc_req;
+	for (n = 0; n < ifc.ifc_len; n += sizeof(struct ifreq)) {
+		add_interface(ifr->ifr_name);
+		ifr++;
+	}
+	err = 0;
+
+  out:
+	free(ifc.ifc_buf);
+	return err;
+}
+
+static char *get_name(char *name, char *p)
+{
+	/* Extract <name> from nul-terminated p where p matches
+	   <name>: after leading whitespace.
+	   If match is not made, set name empty and return unchanged p */
+	int namestart=0, nameend=0;
+	while (isspace(p[namestart]))
+		namestart++;
+	nameend=namestart;
+	while (p[nameend] && p[nameend]!=':' && !isspace(p[nameend]))
+		nameend++;
+	if (p[nameend]==':') {
+		if ((nameend-namestart)<IFNAMSIZ) {
+			memcpy(name,&p[namestart],nameend-namestart);
+			name[nameend-namestart]='\0';
+			p=&p[nameend];
+		} else {
+			/* Interface name too large */
+			name[0]='\0';
+		}
+	} else {
+		/* trailing ':' not found - return empty */
+		name[0]='\0';
+	}
+	return p + 1;
+}
+
+/* If scanf supports size qualifiers for %n conversions, then we can
+ * use a modified fmt that simply stores the position in the fields
+ * having no associated fields in the proc string.  Of course, we need
+ * to zero them again when we're done.  But that is smaller than the
+ * old approach of multiple scanf occurrences with large numbers of
+ * args. */
+
+/* static const char * const ss_fmt[] = { */
+/*	"%lln%llu%lu%lu%lu%lu%ln%ln%lln%llu%lu%lu%lu%lu%lu", */
+/*	"%llu%llu%lu%lu%lu%lu%ln%ln%llu%llu%lu%lu%lu%lu%lu", */
+/*	"%llu%llu%lu%lu%lu%lu%lu%lu%llu%llu%lu%lu%lu%lu%lu%lu" */
+/* }; */
+
+	/* Lie about the size of the int pointed to for %n. */
+#if INT_MAX == LONG_MAX
+static const char * const ss_fmt[] = {
+	"%n%llu%u%u%u%u%n%n%n%llu%u%u%u%u%u",
+	"%llu%llu%u%u%u%u%n%n%llu%llu%u%u%u%u%u",
+	"%llu%llu%u%u%u%u%u%u%llu%llu%u%u%u%u%u%u"
+};
+#else
+static const char * const ss_fmt[] = {
+	"%n%llu%lu%lu%lu%lu%n%n%n%llu%lu%lu%lu%lu%lu",
+	"%llu%llu%lu%lu%lu%lu%n%n%llu%llu%lu%lu%lu%lu%lu",
+	"%llu%llu%lu%lu%lu%lu%lu%lu%llu%llu%lu%lu%lu%lu%lu%lu"
+};
+
+#endif
+
+static void get_dev_fields(char *bp, struct interface *ife, int procnetdev_vsn)
+{
+	memset(&ife->stats, 0, sizeof(struct user_net_device_stats));
+
+	sscanf(bp, ss_fmt[procnetdev_vsn],
+		   &ife->stats.rx_bytes, /* missing for 0 */
+		   &ife->stats.rx_packets,
+		   &ife->stats.rx_errors,
+		   &ife->stats.rx_dropped,
+		   &ife->stats.rx_fifo_errors,
+		   &ife->stats.rx_frame_errors,
+		   &ife->stats.rx_compressed, /* missing for <= 1 */
+		   &ife->stats.rx_multicast, /* missing for <= 1 */
+		   &ife->stats.tx_bytes, /* missing for 0 */
+		   &ife->stats.tx_packets,
+		   &ife->stats.tx_errors,
+		   &ife->stats.tx_dropped,
+		   &ife->stats.tx_fifo_errors,
+		   &ife->stats.collisions,
+		   &ife->stats.tx_carrier_errors,
+		   &ife->stats.tx_compressed /* missing for <= 1 */
+		   );
+
+	if (procnetdev_vsn <= 1) {
+		if (procnetdev_vsn == 0) {
+			ife->stats.rx_bytes = 0;
+			ife->stats.tx_bytes = 0;
+		}
+		ife->stats.rx_multicast = 0;
+		ife->stats.rx_compressed = 0;
+		ife->stats.tx_compressed = 0;
+	}
+}
+
+static inline int procnetdev_version(char *buf)
+{
+	if (strstr(buf, "compressed"))
+		return 2;
+	if (strstr(buf, "bytes"))
+		return 1;
+	return 0;
+}
+
+static int if_readlist_proc(char *target)
+{
+	static int proc_read;
+	FILE *fh;
+	char buf[512];
+	struct interface *ife;
+	int err, procnetdev_vsn;
+
+	if (proc_read)
+		return 0;
+	if (!target)
+		proc_read = 1;
+
+	fh = fopen(_PATH_PROCNET_DEV, "r");
+	if (!fh) {
+		bb_perror_msg("warning: cannot open %s, limiting output", _PATH_PROCNET_DEV);
+		return if_readconf();
+	}
+	fgets(buf, sizeof buf, fh);	/* eat line */
+	fgets(buf, sizeof buf, fh);
+
+	procnetdev_vsn = procnetdev_version(buf);
+
+	err = 0;
+	while (fgets(buf, sizeof buf, fh)) {
+		char *s, name[128];
+
+		s = get_name(name, buf);
+		ife = add_interface(name);
+		get_dev_fields(s, ife, procnetdev_vsn);
+		ife->statistics_valid = 1;
+		if (target && !strcmp(target, name))
+			break;
+	}
+	if (ferror(fh)) {
+		perror(_PATH_PROCNET_DEV);
+		err = -1;
+		proc_read = 0;
+	}
+	fclose(fh);
+	return err;
+}
+
+static int if_readlist(void)
+{
+	int err = if_readlist_proc(NULL);
+
+	if (!err)
+		err = if_readconf();
+	return err;
+}
+
+static int for_all_interfaces(int (*doit) (struct interface *, void *),
+							  void *cookie)
+{
+	struct interface *ife;
+
+	if (!int_list && (if_readlist() < 0))
+		return -1;
+	for (ife = int_list; ife; ife = ife->next) {
+		int err = doit(ife, cookie);
+
+		if (err)
+			return err;
+	}
+	return 0;
+}
+
+/* Fetch the interface configuration from the kernel. */
+static int if_fetch(struct interface *ife)
+{
+	struct ifreq ifr;
+	int fd;
+	char *ifname = ife->name;
+
+	strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
+	if (ioctl(skfd, SIOCGIFFLAGS, &ifr) < 0)
+		return -1;
+	ife->flags = ifr.ifr_flags;
+
+	strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
+	if (ioctl(skfd, SIOCGIFHWADDR, &ifr) < 0)
+		memset(ife->hwaddr, 0, 32);
+	else
+		memcpy(ife->hwaddr, ifr.ifr_hwaddr.sa_data, 8);
+
+	ife->type = ifr.ifr_hwaddr.sa_family;
+
+	strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
+	if (ioctl(skfd, SIOCGIFMETRIC, &ifr) < 0)
+		ife->metric = 0;
+	else
+		ife->metric = ifr.ifr_metric;
+
+	strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
+	if (ioctl(skfd, SIOCGIFMTU, &ifr) < 0)
+		ife->mtu = 0;
+	else
+		ife->mtu = ifr.ifr_mtu;
+
+#ifdef SIOCGIFMAP
+	strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
+	if (ioctl(skfd, SIOCGIFMAP, &ifr) == 0)
+		ife->map = ifr.ifr_map;
+	else
+#endif
+		memset(&ife->map, 0, sizeof(struct ifmap));
+
+#ifdef HAVE_TXQUEUELEN
+	strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
+	if (ioctl(skfd, SIOCGIFTXQLEN, &ifr) < 0)
+		ife->tx_queue_len = -1;	/* unknown value */
+	else
+		ife->tx_queue_len = ifr.ifr_qlen;
+#else
+	ife->tx_queue_len = -1;	/* unknown value */
+#endif
+
+	/* IPv4 address? */
+	fd = get_socket_for_af(AF_INET);
+	if (fd >= 0) {
+		strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
+		ifr.ifr_addr.sa_family = AF_INET;
+		if (ioctl(fd, SIOCGIFADDR, &ifr) == 0) {
+			ife->has_ip = 1;
+			ife->addr = ifr.ifr_addr;
+			strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
+			if (ioctl(fd, SIOCGIFDSTADDR, &ifr) < 0)
+				memset(&ife->dstaddr, 0, sizeof(struct sockaddr));
+			else
+				ife->dstaddr = ifr.ifr_dstaddr;
+
+			strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
+			if (ioctl(fd, SIOCGIFBRDADDR, &ifr) < 0)
+				memset(&ife->broadaddr, 0, sizeof(struct sockaddr));
+			else
+				ife->broadaddr = ifr.ifr_broadaddr;
+
+			strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
+			if (ioctl(fd, SIOCGIFNETMASK, &ifr) < 0)
+				memset(&ife->netmask, 0, sizeof(struct sockaddr));
+			else
+				ife->netmask = ifr.ifr_netmask;
+		} else
+			memset(&ife->addr, 0, sizeof(struct sockaddr));
+	}
+
+	return 0;
+}
+
+
+static int do_if_fetch(struct interface *ife)
+{
+	if (if_fetch(ife) < 0) {
+		char *errmsg;
+
+		if (errno == ENODEV) {
+			/* Give better error message for this case. */
+			errmsg = "Device not found";
+		} else {
+			errmsg = strerror(errno);
+		}
+		bb_error_msg("%s: error fetching interface information: %s",
+				ife->name, errmsg);
+		return -1;
+	}
+	return 0;
+}
+
+/* This structure defines hardware protocols and their handlers. */
+struct hwtype {
+	const char * const name;
+	const char *title;
+	int type;
+	int alen;
+	char *(*print) (unsigned char *);
+	int (*input) (char *, struct sockaddr *);
+	int (*activate) (int fd);
+	int suppress_null_addr;
+};
+
+static const struct hwtype unspec_hwtype = {
+	.name =		"unspec",
+	.title =	"UNSPEC",
+	.type =		-1,
+	.print =	UNSPEC_print
+};
+
+static const struct hwtype loop_hwtype = {
+	.name =		"loop",
+	.title =	"Local Loopback",
+	.type =		ARPHRD_LOOPBACK
+};
+
+#include <net/if_arp.h>
+
+#if (__GLIBC__ >=2 && __GLIBC_MINOR__ >= 1) || defined(_NEWLIB_VERSION)
+#include <net/ethernet.h>
+#else
+#include <linux/if_ether.h>
+#endif
+
+/* Display an Ethernet address in readable format. */
+static char *pr_ether(unsigned char *ptr)
+{
+	static char buff[64];
+
+	snprintf(buff, sizeof(buff), "%02X:%02X:%02X:%02X:%02X:%02X",
+			 (ptr[0] & 0377), (ptr[1] & 0377), (ptr[2] & 0377),
+			 (ptr[3] & 0377), (ptr[4] & 0377), (ptr[5] & 0377)
+		);
+	return buff;
+}
+
+static const struct hwtype ether_hwtype = {
+	.name =		"ether",
+	.title =	"Ethernet",
+	.type =		ARPHRD_ETHER,
+	.alen =		ETH_ALEN,
+	.print =	pr_ether
+};
+
+#include <net/if_arp.h>
+
+static const struct hwtype ppp_hwtype = {
+	.name =		"ppp",
+	.title =	"Point-to-Point Protocol",
+	.type =		ARPHRD_PPP
+};
+
+#ifdef CONFIG_FEATURE_IPV6
+static const struct hwtype sit_hwtype = {
+	.name =			"sit",
+	.title =		"IPv6-in-IPv4",
+	.type =			ARPHRD_SIT,
+	.print =		UNSPEC_print,
+	.suppress_null_addr =	1
+} ;
+#endif
+
+static const struct hwtype * const hwtypes[] = {
+	&loop_hwtype,
+	&ether_hwtype,
+	&ppp_hwtype,
+	&unspec_hwtype,
+#ifdef CONFIG_FEATURE_IPV6
+	&sit_hwtype,
+#endif
+	NULL
+};
+
+#ifdef IFF_PORTSEL
+static const char * const if_port_text[] = {
+	/* Keep in step with <linux/netdevice.h> */
+	"unknown",
+	"10base2",
+	"10baseT",
+	"AUI",
+	"100baseT",
+	"100baseTX",
+	"100baseFX",
+	NULL
+};
+#endif
+
+/* Check our hardware type table for this type. */
+static const struct hwtype *get_hwntype(int type)
+{
+	const struct hwtype * const *hwp;
+
+	hwp = hwtypes;
+	while (*hwp != NULL) {
+		if ((*hwp)->type == type)
+			return *hwp;
+		hwp++;
+	}
+	return NULL;
+}
+
+/* return 1 if address is all zeros */
+static int hw_null_address(const struct hwtype *hw, void *ap)
+{
+	unsigned int i;
+	unsigned char *address = (unsigned char *) ap;
+
+	for (i = 0; i < hw->alen; i++)
+		if (address[i])
+			return 0;
+	return 1;
+}
+
+static const char TRext[] = "\0\0\0Ki\0Mi\0Gi\0Ti";
+
+static void print_bytes_scaled(unsigned long long ull, const char *end)
+{
+	unsigned long long int_part;
+	const char *ext;
+	unsigned int frac_part;
+	int i;
+
+	frac_part = 0;
+	ext = TRext;
+	int_part = ull;
+	i = 4;
+	do {
+		if (int_part >= 1024) {
+			frac_part = ((((unsigned int) int_part) & (1024-1)) * 10) / 1024;
+			int_part /= 1024;
+			ext += 3;	/* KiB, MiB, GiB, TiB */
+		}
+		--i;
+	} while (i);
+
+	printf("X bytes:%llu (%llu.%u %sB)%s", ull, int_part, frac_part, ext, end);
+}
+
+static const char * const ife_print_flags_strs[] = {
+	"UP ",
+	"BROADCAST ",
+	"DEBUG ",
+	"LOOPBACK ",
+	"POINTOPOINT ",
+	"NOTRAILERS ",
+	"RUNNING ",
+	"NOARP ",
+	"PROMISC ",
+	"ALLMULTI ",
+	"SLAVE ",
+	"MASTER ",
+	"MULTICAST ",
+#ifdef HAVE_DYNAMIC
+	"DYNAMIC "
+#endif
+};
+
+static const unsigned short ife_print_flags_mask[] = {
+	IFF_UP,
+	IFF_BROADCAST,
+	IFF_DEBUG,
+	IFF_LOOPBACK,
+	IFF_POINTOPOINT,
+	IFF_NOTRAILERS,
+	IFF_RUNNING,
+	IFF_NOARP,
+	IFF_PROMISC,
+	IFF_ALLMULTI,
+	IFF_SLAVE,
+	IFF_MASTER,
+	IFF_MULTICAST,
+#ifdef HAVE_DYNAMIC
+	IFF_DYNAMIC
+#endif
+	0
+};
+
+static void ife_print(struct interface *ptr)
+{
+	struct aftype *ap;
+	const struct hwtype *hw;
+	int hf;
+	int can_compress = 0;
+
+#ifdef HAVE_AFINET6
+	FILE *f;
+	char addr6[40], devname[20];
+	struct sockaddr_in6 sap;
+	int plen, scope, dad_status, if_idx;
+	char addr6p[8][5];
+#endif
+
+	ap = get_afntype(ptr->addr.sa_family);
+	if (ap == NULL)
+		ap = get_afntype(0);
+
+	hf = ptr->type;
+
+	if (hf == ARPHRD_CSLIP || hf == ARPHRD_CSLIP6)
+		can_compress = 1;
+
+	hw = get_hwntype(hf);
+	if (hw == NULL)
+		hw = get_hwntype(-1);
+
+	printf("%-9.9s Link encap:%s  ", ptr->name, hw->title);
+	/* For some hardware types (eg Ash, ATM) we don't print the
+	   hardware address if it's null.  */
+	if (hw->print != NULL && (!(hw_null_address(hw, ptr->hwaddr) &&
+								hw->suppress_null_addr)))
+		printf("HWaddr %s  ", hw->print((unsigned char *)ptr->hwaddr));
+#ifdef IFF_PORTSEL
+	if (ptr->flags & IFF_PORTSEL) {
+		printf("Media:%s", if_port_text[ptr->map.port] /* [0] */);
+		if (ptr->flags & IFF_AUTOMEDIA)
+			printf("(auto)");
+	}
+#endif
+	puts("");
+
+	if (ptr->has_ip) {
+		printf("          %s addr:%s ", ap->name,
+			   ap->sprint(&ptr->addr, 1));
+		if (ptr->flags & IFF_POINTOPOINT) {
+			printf(" P-t-P:%s ", ap->sprint(&ptr->dstaddr, 1));
+		}
+		if (ptr->flags & IFF_BROADCAST) {
+			printf(" Bcast:%s ", ap->sprint(&ptr->broadaddr, 1));
+		}
+		printf(" Mask:%s\n", ap->sprint(&ptr->netmask, 1));
+	}
+
+#ifdef HAVE_AFINET6
+
+#define IPV6_ADDR_ANY           0x0000U
+
+#define IPV6_ADDR_UNICAST       0x0001U
+#define IPV6_ADDR_MULTICAST     0x0002U
+#define IPV6_ADDR_ANYCAST       0x0004U
+
+#define IPV6_ADDR_LOOPBACK      0x0010U
+#define IPV6_ADDR_LINKLOCAL     0x0020U
+#define IPV6_ADDR_SITELOCAL     0x0040U
+
+#define IPV6_ADDR_COMPATv4      0x0080U
+
+#define IPV6_ADDR_SCOPE_MASK    0x00f0U
+
+#define IPV6_ADDR_MAPPED        0x1000U
+#define IPV6_ADDR_RESERVED      0x2000U	/* reserved address space */
+
+	if ((f = fopen(_PATH_PROCNET_IFINET6, "r")) != NULL) {
+		while (fscanf
+			   (f, "%4s%4s%4s%4s%4s%4s%4s%4s %02x %02x %02x %02x %20s\n",
+				addr6p[0], addr6p[1], addr6p[2], addr6p[3], addr6p[4],
+				addr6p[5], addr6p[6], addr6p[7], &if_idx, &plen, &scope,
+				&dad_status, devname) != EOF) {
+			if (!strcmp(devname, ptr->name)) {
+				sprintf(addr6, "%s:%s:%s:%s:%s:%s:%s:%s",
+						addr6p[0], addr6p[1], addr6p[2], addr6p[3],
+						addr6p[4], addr6p[5], addr6p[6], addr6p[7]);
+				inet_pton(AF_INET6, addr6,
+						  (struct sockaddr *) &sap.sin6_addr);
+				sap.sin6_family = AF_INET6;
+				printf("          inet6 addr: %s/%d",
+					   inet6_aftype.sprint((struct sockaddr *) &sap, 1),
+					   plen);
+				printf(" Scope:");
+				switch (scope & IPV6_ADDR_SCOPE_MASK) {
+				case 0:
+					printf("Global");
+					break;
+				case IPV6_ADDR_LINKLOCAL:
+					printf("Link");
+					break;
+				case IPV6_ADDR_SITELOCAL:
+					printf("Site");
+					break;
+				case IPV6_ADDR_COMPATv4:
+					printf("Compat");
+					break;
+				case IPV6_ADDR_LOOPBACK:
+					printf("Host");
+					break;
+				default:
+					printf("Unknown");
+				}
+				puts("");
+			}
+		}
+		fclose(f);
+	}
+#endif
+
+	printf("          ");
+	/* DONT FORGET TO ADD THE FLAGS IN ife_print_short, too */
+
+	if (ptr->flags == 0) {
+		printf("[NO FLAGS] ");
+	} else {
+		int i = 0;
+		do {
+			if (ptr->flags & ife_print_flags_mask[i]) {
+				printf(ife_print_flags_strs[i]);
+			}
+		} while (ife_print_flags_mask[++i]);
+	}
+
+	/* DONT FORGET TO ADD THE FLAGS IN ife_print_short */
+	printf(" MTU:%d  Metric:%d", ptr->mtu, ptr->metric ? ptr->metric : 1);
+#ifdef SIOCSKEEPALIVE
+	if (ptr->outfill || ptr->keepalive)
+		printf("  Outfill:%d  Keepalive:%d", ptr->outfill, ptr->keepalive);
+#endif
+	puts("");
+
+	/* If needed, display the interface statistics. */
+
+	if (ptr->statistics_valid) {
+		/* XXX: statistics are currently only printed for the primary address,
+		 *      not for the aliases, although strictly speaking they're shared
+		 *      by all addresses.
+		 */
+		printf("          ");
+
+		printf("RX packets:%llu errors:%lu dropped:%lu overruns:%lu frame:%lu\n",
+			   ptr->stats.rx_packets, ptr->stats.rx_errors,
+			   ptr->stats.rx_dropped, ptr->stats.rx_fifo_errors,
+			   ptr->stats.rx_frame_errors);
+		if (can_compress)
+			printf("             compressed:%lu\n",
+				   ptr->stats.rx_compressed);
+		printf("          ");
+		printf("TX packets:%llu errors:%lu dropped:%lu overruns:%lu carrier:%lu\n",
+			   ptr->stats.tx_packets, ptr->stats.tx_errors,
+			   ptr->stats.tx_dropped, ptr->stats.tx_fifo_errors,
+			   ptr->stats.tx_carrier_errors);
+		printf("          collisions:%lu ", ptr->stats.collisions);
+		if (can_compress)
+			printf("compressed:%lu ", ptr->stats.tx_compressed);
+		if (ptr->tx_queue_len != -1)
+			printf("txqueuelen:%d ", ptr->tx_queue_len);
+		printf("\n          R");
+		print_bytes_scaled(ptr->stats.rx_bytes, "  T");
+		print_bytes_scaled(ptr->stats.tx_bytes, "\n");
+
+	}
+
+	if ((ptr->map.irq || ptr->map.mem_start || ptr->map.dma ||
+		 ptr->map.base_addr)) {
+		printf("          ");
+		if (ptr->map.irq)
+			printf("Interrupt:%d ", ptr->map.irq);
+		if (ptr->map.base_addr >= 0x100)	/* Only print devices using it for
+											   I/O maps */
+			printf("Base address:0x%lx ",
+				   (unsigned long) ptr->map.base_addr);
+		if (ptr->map.mem_start) {
+			printf("Memory:%lx-%lx ", ptr->map.mem_start,
+				   ptr->map.mem_end);
+		}
+		if (ptr->map.dma)
+			printf("DMA chan:%x ", ptr->map.dma);
+		puts("");
+	}
+	puts("");
+}
+
+
+static int do_if_print(struct interface *ife, void *cookie)
+{
+	int *opt_a = (int *) cookie;
+	int res;
+
+	res = do_if_fetch(ife);
+	if (res >= 0) {
+		if ((ife->flags & IFF_UP) || *opt_a)
+			ife_print(ife);
+	}
+	return res;
+}
+
+static struct interface *lookup_interface(char *name)
+{
+	struct interface *ife = NULL;
+
+	if (if_readlist_proc(name) < 0)
+		return NULL;
+	ife = add_interface(name);
+	return ife;
+}
+
+/* for ipv4 add/del modes */
+static int if_print(char *ifname)
+{
+	int res;
+
+	if (!ifname) {
+		res = for_all_interfaces(do_if_print, &interface_opt_a);
+	} else {
+		struct interface *ife;
+
+		ife = lookup_interface(ifname);
+		res = do_if_fetch(ife);
+		if (res >= 0)
+			ife_print(ife);
+	}
+	return res;
+}
+
+int display_interfaces(char *ifname);
+int display_interfaces(char *ifname)
+{
+	int status;
+
+	/* Create a channel to the NET kernel. */
+	if ((skfd = sockets_open(0)) < 0) {
+		bb_perror_msg_and_die("socket");
+	}
+
+	/* Do we have to show the current setup? */
+	status = if_print(ifname);
+#ifdef CONFIG_FEATURE_CLEAN_UP
+	sockets_close();
+#endif
+	exit(status < 0);
+}
diff --git a/networking/ip.c b/networking/ip.c
new file mode 100644
index 0000000..4c8b89e
--- /dev/null
+++ b/networking/ip.c
@@ -0,0 +1,48 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * ip.c		"ip" utility frontend.
+ *
+ * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+ *
+ * Authors:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
+ *
+ *
+ * Changes:
+ *
+ * Rani Assaf <rani@magic.metawire.com> 980929:	resolve addresses
+ */
+
+#include "busybox.h"
+
+#include "libiproute/utils.h"
+#include "libiproute/ip_common.h"
+
+int ip_main(int argc, char **argv)
+{
+	int ret = EXIT_FAILURE;
+
+	ip_parse_common_args(&argc, &argv);
+
+	if (argc > 1) {
+		if (ENABLE_FEATURE_IP_ADDRESS && matches(argv[1], "address") == 0) {
+			ret = do_ipaddr(argc-2, argv+2);
+		}
+		if (ENABLE_FEATURE_IP_ROUTE && matches(argv[1], "route") == 0) {
+			ret = do_iproute(argc-2, argv+2);
+		}
+		if (ENABLE_FEATURE_IP_LINK && matches(argv[1], "link") == 0) {
+			ret = do_iplink(argc-2, argv+2);
+		}
+		if (ENABLE_FEATURE_IP_TUNNEL &&
+			(matches(argv[1], "tunnel") == 0 || strcmp(argv[1], "tunl") == 0)) {
+			ret = do_iptunnel(argc-2, argv+2);
+		}
+		if (ENABLE_FEATURE_IP_RULE && matches(argv[1], "rule") == 0) {
+			ret = do_iprule(argc-2, argv+2);
+		}
+	}
+	if (ret) {
+		bb_show_usage();
+	}
+	return EXIT_SUCCESS;
+}
diff --git a/networking/ipaddr.c b/networking/ipaddr.c
new file mode 100644
index 0000000..c907808
--- /dev/null
+++ b/networking/ipaddr.c
@@ -0,0 +1,25 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * ip.c		"ip" utility frontend.
+ *
+ * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+ *
+ * Authors:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
+ *
+ *
+ * Changes:
+ *
+ * Rani Assaf <rani@magic.metawire.com> 980929:	resolve addresses
+ */
+
+#include "libiproute/utils.h"
+#include "libiproute/ip_common.h"
+
+#include "busybox.h"
+
+int ipaddr_main(int argc, char **argv)
+{
+	ip_parse_common_args(&argc, &argv);
+
+	return do_ipaddr(argc-1, argv+1);
+}
diff --git a/networking/ipcalc.c b/networking/ipcalc.c
new file mode 100644
index 0000000..0ee9646
--- /dev/null
+++ b/networking/ipcalc.c
@@ -0,0 +1,194 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Mini ipcalc implementation for busybox
+ *
+ * By Jordan Crouse <jordan@cosmicpenguin.net>
+ *    Stephan Linz  <linz@li-pro.net>
+ *
+ * This is a complete reimplementation of the ipcalc program
+ * from Red Hat.  I didn't look at their source code, but there
+ * is no denying that this is a loving reimplementation
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ */
+
+#include "busybox.h"
+#include <ctype.h>
+#include <getopt.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+
+#define CLASS_A_NETMASK	ntohl(0xFF000000)
+#define CLASS_B_NETMASK	ntohl(0xFFFF0000)
+#define CLASS_C_NETMASK	ntohl(0xFFFFFF00)
+
+static unsigned long get_netmask(unsigned long ipaddr)
+{
+	ipaddr = htonl(ipaddr);
+
+	if ((ipaddr & 0xC0000000) == 0xC0000000)
+		return CLASS_C_NETMASK;
+	else if ((ipaddr & 0x80000000) == 0x80000000)
+		return CLASS_B_NETMASK;
+	else if ((ipaddr & 0x80000000) == 0)
+		return CLASS_A_NETMASK;
+	else
+		return 0;
+}
+
+#ifdef CONFIG_FEATURE_IPCALC_FANCY
+static int get_prefix(unsigned long netmask)
+{
+	unsigned long msk = 0x80000000;
+	int ret = 0;
+
+	netmask = htonl(netmask);
+	while(msk) {
+		if (netmask & msk)
+			ret++;
+		msk >>= 1;
+	}
+	return ret;
+}
+#else
+int get_prefix(unsigned long netmask);
+#endif
+
+
+#define NETMASK   0x01
+#define BROADCAST 0x02
+#define NETWORK   0x04
+#define NETPREFIX 0x08
+#define HOSTNAME  0x10
+#define SILENT    0x20
+
+#if ENABLE_FEATURE_IPCALC_LONG_OPTIONS
+	static const struct option long_options[] = {
+		{ "netmask",     no_argument, NULL, 'm' },
+		{ "broadcast",   no_argument, NULL, 'b' },
+		{ "network",     no_argument, NULL, 'n' },
+# if ENABLE_FEATURE_IPCALC_FANCY
+		{ "prefix",      no_argument, NULL, 'p' },
+		{ "hostname",	 no_argument, NULL, 'h' },
+		{ "silent",      no_argument, NULL, 's' },
+# endif
+		{ NULL, 0, NULL, 0 }
+	};
+#endif
+
+int ipcalc_main(int argc, char **argv)
+{
+	unsigned opt;
+	int have_netmask = 0;
+	in_addr_t netmask, broadcast, network, ipaddr;
+	struct in_addr a;
+	char *ipstr;
+
+#if ENABLE_FEATURE_IPCALC_LONG_OPTIONS
+	applet_long_options = long_options;
+#endif
+	opt = getopt32(argc, argv, "mbn" USE_FEATURE_IPCALC_FANCY("phs"));
+	argc -= optind;
+	argv += optind;
+	if (opt & (BROADCAST | NETWORK | NETPREFIX)) {
+		if (argc > 2 || argc <= 0)
+			bb_show_usage();
+	} else {
+		if (argc != 1)
+			bb_show_usage();
+	}
+	if (opt & SILENT)
+		logmode = LOGMODE_NONE; /* Suppress error_msg() output */
+
+	ipstr = argv[0];
+	if (ENABLE_FEATURE_IPCALC_FANCY) {
+		unsigned long netprefix = 0;
+		char *prefixstr;
+
+		prefixstr = ipstr;
+
+		while (*prefixstr) {
+			if (*prefixstr == '/') {
+				*prefixstr = (char)0;
+				prefixstr++;
+				if (*prefixstr) {
+					unsigned msk;
+					netprefix = xatoul_range(prefixstr, 0, 32);
+					netmask = 0;
+					msk = 0x80000000;
+					while (netprefix > 0) {
+						netmask |= msk;
+						msk >>= 1;
+						netprefix--;
+					}
+					netmask = htonl(netmask);
+					/* Even if it was 0, we will signify that we have a netmask. This allows */
+					/* for specification of default routes, etc which have a 0 netmask/prefix */
+					have_netmask = 1;
+				}
+				break;
+			}
+			prefixstr++;
+		}
+	}
+	ipaddr = inet_aton(ipstr, &a);
+
+	if (ipaddr == 0) {
+		bb_error_msg_and_die("bad IP address: %s", argv[0]);
+	}
+	ipaddr = a.s_addr;
+
+	if (argc == 2) {
+		if (ENABLE_FEATURE_IPCALC_FANCY && have_netmask) {
+			bb_error_msg_and_die("use prefix or netmask, not both");
+		}
+
+		netmask = inet_aton(argv[1], &a);
+		if (netmask == 0) {
+			bb_error_msg_and_die("bad netmask: %s", argv[1]);
+		}
+		netmask = a.s_addr;
+	} else {
+
+		/* JHC - If the netmask wasn't provided then calculate it */
+		if (!ENABLE_FEATURE_IPCALC_FANCY || !have_netmask)
+			netmask = get_netmask(ipaddr);
+	}
+
+	if (opt & NETMASK) {
+		printf("NETMASK=%s\n", inet_ntoa((*(struct in_addr *) &netmask)));
+	}
+
+	if (opt & BROADCAST) {
+		broadcast = (ipaddr & netmask) | ~netmask;
+		printf("BROADCAST=%s\n", inet_ntoa((*(struct in_addr *) &broadcast)));
+	}
+
+	if (opt & NETWORK) {
+		network = ipaddr & netmask;
+		printf("NETWORK=%s\n", inet_ntoa((*(struct in_addr *) &network)));
+	}
+
+	if (ENABLE_FEATURE_IPCALC_FANCY) {
+		if (opt & NETPREFIX) {
+			printf("PREFIX=%i\n", get_prefix(netmask));
+		}
+
+		if (opt & HOSTNAME) {
+			struct hostent *hostinfo;
+			int x;
+
+			hostinfo = gethostbyaddr((char *) &ipaddr, sizeof(ipaddr), AF_INET);
+			if (!hostinfo) {
+				bb_herror_msg_and_die("cannot find hostname for %s", argv[0]);
+			}
+			for (x = 0; hostinfo->h_name[x]; x++) {
+				hostinfo->h_name[x] = tolower(hostinfo->h_name[x]);
+			}
+
+			printf("HOSTNAME=%s\n", hostinfo->h_name);
+		}
+	}
+
+	return EXIT_SUCCESS;
+}
diff --git a/networking/iplink.c b/networking/iplink.c
new file mode 100644
index 0000000..4a28c74
--- /dev/null
+++ b/networking/iplink.c
@@ -0,0 +1,25 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * ip.c		"ip" utility frontend.
+ *
+ * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+ *
+ * Authors:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
+ *
+ *
+ * Changes:
+ *
+ * Rani Assaf <rani@magic.metawire.com> 980929:	resolve addresses
+ */
+
+#include "libiproute/utils.h"
+#include "libiproute/ip_common.h"
+
+#include "busybox.h"
+
+int iplink_main(int argc, char **argv)
+{
+	ip_parse_common_args(&argc, &argv);
+
+	return do_iplink(argc-1, argv+1);
+}
diff --git a/networking/iproute.c b/networking/iproute.c
new file mode 100644
index 0000000..62335a8
--- /dev/null
+++ b/networking/iproute.c
@@ -0,0 +1,25 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * ip.c		"ip" utility frontend.
+ *
+ * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+ *
+ * Authors:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
+ *
+ *
+ * Changes:
+ *
+ * Rani Assaf <rani@magic.metawire.com> 980929:	resolve addresses
+ */
+
+#include "libiproute/utils.h"
+#include "libiproute/ip_common.h"
+
+#include "busybox.h"
+
+int iproute_main(int argc, char **argv)
+{
+	ip_parse_common_args(&argc, &argv);
+
+	return do_iproute(argc-1, argv+1);
+}
diff --git a/networking/iprule.c b/networking/iprule.c
new file mode 100644
index 0000000..43eaea6
--- /dev/null
+++ b/networking/iprule.c
@@ -0,0 +1,25 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * ip.c		"ip" utility frontend.
+ *
+ * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+ *
+ * Authors:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
+ *
+ *
+ * Changes:
+ *
+ * Rani Assaf <rani@magic.metawire.com> 980929:	resolve addresses
+ */
+
+#include "libiproute/utils.h"
+#include "libiproute/ip_common.h"
+
+#include "busybox.h"
+
+int iprule_main(int argc, char **argv)
+{
+	ip_parse_common_args(&argc, &argv);
+
+	return do_iprule(argc-1, argv+1);
+}
diff --git a/networking/iptunnel.c b/networking/iptunnel.c
new file mode 100644
index 0000000..9ae734a
--- /dev/null
+++ b/networking/iptunnel.c
@@ -0,0 +1,25 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * ip.c		"ip" utility frontend.
+ *
+ * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+ *
+ * Authors:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
+ *
+ *
+ * Changes:
+ *
+ * Rani Assaf <rani@magic.metawire.com> 980929:	resolve addresses
+ */
+
+#include "libiproute/utils.h"
+#include "libiproute/ip_common.h"
+
+#include "busybox.h"
+
+int iptunnel_main(int argc, char **argv)
+{
+	ip_parse_common_args(&argc, &argv);
+
+	return do_iptunnel(argc-1, argv+1);
+}
diff --git a/networking/libiproute/Kbuild b/networking/libiproute/Kbuild
new file mode 100644
index 0000000..8383630
--- /dev/null
+++ b/networking/libiproute/Kbuild
@@ -0,0 +1,66 @@
+# Makefile for busybox
+#
+# Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
+#
+# Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+#
+
+lib-y:=
+lib-$(CONFIG_IP) += \
+	ip_parse_common_args.o \
+	ipaddress.o \
+	iplink.o \
+	iproute.o \
+	iptunnel.o \
+	iprule.o \
+	libnetlink.o \
+	ll_addr.o \
+	ll_map.o \
+	ll_proto.o \
+	ll_types.o \
+	rt_names.o \
+	rtm_map.o \
+	utils.o
+
+lib-$(CONFIG_IPADDR) += \
+	ip_parse_common_args.o \
+	ipaddress.o \
+	libnetlink.o \
+	ll_addr.o \
+	ll_map.o \
+	ll_types.o \
+	rt_names.o \
+	utils.o
+
+lib-$(CONFIG_IPLINK) += \
+	ip_parse_common_args.o \
+	ipaddress.o \
+	iplink.o \
+	libnetlink.o \
+	ll_addr.o \
+	ll_map.o \
+	ll_types.o \
+	rt_names.o \
+	utils.o
+
+lib-$(CONFIG_IPROUTE) += \
+	ip_parse_common_args.o \
+	iproute.o \
+	libnetlink.o \
+	ll_map.o \
+	rt_names.o \
+	rtm_map.o \
+	utils.o
+
+lib-$(CONFIG_IPTUNNEL) += \
+	ip_parse_common_args.o \
+	iptunnel.o \
+	rt_names.o \
+	utils.o
+
+lib-$(CONFIG_IPRULE) += \
+	ip_parse_common_args.o \
+	iprule.o \
+	rt_names.o \
+	utils.o
+
diff --git a/networking/libiproute/ip_common.h b/networking/libiproute/ip_common.h
new file mode 100644
index 0000000..1529178
--- /dev/null
+++ b/networking/libiproute/ip_common.h
@@ -0,0 +1,34 @@
+/* vi: set sw=4 ts=4: */
+#ifndef _IP_COMMON_H
+#define _IP_COMMON_H 1
+
+#include "busybox.h"
+#include <asm/types.h>
+#include <linux/netlink.h>
+#include <linux/rtnetlink.h>
+#if !defined IFA_RTA
+#include <linux/if_addr.h>
+#endif
+#if !defined IFLA_RTA
+#include <linux/if_link.h>
+#endif
+
+extern int preferred_family;
+extern char * _SL_;
+
+extern void ip_parse_common_args(int *argcp, char ***argvp);
+extern int print_neigh(struct sockaddr_nl *who, struct nlmsghdr *n, void *arg);
+extern int ipaddr_list_or_flush(int argc, char **argv, int flush);
+extern int iproute_monitor(int argc, char **argv);
+extern void iplink_usage(void) ATTRIBUTE_NORETURN;
+extern void ipneigh_reset_filter(void);
+extern int do_ipaddr(int argc, char **argv);
+extern int do_iproute(int argc, char **argv);
+extern int do_iprule(int argc, char **argv);
+extern int do_ipneigh(int argc, char **argv);
+extern int do_iptunnel(int argc, char **argv);
+extern int do_iplink(int argc, char **argv);
+extern int do_ipmonitor(int argc, char **argv);
+extern int do_multiaddr(int argc, char **argv);
+extern int do_multiroute(int argc, char **argv);
+#endif /* ip_common.h */
diff --git a/networking/libiproute/ip_parse_common_args.c b/networking/libiproute/ip_parse_common_args.c
new file mode 100644
index 0000000..fee6e5e
--- /dev/null
+++ b/networking/libiproute/ip_parse_common_args.c
@@ -0,0 +1,77 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * ip.c		"ip" utility frontend.
+ *
+ *		This program is free software; you can redistribute it and/or
+ *		modify it under the terms of the GNU General Public License
+ *		as published by the Free Software Foundation; either version
+ *		2 of the License, or (at your option) any later version.
+ *
+ * Authors:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
+ *
+ *
+ * Changes:
+ *
+ * Rani Assaf <rani@magic.metawire.com> 980929:	resolve addresses
+ */
+
+#include <string.h>
+
+#include "libbb.h"
+#include "utils.h"
+#include "ip_common.h"
+
+
+int preferred_family = AF_UNSPEC;
+int oneline = 0;
+char * _SL_ = NULL;
+
+void ip_parse_common_args(int *argcp, char ***argvp)
+{
+	int argc = *argcp;
+	char **argv = *argvp;
+
+	while (argc > 1) {
+		char *opt = argv[1];
+
+		if (strcmp(opt,"--") == 0) {
+			argc--; argv++;
+			break;
+		}
+
+		if (opt[0] != '-')
+			break;
+
+		if (opt[1] == '-')
+			opt++;
+
+		if (matches(opt, "-family") == 0) {
+			argc--;
+			argv++;
+			if (!argv[1])
+				bb_show_usage();
+			if (strcmp(argv[1], "inet") == 0)
+				preferred_family = AF_INET;
+			else if (strcmp(argv[1], "inet6") == 0)
+				preferred_family = AF_INET6;
+			else if (strcmp(argv[1], "link") == 0)
+				preferred_family = AF_PACKET;
+			else
+				invarg(argv[1], "protocol family");
+		} else if (strcmp(opt, "-4") == 0) {
+			preferred_family = AF_INET;
+		} else if (strcmp(opt, "-6") == 0) {
+			preferred_family = AF_INET6;
+		} else if (strcmp(opt, "-0") == 0) {
+			preferred_family = AF_PACKET;
+		} else if (matches(opt, "-oneline") == 0) {
+			++oneline;
+		} else {
+			bb_show_usage();
+		}
+		argc--;	argv++;
+	}
+	_SL_ = oneline ? "\\" : "\n" ;
+	*argcp = argc;
+	*argvp = argv;
+}
diff --git a/networking/libiproute/ipaddress.c b/networking/libiproute/ipaddress.c
new file mode 100644
index 0000000..2a267fe
--- /dev/null
+++ b/networking/libiproute/ipaddress.c
@@ -0,0 +1,824 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * ipaddress.c		"ip address".
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ *
+ * Authors:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
+ *
+ * Changes:
+ *	Laszlo Valko <valko@linux.karinthy.hu> 990223: address label must be zero terminated
+ */
+
+#include "libbb.h"
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+
+#include <fnmatch.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <net/if.h>
+#include <net/if_arp.h>
+
+#include "rt_names.h"
+#include "utils.h"
+#include "ip_common.h"
+
+
+static struct
+{
+	int ifindex;
+	int family;
+	int oneline;
+	int showqueue;
+	inet_prefix pfx;
+	int scope, scopemask;
+	int flags, flagmask;
+	int up;
+	char *label;
+	int flushed;
+	char *flushb;
+	int flushp;
+	int flushe;
+	struct rtnl_handle *rth;
+} filter;
+
+static void print_link_flags(FILE *fp, unsigned flags, unsigned mdown)
+{
+	fprintf(fp, "<");
+	flags &= ~IFF_RUNNING;
+#define _PF(f) if (flags&IFF_##f) { \
+		  flags &= ~IFF_##f ; \
+		  fprintf(fp, #f "%s", flags ? "," : ""); }
+	_PF(LOOPBACK);
+	_PF(BROADCAST);
+	_PF(POINTOPOINT);
+	_PF(MULTICAST);
+	_PF(NOARP);
+#if 0
+	_PF(ALLMULTI);
+	_PF(PROMISC);
+	_PF(MASTER);
+	_PF(SLAVE);
+	_PF(DEBUG);
+	_PF(DYNAMIC);
+	_PF(AUTOMEDIA);
+	_PF(PORTSEL);
+	_PF(NOTRAILERS);
+#endif
+	_PF(UP);
+#undef _PF
+	if (flags)
+		fprintf(fp, "%x", flags);
+	if (mdown)
+		fprintf(fp, ",M-DOWN");
+	fprintf(fp, "> ");
+}
+
+static void print_queuelen(char *name)
+{
+	struct ifreq ifr;
+	int s;
+
+	s = socket(AF_INET, SOCK_STREAM, 0);
+	if (s < 0)
+		return;
+
+	memset(&ifr, 0, sizeof(ifr));
+	strncpy(ifr.ifr_name, name, sizeof(ifr.ifr_name));
+	if (ioctl(s, SIOCGIFTXQLEN, &ifr) < 0) {
+		perror("SIOCGIFXQLEN");
+		close(s);
+		return;
+	}
+	close(s);
+
+	if (ifr.ifr_qlen)
+		printf("qlen %d", ifr.ifr_qlen);
+}
+
+static int print_linkinfo(struct sockaddr_nl ATTRIBUTE_UNUSED *who,
+		const struct nlmsghdr *n, void ATTRIBUTE_UNUSED *arg)
+{
+	FILE *fp = (FILE*)arg;
+	struct ifinfomsg *ifi = NLMSG_DATA(n);
+	struct rtattr * tb[IFLA_MAX+1];
+	int len = n->nlmsg_len;
+	unsigned m_flag = 0;
+
+	if (n->nlmsg_type != RTM_NEWLINK && n->nlmsg_type != RTM_DELLINK)
+		return 0;
+
+	len -= NLMSG_LENGTH(sizeof(*ifi));
+	if (len < 0)
+		return -1;
+
+	if (filter.ifindex && ifi->ifi_index != filter.ifindex)
+		return 0;
+	if (filter.up && !(ifi->ifi_flags&IFF_UP))
+		return 0;
+
+	memset(tb, 0, sizeof(tb));
+	parse_rtattr(tb, IFLA_MAX, IFLA_RTA(ifi), len);
+	if (tb[IFLA_IFNAME] == NULL) {
+		bb_error_msg("nil ifname");
+		return -1;
+	}
+	if (filter.label &&
+	    (!filter.family || filter.family == AF_PACKET) &&
+	    fnmatch(filter.label, RTA_DATA(tb[IFLA_IFNAME]), 0))
+		return 0;
+
+	if (n->nlmsg_type == RTM_DELLINK)
+		fprintf(fp, "Deleted ");
+
+	fprintf(fp, "%d: %s", ifi->ifi_index,
+		tb[IFLA_IFNAME] ? (char*)RTA_DATA(tb[IFLA_IFNAME]) : "<nil>");
+
+	if (tb[IFLA_LINK]) {
+		SPRINT_BUF(b1);
+		int iflink = *(int*)RTA_DATA(tb[IFLA_LINK]);
+		if (iflink == 0)
+			fprintf(fp, "@NONE: ");
+		else {
+			fprintf(fp, "@%s: ", ll_idx_n2a(iflink, b1));
+			m_flag = ll_index_to_flags(iflink);
+			m_flag = !(m_flag & IFF_UP);
+		}
+	} else {
+		fprintf(fp, ": ");
+	}
+	print_link_flags(fp, ifi->ifi_flags, m_flag);
+
+	if (tb[IFLA_MTU])
+		fprintf(fp, "mtu %u ", *(int*)RTA_DATA(tb[IFLA_MTU]));
+	if (tb[IFLA_QDISC])
+		fprintf(fp, "qdisc %s ", (char*)RTA_DATA(tb[IFLA_QDISC]));
+#ifdef IFLA_MASTER
+	if (tb[IFLA_MASTER]) {
+		SPRINT_BUF(b1);
+		fprintf(fp, "master %s ", ll_idx_n2a(*(int*)RTA_DATA(tb[IFLA_MASTER]), b1));
+	}
+#endif
+	if (filter.showqueue)
+		print_queuelen((char*)RTA_DATA(tb[IFLA_IFNAME]));
+
+	if (!filter.family || filter.family == AF_PACKET) {
+		SPRINT_BUF(b1);
+		fprintf(fp, "%s", _SL_);
+		fprintf(fp, "    link/%s ", ll_type_n2a(ifi->ifi_type, b1, sizeof(b1)));
+
+		if (tb[IFLA_ADDRESS]) {
+			fprintf(fp, "%s", ll_addr_n2a(RTA_DATA(tb[IFLA_ADDRESS]),
+						      RTA_PAYLOAD(tb[IFLA_ADDRESS]),
+						      ifi->ifi_type,
+						      b1, sizeof(b1)));
+		}
+		if (tb[IFLA_BROADCAST]) {
+			if (ifi->ifi_flags&IFF_POINTOPOINT)
+				fprintf(fp, " peer ");
+			else
+				fprintf(fp, " brd ");
+			fprintf(fp, "%s", ll_addr_n2a(RTA_DATA(tb[IFLA_BROADCAST]),
+						      RTA_PAYLOAD(tb[IFLA_BROADCAST]),
+						      ifi->ifi_type,
+						      b1, sizeof(b1)));
+		}
+	}
+	fprintf(fp, "\n");
+	fflush(fp);
+	return 0;
+}
+
+static int flush_update(void)
+{
+	if (rtnl_send(filter.rth, filter.flushb, filter.flushp) < 0) {
+		perror("Failed to send flush request\n");
+		return -1;
+	}
+	filter.flushp = 0;
+	return 0;
+}
+
+static int print_addrinfo(struct sockaddr_nl ATTRIBUTE_UNUSED *who,
+		struct nlmsghdr *n, void ATTRIBUTE_UNUSED *arg)
+{
+	FILE *fp = (FILE*)arg;
+	struct ifaddrmsg *ifa = NLMSG_DATA(n);
+	int len = n->nlmsg_len;
+	struct rtattr * rta_tb[IFA_MAX+1];
+	char abuf[256];
+	SPRINT_BUF(b1);
+
+	if (n->nlmsg_type != RTM_NEWADDR && n->nlmsg_type != RTM_DELADDR)
+		return 0;
+	len -= NLMSG_LENGTH(sizeof(*ifa));
+	if (len < 0) {
+		bb_error_msg("wrong nlmsg len %d", len);
+		return -1;
+	}
+
+	if (filter.flushb && n->nlmsg_type != RTM_NEWADDR)
+		return 0;
+
+	memset(rta_tb, 0, sizeof(rta_tb));
+	parse_rtattr(rta_tb, IFA_MAX, IFA_RTA(ifa), n->nlmsg_len - NLMSG_LENGTH(sizeof(*ifa)));
+
+	if (!rta_tb[IFA_LOCAL])
+		rta_tb[IFA_LOCAL] = rta_tb[IFA_ADDRESS];
+	if (!rta_tb[IFA_ADDRESS])
+		rta_tb[IFA_ADDRESS] = rta_tb[IFA_LOCAL];
+
+	if (filter.ifindex && filter.ifindex != ifa->ifa_index)
+		return 0;
+	if ((filter.scope^ifa->ifa_scope)&filter.scopemask)
+		return 0;
+	if ((filter.flags^ifa->ifa_flags)&filter.flagmask)
+		return 0;
+	if (filter.label) {
+		const char *label;
+		if (rta_tb[IFA_LABEL])
+			label = RTA_DATA(rta_tb[IFA_LABEL]);
+		else
+			label = ll_idx_n2a(ifa->ifa_index, b1);
+		if (fnmatch(filter.label, label, 0) != 0)
+			return 0;
+	}
+	if (filter.pfx.family) {
+		if (rta_tb[IFA_LOCAL]) {
+			inet_prefix dst;
+			memset(&dst, 0, sizeof(dst));
+			dst.family = ifa->ifa_family;
+			memcpy(&dst.data, RTA_DATA(rta_tb[IFA_LOCAL]), RTA_PAYLOAD(rta_tb[IFA_LOCAL]));
+			if (inet_addr_match(&dst, &filter.pfx, filter.pfx.bitlen))
+				return 0;
+		}
+	}
+
+	if (filter.flushb) {
+		struct nlmsghdr *fn;
+		if (NLMSG_ALIGN(filter.flushp) + n->nlmsg_len > filter.flushe) {
+			if (flush_update())
+				return -1;
+		}
+		fn = (struct nlmsghdr*)(filter.flushb + NLMSG_ALIGN(filter.flushp));
+		memcpy(fn, n, n->nlmsg_len);
+		fn->nlmsg_type = RTM_DELADDR;
+		fn->nlmsg_flags = NLM_F_REQUEST;
+		fn->nlmsg_seq = ++filter.rth->seq;
+		filter.flushp = (((char*)fn) + n->nlmsg_len) - filter.flushb;
+		filter.flushed++;
+		return 0;
+	}
+
+	if (n->nlmsg_type == RTM_DELADDR)
+		fprintf(fp, "Deleted ");
+
+	if (filter.oneline)
+		fprintf(fp, "%u: %s", ifa->ifa_index, ll_index_to_name(ifa->ifa_index));
+	if (ifa->ifa_family == AF_INET)
+		fprintf(fp, "    inet ");
+	else if (ifa->ifa_family == AF_INET6)
+		fprintf(fp, "    inet6 ");
+	else
+		fprintf(fp, "    family %d ", ifa->ifa_family);
+
+	if (rta_tb[IFA_LOCAL]) {
+		fprintf(fp, "%s", rt_addr_n2a(ifa->ifa_family,
+					      RTA_PAYLOAD(rta_tb[IFA_LOCAL]),
+					      RTA_DATA(rta_tb[IFA_LOCAL]),
+					      abuf, sizeof(abuf)));
+
+		if (rta_tb[IFA_ADDRESS] == NULL ||
+		    memcmp(RTA_DATA(rta_tb[IFA_ADDRESS]), RTA_DATA(rta_tb[IFA_LOCAL]), 4) == 0) {
+			fprintf(fp, "/%d ", ifa->ifa_prefixlen);
+		} else {
+			fprintf(fp, " peer %s/%d ",
+				rt_addr_n2a(ifa->ifa_family,
+					    RTA_PAYLOAD(rta_tb[IFA_ADDRESS]),
+					    RTA_DATA(rta_tb[IFA_ADDRESS]),
+					    abuf, sizeof(abuf)),
+				ifa->ifa_prefixlen);
+		}
+	}
+
+	if (rta_tb[IFA_BROADCAST]) {
+		fprintf(fp, "brd %s ",
+			rt_addr_n2a(ifa->ifa_family,
+				    RTA_PAYLOAD(rta_tb[IFA_BROADCAST]),
+				    RTA_DATA(rta_tb[IFA_BROADCAST]),
+				    abuf, sizeof(abuf)));
+	}
+	if (rta_tb[IFA_ANYCAST]) {
+		fprintf(fp, "any %s ",
+			rt_addr_n2a(ifa->ifa_family,
+				    RTA_PAYLOAD(rta_tb[IFA_ANYCAST]),
+				    RTA_DATA(rta_tb[IFA_ANYCAST]),
+				    abuf, sizeof(abuf)));
+	}
+	fprintf(fp, "scope %s ", rtnl_rtscope_n2a(ifa->ifa_scope, b1, sizeof(b1)));
+	if (ifa->ifa_flags&IFA_F_SECONDARY) {
+		ifa->ifa_flags &= ~IFA_F_SECONDARY;
+		fprintf(fp, "secondary ");
+	}
+	if (ifa->ifa_flags&IFA_F_TENTATIVE) {
+		ifa->ifa_flags &= ~IFA_F_TENTATIVE;
+		fprintf(fp, "tentative ");
+	}
+	if (ifa->ifa_flags&IFA_F_DEPRECATED) {
+		ifa->ifa_flags &= ~IFA_F_DEPRECATED;
+		fprintf(fp, "deprecated ");
+	}
+	if (!(ifa->ifa_flags&IFA_F_PERMANENT)) {
+		fprintf(fp, "dynamic ");
+	} else
+		ifa->ifa_flags &= ~IFA_F_PERMANENT;
+	if (ifa->ifa_flags)
+		fprintf(fp, "flags %02x ", ifa->ifa_flags);
+	if (rta_tb[IFA_LABEL])
+		fprintf(fp, "%s", (char*)RTA_DATA(rta_tb[IFA_LABEL]));
+	if (rta_tb[IFA_CACHEINFO]) {
+		struct ifa_cacheinfo *ci = RTA_DATA(rta_tb[IFA_CACHEINFO]);
+		char buf[128];
+		fprintf(fp, "%s", _SL_);
+		if (ci->ifa_valid == 0xFFFFFFFFU)
+			sprintf(buf, "valid_lft forever");
+		else
+			sprintf(buf, "valid_lft %dsec", ci->ifa_valid);
+		if (ci->ifa_prefered == 0xFFFFFFFFU)
+			sprintf(buf+strlen(buf), " preferred_lft forever");
+		else
+			sprintf(buf+strlen(buf), " preferred_lft %dsec", ci->ifa_prefered);
+		fprintf(fp, "       %s", buf);
+	}
+	fprintf(fp, "\n");
+	fflush(fp);
+	return 0;
+}
+
+
+struct nlmsg_list
+{
+	struct nlmsg_list *next;
+	struct nlmsghdr	  h;
+};
+
+static int print_selected_addrinfo(int ifindex, struct nlmsg_list *ainfo, FILE *fp)
+{
+	for ( ;ainfo ;  ainfo = ainfo->next) {
+		struct nlmsghdr *n = &ainfo->h;
+		struct ifaddrmsg *ifa = NLMSG_DATA(n);
+
+		if (n->nlmsg_type != RTM_NEWADDR)
+			continue;
+
+		if (n->nlmsg_len < NLMSG_LENGTH(sizeof(ifa)))
+			return -1;
+
+		if (ifa->ifa_index != ifindex ||
+		    (filter.family && filter.family != ifa->ifa_family))
+			continue;
+
+		print_addrinfo(NULL, n, fp);
+	}
+	return 0;
+}
+
+
+static int store_nlmsg(struct sockaddr_nl *who, struct nlmsghdr *n, void *arg)
+{
+	struct nlmsg_list **linfo = (struct nlmsg_list**)arg;
+	struct nlmsg_list *h;
+	struct nlmsg_list **lp;
+
+	h = malloc(n->nlmsg_len+sizeof(void*));
+	if (h == NULL)
+		return -1;
+
+	memcpy(&h->h, n, n->nlmsg_len);
+	h->next = NULL;
+
+	for (lp = linfo; *lp; lp = &(*lp)->next) /* NOTHING */;
+	*lp = h;
+
+	ll_remember_index(who, n, NULL);
+	return 0;
+}
+
+static void ipaddr_reset_filter(int _oneline)
+{
+	memset(&filter, 0, sizeof(filter));
+	filter.oneline = _oneline;
+}
+
+int ipaddr_list_or_flush(int argc, char **argv, int flush)
+{
+	static const char *const option[] = { "to", "scope", "up", "label", "dev", 0 };
+
+	struct nlmsg_list *linfo = NULL;
+	struct nlmsg_list *ainfo = NULL;
+	struct nlmsg_list *l;
+	struct rtnl_handle rth;
+	char *filter_dev = NULL;
+	int no_link = 0;
+
+	ipaddr_reset_filter(oneline);
+	filter.showqueue = 1;
+
+	if (filter.family == AF_UNSPEC)
+		filter.family = preferred_family;
+
+	if (flush) {
+		if (argc <= 0) {
+			bb_error_msg(bb_msg_requires_arg, "flush");
+			return -1;
+		}
+		if (filter.family == AF_PACKET) {
+			bb_error_msg("cannot flush link addresses");
+			return -1;
+		}
+	}
+
+	while (argc > 0) {
+		const int option_num = index_in_str_array(option, *argv);
+		switch (option_num) {
+			case 0: /* to */
+				NEXT_ARG();
+				get_prefix(&filter.pfx, *argv, filter.family);
+				if (filter.family == AF_UNSPEC) {
+					filter.family = filter.pfx.family;
+				}
+				break;
+			case 1: /* scope */
+			{
+				uint32_t scope = 0;
+				NEXT_ARG();
+				filter.scopemask = -1;
+				if (rtnl_rtscope_a2n(&scope, *argv)) {
+					if (strcmp(*argv, "all") != 0) {
+						invarg(*argv, "scope");
+					}
+					scope = RT_SCOPE_NOWHERE;
+					filter.scopemask = 0;
+				}
+				filter.scope = scope;
+				break;
+			}
+			case 2: /* up */
+				filter.up = 1;
+				break;
+			case 3: /* label */
+				NEXT_ARG();
+				filter.label = *argv;
+				break;
+			case 4: /* dev */
+				NEXT_ARG();
+			default:
+				if (filter_dev) {
+					duparg2("dev", *argv);
+				}
+				filter_dev = *argv;
+		}
+		argv++;
+		argc--;
+	}
+
+	if (rtnl_open(&rth, 0) < 0)
+		exit(1);
+
+	if (rtnl_wilddump_request(&rth, preferred_family, RTM_GETLINK) < 0) {
+		bb_perror_msg_and_die("cannot send dump request");
+	}
+
+	if (rtnl_dump_filter(&rth, store_nlmsg, &linfo, NULL, NULL) < 0) {
+		bb_error_msg_and_die("dump terminated");
+	}
+
+	if (filter_dev) {
+		filter.ifindex = ll_name_to_index(filter_dev);
+		if (filter.ifindex <= 0) {
+			bb_error_msg("device \"%s\" does not exist", filter_dev);
+			return -1;
+		}
+	}
+
+	if (flush) {
+		char flushb[4096-512];
+
+		filter.flushb = flushb;
+		filter.flushp = 0;
+		filter.flushe = sizeof(flushb);
+		filter.rth = &rth;
+
+		for (;;) {
+			if (rtnl_wilddump_request(&rth, filter.family, RTM_GETADDR) < 0) {
+				perror("Cannot send dump request");
+				exit(1);
+			}
+			filter.flushed = 0;
+			if (rtnl_dump_filter(&rth, print_addrinfo, stdout, NULL, NULL) < 0) {
+				fprintf(stderr, "Flush terminated\n");
+				exit(1);
+			}
+			if (filter.flushed == 0) {
+				fflush(stdout);
+				return 0;
+			}
+			if (flush_update() < 0)
+				exit(1);
+		}
+	}
+
+	if (filter.family != AF_PACKET) {
+		if (rtnl_wilddump_request(&rth, filter.family, RTM_GETADDR) < 0) {
+			bb_perror_msg_and_die("cannot send dump request");
+		}
+
+		if (rtnl_dump_filter(&rth, store_nlmsg, &ainfo, NULL, NULL) < 0) {
+			bb_error_msg_and_die("dump terminated");
+		}
+	}
+
+
+	if (filter.family && filter.family != AF_PACKET) {
+		struct nlmsg_list **lp;
+		lp=&linfo;
+
+		if (filter.oneline)
+			no_link = 1;
+
+		while ((l=*lp)!=NULL) {
+			int ok = 0;
+			struct ifinfomsg *ifi = NLMSG_DATA(&l->h);
+			struct nlmsg_list *a;
+
+			for (a=ainfo; a; a=a->next) {
+				struct nlmsghdr *n = &a->h;
+				struct ifaddrmsg *ifa = NLMSG_DATA(n);
+
+				if (ifa->ifa_index != ifi->ifi_index ||
+				    (filter.family && filter.family != ifa->ifa_family))
+					continue;
+				if ((filter.scope^ifa->ifa_scope)&filter.scopemask)
+					continue;
+				if ((filter.flags^ifa->ifa_flags)&filter.flagmask)
+					continue;
+				if (filter.pfx.family || filter.label) {
+					struct rtattr *tb[IFA_MAX+1];
+					memset(tb, 0, sizeof(tb));
+					parse_rtattr(tb, IFA_MAX, IFA_RTA(ifa), IFA_PAYLOAD(n));
+					if (!tb[IFA_LOCAL])
+						tb[IFA_LOCAL] = tb[IFA_ADDRESS];
+
+					if (filter.pfx.family && tb[IFA_LOCAL]) {
+						inet_prefix dst;
+						memset(&dst, 0, sizeof(dst));
+						dst.family = ifa->ifa_family;
+						memcpy(&dst.data, RTA_DATA(tb[IFA_LOCAL]), RTA_PAYLOAD(tb[IFA_LOCAL]));
+						if (inet_addr_match(&dst, &filter.pfx, filter.pfx.bitlen))
+							continue;
+					}
+					if (filter.label) {
+						SPRINT_BUF(b1);
+						const char *label;
+						if (tb[IFA_LABEL])
+							label = RTA_DATA(tb[IFA_LABEL]);
+						else
+							label = ll_idx_n2a(ifa->ifa_index, b1);
+						if (fnmatch(filter.label, label, 0) != 0)
+							continue;
+					}
+				}
+
+				ok = 1;
+				break;
+			}
+			if (!ok)
+				*lp = l->next;
+			else
+				lp = &l->next;
+		}
+	}
+
+	for (l=linfo; l; l = l->next) {
+		if (no_link || print_linkinfo(NULL, &l->h, stdout) == 0) {
+			struct ifinfomsg *ifi = NLMSG_DATA(&l->h);
+			if (filter.family != AF_PACKET)
+				print_selected_addrinfo(ifi->ifi_index, ainfo, stdout);
+		}
+		fflush(stdout);
+	}
+
+	exit(0);
+}
+
+static int default_scope(inet_prefix *lcl)
+{
+	if (lcl->family == AF_INET) {
+		if (lcl->bytelen >= 1 && *(__u8*)&lcl->data == 127)
+			return RT_SCOPE_HOST;
+	}
+	return 0;
+}
+
+static int ipaddr_modify(int cmd, int argc, char **argv)
+{
+	static const char *const option[] = {
+		"peer", "remote", "broadcast", "brd",
+		"anycast", "scope", "dev", "label", "local", 0
+	};
+
+	struct rtnl_handle rth;
+	struct {
+		struct nlmsghdr		n;
+		struct ifaddrmsg	ifa;
+		char			buf[256];
+	} req;
+	char  *d = NULL;
+	char  *l = NULL;
+	inet_prefix lcl;
+	inet_prefix peer;
+	int local_len = 0;
+	int peer_len = 0;
+	int brd_len = 0;
+	int any_len = 0;
+	int scoped = 0;
+
+	memset(&req, 0, sizeof(req));
+
+	req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrmsg));
+	req.n.nlmsg_flags = NLM_F_REQUEST;
+	req.n.nlmsg_type = cmd;
+	req.ifa.ifa_family = preferred_family;
+
+	while (argc > 0) {
+		const int option_num = index_in_str_array(option, *argv);
+		switch (option_num) {
+			case 0: /* peer */
+			case 1: /* remote */
+				NEXT_ARG();
+
+				if (peer_len) {
+					duparg("peer", *argv);
+				}
+				get_prefix(&peer, *argv, req.ifa.ifa_family);
+				peer_len = peer.bytelen;
+				if (req.ifa.ifa_family == AF_UNSPEC) {
+					req.ifa.ifa_family = peer.family;
+				}
+				addattr_l(&req.n, sizeof(req), IFA_ADDRESS, &peer.data, peer.bytelen);
+				req.ifa.ifa_prefixlen = peer.bitlen;
+				break;
+			case 2: /* broadcast */
+			case 3: /* brd */
+			{
+				inet_prefix addr;
+				NEXT_ARG();
+				if (brd_len) {
+					duparg("broadcast", *argv);
+				}
+				if (strcmp(*argv, "+") == 0) {
+					brd_len = -1;
+				}
+				else if (strcmp(*argv, "-") == 0) {
+					brd_len = -2;
+				} else {
+					get_addr(&addr, *argv, req.ifa.ifa_family);
+					if (req.ifa.ifa_family == AF_UNSPEC)
+						req.ifa.ifa_family = addr.family;
+					addattr_l(&req.n, sizeof(req), IFA_BROADCAST, &addr.data, addr.bytelen);
+					brd_len = addr.bytelen;
+				}
+				break;
+			}
+			case 4: /* anycast */
+			{
+				inet_prefix addr;
+				NEXT_ARG();
+				if (any_len) {
+					duparg("anycast", *argv);
+				}
+				get_addr(&addr, *argv, req.ifa.ifa_family);
+				if (req.ifa.ifa_family == AF_UNSPEC) {
+					req.ifa.ifa_family = addr.family;
+				}
+				addattr_l(&req.n, sizeof(req), IFA_ANYCAST, &addr.data, addr.bytelen);
+				any_len = addr.bytelen;
+				break;
+			}
+			case 5: /* scope */
+			{
+				uint32_t scope = 0;
+				NEXT_ARG();
+				if (rtnl_rtscope_a2n(&scope, *argv)) {
+					invarg(*argv, "scope");
+				}
+				req.ifa.ifa_scope = scope;
+				scoped = 1;
+				break;
+			}
+			case 6: /* dev */
+				NEXT_ARG();
+				d = *argv;
+				break;
+			case 7: /* label */
+				NEXT_ARG();
+				l = *argv;
+				addattr_l(&req.n, sizeof(req), IFA_LABEL, l, strlen(l)+1);
+				break;
+			case 8:	/* local */
+				NEXT_ARG();
+			default:
+				if (local_len) {
+					duparg2("local", *argv);
+				}
+				get_prefix(&lcl, *argv, req.ifa.ifa_family);
+				if (req.ifa.ifa_family == AF_UNSPEC) {
+					req.ifa.ifa_family = lcl.family;
+				}
+				addattr_l(&req.n, sizeof(req), IFA_LOCAL, &lcl.data, lcl.bytelen);
+				local_len = lcl.bytelen;
+		}
+		argc--;
+		argv++;
+	}
+
+	if (d == NULL) {
+		bb_error_msg(bb_msg_requires_arg,"\"dev\"");
+		return -1;
+	}
+	if (l && matches(d, l) != 0) {
+		bb_error_msg_and_die("\"dev\" (%s) must match \"label\" (%s)", d, l);
+	}
+
+	if (peer_len == 0 && local_len && cmd != RTM_DELADDR) {
+		peer = lcl;
+		addattr_l(&req.n, sizeof(req), IFA_ADDRESS, &lcl.data, lcl.bytelen);
+	}
+	if (req.ifa.ifa_prefixlen == 0)
+		req.ifa.ifa_prefixlen = lcl.bitlen;
+
+	if (brd_len < 0 && cmd != RTM_DELADDR) {
+		inet_prefix brd;
+		int i;
+		if (req.ifa.ifa_family != AF_INET) {
+			bb_error_msg("broadcast can be set only for IPv4 addresses");
+			return -1;
+		}
+		brd = peer;
+		if (brd.bitlen <= 30) {
+			for (i=31; i>=brd.bitlen; i--) {
+				if (brd_len == -1)
+					brd.data[0] |= htonl(1<<(31-i));
+				else
+					brd.data[0] &= ~htonl(1<<(31-i));
+			}
+			addattr_l(&req.n, sizeof(req), IFA_BROADCAST, &brd.data, brd.bytelen);
+			brd_len = brd.bytelen;
+		}
+	}
+	if (!scoped && cmd != RTM_DELADDR)
+		req.ifa.ifa_scope = default_scope(&lcl);
+
+	if (rtnl_open(&rth, 0) < 0)
+		exit(1);
+
+	ll_init_map(&rth);
+
+	if ((req.ifa.ifa_index = ll_name_to_index(d)) == 0) {
+		bb_error_msg("cannot find device \"%s\"", d);
+		return -1;
+	}
+
+	if (rtnl_talk(&rth, &req.n, 0, 0, NULL, NULL, NULL) < 0)
+		exit(2);
+
+	exit(0);
+}
+
+int do_ipaddr(int argc, char **argv)
+{
+	static const char *const commands[] = {
+		"add", "delete", "list", "show", "lst", "flush", 0
+	};
+
+	int command_num = 2;
+
+	if (*argv) {
+		command_num = index_in_substr_array(commands, *argv);
+	}
+	switch (command_num) {
+		case 0: /* add */
+			return ipaddr_modify(RTM_NEWADDR, argc-1, argv+1);
+		case 1: /* delete */
+			return ipaddr_modify(RTM_DELADDR, argc-1, argv+1);
+		case 2: /* list */
+		case 3: /* show */
+		case 4: /* lst */
+			return ipaddr_list_or_flush(argc-1, argv+1, 0);
+		case 5: /* flush */
+			return ipaddr_list_or_flush(argc-1, argv+1, 1);
+	}
+	bb_error_msg_and_die("unknown command %s", *argv);
+}
diff --git a/networking/libiproute/iplink.c b/networking/libiproute/iplink.c
new file mode 100644
index 0000000..1ea11f6
--- /dev/null
+++ b/networking/libiproute/iplink.c
@@ -0,0 +1,354 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * iplink.c "ip link".
+ *
+ * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ */
+
+#include "libbb.h"
+
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+
+#include <errno.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <net/if.h>
+#include <net/if_packet.h>
+#include <netpacket/packet.h>
+
+#include <net/ethernet.h>
+
+#include "rt_names.h"
+#include "utils.h"
+#include "ip_common.h"
+
+/* take from linux/sockios.h */
+#define SIOCSIFNAME	0x8923		/* set interface name */
+
+static int on_off(char *msg)
+{
+	bb_error_msg("error: argument of \"%s\" must be \"on\" or \"off\"", msg);
+	return -1;
+}
+
+static int get_ctl_fd(void)
+{
+	int s_errno;
+	int fd;
+
+	fd = socket(PF_INET, SOCK_DGRAM, 0);
+	if (fd >= 0)
+		return fd;
+	s_errno = errno;
+	fd = socket(PF_PACKET, SOCK_DGRAM, 0);
+	if (fd >= 0)
+		return fd;
+	fd = socket(PF_INET6, SOCK_DGRAM, 0);
+	if (fd >= 0)
+		return fd;
+	errno = s_errno;
+	perror("Cannot create control socket");
+	return -1;
+}
+
+static int do_chflags(char *dev, __u32 flags, __u32 mask)
+{
+	struct ifreq ifr;
+	int fd;
+	int err;
+
+	strncpy(ifr.ifr_name, dev, sizeof(ifr.ifr_name));
+	fd = get_ctl_fd();
+	if (fd < 0)
+		return -1;
+	err = ioctl(fd, SIOCGIFFLAGS, &ifr);
+	if (err) {
+		perror("SIOCGIFFLAGS");
+		close(fd);
+		return -1;
+	}
+	if ((ifr.ifr_flags^flags)&mask) {
+		ifr.ifr_flags &= ~mask;
+		ifr.ifr_flags |= mask&flags;
+		err = ioctl(fd, SIOCSIFFLAGS, &ifr);
+		if (err)
+			perror("SIOCSIFFLAGS");
+	}
+	close(fd);
+	return err;
+}
+
+static int do_changename(char *dev, char *newdev)
+{
+	struct ifreq ifr;
+	int fd;
+	int err;
+
+	strncpy(ifr.ifr_name, dev, sizeof(ifr.ifr_name));
+	strncpy(ifr.ifr_newname, newdev, sizeof(ifr.ifr_newname));
+	fd = get_ctl_fd();
+	if (fd < 0)
+		return -1;
+	err = ioctl(fd, SIOCSIFNAME, &ifr);
+	if (err) {
+		perror("SIOCSIFNAME");
+		close(fd);
+		return -1;
+	}
+	close(fd);
+	return err;
+}
+
+static int set_qlen(char *dev, int qlen)
+{
+	struct ifreq ifr;
+	int s;
+
+	s = get_ctl_fd();
+	if (s < 0)
+		return -1;
+
+	memset(&ifr, 0, sizeof(ifr));
+	strncpy(ifr.ifr_name, dev, sizeof(ifr.ifr_name));
+	ifr.ifr_qlen = qlen;
+	if (ioctl(s, SIOCSIFTXQLEN, &ifr) < 0) {
+		perror("SIOCSIFXQLEN");
+		close(s);
+		return -1;
+	}
+	close(s);
+
+	return 0;
+}
+
+static int set_mtu(char *dev, int mtu)
+{
+	struct ifreq ifr;
+	int s;
+
+	s = get_ctl_fd();
+	if (s < 0)
+		return -1;
+
+	memset(&ifr, 0, sizeof(ifr));
+	strncpy(ifr.ifr_name, dev, sizeof(ifr.ifr_name));
+	ifr.ifr_mtu = mtu;
+	if (ioctl(s, SIOCSIFMTU, &ifr) < 0) {
+		perror("SIOCSIFMTU");
+		close(s);
+		return -1;
+	}
+	close(s);
+
+	return 0;
+}
+
+static int get_address(char *dev, int *htype)
+{
+	struct ifreq ifr;
+	struct sockaddr_ll me;
+	socklen_t alen;
+	int s;
+
+	s = socket(PF_PACKET, SOCK_DGRAM, 0);
+	if (s < 0) {
+		perror("socket(PF_PACKET)");
+		return -1;
+	}
+
+	memset(&ifr, 0, sizeof(ifr));
+	strncpy(ifr.ifr_name, dev, sizeof(ifr.ifr_name));
+	if (ioctl(s, SIOCGIFINDEX, &ifr) < 0) {
+		perror("SIOCGIFINDEX");
+		close(s);
+		return -1;
+	}
+
+	memset(&me, 0, sizeof(me));
+	me.sll_family = AF_PACKET;
+	me.sll_ifindex = ifr.ifr_ifindex;
+	me.sll_protocol = htons(ETH_P_LOOP);
+	if (bind(s, (struct sockaddr*)&me, sizeof(me)) == -1) {
+		perror("bind");
+		close(s);
+		return -1;
+	}
+
+	alen = sizeof(me);
+	if (getsockname(s, (struct sockaddr*)&me, &alen) == -1) {
+		perror("getsockname");
+		close(s);
+		return -1;
+	}
+	close(s);
+	*htype = me.sll_hatype;
+	return me.sll_halen;
+}
+
+static int parse_address(char *dev, int hatype, int halen, char *lla, struct ifreq *ifr)
+{
+	int alen;
+
+	memset(ifr, 0, sizeof(*ifr));
+	strncpy(ifr->ifr_name, dev, sizeof(ifr->ifr_name));
+	ifr->ifr_hwaddr.sa_family = hatype;
+	alen = ll_addr_a2n((unsigned char *)(ifr->ifr_hwaddr.sa_data), 14, lla);
+	if (alen < 0)
+		return -1;
+	if (alen != halen) {
+		bb_error_msg("wrong address (%s) length: expected %d bytes", lla, halen);
+		return -1;
+	}
+	return 0;
+}
+
+static int set_address(struct ifreq *ifr, int brd)
+{
+	int s;
+
+	s = get_ctl_fd();
+	if (s < 0)
+		return -1;
+	if (ioctl(s, brd?SIOCSIFHWBROADCAST:SIOCSIFHWADDR, ifr) < 0) {
+		perror(brd?"SIOCSIFHWBROADCAST":"SIOCSIFHWADDR");
+		close(s);
+		return -1;
+	}
+	close(s);
+	return 0;
+}
+
+
+static int do_set(int argc, char **argv)
+{
+	char *dev = NULL;
+	__u32 mask = 0;
+	__u32 flags = 0;
+	int qlen = -1;
+	int mtu = -1;
+	char *newaddr = NULL;
+	char *newbrd = NULL;
+	struct ifreq ifr0, ifr1;
+	char *newname = NULL;
+	int htype, halen;
+
+	while (argc > 0) {
+		if (strcmp(*argv, "up") == 0) {
+			mask |= IFF_UP;
+			flags |= IFF_UP;
+		} else if (strcmp(*argv, "down") == 0) {
+			mask |= IFF_UP;
+			flags &= ~IFF_UP;
+		} else if (strcmp(*argv, "name") == 0) {
+			NEXT_ARG();
+			newname = *argv;
+		} else if (strcmp(*argv, "mtu") == 0) {
+			NEXT_ARG();
+			if (mtu != -1)
+				duparg("mtu", *argv);
+			if (get_integer(&mtu, *argv, 0))
+				invarg(*argv, "mtu");
+		} else if (strcmp(*argv, "multicast") == 0) {
+			NEXT_ARG();
+			mask |= IFF_MULTICAST;
+			if (strcmp(*argv, "on") == 0) {
+				flags |= IFF_MULTICAST;
+			} else if (strcmp(*argv, "off") == 0) {
+				flags &= ~IFF_MULTICAST;
+			} else
+				return on_off("multicast");
+		} else if (strcmp(*argv, "arp") == 0) {
+			NEXT_ARG();
+			mask |= IFF_NOARP;
+			if (strcmp(*argv, "on") == 0) {
+				flags &= ~IFF_NOARP;
+			} else if (strcmp(*argv, "off") == 0) {
+				flags |= IFF_NOARP;
+			} else
+				return on_off("noarp");
+		} else if (strcmp(*argv, "addr") == 0) {
+			NEXT_ARG();
+			newaddr = *argv;
+		} else {
+			if (strcmp(*argv, "dev") == 0) {
+				NEXT_ARG();
+			}
+			if (dev)
+				duparg2("dev", *argv);
+			dev = *argv;
+		}
+		argc--; argv++;
+	}
+
+	if (!dev) {
+		bb_error_msg(bb_msg_requires_arg, "\"dev\"");
+		exit(-1);
+	}
+
+	if (newaddr || newbrd) {
+		halen = get_address(dev, &htype);
+		if (halen < 0)
+			return -1;
+		if (newaddr) {
+			if (parse_address(dev, htype, halen, newaddr, &ifr0) < 0)
+				return -1;
+		}
+		if (newbrd) {
+			if (parse_address(dev, htype, halen, newbrd, &ifr1) < 0)
+				return -1;
+		}
+	}
+
+	if (newname && strcmp(dev, newname)) {
+		if (do_changename(dev, newname) < 0)
+			return -1;
+		dev = newname;
+	}
+	if (qlen != -1) {
+		if (set_qlen(dev, qlen) < 0)
+			return -1;
+	}
+	if (mtu != -1) {
+		if (set_mtu(dev, mtu) < 0)
+			return -1;
+	}
+	if (newaddr || newbrd) {
+		if (newbrd) {
+			if (set_address(&ifr1, 1) < 0)
+				return -1;
+		}
+		if (newaddr) {
+			if (set_address(&ifr0, 0) < 0)
+				return -1;
+		}
+	}
+	if (mask)
+		return do_chflags(dev, flags, mask);
+	return 0;
+}
+
+static int ipaddr_list_link(int argc, char **argv)
+{
+	preferred_family = AF_PACKET;
+	return ipaddr_list_or_flush(argc, argv, 0);
+}
+
+int do_iplink(int argc, char **argv)
+{
+	if (argc > 0) {
+		if (matches(*argv, "set") == 0)
+			return do_set(argc-1, argv+1);
+		if (matches(*argv, "show") == 0 ||
+		    matches(*argv, "lst") == 0 ||
+		    matches(*argv, "list") == 0)
+			return ipaddr_list_link(argc-1, argv+1);
+	} else
+		return ipaddr_list_link(0, NULL);
+
+	bb_error_msg("command \"%s\" is unknown", *argv);
+	exit(-1);
+}
diff --git a/networking/libiproute/iproute.c b/networking/libiproute/iproute.c
new file mode 100644
index 0000000..9c3b870
--- /dev/null
+++ b/networking/libiproute/iproute.c
@@ -0,0 +1,858 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * iproute.c		"ip route".
+ *
+ * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+ *
+ * Authors:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
+ *
+ *
+ * Changes:
+ *
+ * Rani Assaf <rani@magic.metawire.com> 980929:	resolve addresses
+ * Kunihiro Ishiguro <kunihiro@zebra.org> 001102: rtnh_ifindex was not initialized
+ */
+
+#include "libbb.h"
+
+#include <sys/socket.h>
+
+#include <string.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+#include "rt_names.h"
+#include "utils.h"
+#include "ip_common.h"
+
+#ifndef RTAX_RTTVAR
+#define RTAX_RTTVAR RTAX_HOPS
+#endif
+
+
+static struct
+{
+	int tb;
+	int flushed;
+	char *flushb;
+	int flushp;
+	int flushe;
+	struct rtnl_handle *rth;
+	int protocol, protocolmask;
+	int scope, scopemask;
+	int type, typemask;
+	int tos, tosmask;
+	int iif, iifmask;
+	int oif, oifmask;
+	int realm, realmmask;
+	inet_prefix rprefsrc;
+	inet_prefix rvia;
+	inet_prefix rdst;
+	inet_prefix mdst;
+	inet_prefix rsrc;
+	inet_prefix msrc;
+} filter;
+
+static int flush_update(void)
+{
+	if (rtnl_send(filter.rth, filter.flushb, filter.flushp) < 0) {
+		perror("Failed to send flush request\n");
+		return -1;
+	}
+	filter.flushp = 0;
+	return 0;
+}
+
+static int print_route(struct sockaddr_nl *who ATTRIBUTE_UNUSED,
+		struct nlmsghdr *n, void *arg)
+{
+	FILE *fp = (FILE*)arg;
+	struct rtmsg *r = NLMSG_DATA(n);
+	int len = n->nlmsg_len;
+	struct rtattr * tb[RTA_MAX+1];
+	char abuf[256];
+	inet_prefix dst;
+	inet_prefix src;
+	int host_len = -1;
+	SPRINT_BUF(b1);
+
+
+	if (n->nlmsg_type != RTM_NEWROUTE && n->nlmsg_type != RTM_DELROUTE) {
+		fprintf(stderr, "Not a route: %08x %08x %08x\n",
+			n->nlmsg_len, n->nlmsg_type, n->nlmsg_flags);
+		return 0;
+	}
+	if (filter.flushb && n->nlmsg_type != RTM_NEWROUTE)
+		return 0;
+	len -= NLMSG_LENGTH(sizeof(*r));
+	if (len < 0) {
+		bb_error_msg("wrong nlmsg len %d", len);
+		return -1;
+	}
+
+	if (r->rtm_family == AF_INET6)
+		host_len = 128;
+	else if (r->rtm_family == AF_INET)
+		host_len = 32;
+
+	if (r->rtm_family == AF_INET6) {
+		if (filter.tb) {
+			if (filter.tb < 0) {
+				if (!(r->rtm_flags&RTM_F_CLONED)) {
+					return 0;
+				}
+			} else {
+				if (r->rtm_flags&RTM_F_CLONED) {
+					return 0;
+				}
+				if (filter.tb == RT_TABLE_LOCAL) {
+					if (r->rtm_type != RTN_LOCAL) {
+						return 0;
+					}
+				} else if (filter.tb == RT_TABLE_MAIN) {
+					if (r->rtm_type == RTN_LOCAL) {
+						return 0;
+					}
+				} else {
+					return 0;
+				}
+			}
+		}
+	} else {
+		if (filter.tb > 0 && filter.tb != r->rtm_table) {
+			return 0;
+		}
+	}
+	if (filter.rdst.family &&
+	    (r->rtm_family != filter.rdst.family || filter.rdst.bitlen > r->rtm_dst_len)) {
+		return 0;
+	}
+	if (filter.mdst.family &&
+	    (r->rtm_family != filter.mdst.family ||
+	     (filter.mdst.bitlen >= 0 && filter.mdst.bitlen < r->rtm_dst_len))) {
+		return 0;
+	}
+	if (filter.rsrc.family &&
+	    (r->rtm_family != filter.rsrc.family || filter.rsrc.bitlen > r->rtm_src_len)) {
+		return 0;
+	}
+	if (filter.msrc.family &&
+	    (r->rtm_family != filter.msrc.family ||
+	     (filter.msrc.bitlen >= 0 && filter.msrc.bitlen < r->rtm_src_len))) {
+		return 0;
+	}
+
+	memset(tb, 0, sizeof(tb));
+	parse_rtattr(tb, RTA_MAX, RTM_RTA(r), len);
+
+	if (filter.rdst.family && inet_addr_match(&dst, &filter.rdst, filter.rdst.bitlen))
+		return 0;
+	if (filter.mdst.family && filter.mdst.bitlen >= 0 &&
+	    inet_addr_match(&dst, &filter.mdst, r->rtm_dst_len))
+		return 0;
+
+	if (filter.rsrc.family && inet_addr_match(&src, &filter.rsrc, filter.rsrc.bitlen))
+		return 0;
+	if (filter.msrc.family && filter.msrc.bitlen >= 0 &&
+	    inet_addr_match(&src, &filter.msrc, r->rtm_src_len))
+		return 0;
+
+	if (filter.flushb &&
+	    r->rtm_family == AF_INET6 &&
+	    r->rtm_dst_len == 0 &&
+	    r->rtm_type == RTN_UNREACHABLE &&
+	    tb[RTA_PRIORITY] &&
+	    *(int*)RTA_DATA(tb[RTA_PRIORITY]) == -1)
+		return 0;
+
+	if (filter.flushb) {
+		struct nlmsghdr *fn;
+		if (NLMSG_ALIGN(filter.flushp) + n->nlmsg_len > filter.flushe) {
+			if (flush_update())
+				return -1;
+		}
+		fn = (struct nlmsghdr*)(filter.flushb + NLMSG_ALIGN(filter.flushp));
+		memcpy(fn, n, n->nlmsg_len);
+		fn->nlmsg_type = RTM_DELROUTE;
+		fn->nlmsg_flags = NLM_F_REQUEST;
+		fn->nlmsg_seq = ++filter.rth->seq;
+		filter.flushp = (((char*)fn) + n->nlmsg_len) - filter.flushb;
+		filter.flushed++;
+		return 0;
+	}
+
+	if (n->nlmsg_type == RTM_DELROUTE) {
+		fprintf(fp, "Deleted ");
+	}
+	if (r->rtm_type != RTN_UNICAST && !filter.type) {
+		fprintf(fp, "%s ", rtnl_rtntype_n2a(r->rtm_type, b1, sizeof(b1)));
+	}
+
+	if (tb[RTA_DST]) {
+		if (r->rtm_dst_len != host_len) {
+			fprintf(fp, "%s/%u ", rt_addr_n2a(r->rtm_family,
+							 RTA_PAYLOAD(tb[RTA_DST]),
+							 RTA_DATA(tb[RTA_DST]),
+							 abuf, sizeof(abuf)),
+				r->rtm_dst_len
+				);
+		} else {
+			fprintf(fp, "%s ", format_host(r->rtm_family,
+						       RTA_PAYLOAD(tb[RTA_DST]),
+						       RTA_DATA(tb[RTA_DST]),
+						       abuf, sizeof(abuf))
+				);
+		}
+	} else if (r->rtm_dst_len) {
+		fprintf(fp, "0/%d ", r->rtm_dst_len);
+	} else {
+		fprintf(fp, "default ");
+	}
+	if (tb[RTA_SRC]) {
+		if (r->rtm_src_len != host_len) {
+			fprintf(fp, "from %s/%u ", rt_addr_n2a(r->rtm_family,
+							 RTA_PAYLOAD(tb[RTA_SRC]),
+							 RTA_DATA(tb[RTA_SRC]),
+							 abuf, sizeof(abuf)),
+				r->rtm_src_len
+				);
+		} else {
+			fprintf(fp, "from %s ", format_host(r->rtm_family,
+						       RTA_PAYLOAD(tb[RTA_SRC]),
+						       RTA_DATA(tb[RTA_SRC]),
+						       abuf, sizeof(abuf))
+				);
+		}
+	} else if (r->rtm_src_len) {
+		fprintf(fp, "from 0/%u ", r->rtm_src_len);
+	}
+	if (tb[RTA_GATEWAY] && filter.rvia.bitlen != host_len) {
+		fprintf(fp, "via %s ",
+			format_host(r->rtm_family,
+				    RTA_PAYLOAD(tb[RTA_GATEWAY]),
+				    RTA_DATA(tb[RTA_GATEWAY]),
+				    abuf, sizeof(abuf)));
+	}
+	if (tb[RTA_OIF] && filter.oifmask != -1) {
+		fprintf(fp, "dev %s ", ll_index_to_name(*(int*)RTA_DATA(tb[RTA_OIF])));
+	}
+
+	if (tb[RTA_PREFSRC] && filter.rprefsrc.bitlen != host_len) {
+		/* Do not use format_host(). It is our local addr
+		   and symbolic name will not be useful.
+		 */
+		fprintf(fp, " src %s ",
+			rt_addr_n2a(r->rtm_family,
+				    RTA_PAYLOAD(tb[RTA_PREFSRC]),
+				    RTA_DATA(tb[RTA_PREFSRC]),
+				    abuf, sizeof(abuf)));
+	}
+	if (tb[RTA_PRIORITY]) {
+		fprintf(fp, " metric %d ", *(__u32*)RTA_DATA(tb[RTA_PRIORITY]));
+	}
+	if (r->rtm_family == AF_INET6) {
+		struct rta_cacheinfo *ci = NULL;
+		if (tb[RTA_CACHEINFO]) {
+			ci = RTA_DATA(tb[RTA_CACHEINFO]);
+		}
+		if ((r->rtm_flags & RTM_F_CLONED) || (ci && ci->rta_expires)) {
+			static int hz;
+			if (!hz) {
+				hz = get_hz();
+			}
+			if (r->rtm_flags & RTM_F_CLONED) {
+				fprintf(fp, "%s    cache ", _SL_);
+			}
+			if (ci->rta_expires) {
+				fprintf(fp, " expires %dsec", ci->rta_expires/hz);
+			}
+			if (ci->rta_error != 0) {
+				fprintf(fp, " error %d", ci->rta_error);
+			}
+		} else if (ci) {
+			if (ci->rta_error != 0)
+				fprintf(fp, " error %d", ci->rta_error);
+		}
+	}
+	if (tb[RTA_IIF] && filter.iifmask != -1) {
+		fprintf(fp, " iif %s", ll_index_to_name(*(int*)RTA_DATA(tb[RTA_IIF])));
+	}
+	fprintf(fp, "\n");
+	fflush(fp);
+	return 0;
+}
+
+static int iproute_modify(int cmd, unsigned flags, int argc, char **argv)
+{
+	struct rtnl_handle rth;
+	struct {
+		struct nlmsghdr		n;
+		struct rtmsg		r;
+		char			buf[1024];
+	} req;
+	char  mxbuf[256];
+	struct rtattr * mxrta = (void*)mxbuf;
+	unsigned mxlock = 0;
+	char  *d = NULL;
+	int gw_ok = 0;
+	int dst_ok = 0;
+	int proto_ok = 0;
+	int type_ok = 0;
+
+	memset(&req, 0, sizeof(req));
+
+	req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
+	req.n.nlmsg_flags = NLM_F_REQUEST|flags;
+	req.n.nlmsg_type = cmd;
+	req.r.rtm_family = preferred_family;
+	req.r.rtm_table = RT_TABLE_MAIN;
+	req.r.rtm_scope = RT_SCOPE_NOWHERE;
+
+	if (cmd != RTM_DELROUTE) {
+		req.r.rtm_protocol = RTPROT_BOOT;
+		req.r.rtm_scope = RT_SCOPE_UNIVERSE;
+		req.r.rtm_type = RTN_UNICAST;
+	}
+
+	mxrta->rta_type = RTA_METRICS;
+	mxrta->rta_len = RTA_LENGTH(0);
+
+	while (argc > 0) {
+		if (strcmp(*argv, "src") == 0) {
+			inet_prefix addr;
+			NEXT_ARG();
+			get_addr(&addr, *argv, req.r.rtm_family);
+			if (req.r.rtm_family == AF_UNSPEC) {
+				req.r.rtm_family = addr.family;
+			}
+			addattr_l(&req.n, sizeof(req), RTA_PREFSRC, &addr.data, addr.bytelen);
+		} else if (strcmp(*argv, "via") == 0) {
+			inet_prefix addr;
+			gw_ok = 1;
+			NEXT_ARG();
+			get_addr(&addr, *argv, req.r.rtm_family);
+			if (req.r.rtm_family == AF_UNSPEC) {
+				req.r.rtm_family = addr.family;
+			}
+			addattr_l(&req.n, sizeof(req), RTA_GATEWAY, &addr.data, addr.bytelen);
+		} else if (strcmp(*argv, "mtu") == 0) {
+			unsigned mtu;
+			NEXT_ARG();
+			if (strcmp(*argv, "lock") == 0) {
+				mxlock |= (1<<RTAX_MTU);
+				NEXT_ARG();
+			}
+			if (get_unsigned(&mtu, *argv, 0)) {
+				invarg(*argv, "mtu");
+			}
+			rta_addattr32(mxrta, sizeof(mxbuf), RTAX_MTU, mtu);
+		} else if (matches(*argv, "protocol") == 0) {
+			uint32_t prot;
+			NEXT_ARG();
+			if (rtnl_rtprot_a2n(&prot, *argv))
+				invarg(*argv, "protocol");
+			req.r.rtm_protocol = prot;
+			proto_ok =1;
+		} else if (strcmp(*argv, "dev") == 0 ||
+			   strcmp(*argv, "oif") == 0) {
+			NEXT_ARG();
+			d = *argv;
+		} else {
+			int type;
+			inet_prefix dst;
+
+			if (strcmp(*argv, "to") == 0) {
+				NEXT_ARG();
+			}
+			if ((**argv < '0' || **argv > '9') &&
+			    rtnl_rtntype_a2n(&type, *argv) == 0) {
+				NEXT_ARG();
+				req.r.rtm_type = type;
+				type_ok = 1;
+			}
+
+			if (dst_ok) {
+				duparg2("to", *argv);
+			}
+			get_prefix(&dst, *argv, req.r.rtm_family);
+			if (req.r.rtm_family == AF_UNSPEC) {
+				req.r.rtm_family = dst.family;
+			}
+			req.r.rtm_dst_len = dst.bitlen;
+			dst_ok = 1;
+			if (dst.bytelen) {
+				addattr_l(&req.n, sizeof(req), RTA_DST, &dst.data, dst.bytelen);
+			}
+		}
+		argc--; argv++;
+	}
+
+	if (rtnl_open(&rth, 0) < 0) {
+		exit(1);
+	}
+
+	if (d)  {
+		int idx;
+
+		ll_init_map(&rth);
+
+		if (d) {
+			if ((idx = ll_name_to_index(d)) == 0) {
+				bb_error_msg("cannot find device \"%s\"", d);
+				return -1;
+			}
+			addattr32(&req.n, sizeof(req), RTA_OIF, idx);
+		}
+	}
+
+	if (mxrta->rta_len > RTA_LENGTH(0)) {
+		if (mxlock) {
+			rta_addattr32(mxrta, sizeof(mxbuf), RTAX_LOCK, mxlock);
+		}
+		addattr_l(&req.n, sizeof(req), RTA_METRICS, RTA_DATA(mxrta), RTA_PAYLOAD(mxrta));
+	}
+
+	if (req.r.rtm_family == AF_UNSPEC) {
+		req.r.rtm_family = AF_INET;
+	}
+
+	if (rtnl_talk(&rth, &req.n, 0, 0, NULL, NULL, NULL) < 0) {
+		exit(2);
+	}
+
+	return 0;
+}
+
+static int rtnl_rtcache_request(struct rtnl_handle *rth, int family)
+{
+	struct {
+		struct nlmsghdr nlh;
+		struct rtmsg rtm;
+	} req;
+	struct sockaddr_nl nladdr;
+
+	memset(&nladdr, 0, sizeof(nladdr));
+	memset(&req, 0, sizeof(req));
+	nladdr.nl_family = AF_NETLINK;
+
+	req.nlh.nlmsg_len = sizeof(req);
+	req.nlh.nlmsg_type = RTM_GETROUTE;
+	req.nlh.nlmsg_flags = NLM_F_ROOT|NLM_F_REQUEST;
+	req.nlh.nlmsg_pid = 0;
+	req.nlh.nlmsg_seq = rth->dump = ++rth->seq;
+	req.rtm.rtm_family = family;
+	req.rtm.rtm_flags |= RTM_F_CLONED;
+
+	return sendto(rth->fd, (void*)&req, sizeof(req), 0, (struct sockaddr*)&nladdr, sizeof(nladdr));
+}
+
+static int iproute_flush_cache(void)
+{
+#define ROUTE_FLUSH_PATH "/proc/sys/net/ipv4/route/flush"
+
+	int len;
+	int flush_fd = open (ROUTE_FLUSH_PATH, O_WRONLY);
+	char *buffer = "-1";
+
+	if (flush_fd < 0) {
+		fprintf(stderr, "Cannot open \"%s\"\n", ROUTE_FLUSH_PATH);
+		return -1;
+	}
+
+	len = strlen (buffer);
+
+	if ((write (flush_fd, (void *)buffer, len)) < len) {
+		fprintf(stderr, "Cannot flush routing cache\n");
+		return -1;
+	}
+	close(flush_fd);
+	return 0;
+}
+
+static void iproute_reset_filter(void)
+{
+	memset(&filter, 0, sizeof(filter));
+	filter.mdst.bitlen = -1;
+	filter.msrc.bitlen = -1;
+}
+
+static int iproute_list_or_flush(int argc, char **argv, int flush)
+{
+	int do_ipv6 = preferred_family;
+	struct rtnl_handle rth;
+	char *id = NULL;
+	char *od = NULL;
+
+	iproute_reset_filter();
+	filter.tb = RT_TABLE_MAIN;
+
+	if (flush && argc <= 0) {
+		bb_error_msg(bb_msg_requires_arg, "\"ip route flush\"");
+		return -1;
+	}
+
+	while (argc > 0) {
+		if (matches(*argv, "protocol") == 0) {
+			uint32_t prot = 0;
+			NEXT_ARG();
+			filter.protocolmask = -1;
+			if (rtnl_rtprot_a2n(&prot, *argv)) {
+				if (strcmp(*argv, "all") != 0) {
+					invarg(*argv, "protocol");
+				}
+				prot = 0;
+				filter.protocolmask = 0;
+			}
+			filter.protocol = prot;
+		} else if (strcmp(*argv, "dev") == 0 ||
+			   strcmp(*argv, "oif") == 0) {
+			NEXT_ARG();
+			od = *argv;
+		} else if (strcmp(*argv, "iif") == 0) {
+			NEXT_ARG();
+			id = *argv;
+		} else if (matches(*argv, "from") == 0) {
+			NEXT_ARG();
+			if (matches(*argv, "root") == 0) {
+				NEXT_ARG();
+				get_prefix(&filter.rsrc, *argv, do_ipv6);
+			} else if (matches(*argv, "match") == 0) {
+				NEXT_ARG();
+				get_prefix(&filter.msrc, *argv, do_ipv6);
+			} else {
+				if (matches(*argv, "exact") == 0) {
+					NEXT_ARG();
+				}
+				get_prefix(&filter.msrc, *argv, do_ipv6);
+				filter.rsrc = filter.msrc;
+			}
+		} else {
+			if (matches(*argv, "to") == 0) {
+				NEXT_ARG();
+			}
+			if (matches(*argv, "root") == 0) {
+				NEXT_ARG();
+				get_prefix(&filter.rdst, *argv, do_ipv6);
+			} else if (matches(*argv, "match") == 0) {
+				NEXT_ARG();
+				get_prefix(&filter.mdst, *argv, do_ipv6);
+			} else if (matches(*argv, "table") == 0) {
+				NEXT_ARG();
+				if (matches(*argv, "cache") == 0) {
+					filter.tb = -1;
+				} else if (matches(*argv, "main") != 0) {
+					invarg(*argv, "table");
+				}
+			} else if (matches(*argv, "cache") == 0) {
+				filter.tb = -1;
+			} else {
+				if (matches(*argv, "exact") == 0) {
+					NEXT_ARG();
+				}
+				get_prefix(&filter.mdst, *argv, do_ipv6);
+				filter.rdst = filter.mdst;
+			}
+		}
+		argc--; argv++;
+	}
+
+	if (do_ipv6 == AF_UNSPEC && filter.tb) {
+		do_ipv6 = AF_INET;
+	}
+
+	if (rtnl_open(&rth, 0) < 0) {
+		exit(1);
+	}
+
+	ll_init_map(&rth);
+
+	if (id || od)  {
+		int idx;
+
+		if (id) {
+			if ((idx = ll_name_to_index(id)) == 0) {
+				bb_error_msg("cannot find device \"%s\"", id);
+				return -1;
+			}
+			filter.iif = idx;
+			filter.iifmask = -1;
+		}
+		if (od) {
+			if ((idx = ll_name_to_index(od)) == 0) {
+				bb_error_msg("cannot find device \"%s\"", od);
+			}
+			filter.oif = idx;
+			filter.oifmask = -1;
+		}
+	}
+
+	if (flush) {
+		char flushb[4096-512];
+
+		if (filter.tb == -1) {
+			if (do_ipv6 != AF_INET6)
+				iproute_flush_cache();
+			if (do_ipv6 == AF_INET)
+				return 0;
+		}
+
+		filter.flushb = flushb;
+		filter.flushp = 0;
+		filter.flushe = sizeof(flushb);
+		filter.rth = &rth;
+
+		for (;;) {
+			if (rtnl_wilddump_request(&rth, do_ipv6, RTM_GETROUTE) < 0) {
+				perror("Cannot send dump request");
+				return -1;
+			}
+			filter.flushed = 0;
+			if (rtnl_dump_filter(&rth, print_route, stdout, NULL, NULL) < 0) {
+				bb_error_msg("flush terminated");
+				return -1;
+			}
+			if (filter.flushed == 0) {
+				fflush(stdout);
+				return 0;
+			}
+			if (flush_update() < 0)
+				exit(1);
+		}
+	}
+
+	if (filter.tb != -1) {
+		if (rtnl_wilddump_request(&rth, do_ipv6, RTM_GETROUTE) < 0) {
+			bb_perror_msg_and_die("cannot send dump request");
+		}
+	} else {
+		if (rtnl_rtcache_request(&rth, do_ipv6) < 0) {
+			bb_perror_msg_and_die("cannot send dump request");
+		}
+	}
+
+	if (rtnl_dump_filter(&rth, print_route, stdout, NULL, NULL) < 0) {
+		bb_error_msg_and_die("dump terminated");
+	}
+
+	exit(0);
+}
+
+
+static int iproute_get(int argc, char **argv)
+{
+	struct rtnl_handle rth;
+	struct {
+		struct nlmsghdr		n;
+		struct rtmsg		r;
+		char			buf[1024];
+	} req;
+	char  *idev = NULL;
+	char  *odev = NULL;
+	int connected = 0;
+	int from_ok = 0;
+	static const char * const options[] =
+		{ "from", "iif", "oif", "dev", "notify", "connected", "to", 0 };
+
+	memset(&req, 0, sizeof(req));
+
+	iproute_reset_filter();
+
+	req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
+	req.n.nlmsg_flags = NLM_F_REQUEST;
+	req.n.nlmsg_type = RTM_GETROUTE;
+	req.r.rtm_family = preferred_family;
+	req.r.rtm_table = 0;
+	req.r.rtm_protocol = 0;
+	req.r.rtm_scope = 0;
+	req.r.rtm_type = 0;
+	req.r.rtm_src_len = 0;
+	req.r.rtm_dst_len = 0;
+	req.r.rtm_tos = 0;
+
+	while (argc > 0) {
+		switch (index_in_str_array(options, *argv)) {
+			case 0: /* from */
+			{
+				inet_prefix addr;
+				NEXT_ARG();
+				from_ok = 1;
+				get_prefix(&addr, *argv, req.r.rtm_family);
+				if (req.r.rtm_family == AF_UNSPEC) {
+					req.r.rtm_family = addr.family;
+				}
+				if (addr.bytelen) {
+					addattr_l(&req.n, sizeof(req), RTA_SRC, &addr.data, addr.bytelen);
+				}
+				req.r.rtm_src_len = addr.bitlen;
+				break;
+			}
+			case 1: /* iif */
+				NEXT_ARG();
+				idev = *argv;
+				break;
+			case 2: /* oif */
+			case 3: /* dev */
+				NEXT_ARG();
+				odev = *argv;
+				break;
+			case 4: /* notify */
+				req.r.rtm_flags |= RTM_F_NOTIFY;
+				break;
+			case 5: /* connected */
+				connected = 1;
+				break;
+			case 6: /* to */
+				NEXT_ARG();
+			default:
+			{
+				inet_prefix addr;
+				get_prefix(&addr, *argv, req.r.rtm_family);
+				if (req.r.rtm_family == AF_UNSPEC) {
+					req.r.rtm_family = addr.family;
+				}
+				if (addr.bytelen) {
+					addattr_l(&req.n, sizeof(req), RTA_DST, &addr.data, addr.bytelen);
+				}
+				req.r.rtm_dst_len = addr.bitlen;
+			}
+			argc--; argv++;
+		}
+	}
+
+	if (req.r.rtm_dst_len == 0) {
+		bb_error_msg_and_die("need at least destination address");
+	}
+
+	if (rtnl_open(&rth, 0) < 0)
+		exit(1);
+
+	ll_init_map(&rth);
+
+	if (idev || odev)  {
+		int idx;
+
+		if (idev) {
+			if ((idx = ll_name_to_index(idev)) == 0) {
+				bb_error_msg("cannot find device \"%s\"", idev);
+				return -1;
+			}
+			addattr32(&req.n, sizeof(req), RTA_IIF, idx);
+		}
+		if (odev) {
+			if ((idx = ll_name_to_index(odev)) == 0) {
+				bb_error_msg("cannot find device \"%s\"", odev);
+				return -1;
+			}
+			addattr32(&req.n, sizeof(req), RTA_OIF, idx);
+		}
+	}
+
+	if (req.r.rtm_family == AF_UNSPEC) {
+		req.r.rtm_family = AF_INET;
+	}
+
+	if (rtnl_talk(&rth, &req.n, 0, 0, &req.n, NULL, NULL) < 0) {
+		exit(2);
+	}
+
+	if (connected && !from_ok) {
+		struct rtmsg *r = NLMSG_DATA(&req.n);
+		int len = req.n.nlmsg_len;
+		struct rtattr * tb[RTA_MAX+1];
+
+		if (print_route(NULL, &req.n, (void*)stdout) < 0) {
+			bb_error_msg_and_die("an error :-)");
+		}
+
+		if (req.n.nlmsg_type != RTM_NEWROUTE) {
+			bb_error_msg("not a route?");
+			return -1;
+		}
+		len -= NLMSG_LENGTH(sizeof(*r));
+		if (len < 0) {
+			bb_error_msg("wrong len %d", len);
+			return -1;
+		}
+
+		memset(tb, 0, sizeof(tb));
+		parse_rtattr(tb, RTA_MAX, RTM_RTA(r), len);
+
+		if (tb[RTA_PREFSRC]) {
+			tb[RTA_PREFSRC]->rta_type = RTA_SRC;
+			r->rtm_src_len = 8*RTA_PAYLOAD(tb[RTA_PREFSRC]);
+		} else if (!tb[RTA_SRC]) {
+			bb_error_msg("failed to connect the route");
+			return -1;
+		}
+		if (!odev && tb[RTA_OIF]) {
+			tb[RTA_OIF]->rta_type = 0;
+		}
+		if (tb[RTA_GATEWAY]) {
+			tb[RTA_GATEWAY]->rta_type = 0;
+		}
+		if (!idev && tb[RTA_IIF]) {
+			tb[RTA_IIF]->rta_type = 0;
+		}
+		req.n.nlmsg_flags = NLM_F_REQUEST;
+		req.n.nlmsg_type = RTM_GETROUTE;
+
+		if (rtnl_talk(&rth, &req.n, 0, 0, &req.n, NULL, NULL) < 0) {
+			exit(2);
+		}
+	}
+
+	if (print_route(NULL, &req.n, (void*)stdout) < 0) {
+		bb_error_msg_and_die("an error :-)");
+	}
+
+	exit(0);
+}
+
+int do_iproute(int argc, char **argv)
+{
+	static const char * const ip_route_commands[] =
+		{ "add", "append", "change", "chg", "delete", "get",
+		"list", "show", "prepend", "replace", "test", "flush", 0 };
+	int command_num = 6;
+	unsigned int flags = 0;
+	int cmd = RTM_NEWROUTE;
+
+	/* "Standard" 'ip r a' treats 'a' as 'add', not 'append' */
+	/* It probably means that it is using "first match" rule */
+	if (*argv) {
+		command_num = index_in_substr_array(ip_route_commands, *argv);
+	}
+	switch (command_num) {
+		case 0: /* add*/
+			flags = NLM_F_CREATE|NLM_F_EXCL;
+			break;
+		case 1: /* append */
+			flags = NLM_F_CREATE|NLM_F_APPEND;
+			break;
+		case 2: /* change */
+		case 3: /* chg */
+			flags = NLM_F_REPLACE;
+			break;
+		case 4: /* delete */
+		case 5: /* del */
+			cmd = RTM_DELROUTE;
+			break;
+		case 6: /* get */
+			return iproute_get(argc-1, argv+1);
+		case 7: /* list */
+		case 8: /* show */
+			return iproute_list_or_flush(argc-1, argv+1, 0);
+		case 9: /* prepend */
+			flags = NLM_F_CREATE;
+		case 10: /* replace */
+			flags = NLM_F_CREATE|NLM_F_REPLACE;
+		case 11: /* test */
+			flags = NLM_F_EXCL;
+		case 12: /* flush */
+			return iproute_list_or_flush(argc-1, argv+1, 1);
+		default:
+			bb_error_msg_and_die("unknown command %s", *argv);
+	}
+
+	return iproute_modify(cmd, flags, argc-1, argv+1);
+}
diff --git a/networking/libiproute/iprule.c b/networking/libiproute/iprule.c
new file mode 100644
index 0000000..1933877
--- /dev/null
+++ b/networking/libiproute/iprule.c
@@ -0,0 +1,331 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * iprule.c		"ip rule".
+ *
+ *		This program is free software; you can redistribute it and/or
+ *		modify it under the terms of the GNU General Public License
+ *		as published by the Free Software Foundation; either version
+ *		2 of the License, or (at your option) any later version.
+ *
+ * Authors:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
+ *
+ *
+ * Changes:
+ *
+ * Rani Assaf <rani@magic.metawire.com> 980929:	resolve addresses
+ */
+
+#include "libbb.h"
+#include <syslog.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netinet/ip.h>
+#include <arpa/inet.h>
+
+#include "rt_names.h"
+#include "utils.h"
+/*
+static void usage(void) __attribute__((noreturn));
+
+static void usage(void)
+{
+	fprintf(stderr, "Usage: ip rule [ list | add | del ] SELECTOR ACTION\n");
+	fprintf(stderr, "SELECTOR := [ from PREFIX ] [ to PREFIX ] [ tos TOS ] [ fwmark FWMARK ]\n");
+	fprintf(stderr, "            [ dev STRING ] [ pref NUMBER ]\n");
+	fprintf(stderr, "ACTION := [ table TABLE_ID ] [ nat ADDRESS ]\n");
+	fprintf(stderr, "          [ prohibit | reject | unreachable ]\n");
+	fprintf(stderr, "          [ realms [SRCREALM/]DSTREALM ]\n");
+	fprintf(stderr, "TABLE_ID := [ local | main | default | NUMBER ]\n");
+	exit(-1);
+}
+*/
+static int print_rule(struct sockaddr_nl *who ATTRIBUTE_UNUSED,
+					struct nlmsghdr *n, void *arg)
+{
+	FILE *fp = (FILE*)arg;
+	struct rtmsg *r = NLMSG_DATA(n);
+	int len = n->nlmsg_len;
+	int host_len = -1;
+	struct rtattr * tb[RTA_MAX+1];
+	char abuf[256];
+	SPRINT_BUF(b1);
+
+	if (n->nlmsg_type != RTM_NEWRULE)
+		return 0;
+
+	len -= NLMSG_LENGTH(sizeof(*r));
+	if (len < 0)
+		return -1;
+
+	memset(tb, 0, sizeof(tb));
+	parse_rtattr(tb, RTA_MAX, RTM_RTA(r), len);
+
+	if (r->rtm_family == AF_INET)
+		host_len = 32;
+	else if (r->rtm_family == AF_INET6)
+		host_len = 128;
+/*	else if (r->rtm_family == AF_DECnet)
+		host_len = 16;
+	else if (r->rtm_family == AF_IPX)
+		host_len = 80;
+*/
+	if (tb[RTA_PRIORITY])
+		fprintf(fp, "%u:\t", *(unsigned*)RTA_DATA(tb[RTA_PRIORITY]));
+	else
+		fprintf(fp, "0:\t");
+
+	fprintf(fp, "from ");
+	if (tb[RTA_SRC]) {
+		if (r->rtm_src_len != host_len) {
+			fprintf(fp, "%s/%u", rt_addr_n2a(r->rtm_family,
+							 RTA_PAYLOAD(tb[RTA_SRC]),
+							 RTA_DATA(tb[RTA_SRC]),
+							 abuf, sizeof(abuf)),
+				r->rtm_src_len
+				);
+		} else {
+			fprintf(fp, "%s", format_host(r->rtm_family,
+						       RTA_PAYLOAD(tb[RTA_SRC]),
+						       RTA_DATA(tb[RTA_SRC]),
+						       abuf, sizeof(abuf))
+				);
+		}
+	} else if (r->rtm_src_len) {
+		fprintf(fp, "0/%d", r->rtm_src_len);
+	} else {
+		fprintf(fp, "all");
+	}
+	fprintf(fp, " ");
+
+	if (tb[RTA_DST]) {
+		if (r->rtm_dst_len != host_len) {
+			fprintf(fp, "to %s/%u ", rt_addr_n2a(r->rtm_family,
+							 RTA_PAYLOAD(tb[RTA_DST]),
+							 RTA_DATA(tb[RTA_DST]),
+							 abuf, sizeof(abuf)),
+				r->rtm_dst_len
+				);
+		} else {
+			fprintf(fp, "to %s ", format_host(r->rtm_family,
+						       RTA_PAYLOAD(tb[RTA_DST]),
+						       RTA_DATA(tb[RTA_DST]),
+						       abuf, sizeof(abuf)));
+		}
+	} else if (r->rtm_dst_len) {
+		fprintf(fp, "to 0/%d ", r->rtm_dst_len);
+	}
+
+	if (r->rtm_tos) {
+		fprintf(fp, "tos %s ", rtnl_dsfield_n2a(r->rtm_tos, b1, sizeof(b1)));
+	}
+	if (tb[RTA_PROTOINFO]) {
+		fprintf(fp, "fwmark %#x ", *(__u32*)RTA_DATA(tb[RTA_PROTOINFO]));
+	}
+
+	if (tb[RTA_IIF]) {
+		fprintf(fp, "iif %s ", (char*)RTA_DATA(tb[RTA_IIF]));
+	}
+
+	if (r->rtm_table)
+		fprintf(fp, "lookup %s ", rtnl_rttable_n2a(r->rtm_table, b1, sizeof(b1)));
+
+	if (tb[RTA_FLOW]) {
+		__u32 to = *(__u32*)RTA_DATA(tb[RTA_FLOW]);
+		__u32 from = to>>16;
+		to &= 0xFFFF;
+		if (from) {
+			fprintf(fp, "realms %s/",
+				rtnl_rtrealm_n2a(from, b1, sizeof(b1)));
+		}
+		fprintf(fp, "%s ",
+			rtnl_rtrealm_n2a(to, b1, sizeof(b1)));
+	}
+
+	if (r->rtm_type == RTN_NAT) {
+		if (tb[RTA_GATEWAY]) {
+			fprintf(fp, "map-to %s ",
+				format_host(r->rtm_family,
+					    RTA_PAYLOAD(tb[RTA_GATEWAY]),
+					    RTA_DATA(tb[RTA_GATEWAY]),
+					    abuf, sizeof(abuf)));
+		} else
+			fprintf(fp, "masquerade");
+	} else if (r->rtm_type != RTN_UNICAST)
+		fprintf(fp, "%s", rtnl_rtntype_n2a(r->rtm_type, b1, sizeof(b1)));
+
+	fprintf(fp, "\n");
+	fflush(fp);
+	return 0;
+}
+
+int iprule_list(int argc, char **argv)
+{
+	struct rtnl_handle rth;
+	int af = preferred_family;
+
+	if (af == AF_UNSPEC)
+		af = AF_INET;
+
+	if (argc > 0) {
+		bb_error_msg("\"rule show\" needs no arguments");
+		return -1;
+	}
+
+	if (rtnl_open(&rth, 0) < 0)
+		return 1;
+
+	if (rtnl_wilddump_request(&rth, af, RTM_GETRULE) < 0) {
+		bb_perror_msg("Cannot send dump request");
+		return 1;
+	}
+
+	if (rtnl_dump_filter(&rth, print_rule, stdout, NULL, NULL) < 0) {
+		bb_error_msg("Dump terminated");
+		return 1;
+	}
+
+	return 0;
+}
+
+
+int iprule_modify(int cmd, int argc, char **argv)
+{
+	int table_ok = 0;
+	struct rtnl_handle rth;
+	struct {
+		struct nlmsghdr	n;
+		struct rtmsg	r;
+		char		buf[1024];
+	} req;
+
+	memset(&req, 0, sizeof(req));
+
+	req.n.nlmsg_type = cmd;
+	req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
+	req.n.nlmsg_flags = NLM_F_REQUEST;
+	req.r.rtm_family = preferred_family;
+	req.r.rtm_protocol = RTPROT_BOOT;
+	req.r.rtm_scope = RT_SCOPE_UNIVERSE;
+	req.r.rtm_table = 0;
+	req.r.rtm_type = RTN_UNSPEC;
+
+	if (cmd == RTM_NEWRULE) {
+		req.n.nlmsg_flags |= NLM_F_CREATE|NLM_F_EXCL;
+		req.r.rtm_type = RTN_UNICAST;
+	}
+
+	while (argc > 0) {
+		if (strcmp(*argv, "from") == 0) {
+			inet_prefix dst;
+			NEXT_ARG();
+			get_prefix(&dst, *argv, req.r.rtm_family);
+			req.r.rtm_src_len = dst.bitlen;
+			addattr_l(&req.n, sizeof(req), RTA_SRC, &dst.data, dst.bytelen);
+		} else if (strcmp(*argv, "to") == 0) {
+			inet_prefix dst;
+			NEXT_ARG();
+			get_prefix(&dst, *argv, req.r.rtm_family);
+			req.r.rtm_dst_len = dst.bitlen;
+			addattr_l(&req.n, sizeof(req), RTA_DST, &dst.data, dst.bytelen);
+		} else if (matches(*argv, "preference") == 0 ||
+			   matches(*argv, "order") == 0 ||
+			   matches(*argv, "priority") == 0) {
+			__u32 pref;
+			NEXT_ARG();
+			if (get_u32(&pref, *argv, 0))
+				invarg("preference value", *argv);
+			addattr32(&req.n, sizeof(req), RTA_PRIORITY, pref);
+		} else if (strcmp(*argv, "tos") == 0) {
+			__u32 tos;
+			NEXT_ARG();
+			if (rtnl_dsfield_a2n(&tos, *argv))
+				invarg("TOS value", *argv);
+			req.r.rtm_tos = tos;
+		} else if (strcmp(*argv, "fwmark") == 0) {
+			__u32 fwmark;
+			NEXT_ARG();
+			if (get_u32(&fwmark, *argv, 0))
+				invarg("fwmark value", *argv);
+			addattr32(&req.n, sizeof(req), RTA_PROTOINFO, fwmark);
+		} else if (matches(*argv, "realms") == 0) {
+			__u32 realm;
+			NEXT_ARG();
+			if (get_rt_realms(&realm, *argv))
+				invarg("realms", *argv);
+			addattr32(&req.n, sizeof(req), RTA_FLOW, realm);
+		} else if (matches(*argv, "table") == 0 ||
+			   strcmp(*argv, "lookup") == 0) {
+			int tid;
+			NEXT_ARG();
+			if (rtnl_rttable_a2n(&tid, *argv))
+				invarg("table ID", *argv);
+			req.r.rtm_table = tid;
+			table_ok = 1;
+		} else if (strcmp(*argv, "dev") == 0 ||
+			   strcmp(*argv, "iif") == 0) {
+			NEXT_ARG();
+			addattr_l(&req.n, sizeof(req), RTA_IIF, *argv, strlen(*argv)+1);
+		} else if (strcmp(*argv, "nat") == 0 ||
+			   matches(*argv, "map-to") == 0) {
+			NEXT_ARG();
+			addattr32(&req.n, sizeof(req), RTA_GATEWAY, get_addr32(*argv));
+			req.r.rtm_type = RTN_NAT;
+		} else {
+			int type;
+
+			if (strcmp(*argv, "type") == 0) {
+				NEXT_ARG();
+			}
+			if (matches(*argv, "help") == 0)
+				bb_show_usage();
+			if (rtnl_rtntype_a2n(&type, *argv))
+				invarg("Failed to parse rule type", *argv);
+			req.r.rtm_type = type;
+		}
+		argc--;
+		argv++;
+	}
+
+	if (req.r.rtm_family == AF_UNSPEC)
+		req.r.rtm_family = AF_INET;
+
+	if (!table_ok && cmd == RTM_NEWRULE)
+		req.r.rtm_table = RT_TABLE_MAIN;
+
+	if (rtnl_open(&rth, 0) < 0)
+		return 1;
+
+	if (rtnl_talk(&rth, &req.n, 0, 0, NULL, NULL, NULL) < 0)
+		return 2;
+
+	return 0;
+}
+
+int do_iprule(int argc, char **argv)
+{
+	static const char * const ip_rule_commands[] =
+		{"add", "delete", "list", "show", 0};
+	int command_num = 2;
+	int cmd;
+
+	if (argc < 1)
+		return iprule_list(0, NULL);
+	if (*argv)
+		command_num = index_in_substr_array(ip_rule_commands, *argv);
+	switch (command_num) {
+		case 0: /* add */
+			cmd = RTM_NEWRULE;
+			break;
+		case 1: /* delete */
+			cmd = RTM_DELRULE;
+			break;
+		case 2: /* list */
+		case 3: /* show */
+			return iprule_list(argc-1, argv+1);
+			break;
+		default:
+			bb_error_msg_and_die("unknown command %s", *argv);
+	}
+	return iprule_modify(cmd, argc-1, argv+1);
+}
+
diff --git a/networking/libiproute/iptunnel.c b/networking/libiproute/iptunnel.c
new file mode 100644
index 0000000..2080324
--- /dev/null
+++ b/networking/libiproute/iptunnel.c
@@ -0,0 +1,546 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * iptunnel.c	       "ip tunnel"
+ *
+ * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+ *
+ * Authors:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
+ *
+ *
+ * Changes:
+ *
+ * Rani Assaf <rani@magic.metawire.com> 980929:	resolve addresses
+ * Rani Assaf <rani@magic.metawire.com> 980930:	do not allow key for ipip/sit
+ * Phil Karn <karn@ka9q.ampr.org>	990408:	"pmtudisc" flag
+ */
+
+#include "libbb.h"
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+
+#include <string.h>
+#include <unistd.h>
+
+#include <netinet/ip.h>
+
+#include <net/if.h>
+#include <net/if_arp.h>
+
+#include <asm/types.h>
+#ifndef __constant_htons
+#define __constant_htons htons
+#endif
+#include <linux/if_tunnel.h>
+
+#include "rt_names.h"
+#include "utils.h"
+#include "ip_common.h"
+
+
+static int do_ioctl_get_ifindex(char *dev)
+{
+	struct ifreq ifr;
+	int fd;
+
+	strncpy(ifr.ifr_name, dev, sizeof(ifr.ifr_name));
+	fd = xsocket(AF_INET, SOCK_DGRAM, 0);
+	if (ioctl(fd, SIOCGIFINDEX, &ifr)) {
+		bb_perror_msg("ioctl");
+		return 0;
+	}
+	close(fd);
+	return ifr.ifr_ifindex;
+}
+
+static int do_ioctl_get_iftype(char *dev)
+{
+	struct ifreq ifr;
+	int fd;
+
+	strncpy(ifr.ifr_name, dev, sizeof(ifr.ifr_name));
+	fd = xsocket(AF_INET, SOCK_DGRAM, 0);
+	if (ioctl(fd, SIOCGIFHWADDR, &ifr)) {
+		bb_perror_msg("ioctl");
+		return -1;
+	}
+	close(fd);
+	return ifr.ifr_addr.sa_family;
+}
+
+
+static char *do_ioctl_get_ifname(int idx)
+{
+	static struct ifreq ifr;
+	int fd;
+
+	ifr.ifr_ifindex = idx;
+	fd = xsocket(AF_INET, SOCK_DGRAM, 0);
+	if (ioctl(fd, SIOCGIFNAME, &ifr)) {
+		bb_perror_msg("ioctl");
+		return NULL;
+	}
+	close(fd);
+	return ifr.ifr_name;
+}
+
+
+
+static int do_get_ioctl(char *basedev, struct ip_tunnel_parm *p)
+{
+	struct ifreq ifr;
+	int fd;
+	int err;
+
+	strncpy(ifr.ifr_name, basedev, sizeof(ifr.ifr_name));
+	ifr.ifr_ifru.ifru_data = (void*)p;
+	fd = xsocket(AF_INET, SOCK_DGRAM, 0);
+	err = ioctl(fd, SIOCGETTUNNEL, &ifr);
+	if (err) {
+		bb_perror_msg("ioctl");
+	}
+	close(fd);
+	return err;
+}
+
+static int do_add_ioctl(int cmd, char *basedev, struct ip_tunnel_parm *p)
+{
+	struct ifreq ifr;
+	int fd;
+	int err;
+
+	if (cmd == SIOCCHGTUNNEL && p->name[0]) {
+		strncpy(ifr.ifr_name, p->name, sizeof(ifr.ifr_name));
+	} else {
+		strncpy(ifr.ifr_name, basedev, sizeof(ifr.ifr_name));
+	}
+	ifr.ifr_ifru.ifru_data = (void*)p;
+	fd = xsocket(AF_INET, SOCK_DGRAM, 0);
+	err = ioctl(fd, cmd, &ifr);
+	if (err) {
+		bb_perror_msg("ioctl");
+	}
+	close(fd);
+	return err;
+}
+
+static int do_del_ioctl(char *basedev, struct ip_tunnel_parm *p)
+{
+	struct ifreq ifr;
+	int fd;
+	int err;
+
+	if (p->name[0]) {
+		strncpy(ifr.ifr_name, p->name, sizeof(ifr.ifr_name));
+	} else {
+		strncpy(ifr.ifr_name, basedev, sizeof(ifr.ifr_name));
+	}
+	ifr.ifr_ifru.ifru_data = (void*)p;
+	fd = xsocket(AF_INET, SOCK_DGRAM, 0);
+	err = ioctl(fd, SIOCDELTUNNEL, &ifr);
+	if (err) {
+		bb_perror_msg("ioctl");
+	}
+	close(fd);
+	return err;
+}
+
+static int parse_args(int argc, char **argv, int cmd, struct ip_tunnel_parm *p)
+{
+	int count = 0;
+	char medium[IFNAMSIZ];
+	memset(p, 0, sizeof(*p));
+	memset(&medium, 0, sizeof(medium));
+
+	p->iph.version = 4;
+	p->iph.ihl = 5;
+#ifndef IP_DF
+#define IP_DF		0x4000		/* Flag: "Don't Fragment"	*/
+#endif
+	p->iph.frag_off = htons(IP_DF);
+
+	while (argc > 0) {
+		if (strcmp(*argv, "mode") == 0) {
+			NEXT_ARG();
+			if (strcmp(*argv, "ipip") == 0 ||
+			    strcmp(*argv, "ip/ip") == 0) {
+				if (p->iph.protocol && p->iph.protocol != IPPROTO_IPIP) {
+					bb_error_msg("you managed to ask for more than one tunnel mode");
+					exit(-1);
+				}
+				p->iph.protocol = IPPROTO_IPIP;
+			} else if (strcmp(*argv, "gre") == 0 ||
+				   strcmp(*argv, "gre/ip") == 0) {
+				if (p->iph.protocol && p->iph.protocol != IPPROTO_GRE) {
+					bb_error_msg("you managed to ask for more than one tunnel mode");
+					exit(-1);
+				}
+				p->iph.protocol = IPPROTO_GRE;
+			} else if (strcmp(*argv, "sit") == 0 ||
+				   strcmp(*argv, "ipv6/ip") == 0) {
+				if (p->iph.protocol && p->iph.protocol != IPPROTO_IPV6) {
+					bb_error_msg("you managed to ask for more than one tunnel mode");
+					exit(-1);
+				}
+				p->iph.protocol = IPPROTO_IPV6;
+			} else {
+				bb_error_msg("cannot guess tunnel mode");
+				exit(-1);
+			}
+		} else if (strcmp(*argv, "key") == 0) {
+			unsigned uval;
+			NEXT_ARG();
+			p->i_flags |= GRE_KEY;
+			p->o_flags |= GRE_KEY;
+			if (strchr(*argv, '.'))
+				p->i_key = p->o_key = get_addr32(*argv);
+			else {
+				if (get_unsigned(&uval, *argv, 0)<0) {
+					bb_error_msg("invalid value of \"key\"");
+					exit(-1);
+				}
+				p->i_key = p->o_key = htonl(uval);
+			}
+		} else if (strcmp(*argv, "ikey") == 0) {
+			unsigned uval;
+			NEXT_ARG();
+			p->i_flags |= GRE_KEY;
+			if (strchr(*argv, '.'))
+				p->o_key = get_addr32(*argv);
+			else {
+				if (get_unsigned(&uval, *argv, 0)<0) {
+					bb_error_msg("invalid value of \"ikey\"");
+					exit(-1);
+				}
+				p->i_key = htonl(uval);
+			}
+		} else if (strcmp(*argv, "okey") == 0) {
+			unsigned uval;
+			NEXT_ARG();
+			p->o_flags |= GRE_KEY;
+			if (strchr(*argv, '.'))
+				p->o_key = get_addr32(*argv);
+			else {
+				if (get_unsigned(&uval, *argv, 0)<0) {
+					bb_error_msg("invalid value of \"okey\"");
+					exit(-1);
+				}
+				p->o_key = htonl(uval);
+			}
+		} else if (strcmp(*argv, "seq") == 0) {
+			p->i_flags |= GRE_SEQ;
+			p->o_flags |= GRE_SEQ;
+		} else if (strcmp(*argv, "iseq") == 0) {
+			p->i_flags |= GRE_SEQ;
+		} else if (strcmp(*argv, "oseq") == 0) {
+			p->o_flags |= GRE_SEQ;
+		} else if (strcmp(*argv, "csum") == 0) {
+			p->i_flags |= GRE_CSUM;
+			p->o_flags |= GRE_CSUM;
+		} else if (strcmp(*argv, "icsum") == 0) {
+			p->i_flags |= GRE_CSUM;
+		} else if (strcmp(*argv, "ocsum") == 0) {
+			p->o_flags |= GRE_CSUM;
+		} else if (strcmp(*argv, "nopmtudisc") == 0) {
+			p->iph.frag_off = 0;
+		} else if (strcmp(*argv, "pmtudisc") == 0) {
+			p->iph.frag_off = htons(IP_DF);
+		} else if (strcmp(*argv, "remote") == 0) {
+			NEXT_ARG();
+			if (strcmp(*argv, "any"))
+				p->iph.daddr = get_addr32(*argv);
+		} else if (strcmp(*argv, "local") == 0) {
+			NEXT_ARG();
+			if (strcmp(*argv, "any"))
+				p->iph.saddr = get_addr32(*argv);
+		} else if (strcmp(*argv, "dev") == 0) {
+			NEXT_ARG();
+			strncpy(medium, *argv, IFNAMSIZ-1);
+		} else if (strcmp(*argv, "ttl") == 0) {
+			unsigned uval;
+			NEXT_ARG();
+			if (strcmp(*argv, "inherit") != 0) {
+				if (get_unsigned(&uval, *argv, 0))
+					invarg(*argv, "TTL");
+				if (uval > 255)
+					invarg(*argv, "TTL must be <=255");
+				p->iph.ttl = uval;
+			}
+		} else if (strcmp(*argv, "tos") == 0 ||
+			   matches(*argv, "dsfield") == 0) {
+			__u32 uval;
+			NEXT_ARG();
+			if (strcmp(*argv, "inherit") != 0) {
+				if (rtnl_dsfield_a2n(&uval, *argv))
+					invarg(*argv, "TOS");
+				p->iph.tos = uval;
+			} else
+				p->iph.tos = 1;
+		} else {
+			if (strcmp(*argv, "name") == 0) {
+				NEXT_ARG();
+			}
+			if (p->name[0])
+				duparg2("name", *argv);
+			strncpy(p->name, *argv, IFNAMSIZ);
+			if (cmd == SIOCCHGTUNNEL && count == 0) {
+				struct ip_tunnel_parm old_p;
+				memset(&old_p, 0, sizeof(old_p));
+				if (do_get_ioctl(*argv, &old_p))
+					return -1;
+				*p = old_p;
+			}
+		}
+		count++;
+		argc--; argv++;
+	}
+
+
+	if (p->iph.protocol == 0) {
+		if (memcmp(p->name, "gre", 3) == 0)
+			p->iph.protocol = IPPROTO_GRE;
+		else if (memcmp(p->name, "ipip", 4) == 0)
+			p->iph.protocol = IPPROTO_IPIP;
+		else if (memcmp(p->name, "sit", 3) == 0)
+			p->iph.protocol = IPPROTO_IPV6;
+	}
+
+	if (p->iph.protocol == IPPROTO_IPIP || p->iph.protocol == IPPROTO_IPV6) {
+		if ((p->i_flags & GRE_KEY) || (p->o_flags & GRE_KEY)) {
+			bb_error_msg("keys are not allowed with ipip and sit");
+			return -1;
+		}
+	}
+
+	if (medium[0]) {
+		p->link = do_ioctl_get_ifindex(medium);
+		if (p->link == 0)
+			return -1;
+	}
+
+	if (p->i_key == 0 && IN_MULTICAST(ntohl(p->iph.daddr))) {
+		p->i_key = p->iph.daddr;
+		p->i_flags |= GRE_KEY;
+	}
+	if (p->o_key == 0 && IN_MULTICAST(ntohl(p->iph.daddr))) {
+		p->o_key = p->iph.daddr;
+		p->o_flags |= GRE_KEY;
+	}
+	if (IN_MULTICAST(ntohl(p->iph.daddr)) && !p->iph.saddr) {
+		bb_error_msg("broadcast tunnel requires a source address");
+		return -1;
+	}
+	return 0;
+}
+
+
+static int do_add(int cmd, int argc, char **argv)
+{
+	struct ip_tunnel_parm p;
+
+	if (parse_args(argc, argv, cmd, &p) < 0)
+		return -1;
+
+	if (p.iph.ttl && p.iph.frag_off == 0) {
+		bb_error_msg("ttl != 0 and noptmudisc are incompatible");
+		return -1;
+	}
+
+	switch (p.iph.protocol) {
+	case IPPROTO_IPIP:
+		return do_add_ioctl(cmd, "tunl0", &p);
+	case IPPROTO_GRE:
+		return do_add_ioctl(cmd, "gre0", &p);
+	case IPPROTO_IPV6:
+		return do_add_ioctl(cmd, "sit0", &p);
+	default:
+		bb_error_msg("cannot determine tunnel mode (ipip, gre or sit)");
+		return -1;
+	}
+	return -1;
+}
+
+static int do_del(int argc, char **argv)
+{
+	struct ip_tunnel_parm p;
+
+	if (parse_args(argc, argv, SIOCDELTUNNEL, &p) < 0)
+		return -1;
+
+	switch (p.iph.protocol) {
+	case IPPROTO_IPIP:
+		return do_del_ioctl("tunl0", &p);
+	case IPPROTO_GRE:
+		return do_del_ioctl("gre0", &p);
+	case IPPROTO_IPV6:
+		return do_del_ioctl("sit0", &p);
+	default:
+		return do_del_ioctl(p.name, &p);
+	}
+	return -1;
+}
+
+static void print_tunnel(struct ip_tunnel_parm *p)
+{
+	char s1[256];
+	char s2[256];
+	char s3[64];
+	char s4[64];
+
+	format_host(AF_INET, 4, &p->iph.daddr, s1, sizeof(s1));
+	format_host(AF_INET, 4, &p->iph.saddr, s2, sizeof(s2));
+	inet_ntop(AF_INET, &p->i_key, s3, sizeof(s3));
+	inet_ntop(AF_INET, &p->o_key, s4, sizeof(s4));
+
+	printf("%s: %s/ip  remote %s  local %s ",
+	       p->name,
+	       p->iph.protocol == IPPROTO_IPIP ? "ip" :
+	       (p->iph.protocol == IPPROTO_GRE ? "gre" :
+		(p->iph.protocol == IPPROTO_IPV6 ? "ipv6" : "unknown")),
+	       p->iph.daddr ? s1 : "any", p->iph.saddr ? s2 : "any");
+	if (p->link) {
+		char *n = do_ioctl_get_ifname(p->link);
+		if (n)
+			printf(" dev %s ", n);
+	}
+	if (p->iph.ttl)
+		printf(" ttl %d ", p->iph.ttl);
+	else
+		printf(" ttl inherit ");
+	if (p->iph.tos) {
+		SPRINT_BUF(b1);
+		printf(" tos");
+		if (p->iph.tos&1)
+			printf(" inherit");
+		if (p->iph.tos&~1)
+			printf("%c%s ", p->iph.tos&1 ? '/' : ' ',
+			       rtnl_dsfield_n2a(p->iph.tos&~1, b1, sizeof(b1)));
+	}
+	if (!(p->iph.frag_off&htons(IP_DF)))
+		printf(" nopmtudisc");
+
+	if ((p->i_flags&GRE_KEY) && (p->o_flags&GRE_KEY) && p->o_key == p->i_key)
+		printf(" key %s", s3);
+	else if ((p->i_flags|p->o_flags)&GRE_KEY) {
+		if (p->i_flags&GRE_KEY)
+			printf(" ikey %s ", s3);
+		if (p->o_flags&GRE_KEY)
+			printf(" okey %s ", s4);
+	}
+
+	if (p->i_flags&GRE_SEQ)
+		printf("%s  Drop packets out of sequence.\n", _SL_);
+	if (p->i_flags&GRE_CSUM)
+		printf("%s  Checksum in received packet is required.", _SL_);
+	if (p->o_flags&GRE_SEQ)
+		printf("%s  Sequence packets on output.", _SL_);
+	if (p->o_flags&GRE_CSUM)
+		printf("%s  Checksum output packets.", _SL_);
+}
+
+static int do_tunnels_list(struct ip_tunnel_parm *p)
+{
+	char name[IFNAMSIZ];
+	unsigned long  rx_bytes, rx_packets, rx_errs, rx_drops,
+	rx_fifo, rx_frame,
+	tx_bytes, tx_packets, tx_errs, tx_drops,
+	tx_fifo, tx_colls, tx_carrier, rx_multi;
+	int type;
+	struct ip_tunnel_parm p1;
+
+	char buf[512];
+	FILE *fp = fopen("/proc/net/dev", "r");
+	if (fp == NULL) {
+		perror("fopen");
+		return -1;
+	}
+
+	fgets(buf, sizeof(buf), fp);
+	fgets(buf, sizeof(buf), fp);
+
+	while (fgets(buf, sizeof(buf), fp) != NULL) {
+		char *ptr;
+		buf[sizeof(buf) - 1] = 0;
+		if ((ptr = strchr(buf, ':')) == NULL ||
+		    (*ptr++ = 0, sscanf(buf, "%s", name) != 1)) {
+			bb_error_msg("wrong format of /proc/net/dev. Sorry");
+			return -1;
+		}
+		if (sscanf(ptr, "%lu%lu%lu%lu%lu%lu%lu%*d%lu%lu%lu%lu%lu%lu%lu",
+			   &rx_bytes, &rx_packets, &rx_errs, &rx_drops,
+			   &rx_fifo, &rx_frame, &rx_multi,
+			   &tx_bytes, &tx_packets, &tx_errs, &tx_drops,
+			   &tx_fifo, &tx_colls, &tx_carrier) != 14)
+			continue;
+		if (p->name[0] && strcmp(p->name, name))
+			continue;
+		type = do_ioctl_get_iftype(name);
+		if (type == -1) {
+			bb_error_msg("failed to get type of [%s]", name);
+			continue;
+		}
+		if (type != ARPHRD_TUNNEL && type != ARPHRD_IPGRE && type != ARPHRD_SIT)
+			continue;
+		memset(&p1, 0, sizeof(p1));
+		if (do_get_ioctl(name, &p1))
+			continue;
+		if ((p->link && p1.link != p->link) ||
+		    (p->name[0] && strcmp(p1.name, p->name)) ||
+		    (p->iph.daddr && p1.iph.daddr != p->iph.daddr) ||
+		    (p->iph.saddr && p1.iph.saddr != p->iph.saddr) ||
+		    (p->i_key && p1.i_key != p->i_key))
+			continue;
+		print_tunnel(&p1);
+		puts("");
+	}
+	return 0;
+}
+
+static int do_show(int argc, char **argv)
+{
+	int err;
+	struct ip_tunnel_parm p;
+
+	if (parse_args(argc, argv, SIOCGETTUNNEL, &p) < 0)
+		return -1;
+
+	switch (p.iph.protocol) {
+	case IPPROTO_IPIP:
+		err = do_get_ioctl(p.name[0] ? p.name : "tunl0", &p);
+		break;
+	case IPPROTO_GRE:
+		err = do_get_ioctl(p.name[0] ? p.name : "gre0", &p);
+		break;
+	case IPPROTO_IPV6:
+		err = do_get_ioctl(p.name[0] ? p.name : "sit0", &p);
+		break;
+	default:
+		do_tunnels_list(&p);
+		return 0;
+	}
+	if (err)
+		return -1;
+
+	print_tunnel(&p);
+	puts("");
+	return 0;
+}
+
+int do_iptunnel(int argc, char **argv)
+{
+	if (argc > 0) {
+		if (matches(*argv, "add") == 0)
+			return do_add(SIOCADDTUNNEL, argc-1, argv+1);
+		if (matches(*argv, "change") == 0)
+			return do_add(SIOCCHGTUNNEL, argc-1, argv+1);
+		if (matches(*argv, "del") == 0)
+			return do_del(argc-1, argv+1);
+		if (matches(*argv, "show") == 0 ||
+		    matches(*argv, "lst") == 0 ||
+		    matches(*argv, "list") == 0)
+			return do_show(argc-1, argv+1);
+	} else
+		return do_show(0, NULL);
+
+	bb_error_msg("command \"%s\" is unknown", *argv);
+	exit(-1);
+}
diff --git a/networking/libiproute/libnetlink.c b/networking/libiproute/libnetlink.c
new file mode 100644
index 0000000..c7e17e1
--- /dev/null
+++ b/networking/libiproute/libnetlink.c
@@ -0,0 +1,396 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * libnetlink.c	RTnetlink service routines.
+ *
+ *		This program is free software; you can redistribute it and/or
+ *		modify it under the terms of the GNU General Public License
+ *		as published by the Free Software Foundation; either version
+ *		2 of the License, or (at your option) any later version.
+ *
+ * Authors:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
+ *
+ */
+
+#include "libbb.h"
+#include <sys/socket.h>
+
+#include <errno.h>
+#include <string.h>
+#include <time.h>
+#include <unistd.h>
+
+#include <sys/uio.h>
+
+#include "libnetlink.h"
+
+void rtnl_close(struct rtnl_handle *rth)
+{
+	close(rth->fd);
+}
+
+int rtnl_open(struct rtnl_handle *rth, unsigned subscriptions)
+{
+	socklen_t addr_len;
+
+	memset(rth, 0, sizeof(rth));
+
+	rth->fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
+	if (rth->fd < 0) {
+		bb_perror_msg("cannot open netlink socket");
+		return -1;
+	}
+
+	memset(&rth->local, 0, sizeof(rth->local));
+	rth->local.nl_family = AF_NETLINK;
+	rth->local.nl_groups = subscriptions;
+
+	if (bind(rth->fd, (struct sockaddr*)&rth->local, sizeof(rth->local)) < 0) {
+		bb_perror_msg("cannot bind netlink socket");
+		return -1;
+	}
+	addr_len = sizeof(rth->local);
+	if (getsockname(rth->fd, (struct sockaddr*)&rth->local, &addr_len) < 0) {
+		bb_perror_msg("cannot getsockname");
+		return -1;
+	}
+	if (addr_len != sizeof(rth->local)) {
+		bb_error_msg("wrong address length %d", addr_len);
+		return -1;
+	}
+	if (rth->local.nl_family != AF_NETLINK) {
+		bb_error_msg("wrong address family %d", rth->local.nl_family);
+		return -1;
+	}
+	rth->seq = time(NULL);
+	return 0;
+}
+
+int rtnl_wilddump_request(struct rtnl_handle *rth, int family, int type)
+{
+	struct {
+		struct nlmsghdr nlh;
+		struct rtgenmsg g;
+	} req;
+	struct sockaddr_nl nladdr;
+
+	memset(&nladdr, 0, sizeof(nladdr));
+	nladdr.nl_family = AF_NETLINK;
+
+	req.nlh.nlmsg_len = sizeof(req);
+	req.nlh.nlmsg_type = type;
+	req.nlh.nlmsg_flags = NLM_F_ROOT|NLM_F_MATCH|NLM_F_REQUEST;
+	req.nlh.nlmsg_pid = 0;
+	req.nlh.nlmsg_seq = rth->dump = ++rth->seq;
+	req.g.rtgen_family = family;
+
+	return sendto(rth->fd, (void*)&req, sizeof(req), 0, (struct sockaddr*)&nladdr, sizeof(nladdr));
+}
+
+int rtnl_send(struct rtnl_handle *rth, char *buf, int len)
+{
+	struct sockaddr_nl nladdr;
+
+	memset(&nladdr, 0, sizeof(nladdr));
+	nladdr.nl_family = AF_NETLINK;
+
+	return sendto(rth->fd, buf, len, 0, (struct sockaddr*)&nladdr, sizeof(nladdr));
+}
+
+int rtnl_dump_request(struct rtnl_handle *rth, int type, void *req, int len)
+{
+	struct nlmsghdr nlh;
+	struct sockaddr_nl nladdr;
+	struct iovec iov[2] = { { &nlh, sizeof(nlh) }, { req, len } };
+	struct msghdr msg = {
+		(void*)&nladdr, sizeof(nladdr),
+		iov,	2,
+		NULL,	0,
+		0
+	};
+
+	memset(&nladdr, 0, sizeof(nladdr));
+	nladdr.nl_family = AF_NETLINK;
+
+	nlh.nlmsg_len = NLMSG_LENGTH(len);
+	nlh.nlmsg_type = type;
+	nlh.nlmsg_flags = NLM_F_ROOT|NLM_F_MATCH|NLM_F_REQUEST;
+	nlh.nlmsg_pid = 0;
+	nlh.nlmsg_seq = rth->dump = ++rth->seq;
+
+	return sendmsg(rth->fd, &msg, 0);
+}
+
+int rtnl_dump_filter(struct rtnl_handle *rth,
+		int (*filter)(struct sockaddr_nl *, struct nlmsghdr *n, void *),
+		void *arg1,
+		int (*junk)(struct sockaddr_nl *, struct nlmsghdr *n, void *),
+		void *arg2)
+{
+	char buf[8192];
+	struct sockaddr_nl nladdr;
+	struct iovec iov = { buf, sizeof(buf) };
+
+	while (1) {
+		int status;
+		struct nlmsghdr *h;
+
+		struct msghdr msg = {
+			(void*)&nladdr, sizeof(nladdr),
+			&iov,	1,
+			NULL,	0,
+			0
+		};
+
+		status = recvmsg(rth->fd, &msg, 0);
+
+		if (status < 0) {
+			if (errno == EINTR)
+				continue;
+			bb_perror_msg("OVERRUN");
+			continue;
+		}
+		if (status == 0) {
+			bb_error_msg("EOF on netlink");
+			return -1;
+		}
+		if (msg.msg_namelen != sizeof(nladdr)) {
+			bb_error_msg_and_die("sender address length == %d", msg.msg_namelen);
+		}
+
+		h = (struct nlmsghdr*)buf;
+		while (NLMSG_OK(h, status)) {
+			int err;
+
+			if (nladdr.nl_pid != 0 ||
+			    h->nlmsg_pid != rth->local.nl_pid ||
+			    h->nlmsg_seq != rth->dump) {
+				if (junk) {
+					err = junk(&nladdr, h, arg2);
+					if (err < 0) {
+						return err;
+					}
+				}
+				goto skip_it;
+			}
+
+			if (h->nlmsg_type == NLMSG_DONE) {
+				return 0;
+			}
+			if (h->nlmsg_type == NLMSG_ERROR) {
+				struct nlmsgerr *l_err = (struct nlmsgerr*)NLMSG_DATA(h);
+				if (h->nlmsg_len < NLMSG_LENGTH(sizeof(struct nlmsgerr))) {
+					bb_error_msg("ERROR truncated");
+				} else {
+					errno = -l_err->error;
+					bb_perror_msg("RTNETLINK answers");
+				}
+				return -1;
+			}
+			err = filter(&nladdr, h, arg1);
+			if (err < 0) {
+				return err;
+			}
+
+skip_it:
+			h = NLMSG_NEXT(h, status);
+		}
+		if (msg.msg_flags & MSG_TRUNC) {
+			bb_error_msg("message truncated");
+			continue;
+		}
+		if (status) {
+			bb_error_msg_and_die("remnant of size %d!", status);
+		}
+	}
+}
+
+int rtnl_talk(struct rtnl_handle *rtnl, struct nlmsghdr *n, pid_t peer,
+	      unsigned groups, struct nlmsghdr *answer,
+	      int (*junk)(struct sockaddr_nl *,struct nlmsghdr *n, void *),
+	      void *jarg)
+{
+	int status;
+	unsigned seq;
+	struct nlmsghdr *h;
+	struct sockaddr_nl nladdr;
+	struct iovec iov = { (void*)n, n->nlmsg_len };
+	char   buf[8192];
+	struct msghdr msg = {
+		(void*)&nladdr, sizeof(nladdr),
+		&iov,	1,
+		NULL,	0,
+		0
+	};
+
+	memset(&nladdr, 0, sizeof(nladdr));
+	nladdr.nl_family = AF_NETLINK;
+	nladdr.nl_pid = peer;
+	nladdr.nl_groups = groups;
+
+	n->nlmsg_seq = seq = ++rtnl->seq;
+	if (answer == NULL) {
+		n->nlmsg_flags |= NLM_F_ACK;
+	}
+	status = sendmsg(rtnl->fd, &msg, 0);
+
+	if (status < 0) {
+		bb_perror_msg("cannot talk to rtnetlink");
+		return -1;
+	}
+
+	iov.iov_base = buf;
+
+	while (1) {
+		iov.iov_len = sizeof(buf);
+		status = recvmsg(rtnl->fd, &msg, 0);
+
+		if (status < 0) {
+			if (errno == EINTR) {
+				continue;
+			}
+			bb_perror_msg("OVERRUN");
+			continue;
+		}
+		if (status == 0) {
+			bb_error_msg("EOF on netlink");
+			return -1;
+		}
+		if (msg.msg_namelen != sizeof(nladdr)) {
+			bb_error_msg_and_die("sender address length == %d", msg.msg_namelen);
+		}
+		for (h = (struct nlmsghdr*)buf; status >= sizeof(*h); ) {
+			int l_err;
+			int len = h->nlmsg_len;
+			int l = len - sizeof(*h);
+
+			if (l<0 || len>status) {
+				if (msg.msg_flags & MSG_TRUNC) {
+					bb_error_msg("truncated message");
+					return -1;
+				}
+				bb_error_msg_and_die("malformed message: len=%d!", len);
+			}
+
+			if (nladdr.nl_pid != peer ||
+			    h->nlmsg_pid != rtnl->local.nl_pid ||
+			    h->nlmsg_seq != seq) {
+				if (junk) {
+					l_err = junk(&nladdr, h, jarg);
+					if (l_err < 0) {
+						return l_err;
+					}
+				}
+				continue;
+			}
+
+			if (h->nlmsg_type == NLMSG_ERROR) {
+				struct nlmsgerr *err = (struct nlmsgerr*)NLMSG_DATA(h);
+				if (l < sizeof(struct nlmsgerr)) {
+					bb_error_msg("ERROR truncated");
+				} else {
+					errno = -err->error;
+					if (errno == 0) {
+						if (answer) {
+							memcpy(answer, h, h->nlmsg_len);
+						}
+						return 0;
+					}
+					bb_perror_msg("RTNETLINK answers");
+				}
+				return -1;
+			}
+			if (answer) {
+				memcpy(answer, h, h->nlmsg_len);
+				return 0;
+			}
+
+			bb_error_msg("unexpected reply!");
+
+			status -= NLMSG_ALIGN(len);
+			h = (struct nlmsghdr*)((char*)h + NLMSG_ALIGN(len));
+		}
+		if (msg.msg_flags & MSG_TRUNC) {
+			bb_error_msg("message truncated");
+			continue;
+		}
+		if (status) {
+			bb_error_msg_and_die("remnant of size %d!", status);
+		}
+	}
+}
+
+int addattr32(struct nlmsghdr *n, int maxlen, int type, __u32 data)
+{
+	int len = RTA_LENGTH(4);
+	struct rtattr *rta;
+	if (NLMSG_ALIGN(n->nlmsg_len) + len > maxlen)
+		return -1;
+	rta = (struct rtattr*)(((char*)n) + NLMSG_ALIGN(n->nlmsg_len));
+	rta->rta_type = type;
+	rta->rta_len = len;
+	memcpy(RTA_DATA(rta), &data, 4);
+	n->nlmsg_len = NLMSG_ALIGN(n->nlmsg_len) + len;
+	return 0;
+}
+
+int addattr_l(struct nlmsghdr *n, int maxlen, int type, void *data, int alen)
+{
+	int len = RTA_LENGTH(alen);
+	struct rtattr *rta;
+
+	if (NLMSG_ALIGN(n->nlmsg_len) + len > maxlen)
+		return -1;
+	rta = (struct rtattr*)(((char*)n) + NLMSG_ALIGN(n->nlmsg_len));
+	rta->rta_type = type;
+	rta->rta_len = len;
+	memcpy(RTA_DATA(rta), data, alen);
+	n->nlmsg_len = NLMSG_ALIGN(n->nlmsg_len) + len;
+	return 0;
+}
+
+int rta_addattr32(struct rtattr *rta, int maxlen, int type, __u32 data)
+{
+	int len = RTA_LENGTH(4);
+	struct rtattr *subrta;
+
+	if (RTA_ALIGN(rta->rta_len) + len > maxlen) {
+		return -1;
+	}
+	subrta = (struct rtattr*)(((char*)rta) + RTA_ALIGN(rta->rta_len));
+	subrta->rta_type = type;
+	subrta->rta_len = len;
+	memcpy(RTA_DATA(subrta), &data, 4);
+	rta->rta_len = NLMSG_ALIGN(rta->rta_len) + len;
+	return 0;
+}
+
+int rta_addattr_l(struct rtattr *rta, int maxlen, int type, void *data, int alen)
+{
+	struct rtattr *subrta;
+	int len = RTA_LENGTH(alen);
+
+	if (RTA_ALIGN(rta->rta_len) + len > maxlen) {
+		return -1;
+	}
+	subrta = (struct rtattr*)(((char*)rta) + RTA_ALIGN(rta->rta_len));
+	subrta->rta_type = type;
+	subrta->rta_len = len;
+	memcpy(RTA_DATA(subrta), data, alen);
+	rta->rta_len = NLMSG_ALIGN(rta->rta_len) + len;
+	return 0;
+}
+
+
+int parse_rtattr(struct rtattr *tb[], int max, struct rtattr *rta, int len)
+{
+	while (RTA_OK(rta, len)) {
+		if (rta->rta_type <= max) {
+			tb[rta->rta_type] = rta;
+		}
+		rta = RTA_NEXT(rta,len);
+	}
+	if (len) {
+		bb_error_msg("deficit %d, rta_len=%d!", len, rta->rta_len);
+	}
+	return 0;
+}
diff --git a/networking/libiproute/libnetlink.h b/networking/libiproute/libnetlink.h
new file mode 100644
index 0000000..7cfcd20
--- /dev/null
+++ b/networking/libiproute/libnetlink.h
@@ -0,0 +1,43 @@
+/* vi: set sw=4 ts=4: */
+#ifndef __LIBNETLINK_H__
+#define __LIBNETLINK_H__ 1
+
+#include <asm/types.h>
+#include <linux/netlink.h>
+#include <linux/rtnetlink.h>
+
+struct rtnl_handle
+{
+	int			fd;
+	struct sockaddr_nl	local;
+	struct sockaddr_nl	peer;
+	__u32			seq;
+	__u32			dump;
+};
+
+extern int rtnl_open(struct rtnl_handle *rth, unsigned subscriptions);
+extern void rtnl_close(struct rtnl_handle *rth);
+extern int rtnl_wilddump_request(struct rtnl_handle *rth, int fam, int type);
+extern int rtnl_dump_request(struct rtnl_handle *rth, int type, void *req, int len);
+extern int rtnl_dump_filter(struct rtnl_handle *rth,
+			int (*filter)(struct sockaddr_nl*, struct nlmsghdr *n, void*),
+			void *arg1,
+			int (*junk)(struct sockaddr_nl *, struct nlmsghdr *n, void *),
+			void *arg2);
+extern int rtnl_talk(struct rtnl_handle *rtnl, struct nlmsghdr *n, pid_t peer,
+			unsigned groups, struct nlmsghdr *answer,
+			int (*junk)(struct sockaddr_nl *,struct nlmsghdr *n, void *),
+			void *jarg);
+extern int rtnl_send(struct rtnl_handle *rth, char *buf, int);
+
+
+extern int addattr32(struct nlmsghdr *n, int maxlen, int type, __u32 data);
+extern int addattr_l(struct nlmsghdr *n, int maxlen, int type, void *data, int alen);
+extern int rta_addattr32(struct rtattr *rta, int maxlen, int type, __u32 data);
+extern int rta_addattr_l(struct rtattr *rta, int maxlen, int type, void *data, int alen);
+
+extern int parse_rtattr(struct rtattr *tb[], int max, struct rtattr *rta, int len);
+
+
+#endif /* __LIBNETLINK_H__ */
+
diff --git a/networking/libiproute/linux/pkt_sched.h b/networking/libiproute/linux/pkt_sched.h
new file mode 100644
index 0000000..d6cf1fc
--- /dev/null
+++ b/networking/libiproute/linux/pkt_sched.h
@@ -0,0 +1,414 @@
+/* vi: set sw=4 ts=4: */
+#ifndef __LINUX_PKT_SCHED_H
+#define __LINUX_PKT_SCHED_H
+
+/* Logical priority bands not depending on specific packet scheduler.
+   Every scheduler will map them to real traffic classes, if it has
+   no more precise mechanism to classify packets.
+
+   These numbers have no special meaning, though their coincidence
+   with obsolete IPv6 values is not occasional :-). New IPv6 drafts
+   preferred full anarchy inspired by diffserv group.
+
+   Note: TC_PRIO_BESTEFFORT does not mean that it is the most unhappy
+   class, actually, as rule it will be handled with more care than
+   filler or even bulk.
+ */
+
+#include <asm/types.h>
+
+#define TC_PRIO_BESTEFFORT		0
+#define TC_PRIO_FILLER			1
+#define TC_PRIO_BULK			2
+#define TC_PRIO_INTERACTIVE_BULK	4
+#define TC_PRIO_INTERACTIVE		6
+#define TC_PRIO_CONTROL			7
+
+#define TC_PRIO_MAX			15
+
+/* Generic queue statistics, available for all the elements.
+   Particular schedulers may have also their private records.
+ */
+
+struct tc_stats
+{
+	__u64	bytes;			/* NUmber of enqueues bytes */
+	__u32	packets;		/* Number of enqueued packets	*/
+	__u32	drops;			/* Packets dropped because of lack of resources */
+	__u32	overlimits;		/* Number of throttle events when this
+					 * flow goes out of allocated bandwidth */
+	__u32	bps;			/* Current flow byte rate */
+	__u32	pps;			/* Current flow packet rate */
+	__u32	qlen;
+	__u32	backlog;
+#ifdef __KERNEL__
+	spinlock_t *lock;
+#endif
+};
+
+struct tc_estimator
+{
+	char		interval;
+	unsigned char	ewma_log;
+};
+
+/* "Handles"
+   ---------
+
+    All the traffic control objects have 32bit identifiers, or "handles".
+
+    They can be considered as opaque numbers from user API viewpoint,
+    but actually they always consist of two fields: major and
+    minor numbers, which are interpreted by kernel specially,
+    that may be used by applications, though not recommended.
+
+    F.e. qdisc handles always have minor number equal to zero,
+    classes (or flows) have major equal to parent qdisc major, and
+    minor uniquely identifying class inside qdisc.
+
+    Macros to manipulate handles:
+ */
+
+#define TC_H_MAJ_MASK (0xFFFF0000U)
+#define TC_H_MIN_MASK (0x0000FFFFU)
+#define TC_H_MAJ(h) ((h)&TC_H_MAJ_MASK)
+#define TC_H_MIN(h) ((h)&TC_H_MIN_MASK)
+#define TC_H_MAKE(maj,min) (((maj)&TC_H_MAJ_MASK)|((min)&TC_H_MIN_MASK))
+
+#define TC_H_UNSPEC	(0U)
+#define TC_H_ROOT	(0xFFFFFFFFU)
+#define TC_H_INGRESS    (0xFFFFFFF1U)
+
+struct tc_ratespec
+{
+	unsigned char	cell_log;
+	unsigned char	__reserved;
+	unsigned short	feature;
+	short		addend;
+	unsigned short	mpu;
+	__u32		rate;
+};
+
+/* FIFO section */
+
+struct tc_fifo_qopt
+{
+	__u32	limit;	/* Queue length: bytes for bfifo, packets for pfifo */
+};
+
+/* PRIO section */
+
+#define TCQ_PRIO_BANDS	16
+
+struct tc_prio_qopt
+{
+	int	bands;			/* Number of bands */
+	__u8	priomap[TC_PRIO_MAX+1];	/* Map: logical priority -> PRIO band */
+};
+
+/* CSZ section */
+
+struct tc_csz_qopt
+{
+	int		flows;		/* Maximal number of guaranteed flows */
+	unsigned char	R_log;		/* Fixed point position for round number */
+	unsigned char	delta_log;	/* Log of maximal managed time interval */
+	__u8		priomap[TC_PRIO_MAX+1];	/* Map: logical priority -> CSZ band */
+};
+
+struct tc_csz_copt
+{
+	struct tc_ratespec slice;
+	struct tc_ratespec rate;
+	struct tc_ratespec peakrate;
+	__u32		limit;
+	__u32		buffer;
+	__u32		mtu;
+};
+
+enum
+{
+	TCA_CSZ_UNSPEC,
+	TCA_CSZ_PARMS,
+	TCA_CSZ_RTAB,
+	TCA_CSZ_PTAB,
+};
+
+/* TBF section */
+
+struct tc_tbf_qopt
+{
+	struct tc_ratespec rate;
+	struct tc_ratespec peakrate;
+	__u32		limit;
+	__u32		buffer;
+	__u32		mtu;
+};
+
+enum
+{
+	TCA_TBF_UNSPEC,
+	TCA_TBF_PARMS,
+	TCA_TBF_RTAB,
+	TCA_TBF_PTAB,
+};
+
+
+/* TEQL section */
+
+/* TEQL does not require any parameters */
+
+/* SFQ section */
+
+struct tc_sfq_qopt
+{
+	unsigned	quantum;	/* Bytes per round allocated to flow */
+	int		perturb_period;	/* Period of hash perturbation */
+	__u32		limit;		/* Maximal packets in queue */
+	unsigned	divisor;	/* Hash divisor  */
+	unsigned	flows;		/* Maximal number of flows  */
+};
+
+/*
+ *  NOTE: limit, divisor and flows are hardwired to code at the moment.
+ *
+ *	limit=flows=128, divisor=1024;
+ *
+ *	The only reason for this is efficiency, it is possible
+ *	to change these parameters in compile time.
+ */
+
+/* RED section */
+
+enum
+{
+	TCA_RED_UNSPEC,
+	TCA_RED_PARMS,
+	TCA_RED_STAB,
+};
+
+struct tc_red_qopt
+{
+	__u32		limit;		/* HARD maximal queue length (bytes)	*/
+	__u32		qth_min;	/* Min average length threshold (bytes) */
+	__u32		qth_max;	/* Max average length threshold (bytes) */
+	unsigned char   Wlog;		/* log(W)		*/
+	unsigned char   Plog;		/* log(P_max/(qth_max-qth_min))	*/
+	unsigned char   Scell_log;	/* cell size for idle damping */
+	unsigned char	flags;
+#define TC_RED_ECN	1
+};
+
+struct tc_red_xstats
+{
+	__u32           early;          /* Early drops */
+	__u32           pdrop;          /* Drops due to queue limits */
+	__u32           other;          /* Drops due to drop() calls */
+	__u32           marked;         /* Marked packets */
+};
+
+/* GRED section */
+
+#define MAX_DPs 16
+
+enum
+{
+       TCA_GRED_UNSPEC,
+       TCA_GRED_PARMS,
+       TCA_GRED_STAB,
+       TCA_GRED_DPS,
+};
+
+#define TCA_SET_OFF TCA_GRED_PARMS
+struct tc_gred_qopt
+{
+       __u32           limit;          /* HARD maximal queue length (bytes)
+*/
+       __u32           qth_min;        /* Min average length threshold (bytes)
+*/
+       __u32           qth_max;        /* Max average length threshold (bytes)
+*/
+       __u32           DP;             /* upto 2^32 DPs */
+       __u32           backlog;
+       __u32           qave;
+       __u32           forced;
+       __u32           early;
+       __u32           other;
+       __u32           pdrop;
+
+       unsigned char   Wlog;           /* log(W)               */
+       unsigned char   Plog;           /* log(P_max/(qth_max-qth_min)) */
+       unsigned char   Scell_log;      /* cell size for idle damping */
+       __u8            prio;		/* prio of this VQ */
+       __u32	packets;
+       __u32	bytesin;
+};
+/* gred setup */
+struct tc_gred_sopt
+{
+       __u32           DPs;
+       __u32           def_DP;
+       __u8            grio;
+};
+
+/* HTB section */
+#define TC_HTB_NUMPRIO		4
+#define TC_HTB_MAXDEPTH		4
+
+struct tc_htb_opt
+{
+	struct tc_ratespec	rate;
+	struct tc_ratespec	ceil;
+	__u32	buffer;
+	__u32	cbuffer;
+	__u32	quantum;	/* out only */
+	__u32	level;		/* out only */
+	__u8	prio;
+	__u8	injectd;	/* inject class distance */
+	__u8	pad[2];
+};
+struct tc_htb_glob
+{
+	__u32 rate2quantum;	/* bps->quantum divisor */
+	__u32 defcls;		/* default class number */
+	__u32 use_dcache;	/* use dequeue cache ? */
+	__u32 debug;		/* debug flags */
+
+
+	/* stats */
+	__u32 deq_rate;	/* dequeue rate */
+	__u32 utilz;	/* dequeue utilization */
+	__u32 trials;	/* deq_prio trials per dequeue */
+	__u32 dcache_hits;
+	__u32 direct_pkts; /* count of non shapped packets */
+};
+enum
+{
+	TCA_HTB_UNSPEC,
+	TCA_HTB_PARMS,
+	TCA_HTB_INIT,
+	TCA_HTB_CTAB,
+	TCA_HTB_RTAB,
+};
+struct tc_htb_xstats
+{
+	__u32 lends;
+	__u32 borrows;
+	__u32 giants;	/* too big packets (rate will not be accurate) */
+	__u32 injects;	/* how many times leaf used injected bw */
+	__u32 tokens;
+	__u32 ctokens;
+};
+
+/* CBQ section */
+
+#define TC_CBQ_MAXPRIO		8
+#define TC_CBQ_MAXLEVEL		8
+#define TC_CBQ_DEF_EWMA		5
+
+struct tc_cbq_lssopt
+{
+	unsigned char	change;
+	unsigned char	flags;
+#define TCF_CBQ_LSS_BOUNDED	1
+#define TCF_CBQ_LSS_ISOLATED	2
+	unsigned char	ewma_log;
+	unsigned char	level;
+#define TCF_CBQ_LSS_FLAGS	1
+#define TCF_CBQ_LSS_EWMA	2
+#define TCF_CBQ_LSS_MAXIDLE	4
+#define TCF_CBQ_LSS_MINIDLE	8
+#define TCF_CBQ_LSS_OFFTIME	0x10
+#define TCF_CBQ_LSS_AVPKT	0x20
+	__u32		maxidle;
+	__u32		minidle;
+	__u32		offtime;
+	__u32		avpkt;
+};
+
+struct tc_cbq_wrropt
+{
+	unsigned char	flags;
+	unsigned char	priority;
+	unsigned char	cpriority;
+	unsigned char	__reserved;
+	__u32		allot;
+	__u32		weight;
+};
+
+struct tc_cbq_ovl
+{
+	unsigned char	strategy;
+#define	TC_CBQ_OVL_CLASSIC	0
+#define	TC_CBQ_OVL_DELAY	1
+#define	TC_CBQ_OVL_LOWPRIO	2
+#define	TC_CBQ_OVL_DROP		3
+#define	TC_CBQ_OVL_RCLASSIC	4
+	unsigned char	priority2;
+	__u32		penalty;
+};
+
+struct tc_cbq_police
+{
+	unsigned char	police;
+	unsigned char	__res1;
+	unsigned short	__res2;
+};
+
+struct tc_cbq_fopt
+{
+	__u32		split;
+	__u32		defmap;
+	__u32		defchange;
+};
+
+struct tc_cbq_xstats
+{
+	__u32		borrows;
+	__u32		overactions;
+	__s32		avgidle;
+	__s32		undertime;
+};
+
+enum
+{
+	TCA_CBQ_UNSPEC,
+	TCA_CBQ_LSSOPT,
+	TCA_CBQ_WRROPT,
+	TCA_CBQ_FOPT,
+	TCA_CBQ_OVL_STRATEGY,
+	TCA_CBQ_RATE,
+	TCA_CBQ_RTAB,
+	TCA_CBQ_POLICE,
+};
+
+#define TCA_CBQ_MAX	TCA_CBQ_POLICE
+
+/* dsmark section */
+
+enum {
+	TCA_DSMARK_UNSPEC,
+	TCA_DSMARK_INDICES,
+	TCA_DSMARK_DEFAULT_INDEX,
+	TCA_DSMARK_SET_TC_INDEX,
+	TCA_DSMARK_MASK,
+	TCA_DSMARK_VALUE
+};
+
+#define TCA_DSMARK_MAX TCA_DSMARK_VALUE
+
+/* ATM  section */
+
+enum {
+	TCA_ATM_UNSPEC,
+	TCA_ATM_FD,		/* file/socket descriptor */
+	TCA_ATM_PTR,		/* pointer to descriptor - later */
+	TCA_ATM_HDR,		/* LL header */
+	TCA_ATM_EXCESS,		/* excess traffic class (0 for CLP)  */
+	TCA_ATM_ADDR,		/* PVC address (for output only) */
+	TCA_ATM_STATE		/* VC state (ATM_VS_*; for output only) */
+};
+
+#define TCA_ATM_MAX	TCA_ATM_STATE
+
+#endif
diff --git a/networking/libiproute/ll_addr.c b/networking/libiproute/ll_addr.c
new file mode 100644
index 0000000..ba0a65a
--- /dev/null
+++ b/networking/libiproute/ll_addr.c
@@ -0,0 +1,85 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * ll_addr.c
+ *
+ *		This program is free software; you can redistribute it and/or
+ *		modify it under the terms of the GNU General Public License
+ *		as published by the Free Software Foundation; either version
+ *		2 of the License, or (at your option) any later version.
+ *
+ * Authors:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
+ */
+
+#include "libbb.h"
+
+#include <string.h>
+#include <net/if_arp.h>
+
+#include "rt_names.h"
+#include "utils.h"
+
+
+const char *ll_addr_n2a(unsigned char *addr, int alen, int type, char *buf, int blen)
+{
+	int i;
+	int l;
+
+	if (alen == 4 &&
+	    (type == ARPHRD_TUNNEL || type == ARPHRD_SIT || type == ARPHRD_IPGRE)) {
+		return inet_ntop(AF_INET, addr, buf, blen);
+	}
+	l = 0;
+	for (i=0; i<alen; i++) {
+		if (i==0) {
+			snprintf(buf+l, blen, "%02x", addr[i]);
+			blen -= 2;
+			l += 2;
+		} else {
+			snprintf(buf+l, blen, ":%02x", addr[i]);
+			blen -= 3;
+			l += 3;
+		}
+	}
+	return buf;
+}
+
+int ll_addr_a2n(unsigned char *lladdr, int len, char *arg)
+{
+	if (strchr(arg, '.')) {
+		inet_prefix pfx;
+		if (get_addr_1(&pfx, arg, AF_INET)) {
+			bb_error_msg("\"%s\" is invalid lladdr", arg);
+			return -1;
+		}
+		if (len < 4) {
+			return -1;
+		}
+		memcpy(lladdr, pfx.data, 4);
+		return 4;
+	} else {
+		int i;
+
+		for (i=0; i<len; i++) {
+			int temp;
+			char *cp = strchr(arg, ':');
+			if (cp) {
+				*cp = 0;
+				cp++;
+			}
+			if (sscanf(arg, "%x", &temp) != 1) {
+				bb_error_msg("\"%s\" is invalid lladdr", arg);
+				return -1;
+			}
+			if (temp < 0 || temp > 255) {
+				bb_error_msg("\"%s\" is invalid lladdr", arg);
+				return -1;
+			}
+			lladdr[i] = temp;
+			if (!cp) {
+				break;
+			}
+			arg = cp;
+		}
+		return i+1;
+	}
+}
diff --git a/networking/libiproute/ll_map.c b/networking/libiproute/ll_map.c
new file mode 100644
index 0000000..a14fa4e
--- /dev/null
+++ b/networking/libiproute/ll_map.c
@@ -0,0 +1,186 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * ll_map.c
+ *
+ *		This program is free software; you can redistribute it and/or
+ *		modify it under the terms of the GNU General Public License
+ *		as published by the Free Software Foundation; either version
+ *		2 of the License, or (at your option) any later version.
+ *
+ * Authors:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
+ *
+ */
+
+#include "libbb.h"
+#include <string.h>
+
+#include "libnetlink.h"
+#include "ll_map.h"
+
+#include <sys/socket.h>	/* socket() */
+#include <net/if.h>	/* struct ifreq and co. */
+#include <sys/ioctl.h>	/* ioctl() & SIOCGIFINDEX */
+
+struct idxmap {
+	struct idxmap * next;
+	int		index;
+	int		type;
+	int		alen;
+	unsigned	flags;
+	unsigned char	addr[8];
+	char		name[16];
+};
+
+static struct idxmap *idxmap[16];
+
+int ll_remember_index(struct sockaddr_nl *who, struct nlmsghdr *n, void *arg)
+{
+	int h;
+	struct ifinfomsg *ifi = NLMSG_DATA(n);
+	struct idxmap *im, **imp;
+	struct rtattr *tb[IFLA_MAX+1];
+
+	if (n->nlmsg_type != RTM_NEWLINK)
+		return 0;
+
+	if (n->nlmsg_len < NLMSG_LENGTH(sizeof(ifi)))
+		return -1;
+
+
+	memset(tb, 0, sizeof(tb));
+	parse_rtattr(tb, IFLA_MAX, IFLA_RTA(ifi), IFLA_PAYLOAD(n));
+	if (tb[IFLA_IFNAME] == NULL)
+		return 0;
+
+	h = ifi->ifi_index&0xF;
+
+	for (imp=&idxmap[h]; (im=*imp)!=NULL; imp = &im->next)
+		if (im->index == ifi->ifi_index)
+			break;
+
+	if (im == NULL) {
+		im = xmalloc(sizeof(*im));
+		im->next = *imp;
+		im->index = ifi->ifi_index;
+		*imp = im;
+	}
+
+	im->type = ifi->ifi_type;
+	im->flags = ifi->ifi_flags;
+	if (tb[IFLA_ADDRESS]) {
+		int alen;
+		im->alen = alen = RTA_PAYLOAD(tb[IFLA_ADDRESS]);
+		if (alen > sizeof(im->addr))
+			alen = sizeof(im->addr);
+		memcpy(im->addr, RTA_DATA(tb[IFLA_ADDRESS]), alen);
+	} else {
+		im->alen = 0;
+		memset(im->addr, 0, sizeof(im->addr));
+	}
+	strcpy(im->name, RTA_DATA(tb[IFLA_IFNAME]));
+	return 0;
+}
+
+const char *ll_idx_n2a(int idx, char *buf)
+{
+	struct idxmap *im;
+
+	if (idx == 0)
+		return "*";
+	for (im = idxmap[idx&0xF]; im; im = im->next)
+		if (im->index == idx)
+			return im->name;
+	snprintf(buf, 16, "if%d", idx);
+	return buf;
+}
+
+
+const char *ll_index_to_name(int idx)
+{
+	static char nbuf[16];
+
+	return ll_idx_n2a(idx, nbuf);
+}
+
+int ll_index_to_type(int idx)
+{
+	struct idxmap *im;
+
+	if (idx == 0)
+		return -1;
+	for (im = idxmap[idx&0xF]; im; im = im->next)
+		if (im->index == idx)
+			return im->type;
+	return -1;
+}
+
+unsigned ll_index_to_flags(int idx)
+{
+	struct idxmap *im;
+
+	if (idx == 0)
+		return 0;
+
+	for (im = idxmap[idx&0xF]; im; im = im->next)
+		if (im->index == idx)
+			return im->flags;
+	return 0;
+}
+
+int ll_name_to_index(char *name)
+{
+	static char ncache[16];
+	static int icache;
+	struct idxmap *im;
+	int sock_fd;
+	int i;
+
+	if (name == NULL)
+		return 0;
+	if (icache && strcmp(name, ncache) == 0)
+		return icache;
+	for (i=0; i<16; i++) {
+		for (im = idxmap[i]; im; im = im->next) {
+			if (strcmp(im->name, name) == 0) {
+				icache = im->index;
+				strcpy(ncache, name);
+				return im->index;
+			}
+		}
+	}
+	/* We have not found the interface in our cache, but the kernel
+	 * may still know about it. One reason is that we may be using
+	 * module on-demand loading, which means that the kernel will
+	 * load the module and make the interface exist only when
+	 * we explicitely request it (check for dev_load() in net/core/dev.c).
+	 * I can think of other similar scenario, but they are less common...
+	 * Jean II */
+	sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
+	if (sock_fd) {
+		struct ifreq ifr;
+		int ret;
+		strncpy(ifr.ifr_name, name, IFNAMSIZ);
+		ifr.ifr_ifindex = -1;
+		ret = ioctl(sock_fd, SIOCGIFINDEX, &ifr);
+		close(sock_fd);
+		if (ret >= 0)
+			/* In theory, we should redump the interface list
+			 * to update our cache, this is left as an exercise
+			 * to the reader... Jean II */
+			return ifr.ifr_ifindex;
+	}
+	
+	return 0;
+}
+
+int ll_init_map(struct rtnl_handle *rth)
+{
+	if (rtnl_wilddump_request(rth, AF_UNSPEC, RTM_GETLINK) < 0) {
+		bb_perror_msg_and_die("cannot send dump request");
+	}
+
+	if (rtnl_dump_filter(rth, ll_remember_index, &idxmap, NULL, NULL) < 0) {
+		bb_error_msg_and_die("dump terminated");
+	}
+	return 0;
+}
diff --git a/networking/libiproute/ll_map.h b/networking/libiproute/ll_map.h
new file mode 100644
index 0000000..226d48f
--- /dev/null
+++ b/networking/libiproute/ll_map.h
@@ -0,0 +1,13 @@
+/* vi: set sw=4 ts=4: */
+#ifndef __LL_MAP_H__
+#define __LL_MAP_H__ 1
+
+extern int ll_remember_index(struct sockaddr_nl *who, struct nlmsghdr *n, void *arg);
+extern int ll_init_map(struct rtnl_handle *rth);
+extern int ll_name_to_index(char *name);
+extern const char *ll_index_to_name(int idx);
+extern const char *ll_idx_n2a(int idx, char *buf);
+extern int ll_index_to_type(int idx);
+extern unsigned ll_index_to_flags(int idx);
+
+#endif /* __LL_MAP_H__ */
diff --git a/networking/libiproute/ll_proto.c b/networking/libiproute/ll_proto.c
new file mode 100644
index 0000000..a3fe9d3
--- /dev/null
+++ b/networking/libiproute/ll_proto.c
@@ -0,0 +1,122 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * ll_proto.c
+ *
+ *		This program is free software; you can redistribute it and/or
+ *		modify it under the terms of the GNU General Public License
+ *		as published by the Free Software Foundation; either version
+ *		2 of the License, or (at your option) any later version.
+ *
+ * Authors:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
+ */
+
+#include "libbb.h"
+#include <string.h>
+
+#include "rt_names.h"
+#include "utils.h"
+
+#if __GLIBC__ >=2 && __GLIBC_MINOR__ >= 1
+#include <net/ethernet.h>
+#else
+#include <linux/if_ether.h>
+#endif
+
+#define __PF(f,n) { ETH_P_##f, #n },
+static struct {
+	int id;
+	char *name;
+} llproto_names[] = {
+__PF(LOOP,loop)
+__PF(PUP,pup)
+#ifdef ETH_P_PUPAT
+__PF(PUPAT,pupat)
+#endif
+__PF(IP,ip)
+__PF(X25,x25)
+__PF(ARP,arp)
+__PF(BPQ,bpq)
+#ifdef ETH_P_IEEEPUP
+__PF(IEEEPUP,ieeepup)
+#endif
+#ifdef ETH_P_IEEEPUPAT
+__PF(IEEEPUPAT,ieeepupat)
+#endif
+__PF(DEC,dec)
+__PF(DNA_DL,dna_dl)
+__PF(DNA_RC,dna_rc)
+__PF(DNA_RT,dna_rt)
+__PF(LAT,lat)
+__PF(DIAG,diag)
+__PF(CUST,cust)
+__PF(SCA,sca)
+__PF(RARP,rarp)
+__PF(ATALK,atalk)
+__PF(AARP,aarp)
+__PF(IPX,ipx)
+__PF(IPV6,ipv6)
+#ifdef ETH_P_PPP_DISC
+__PF(PPP_DISC,ppp_disc)
+#endif
+#ifdef ETH_P_PPP_SES
+__PF(PPP_SES,ppp_ses)
+#endif
+#ifdef ETH_P_ATMMPOA
+__PF(ATMMPOA,atmmpoa)
+#endif
+#ifdef ETH_P_ATMFATE
+__PF(ATMFATE,atmfate)
+#endif
+
+__PF(802_3,802_3)
+__PF(AX25,ax25)
+__PF(ALL,all)
+__PF(802_2,802_2)
+__PF(SNAP,snap)
+__PF(DDCMP,ddcmp)
+__PF(WAN_PPP,wan_ppp)
+__PF(PPP_MP,ppp_mp)
+__PF(LOCALTALK,localtalk)
+__PF(PPPTALK,ppptalk)
+__PF(TR_802_2,tr_802_2)
+__PF(MOBITEX,mobitex)
+__PF(CONTROL,control)
+__PF(IRDA,irda)
+#ifdef ETH_P_ECONET
+__PF(ECONET,econet)
+#endif
+
+{ 0x8100, "802.1Q" },
+{ ETH_P_IP, "ipv4" },
+};
+#undef __PF
+
+
+const char * ll_proto_n2a(unsigned short id, char *buf, int len)
+{
+	int i;
+
+	id = ntohs(id);
+
+	for (i=0; i<sizeof(llproto_names)/sizeof(llproto_names[0]); i++) {
+		 if (llproto_names[i].id == id)
+			return llproto_names[i].name;
+	}
+	snprintf(buf, len, "[%d]", id);
+	return buf;
+}
+
+int ll_proto_a2n(unsigned short *id, char *buf)
+{
+	int i;
+	for (i=0; i<sizeof(llproto_names)/sizeof(llproto_names[0]); i++) {
+		 if (strcasecmp(llproto_names[i].name, buf) == 0) {
+			 *id = htons(llproto_names[i].id);
+			 return 0;
+		 }
+	}
+	if (get_u16(id, buf, 0))
+		return -1;
+	*id = htons(*id);
+	return 0;
+}
diff --git a/networking/libiproute/ll_types.c b/networking/libiproute/ll_types.c
new file mode 100644
index 0000000..a53c894
--- /dev/null
+++ b/networking/libiproute/ll_types.c
@@ -0,0 +1,118 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * ll_types.c
+ *
+ *		This program is free software; you can redistribute it and/or
+ *		modify it under the terms of the GNU General Public License
+ *		as published by the Free Software Foundation; either version
+ *		2 of the License, or (at your option) any later version.
+ *
+ * Authors:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
+ */
+#include <stdio.h>
+#include <arpa/inet.h>
+
+#include <linux/if_arp.h>
+
+#include "rt_names.h"
+
+const char * ll_type_n2a(int type, char *buf, int len)
+{
+#define __PF(f,n) { ARPHRD_##f, #n },
+static struct {
+	int type;
+	char *name;
+} arphrd_names[] = {
+{ 0, "generic" },
+__PF(ETHER,ether)
+__PF(EETHER,eether)
+__PF(AX25,ax25)
+__PF(PRONET,pronet)
+__PF(CHAOS,chaos)
+#ifdef ARPHRD_IEEE802_TR
+__PF(IEEE802,ieee802)
+#else
+__PF(IEEE802,tr)
+#endif
+__PF(ARCNET,arcnet)
+__PF(APPLETLK,atalk)
+__PF(DLCI,dlci)
+#ifdef ARPHRD_ATM
+__PF(ATM,atm)
+#endif
+__PF(METRICOM,metricom)
+#ifdef ARPHRD_IEEE1394
+__PF(IEEE1394,ieee1394)
+#endif
+
+__PF(SLIP,slip)
+__PF(CSLIP,cslip)
+__PF(SLIP6,slip6)
+__PF(CSLIP6,cslip6)
+__PF(RSRVD,rsrvd)
+__PF(ADAPT,adapt)
+__PF(ROSE,rose)
+__PF(X25,x25)
+#ifdef ARPHRD_HWX25
+__PF(HWX25,hwx25)
+#endif
+__PF(PPP,ppp)
+__PF(HDLC,hdlc)
+__PF(LAPB,lapb)
+#ifdef ARPHRD_DDCMP
+__PF(DDCMP,ddcmp)
+__PF(RAWHDLC,rawhdlc)
+#endif
+
+__PF(TUNNEL,ipip)
+__PF(TUNNEL6,tunnel6)
+__PF(FRAD,frad)
+__PF(SKIP,skip)
+__PF(LOOPBACK,loopback)
+__PF(LOCALTLK,ltalk)
+__PF(FDDI,fddi)
+__PF(BIF,bif)
+__PF(SIT,sit)
+__PF(IPDDP,ip/ddp)
+__PF(IPGRE,gre)
+__PF(PIMREG,pimreg)
+__PF(HIPPI,hippi)
+__PF(ASH,ash)
+__PF(ECONET,econet)
+__PF(IRDA,irda)
+__PF(FCPP,fcpp)
+__PF(FCAL,fcal)
+__PF(FCPL,fcpl)
+__PF(FCFABRIC,fcfb0)
+__PF(FCFABRIC+1,fcfb1)
+__PF(FCFABRIC+2,fcfb2)
+__PF(FCFABRIC+3,fcfb3)
+__PF(FCFABRIC+4,fcfb4)
+__PF(FCFABRIC+5,fcfb5)
+__PF(FCFABRIC+6,fcfb6)
+__PF(FCFABRIC+7,fcfb7)
+__PF(FCFABRIC+8,fcfb8)
+__PF(FCFABRIC+9,fcfb9)
+__PF(FCFABRIC+10,fcfb10)
+__PF(FCFABRIC+11,fcfb11)
+__PF(FCFABRIC+12,fcfb12)
+#ifdef ARPHRD_IEEE802_TR
+__PF(IEEE802_TR,tr)
+#endif
+#ifdef ARPHRD_IEEE80211
+__PF(IEEE80211,ieee802.11)
+#endif
+#ifdef ARPHRD_VOID
+__PF(VOID,void)
+#endif
+};
+#undef __PF
+
+	int i;
+	for (i=0; i<sizeof(arphrd_names)/sizeof(arphrd_names[0]); i++) {
+		 if (arphrd_names[i].type == type)
+			return arphrd_names[i].name;
+	}
+	snprintf(buf, len, "[%d]", type);
+	return buf;
+}
diff --git a/networking/libiproute/rt_names.c b/networking/libiproute/rt_names.c
new file mode 100644
index 0000000..ed21fbe
--- /dev/null
+++ b/networking/libiproute/rt_names.c
@@ -0,0 +1,384 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * rt_names.c		rtnetlink names DB.
+ *
+ *		This program is free software; you can redistribute it and/or
+ *		modify it under the terms of the GNU General Public License
+ *		as published by the Free Software Foundation; either version
+ *		2 of the License, or (at your option) any later version.
+ *
+ * Authors:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <stdint.h>
+#include "rt_names.h"
+
+static void rtnl_tab_initialize(char *file, const char **tab, int size)
+{
+	char buf[512];
+	FILE *fp;
+
+	fp = fopen(file, "r");
+	if (!fp)
+		return;
+	while (fgets(buf, sizeof(buf), fp)) {
+		char *p = buf;
+		int id;
+		char namebuf[512];
+
+		while (*p == ' ' || *p == '\t')
+			p++;
+		if (*p == '#' || *p == '\n' || *p == 0)
+			continue;
+		if (sscanf(p, "0x%x %s\n", &id, namebuf) != 2 &&
+		    sscanf(p, "0x%x %s #", &id, namebuf) != 2 &&
+		    sscanf(p, "%d %s\n", &id, namebuf) != 2 &&
+		    sscanf(p, "%d %s #", &id, namebuf) != 2) {
+			fprintf(stderr, "Database %s is corrupted at %s\n",
+				file, p);
+			return;
+		}
+
+		if (id<0 || id>size)
+			continue;
+
+		tab[id] = strdup(namebuf);
+	}
+	fclose(fp);
+}
+
+
+static const char * rtnl_rtprot_tab[256] = {
+	"none",
+	"redirect",
+	"kernel",
+	"boot",
+	"static",
+	NULL,
+	NULL,
+	NULL,
+	"gated",
+	"ra",
+	"mrt",
+	"zebra",
+	"bird",
+};
+
+
+
+static int rtnl_rtprot_init;
+
+static void rtnl_rtprot_initialize(void)
+{
+	rtnl_rtprot_init = 1;
+	rtnl_tab_initialize("/etc/iproute2/rt_protos",
+			    rtnl_rtprot_tab, 256);
+}
+
+const char * rtnl_rtprot_n2a(int id, char *buf, int len)
+{
+	if (id<0 || id>=256) {
+		snprintf(buf, len, "%d", id);
+		return buf;
+	}
+	if (!rtnl_rtprot_tab[id]) {
+		if (!rtnl_rtprot_init)
+			rtnl_rtprot_initialize();
+	}
+	if (rtnl_rtprot_tab[id])
+		return rtnl_rtprot_tab[id];
+	snprintf(buf, len, "%d", id);
+	return buf;
+}
+
+int rtnl_rtprot_a2n(uint32_t *id, char *arg)
+{
+	static const char *cache = NULL;
+	static unsigned long res;
+	char *end;
+	int i;
+
+	if (cache && strcmp(cache, arg) == 0) {
+		*id = res;
+		return 0;
+	}
+
+	if (!rtnl_rtprot_init)
+		rtnl_rtprot_initialize();
+
+	for (i=0; i<256; i++) {
+		if (rtnl_rtprot_tab[i] &&
+		    strcmp(rtnl_rtprot_tab[i], arg) == 0) {
+			cache = rtnl_rtprot_tab[i];
+			res = i;
+			*id = res;
+			return 0;
+		}
+	}
+
+	res = strtoul(arg, &end, 0);
+	if (!end || end == arg || *end || res > 255)
+		return -1;
+	*id = res;
+	return 0;
+}
+
+
+
+static const char * rtnl_rtscope_tab[256] = {
+	"global",
+};
+
+static int rtnl_rtscope_init;
+
+static void rtnl_rtscope_initialize(void)
+{
+	rtnl_rtscope_init = 1;
+	rtnl_rtscope_tab[255] = "nowhere";
+	rtnl_rtscope_tab[254] = "host";
+	rtnl_rtscope_tab[253] = "link";
+	rtnl_rtscope_tab[200] = "site";
+	rtnl_tab_initialize("/etc/iproute2/rt_scopes",
+			    rtnl_rtscope_tab, 256);
+}
+
+const char * rtnl_rtscope_n2a(int id, char *buf, int len)
+{
+	if (id<0 || id>=256) {
+		snprintf(buf, len, "%d", id);
+		return buf;
+	}
+	if (!rtnl_rtscope_tab[id]) {
+		if (!rtnl_rtscope_init)
+			rtnl_rtscope_initialize();
+	}
+	if (rtnl_rtscope_tab[id])
+		return rtnl_rtscope_tab[id];
+	snprintf(buf, len, "%d", id);
+	return buf;
+}
+
+int rtnl_rtscope_a2n(uint32_t *id, char *arg)
+{
+	static const char *cache = NULL;
+	static unsigned long res;
+	char *end;
+	int i;
+
+	if (cache && strcmp(cache, arg) == 0) {
+		*id = res;
+		return 0;
+	}
+
+	if (!rtnl_rtscope_init)
+		rtnl_rtscope_initialize();
+
+	for (i=0; i<256; i++) {
+		if (rtnl_rtscope_tab[i] &&
+		    strcmp(rtnl_rtscope_tab[i], arg) == 0) {
+			cache = rtnl_rtscope_tab[i];
+			res = i;
+			*id = res;
+			return 0;
+		}
+	}
+
+	res = strtoul(arg, &end, 0);
+	if (!end || end == arg || *end || res > 255)
+		return -1;
+	*id = res;
+	return 0;
+}
+
+
+
+static const char * rtnl_rtrealm_tab[256] = {
+	"unknown",
+};
+
+static int rtnl_rtrealm_init;
+
+static void rtnl_rtrealm_initialize(void)
+{
+	rtnl_rtrealm_init = 1;
+	rtnl_tab_initialize("/etc/iproute2/rt_realms",
+			    rtnl_rtrealm_tab, 256);
+}
+
+int rtnl_rtrealm_a2n(uint32_t *id, char *arg)
+{
+	static const char *cache = NULL;
+	static unsigned long res;
+	char *end;
+	int i;
+
+	if (cache && strcmp(cache, arg) == 0) {
+		*id = res;
+		return 0;
+	}
+
+	if (!rtnl_rtrealm_init)
+		rtnl_rtrealm_initialize();
+
+	for (i=0; i<256; i++) {
+		if (rtnl_rtrealm_tab[i] &&
+		    strcmp(rtnl_rtrealm_tab[i], arg) == 0) {
+			cache = rtnl_rtrealm_tab[i];
+			res = i;
+			*id = res;
+			return 0;
+		}
+	}
+
+	res = strtoul(arg, &end, 0);
+	if (!end || end == arg || *end || res > 255)
+		return -1;
+	*id = res;
+	return 0;
+}
+
+#if ENABLE_FEATURE_IP_RULE
+const char * rtnl_rtrealm_n2a(int id, char *buf, int len)
+{
+	if (id<0 || id>=256) {
+		snprintf(buf, len, "%d", id);
+		return buf;
+	}
+	if (!rtnl_rtrealm_tab[id]) {
+		if (!rtnl_rtrealm_init)
+			rtnl_rtrealm_initialize();
+	}
+	if (rtnl_rtrealm_tab[id])
+		return rtnl_rtrealm_tab[id];
+	snprintf(buf, len, "%d", id);
+	return buf;
+}
+#endif
+
+static const char * rtnl_rtdsfield_tab[256] = {
+	"0",
+};
+
+static int rtnl_rtdsfield_init;
+
+static void rtnl_rtdsfield_initialize(void)
+{
+	rtnl_rtdsfield_init = 1;
+	rtnl_tab_initialize("/etc/iproute2/rt_dsfield",
+			    rtnl_rtdsfield_tab, 256);
+}
+
+const char * rtnl_dsfield_n2a(int id, char *buf, int len)
+{
+	if (id<0 || id>=256) {
+		snprintf(buf, len, "%d", id);
+		return buf;
+	}
+	if (!rtnl_rtdsfield_tab[id]) {
+		if (!rtnl_rtdsfield_init)
+			rtnl_rtdsfield_initialize();
+	}
+	if (rtnl_rtdsfield_tab[id])
+		return rtnl_rtdsfield_tab[id];
+	snprintf(buf, len, "0x%02x", id);
+	return buf;
+}
+
+
+int rtnl_dsfield_a2n(uint32_t *id, char *arg)
+{
+	static const char *cache = NULL;
+	static unsigned long res;
+	char *end;
+	int i;
+
+	if (cache && strcmp(cache, arg) == 0) {
+		*id = res;
+		return 0;
+	}
+
+	if (!rtnl_rtdsfield_init)
+		rtnl_rtdsfield_initialize();
+
+	for (i=0; i<256; i++) {
+		if (rtnl_rtdsfield_tab[i] &&
+		    strcmp(rtnl_rtdsfield_tab[i], arg) == 0) {
+			cache = rtnl_rtdsfield_tab[i];
+			res = i;
+			*id = res;
+			return 0;
+		}
+	}
+
+	res = strtoul(arg, &end, 16);
+	if (!end || end == arg || *end || res > 255)
+		return -1;
+	*id = res;
+	return 0;
+}
+
+#if ENABLE_FEATURE_IP_RULE
+static int rtnl_rttable_init;
+static const char * rtnl_rttable_tab[256] = {
+	"unspec",
+};
+static void rtnl_rttable_initialize(void)
+{
+	rtnl_rttable_init = 1;
+	rtnl_rttable_tab[255] = "local";
+	rtnl_rttable_tab[254] = "main";
+	rtnl_rttable_tab[253] = "default";
+	rtnl_tab_initialize("/etc/iproute2/rt_tables", rtnl_rttable_tab, 256);
+}
+
+const char *rtnl_rttable_n2a(int id, char *buf, int len)
+{
+	if (id < 0 || id >= 256) {
+		snprintf(buf, len, "%d", id);
+		return buf;
+	}
+	if (!rtnl_rttable_tab[id]) {
+		if (!rtnl_rttable_init)
+			rtnl_rttable_initialize();
+	}
+	if (rtnl_rttable_tab[id])
+		return rtnl_rttable_tab[id];
+	snprintf(buf, len, "%d", id);
+	return buf;
+}
+
+int rtnl_rttable_a2n(uint32_t * id, char *arg)
+{
+	static char *cache = NULL;
+	static unsigned long res;
+	char *end;
+	int i;
+
+	if (cache && strcmp(cache, arg) == 0) {
+		*id = res;
+		return 0;
+	}
+
+	if (!rtnl_rttable_init)
+		rtnl_rttable_initialize();
+
+	for (i = 0; i < 256; i++) {
+		if (rtnl_rttable_tab[i] && strcmp(rtnl_rttable_tab[i], arg) == 0) {
+			cache = (char*)rtnl_rttable_tab[i];
+			res = i;
+			*id = res;
+			return 0;
+		}
+	}
+
+	i = strtoul(arg, &end, 0);
+	if (!end || end == arg || *end || i > 255)
+		return -1;
+	*id = i;
+	return 0;
+}
+
+#endif
diff --git a/networking/libiproute/rt_names.h b/networking/libiproute/rt_names.h
new file mode 100644
index 0000000..92b807f
--- /dev/null
+++ b/networking/libiproute/rt_names.h
@@ -0,0 +1,29 @@
+/* vi: set sw=4 ts=4: */
+#ifndef RT_NAMES_H_
+#define RT_NAMES_H_ 1
+
+#include <stdint.h>
+
+extern const char* rtnl_rtprot_n2a(int id, char *buf, int len);
+extern const char* rtnl_rtscope_n2a(int id, char *buf, int len);
+extern const char* rtnl_rtrealm_n2a(int id, char *buf, int len);
+extern const char* rtnl_dsfield_n2a(int id, char *buf, int len);
+extern const char* rtnl_rttable_n2a(int id, char *buf, int len);
+extern int rtnl_rtprot_a2n(uint32_t *id, char *arg);
+extern int rtnl_rtscope_a2n(uint32_t *id, char *arg);
+extern int rtnl_rtrealm_a2n(uint32_t *id, char *arg);
+extern int rtnl_dsfield_a2n(uint32_t *id, char *arg);
+extern int rtnl_rttable_a2n(uint32_t *id, char *arg);
+
+
+extern const char * ll_type_n2a(int type, char *buf, int len);
+
+extern const char *ll_addr_n2a(unsigned char *addr, int alen, int type,
+				char *buf, int blen);
+extern int ll_addr_a2n(unsigned char *lladdr, int len, char *arg);
+
+extern const char * ll_proto_n2a(unsigned short id, char *buf, int len);
+extern int ll_proto_a2n(unsigned short *id, char *buf);
+
+
+#endif
diff --git a/networking/libiproute/rtm_map.c b/networking/libiproute/rtm_map.c
new file mode 100644
index 0000000..8aaee4b
--- /dev/null
+++ b/networking/libiproute/rtm_map.c
@@ -0,0 +1,111 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * rtm_map.c
+ *
+ *		This program is free software; you can redistribute it and/or
+ *		modify it under the terms of the GNU General Public License
+ *		as published by the Free Software Foundation; either version
+ *		2 of the License, or (at your option) any later version.
+ *
+ * Authors:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
+ *
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "rt_names.h"
+#include "utils.h"
+
+char *rtnl_rtntype_n2a(int id, char *buf, int len)
+{
+	switch (id) {
+	case RTN_UNSPEC:
+		return "none";
+	case RTN_UNICAST:
+		return "unicast";
+	case RTN_LOCAL:
+		return "local";
+	case RTN_BROADCAST:
+		return "broadcast";
+	case RTN_ANYCAST:
+		return "anycast";
+	case RTN_MULTICAST:
+		return "multicast";
+	case RTN_BLACKHOLE:
+		return "blackhole";
+	case RTN_UNREACHABLE:
+		return "unreachable";
+	case RTN_PROHIBIT:
+		return "prohibit";
+	case RTN_THROW:
+		return "throw";
+	case RTN_NAT:
+		return "nat";
+	case RTN_XRESOLVE:
+		return "xresolve";
+	default:
+		snprintf(buf, len, "%d", id);
+		return buf;
+	}
+}
+
+
+int rtnl_rtntype_a2n(int *id, char *arg)
+{
+	char *end;
+	unsigned long res;
+
+	if (strcmp(arg, "local") == 0)
+		res = RTN_LOCAL;
+	else if (strcmp(arg, "nat") == 0)
+		res = RTN_NAT;
+	else if (matches(arg, "broadcast") == 0 ||
+		 strcmp(arg, "brd") == 0)
+		res = RTN_BROADCAST;
+	else if (matches(arg, "anycast") == 0)
+		res = RTN_ANYCAST;
+	else if (matches(arg, "multicast") == 0)
+		res = RTN_MULTICAST;
+	else if (matches(arg, "prohibit") == 0)
+		res = RTN_PROHIBIT;
+	else if (matches(arg, "unreachable") == 0)
+		res = RTN_UNREACHABLE;
+	else if (matches(arg, "blackhole") == 0)
+		res = RTN_BLACKHOLE;
+	else if (matches(arg, "xresolve") == 0)
+		res = RTN_XRESOLVE;
+	else if (matches(arg, "unicast") == 0)
+		res = RTN_UNICAST;
+	else if (strcmp(arg, "throw") == 0)
+		res = RTN_THROW;
+	else {
+		res = strtoul(arg, &end, 0);
+		if (!end || end == arg || *end || res > 255)
+			return -1;
+	}
+	*id = res;
+	return 0;
+}
+
+int get_rt_realms(__u32 *realms, char *arg)
+{
+	__u32 realm = 0;
+	char *p = strchr(arg, '/');
+
+	*realms = 0;
+	if (p) {
+		*p = 0;
+		if (rtnl_rtrealm_a2n(realms, arg)) {
+			*p = '/';
+			return -1;
+		}
+		*realms <<= 16;
+		*p = '/';
+		arg = p+1;
+	}
+	if (*arg && rtnl_rtrealm_a2n(&realm, arg))
+		return -1;
+	*realms |= realm;
+	return 0;
+}
diff --git a/networking/libiproute/rtm_map.h b/networking/libiproute/rtm_map.h
new file mode 100644
index 0000000..1ffb940
--- /dev/null
+++ b/networking/libiproute/rtm_map.h
@@ -0,0 +1,11 @@
+/* vi: set sw=4 ts=4: */
+#ifndef __RTM_MAP_H__
+#define __RTM_MAP_H__ 1
+
+char *rtnl_rtntype_n2a(int id, char *buf, int len);
+int rtnl_rtntype_a2n(int *id, char *arg);
+
+int get_rt_realms(__u32 *realms, char *arg);
+
+
+#endif /* __RTM_MAP_H__ */
diff --git a/networking/libiproute/utils.c b/networking/libiproute/utils.c
new file mode 100644
index 0000000..fc6aff1
--- /dev/null
+++ b/networking/libiproute/utils.c
@@ -0,0 +1,354 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * utils.c
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ *
+ * Authors:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
+ *
+ * Changes:
+ *
+ * Rani Assaf <rani@magic.metawire.com> 980929:	resolve addresses
+ */
+
+#include "libbb.h"
+
+#include <string.h>
+#include <unistd.h>
+
+#include "utils.h"
+#include "inet_common.h"
+
+int get_integer(int *val, char *arg, int base)
+{
+	long res;
+	char *ptr;
+
+	if (!arg || !*arg)
+		return -1;
+	res = strtol(arg, &ptr, base);
+	if (!ptr || ptr == arg || *ptr || res > INT_MAX || res < INT_MIN)
+		return -1;
+	*val = res;
+	return 0;
+}
+
+int get_unsigned(unsigned *val, char *arg, int base)
+{
+	unsigned long res;
+	char *ptr;
+
+	if (!arg || !*arg)
+		return -1;
+	res = strtoul(arg, &ptr, base);
+	if (!ptr || ptr == arg || *ptr || res > UINT_MAX)
+		return -1;
+	*val = res;
+	return 0;
+}
+
+int get_u32(__u32 * val, char *arg, int base)
+{
+	unsigned long res;
+	char *ptr;
+
+	if (!arg || !*arg)
+		return -1;
+	res = strtoul(arg, &ptr, base);
+	if (!ptr || ptr == arg || *ptr || res > 0xFFFFFFFFUL)
+		return -1;
+	*val = res;
+	return 0;
+}
+
+int get_u16(__u16 * val, char *arg, int base)
+{
+	unsigned long res;
+	char *ptr;
+
+	if (!arg || !*arg)
+		return -1;
+	res = strtoul(arg, &ptr, base);
+	if (!ptr || ptr == arg || *ptr || res > 0xFFFF)
+		return -1;
+	*val = res;
+	return 0;
+}
+
+int get_u8(__u8 * val, char *arg, int base)
+{
+	unsigned long res;
+	char *ptr;
+
+	if (!arg || !*arg)
+		return -1;
+	res = strtoul(arg, &ptr, base);
+	if (!ptr || ptr == arg || *ptr || res > 0xFF)
+		return -1;
+	*val = res;
+	return 0;
+}
+
+int get_s16(__s16 * val, char *arg, int base)
+{
+	long res;
+	char *ptr;
+
+	if (!arg || !*arg)
+		return -1;
+	res = strtol(arg, &ptr, base);
+	if (!ptr || ptr == arg || *ptr || res > 0x7FFF || res < -0x8000)
+		return -1;
+	*val = res;
+	return 0;
+}
+
+int get_s8(__s8 * val, char *arg, int base)
+{
+	long res;
+	char *ptr;
+
+	if (!arg || !*arg)
+		return -1;
+	res = strtol(arg, &ptr, base);
+	if (!ptr || ptr == arg || *ptr || res > 0x7F || res < -0x80)
+		return -1;
+	*val = res;
+	return 0;
+}
+
+int get_addr_1(inet_prefix * addr, char *name, int family)
+{
+	char *cp;
+	unsigned char *ap = (unsigned char *) addr->data;
+	int i;
+
+	memset(addr, 0, sizeof(*addr));
+
+	if (strcmp(name, bb_str_default) == 0 ||
+		strcmp(name, "all") == 0 || strcmp(name, "any") == 0) {
+		addr->family = family;
+		addr->bytelen = (family == AF_INET6 ? 16 : 4);
+		addr->bitlen = -1;
+		return 0;
+	}
+
+	if (strchr(name, ':')) {
+		addr->family = AF_INET6;
+		if (family != AF_UNSPEC && family != AF_INET6)
+			return -1;
+		if (inet_pton(AF_INET6, name, addr->data) <= 0)
+			return -1;
+		addr->bytelen = 16;
+		addr->bitlen = -1;
+		return 0;
+	}
+
+	addr->family = AF_INET;
+	if (family != AF_UNSPEC && family != AF_INET)
+		return -1;
+	addr->bytelen = 4;
+	addr->bitlen = -1;
+	for (cp = name, i = 0; *cp; cp++) {
+		if (*cp <= '9' && *cp >= '0') {
+			ap[i] = 10 * ap[i] + (*cp - '0');
+			continue;
+		}
+		if (*cp == '.' && ++i <= 3)
+			continue;
+		return -1;
+	}
+	return 0;
+}
+
+int get_prefix_1(inet_prefix * dst, char *arg, int family)
+{
+	int err;
+	int plen;
+	char *slash;
+
+	memset(dst, 0, sizeof(*dst));
+
+	if (strcmp(arg, bb_str_default) == 0 || strcmp(arg, "any") == 0) {
+		dst->family = family;
+		dst->bytelen = 0;
+		dst->bitlen = 0;
+		return 0;
+	}
+
+	slash = strchr(arg, '/');
+	if (slash)
+		*slash = 0;
+	err = get_addr_1(dst, arg, family);
+	if (err == 0) {
+		switch (dst->family) {
+		case AF_INET6:
+			dst->bitlen = 128;
+			break;
+		default:
+		case AF_INET:
+			dst->bitlen = 32;
+		}
+		if (slash) {
+			if (get_integer(&plen, slash + 1, 0) || plen > dst->bitlen) {
+				err = -1;
+				goto done;
+			}
+			dst->bitlen = plen;
+		}
+	}
+  done:
+	if (slash)
+		*slash = '/';
+	return err;
+}
+
+int get_addr(inet_prefix * dst, char *arg, int family)
+{
+	if (family == AF_PACKET) {
+		bb_error_msg_and_die("\"%s\" may be inet address, but it is not allowed in this context", arg);
+	}
+	if (get_addr_1(dst, arg, family)) {
+		bb_error_msg_and_die("an inet address is expected rather than \"%s\"", arg);
+	}
+	return 0;
+}
+
+int get_prefix(inet_prefix * dst, char *arg, int family)
+{
+	if (family == AF_PACKET) {
+		bb_error_msg_and_die("\"%s\" may be inet address, but it is not allowed in this context", arg);
+	}
+	if (get_prefix_1(dst, arg, family)) {
+		bb_error_msg_and_die("an inet address is expected rather than \"%s\"", arg);
+	}
+	return 0;
+}
+
+__u32 get_addr32(char *name)
+{
+	inet_prefix addr;
+
+	if (get_addr_1(&addr, name, AF_INET)) {
+		bb_error_msg_and_die("an IP address is expected rather than \"%s\"", name);
+	}
+	return addr.data[0];
+}
+
+void incomplete_command(void)
+{
+	bb_error_msg("command line is not complete, try option \"help\"");
+	exit(-1);
+}
+
+void invarg(const char * const arg, const char * const opt)
+{
+	bb_error_msg(bb_msg_invalid_arg, arg, opt);
+	exit(-1);
+}
+
+void duparg(char *key, char *arg)
+{
+	bb_error_msg("duplicate \"%s\": \"%s\" is the second value", key, arg);
+	exit(-1);
+}
+
+void duparg2(char *key, char *arg)
+{
+	bb_error_msg("either \"%s\" is duplicate, or \"%s\" is garbage", key, arg);
+	exit(-1);
+}
+
+int matches(char *cmd, char *pattern)
+{
+	int len = strlen(cmd);
+
+	return strncmp(pattern, cmd, len);
+}
+
+int inet_addr_match(inet_prefix * a, inet_prefix * b, int bits)
+{
+	__u32 *a1 = a->data;
+	__u32 *a2 = b->data;
+	int words = bits >> 0x05;
+
+	bits &= 0x1f;
+
+	if (words)
+		if (memcmp(a1, a2, words << 2))
+			return -1;
+
+	if (bits) {
+		__u32 w1, w2;
+		__u32 mask;
+
+		w1 = a1[words];
+		w2 = a2[words];
+
+		mask = htonl((0xffffffff) << (0x20 - bits));
+
+		if ((w1 ^ w2) & mask)
+			return 1;
+	}
+
+	return 0;
+}
+
+int __iproute2_hz_internal;
+
+int __get_hz(void)
+{
+	int hz = 0;
+	FILE *fp = fopen("/proc/net/psched", "r");
+
+	if (fp) {
+		unsigned nom, denom;
+
+		if (fscanf(fp, "%*08x%*08x%08x%08x", &nom, &denom) == 2)
+			if (nom == 1000000)
+				hz = denom;
+		fclose(fp);
+	}
+	if (hz)
+		return hz;
+	return sysconf(_SC_CLK_TCK);
+}
+
+const char *rt_addr_n2a(int af, int ATTRIBUTE_UNUSED len,
+		void *addr, char *buf, int buflen)
+{
+	switch (af) {
+	case AF_INET:
+	case AF_INET6:
+		return inet_ntop(af, addr, buf, buflen);
+	default:
+		return "???";
+	}
+}
+
+
+const char *format_host(int af, int len, void *addr, char *buf, int buflen)
+{
+#ifdef RESOLVE_HOSTNAMES
+	if (resolve_hosts) {
+		struct hostent *h_ent;
+
+		if (len <= 0) {
+			switch (af) {
+			case AF_INET:
+				len = 4;
+				break;
+			case AF_INET6:
+				len = 16;
+				break;
+			default:;
+			}
+		}
+		if (len > 0 && (h_ent = gethostbyaddr(addr, len, af)) != NULL) {
+			snprintf(buf, buflen - 1, "%s", h_ent->h_name);
+			return buf;
+		}
+	}
+#endif
+	return rt_addr_n2a(af, len, addr, buf, buflen);
+}
diff --git a/networking/libiproute/utils.h b/networking/libiproute/utils.h
new file mode 100644
index 0000000..0b0d754
--- /dev/null
+++ b/networking/libiproute/utils.h
@@ -0,0 +1,103 @@
+/* vi: set sw=4 ts=4: */
+#ifndef __UTILS_H__
+#define __UTILS_H__ 1
+
+#include "libbb.h"
+#include <asm/types.h>
+#include <resolv.h>
+
+#include "libnetlink.h"
+#include "ll_map.h"
+#include "rtm_map.h"
+
+extern int preferred_family;
+extern int show_stats;
+extern int show_details;
+extern int show_raw;
+extern int resolve_hosts;
+extern int oneline;
+extern char * _SL_;
+
+#ifndef IPPROTO_ESP
+#define IPPROTO_ESP	50
+#endif
+#ifndef IPPROTO_AH
+#define IPPROTO_AH	51
+#endif
+
+#define SPRINT_BSIZE 64
+#define SPRINT_BUF(x)	char x[SPRINT_BSIZE]
+
+extern void incomplete_command(void) ATTRIBUTE_NORETURN;
+
+#define NEXT_ARG() do { argv++; if (--argc <= 0) incomplete_command(); } while(0)
+
+typedef struct
+{
+	__u8 family;
+	__u8 bytelen;
+	__s16 bitlen;
+	__u32 data[4];
+} inet_prefix;
+
+#define DN_MAXADDL 20
+#ifndef AF_DECnet
+#define AF_DECnet 12
+#endif
+
+struct dn_naddr
+{
+	unsigned short          a_len;
+	unsigned char a_addr[DN_MAXADDL];
+};
+
+#define IPX_NODE_LEN 6
+
+struct ipx_addr {
+	uint32_t ipx_net;
+	uint8_t  ipx_node[IPX_NODE_LEN];
+};
+
+extern __u32 get_addr32(char *name);
+extern int get_addr_1(inet_prefix *dst, char *arg, int family);
+extern int get_prefix_1(inet_prefix *dst, char *arg, int family);
+extern int get_addr(inet_prefix *dst, char *arg, int family);
+extern int get_prefix(inet_prefix *dst, char *arg, int family);
+
+extern int get_integer(int *val, char *arg, int base);
+extern int get_unsigned(unsigned *val, char *arg, int base);
+#define get_byte get_u8
+#define get_ushort get_u16
+#define get_short get_s16
+extern int get_u32(__u32 *val, char *arg, int base);
+extern int get_u16(__u16 *val, char *arg, int base);
+extern int get_s16(__s16 *val, char *arg, int base);
+extern int get_u8(__u8 *val, char *arg, int base);
+extern int get_s8(__s8 *val, char *arg, int base);
+
+extern const char *format_host(int af, int len, void *addr, char *buf, int buflen);
+extern const char *rt_addr_n2a(int af, int len, void *addr, char *buf, int buflen);
+
+void invarg(const char * const, const char * const) ATTRIBUTE_NORETURN;
+void duparg(char *, char *) ATTRIBUTE_NORETURN;
+void duparg2(char *, char *) ATTRIBUTE_NORETURN;
+int matches(char *arg, char *pattern);
+extern int inet_addr_match(inet_prefix *a, inet_prefix *b, int bits);
+
+const char *dnet_ntop(int af, const void *addr, char *str, size_t len);
+int dnet_pton(int af, const char *src, void *addr);
+
+const char *ipx_ntop(int af, const void *addr, char *str, size_t len);
+int ipx_pton(int af, const char *src, void *addr);
+
+extern int __iproute2_hz_internal;
+extern int __get_hz(void);
+
+static __inline__ int get_hz(void)
+{
+	if (__iproute2_hz_internal == 0)
+		__iproute2_hz_internal = __get_hz();
+	return __iproute2_hz_internal;
+}
+
+#endif /* __UTILS_H__ */
diff --git a/networking/nameif.c b/networking/nameif.c
new file mode 100644
index 0000000..52aad28
--- /dev/null
+++ b/networking/nameif.c
@@ -0,0 +1,170 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * nameif.c - Naming Interfaces based on MAC address for busybox.
+ *
+ * Written 2000 by Andi Kleen.
+ * Busybox port 2002 by Nick Fedchik <nick@fedchik.org.ua>
+ *			Glenn McGrath <bug1@iinet.net.au>
+ *
+ * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+ */
+
+#include "busybox.h"
+#include <syslog.h>
+#include <net/if.h>
+#include <netinet/ether.h>
+
+
+/* Older versions of net/if.h do not appear to define IF_NAMESIZE. */
+#ifndef IF_NAMESIZE
+#  ifdef IFNAMSIZ
+#    define IF_NAMESIZE IFNAMSIZ
+#  else
+#    define IF_NAMESIZE 16
+#  endif
+#endif
+
+/* take from linux/sockios.h */
+#define SIOCSIFNAME	0x8923	/* set interface name */
+
+/* Octets in one Ethernet addr, from <linux/if_ether.h> */
+#define ETH_ALEN	6
+
+#ifndef ifr_newname
+#define ifr_newname ifr_ifru.ifru_slave
+#endif
+
+typedef struct mactable_s {
+	struct mactable_s *next;
+	struct mactable_s *prev;
+	char *ifname;
+	struct ether_addr *mac;
+} mactable_t;
+
+/* Check ascii str_macaddr, convert and copy to *mac */
+static struct ether_addr *cc_macaddr(const char *str_macaddr)
+{
+	struct ether_addr *lmac, *mac;
+
+	lmac = ether_aton(str_macaddr);
+	if (lmac == NULL)
+		bb_error_msg_and_die("cannot parse MAC %s", str_macaddr);
+	mac = xmalloc(ETH_ALEN);
+	memcpy(mac, lmac, ETH_ALEN);
+
+	return mac;
+}
+
+int nameif_main(int argc, char **argv)
+{
+	mactable_t *clist = NULL;
+	FILE *ifh;
+	const char *fname = "/etc/mactab";
+	char *line;
+	int ctl_sk;
+	int if_index = 1;
+	mactable_t *ch;
+
+	if (1 & getopt32(argc, argv, "sc:", &fname)) {
+		openlog(applet_name, 0, LOG_LOCAL0);
+		logmode = LOGMODE_SYSLOG;
+	}
+
+	if ((argc - optind) & 1)
+		bb_show_usage();
+
+	if (optind < argc) {
+		char **a = argv + optind;
+
+		while (*a) {
+			if (strlen(*a) > IF_NAMESIZE)
+				bb_error_msg_and_die("interface name '%s' "
+					    "too long", *a);
+			ch = xzalloc(sizeof(mactable_t));
+			ch->ifname = xstrdup(*a++);
+			ch->mac = cc_macaddr(*a++);
+			if (clist)
+				clist->prev = ch;
+			ch->next = clist;
+			clist = ch;
+		}
+	} else {
+		ifh = xfopen(fname, "r");
+
+		while ((line = xmalloc_fgets(ifh)) != NULL) {
+			char *line_ptr;
+			size_t name_length;
+
+			line_ptr = line + strspn(line, " \t");
+			if ((line_ptr[0] == '#') || (line_ptr[0] == '\n')) {
+				free(line);
+				continue;
+			}
+			name_length = strcspn(line_ptr, " \t");
+			ch = xzalloc(sizeof(mactable_t));
+			ch->ifname = xstrndup(line_ptr, name_length);
+			if (name_length > IF_NAMESIZE)
+				bb_error_msg_and_die("interface name '%s' "
+						"too long", ch->ifname);
+			line_ptr += name_length;
+			line_ptr += strspn(line_ptr, " \t");
+			name_length = strspn(line_ptr, "0123456789ABCDEFabcdef:");
+			line_ptr[name_length] = '\0';
+			ch->mac = cc_macaddr(line_ptr);
+			if (clist)
+				clist->prev = ch;
+			ch->next = clist;
+			clist = ch;
+			free(line);
+		}
+		fclose(ifh);
+	}
+
+	ctl_sk = xsocket(PF_INET, SOCK_DGRAM, 0);
+
+	while (clist) {
+		struct ifreq ifr;
+
+		memset(&ifr, 0, sizeof(struct ifreq));
+		if_index++;
+		ifr.ifr_ifindex = if_index;
+
+		/* Get ifname by index or die */
+		if (ioctl(ctl_sk, SIOCGIFNAME, &ifr))
+			break;
+
+		/* Has this device hwaddr? */
+		if (ioctl(ctl_sk, SIOCGIFHWADDR, &ifr))
+			continue;
+
+		/* Search for mac like in ifr.ifr_hwaddr.sa_data */
+		for (ch = clist; ch; ch = ch->next)
+			if (!memcmp(ch->mac, ifr.ifr_hwaddr.sa_data, ETH_ALEN))
+				break;
+
+		/* Nothing found for current ifr.ifr_hwaddr.sa_data */
+		if (ch == NULL)
+			continue;
+
+		strcpy(ifr.ifr_newname, ch->ifname);
+		if (ioctl(ctl_sk, SIOCSIFNAME, &ifr) < 0)
+			bb_perror_msg_and_die("cannot change ifname %s to %s",
+				   ifr.ifr_name, ch->ifname);
+
+		/* Remove list entry of renamed interface */
+		if (ch->prev != NULL) {
+			(ch->prev)->next = ch->next;
+		} else {
+			clist = ch->next;
+		}
+		if (ch->next != NULL)
+			(ch->next)->prev = ch->prev;
+		if (ENABLE_FEATURE_CLEAN_UP) {
+			free(ch->ifname);
+			free(ch->mac);
+			free(ch);
+		}
+	}
+
+	return 0;
+}
diff --git a/networking/nc.c b/networking/nc.c
new file mode 100644
index 0000000..5fd9242
--- /dev/null
+++ b/networking/nc.c
@@ -0,0 +1,201 @@
+/* vi: set sw=4 ts=4: */
+/*  nc: mini-netcat - built from the ground up for LRP
+ *
+ *  Copyright (C) 1998, 1999  Charles P. Wright
+ *  Copyright (C) 1998  Dave Cinege
+ *
+ *  Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ */
+
+#include "busybox.h"
+
+static void timeout(int signum)
+{
+	bb_error_msg_and_die("timed out");
+}
+
+int nc_main(int argc, char **argv)
+{
+	int sfd = 0;
+	int cfd = 0;
+	SKIP_NC_SERVER(const) unsigned do_listen = 0;
+	SKIP_NC_SERVER(const) unsigned lport = 0;
+	SKIP_NC_EXTRA (const) unsigned wsecs = 0;
+	SKIP_NC_EXTRA (const) unsigned delay = 0;
+	SKIP_NC_EXTRA (const int execparam = 0;)
+	USE_NC_EXTRA  (char **execparam = NULL;)
+	struct sockaddr_in address;
+	fd_set readfds, testfds;
+	int opt; /* must be signed (getopt returns -1) */
+
+	memset(&address, 0, sizeof(address));
+
+	if (ENABLE_NC_SERVER || ENABLE_NC_EXTRA) {
+		/* getopt32 is _almost_ usable:
+		** it cannot handle "... -e prog -prog-opt" */
+		while ((opt = getopt(argc, argv,
+		        "" USE_NC_SERVER("lp:") USE_NC_EXTRA("w:i:f:e:") )) > 0
+		) {
+			if (ENABLE_NC_SERVER && opt=='l')      USE_NC_SERVER(do_listen++);
+			else if (ENABLE_NC_SERVER && opt=='p') USE_NC_SERVER(lport = bb_lookup_port(optarg, "tcp", 0));
+			else if (ENABLE_NC_EXTRA  && opt=='w') USE_NC_EXTRA( wsecs = xatou(optarg));
+			else if (ENABLE_NC_EXTRA  && opt=='i') USE_NC_EXTRA( delay = xatou(optarg));
+			else if (ENABLE_NC_EXTRA  && opt=='f') USE_NC_EXTRA( cfd = xopen(optarg, O_RDWR));
+			else if (ENABLE_NC_EXTRA  && opt=='e' && optind<=argc) {
+				/* We cannot just 'break'. We should let getopt finish.
+				** Or else we won't be able to find where
+				** 'host' and 'port' params are
+				** (think "nc -w 60 host port -e prog"). */
+				USE_NC_EXTRA(
+					char **p;
+					// +2: one for progname (optarg) and one for NULL
+					execparam = xzalloc(sizeof(char*) * (argc - optind + 2));
+					p = execparam;
+					*p++ = optarg;
+					while (optind < argc) {
+						*p++ = argv[optind++];
+					}
+				)
+				/* optind points to argv[arvc] (NULL) now.
+				** FIXME: we assume that getopt will not count options
+				** possibly present on "-e prog args" and will not
+				** include them into final value of optind
+				** which is to be used ...  */
+			} else bb_show_usage();
+		}
+		argv += optind; /* ... here! */
+		argc -= optind;
+		// -l and -f don't mix
+		if (do_listen && cfd) bb_show_usage();
+		// Listen or file modes need zero arguments, client mode needs 2
+		opt = ((do_listen || cfd) ? 0 : 2);
+		if (argc != opt)
+			bb_show_usage();
+	} else {
+		if (argc != 3) bb_show_usage();
+		argc--;
+		argv++;
+	}
+
+	if (wsecs) {
+		signal(SIGALRM, timeout);
+		alarm(wsecs);
+	}
+
+	if (!cfd) {
+		sfd = xsocket(AF_INET, SOCK_STREAM, 0);
+		fcntl(sfd, F_SETFD, FD_CLOEXEC);
+		setsockopt_reuseaddr(sfd);
+		address.sin_family = AF_INET;
+
+		// Set local port.
+
+		if (lport != 0) {
+			address.sin_port = lport;
+			xbind(sfd, (struct sockaddr *) &address, sizeof(address));
+		}
+
+		if (do_listen) {
+			socklen_t addrlen = sizeof(address);
+
+			xlisten(sfd, do_listen);
+
+			// If we didn't specify a port number, query and print it to stderr.
+
+			if (!lport) {
+				socklen_t len = sizeof(address);
+				getsockname(sfd, &address, &len);
+				fdprintf(2, "%d\n", SWAP_BE16(address.sin_port));
+			}
+ repeatyness:
+			cfd = accept(sfd, (struct sockaddr *) &address, &addrlen);
+			if (cfd < 0)
+				bb_perror_msg_and_die("accept");
+
+			if (!execparam) close(sfd);
+		} else {
+			struct hostent *hostinfo;
+			hostinfo = xgethostbyname(argv[0]);
+
+			address.sin_addr = *(struct in_addr *) *hostinfo->h_addr_list;
+			address.sin_port = bb_lookup_port(argv[1], "tcp", 0);
+
+			if (connect(sfd, (struct sockaddr *) &address, sizeof(address)) < 0)
+				bb_perror_msg_and_die("connect");
+			cfd = sfd;
+		}
+	}
+
+	if (wsecs) {
+		alarm(0);
+		signal(SIGALRM, SIG_DFL);
+	}
+
+	/* -e given? */
+	if (execparam) {
+		if (cfd) {
+			signal(SIGCHLD, SIG_IGN);
+			dup2(cfd, 0);
+			close(cfd);
+		}
+		dup2(0, 1);
+		dup2(0, 2);
+
+		// With more than one -l, repeatedly act as server.
+
+		if (do_listen > 1 && vfork()) {
+			// This is a bit weird as cleanup goes, since we wind up with no
+			// stdin/stdout/stderr.  But it's small and shouldn't hurt anything.
+			// We check for cfd == 0 above.
+			logmode = LOGMODE_NONE;
+			close(0);
+			close(1);
+			close(2);
+
+			goto repeatyness;
+		}
+		USE_NC_EXTRA(execvp(execparam[0], execparam);)
+		/* Don't print stuff or it will go over the wire.... */
+		_exit(127);
+	}
+
+	// Select loop copying stdin to cfd, and cfd to stdout.
+
+	FD_ZERO(&readfds);
+	FD_SET(cfd, &readfds);
+	FD_SET(STDIN_FILENO, &readfds);
+
+	for (;;) {
+		int fd;
+		int ofd;
+		int nread;
+
+		testfds = readfds;
+
+		if (select(FD_SETSIZE, &testfds, NULL, NULL, NULL) < 0)
+			bb_perror_msg_and_die("select");
+
+		for (fd = 0; fd < FD_SETSIZE; fd++) {
+			if (FD_ISSET(fd, &testfds)) {
+				nread = safe_read(fd, bb_common_bufsiz1,
+							sizeof(bb_common_bufsiz1));
+
+				if (fd == cfd) {
+					if (nread<1) exit(0);
+					ofd = STDOUT_FILENO;
+				} else {
+					if (nread<1) {
+						// Close outgoing half-connection so they get EOF, but
+						// leave incoming alone so we can see response.
+						shutdown(cfd, 1);
+						FD_CLR(STDIN_FILENO, &readfds);
+					}
+					ofd = cfd;
+				}
+
+				xwrite(ofd, bb_common_bufsiz1, nread);
+				if (delay > 0) sleep(delay);
+			}
+		}
+	}
+}
diff --git a/networking/netstat.c b/networking/netstat.c
new file mode 100644
index 0000000..3dad57a
--- /dev/null
+++ b/networking/netstat.c
@@ -0,0 +1,613 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Mini netstat implementation(s) for busybox
+ * based in part on the netstat implementation from net-tools.
+ *
+ * Copyright (C) 2002 by Bart Visscher <magick@linux-fan.com>
+ *
+ * 2002-04-20
+ * IPV6 support added by Bart Visscher <magick@linux-fan.com>
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ */
+
+#include "busybox.h"
+#include "inet_common.h"
+
+#ifdef CONFIG_ROUTE
+extern void displayroutes(int noresolve, int netstatfmt);
+#endif
+
+#define NETSTAT_CONNECTED       0x01
+#define NETSTAT_LISTENING       0x02
+#define NETSTAT_NUMERIC         0x04
+/* Must match getopt32 option string */
+#define NETSTAT_TCP             0x10
+#define NETSTAT_UDP             0x20
+#define NETSTAT_RAW             0x40
+#define NETSTAT_UNIX            0x80
+#define NETSTAT_ALLPROTO (NETSTAT_TCP|NETSTAT_UDP|NETSTAT_RAW|NETSTAT_UNIX)
+
+static int flags = NETSTAT_CONNECTED | NETSTAT_ALLPROTO;
+
+#define PROGNAME_WIDTHs PROGNAME_WIDTH1(PROGNAME_WIDTH)
+#define PROGNAME_WIDTH1(s) PROGNAME_WIDTH2(s)
+#define PROGNAME_WIDTH2(s) #s
+
+#define PRG_HASH_SIZE 211
+
+enum {
+    TCP_ESTABLISHED = 1,
+    TCP_SYN_SENT,
+    TCP_SYN_RECV,
+    TCP_FIN_WAIT1,
+    TCP_FIN_WAIT2,
+    TCP_TIME_WAIT,
+    TCP_CLOSE,
+    TCP_CLOSE_WAIT,
+    TCP_LAST_ACK,
+    TCP_LISTEN,
+    TCP_CLOSING			/* now a valid state */
+};
+
+static const char * const tcp_state[] =
+{
+    "",
+    "ESTABLISHED",
+    "SYN_SENT",
+    "SYN_RECV",
+    "FIN_WAIT1",
+    "FIN_WAIT2",
+    "TIME_WAIT",
+    "CLOSE",
+    "CLOSE_WAIT",
+    "LAST_ACK",
+    "LISTEN",
+    "CLOSING"
+};
+
+typedef enum {
+    SS_FREE = 0,		/* not allocated                */
+    SS_UNCONNECTED,		/* unconnected to any socket    */
+    SS_CONNECTING,		/* in process of connecting     */
+    SS_CONNECTED,		/* connected to socket          */
+    SS_DISCONNECTING		/* in process of disconnecting  */
+} socket_state;
+
+#define SO_ACCEPTCON    (1<<16)	/* performed a listen           */
+#define SO_WAITDATA     (1<<17)	/* wait data to read            */
+#define SO_NOSPACE      (1<<18)	/* no space to write            */
+
+static char *get_sname(int port, const char *proto, int num)
+{
+	char *str=itoa(ntohs(port));
+	if (num) {
+	} else {
+		struct servent *se=getservbyport(port,proto);
+		if (se)
+			str=se->s_name;
+	}
+	if (!port) {
+		str="*";
+	}
+	return str;
+}
+
+static void snprint_ip_port(char *ip_port, int size, struct sockaddr *addr, int port, char *proto, int numeric)
+{
+	char *port_name;
+
+#ifdef CONFIG_FEATURE_IPV6
+	if (addr->sa_family == AF_INET6) {
+		INET6_rresolve(ip_port, size, (struct sockaddr_in6 *)addr,
+					   (numeric&NETSTAT_NUMERIC) ? 0x0fff : 0);
+	} else
+#endif
+	{
+	INET_rresolve(ip_port, size, (struct sockaddr_in *)addr,
+		0x4000 | ((numeric&NETSTAT_NUMERIC) ? 0x0fff : 0),
+		0xffffffff);
+	}
+	port_name=get_sname(htons(port), proto, numeric);
+	if ((strlen(ip_port) + strlen(port_name)) > 22)
+		ip_port[22 - strlen(port_name)] = '\0';
+	ip_port+=strlen(ip_port);
+	strcat(ip_port, ":");
+	strcat(ip_port, port_name);
+}
+
+static void tcp_do_one(int lnr, const char *line)
+{
+	char local_addr[64], rem_addr[64];
+	const char *state_str;
+	char more[512];
+	int num, local_port, rem_port, d, state, timer_run, uid, timeout;
+#ifdef CONFIG_FEATURE_IPV6
+	struct sockaddr_in6 localaddr, remaddr;
+	char addr6[INET6_ADDRSTRLEN];
+	struct in6_addr in6;
+#else
+	struct sockaddr_in localaddr, remaddr;
+#endif
+	unsigned long rxq, txq, time_len, retr, inode;
+
+	if (lnr == 0)
+		return;
+
+	more[0] = '\0';
+	num = sscanf(line,
+				 "%d: %64[0-9A-Fa-f]:%X %64[0-9A-Fa-f]:%X %X %lX:%lX %X:%lX %lX %d %d %ld %512s\n",
+				 &d, local_addr, &local_port,
+				 rem_addr, &rem_port, &state,
+				 &txq, &rxq, &timer_run, &time_len, &retr, &uid, &timeout, &inode, more);
+
+	if (strlen(local_addr) > 8) {
+#ifdef CONFIG_FEATURE_IPV6
+		sscanf(local_addr, "%08X%08X%08X%08X",
+			   &in6.s6_addr32[0], &in6.s6_addr32[1],
+			   &in6.s6_addr32[2], &in6.s6_addr32[3]);
+		inet_ntop(AF_INET6, &in6, addr6, sizeof(addr6));
+		inet_pton(AF_INET6, addr6, (struct sockaddr *) &localaddr.sin6_addr);
+		sscanf(rem_addr, "%08X%08X%08X%08X",
+			   &in6.s6_addr32[0], &in6.s6_addr32[1],
+			   &in6.s6_addr32[2], &in6.s6_addr32[3]);
+		inet_ntop(AF_INET6, &in6, addr6, sizeof(addr6));
+		inet_pton(AF_INET6, addr6, (struct sockaddr *) &remaddr.sin6_addr);
+		localaddr.sin6_family = AF_INET6;
+		remaddr.sin6_family = AF_INET6;
+#endif
+	} else {
+		sscanf(local_addr, "%X",
+			   &((struct sockaddr_in *) &localaddr)->sin_addr.s_addr);
+		sscanf(rem_addr, "%X",
+			   &((struct sockaddr_in *) &remaddr)->sin_addr.s_addr);
+		((struct sockaddr *) &localaddr)->sa_family = AF_INET;
+		((struct sockaddr *) &remaddr)->sa_family = AF_INET;
+	}
+
+	if (num < 10) {
+		bb_error_msg("warning, got bogus tcp line");
+		return;
+	}
+	state_str = tcp_state[state];
+	if ((rem_port && (flags&NETSTAT_CONNECTED)) ||
+		(!rem_port && (flags&NETSTAT_LISTENING)))
+	{
+		snprint_ip_port(local_addr, sizeof(local_addr),
+						(struct sockaddr *) &localaddr, local_port,
+						"tcp", flags&NETSTAT_NUMERIC);
+
+		snprint_ip_port(rem_addr, sizeof(rem_addr),
+						(struct sockaddr *) &remaddr, rem_port,
+						"tcp", flags&NETSTAT_NUMERIC);
+
+		printf("tcp   %6ld %6ld %-23s %-23s %-12s\n",
+			   rxq, txq, local_addr, rem_addr, state_str);
+
+	}
+}
+
+static void udp_do_one(int lnr, const char *line)
+{
+	char local_addr[64], rem_addr[64];
+	char *state_str, more[512];
+	int num, local_port, rem_port, d, state, timer_run, uid, timeout;
+#ifdef CONFIG_FEATURE_IPV6
+	struct sockaddr_in6 localaddr, remaddr;
+	char addr6[INET6_ADDRSTRLEN];
+	struct in6_addr in6;
+#else
+	struct sockaddr_in localaddr, remaddr;
+#endif
+	unsigned long rxq, txq, time_len, retr, inode;
+
+	if (lnr == 0)
+		return;
+
+	more[0] = '\0';
+	num = sscanf(line,
+				 "%d: %64[0-9A-Fa-f]:%X %64[0-9A-Fa-f]:%X %X %lX:%lX %X:%lX %lX %d %d %ld %512s\n",
+				 &d, local_addr, &local_port,
+				 rem_addr, &rem_port, &state,
+				 &txq, &rxq, &timer_run, &time_len, &retr, &uid, &timeout, &inode, more);
+
+	if (strlen(local_addr) > 8) {
+#ifdef CONFIG_FEATURE_IPV6
+	/* Demangle what the kernel gives us */
+		sscanf(local_addr, "%08X%08X%08X%08X",
+			   &in6.s6_addr32[0], &in6.s6_addr32[1],
+			   &in6.s6_addr32[2], &in6.s6_addr32[3]);
+		inet_ntop(AF_INET6, &in6, addr6, sizeof(addr6));
+		inet_pton(AF_INET6, addr6, (struct sockaddr *) &localaddr.sin6_addr);
+		sscanf(rem_addr, "%08X%08X%08X%08X",
+			   &in6.s6_addr32[0], &in6.s6_addr32[1],
+			   &in6.s6_addr32[2], &in6.s6_addr32[3]);
+		inet_ntop(AF_INET6, &in6, addr6, sizeof(addr6));
+		inet_pton(AF_INET6, addr6, (struct sockaddr *) &remaddr.sin6_addr);
+		localaddr.sin6_family = AF_INET6;
+		remaddr.sin6_family = AF_INET6;
+#endif
+	} else {
+		sscanf(local_addr, "%X",
+			   &((struct sockaddr_in *) &localaddr)->sin_addr.s_addr);
+		sscanf(rem_addr, "%X",
+			   &((struct sockaddr_in *) &remaddr)->sin_addr.s_addr);
+		((struct sockaddr *) &localaddr)->sa_family = AF_INET;
+		((struct sockaddr *) &remaddr)->sa_family = AF_INET;
+	}
+
+	if (num < 10) {
+		bb_error_msg("warning, got bogus udp line");
+		return;
+	}
+	switch (state) {
+		case TCP_ESTABLISHED:
+			state_str = "ESTABLISHED";
+			break;
+
+		case TCP_CLOSE:
+			state_str = "";
+			break;
+
+		default:
+			state_str = "UNKNOWN";
+			break;
+	}
+
+#ifdef CONFIG_FEATURE_IPV6
+# define notnull(A) (((A.sin6_family == AF_INET6) &&            \
+					 ((A.sin6_addr.s6_addr32[0]) ||            \
+					  (A.sin6_addr.s6_addr32[1]) ||            \
+					  (A.sin6_addr.s6_addr32[2]) ||            \
+					  (A.sin6_addr.s6_addr32[3]))) ||          \
+					((A.sin6_family == AF_INET) &&             \
+					 ((struct sockaddr_in *) &A)->sin_addr.s_addr))
+#else
+# define notnull(A) (A.sin_addr.s_addr)
+#endif
+	if ((notnull(remaddr) && (flags&NETSTAT_CONNECTED)) ||
+		(!notnull(remaddr) && (flags&NETSTAT_LISTENING)))
+	{
+		snprint_ip_port(local_addr, sizeof(local_addr),
+						(struct sockaddr *) &localaddr, local_port,
+						"udp", flags&NETSTAT_NUMERIC);
+
+		snprint_ip_port(rem_addr, sizeof(rem_addr),
+						(struct sockaddr *) &remaddr, rem_port,
+						"udp", flags&NETSTAT_NUMERIC);
+
+		printf("udp   %6ld %6ld %-23s %-23s %-12s\n",
+			   rxq, txq, local_addr, rem_addr, state_str);
+
+	}
+}
+
+static void raw_do_one(int lnr, const char *line)
+{
+	char local_addr[64], rem_addr[64];
+	char *state_str, more[512];
+	int num, local_port, rem_port, d, state, timer_run, uid, timeout;
+#ifdef CONFIG_FEATURE_IPV6
+	struct sockaddr_in6 localaddr, remaddr;
+	char addr6[INET6_ADDRSTRLEN];
+	struct in6_addr in6;
+#else
+	struct sockaddr_in localaddr, remaddr;
+#endif
+	unsigned long rxq, txq, time_len, retr, inode;
+
+	if (lnr == 0)
+		return;
+
+	more[0] = '\0';
+	num = sscanf(line,
+				 "%d: %64[0-9A-Fa-f]:%X %64[0-9A-Fa-f]:%X %X %lX:%lX %X:%lX %lX %d %d %ld %512s\n",
+				 &d, local_addr, &local_port,
+				 rem_addr, &rem_port, &state,
+				 &txq, &rxq, &timer_run, &time_len, &retr, &uid, &timeout, &inode, more);
+
+	if (strlen(local_addr) > 8) {
+#ifdef CONFIG_FEATURE_IPV6
+		sscanf(local_addr, "%08X%08X%08X%08X",
+			   &in6.s6_addr32[0], &in6.s6_addr32[1],
+			   &in6.s6_addr32[2], &in6.s6_addr32[3]);
+		inet_ntop(AF_INET6, &in6, addr6, sizeof(addr6));
+		inet_pton(AF_INET6, addr6, (struct sockaddr *) &localaddr.sin6_addr);
+		sscanf(rem_addr, "%08X%08X%08X%08X",
+			   &in6.s6_addr32[0], &in6.s6_addr32[1],
+			   &in6.s6_addr32[2], &in6.s6_addr32[3]);
+		inet_ntop(AF_INET6, &in6, addr6, sizeof(addr6));
+		inet_pton(AF_INET6, addr6, (struct sockaddr *) &remaddr.sin6_addr);
+		localaddr.sin6_family = AF_INET6;
+		remaddr.sin6_family = AF_INET6;
+#endif
+	} else {
+		sscanf(local_addr, "%X",
+			   &((struct sockaddr_in *) &localaddr)->sin_addr.s_addr);
+		sscanf(rem_addr, "%X",
+			   &((struct sockaddr_in *) &remaddr)->sin_addr.s_addr);
+		((struct sockaddr *) &localaddr)->sa_family = AF_INET;
+		((struct sockaddr *) &remaddr)->sa_family = AF_INET;
+	}
+
+	if (num < 10) {
+		bb_error_msg("warning, got bogus raw line");
+		return;
+	}
+	state_str=itoa(state);
+
+#ifdef CONFIG_FEATURE_IPV6
+# define notnull(A) (((A.sin6_family == AF_INET6) &&            \
+					 ((A.sin6_addr.s6_addr32[0]) ||            \
+					  (A.sin6_addr.s6_addr32[1]) ||            \
+					  (A.sin6_addr.s6_addr32[2]) ||            \
+					  (A.sin6_addr.s6_addr32[3]))) ||          \
+					((A.sin6_family == AF_INET) &&             \
+					 ((struct sockaddr_in *) &A)->sin_addr.s_addr))
+#else
+# define notnull(A) (A.sin_addr.s_addr)
+#endif
+	if ((notnull(remaddr) && (flags&NETSTAT_CONNECTED)) ||
+		(!notnull(remaddr) && (flags&NETSTAT_LISTENING)))
+	{
+		snprint_ip_port(local_addr, sizeof(local_addr),
+						(struct sockaddr *) &localaddr, local_port,
+						"raw", flags&NETSTAT_NUMERIC);
+
+		snprint_ip_port(rem_addr, sizeof(rem_addr),
+						(struct sockaddr *) &remaddr, rem_port,
+						"raw", flags&NETSTAT_NUMERIC);
+
+		printf("raw   %6ld %6ld %-23s %-23s %-12s\n",
+			   rxq, txq, local_addr, rem_addr, state_str);
+
+	}
+}
+
+#define HAS_INODE 1
+
+static void unix_do_one(int nr, const char *line)
+{
+	static int has = 0;
+	char path[PATH_MAX], ss_flags[32];
+	char *ss_proto, *ss_state, *ss_type;
+	int num, state, type, inode;
+	void *d;
+	unsigned long refcnt, proto, unix_flags;
+
+	if (nr == 0) {
+		if (strstr(line, "Inode"))
+			has |= HAS_INODE;
+		return;
+	}
+	path[0] = '\0';
+	num = sscanf(line, "%p: %lX %lX %lX %X %X %d %s",
+				 &d, &refcnt, &proto, &unix_flags, &type, &state, &inode, path);
+	if (num < 6) {
+		bb_error_msg("warning, got bogus unix line");
+		return;
+	}
+	if (!(has & HAS_INODE))
+		snprintf(path,sizeof(path),"%d",inode);
+
+	if ((flags&(NETSTAT_LISTENING|NETSTAT_CONNECTED))!=(NETSTAT_LISTENING|NETSTAT_CONNECTED)) {
+		if ((state == SS_UNCONNECTED) && (unix_flags & SO_ACCEPTCON)) {
+			if (!(flags&NETSTAT_LISTENING))
+				return;
+		} else {
+			if (!(flags&NETSTAT_CONNECTED))
+				return;
+		}
+	}
+
+	switch (proto) {
+		case 0:
+			ss_proto = "unix";
+			break;
+
+		default:
+			ss_proto = "??";
+	}
+
+	switch (type) {
+		case SOCK_STREAM:
+			ss_type = "STREAM";
+			break;
+
+		case SOCK_DGRAM:
+			ss_type = "DGRAM";
+			break;
+
+		case SOCK_RAW:
+			ss_type = "RAW";
+			break;
+
+		case SOCK_RDM:
+			ss_type = "RDM";
+			break;
+
+		case SOCK_SEQPACKET:
+			ss_type = "SEQPACKET";
+			break;
+
+		default:
+			ss_type = "UNKNOWN";
+	}
+
+	switch (state) {
+		case SS_FREE:
+			ss_state = "FREE";
+			break;
+
+		case SS_UNCONNECTED:
+			/*
+			 * Unconnected sockets may be listening
+			 * for something.
+			 */
+			if (unix_flags & SO_ACCEPTCON) {
+				ss_state = "LISTENING";
+			} else {
+				ss_state = "";
+			}
+			break;
+
+		case SS_CONNECTING:
+			ss_state = "CONNECTING";
+			break;
+
+		case SS_CONNECTED:
+			ss_state = "CONNECTED";
+			break;
+
+		case SS_DISCONNECTING:
+			ss_state = "DISCONNECTING";
+			break;
+
+		default:
+			ss_state = "UNKNOWN";
+	}
+
+	strcpy(ss_flags, "[ ");
+	if (unix_flags & SO_ACCEPTCON)
+		strcat(ss_flags, "ACC ");
+	if (unix_flags & SO_WAITDATA)
+		strcat(ss_flags, "W ");
+	if (unix_flags & SO_NOSPACE)
+		strcat(ss_flags, "N ");
+
+	strcat(ss_flags, "]");
+
+	printf("%-5s %-6ld %-11s %-10s %-13s ",
+		   ss_proto, refcnt, ss_flags, ss_type, ss_state);
+	if (has & HAS_INODE)
+		printf("%-6d ",inode);
+	else
+		printf("-      ");
+	puts(path);
+}
+
+#define _PATH_PROCNET_UDP "/proc/net/udp"
+#define _PATH_PROCNET_UDP6 "/proc/net/udp6"
+#define _PATH_PROCNET_TCP "/proc/net/tcp"
+#define _PATH_PROCNET_TCP6 "/proc/net/tcp6"
+#define _PATH_PROCNET_RAW "/proc/net/raw"
+#define _PATH_PROCNET_RAW6 "/proc/net/raw6"
+#define _PATH_PROCNET_UNIX "/proc/net/unix"
+
+static void do_info(const char *file, const char *name, void (*proc)(int, const char *))
+{
+	int lnr = 0;
+	FILE *procinfo;
+
+	procinfo = fopen(file, "r");
+	if (procinfo == NULL) {
+		if (errno != ENOENT) {
+			perror(file);
+		} else {
+			bb_error_msg("no support for '%s' on this system", name);
+		}
+	} else {
+		do {
+			char *buffer = xmalloc_fgets(procinfo);
+			if (buffer) {
+				(proc)(lnr++, buffer);
+				free(buffer);
+			}
+		} while (!feof(procinfo));
+		fclose(procinfo);
+	}
+}
+
+/*
+ * Our main function.
+ */
+
+int netstat_main(int argc, char **argv)
+{
+	enum {
+		OPT_extended = 0x4,
+		OPT_showroute = 0x100,
+	};
+	unsigned opt;
+#ifdef CONFIG_FEATURE_IPV6
+	int inet = 1;
+	int inet6 = 1;
+#else
+# define inet 1
+# define inet6 0
+#endif
+
+	/* Option string must match NETSTAT_xxx constants */
+	opt = getopt32(argc, argv, "laentuwxr");
+	if (opt & 0x1) { // -l
+		flags &= ~NETSTAT_CONNECTED;
+		flags |= NETSTAT_LISTENING;
+	}
+	if (opt & 0x2) flags |= NETSTAT_LISTENING | NETSTAT_CONNECTED; // -a
+	//if (opt & 0x4) // -e
+	if (opt & 0x8) flags |= NETSTAT_NUMERIC; // -n
+	//if (opt & 0x10) // -t: NETSTAT_TCP
+	//if (opt & 0x20) // -u: NETSTAT_UDP
+	//if (opt & 0x40) // -w: NETSTAT_RAW
+	//if (opt & 0x80) // -x: NETSTAT_UNIX
+	if (opt & OPT_showroute) { // -r
+#ifdef CONFIG_ROUTE
+		displayroutes(flags & NETSTAT_NUMERIC, !(opt & OPT_extended));
+		return 0;
+#else
+		bb_error_msg_and_die("-r (display routing table) is not compiled in");
+#endif
+	}
+
+	opt &= NETSTAT_ALLPROTO;
+	if (opt) {
+		flags &= ~NETSTAT_ALLPROTO;
+		flags |= opt;
+	}
+	if (flags & (NETSTAT_TCP|NETSTAT_UDP|NETSTAT_RAW)) {
+		printf("Active Internet connections ");	/* xxx */
+
+		if ((flags&(NETSTAT_LISTENING|NETSTAT_CONNECTED))==(NETSTAT_LISTENING|NETSTAT_CONNECTED))
+			printf("(servers and established)");
+		else {
+			if (flags & NETSTAT_LISTENING)
+				printf("(only servers)");
+			else
+				printf("(w/o servers)");
+		}
+		printf("\nProto Recv-Q Send-Q Local Address           Foreign Address         State\n");
+	}
+	if (inet && flags&NETSTAT_TCP)
+		do_info(_PATH_PROCNET_TCP,"AF INET (tcp)",tcp_do_one);
+#ifdef CONFIG_FEATURE_IPV6
+	if (inet6 && flags&NETSTAT_TCP)
+		do_info(_PATH_PROCNET_TCP6,"AF INET6 (tcp)",tcp_do_one);
+#endif
+	if (inet && flags&NETSTAT_UDP)
+		do_info(_PATH_PROCNET_UDP,"AF INET (udp)",udp_do_one);
+#ifdef CONFIG_FEATURE_IPV6
+	if (inet6 && flags&NETSTAT_UDP)
+		do_info(_PATH_PROCNET_UDP6,"AF INET6 (udp)",udp_do_one);
+#endif
+	if (inet && flags&NETSTAT_RAW)
+		do_info(_PATH_PROCNET_RAW,"AF INET (raw)",raw_do_one);
+#ifdef CONFIG_FEATURE_IPV6
+	if (inet6 && flags&NETSTAT_RAW)
+		do_info(_PATH_PROCNET_RAW6,"AF INET6 (raw)",raw_do_one);
+#endif
+	if (flags&NETSTAT_UNIX) {
+		printf("Active UNIX domain sockets ");
+		if ((flags&(NETSTAT_LISTENING|NETSTAT_CONNECTED))==(NETSTAT_LISTENING|NETSTAT_CONNECTED))
+			printf("(servers and established)");
+		else {
+			if (flags&NETSTAT_LISTENING)
+				printf("(only servers)");
+			else
+				printf("(w/o servers)");
+		}
+
+		printf("\nProto RefCnt Flags       Type       State         I-Node Path\n");
+		do_info(_PATH_PROCNET_UNIX,"AF UNIX",unix_do_one);
+	}
+	return 0;
+}
diff --git a/networking/nslookup.c b/networking/nslookup.c
new file mode 100644
index 0000000..cc5ff95
--- /dev/null
+++ b/networking/nslookup.c
@@ -0,0 +1,149 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Mini nslookup implementation for busybox
+ *
+ * Copyright (C) 1999,2000 by Lineo, inc. and John Beppu
+ * Copyright (C) 1999,2000,2001 by John Beppu <beppu@codepoet.org>
+ *
+ * Correct default name server display and explicit name server option
+ * added by Ben Zeckel <bzeckel@hmc.edu> June 2001
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ */
+
+#include <resolv.h>
+#include "busybox.h"
+
+/*
+ *  I'm only implementing non-interactive mode;
+ *  I totally forgot nslookup even had an interactive mode.
+ */
+
+/* Examples of 'standard' nslookup output
+ * $ nslookup yahoo.com
+ * Server:         128.193.0.10
+ * Address:        128.193.0.10#53
+ * 
+ * Non-authoritative answer:
+ * Name:   yahoo.com
+ * Address: 216.109.112.135
+ * Name:   yahoo.com
+ * Address: 66.94.234.13
+ *
+ * $ nslookup 204.152.191.37
+ * Server:         128.193.4.20
+ * Address:        128.193.4.20#53
+ * 
+ * Non-authoritative answer:
+ * 37.191.152.204.in-addr.arpa     canonical name = 37.32-27.191.152.204.in-addr.arpa.
+ * 37.32-27.191.152.204.in-addr.arpa       name = zeus-pub2.kernel.org.
+ * 
+ * Authoritative answers can be found from:
+ * 32-27.191.152.204.in-addr.arpa  nameserver = ns1.kernel.org.
+ * 32-27.191.152.204.in-addr.arpa  nameserver = ns2.kernel.org.
+ * 32-27.191.152.204.in-addr.arpa  nameserver = ns3.kernel.org.
+ * ns1.kernel.org  internet address = 140.211.167.34
+ * ns2.kernel.org  internet address = 204.152.191.4
+ * ns3.kernel.org  internet address = 204.152.191.36
+ */
+
+static int sockaddr_to_dotted(struct sockaddr *saddr, char *buf, int buflen)
+{
+	if (buflen <= 0) return -1;
+	buf[0] = '\0';
+	if (saddr->sa_family == AF_INET) {
+		inet_ntop(AF_INET, &((struct sockaddr_in*)saddr)->sin_addr, buf, buflen);
+		return 0;
+	}
+	if (saddr->sa_family == AF_INET6) {
+		inet_ntop(AF_INET6, &((struct sockaddr_in6*)saddr)->sin6_addr, buf, buflen);
+		return 0;
+	}
+	return -1;
+}
+
+static int print_host(const char *hostname, const char *header)
+{
+	char str[128];	/* IPv6 address will fit, hostnames hopefully too */
+	struct addrinfo *result = NULL;
+	int rc;
+	struct addrinfo hint;
+
+	memset(&hint, 0 , sizeof(hint));
+	/* hint.ai_family = AF_UNSPEC; - zero anyway */
+	/* Needed. Or else we will get each address thrice (or more)
+	 * for each possible socket type (tcp,udp,raw...): */
+	hint.ai_socktype = SOCK_STREAM;
+	// hint.ai_flags = AI_CANONNAME;
+	rc = getaddrinfo(hostname, NULL /*service*/, &hint, &result);
+	if (!rc) {
+		struct addrinfo *cur = result;
+		// printf("%s\n", cur->ai_canonname); ?
+		while (cur) {
+			sockaddr_to_dotted(cur->ai_addr, str, sizeof(str));
+			printf("%s  %s\nAddress: %s", header, hostname, str);
+			str[0] = ' ';
+			if (getnameinfo(cur->ai_addr, cur->ai_addrlen, str+1, sizeof(str)-1, NULL, 0, NI_NAMEREQD))
+				str[0] = '\0';
+			puts(str);
+			cur = cur->ai_next;
+		}
+	} else {
+		bb_error_msg("getaddrinfo('%s') failed: %s", hostname, gai_strerror(rc));
+	}
+	freeaddrinfo(result);
+	return (rc != 0);
+}
+
+
+/* alter the global _res nameserver structure to use
+   an explicit dns server instead of what is in /etc/resolv.h */
+static void set_default_dns(char *server)
+{
+	struct in_addr server_in_addr;
+
+	if (inet_pton(AF_INET, server, &server_in_addr) > 0) {
+		_res.nscount = 1;
+		_res.nsaddr_list[0].sin_addr = server_in_addr;
+	}
+}
+
+
+/* lookup the default nameserver and display it */
+static void server_print(void)
+{
+	char str[INET6_ADDRSTRLEN];
+
+	sockaddr_to_dotted((struct sockaddr*)&_res.nsaddr_list[0], str, sizeof(str));
+	print_host(str, "Server:");
+	puts("");
+}
+
+
+int nslookup_main(int argc, char **argv)
+{
+	/*
+	* initialize DNS structure _res used in printing the default
+	* name server and in the explicit name server option feature.
+	*/
+
+	res_init();
+
+	/*
+	* We allow 1 or 2 arguments.
+	* The first is the name to be looked up and the second is an
+	* optional DNS server with which to do the lookup.
+	* More than 3 arguments is an error to follow the pattern of the
+	* standard nslookup
+	*/
+
+	if (argc < 2 || *argv[1] == '-' || argc > 3)
+		bb_show_usage();
+	else if(argc == 3)
+		set_default_dns(argv[2]);
+
+	server_print();
+	return print_host(argv[1], "Name:  ");
+}
+
+/* $Id: nslookup.c,v 1.33 2004/10/13 07:25:01 andersen Exp $ */
diff --git a/networking/ping.c b/networking/ping.c
new file mode 100644
index 0000000..658c015
--- /dev/null
+++ b/networking/ping.c
@@ -0,0 +1,440 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * $Id: ping.c,v 1.56 2004/03/15 08:28:48 andersen Exp $
+ * Mini ping implementation for busybox
+ *
+ * Copyright (C) 1999 by Randolph Chung <tausq@debian.org>
+ *
+ * Adapted from the ping in netkit-base 0.10:
+ * Copyright (c) 1989 The Regents of the University of California.
+ * Derived from software contributed to Berkeley by Mike Muuss.
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ */
+
+#include <sys/param.h>
+#include <sys/socket.h>
+#include <sys/file.h>
+#include <sys/times.h>
+#include <signal.h>
+
+#include <netinet/in.h>
+#include <netinet/ip.h>
+#include <netinet/ip_icmp.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdlib.h>
+#include "busybox.h"
+
+enum {
+	DEFDATALEN = 56,
+	MAXIPLEN = 60,
+	MAXICMPLEN = 76,
+	MAXPACKET = 65468,
+	MAX_DUP_CHK = (8 * 128),
+	MAXWAIT = 10,
+	PINGINTERVAL = 1		/* second */
+};
+
+static void ping(const char *host);
+
+/* common routines */
+
+static int in_cksum(unsigned short *buf, int sz)
+{
+	int nleft = sz;
+	int sum = 0;
+	unsigned short *w = buf;
+	unsigned short ans = 0;
+
+	while (nleft > 1) {
+		sum += *w++;
+		nleft -= 2;
+	}
+
+	if (nleft == 1) {
+		*(unsigned char *) (&ans) = *(unsigned char *) w;
+		sum += ans;
+	}
+
+	sum = (sum >> 16) + (sum & 0xFFFF);
+	sum += (sum >> 16);
+	ans = ~sum;
+	return ans;
+}
+
+#ifndef CONFIG_FEATURE_FANCY_PING
+
+/* simple version */
+
+static char *hostname;
+
+static void noresp(int ign)
+{
+	printf("No response from %s\n", hostname);
+	exit(EXIT_FAILURE);
+}
+
+static void ping(const char *host)
+{
+	struct hostent *h;
+	struct sockaddr_in pingaddr;
+	struct icmp *pkt;
+	int pingsock, c;
+	char packet[DEFDATALEN + MAXIPLEN + MAXICMPLEN];
+
+	pingsock = create_icmp_socket();
+
+	memset(&pingaddr, 0, sizeof(struct sockaddr_in));
+
+	pingaddr.sin_family = AF_INET;
+	h = xgethostbyname(host);
+	memcpy(&pingaddr.sin_addr, h->h_addr, sizeof(pingaddr.sin_addr));
+	hostname = h->h_name;
+
+	pkt = (struct icmp *) packet;
+	memset(pkt, 0, sizeof(packet));
+	pkt->icmp_type = ICMP_ECHO;
+	pkt->icmp_cksum = in_cksum((unsigned short *) pkt, sizeof(packet));
+
+	c = sendto(pingsock, packet, DEFDATALEN + ICMP_MINLEN, 0,
+			   (struct sockaddr *) &pingaddr, sizeof(struct sockaddr_in));
+
+	if (c < 0) {
+		if (ENABLE_FEATURE_CLEAN_UP) close(pingsock);
+		bb_perror_msg_and_die("sendto");
+	}
+
+	signal(SIGALRM, noresp);
+	alarm(5);					/* give the host 5000ms to respond */
+	/* listen for replies */
+	while (1) {
+		struct sockaddr_in from;
+		socklen_t fromlen = sizeof(from);
+
+		if ((c = recvfrom(pingsock, packet, sizeof(packet), 0,
+						  (struct sockaddr *) &from, &fromlen)) < 0) {
+			if (errno == EINTR)
+				continue;
+			bb_perror_msg("recvfrom");
+			continue;
+		}
+		if (c >= 76) {			/* ip + icmp */
+			struct iphdr *iphdr = (struct iphdr *) packet;
+
+			pkt = (struct icmp *) (packet + (iphdr->ihl << 2));	/* skip ip hdr */
+			if (pkt->icmp_type == ICMP_ECHOREPLY)
+				break;
+		}
+	}
+	if (ENABLE_FEATURE_CLEAN_UP) close(pingsock);
+	printf("%s is alive!\n", hostname);
+	return;
+}
+
+int ping_main(int argc, char **argv)
+{
+	argc--;
+	argv++;
+	if (argc < 1)
+		bb_show_usage();
+	ping(*argv);
+	return EXIT_SUCCESS;
+}
+
+#else /* ! CONFIG_FEATURE_FANCY_PING */
+
+/* full(er) version */
+
+#define OPT_STRING "qc:s:I:"
+enum {
+	OPT_QUIET = 1 << 0,
+};
+
+static struct sockaddr_in pingaddr;
+static struct sockaddr_in sourceaddr;
+static int pingsock = -1;
+static unsigned datalen; /* intentionally uninitialized to work around gcc bug */
+
+static unsigned long ntransmitted, nreceived, nrepeats, pingcount;
+static int myid;
+static unsigned long tmin = ULONG_MAX, tmax, tsum;
+static char rcvd_tbl[MAX_DUP_CHK / 8];
+
+static struct hostent *hostent;
+
+static void sendping(int);
+static void pingstats(int);
+static void unpack(char *, int, struct sockaddr_in *);
+
+#define	A(bit)		rcvd_tbl[(bit)>>3]	/* identify byte in array */
+#define	B(bit)		(1 << ((bit) & 0x07))	/* identify bit in byte */
+#define	SET(bit)	(A(bit) |= B(bit))
+#define	CLR(bit)	(A(bit) &= (~B(bit)))
+#define	TST(bit)	(A(bit) & B(bit))
+
+/**************************************************************************/
+
+static void pingstats(int junk)
+{
+	int status;
+
+	signal(SIGINT, SIG_IGN);
+
+	printf("\n--- %s ping statistics ---\n", hostent->h_name);
+	printf("%lu packets transmitted, ", ntransmitted);
+	printf("%lu packets received, ", nreceived);
+	if (nrepeats)
+		printf("%lu duplicates, ", nrepeats);
+	if (ntransmitted)
+		printf("%lu%% packet loss\n",
+			   (ntransmitted - nreceived) * 100 / ntransmitted);
+	if (nreceived)
+		printf("round-trip min/avg/max = %lu.%lu/%lu.%lu/%lu.%lu ms\n",
+			   tmin / 10, tmin % 10,
+			   (tsum / (nreceived + nrepeats)) / 10,
+			   (tsum / (nreceived + nrepeats)) % 10, tmax / 10, tmax % 10);
+	if (nreceived != 0)
+		status = EXIT_SUCCESS;
+	else
+		status = EXIT_FAILURE;
+	exit(status);
+}
+
+static void sendping(int junk)
+{
+	struct icmp *pkt;
+	int i;
+	char packet[datalen + ICMP_MINLEN];
+
+	pkt = (struct icmp *) packet;
+
+	pkt->icmp_type = ICMP_ECHO;
+	pkt->icmp_code = 0;
+	pkt->icmp_cksum = 0;
+	pkt->icmp_seq = htons(ntransmitted++);
+	pkt->icmp_id = myid;
+	CLR(ntohs(pkt->icmp_seq) % MAX_DUP_CHK);
+
+	gettimeofday((struct timeval *) &pkt->icmp_dun, NULL);
+	pkt->icmp_cksum = in_cksum((unsigned short *) pkt, sizeof(packet));
+
+	i = sendto(pingsock, packet, sizeof(packet), 0,
+			   (struct sockaddr *) &pingaddr, sizeof(struct sockaddr_in));
+
+	if (i < 0)
+		bb_perror_msg_and_die("sendto");
+	else if ((size_t)i != sizeof(packet))
+		bb_error_msg_and_die("ping wrote %d chars; %d expected", i,
+			   (int)sizeof(packet));
+
+	signal(SIGALRM, sendping);
+	if (pingcount == 0 || ntransmitted < pingcount) {	/* schedule next in 1s */
+		alarm(PINGINTERVAL);
+	} else {					/* done, wait for the last ping to come back */
+		/* todo, don't necessarily need to wait so long... */
+		signal(SIGALRM, pingstats);
+		alarm(MAXWAIT);
+	}
+}
+
+static char *icmp_type_name(int id)
+{
+	switch (id) {
+	case ICMP_ECHOREPLY:		return "Echo Reply";
+	case ICMP_DEST_UNREACH:		return "Destination Unreachable";
+	case ICMP_SOURCE_QUENCH:	return "Source Quench";
+	case ICMP_REDIRECT:			return "Redirect (change route)";
+	case ICMP_ECHO:				return "Echo Request";
+	case ICMP_TIME_EXCEEDED:	return "Time Exceeded";
+	case ICMP_PARAMETERPROB:	return "Parameter Problem";
+	case ICMP_TIMESTAMP:		return "Timestamp Request";
+	case ICMP_TIMESTAMPREPLY:	return "Timestamp Reply";
+	case ICMP_INFO_REQUEST:		return "Information Request";
+	case ICMP_INFO_REPLY:		return "Information Reply";
+	case ICMP_ADDRESS:			return "Address Mask Request";
+	case ICMP_ADDRESSREPLY:		return "Address Mask Reply";
+	default:					return "unknown ICMP type";
+	}
+}
+
+static void unpack(char *buf, int sz, struct sockaddr_in *from)
+{
+	struct icmp *icmppkt;
+	struct iphdr *iphdr;
+	struct timeval tv, *tp;
+	int hlen, dupflag;
+	unsigned long triptime;
+
+	gettimeofday(&tv, NULL);
+
+	/* discard if too short */
+	if (sz < (datalen + ICMP_MINLEN))
+		return;
+
+	/* check IP header */
+	iphdr = (struct iphdr *) buf;
+	hlen = iphdr->ihl << 2;
+	sz -= hlen;
+	icmppkt = (struct icmp *) (buf + hlen);
+	if (icmppkt->icmp_id != myid)
+		return;				/* not our ping */
+
+	if (icmppkt->icmp_type == ICMP_ECHOREPLY) {
+		u_int16_t recv_seq = ntohs(icmppkt->icmp_seq);
+		++nreceived;
+		tp = (struct timeval *) icmppkt->icmp_data;
+
+		if ((tv.tv_usec -= tp->tv_usec) < 0) {
+			--tv.tv_sec;
+			tv.tv_usec += 1000000;
+		}
+		tv.tv_sec -= tp->tv_sec;
+
+		triptime = tv.tv_sec * 10000 + (tv.tv_usec / 100);
+		tsum += triptime;
+		if (triptime < tmin)
+			tmin = triptime;
+		if (triptime > tmax)
+			tmax = triptime;
+
+		if (TST(recv_seq % MAX_DUP_CHK)) {
+			++nrepeats;
+			--nreceived;
+			dupflag = 1;
+		} else {
+			SET(recv_seq % MAX_DUP_CHK);
+			dupflag = 0;
+		}
+
+		if (option_mask32 & OPT_QUIET)
+			return;
+
+		printf("%d bytes from %s: icmp_seq=%u", sz,
+			   inet_ntoa(*(struct in_addr *) &from->sin_addr.s_addr),
+			   recv_seq);
+		printf(" ttl=%d", iphdr->ttl);
+		printf(" time=%lu.%lu ms", triptime / 10, triptime % 10);
+		if (dupflag)
+			printf(" (DUP!)");
+		puts("");
+	} else
+		if (icmppkt->icmp_type != ICMP_ECHO)
+			bb_error_msg("warning: got ICMP %d (%s)",
+					icmppkt->icmp_type, icmp_type_name(icmppkt->icmp_type));
+	fflush(stdout);
+}
+
+static void ping(const char *host)
+{
+	char packet[datalen + MAXIPLEN + MAXICMPLEN];
+	int sockopt;
+
+	pingsock = create_icmp_socket();
+
+	if (sourceaddr.sin_addr.s_addr) {
+		xbind(pingsock, (struct sockaddr*)&sourceaddr, sizeof(sourceaddr));
+	}
+
+	memset(&pingaddr, 0, sizeof(struct sockaddr_in));
+
+	pingaddr.sin_family = AF_INET;
+	hostent = xgethostbyname(host);
+	if (hostent->h_addrtype != AF_INET)
+		bb_error_msg_and_die("unknown address type; only AF_INET is currently supported");
+
+	memcpy(&pingaddr.sin_addr, hostent->h_addr, sizeof(pingaddr.sin_addr));
+
+	/* enable broadcast pings */
+	setsockopt_broadcast(pingsock);
+
+	/* set recv buf for broadcast pings */
+	sockopt = 48 * 1024;
+	setsockopt(pingsock, SOL_SOCKET, SO_RCVBUF, (char *) &sockopt,
+			   sizeof(sockopt));
+
+	printf("PING %s (%s)",
+			hostent->h_name,
+			inet_ntoa(*(struct in_addr *) &pingaddr.sin_addr.s_addr));
+	if (sourceaddr.sin_addr.s_addr) {
+		printf(" from %s",
+			inet_ntoa(*(struct in_addr *) &sourceaddr.sin_addr.s_addr));
+	}
+	printf(": %d data bytes\n", datalen);
+
+	signal(SIGINT, pingstats);
+
+	/* start the ping's going ... */
+	sendping(0);
+
+	/* listen for replies */
+	while (1) {
+		struct sockaddr_in from;
+		socklen_t fromlen = (socklen_t) sizeof(from);
+		int c;
+
+		if ((c = recvfrom(pingsock, packet, sizeof(packet), 0,
+						  (struct sockaddr *) &from, &fromlen)) < 0) {
+			if (errno == EINTR)
+				continue;
+			bb_perror_msg("recvfrom");
+			continue;
+		}
+		unpack(packet, c, &from);
+		if (pingcount > 0 && nreceived >= pingcount)
+			break;
+	}
+	pingstats(0);
+}
+
+/* TODO: consolidate ether-wake.c, dnsd.c, ifupdown.c, nslookup.c
+ * versions of below thing. BTW we have far too many "%u.%u.%u.%u" too...
+*/
+static int parse_nipquad(const char *str, struct sockaddr_in* addr)
+{
+	char dummy;
+	unsigned i1, i2, i3, i4;
+	if (sscanf(str, "%u.%u.%u.%u%c",
+			   &i1, &i2, &i3, &i4, &dummy) == 4
+	&& ( (i1|i2|i3|i4) <= 0xff )
+	) {
+		uint8_t* ptr = (uint8_t*)&addr->sin_addr;
+		ptr[0] = i1;
+		ptr[1] = i2;
+		ptr[2] = i3;
+		ptr[3] = i4;
+		return 0;
+	}
+	return 1; /* error */
+}
+
+int ping_main(int argc, char **argv)
+{
+	char *opt_c, *opt_s, *opt_I;
+
+	datalen = DEFDATALEN; /* initialized here rather than in global scope to work around gcc bug */
+
+	/* exactly one argument needed */
+	opt_complementary = "=1";
+	getopt32(argc, argv, OPT_STRING, &opt_c, &opt_s, &opt_I);
+	if (option_mask32 & 2) pingcount = xatoul(opt_c); // -c
+	if (option_mask32 & 4) datalen = xatou16(opt_s); // -s
+	if (option_mask32 & 8) { // -I
+/* TODO: ping6 accepts iface too:
+		if_index = if_nametoindex(*argv);
+		if (!if_index) ...
+make it true for ping. */
+		if (parse_nipquad(opt_I, &sourceaddr))
+			bb_show_usage();
+	}
+
+	myid = (int16_t) getpid();
+	ping(argv[optind]);
+	return EXIT_SUCCESS;
+}
+#endif /* ! CONFIG_FEATURE_FANCY_PING */
diff --git a/networking/ping6.c b/networking/ping6.c
new file mode 100644
index 0000000..9f0509e
--- /dev/null
+++ b/networking/ping6.c
@@ -0,0 +1,480 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * $Id: ping6.c,v 1.6 2004/03/15 08:28:48 andersen Exp $
+ * Mini ping implementation for busybox
+ *
+ * Copyright (C) 1999 by Randolph Chung <tausq@debian.org>
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ *
+ * This version of ping is adapted from the ping in netkit-base 0.10,
+ * which is:
+ *
+ * Copyright (c) 1989 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Mike Muuss.
+ *
+ * Original copyright notice is retained at the end of this file.
+ *
+ * This version is an adaptation of ping.c from busybox.
+ * The code was modified by Bart Visscher <magick@linux-fan.com>
+ */
+
+#include <sys/param.h>
+#include <sys/socket.h>
+#include <sys/file.h>
+#include <sys/times.h>
+#include <signal.h>
+
+#include <netinet/in.h>
+#include <netinet/ip6.h>
+#include <netinet/icmp6.h>
+#include <arpa/inet.h>
+#include <net/if.h>
+#include <netdb.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stddef.h>				/* offsetof */
+#include "busybox.h"
+
+enum {
+	DEFDATALEN = 56,
+	MAXIPLEN = 60,
+	MAXICMPLEN = 76,
+	MAXPACKET = 65468,
+	MAX_DUP_CHK = (8 * 128),
+	MAXWAIT = 10,
+	PINGINTERVAL = 1		/* second */
+};
+
+static void ping(const char *host);
+
+#ifndef CONFIG_FEATURE_FANCY_PING6
+
+/* simple version */
+
+static struct hostent *h;
+
+static void noresp(int ign)
+{
+	printf("No response from %s\n", h->h_name);
+	exit(EXIT_FAILURE);
+}
+
+static void ping(const char *host)
+{
+	struct sockaddr_in6 pingaddr;
+	struct icmp6_hdr *pkt;
+	int pingsock, c;
+	int sockopt;
+	char packet[DEFDATALEN + MAXIPLEN + MAXICMPLEN];
+
+	pingsock = create_icmp6_socket();
+
+	memset(&pingaddr, 0, sizeof(struct sockaddr_in));
+
+	pingaddr.sin6_family = AF_INET6;
+	h = xgethostbyname2(host, AF_INET6);
+	memcpy(&pingaddr.sin6_addr, h->h_addr, sizeof(pingaddr.sin6_addr));
+
+	pkt = (struct icmp6_hdr *) packet;
+	memset(pkt, 0, sizeof(packet));
+	pkt->icmp6_type = ICMP6_ECHO_REQUEST;
+
+	sockopt = offsetof(struct icmp6_hdr, icmp6_cksum);
+	setsockopt(pingsock, SOL_RAW, IPV6_CHECKSUM, (char *) &sockopt,
+			   sizeof(sockopt));
+
+	c = sendto(pingsock, packet, DEFDATALEN + sizeof (struct icmp6_hdr), 0,
+			   (struct sockaddr *) &pingaddr, sizeof(struct sockaddr_in6));
+
+	if (c < 0 || c != sizeof(packet)) {
+		if (ENABLE_FEATURE_CLEAN_UP) close(pingsock);
+		bb_perror_msg_and_die("sendto");
+	}
+
+	signal(SIGALRM, noresp);
+	alarm(5);					/* give the host 5000ms to respond */
+	/* listen for replies */
+	while (1) {
+		struct sockaddr_in6 from;
+		size_t fromlen = sizeof(from);
+
+		if ((c = recvfrom(pingsock, packet, sizeof(packet), 0,
+						  (struct sockaddr *) &from, &fromlen)) < 0) {
+			if (errno == EINTR)
+				continue;
+			bb_perror_msg("recvfrom");
+			continue;
+		}
+		if (c >= 8) {			/* icmp6_hdr */
+			pkt = (struct icmp6_hdr *) packet;
+			if (pkt->icmp6_type == ICMP6_ECHO_REPLY)
+				break;
+		}
+	}
+	if (ENABLE_FEATURE_CLEAN_UP) close(pingsock);
+	printf("%s is alive!\n", h->h_name);
+	return;
+}
+
+int ping6_main(int argc, char **argv)
+{
+	argc--;
+	argv++;
+	if (argc < 1)
+		bb_show_usage();
+	ping(*argv);
+	return EXIT_SUCCESS;
+}
+
+#else /* ! CONFIG_FEATURE_FANCY_PING6 */
+
+/* full(er) version */
+
+#define OPT_STRING "qvc:s:I:"
+enum {
+	OPT_QUIET = 1 << 0,
+	OPT_VERBOSE = 1 << 1,
+};
+
+static struct sockaddr_in6 pingaddr;
+static int pingsock = -1;
+static unsigned datalen; /* intentionally uninitialized to work around gcc bug */
+static int if_index;
+
+static unsigned long ntransmitted, nreceived, nrepeats, pingcount;
+static int myid;
+static unsigned long tmin = ULONG_MAX, tmax, tsum;
+static char rcvd_tbl[MAX_DUP_CHK / 8];
+
+static struct hostent *hostent;
+
+static void sendping(int);
+static void pingstats(int);
+static void unpack(char *, int, struct sockaddr_in6 *, int);
+
+#define	A(bit)		rcvd_tbl[(bit)>>3]	/* identify byte in array */
+#define	B(bit)		(1 << ((bit) & 0x07))	/* identify bit in byte */
+#define	SET(bit)	(A(bit) |= B(bit))
+#define	CLR(bit)	(A(bit) &= (~B(bit)))
+#define	TST(bit)	(A(bit) & B(bit))
+
+/**************************************************************************/
+
+static void pingstats(int junk)
+{
+	int status;
+
+	signal(SIGINT, SIG_IGN);
+
+	printf("\n--- %s ping statistics ---\n", hostent->h_name);
+	printf("%lu packets transmitted, ", ntransmitted);
+	printf("%lu packets received, ", nreceived);
+	if (nrepeats)
+		printf("%lu duplicates, ", nrepeats);
+	if (ntransmitted)
+		printf("%lu%% packet loss\n",
+			   (ntransmitted - nreceived) * 100 / ntransmitted);
+	if (nreceived)
+		printf("round-trip min/avg/max = %lu.%lu/%lu.%lu/%lu.%lu ms\n",
+			   tmin / 10, tmin % 10,
+			   (tsum / (nreceived + nrepeats)) / 10,
+			   (tsum / (nreceived + nrepeats)) % 10, tmax / 10, tmax % 10);
+	if (nreceived != 0)
+		status = EXIT_SUCCESS;
+	else
+		status = EXIT_FAILURE;
+	exit(status);
+}
+
+static void sendping(int junk)
+{
+	struct icmp6_hdr *pkt;
+	int i;
+	char packet[datalen + sizeof (struct icmp6_hdr)];
+
+	pkt = (struct icmp6_hdr *) packet;
+
+	pkt->icmp6_type = ICMP6_ECHO_REQUEST;
+	pkt->icmp6_code = 0;
+	pkt->icmp6_cksum = 0;
+	pkt->icmp6_seq = htons(ntransmitted++);
+	pkt->icmp6_id = myid;
+	CLR(pkt->icmp6_seq % MAX_DUP_CHK);
+
+	gettimeofday((struct timeval *) &pkt->icmp6_data8[4], NULL);
+
+	i = sendto(pingsock, packet, sizeof(packet), 0,
+			   (struct sockaddr *) &pingaddr, sizeof(struct sockaddr_in6));
+
+	if (i < 0)
+		bb_perror_msg_and_die("sendto");
+	else if ((size_t)i != sizeof(packet))
+		bb_error_msg_and_die("ping wrote %d chars; %d expected", i,
+			   (int)sizeof(packet));
+
+	signal(SIGALRM, sendping);
+	if (pingcount == 0 || ntransmitted < pingcount) {	/* schedule next in 1s */
+		alarm(PINGINTERVAL);
+	} else {					/* done, wait for the last ping to come back */
+		/* todo, don't necessarily need to wait so long... */
+		signal(SIGALRM, pingstats);
+		alarm(MAXWAIT);
+	}
+}
+
+/* RFC3542 changed some definitions from RFC2292 for no good reason, whee !
+ * the newer 3542 uses a MLD_ prefix where as 2292 uses ICMP6_ prefix */
+#ifndef MLD_LISTENER_QUERY
+# define MLD_LISTENER_QUERY ICMP6_MEMBERSHIP_QUERY
+#endif
+#ifndef MLD_LISTENER_REPORT
+# define MLD_LISTENER_REPORT ICMP6_MEMBERSHIP_REPORT
+#endif
+#ifndef MLD_LISTENER_REDUCTION
+# define MLD_LISTENER_REDUCTION ICMP6_MEMBERSHIP_REDUCTION
+#endif
+static char *icmp6_type_name(int id)
+{
+	switch (id) {
+	case ICMP6_DST_UNREACH:				return "Destination Unreachable";
+	case ICMP6_PACKET_TOO_BIG:			return "Packet too big";
+	case ICMP6_TIME_EXCEEDED:			return "Time Exceeded";
+	case ICMP6_PARAM_PROB:				return "Parameter Problem";
+	case ICMP6_ECHO_REPLY:				return "Echo Reply";
+	case ICMP6_ECHO_REQUEST:			return "Echo Request";
+	case MLD_LISTENER_QUERY:			return "Listener Query";
+	case MLD_LISTENER_REPORT:			return "Listener Report";
+	case MLD_LISTENER_REDUCTION:		return "Listener Reduction";
+	default:							return "unknown ICMP type";
+	}
+}
+
+static void unpack(char *packet, int sz, struct sockaddr_in6 *from, int hoplimit)
+{
+	struct icmp6_hdr *icmppkt;
+	struct timeval tv, *tp;
+	int dupflag;
+	unsigned long triptime;
+	char buf[INET6_ADDRSTRLEN];
+
+	gettimeofday(&tv, NULL);
+
+	/* discard if too short */
+	if (sz < (datalen + sizeof(struct icmp6_hdr)))
+		return;
+
+	icmppkt = (struct icmp6_hdr *) packet;
+	if (icmppkt->icmp6_id != myid)
+		return;				/* not our ping */
+
+	if (icmppkt->icmp6_type == ICMP6_ECHO_REPLY) {
+		++nreceived;
+		tp = (struct timeval *) &icmppkt->icmp6_data8[4];
+
+		if ((tv.tv_usec -= tp->tv_usec) < 0) {
+			--tv.tv_sec;
+			tv.tv_usec += 1000000;
+		}
+		tv.tv_sec -= tp->tv_sec;
+
+		triptime = tv.tv_sec * 10000 + (tv.tv_usec / 100);
+		tsum += triptime;
+		if (triptime < tmin)
+			tmin = triptime;
+		if (triptime > tmax)
+			tmax = triptime;
+
+		if (TST(icmppkt->icmp6_seq % MAX_DUP_CHK)) {
+			++nrepeats;
+			--nreceived;
+			dupflag = 1;
+		} else {
+			SET(icmppkt->icmp6_seq % MAX_DUP_CHK);
+			dupflag = 0;
+		}
+
+		if (option_mask32 & OPT_QUIET)
+			return;
+
+		printf("%d bytes from %s: icmp6_seq=%u", sz,
+			   inet_ntop(AF_INET6, &pingaddr.sin6_addr,
+						 buf, sizeof(buf)),
+			   icmppkt->icmp6_seq);
+		printf(" ttl=%d time=%lu.%lu ms", hoplimit,
+			   triptime / 10, triptime % 10);
+		if (dupflag)
+			printf(" (DUP!)");
+		puts("");
+	} else
+		if (icmppkt->icmp6_type != ICMP6_ECHO_REQUEST)
+			bb_error_msg("warning: got ICMP %d (%s)",
+					icmppkt->icmp6_type, icmp6_type_name(icmppkt->icmp6_type));
+}
+
+static void ping(const char *host)
+{
+	char packet[datalen + MAXIPLEN + MAXICMPLEN];
+	char buf[INET6_ADDRSTRLEN];
+	int sockopt;
+	struct msghdr msg;
+	struct sockaddr_in6 from;
+	struct iovec iov;
+	char control_buf[CMSG_SPACE(36)];
+
+	pingsock = create_icmp6_socket();
+
+	memset(&pingaddr, 0, sizeof(struct sockaddr_in));
+
+	pingaddr.sin6_family = AF_INET6;
+	hostent = xgethostbyname2(host, AF_INET6);
+	if (hostent->h_addrtype != AF_INET6)
+		bb_error_msg_and_die("unknown address type; only AF_INET6 is currently supported");
+
+	memcpy(&pingaddr.sin6_addr, hostent->h_addr, sizeof(pingaddr.sin6_addr));
+
+#ifdef ICMP6_FILTER
+	{
+		struct icmp6_filter filt;
+		if (!(option_mask32 & OPT_VERBOSE)) {
+			ICMP6_FILTER_SETBLOCKALL(&filt);
+			ICMP6_FILTER_SETPASS(ICMP6_ECHO_REPLY, &filt);
+		} else {
+			ICMP6_FILTER_SETPASSALL(&filt);
+		}
+		if (setsockopt(pingsock, IPPROTO_ICMPV6, ICMP6_FILTER, &filt,
+					   sizeof(filt)) < 0)
+			bb_error_msg_and_die("setsockopt(ICMP6_FILTER)");
+	}
+#endif /*ICMP6_FILTER*/
+
+	/* enable broadcast pings */
+	setsockopt_broadcast(pingsock);
+
+	/* set recv buf for broadcast pings */
+	sockopt = 48 * 1024;
+	setsockopt(pingsock, SOL_SOCKET, SO_RCVBUF, (char *) &sockopt,
+			   sizeof(sockopt));
+
+	sockopt = offsetof(struct icmp6_hdr, icmp6_cksum);
+	setsockopt(pingsock, SOL_RAW, IPV6_CHECKSUM, (char *) &sockopt,
+			   sizeof(sockopt));
+
+	sockopt = 1;
+	setsockopt(pingsock, SOL_IPV6, IPV6_HOPLIMIT, (char *) &sockopt,
+			   sizeof(sockopt));
+
+	if (if_index)
+		pingaddr.sin6_scope_id = if_index;
+
+	printf("PING %s (%s): %d data bytes\n",
+		   hostent->h_name,
+		   inet_ntop(AF_INET6, &pingaddr.sin6_addr,
+			buf, sizeof(buf)),
+		   datalen);
+
+	signal(SIGINT, pingstats);
+
+	/* start the ping's going ... */
+	sendping(0);
+
+	/* listen for replies */
+	msg.msg_name = &from;
+	msg.msg_namelen = sizeof(from);
+	msg.msg_iov = &iov;
+	msg.msg_iovlen = 1;
+	msg.msg_control = control_buf;
+	iov.iov_base = packet;
+	iov.iov_len = sizeof(packet);
+	while (1) {
+		int c;
+		struct cmsghdr *cmsgptr = NULL;
+		int hoplimit = -1;
+		msg.msg_controllen = sizeof(control_buf);
+
+		if ((c = recvmsg(pingsock, &msg, 0)) < 0) {
+			if (errno == EINTR)
+				continue;
+			bb_perror_msg("recvfrom");
+			continue;
+		}
+		for (cmsgptr = CMSG_FIRSTHDR(&msg); cmsgptr != NULL;
+			 cmsgptr = CMSG_NXTHDR(&msg, cmsgptr)) {
+			if (cmsgptr->cmsg_level == SOL_IPV6 &&
+				cmsgptr->cmsg_type == IPV6_HOPLIMIT ) {
+				hoplimit = *(int*)CMSG_DATA(cmsgptr);
+			}
+		}
+		unpack(packet, c, &from, hoplimit);
+		if (pingcount > 0 && nreceived >= pingcount)
+			break;
+	}
+	pingstats(0);
+}
+
+int ping6_main(int argc, char **argv)
+{
+	char *opt_c, *opt_s, *opt_I;
+
+	datalen = DEFDATALEN; /* initialized here rather than in global scope to work around gcc bug */
+
+	/* exactly one argument needed, -v and -q don't mix */
+	opt_complementary = "=1:q--v:v--q"; 
+	getopt32(argc, argv, OPT_STRING, &opt_c, &opt_s, &opt_I);
+	if (option_mask32 & 4) pingcount = xatoul(opt_c); // -c
+	if (option_mask32 & 8) datalen = xatou16(opt_s); // -s
+	if (option_mask32 & 0x10) { // -I
+		if_index = if_nametoindex(opt_I);
+		if (!if_index)
+			bb_error_msg_and_die(
+				"%s: invalid interface name", opt_I);
+	}
+
+	myid = (int16_t)getpid();
+	ping(argv[optind]);
+	return EXIT_SUCCESS;
+}
+#endif /* ! CONFIG_FEATURE_FANCY_PING6 */
+
+/*
+ * Copyright (c) 1989 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Mike Muuss.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * 3. <BSD Advertising Clause omitted per the July 22, 1999 licensing change
+ *		ftp://ftp.cs.berkeley.edu/pub/4bsd/README.Impt.License.Change>
+ *
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
diff --git a/networking/route.c b/networking/route.c
new file mode 100644
index 0000000..a8926f4
--- /dev/null
+++ b/networking/route.c
@@ -0,0 +1,703 @@
+/* vi: set sw=4 ts=4: */
+/* route
+ *
+ * Similar to the standard Unix route, but with only the necessary
+ * parts for AF_INET and AF_INET6
+ *
+ * Bjorn Wesen, Axis Communications AB
+ *
+ * Author of the original route:
+ *              Fred N. van Kempen, <waltje@uwalt.nl.mugnet.org>
+ *              (derived from FvK's 'route.c     1.70    01/04/94')
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ *
+ * $Id: route.c,v 1.26 2004/03/19 23:27:08 mjn3 Exp $
+ *
+ * displayroute() code added by Vladimir N. Oleynik <dzo@simtreas.ru>
+ * adjustments by Larry Doolittle  <LRDoolittle@lbl.gov>
+ *
+ * IPV6 support added by Bart Visscher <magick@linux-fan.com>
+ */
+
+/* 2004/03/09  Manuel Novoa III <mjn3@codepoet.org>
+ *
+ * Rewritten to fix several bugs, add additional error checking, and
+ * remove ridiculous amounts of bloat.
+ */
+
+#include "busybox.h"
+#include "inet_common.h"
+#include <getopt.h>
+#include <net/route.h>
+#include <net/if.h>
+
+
+#ifndef RTF_UP
+/* Keep this in sync with /usr/src/linux/include/linux/route.h */
+#define RTF_UP          0x0001	/* route usable                 */
+#define RTF_GATEWAY     0x0002	/* destination is a gateway     */
+#define RTF_HOST        0x0004	/* host entry (net otherwise)   */
+#define RTF_REINSTATE   0x0008	/* reinstate route after tmout  */
+#define RTF_DYNAMIC     0x0010	/* created dyn. (by redirect)   */
+#define RTF_MODIFIED    0x0020	/* modified dyn. (by redirect)  */
+#define RTF_MTU         0x0040	/* specific MTU for this route  */
+#ifndef RTF_MSS
+#define RTF_MSS         RTF_MTU	/* Compatibility :-(            */
+#endif
+#define RTF_WINDOW      0x0080	/* per route window clamping    */
+#define RTF_IRTT        0x0100	/* Initial round trip time      */
+#define RTF_REJECT      0x0200	/* Reject route                 */
+#endif
+
+#if defined (SIOCADDRTOLD) || defined (RTF_IRTT)	/* route */
+#define HAVE_NEW_ADDRT 1
+#endif
+
+#if HAVE_NEW_ADDRT
+#define mask_in_addr(x) (((struct sockaddr_in *)&((x).rt_genmask))->sin_addr.s_addr)
+#define full_mask(x) (x)
+#else
+#define mask_in_addr(x) ((x).rt_genmask)
+#define full_mask(x) (((struct sockaddr_in *)&(x))->sin_addr.s_addr)
+#endif
+
+/* The RTACTION entries must agree with tbl_verb[] below! */
+#define RTACTION_ADD		1
+#define RTACTION_DEL		2
+
+/* For the various tbl_*[] arrays, the 1st byte is the offset to
+ * the next entry and the 2nd byte is return value. */
+
+#define NET_FLAG			1
+#define HOST_FLAG			2
+
+/* We remap '-' to '#' to avoid problems with getopt. */
+static const char tbl_hash_net_host[] =
+	"\007\001#net\0"
+/*	"\010\002#host\0" */
+	"\007\002#host"				/* Since last, we can save a byte. */
+;
+
+#define KW_TAKES_ARG		020
+#define KW_SETS_FLAG		040
+
+#define KW_IPVx_METRIC		020
+#define KW_IPVx_NETMASK		021
+#define KW_IPVx_GATEWAY		022
+#define KW_IPVx_MSS			023
+#define KW_IPVx_WINDOW		024
+#define KW_IPVx_IRTT		025
+#define KW_IPVx_DEVICE		026
+
+#define KW_IPVx_FLAG_ONLY	040
+#define KW_IPVx_REJECT		040
+#define KW_IPVx_MOD			041
+#define KW_IPVx_DYN			042
+#define KW_IPVx_REINSTATE	043
+
+static const char tbl_ipvx[] =
+	/* 020 is the "takes an arg" bit */
+#if HAVE_NEW_ADDRT
+	"\011\020metric\0"
+#endif
+	"\012\021netmask\0"
+	"\005\022gw\0"
+	"\012\022gateway\0"
+	"\006\023mss\0"
+	"\011\024window\0"
+#ifdef RTF_IRTT
+	"\007\025irtt\0"
+#endif
+	"\006\026dev\0"
+	"\011\026device\0"
+	/* 040 is the "sets a flag" bit - MUST match flags_ipvx[] values below. */
+#ifdef RTF_REJECT
+	"\011\040reject\0"
+#endif
+	"\006\041mod\0"
+	"\006\042dyn\0"
+/*	"\014\043reinstate\0" */
+	"\013\043reinstate"			/* Since last, we can save a byte. */
+;
+
+static const int flags_ipvx[] = { /* MUST match tbl_ipvx[] values above. */
+#ifdef RTF_REJECT
+	RTF_REJECT,
+#endif
+	RTF_MODIFIED,
+	RTF_DYNAMIC,
+	RTF_REINSTATE
+};
+
+static int kw_lookup(const char *kwtbl, char ***pargs)
+{
+	if (**pargs) {
+		do {
+			if (strcmp(kwtbl+2, **pargs) == 0) { /* Found a match. */
+				*pargs += 1;
+				if (kwtbl[1] & KW_TAKES_ARG) {
+					if (!**pargs) {	/* No more args! */
+						bb_show_usage();
+					}
+					*pargs += 1; /* Calling routine will use args[-1]. */
+				}
+				return kwtbl[1];
+			}
+			kwtbl += *kwtbl;
+		} while (*kwtbl);
+	}
+	return 0;
+}
+
+/* Add or delete a route, depending on action. */
+
+static void INET_setroute(int action, char **args)
+{
+	struct rtentry rt;
+	const char *netmask = NULL;
+	int skfd, isnet, xflag;
+
+	/* Grab the -net or -host options.  Remember they were transformed. */
+	xflag = kw_lookup(tbl_hash_net_host, &args);
+
+	/* If we did grab -net or -host, make sure we still have an arg left. */
+	if (*args == NULL) {
+		bb_show_usage();
+	}
+
+	/* Clean out the RTREQ structure. */
+	memset((char *) &rt, 0, sizeof(struct rtentry));
+
+	{
+		const char *target = *args++;
+		char *prefix;
+
+		/* recognize x.x.x.x/mask format. */
+		prefix = strchr(target, '/');
+		if(prefix) {
+			int prefix_len;
+
+			prefix_len = xatoul_range(prefix+1, 0, 32);
+			mask_in_addr(rt) = htonl( ~ (0xffffffffUL >> prefix_len));
+			*prefix = '\0';
+#if HAVE_NEW_ADDRT
+			rt.rt_genmask.sa_family = AF_INET;
+#endif
+		} else {
+			/* Default netmask. */
+			netmask = bb_str_default;
+		}
+		/* Prefer hostname lookup is -host flag (xflag==1) was given. */
+		isnet = INET_resolve(target, (struct sockaddr_in *) &rt.rt_dst,
+							 (xflag & HOST_FLAG));
+		if (isnet < 0) {
+			bb_error_msg_and_die("resolving %s", target);
+		}
+		if(prefix) {
+			/* do not destroy prefix for process args */
+			*prefix = '/';
+		}
+	}
+
+	if (xflag) {		/* Reinit isnet if -net or -host was specified. */
+		isnet = (xflag & NET_FLAG);
+	}
+
+	/* Fill in the other fields. */
+	rt.rt_flags = ((isnet) ? RTF_UP : (RTF_UP | RTF_HOST));
+
+	while (*args) {
+		int k = kw_lookup(tbl_ipvx, &args);
+		const char *args_m1 = args[-1];
+
+		if (k & KW_IPVx_FLAG_ONLY) {
+			rt.rt_flags |= flags_ipvx[k & 3];
+			continue;
+		}
+
+#if HAVE_NEW_ADDRT
+		if (k == KW_IPVx_METRIC) {
+			rt.rt_metric = xatoul(args_m1) + 1;
+			continue;
+		}
+#endif
+
+		if (k == KW_IPVx_NETMASK) {
+			struct sockaddr mask;
+
+			if (mask_in_addr(rt)) {
+				bb_show_usage();
+			}
+
+			netmask = args_m1;
+			isnet = INET_resolve(netmask, (struct sockaddr_in *) &mask, 0);
+			if (isnet < 0) {
+				bb_error_msg_and_die("resolving %s", netmask);
+			}
+			rt.rt_genmask = full_mask(mask);
+			continue;
+		}
+
+		if (k == KW_IPVx_GATEWAY) {
+			if (rt.rt_flags & RTF_GATEWAY) {
+				bb_show_usage();
+			}
+
+			isnet = INET_resolve(args_m1,
+								 (struct sockaddr_in *) &rt.rt_gateway, 1);
+			rt.rt_flags |= RTF_GATEWAY;
+
+			if (isnet) {
+				if (isnet < 0) {
+					bb_error_msg_and_die("resolving %s", args_m1);
+				}
+				bb_error_msg_and_die("gateway %s is a NETWORK", args_m1);
+			}
+			continue;
+		}
+
+		if (k == KW_IPVx_MSS) {	/* Check valid MSS bounds. */
+			rt.rt_flags |= RTF_MSS;
+			rt.rt_mss = xatoul_range(args_m1, 64, 32768);
+			continue;
+		}
+
+		if (k == KW_IPVx_WINDOW) {	/* Check valid window bounds. */
+			rt.rt_flags |= RTF_WINDOW;
+			rt.rt_window = xatoul_range(args_m1, 128, INT_MAX);
+			continue;
+		}
+
+#ifdef RTF_IRTT
+		if (k == KW_IPVx_IRTT) {
+			rt.rt_flags |= RTF_IRTT;
+			rt.rt_irtt = xatoul(args_m1);
+			rt.rt_irtt *= (sysconf(_SC_CLK_TCK) / 100);	/* FIXME */
+#if 0					/* FIXME: do we need to check anything of this? */
+			if (rt.rt_irtt < 1 || rt.rt_irtt > (120 * HZ)) {
+				bb_error_msg_and_die("bad irtt");
+			}
+#endif
+			continue;
+		}
+#endif
+
+		/* Device is special in that it can be the last arg specified
+		 * and doesn't requre the dev/device keyword in that case. */
+		if (!rt.rt_dev && ((k == KW_IPVx_DEVICE) || (!k && !*++args))) {
+			/* Don't use args_m1 here since args may have changed! */
+			rt.rt_dev = args[-1];
+			continue;
+		}
+
+		/* Nothing matched. */
+		bb_show_usage();
+	}
+
+#ifdef RTF_REJECT
+	if ((rt.rt_flags & RTF_REJECT) && !rt.rt_dev) {
+		rt.rt_dev = "lo";
+	}
+#endif
+
+	/* sanity checks.. */
+	if (mask_in_addr(rt)) {
+		unsigned long mask = mask_in_addr(rt);
+
+		mask = ~ntohl(mask);
+		if ((rt.rt_flags & RTF_HOST) && mask != 0xffffffff) {
+			bb_error_msg_and_die("netmask %.8x and host route conflict",
+								 (unsigned int) mask);
+		}
+		if (mask & (mask + 1)) {
+			bb_error_msg_and_die("bogus netmask %s", netmask);
+		}
+		mask = ((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr;
+		if (mask & ~mask_in_addr(rt)) {
+			bb_error_msg_and_die("netmask and route address conflict");
+		}
+	}
+
+	/* Fill out netmask if still unset */
+	if ((action == RTACTION_ADD) && (rt.rt_flags & RTF_HOST)) {
+		mask_in_addr(rt) = 0xffffffff;
+	}
+
+	/* Create a socket to the INET kernel. */
+	skfd = xsocket(AF_INET, SOCK_DGRAM, 0);
+
+	if (ioctl(skfd, ((action==RTACTION_ADD) ? SIOCADDRT : SIOCDELRT), &rt)<0) {
+		bb_perror_msg_and_die("SIOC[ADD|DEL]RT");
+	}
+
+	if (ENABLE_FEATURE_CLEAN_UP) close(skfd);
+}
+
+#ifdef CONFIG_FEATURE_IPV6
+
+static void INET6_setroute(int action, char **args)
+{
+	struct sockaddr_in6 sa6;
+	struct in6_rtmsg rt;
+	int prefix_len, skfd;
+	const char *devname;
+
+		/* We know args isn't NULL from the check in route_main. */
+		const char *target = *args++;
+
+		if (strcmp(target, bb_str_default) == 0) {
+			prefix_len = 0;
+			memset(&sa6, 0, sizeof(sa6));
+		} else {
+			char *cp;
+			if ((cp = strchr(target, '/'))) { /* Yes... const to non is ok. */
+				*cp = 0;
+				prefix_len = xatoul_range(cp+1, 0, 128);
+			} else {
+				prefix_len = 128;
+			}
+			if (INET6_resolve(target, (struct sockaddr_in6 *) &sa6) < 0) {
+				bb_error_msg_and_die("resolving %s", target);
+			}
+		}
+
+	/* Clean out the RTREQ structure. */
+	memset((char *) &rt, 0, sizeof(struct in6_rtmsg));
+
+	memcpy(&rt.rtmsg_dst, sa6.sin6_addr.s6_addr, sizeof(struct in6_addr));
+
+	/* Fill in the other fields. */
+	rt.rtmsg_dst_len = prefix_len;
+	rt.rtmsg_flags = ((prefix_len == 128) ? (RTF_UP|RTF_HOST) : RTF_UP);
+	rt.rtmsg_metric = 1;
+
+	devname = NULL;
+
+	while (*args) {
+		int k = kw_lookup(tbl_ipvx, &args);
+		const char *args_m1 = args[-1];
+
+		if ((k == KW_IPVx_MOD) || (k == KW_IPVx_DYN)) {
+			rt.rtmsg_flags |= flags_ipvx[k & 3];
+			continue;
+		}
+
+		if (k == KW_IPVx_METRIC) {
+			rt.rtmsg_metric = xatoul(args_m1);
+			continue;
+		}
+
+		if (k == KW_IPVx_GATEWAY) {
+			if (rt.rtmsg_flags & RTF_GATEWAY) {
+				bb_show_usage();
+			}
+
+			if (INET6_resolve(args_m1, (struct sockaddr_in6 *) &sa6) < 0) {
+				bb_error_msg_and_die("resolving %s", args_m1);
+			}
+			memcpy(&rt.rtmsg_gateway, sa6.sin6_addr.s6_addr,
+				   sizeof(struct in6_addr));
+			rt.rtmsg_flags |= RTF_GATEWAY;
+			continue;
+		}
+
+		/* Device is special in that it can be the last arg specified
+		 * and doesn't requre the dev/device keyword in that case. */
+		if (!devname && ((k == KW_IPVx_DEVICE) || (!k && !*++args))) {
+			/* Don't use args_m1 here since args may have changed! */
+			devname = args[-1];
+			continue;
+		}
+
+		/* Nothing matched. */
+		bb_show_usage();
+	}
+
+	/* Create a socket to the INET6 kernel. */
+	skfd = xsocket(AF_INET6, SOCK_DGRAM, 0);
+
+	rt.rtmsg_ifindex = 0;
+
+	if (devname) {
+		struct ifreq ifr;
+		memset(&ifr, 0, sizeof(ifr));
+		strncpy(ifr.ifr_name, devname, sizeof(ifr.ifr_name));
+
+		if (ioctl(skfd, SIOGIFINDEX, &ifr) < 0) {
+			bb_perror_msg_and_die("SIOGIFINDEX");
+		}
+		rt.rtmsg_ifindex = ifr.ifr_ifindex;
+	}
+
+	/* Tell the kernel to accept this route. */
+	if (ioctl(skfd, ((action==RTACTION_ADD) ? SIOCADDRT : SIOCDELRT), &rt)<0) {
+		bb_perror_msg_and_die("SIOC[ADD|DEL]RT");
+	}
+
+	if (ENABLE_FEATURE_CLEAN_UP) close(skfd);
+}
+#endif
+
+static const unsigned int flagvals[] = { /* Must agree with flagchars[]. */
+	RTF_GATEWAY,
+	RTF_HOST,
+	RTF_REINSTATE,
+	RTF_DYNAMIC,
+	RTF_MODIFIED,
+#ifdef CONFIG_FEATURE_IPV6
+	RTF_DEFAULT,
+	RTF_ADDRCONF,
+	RTF_CACHE
+#endif
+};
+
+#define IPV4_MASK (RTF_GATEWAY|RTF_HOST|RTF_REINSTATE|RTF_DYNAMIC|RTF_MODIFIED)
+#define IPV6_MASK (RTF_GATEWAY|RTF_HOST|RTF_DEFAULT|RTF_ADDRCONF|RTF_CACHE)
+
+static const char flagchars[] =		/* Must agree with flagvals[]. */
+	"GHRDM"
+#ifdef CONFIG_FEATURE_IPV6
+	"DAC"
+#endif
+;
+
+static
+#ifndef CONFIG_FEATURE_IPV6
+__inline
+#endif
+void set_flags(char *flagstr, int flags)
+{
+	int i;
+
+	*flagstr++ = 'U';
+
+	for (i=0 ; (*flagstr = flagchars[i]) != 0 ; i++) {
+		if (flags & flagvals[i]) {
+			++flagstr;
+		}
+	}
+}
+
+/* also used in netstat */
+void displayroutes(int noresolve, int netstatfmt);
+void displayroutes(int noresolve, int netstatfmt)
+{
+	char devname[64], flags[16], sdest[16], sgw[16];
+	unsigned long int d, g, m;
+	int flgs, ref, use, metric, mtu, win, ir;
+	struct sockaddr_in s_addr;
+	struct in_addr mask;
+
+	FILE *fp = xfopen("/proc/net/route", "r");
+
+	printf("Kernel IP routing table\n"
+			  "Destination     Gateway         Genmask"
+			  "         Flags %s Iface\n",
+			  netstatfmt ? "  MSS Window  irtt" : "Metric Ref    Use");
+
+	if (fscanf(fp, "%*[^\n]\n") < 0) { /* Skip the first line. */
+		goto ERROR;		   /* Empty or missing line, or read error. */
+	}
+	while (1) {
+		int r;
+		r = fscanf(fp, "%63s%lx%lx%X%d%d%d%lx%d%d%d\n",
+				   devname, &d, &g, &flgs, &ref, &use, &metric, &m,
+				   &mtu, &win, &ir);
+		if (r != 11) {
+			if ((r < 0) && feof(fp)) { /* EOF with no (nonspace) chars read. */
+				break;
+			}
+		ERROR:
+			bb_error_msg_and_die("fscanf");
+		}
+
+		if (!(flgs & RTF_UP)) { /* Skip interfaces that are down. */
+			continue;
+		}
+
+		set_flags(flags, (flgs & IPV4_MASK));
+#ifdef RTF_REJECT
+		if (flgs & RTF_REJECT) {
+			flags[0] = '!';
+		}
+#endif
+
+		memset(&s_addr, 0, sizeof(struct sockaddr_in));
+		s_addr.sin_family = AF_INET;
+		s_addr.sin_addr.s_addr = d;
+		INET_rresolve(sdest, sizeof(sdest), &s_addr,
+					  (noresolve | 0x8000), m);	/* Default instead of *. */
+
+		s_addr.sin_addr.s_addr = g;
+		INET_rresolve(sgw, sizeof(sgw), &s_addr,
+					  (noresolve | 0x4000), m);	/* Host instead of net. */
+
+		mask.s_addr = m;
+		printf("%-16s%-16s%-16s%-6s", sdest, sgw, inet_ntoa(mask), flags);
+		if (netstatfmt) {
+			printf("%5d %-5d %6d %s\n", mtu, win, ir, devname);
+		} else {
+			printf("%-6d %-2d %7d %s\n", metric, ref, use, devname);
+		}
+	}
+}
+
+#ifdef CONFIG_FEATURE_IPV6
+
+static void INET6_displayroutes(int noresolve)
+{
+	char addr6[128], naddr6[128];
+	/* In addr6x, we store both 40-byte ':'-delimited ipv6 addresses.
+	 * We read the non-delimited strings into the tail of the buffer
+	 * using fscanf and then modify the buffer by shifting forward
+	 * while inserting ':'s and the nul terminator for the first string.
+	 * Hence the strings are at addr6x and addr6x+40.  This generates
+	 * _much_ less code than the previous (upstream) approach. */
+	char addr6x[80];
+	char iface[16], flags[16];
+	int iflags, metric, refcnt, use, prefix_len, slen;
+	struct sockaddr_in6 snaddr6;
+
+	FILE *fp = xfopen("/proc/net/ipv6_route", "r");
+
+	printf("Kernel IPv6 routing table\n%-44s%-40s"
+			  "Flags Metric Ref    Use Iface\n",
+			  "Destination", "Next Hop");
+
+	while (1) {
+		int r;
+		r = fscanf(fp, "%32s%x%*s%x%32s%x%x%x%x%s\n",
+				   addr6x+14, &prefix_len, &slen, addr6x+40+7,
+				   &metric, &use, &refcnt, &iflags, iface);
+		if (r != 9) {
+			if ((r < 0) && feof(fp)) { /* EOF with no (nonspace) chars read. */
+				break;
+			}
+		ERROR:
+			bb_error_msg_and_die("fscanf");
+		}
+
+		/* Do the addr6x shift-and-insert changes to ':'-delimit addresses.
+		 * For now, always do this to validate the proc route format, even
+		 * if the interface is down. */
+		{
+			int i = 0;
+			char *p = addr6x+14;
+
+			do {
+				if (!*p) {
+					if (i==40) { /* nul terminator for 1st address? */
+						addr6x[39] = 0;	/* Fixup... need 0 instead of ':'. */
+						++p;	/* Skip and continue. */
+						continue;
+					}
+					goto ERROR;
+				}
+				addr6x[i++] = *p++;
+				if (!((i+1)%5)) {
+					addr6x[i++] = ':';
+				}
+			} while (i < 40+28+7);
+		}
+
+		if (!(iflags & RTF_UP)) { /* Skip interfaces that are down. */
+			continue;
+		}
+
+		set_flags(flags, (iflags & IPV6_MASK));
+
+		r = 0;
+		do {
+			inet_pton(AF_INET6, addr6x + r,
+					  (struct sockaddr *) &snaddr6.sin6_addr);
+			snaddr6.sin6_family = AF_INET6;
+			INET6_rresolve(naddr6, sizeof(naddr6),
+						   (struct sockaddr_in6 *) &snaddr6,
+						   0x0fff /* Apparently, upstream never resolves. */
+						   );
+
+			if (!r) {			/* 1st pass */
+				snprintf(addr6, sizeof(addr6), "%s/%d", naddr6, prefix_len);
+				r += 40;
+			} else {			/* 2nd pass */
+				/* Print the info. */
+				printf("%-43s %-39s %-5s %-6d %-2d %7d %-8s\n",
+						  addr6, naddr6, flags, metric, refcnt, use, iface);
+				break;
+			}
+		} while (1);
+	}
+}
+
+#endif
+
+#define ROUTE_OPT_A			0x01
+#define ROUTE_OPT_n			0x02
+#define ROUTE_OPT_e			0x04
+#define ROUTE_OPT_INET6		0x08 /* Not an actual option. See below. */
+
+/* 1st byte is offset to next entry offset.  2nd byte is return value. */
+static const char tbl_verb[] =	/* 2nd byte matches RTACTION_* code */
+	"\006\001add\0"
+	"\006\002del\0"
+/*	"\011\002delete\0" */
+	"\010\002delete"			/* Since last, we can save a byte. */
+;
+
+int route_main(int argc, char **argv)
+{
+	unsigned opt;
+	int what;
+	char *family;
+	char **p;
+
+	/* First, remap '-net' and '-host' to avoid getopt problems. */
+	p = argv;
+	while (*++p) {
+		if ((strcmp(*p, "-net") == 0) || (strcmp(*p, "-host") == 0)) {
+			p[0][0] = '#';
+		}
+	}
+
+	opt = getopt32(argc, argv, "A:ne", &family);
+
+	if ((opt & ROUTE_OPT_A) && strcmp(family, "inet")) {
+#ifdef CONFIG_FEATURE_IPV6
+		if (strcmp(family, "inet6") == 0) {
+			opt |= ROUTE_OPT_INET6;	/* Set flag for ipv6. */
+		} else
+#endif
+		bb_show_usage();
+	}
+
+	argv += optind;
+
+	/* No more args means display the routing table. */
+	if (!*argv) {
+		int noresolve = (opt & ROUTE_OPT_n) ? 0x0fff : 0;
+#ifdef CONFIG_FEATURE_IPV6
+		if (opt & ROUTE_OPT_INET6)
+			INET6_displayroutes(noresolve);
+		else
+#endif
+			displayroutes(noresolve, opt & ROUTE_OPT_e);
+
+		fflush_stdout_and_exit(EXIT_SUCCESS);
+	}
+
+	/* Check verb.  At the moment, must be add, del, or delete. */
+	what = kw_lookup(tbl_verb, &argv);
+	if (!what || !*argv) {		/* Unknown verb or no more args. */
+		bb_show_usage();
+	}
+
+#ifdef CONFIG_FEATURE_IPV6
+	if (opt & ROUTE_OPT_INET6)
+		INET6_setroute(what, argv);
+	else
+#endif
+		INET_setroute(what, argv);
+
+	return EXIT_SUCCESS;
+}
diff --git a/networking/telnet.c b/networking/telnet.c
new file mode 100644
index 0000000..6085d88
--- /dev/null
+++ b/networking/telnet.c
@@ -0,0 +1,714 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * telnet implementation for busybox
+ *
+ * Author: Tomi Ollila <too@iki.fi>
+ * Copyright (C) 1994-2000 by Tomi Ollila
+ *
+ * Created: Thu Apr  7 13:29:41 1994 too
+ * Last modified: Fri Jun  9 14:34:24 2000 too
+ *
+ * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+ *
+ * HISTORY
+ * Revision 3.1  1994/04/17  11:31:54  too
+ * initial revision
+ * Modified 2000/06/13 for inclusion into BusyBox by Erik Andersen <andersen@codepoet.org>
+ * Modified 2001/05/07 to add ability to pass TTYPE to remote host by Jim McQuillan
+ * <jam@ltsp.org>
+ * Modified 2004/02/11 to add ability to pass the USER variable to remote host
+ * by Fernando Silveira <swrh@gmx.net>
+ *
+ */
+
+#include <termios.h>
+#include <unistd.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <signal.h>
+#include <arpa/telnet.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include "busybox.h"
+
+#ifdef DOTRACE
+#include <arpa/inet.h> /* for inet_ntoa()... */
+#define TRACE(x, y) do { if (x) printf y; } while (0)
+#else
+#define TRACE(x, y)
+#endif
+
+#define DATABUFSIZE  128
+#define IACBUFSIZE   128
+
+enum {
+	CHM_TRY = 0,
+	CHM_ON = 1,
+	CHM_OFF = 2,
+
+	UF_ECHO = 0x01,
+	UF_SGA = 0x02,
+
+	TS_0 = 1,
+	TS_IAC = 2,
+	TS_OPT = 3,
+	TS_SUB1 = 4,
+	TS_SUB2 = 5,
+};
+
+#define WriteCS(fd, str) write(fd, str, sizeof str -1)
+
+typedef unsigned char byte;
+
+/* use globals to reduce size ??? */ /* test this hypothesis later */
+static struct Globalvars {
+	int		netfd; /* console fd:s are 0 and 1 (and 2) */
+    /* same buffer used both for network and console read/write */
+	char    buf[DATABUFSIZE]; /* allocating so static size is smaller */
+	byte	telstate; /* telnet negotiation state from network input */
+	byte	telwish;  /* DO, DONT, WILL, WONT */
+	byte    charmode;
+	byte    telflags;
+	byte	gotsig;
+	byte	do_termios;
+	/* buffer to handle telnet negotiations */
+	char    iacbuf[IACBUFSIZE];
+	short	iaclen; /* could even use byte */
+	struct termios termios_def;
+	struct termios termios_raw;
+} G;
+
+#define xUSE_GLOBALVAR_PTR /* xUSE... -> don't use :D (makes smaller code) */
+
+#ifdef USE_GLOBALVAR_PTR
+struct Globalvars * Gptr;
+#define G (*Gptr)
+#endif
+
+static void iacflush(void)
+{
+	write(G.netfd, G.iacbuf, G.iaclen);
+	G.iaclen = 0;
+}
+
+/* Function prototypes */
+static void rawmode(void);
+static void cookmode(void);
+static void do_linemode(void);
+static void will_charmode(void);
+static void telopt(byte c);
+static int subneg(byte c);
+
+/* Some globals */
+static const int one = 1;
+
+#ifdef CONFIG_FEATURE_TELNET_TTYPE
+static char *ttype;
+#endif
+
+#ifdef CONFIG_FEATURE_TELNET_AUTOLOGIN
+static const char *autologin;
+#endif
+
+#ifdef CONFIG_FEATURE_AUTOWIDTH
+static int win_width, win_height;
+#endif
+
+static void doexit(int ev)
+{
+	cookmode();
+	exit(ev);
+}
+
+static void conescape(void)
+{
+	char b;
+
+	if (G.gotsig)	/* came from line  mode... go raw */
+		rawmode();
+
+	WriteCS(1, "\r\nConsole escape. Commands are:\r\n\n"
+			" l	go to line mode\r\n"
+			" c	go to character mode\r\n"
+			" z	suspend telnet\r\n"
+			" e	exit telnet\r\n");
+
+	if (read(0, &b, 1) <= 0)
+		doexit(1);
+
+	switch (b)
+	{
+	case 'l':
+		if (!G.gotsig)
+		{
+			do_linemode();
+			goto rrturn;
+		}
+		break;
+	case 'c':
+		if (G.gotsig)
+		{
+			will_charmode();
+			goto rrturn;
+		}
+		break;
+	case 'z':
+		cookmode();
+		kill(0, SIGTSTP);
+		rawmode();
+		break;
+	case 'e':
+		doexit(0);
+	}
+
+	WriteCS(1, "continuing...\r\n");
+
+	if (G.gotsig)
+		cookmode();
+
+ rrturn:
+	G.gotsig = 0;
+
+}
+static void handlenetoutput(int len)
+{
+	/*	here we could do smart tricks how to handle 0xFF:s in output
+	 *	stream  like writing twice every sequence of FF:s (thus doing
+	 *	many write()s. But I think interactive telnet application does
+	 *	not need to be 100% 8-bit clean, so changing every 0xff:s to
+	 *	0x7f:s
+	 *
+	 *	2002-mar-21, Przemyslaw Czerpak (druzus@polbox.com)
+	 *	I don't agree.
+	 *	first - I cannot use programs like sz/rz
+	 *	second - the 0x0D is sent as one character and if the next
+	 *		 char is 0x0A then it's eaten by a server side.
+	 *	third - whay doy you have to make 'many write()s'?
+	 *		I don't understand.
+	 *	So I implemented it. It's realy useful for me. I hope that
+	 *	others people will find it interesting to.
+	 */
+
+	int i, j;
+	byte * p = (byte*)G.buf;
+	byte outbuf[4*DATABUFSIZE];
+
+	for (i = len, j = 0; i > 0; i--, p++)
+	{
+		if (*p == 0x1d)
+		{
+			conescape();
+			return;
+		}
+		outbuf[j++] = *p;
+		if (*p == 0xff)
+			outbuf[j++] = 0xff;
+		else if (*p == 0x0d)
+			outbuf[j++] = 0x00;
+	}
+	if (j > 0 )
+		write(G.netfd, outbuf, j);
+}
+
+
+static void handlenetinput(int len)
+{
+	int i;
+	int cstart = 0;
+
+	for (i = 0; i < len; i++)
+	{
+		byte c = G.buf[i];
+
+		if (G.telstate == 0) /* most of the time state == 0 */
+		{
+			if (c == IAC)
+			{
+				cstart = i;
+				G.telstate = TS_IAC;
+			}
+		}
+		else
+			switch (G.telstate)
+			 {
+			 case TS_0:
+				 if (c == IAC)
+					 G.telstate = TS_IAC;
+				 else
+					 G.buf[cstart++] = c;
+				 break;
+
+			 case TS_IAC:
+				 if (c == IAC) /* IAC IAC -> 0xFF */
+				 {
+					 G.buf[cstart++] = c;
+					 G.telstate = TS_0;
+					 break;
+				 }
+				 /* else */
+				 switch (c)
+				 {
+				 case SB:
+					 G.telstate = TS_SUB1;
+					 break;
+				 case DO:
+				 case DONT:
+				 case WILL:
+				 case WONT:
+					 G.telwish =  c;
+					 G.telstate = TS_OPT;
+					 break;
+				 default:
+					 G.telstate = TS_0;	/* DATA MARK must be added later */
+				 }
+				 break;
+			 case TS_OPT: /* WILL, WONT, DO, DONT */
+				 telopt(c);
+				 G.telstate = TS_0;
+				 break;
+			 case TS_SUB1: /* Subnegotiation */
+			 case TS_SUB2: /* Subnegotiation */
+				 if (subneg(c))
+					 G.telstate = TS_0;
+				 break;
+			 }
+	}
+	if (G.telstate)
+	{
+		if (G.iaclen)			iacflush();
+		if (G.telstate == TS_0)	G.telstate = 0;
+
+		len = cstart;
+	}
+
+	if (len)
+		write(1, G.buf, len);
+}
+
+
+/* ******************************* */
+
+static void putiac(int c)
+{
+	G.iacbuf[G.iaclen++] = c;
+}
+
+
+static void putiac2(byte wwdd, byte c)
+{
+	if (G.iaclen + 3 > IACBUFSIZE)
+		iacflush();
+
+	putiac(IAC);
+	putiac(wwdd);
+	putiac(c);
+}
+
+#ifdef CONFIG_FEATURE_TELNET_TTYPE
+static void putiac_subopt(byte c, char *str)
+{
+	int	len = strlen(str) + 6;   // ( 2 + 1 + 1 + strlen + 2 )
+
+	if (G.iaclen + len > IACBUFSIZE)
+		iacflush();
+
+	putiac(IAC);
+	putiac(SB);
+	putiac(c);
+	putiac(0);
+
+	while(*str)
+		putiac(*str++);
+
+	putiac(IAC);
+	putiac(SE);
+}
+#endif
+
+#ifdef CONFIG_FEATURE_TELNET_AUTOLOGIN
+static void putiac_subopt_autologin(void)
+{
+	int len = strlen(autologin) + 6;	// (2 + 1 + 1 + strlen + 2)
+	char *user = "USER";
+
+	if (G.iaclen + len > IACBUFSIZE)
+		iacflush();
+
+	putiac(IAC);
+	putiac(SB);
+	putiac(TELOPT_NEW_ENVIRON);
+	putiac(TELQUAL_IS);
+	putiac(NEW_ENV_VAR);
+
+	while(*user)
+		putiac(*user++);
+
+	putiac(NEW_ENV_VALUE);
+
+	while(*autologin)
+		putiac(*autologin++);
+
+	putiac(IAC);
+	putiac(SE);
+}
+#endif
+
+#ifdef CONFIG_FEATURE_AUTOWIDTH
+static void putiac_naws(byte c, int x, int y)
+{
+	if (G.iaclen + 9 > IACBUFSIZE)
+		iacflush();
+
+	putiac(IAC);
+	putiac(SB);
+	putiac(c);
+
+	putiac((x >> 8) & 0xff);
+	putiac(x & 0xff);
+	putiac((y >> 8) & 0xff);
+	putiac(y & 0xff);
+
+	putiac(IAC);
+	putiac(SE);
+}
+#endif
+
+/* void putiacstring (subneg strings) */
+
+/* ******************************* */
+
+static char const escapecharis[] = "\r\nEscape character is ";
+
+static void setConMode(void)
+{
+	if (G.telflags & UF_ECHO)
+	{
+		if (G.charmode == CHM_TRY) {
+			G.charmode = CHM_ON;
+			printf("\r\nEntering character mode%s'^]'.\r\n", escapecharis);
+			rawmode();
+		}
+	}
+	else
+	{
+		if (G.charmode != CHM_OFF) {
+			G.charmode = CHM_OFF;
+			printf("\r\nEntering line mode%s'^C'.\r\n", escapecharis);
+			cookmode();
+		}
+	}
+}
+
+/* ******************************* */
+
+static void will_charmode(void)
+{
+	G.charmode = CHM_TRY;
+	G.telflags |= (UF_ECHO | UF_SGA);
+	setConMode();
+
+	putiac2(DO, TELOPT_ECHO);
+	putiac2(DO, TELOPT_SGA);
+	iacflush();
+}
+
+static void do_linemode(void)
+{
+	G.charmode = CHM_TRY;
+	G.telflags &= ~(UF_ECHO | UF_SGA);
+	setConMode();
+
+	putiac2(DONT, TELOPT_ECHO);
+	putiac2(DONT, TELOPT_SGA);
+	iacflush();
+}
+
+/* ******************************* */
+
+static void to_notsup(char c)
+{
+	if      (G.telwish == WILL)	putiac2(DONT, c);
+	else if (G.telwish == DO)	putiac2(WONT, c);
+}
+
+static void to_echo(void)
+{
+	/* if server requests ECHO, don't agree */
+	if      (G.telwish == DO) {	putiac2(WONT, TELOPT_ECHO);	return; }
+	else if (G.telwish == DONT)	return;
+
+	if (G.telflags & UF_ECHO)
+	{
+		if (G.telwish == WILL)
+			return;
+	}
+	else
+		if (G.telwish == WONT)
+			return;
+
+	if (G.charmode != CHM_OFF)
+		G.telflags ^= UF_ECHO;
+
+	if (G.telflags & UF_ECHO)
+		putiac2(DO, TELOPT_ECHO);
+	else
+		putiac2(DONT, TELOPT_ECHO);
+
+	setConMode();
+	WriteCS(1, "\r\n");  /* sudden modec */
+}
+
+static void to_sga(void)
+{
+	/* daemon always sends will/wont, client do/dont */
+
+	if (G.telflags & UF_SGA)
+	{
+		if (G.telwish == WILL)
+			return;
+	}
+	else
+		if (G.telwish == WONT)
+			return;
+
+	if ((G.telflags ^= UF_SGA) & UF_SGA) /* toggle */
+		putiac2(DO, TELOPT_SGA);
+	else
+		putiac2(DONT, TELOPT_SGA);
+
+	return;
+}
+
+#ifdef CONFIG_FEATURE_TELNET_TTYPE
+static void to_ttype(void)
+{
+	/* Tell server we will (or won't) do TTYPE */
+
+	if(ttype)
+		putiac2(WILL, TELOPT_TTYPE);
+	else
+		putiac2(WONT, TELOPT_TTYPE);
+
+	return;
+}
+#endif
+
+#ifdef CONFIG_FEATURE_TELNET_AUTOLOGIN
+static void to_new_environ(void)
+{
+	/* Tell server we will (or will not) do AUTOLOGIN */
+
+	if (autologin)
+		putiac2(WILL, TELOPT_NEW_ENVIRON);
+	else
+		putiac2(WONT, TELOPT_NEW_ENVIRON);
+
+	return;
+}
+#endif
+
+#ifdef CONFIG_FEATURE_AUTOWIDTH
+static void to_naws(void)
+{
+	/* Tell server we will do NAWS */
+	putiac2(WILL, TELOPT_NAWS);
+	return;
+}
+#endif
+
+static void telopt(byte c)
+{
+	switch (c)
+	{
+		case TELOPT_ECHO:		to_echo();	break;
+		case TELOPT_SGA:		to_sga();	break;
+#ifdef CONFIG_FEATURE_TELNET_TTYPE
+		case TELOPT_TTYPE:		to_ttype();break;
+#endif
+#ifdef CONFIG_FEATURE_TELNET_AUTOLOGIN
+		case TELOPT_NEW_ENVIRON:	to_new_environ();	break;
+#endif
+#ifdef CONFIG_FEATURE_AUTOWIDTH
+		case TELOPT_NAWS:		to_naws();
+								putiac_naws(c, win_width, win_height);
+								break;
+#endif
+		default:				to_notsup(c);
+								break;
+	}
+}
+
+
+/* ******************************* */
+
+/* subnegotiation -- ignore all (except TTYPE,NAWS) */
+
+static int subneg(byte c)
+{
+	switch (G.telstate)
+	{
+	case TS_SUB1:
+		if (c == IAC)
+			G.telstate = TS_SUB2;
+#ifdef CONFIG_FEATURE_TELNET_TTYPE
+		else
+		if (c == TELOPT_TTYPE)
+			putiac_subopt(TELOPT_TTYPE,ttype);
+#endif
+#ifdef CONFIG_FEATURE_TELNET_AUTOLOGIN
+		else
+		if (c == TELOPT_NEW_ENVIRON)
+			putiac_subopt_autologin();
+#endif
+		break;
+	case TS_SUB2:
+		if (c == SE)
+			return TRUE;
+		G.telstate = TS_SUB1;
+		/* break; */
+	}
+	return FALSE;
+}
+
+/* ******************************* */
+
+static void fgotsig(int sig)
+{
+	G.gotsig = sig;
+}
+
+
+static void rawmode(void)
+{
+	if (G.do_termios) tcsetattr(0, TCSADRAIN, &G.termios_raw);
+}
+
+static void cookmode(void)
+{
+	if (G.do_termios) tcsetattr(0, TCSADRAIN, &G.termios_def);
+}
+
+int telnet_main(int argc, char** argv)
+{
+	int len;
+	struct sockaddr_in s_in;
+#ifdef USE_POLL
+	struct pollfd ufds[2];
+#else
+	fd_set readfds;
+	int maxfd;
+#endif
+
+#ifdef CONFIG_FEATURE_AUTOWIDTH
+	get_terminal_width_height(0, &win_width, &win_height);
+#endif
+
+#ifdef CONFIG_FEATURE_TELNET_TTYPE
+	ttype = getenv("TERM");
+#endif
+
+	memset(&G, 0, sizeof G);
+
+	if (tcgetattr(0, &G.termios_def) >= 0) {
+		G.do_termios = 1;
+
+		G.termios_raw = G.termios_def;
+		cfmakeraw(&G.termios_raw);
+	}
+
+	if (argc < 2)
+		bb_show_usage();
+
+#ifdef CONFIG_FEATURE_TELNET_AUTOLOGIN
+	if (1 & getopt32(argc, argv, "al:", &autologin))
+		autologin = getenv("USER");
+
+	if (optind < argc) {
+		bb_lookup_host(&s_in, argv[optind++]);
+		s_in.sin_port = bb_lookup_port((optind < argc) ? argv[optind++] :
+				"telnet", "tcp", 23);
+		if (optind < argc)
+			bb_show_usage();
+	} else
+		bb_show_usage();
+#else
+	bb_lookup_host(&s_in, argv[1]);
+	s_in.sin_port = bb_lookup_port((argc == 3) ? argv[2] : "telnet", "tcp", 23);
+#endif
+
+	G.netfd = xconnect_tcp_v4(&s_in);
+
+	setsockopt(G.netfd, SOL_SOCKET, SO_KEEPALIVE, &one, sizeof one);
+
+	signal(SIGINT, fgotsig);
+
+#ifdef USE_POLL
+	ufds[0].fd = 0; ufds[1].fd = G.netfd;
+	ufds[0].events = ufds[1].events = POLLIN;
+#else
+	FD_ZERO(&readfds);
+	FD_SET(0, &readfds);
+	FD_SET(G.netfd, &readfds);
+	maxfd = G.netfd + 1;
+#endif
+
+	while (1)
+	{
+#ifndef USE_POLL
+		fd_set rfds = readfds;
+
+		switch (select(maxfd, &rfds, NULL, NULL, NULL))
+#else
+		switch (poll(ufds, 2, -1))
+#endif
+		{
+		case 0:
+			/* timeout */
+		case -1:
+			/* error, ignore and/or log something, bay go to loop */
+			if (G.gotsig)
+				conescape();
+			else
+				sleep(1);
+			break;
+		default:
+
+#ifdef USE_POLL
+			if (ufds[0].revents) /* well, should check POLLIN, but ... */
+#else
+			if (FD_ISSET(0, &rfds))
+#endif
+			{
+				len = read(0, G.buf, DATABUFSIZE);
+
+				if (len <= 0)
+					doexit(0);
+
+				TRACE(0, ("Read con: %d\n", len));
+
+				handlenetoutput(len);
+			}
+
+#ifdef USE_POLL
+			if (ufds[1].revents) /* well, should check POLLIN, but ... */
+#else
+			if (FD_ISSET(G.netfd, &rfds))
+#endif
+			{
+				len = read(G.netfd, G.buf, DATABUFSIZE);
+
+				if (len <= 0)
+				{
+					WriteCS(1, "Connection closed by foreign host.\r\n");
+					doexit(1);
+				}
+				TRACE(0, ("Read netfd (%d): %d\n", G.netfd, len));
+
+				handlenetinput(len);
+			}
+		}
+	}
+}
diff --git a/networking/telnetd.c b/networking/telnetd.c
new file mode 100644
index 0000000..604f65c
--- /dev/null
+++ b/networking/telnetd.c
@@ -0,0 +1,578 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Simple telnet server
+ * Bjorn Wesen, Axis Communications AB (bjornw@axis.com)
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ *
+ * ---------------------------------------------------------------------------
+ * (C) Copyright 2000, Axis Communications AB, LUND, SWEDEN
+ ****************************************************************************
+ *
+ * The telnetd manpage says it all:
+ *
+ *   Telnetd operates by allocating a pseudo-terminal device (see pty(4))  for
+ *   a client, then creating a login process which has the slave side of the
+ *   pseudo-terminal as stdin, stdout, and stderr. Telnetd manipulates the
+ *   master side of the pseudo-terminal, implementing the telnet protocol and
+ *   passing characters between the remote client and the login process.
+ *
+ * Vladimir Oleynik <dzo@simtreas.ru> 2001
+ *     Set process group corrections, initial busybox port
+ */
+
+/*#define DEBUG 1 */
+#define DEBUG 0
+
+#include "busybox.h"
+
+#if DEBUG
+#define TELCMDS
+#define TELOPTS
+#endif
+#include <arpa/telnet.h>
+#include <sys/syslog.h>
+
+
+#define BUFSIZE 4000
+
+#if ENABLE_FEATURE_IPV6
+typedef struct sockaddr_in6 sockaddr_type;
+#else
+typedef struct sockaddr_in sockaddr_type;
+#endif
+
+#if ENABLE_LOGIN
+static const char *loginpath = "/bin/login";
+#else
+static const char *loginpath = DEFAULT_SHELL;
+#endif
+
+static const char *issuefile = "/etc/issue.net";
+
+/* shell name and arguments */
+
+static const char *argv_init[2];
+
+/* structure that describes a session */
+
+struct tsession {
+	struct tsession *next;
+	int sockfd_read, sockfd_write, ptyfd;
+	int shell_pid;
+	/* two circular buffers */
+	char *buf1, *buf2;
+	int rdidx1, wridx1, size1;
+	int rdidx2, wridx2, size2;
+};
+
+/*
+   This is how the buffers are used. The arrows indicate the movement
+   of data.
+
+   +-------+     wridx1++     +------+     rdidx1++     +----------+
+   |       | <--------------  | buf1 | <--------------  |          |
+   |       |     size1--      +------+     size1++      |          |
+   |  pty  |                                            |  socket  |
+   |       |     rdidx2++     +------+     wridx2++     |          |
+   |       |  --------------> | buf2 |  --------------> |          |
+   +-------+     size2++      +------+     size2--      +----------+
+
+   Each session has got two buffers.
+*/
+
+static int maxfd;
+
+static struct tsession *sessions;
+
+
+/*
+   Remove all IAC's from the buffer pointed to by bf (received IACs are ignored
+   and must be removed so as to not be interpreted by the terminal).  Make an
+   uninterrupted string of characters fit for the terminal.  Do this by packing
+   all characters meant for the terminal sequentially towards the end of bf.
+
+   Return a pointer to the beginning of the characters meant for the terminal.
+   and make *num_totty the number of characters that should be sent to
+   the terminal.
+
+   Note - If an IAC (3 byte quantity) starts before (bf + len) but extends
+   past (bf + len) then that IAC will be left unprocessed and *processed will be
+   less than len.
+
+   FIXME - if we mean to send 0xFF to the terminal then it will be escaped,
+   what is the escape character?  We aren't handling that situation here.
+
+   CR-LF ->'s CR mapping is also done here, for convenience
+ */
+static char *
+remove_iacs(struct tsession *ts, int *pnum_totty)
+{
+	unsigned char *ptr0 = (unsigned char *)ts->buf1 + ts->wridx1;
+	unsigned char *ptr = ptr0;
+	unsigned char *totty = ptr;
+	unsigned char *end = ptr + MIN(BUFSIZE - ts->wridx1, ts->size1);
+	int processed;
+	int num_totty;
+
+	while (ptr < end) {
+		if (*ptr != IAC) {
+			int c = *ptr;
+			*totty++ = *ptr++;
+			/* We now map \r\n ==> \r for pragmatic reasons.
+			 * Many client implementations send \r\n when
+			 * the user hits the CarriageReturn key.
+			 */
+			if (c == '\r' && (*ptr == '\n' || *ptr == 0) && ptr < end)
+				ptr++;
+		} else {
+			/*
+			 * TELOPT_NAWS support!
+			 */
+			if ((ptr+2) >= end) {
+				/* only the beginning of the IAC is in the
+				buffer we were asked to process, we can't
+				process this char. */
+				break;
+			}
+
+			/*
+			 * IAC -> SB -> TELOPT_NAWS -> 4-byte -> IAC -> SE
+			 */
+			else if (ptr[1] == SB && ptr[2] == TELOPT_NAWS) {
+				struct winsize ws;
+				if ((ptr+8) >= end)
+					break;	/* incomplete, can't process */
+				ws.ws_col = (ptr[3] << 8) | ptr[4];
+				ws.ws_row = (ptr[5] << 8) | ptr[6];
+				ioctl(ts->ptyfd, TIOCSWINSZ, (char *)&ws);
+				ptr += 9;
+			} else {
+				/* skip 3-byte IAC non-SB cmd */
+#if DEBUG
+				fprintf(stderr, "Ignoring IAC %s,%s\n",
+					TELCMD(ptr[1]), TELOPT(ptr[2]));
+#endif
+				ptr += 3;
+			}
+		}
+	}
+
+	processed = ptr - ptr0;
+	num_totty = totty - ptr0;
+	/* the difference between processed and num_to tty
+	   is all the iacs we removed from the stream.
+	   Adjust buf1 accordingly. */
+	ts->wridx1 += processed - num_totty;
+	ts->size1 -= processed - num_totty;
+	*pnum_totty = num_totty;
+	/* move the chars meant for the terminal towards the end of the
+	buffer. */
+	return memmove(ptr - num_totty, ptr0, num_totty);
+}
+
+
+static int
+getpty(char *line, int size)
+{
+	int p;
+#if ENABLE_FEATURE_DEVPTS
+	p = open("/dev/ptmx", O_RDWR);
+	if (p > 0) {
+		const char *name;
+		grantpt(p);
+		unlockpt(p);
+		name = ptsname(p);
+		if (!name) {
+			bb_perror_msg("ptsname error (is /dev/pts mounted?)");
+			return -1;
+		}
+		safe_strncpy(line, name, size);
+		return p;
+	}
+#else
+	struct stat stb;
+	int i;
+	int j;
+
+	strcpy(line, "/dev/ptyXX");
+
+	for (i = 0; i < 16; i++) {
+		line[8] = "pqrstuvwxyzabcde"[i];
+		line[9] = '0';
+		if (stat(line, &stb) < 0) {
+			continue;
+		}
+		for (j = 0; j < 16; j++) {
+			line[9] = j < 10 ? j + '0' : j - 10 + 'a';
+			if (DEBUG)
+				fprintf(stderr, "Trying to open device: %s\n", line);
+			p = open(line, O_RDWR | O_NOCTTY);
+			if (p >= 0) {
+				line[5] = 't';
+				return p;
+			}
+		}
+	}
+#endif /* FEATURE_DEVPTS */
+	return -1;
+}
+
+
+static void
+send_iac(struct tsession *ts, unsigned char command, int option)
+{
+	/* We rely on that there is space in the buffer for now. */
+	char *b = ts->buf2 + ts->rdidx2;
+	*b++ = IAC;
+	*b++ = command;
+	*b++ = option;
+	ts->rdidx2 += 3;
+	ts->size2 += 3;
+}
+
+
+static struct tsession *
+make_new_session(
+		USE_FEATURE_TELNETD_STANDALONE(int sock_r, int sock_w)
+		SKIP_FEATURE_TELNETD_STANDALONE(void)
+) {
+	struct termios termbuf;
+	int fd, pid;
+	char tty_name[32];
+	struct tsession *ts = xzalloc(sizeof(struct tsession) + BUFSIZE * 2);
+
+	ts->buf1 = (char *)(&ts[1]);
+	ts->buf2 = ts->buf1 + BUFSIZE;
+
+	/* Got a new connection, set up a tty. */
+	fd = getpty(tty_name, 32);
+	if (fd < 0) {
+		bb_error_msg("all terminals in use");
+		return NULL;
+	}
+	if (fd > maxfd) maxfd = fd;
+	ndelay_on(ts->ptyfd = fd);
+#if ENABLE_FEATURE_TELNETD_STANDALONE
+	if (sock_w > maxfd) maxfd = sock_w;
+	if (sock_r > maxfd) maxfd = sock_r;
+	ndelay_on(ts->sockfd_write = sock_w);
+	ndelay_on(ts->sockfd_read = sock_r);
+#else
+	ts->sockfd_write = 1;
+	/* xzalloc: ts->sockfd_read = 0; */
+	ndelay_on(0);
+	ndelay_on(1);
+#endif
+	/* Make the telnet client understand we will echo characters so it
+	 * should not do it locally. We don't tell the client to run linemode,
+	 * because we want to handle line editing and tab completion and other
+	 * stuff that requires char-by-char support. */
+	send_iac(ts, DO, TELOPT_ECHO);
+	send_iac(ts, DO, TELOPT_NAWS);
+	send_iac(ts, DO, TELOPT_LFLOW);
+	send_iac(ts, WILL, TELOPT_ECHO);
+	send_iac(ts, WILL, TELOPT_SGA);
+
+	pid = fork();
+	if (pid < 0) {
+		free(ts);
+		close(fd);
+		bb_perror_msg("fork");
+		return NULL;
+	}
+	if (pid > 0) {
+		/* parent */
+		ts->shell_pid = pid;
+		return ts;
+	}
+	
+	/* child */
+
+	/* open the child's side of the tty. */
+	fd = xopen(tty_name, O_RDWR /*| O_NOCTTY*/);
+	dup2(fd, 0);
+	dup2(fd, 1);
+	dup2(fd, 2);
+	while (fd > 2) close(fd--);
+	/* make new process group */
+	setsid();
+	tcsetpgrp(0, getpid());
+
+	/* The pseudo-terminal allocated to the client is configured to operate in
+	 * cooked mode, and with XTABS CRMOD enabled (see tty(4)). */
+	tcgetattr(0, &termbuf);
+	termbuf.c_lflag |= ECHO; /* if we use readline we dont want this */
+	termbuf.c_oflag |= ONLCR|XTABS;
+	termbuf.c_iflag |= ICRNL;
+	termbuf.c_iflag &= ~IXOFF;
+	/*termbuf.c_lflag &= ~ICANON;*/
+	tcsetattr(0, TCSANOW, &termbuf);
+
+	print_login_issue(issuefile, NULL);
+
+	/* exec shell, with correct argv and env */
+	execv(loginpath, (char *const *)argv_init);
+	bb_perror_msg_and_die("execv");
+}
+
+#if ENABLE_FEATURE_TELNETD_STANDALONE
+
+static void
+free_session(struct tsession *ts)
+{
+	struct tsession *t = sessions;
+
+	/* unlink this telnet session from the session list */
+	if (t == ts)
+		sessions = ts->next;
+	else {
+		while (t->next != ts)
+			t = t->next;
+		t->next = ts->next;
+	}
+
+	kill(ts->shell_pid, SIGKILL);
+	wait4(ts->shell_pid, NULL, 0, NULL);
+	close(ts->ptyfd);
+	close(ts->sockfd_read);
+	/* error if ts->sockfd_read == ts->sockfd_write. So what? ;) */
+	close(ts->sockfd_write);
+	free(ts);
+
+	/* scan all sessions and find new maxfd */
+        ts = sessions;
+	maxfd = 0;
+	while (ts) {
+		if (maxfd < ts->ptyfd)
+			maxfd = ts->ptyfd;
+		if (maxfd < ts->sockfd_read)
+			maxfd = ts->sockfd_read;
+		if (maxfd < ts->sockfd_write)
+			maxfd = ts->sockfd_write;
+		ts = ts->next;
+	}
+}
+
+#else /* !FEATURE_TELNETD_STANDALONE */
+
+/* Never actually called */
+void free_session(struct tsession *ts);
+
+#endif
+
+
+int
+telnetd_main(int argc, char **argv)
+{
+	fd_set rdfdset, wrfdset;
+	unsigned opt;
+	int selret, maxlen, w, r;
+	struct tsession *ts;
+#if ENABLE_FEATURE_TELNETD_STANDALONE
+#define IS_INETD (opt & OPT_INETD)
+	int master_fd = -1; /* be happy, gcc */
+	unsigned portnbr = 23;
+	char *opt_bindaddr = NULL;
+	char *opt_portnbr;
+#else
+	enum {
+		IS_INETD = 1,
+		master_fd = -1,
+		portnbr = 23,
+	};
+#endif
+	enum {
+		OPT_PORT = 4 * ENABLE_FEATURE_TELNETD_STANDALONE,
+		OPT_FOREGROUND = 0x10 * ENABLE_FEATURE_TELNETD_STANDALONE,
+		OPT_INETD = 0x20 * ENABLE_FEATURE_TELNETD_STANDALONE,
+	};
+
+	opt = getopt32(argc, argv, "f:l:" USE_FEATURE_TELNETD_STANDALONE("p:b:Fi"),
+			&issuefile, &loginpath
+			USE_FEATURE_TELNETD_STANDALONE(, &opt_portnbr, &opt_bindaddr));
+	/* Redirect log to syslog early, if needed */
+	if (IS_INETD || !(opt & OPT_FOREGROUND)) {
+		openlog(applet_name, 0, LOG_USER);
+		logmode = LOGMODE_SYSLOG;
+	}
+	//if (opt & 1) // -f
+	//if (opt & 2) // -l
+	USE_FEATURE_TELNETD_STANDALONE(
+		if (opt & OPT_PORT) // -p
+			portnbr = xatou16(opt_portnbr);
+		//if (opt & 8) // -b
+		//if (opt & 0x10) // -F
+		//if (opt & 0x20) // -i
+	);
+
+	/* Used to check access(loginpath, X_OK) here. Pointless.
+	 * exec will do this for us for free later. */
+	argv_init[0] = loginpath;
+
+#if ENABLE_FEATURE_TELNETD_STANDALONE
+	if (IS_INETD) {
+		sessions = make_new_session(0, 1);
+	} else {
+		master_fd = create_and_bind_socket_ip4or6(opt_bindaddr, portnbr);
+		xlisten(master_fd, 1);
+		if (!(opt & OPT_FOREGROUND))
+			xdaemon(0, 0);
+	}
+#else
+	sessions = make_new_session();
+#endif
+
+	/* We don't want to die if just one session is broken */
+	signal(SIGPIPE, SIG_IGN);
+
+ again:
+	FD_ZERO(&rdfdset);
+	FD_ZERO(&wrfdset);
+	if (!IS_INETD) {
+		FD_SET(master_fd, &rdfdset);
+		/* This is needed because free_session() does not
+		 * take into account master_fd when it finds new
+		 * maxfd among remaining fd's: */
+		if (master_fd > maxfd)
+			maxfd = master_fd;
+	}
+
+	/* select on the master socket, all telnet sockets and their
+	 * ptys if there is room in their session buffers. */
+	ts = sessions;
+	while (ts) {
+		/* buf1 is used from socket to pty
+		 * buf2 is used from pty to socket */
+		if (ts->size1 > 0)       /* can write to pty */
+			FD_SET(ts->ptyfd, &wrfdset);
+		if (ts->size1 < BUFSIZE) /* can read from socket */
+			FD_SET(ts->sockfd_read, &rdfdset);
+		if (ts->size2 > 0)       /* can write to socket */
+			FD_SET(ts->sockfd_write, &wrfdset);
+		if (ts->size2 < BUFSIZE) /* can read from pty */
+			FD_SET(ts->ptyfd, &rdfdset);
+		ts = ts->next;
+	}
+
+	selret = select(maxfd + 1, &rdfdset, &wrfdset, 0, 0);
+	if (!selret)
+		return 0;
+
+#if ENABLE_FEATURE_TELNETD_STANDALONE
+	/* First check for and accept new sessions. */
+	if (!IS_INETD && FD_ISSET(master_fd, &rdfdset)) {
+		sockaddr_type sa;
+		int fd;
+		socklen_t salen;
+		struct tsession *new_ts;
+
+		salen = sizeof(sa);
+		fd = accept(master_fd, (struct sockaddr *)&sa, &salen);
+		if (fd < 0)
+			goto again;
+		/* Create a new session and link it into our active list */
+		new_ts = make_new_session(fd, fd);
+		if (new_ts) {
+			new_ts->next = sessions;
+			sessions = new_ts;
+		} else {
+			close(fd);
+		}
+	}
+#endif
+
+	/* Then check for data tunneling. */
+	ts = sessions;
+	while (ts) { /* For all sessions... */
+		struct tsession *next = ts->next; /* in case we free ts. */
+
+		if (ts->size1 && FD_ISSET(ts->ptyfd, &wrfdset)) {
+			int num_totty;
+			char *ptr;
+			/* Write to pty from buffer 1. */
+			ptr = remove_iacs(ts, &num_totty);
+			w = safe_write(ts->ptyfd, ptr, num_totty);
+			/* needed? if (w < 0 && errno == EAGAIN) continue; */
+			if (w < 0) {
+				if (IS_INETD)
+					return 0;
+				free_session(ts);
+				ts = next;
+				continue;
+			}
+			ts->wridx1 += w;
+			ts->size1 -= w;
+			if (ts->wridx1 == BUFSIZE)
+				ts->wridx1 = 0;
+		}
+
+		if (ts->size2 && FD_ISSET(ts->sockfd_write, &wrfdset)) {
+			/* Write to socket from buffer 2. */
+			maxlen = MIN(BUFSIZE - ts->wridx2, ts->size2);
+			w = safe_write(ts->sockfd_write, ts->buf2 + ts->wridx2, maxlen);
+			/* needed? if (w < 0 && errno == EAGAIN) continue; */
+			if (w < 0) {
+				if (IS_INETD)
+					return 0;
+				free_session(ts);
+				ts = next;
+				continue;
+			}
+			ts->wridx2 += w;
+			ts->size2 -= w;
+			if (ts->wridx2 == BUFSIZE)
+				ts->wridx2 = 0;
+		}
+
+		if (ts->size1 < BUFSIZE && FD_ISSET(ts->sockfd_read, &rdfdset)) {
+			/* Read from socket to buffer 1. */
+			maxlen = MIN(BUFSIZE - ts->rdidx1, BUFSIZE - ts->size1);
+			r = safe_read(ts->sockfd_read, ts->buf1 + ts->rdidx1, maxlen);
+			if (r < 0 && errno == EAGAIN) continue;
+			if (r <= 0) {
+				if (IS_INETD)
+					return 0;
+				free_session(ts);
+				ts = next;
+				continue;
+			}
+			if (!ts->buf1[ts->rdidx1 + r - 1])
+				if (!--r)
+					continue;
+			ts->rdidx1 += r;
+			ts->size1 += r;
+			if (ts->rdidx1 == BUFSIZE)
+				ts->rdidx1 = 0;
+		}
+
+		if (ts->size2 < BUFSIZE && FD_ISSET(ts->ptyfd, &rdfdset)) {
+			/* Read from pty to buffer 2. */
+			maxlen = MIN(BUFSIZE - ts->rdidx2, BUFSIZE - ts->size2);
+			r = safe_read(ts->ptyfd, ts->buf2 + ts->rdidx2, maxlen);
+			if (r < 0 && errno == EAGAIN) continue;
+			if (r <= 0) {
+				if (IS_INETD)
+					return 0;
+				free_session(ts);
+				ts = next;
+				continue;
+			}
+			ts->rdidx2 += r;
+			ts->size2 += r;
+			if (ts->rdidx2 == BUFSIZE)
+				ts->rdidx2 = 0;
+		}
+
+		if (ts->size1 == 0) {
+			ts->rdidx1 = 0;
+			ts->wridx1 = 0;
+		}
+		if (ts->size2 == 0) {
+			ts->rdidx2 = 0;
+			ts->wridx2 = 0;
+		}
+		ts = next;
+	}
+	goto again;
+}
diff --git a/networking/tftp.c b/networking/tftp.c
new file mode 100644
index 0000000..64d376f
--- /dev/null
+++ b/networking/tftp.c
@@ -0,0 +1,561 @@
+/* vi: set sw=4 ts=4: */
+/* -------------------------------------------------------------------------
+ * tftp.c
+ *
+ * A simple tftp client for busybox.
+ * Tries to follow RFC1350.
+ * Only "octet" mode supported.
+ * Optional blocksize negotiation (RFC2347 + RFC2348)
+ *
+ * Copyright (C) 2001 Magnus Damm <damm@opensource.se>
+ *
+ * Parts of the code based on:
+ *
+ * atftp:  Copyright (C) 2000 Jean-Pierre Lefebvre <helix@step.polymtl.ca>
+ *                        and Remi Lefebvre <remi@debian.org>
+ *
+ * utftp:  Copyright (C) 1999 Uwe Ohse <uwe@ohse.de>
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ * ------------------------------------------------------------------------- */
+
+#include "busybox.h"
+
+
+#define TFTP_BLOCKSIZE_DEFAULT 512	/* according to RFC 1350, don't change */
+#define TFTP_TIMEOUT 5	/* seconds */
+#define TFTP_NUM_RETRIES 5 /* number of retries */
+
+static const char * const MODE_OCTET = "octet";
+#define MODE_OCTET_LEN 6 /* sizeof(MODE_OCTET)*/
+
+static const char * const OPTION_BLOCKSIZE = "blksize";
+#define OPTION_BLOCKSIZE_LEN 8 /* sizeof(OPTION_BLOCKSIZE) */
+
+/* opcodes we support */
+#define TFTP_RRQ   1
+#define TFTP_WRQ   2
+#define TFTP_DATA  3
+#define TFTP_ACK   4
+#define TFTP_ERROR 5
+#define TFTP_OACK  6
+
+static const char *const tftp_bb_error_msg[] = {
+	"Undefined error",
+	"File not found",
+	"Access violation",
+	"Disk full or allocation error",
+	"Illegal TFTP operation",
+	"Unknown transfer ID",
+	"File already exists",
+	"No such user"
+};
+
+#define tftp_cmd_get ENABLE_FEATURE_TFTP_GET
+
+#if ENABLE_FEATURE_TFTP_PUT
+# define tftp_cmd_put (tftp_cmd_get+ENABLE_FEATURE_TFTP_PUT)
+#else
+# define tftp_cmd_put 0
+#endif
+
+
+#if ENABLE_FEATURE_TFTP_BLOCKSIZE
+
+static int tftp_blocksize_check(int blocksize, int bufsize)
+{
+	/* Check if the blocksize is valid:
+	 * RFC2348 says between 8 and 65464,
+	 * but our implementation makes it impossible
+	 * to use blocksizes smaller than 22 octets.
+	 */
+
+	if ((bufsize && (blocksize > bufsize)) ||
+		(blocksize < 8) || (blocksize > 65564)) {
+		bb_error_msg("bad blocksize");
+		return 0;
+	}
+
+	return blocksize;
+}
+
+static char *tftp_option_get(char *buf, int len, const char * const option)
+{
+	int opt_val = 0;
+	int opt_found = 0;
+	int k;
+
+	while (len > 0) {
+
+		/* Make sure the options are terminated correctly */
+
+		for (k = 0; k < len; k++) {
+			if (buf[k] == '\0') {
+				break;
+			}
+		}
+
+		if (k >= len) {
+			break;
+		}
+
+		if (opt_val == 0) {
+			if (strcasecmp(buf, option) == 0) {
+				opt_found = 1;
+			}
+		} else {
+			if (opt_found) {
+				return buf;
+			}
+		}
+
+		k++;
+
+		buf += k;
+		len -= k;
+
+		opt_val ^= 1;
+	}
+
+	return NULL;
+}
+
+#endif
+
+static int tftp(const int cmd, const struct hostent *host,
+		   const char *remotefile, const int localfd,
+		   const unsigned short port, int tftp_bufsize)
+{
+	struct sockaddr_in sa;
+	struct sockaddr_in from;
+	struct timeval tv;
+	socklen_t fromlen;
+	fd_set rfds;
+	int socketfd;
+	int len;
+	int opcode = 0;
+	int finished = 0;
+	int timeout = TFTP_NUM_RETRIES;
+	unsigned short block_nr = 1;
+	unsigned short tmp;
+	char *cp;
+
+	USE_FEATURE_TFTP_BLOCKSIZE(int want_option_ack = 0;)
+
+	/* Can't use RESERVE_CONFIG_BUFFER here since the allocation
+	 * size varies meaning BUFFERS_GO_ON_STACK would fail */
+	char *buf=xmalloc(tftp_bufsize += 4);
+
+	if ((socketfd = socket(PF_INET, SOCK_DGRAM, 0)) < 0) {
+		/* need to unlink the localfile, so don't use xsocket here. */
+		bb_perror_msg("socket");
+		return EXIT_FAILURE;
+	}
+
+	len = sizeof(sa);
+
+	memset(&sa, 0, len);
+	xbind(socketfd, (struct sockaddr *)&sa, len);
+
+	sa.sin_family = host->h_addrtype;
+	sa.sin_port = port;
+	memcpy(&sa.sin_addr, (struct in_addr *) host->h_addr,
+		   sizeof(sa.sin_addr));
+
+	/* build opcode */
+	if (cmd & tftp_cmd_get) {
+		opcode = TFTP_RRQ;
+	}
+	if (cmd & tftp_cmd_put) {
+		opcode = TFTP_WRQ;
+	}
+
+	while (1) {
+
+		cp = buf;
+
+		/* first create the opcode part */
+		*((unsigned short *) cp) = htons(opcode);
+		cp += 2;
+
+		/* add filename and mode */
+		if (((cmd & tftp_cmd_get) && (opcode == TFTP_RRQ)) ||
+			((cmd & tftp_cmd_put) && (opcode == TFTP_WRQ)))
+		{
+			int too_long = 0;
+
+			/* see if the filename fits into buf
+			 * and fill in packet.  */
+			len = strlen(remotefile) + 1;
+
+			if ((cp + len) >= &buf[tftp_bufsize - 1]) {
+				too_long = 1;
+			} else {
+				safe_strncpy(cp, remotefile, len);
+				cp += len;
+			}
+
+			if (too_long || ((&buf[tftp_bufsize - 1] - cp) < MODE_OCTET_LEN)) {
+				bb_error_msg("remote filename too long");
+				break;
+			}
+
+			/* add "mode" part of the package */
+			memcpy(cp, MODE_OCTET, MODE_OCTET_LEN);
+			cp += MODE_OCTET_LEN;
+
+#if ENABLE_FEATURE_TFTP_BLOCKSIZE
+
+			len = tftp_bufsize - 4;	/* data block size */
+
+			if (len != TFTP_BLOCKSIZE_DEFAULT) {
+
+				if ((&buf[tftp_bufsize - 1] - cp) < 15) {
+					bb_error_msg("remote filename too long");
+					break;
+				}
+
+				/* add "blksize" + number of blocks  */
+				memcpy(cp, OPTION_BLOCKSIZE, OPTION_BLOCKSIZE_LEN);
+				cp += OPTION_BLOCKSIZE_LEN;
+				cp += snprintf(cp, 6, "%d", len) + 1;
+
+				want_option_ack = 1;
+			}
+#endif
+		}
+
+		/* add ack and data */
+
+		if (((cmd & tftp_cmd_get) && (opcode == TFTP_ACK)) ||
+			((cmd & tftp_cmd_put) && (opcode == TFTP_DATA))) {
+
+			*((unsigned short *) cp) = htons(block_nr);
+
+			cp += 2;
+
+			block_nr++;
+
+			if ((cmd & tftp_cmd_put) && (opcode == TFTP_DATA)) {
+				len = full_read(localfd, cp, tftp_bufsize - 4);
+
+				if (len < 0) {
+					bb_perror_msg(bb_msg_read_error);
+					break;
+				}
+
+				if (len != (tftp_bufsize - 4)) {
+					finished++;
+				}
+
+				cp += len;
+			}
+		}
+
+
+		/* send packet */
+
+
+		timeout = TFTP_NUM_RETRIES;	/* re-initialize */
+		do {
+
+			len = cp - buf;
+
+#if ENABLE_DEBUG_TFTP
+			fprintf(stderr, "sending %u bytes\n", len);
+			for (cp = buf; cp < &buf[len]; cp++)
+				fprintf(stderr, "%02x ", (unsigned char) *cp);
+			fprintf(stderr, "\n");
+#endif
+			if (sendto(socketfd, buf, len, 0,
+					   (struct sockaddr *) &sa, sizeof(sa)) < 0) {
+				bb_perror_msg("send");
+				len = -1;
+				break;
+			}
+
+
+			if (finished && (opcode == TFTP_ACK)) {
+				break;
+			}
+
+			/* receive packet */
+
+			memset(&from, 0, sizeof(from));
+			fromlen = sizeof(from);
+
+			tv.tv_sec = TFTP_TIMEOUT;
+			tv.tv_usec = 0;
+
+			FD_ZERO(&rfds);
+			FD_SET(socketfd, &rfds);
+
+			switch (select(socketfd + 1, &rfds, NULL, NULL, &tv)) {
+			case 1:
+				len = recvfrom(socketfd, buf, tftp_bufsize, 0,
+							   (struct sockaddr *) &from, &fromlen);
+
+				if (len < 0) {
+					bb_perror_msg("recvfrom");
+					break;
+				}
+
+				timeout = 0;
+
+				if (sa.sin_port == port) {
+					sa.sin_port = from.sin_port;
+				}
+				if (sa.sin_port == from.sin_port) {
+					break;
+				}
+
+				/* fall-through for bad packets! */
+				/* discard the packet - treat as timeout */
+				timeout = TFTP_NUM_RETRIES;
+			case 0:
+				bb_error_msg("timeout");
+
+				timeout--;
+				if (timeout == 0) {
+					len = -1;
+					bb_error_msg("last timeout");
+				}
+				break;
+			default:
+				bb_perror_msg("select");
+				len = -1;
+			}
+
+		} while (timeout && (len >= 0));
+
+		if ((finished) || (len < 0)) {
+			break;
+		}
+
+		/* process received packet */
+
+		opcode = ntohs(*((unsigned short *) buf));
+		tmp = ntohs(*((unsigned short *) &buf[2]));
+
+#if ENABLE_DEBUG_TFTP
+		fprintf(stderr, "received %d bytes: %04x %04x\n", len, opcode, tmp);
+#endif
+
+		if (opcode == TFTP_ERROR) {
+			const char *msg = NULL;
+
+			if (buf[4] != '\0') {
+				msg = &buf[4];
+				buf[tftp_bufsize - 1] = '\0';
+			} else if (tmp < (sizeof(tftp_bb_error_msg)
+							  / sizeof(char *))) {
+
+				msg = tftp_bb_error_msg[tmp];
+			}
+
+			if (msg) {
+				bb_error_msg("server says: %s", msg);
+			}
+
+			break;
+		}
+#if ENABLE_FEATURE_TFTP_BLOCKSIZE
+		if (want_option_ack) {
+
+			want_option_ack = 0;
+
+			if (opcode == TFTP_OACK) {
+
+				/* server seems to support options */
+
+				char *res;
+
+				res = tftp_option_get(&buf[2], len - 2, OPTION_BLOCKSIZE);
+
+				if (res) {
+					int blksize = xatoi_u(res);
+
+					if (tftp_blocksize_check(blksize, tftp_bufsize - 4)) {
+
+						if (cmd & tftp_cmd_put) {
+							opcode = TFTP_DATA;
+						} else {
+							opcode = TFTP_ACK;
+						}
+#if ENABLE_DEBUG_TFTP
+						fprintf(stderr, "using %s %u\n", OPTION_BLOCKSIZE,
+								blksize);
+#endif
+						tftp_bufsize = blksize + 4;
+						block_nr = 0;
+						continue;
+					}
+				}
+				/* FIXME:
+				 * we should send ERROR 8 */
+				bb_error_msg("bad server option");
+				break;
+			}
+
+			bb_error_msg("warning: blksize not supported by server"
+						 " - reverting to 512");
+
+			tftp_bufsize = TFTP_BLOCKSIZE_DEFAULT + 4;
+		}
+#endif
+
+		if ((cmd & tftp_cmd_get) && (opcode == TFTP_DATA)) {
+
+			if (tmp == block_nr) {
+
+				len = full_write(localfd, &buf[4], len - 4);
+
+				if (len < 0) {
+					bb_perror_msg(bb_msg_write_error);
+					break;
+				}
+
+				if (len != (tftp_bufsize - 4)) {
+					finished++;
+				}
+
+				opcode = TFTP_ACK;
+				continue;
+			}
+			/* in case the last ack disappeared into the ether */
+			if (tmp == (block_nr - 1)) {
+				--block_nr;
+				opcode = TFTP_ACK;
+				continue;
+			} else if (tmp + 1 == block_nr) {
+				/* Server lost our TFTP_ACK.  Resend it */
+				block_nr = tmp;
+				opcode = TFTP_ACK;
+				continue;
+			}
+		}
+
+		if ((cmd & tftp_cmd_put) && (opcode == TFTP_ACK)) {
+
+			if (tmp == (unsigned short) (block_nr - 1)) {
+				if (finished) {
+					break;
+				}
+
+				opcode = TFTP_DATA;
+				continue;
+			}
+		}
+	}
+
+#if ENABLE_FEATURE_CLEAN_UP
+	close(socketfd);
+	free(buf);
+#endif
+
+	return finished ? EXIT_SUCCESS : EXIT_FAILURE;
+}
+
+int tftp_main(int argc, char **argv)
+{
+	struct hostent *host = NULL;
+	const char *localfile = NULL;
+	const char *remotefile = NULL;
+	int port;
+	int cmd = 0;
+	int fd = -1;
+	int flags = 0;
+	int result;
+	int blocksize = TFTP_BLOCKSIZE_DEFAULT;
+
+	/* figure out what to pass to getopt */
+
+#if ENABLE_FEATURE_TFTP_BLOCKSIZE
+	char *sblocksize = NULL;
+
+#define BS "b:"
+#define BS_ARG , &sblocksize
+#else
+#define BS
+#define BS_ARG
+#endif
+
+#if ENABLE_FEATURE_TFTP_GET
+#define GET "g"
+#define GET_COMPL ":g"
+#else
+#define GET
+#define GET_COMPL
+#endif
+
+#if ENABLE_FEATURE_TFTP_PUT
+#define PUT "p"
+#define PUT_COMPL ":p"
+#else
+#define PUT
+#define PUT_COMPL
+#endif
+
+#if defined(CONFIG_FEATURE_TFTP_GET) && defined(CONFIG_FEATURE_TFTP_PUT)
+	opt_complementary = GET_COMPL PUT_COMPL ":?g--p:p--g";
+#elif defined(CONFIG_FEATURE_TFTP_GET) || defined(CONFIG_FEATURE_TFTP_PUT)
+	opt_complementary = GET_COMPL PUT_COMPL;
+#endif
+
+	cmd = getopt32(argc, argv, GET PUT "l:r:" BS, &localfile, &remotefile BS_ARG);
+
+	cmd &= (tftp_cmd_get | tftp_cmd_put);
+#if ENABLE_FEATURE_TFTP_GET
+	if (cmd == tftp_cmd_get)
+		flags = O_WRONLY | O_CREAT | O_TRUNC;
+#endif
+#if ENABLE_FEATURE_TFTP_PUT
+	if (cmd == tftp_cmd_put)
+		flags = O_RDONLY;
+#endif
+
+#if ENABLE_FEATURE_TFTP_BLOCKSIZE
+	if (sblocksize) {
+		blocksize = xatoi_u(sblocksize);
+		if (!tftp_blocksize_check(blocksize, 0)) {
+			return EXIT_FAILURE;
+		}
+	}
+#endif
+
+	if (localfile == NULL)
+		localfile = remotefile;
+	if (remotefile == NULL)
+		remotefile = localfile;
+	if ((localfile == NULL && remotefile == NULL) || (argv[optind] == NULL))
+		bb_show_usage();
+
+	if (localfile == NULL || strcmp(localfile, "-") == 0) {
+		fd = (cmd == tftp_cmd_get) ? STDOUT_FILENO : STDIN_FILENO;
+	} else {
+		fd = open(localfile, flags, 0644); /* fail below */
+	}
+	if (fd < 0) {
+		bb_perror_msg_and_die("local file");
+	}
+
+	host = xgethostbyname(argv[optind]);
+	port = bb_lookup_port(argv[optind + 1], "udp", 69);
+
+#if ENABLE_DEBUG_TFTP
+	fprintf(stderr, "using server \"%s\", remotefile \"%s\", "
+			"localfile \"%s\".\n",
+			inet_ntoa(*((struct in_addr *) host->h_addr)),
+			remotefile, localfile);
+#endif
+
+	result = tftp(cmd, host, remotefile, fd, port, blocksize);
+
+	if (!(fd == STDOUT_FILENO || fd == STDIN_FILENO)) {
+		if (ENABLE_FEATURE_CLEAN_UP)
+			close(fd);
+		if (cmd == tftp_cmd_get && result != EXIT_SUCCESS)
+			unlink(localfile);
+	}
+	return result;
+}
diff --git a/networking/traceroute.c b/networking/traceroute.c
new file mode 100644
index 0000000..4900765
--- /dev/null
+++ b/networking/traceroute.c
@@ -0,0 +1,1350 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Copyright (c) 1988, 1989, 1991, 1994, 1995, 1996, 1997, 1998, 1999, 2000
+ *      The Regents of the University of California.  All rights reserved.
+ *
+ * Busybox port by Vladimir Oleynik (C) 2005 <dzo@simtreas.ru>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that: (1) source code distributions
+ * retain the above copyright notice and this paragraph in its entirety, (2)
+ * distributions including binary code include the above copyright notice and
+ * this paragraph in its entirety in the documentation or other materials
+ * provided with the distribution, and (3) all advertising materials mentioning
+ * features or use of this software display the following acknowledgement:
+ * ``This product includes software developed by the University of California,
+ * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
+ * the University nor the names of its contributors may be used to endorse
+ * or promote products derived from this software without specific prior
+ * written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+//#define version "1.4a12"
+
+
+/*
+ * traceroute host  - trace the route ip packets follow going to "host".
+ *
+ * Attempt to trace the route an ip packet would follow to some
+ * internet host.  We find out intermediate hops by launching probe
+ * packets with a small ttl (time to live) then listening for an
+ * icmp "time exceeded" reply from a gateway.  We start our probes
+ * with a ttl of one and increase by one until we get an icmp "port
+ * unreachable" (which means we got to "host") or hit a max (which
+ * defaults to 30 hops & can be changed with the -m flag).  Three
+ * probes (change with -q flag) are sent at each ttl setting and a
+ * line is printed showing the ttl, address of the gateway and
+ * round trip time of each probe.  If the probe answers come from
+ * different gateways, the address of each responding system will
+ * be printed.  If there is no response within a 5 sec. timeout
+ * interval (changed with the -w flag), a "*" is printed for that
+ * probe.
+ *
+ * Probe packets are UDP format.  We don't want the destination
+ * host to process them so the destination port is set to an
+ * unlikely value (if some clod on the destination is using that
+ * value, it can be changed with the -p flag).
+ *
+ * A sample use might be:
+ *
+ *     [yak 71]% traceroute nis.nsf.net.
+ *     traceroute to nis.nsf.net (35.1.1.48), 30 hops max, 56 byte packet
+ *      1  helios.ee.lbl.gov (128.3.112.1)  19 ms  19 ms  0 ms
+ *      2  lilac-dmc.Berkeley.EDU (128.32.216.1)  39 ms  39 ms  19 ms
+ *      3  lilac-dmc.Berkeley.EDU (128.32.216.1)  39 ms  39 ms  19 ms
+ *      4  ccngw-ner-cc.Berkeley.EDU (128.32.136.23)  39 ms  40 ms  39 ms
+ *      5  ccn-nerif22.Berkeley.EDU (128.32.168.22)  39 ms  39 ms  39 ms
+ *      6  128.32.197.4 (128.32.197.4)  40 ms  59 ms  59 ms
+ *      7  131.119.2.5 (131.119.2.5)  59 ms  59 ms  59 ms
+ *      8  129.140.70.13 (129.140.70.13)  99 ms  99 ms  80 ms
+ *      9  129.140.71.6 (129.140.71.6)  139 ms  239 ms  319 ms
+ *     10  129.140.81.7 (129.140.81.7)  220 ms  199 ms  199 ms
+ *     11  nic.merit.edu (35.1.1.48)  239 ms  239 ms  239 ms
+ *
+ * Note that lines 2 & 3 are the same.  This is due to a buggy
+ * kernel on the 2nd hop system -- lbl-csam.arpa -- that forwards
+ * packets with a zero ttl.
+ *
+ * A more interesting example is:
+ *
+ *     [yak 72]% traceroute allspice.lcs.mit.edu.
+ *     traceroute to allspice.lcs.mit.edu (18.26.0.115), 30 hops max
+ *      1  helios.ee.lbl.gov (128.3.112.1)  0 ms  0 ms  0 ms
+ *      2  lilac-dmc.Berkeley.EDU (128.32.216.1)  19 ms  19 ms  19 ms
+ *      3  lilac-dmc.Berkeley.EDU (128.32.216.1)  39 ms  19 ms  19 ms
+ *      4  ccngw-ner-cc.Berkeley.EDU (128.32.136.23)  19 ms  39 ms  39 ms
+ *      5  ccn-nerif22.Berkeley.EDU (128.32.168.22)  20 ms  39 ms  39 ms
+ *      6  128.32.197.4 (128.32.197.4)  59 ms  119 ms  39 ms
+ *      7  131.119.2.5 (131.119.2.5)  59 ms  59 ms  39 ms
+ *      8  129.140.70.13 (129.140.70.13)  80 ms  79 ms  99 ms
+ *      9  129.140.71.6 (129.140.71.6)  139 ms  139 ms  159 ms
+ *     10  129.140.81.7 (129.140.81.7)  199 ms  180 ms  300 ms
+ *     11  129.140.72.17 (129.140.72.17)  300 ms  239 ms  239 ms
+ *     12  * * *
+ *     13  128.121.54.72 (128.121.54.72)  259 ms  499 ms  279 ms
+ *     14  * * *
+ *     15  * * *
+ *     16  * * *
+ *     17  * * *
+ *     18  ALLSPICE.LCS.MIT.EDU (18.26.0.115)  339 ms  279 ms  279 ms
+ *
+ * (I start to see why I'm having so much trouble with mail to
+ * MIT.)  Note that the gateways 12, 14, 15, 16 & 17 hops away
+ * either don't send ICMP "time exceeded" messages or send them
+ * with a ttl too small to reach us.  14 - 17 are running the
+ * MIT C Gateway code that doesn't send "time exceeded"s.  God
+ * only knows what's going on with 12.
+ *
+ * The silent gateway 12 in the above may be the result of a bug in
+ * the 4.[23]BSD network code (and its derivatives):  4.x (x <= 3)
+ * sends an unreachable message using whatever ttl remains in the
+ * original datagram.  Since, for gateways, the remaining ttl is
+ * zero, the icmp "time exceeded" is guaranteed to not make it back
+ * to us.  The behavior of this bug is slightly more interesting
+ * when it appears on the destination system:
+ *
+ *      1  helios.ee.lbl.gov (128.3.112.1)  0 ms  0 ms  0 ms
+ *      2  lilac-dmc.Berkeley.EDU (128.32.216.1)  39 ms  19 ms  39 ms
+ *      3  lilac-dmc.Berkeley.EDU (128.32.216.1)  19 ms  39 ms  19 ms
+ *      4  ccngw-ner-cc.Berkeley.EDU (128.32.136.23)  39 ms  40 ms  19 ms
+ *      5  ccn-nerif35.Berkeley.EDU (128.32.168.35)  39 ms  39 ms  39 ms
+ *      6  csgw.Berkeley.EDU (128.32.133.254)  39 ms  59 ms  39 ms
+ *      7  * * *
+ *      8  * * *
+ *      9  * * *
+ *     10  * * *
+ *     11  * * *
+ *     12  * * *
+ *     13  rip.Berkeley.EDU (128.32.131.22)  59 ms !  39 ms !  39 ms !
+ *
+ * Notice that there are 12 "gateways" (13 is the final
+ * destination) and exactly the last half of them are "missing".
+ * What's really happening is that rip (a Sun-3 running Sun OS3.5)
+ * is using the ttl from our arriving datagram as the ttl in its
+ * icmp reply.  So, the reply will time out on the return path
+ * (with no notice sent to anyone since icmp's aren't sent for
+ * icmp's) until we probe with a ttl that's at least twice the path
+ * length.  I.e., rip is really only 7 hops away.  A reply that
+ * returns with a ttl of 1 is a clue this problem exists.
+ * Traceroute prints a "!" after the time if the ttl is <= 1.
+ * Since vendors ship a lot of obsolete (DEC's Ultrix, Sun 3.x) or
+ * non-standard (HPUX) software, expect to see this problem
+ * frequently and/or take care picking the target host of your
+ * probes.
+ *
+ * Other possible annotations after the time are !H, !N, !P (got a host,
+ * network or protocol unreachable, respectively), !S or !F (source
+ * route failed or fragmentation needed -- neither of these should
+ * ever occur and the associated gateway is busted if you see one).  If
+ * almost all the probes result in some kind of unreachable, traceroute
+ * will give up and exit.
+ *
+ * Notes
+ * -----
+ * This program must be run by root or be setuid.  (I suggest that
+ * you *don't* make it setuid -- casual use could result in a lot
+ * of unnecessary traffic on our poor, congested nets.)
+ *
+ * This program requires a kernel mod that does not appear in any
+ * system available from Berkeley:  A raw ip socket using proto
+ * IPPROTO_RAW must interpret the data sent as an ip datagram (as
+ * opposed to data to be wrapped in a ip datagram).  See the README
+ * file that came with the source to this program for a description
+ * of the mods I made to /sys/netinet/raw_ip.c.  Your mileage may
+ * vary.  But, again, ANY 4.x (x < 4) BSD KERNEL WILL HAVE TO BE
+ * MODIFIED TO RUN THIS PROGRAM.
+ *
+ * The udp port usage may appear bizarre (well, ok, it is bizarre).
+ * The problem is that an icmp message only contains 8 bytes of
+ * data from the original datagram.  8 bytes is the size of a udp
+ * header so, if we want to associate replies with the original
+ * datagram, the necessary information must be encoded into the
+ * udp header (the ip id could be used but there's no way to
+ * interlock with the kernel's assignment of ip id's and, anyway,
+ * it would have taken a lot more kernel hacking to allow this
+ * code to set the ip id).  So, to allow two or more users to
+ * use traceroute simultaneously, we use this task's pid as the
+ * source port (the high bit is set to move the port number out
+ * of the "likely" range).  To keep track of which probe is being
+ * replied to (so times and/or hop counts don't get confused by a
+ * reply that was delayed in transit), we increment the destination
+ * port number before each probe.
+ *
+ * Don't use this as a coding example.  I was trying to find a
+ * routing problem and this code sort-of popped out after 48 hours
+ * without sleep.  I was amazed it ever compiled, much less ran.
+ *
+ * I stole the idea for this program from Steve Deering.  Since
+ * the first release, I've learned that had I attended the right
+ * IETF working group meetings, I also could have stolen it from Guy
+ * Almes or Matt Mathis.  I don't know (or care) who came up with
+ * the idea first.  I envy the originators' perspicacity and I'm
+ * glad they didn't keep the idea a secret.
+ *
+ * Tim Seaver, Ken Adelman and C. Philip Wood provided bug fixes and/or
+ * enhancements to the original distribution.
+ *
+ * I've hacked up a round-trip-route version of this that works by
+ * sending a loose-source-routed udp datagram through the destination
+ * back to yourself.  Unfortunately, SO many gateways botch source
+ * routing, the thing is almost worthless.  Maybe one day...
+ *
+ *  -- Van Jacobson (van@ee.lbl.gov)
+ *     Tue Dec 20 03:50:13 PST 1988
+ */
+
+#define TRACEROUTE_SO_DEBUG 0
+
+/* TODO: undefs were uncommented - ??! we have config system for that! */
+/* probably ok to remove altogether */
+//#undef CONFIG_FEATURE_TRACEROUTE_VERBOSE
+//#define CONFIG_FEATURE_TRACEROUTE_VERBOSE
+//#undef CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE
+//#define CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE
+//#undef CONFIG_FEATURE_TRACEROUTE_USE_ICMP
+//#define CONFIG_FEATURE_TRACEROUTE_USE_ICMP
+
+#include "inet_common.h"
+
+#include <net/if.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <netinet/udp.h>
+#include <netinet/ip.h>
+#include <netinet/ip_icmp.h>
+
+#include "busybox.h"
+
+
+/*
+ * Definitions for internet protocol version 4.
+ * Per RFC 791, September 1981.
+ */
+#define IPVERSION 4
+
+#ifndef IPPROTO_ICMP
+/* Grrrr.... */
+#define IPPROTO_ICMP 1
+#endif
+#ifndef IPPROTO_IP
+#define IPPROTO_IP 0
+#endif
+
+/*
+ * Overlay for ip header used by other protocols (tcp, udp).
+ */
+struct ipovly {
+	unsigned char  ih_x1[9];               /* (unused) */
+	unsigned char  ih_pr;                  /* protocol */
+	short   ih_len;                 /* protocol length */
+	struct  in_addr ih_src;         /* source internet address */
+	struct  in_addr ih_dst;         /* destination internet address */
+};
+
+/*
+ * UDP kernel structures and variables.
+ */
+struct  udpiphdr {
+	struct  ipovly ui_i;            /* overlaid ip structure */
+	struct  udphdr ui_u;            /* udp header */
+};
+#define ui_next         ui_i.ih_next
+#define ui_prev         ui_i.ih_prev
+#define ui_x1           ui_i.ih_x1
+#define ui_pr           ui_i.ih_pr
+#define ui_len          ui_i.ih_len
+#define ui_src          ui_i.ih_src
+#define ui_dst          ui_i.ih_dst
+#define ui_sport        ui_u.uh_sport
+#define ui_dport        ui_u.uh_dport
+#define ui_ulen         ui_u.uh_ulen
+#define ui_sum          ui_u.uh_sum
+
+
+/* Host name and address list */
+struct hostinfo {
+	char *name;
+	int n;
+	u_int32_t *addrs;
+};
+
+/* Data section of the probe packet */
+struct outdata {
+	unsigned char seq;             /* sequence number of this packet */
+	unsigned char ttl;             /* ttl packet left with */
+	struct timeval tv ATTRIBUTE_PACKED; /* time packet left */
+};
+
+struct IFADDRLIST {
+	u_int32_t addr;
+	char device[sizeof(struct ifreq)];
+};
+
+
+static const char route[] = "/proc/net/route";
+
+/* last inbound (icmp) packet */
+static unsigned char packet[512] ATTRIBUTE_ALIGNED(32);
+
+static struct ip *outip;               /* last output (udp) packet */
+static struct udphdr *outudp;          /* last output (udp) packet */
+static struct outdata *outdata;        /* last output (udp) packet */
+
+#if ENABLE_FEATURE_TRACEROUTE_USE_ICMP
+static struct icmp *outicmp;           /* last output (icmp) packet */
+#endif
+
+#if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
+/* Maximum number of gateways (include room for one noop) */
+#define NGATEWAYS ((int)((MAX_IPOPTLEN - IPOPT_MINOFF - 1) / sizeof(u_int32_t)))
+/* loose source route gateway list (including room for final destination) */
+static u_int32_t gwlist[NGATEWAYS + 1];
+#endif
+
+static int s;                          /* receive (icmp) socket file descriptor */
+static int sndsock;                    /* send (udp/icmp) socket file descriptor */
+
+static struct sockaddr_storage whereto;        /* Who to try to reach */
+static struct sockaddr_storage wherefrom;      /* Who we are */
+static int packlen;                    /* total length of packet */
+static int minpacket;                  /* min ip packet size */
+static int maxpacket = 32 * 1024;      /* max ip packet size */
+static int pmtu;                       /* Path MTU Discovery (RFC1191) */
+
+static char *hostname;
+
+static u_short ident;
+static u_short port = 32768 + 666;     /* start udp dest port # for probe packets */
+
+static int waittime = 5;               /* time to wait for response (in seconds) */
+static int nflag;                      /* print addresses numerically */
+static int doipcksum = 1;              /* calculate ip checksums by default */
+
+#if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
+static int optlen;                     /* length of ip options */
+#else
+#define optlen 0
+#endif
+
+#if ENABLE_FEATURE_TRACEROUTE_USE_ICMP
+static int useicmp;                    /* use icmp echo instead of udp packets */
+#endif
+#if ENABLE_FEATURE_TRACEROUTE_VERBOSE
+static int verbose;
+#endif
+
+/*
+ * Return the interface list
+ */
+static int
+ifaddrlist(struct IFADDRLIST **ipaddrp)
+{
+	int fd, nipaddr;
+#ifdef HAVE_SOCKADDR_SA_LEN
+	int n;
+#endif
+	struct ifreq *ifrp, *ifend, *ifnext;
+	struct sockaddr_in *addr_sin;
+	struct IFADDRLIST *al;
+	struct ifconf ifc;
+	struct ifreq ibuf[(32 * 1024) / sizeof(struct ifreq)], ifr;
+	struct IFADDRLIST *st_ifaddrlist;
+
+	fd = xsocket(AF_INET, SOCK_DGRAM, 0);
+
+	ifc.ifc_len = sizeof(ibuf);
+	ifc.ifc_buf = (caddr_t)ibuf;
+
+	if (ioctl(fd, SIOCGIFCONF, (char *)&ifc) < 0 ||
+	    ifc.ifc_len < sizeof(struct ifreq)) {
+		if (errno == EINVAL)
+			bb_error_msg_and_die(
+			    "SIOCGIFCONF: ifreq struct too small (%d bytes)",
+			    (int)sizeof(ibuf));
+		else
+			bb_perror_msg_and_die("SIOCGIFCONF");
+	}
+	ifrp = ibuf;
+	ifend = (struct ifreq *)((char *)ibuf + ifc.ifc_len);
+
+	nipaddr = 1 + (ifc.ifc_len / sizeof(struct ifreq));
+	st_ifaddrlist = xzalloc(nipaddr * sizeof(struct IFADDRLIST));
+	al = st_ifaddrlist;
+	nipaddr = 0;
+
+	for (; ifrp < ifend; ifrp = ifnext) {
+#ifdef HAVE_SOCKADDR_SA_LEN
+		n = ifrp->ifr_addr.sa_len + sizeof(ifrp->ifr_name);
+		if (n < sizeof(*ifrp))
+			ifnext = ifrp + 1;
+		else
+			ifnext = (struct ifreq *)((char *)ifrp + n);
+		if (ifrp->ifr_addr.sa_family != AF_INET)
+			continue;
+#else
+		ifnext = ifrp + 1;
+#endif
+		/*
+		 * Need a template to preserve address info that is
+		 * used below to locate the next entry.  (Otherwise,
+		 * SIOCGIFFLAGS stomps over it because the requests
+		 * are returned in a union.)
+		 */
+		strncpy(ifr.ifr_name, ifrp->ifr_name, sizeof(ifr.ifr_name));
+		if (ioctl(fd, SIOCGIFFLAGS, (char *)&ifr) < 0) {
+			if (errno == ENXIO)
+				continue;
+			bb_perror_msg_and_die("SIOCGIFFLAGS: %.*s",
+			    (int)sizeof(ifr.ifr_name), ifr.ifr_name);
+		}
+
+		/* Must be up */
+		if ((ifr.ifr_flags & IFF_UP) == 0)
+			continue;
+
+		safe_strncpy(al->device, ifr.ifr_name, sizeof(ifr.ifr_name) + 1);
+#ifdef sun
+		/* Ignore sun virtual interfaces */
+		if (strchr(al->device, ':') != NULL)
+			continue;
+#endif
+		if (ioctl(fd, SIOCGIFADDR, (char *)&ifr) < 0)
+			bb_perror_msg_and_die("SIOCGIFADDR: %s", al->device);
+
+		addr_sin = (struct sockaddr_in *)&ifr.ifr_addr;
+		al->addr = addr_sin->sin_addr.s_addr;
+		++al;
+		++nipaddr;
+	}
+	if (nipaddr == 0)
+		bb_error_msg_and_die ("can't find any network interfaces");
+	(void)close(fd);
+
+	*ipaddrp = st_ifaddrlist;
+	return nipaddr;
+}
+
+
+static void
+setsin(struct sockaddr_in *addr_sin, u_int32_t addr)
+{
+	memset(addr_sin, 0, sizeof(*addr_sin));
+#ifdef HAVE_SOCKADDR_SA_LEN
+	addr_sin->sin_len = sizeof(*addr_sin);
+#endif
+	addr_sin->sin_family = AF_INET;
+	addr_sin->sin_addr.s_addr = addr;
+}
+
+
+/*
+ * Return the source address for the given destination address
+ */
+static void
+findsaddr(const struct sockaddr_in *to, struct sockaddr_in *from)
+{
+	int i, n;
+	FILE *f;
+	u_int32_t mask;
+	u_int32_t dest, tmask;
+	struct IFADDRLIST *al;
+	char buf[256], tdevice[256], device[256];
+
+	f = xfopen(route, "r");
+
+	/* Find the appropriate interface */
+	n = 0;
+	mask = 0;
+	device[0] = '\0';
+	while (fgets(buf, sizeof(buf), f) != NULL) {
+		++n;
+		if (n == 1 && strncmp(buf, "Iface", 5) == 0)
+			continue;
+		if ((i = sscanf(buf, "%255s %x %*s %*s %*s %*s %*s %x",
+		    tdevice, &dest, &tmask)) != 3)
+			bb_error_msg_and_die ("junk in buffer");
+		if ((to->sin_addr.s_addr & tmask) == dest &&
+		    (tmask > mask || mask == 0)) {
+			mask = tmask;
+			strcpy(device, tdevice);
+		}
+	}
+	fclose(f);
+
+	if (device[0] == '\0')
+		bb_error_msg_and_die ("can't find interface");
+
+	/* Get the interface address list */
+	n = ifaddrlist(&al);
+
+	/* Find our appropriate source address */
+	for (i = n; i > 0; --i, ++al)
+		if (strcmp(device, al->device) == 0)
+			break;
+	if (i <= 0)
+		bb_error_msg_and_die("can't find interface %s", device);
+
+	setsin(from, al->addr);
+}
+
+/*
+"Usage: %s [-dFIlnrvx] [-g gateway] [-i iface] [-f first_ttl]\n"
+"\t[-m max_ttl] [ -p port] [-q nqueries] [-s src_addr] [-t tos]\n"
+"\t[-w waittime] [-z pausemsecs] host [packetlen]"
+
+*/
+
+/*
+ * Subtract 2 timeval structs:  out = out - in.
+ * Out is assumed to be >= in.
+ */
+static inline void
+tvsub(struct timeval *out, struct timeval *in)
+{
+
+	if ((out->tv_usec -= in->tv_usec) < 0)   {
+		--out->tv_sec;
+		out->tv_usec += 1000000;
+	}
+	out->tv_sec -= in->tv_sec;
+}
+
+static int
+wait_for_reply(int sock, struct sockaddr_in *fromp, const struct timeval *tp)
+{
+	fd_set fds;
+	struct timeval now, tvwait;
+	struct timezone tz;
+	int cc = 0;
+	socklen_t fromlen = sizeof(*fromp);
+
+	FD_ZERO(&fds);
+	FD_SET(sock, &fds);
+
+	tvwait.tv_sec = tp->tv_sec + waittime;
+	tvwait.tv_usec = tp->tv_usec;
+	(void)gettimeofday(&now, &tz);
+	tvsub(&tvwait, &now);
+
+	if (select(sock + 1, &fds, NULL, NULL, &tvwait) > 0)
+		cc = recvfrom(sock, (char *)packet, sizeof(packet), 0,
+			    (struct sockaddr *)fromp, &fromlen);
+
+	return cc;
+}
+
+/*
+ * Checksum routine for Internet Protocol family headers (C Version)
+ */
+static u_short
+in_cksum(u_short *addr, int len)
+{
+	int nleft = len;
+	u_short *w = addr;
+	u_short answer;
+	int sum = 0;
+
+	/*
+	 *  Our algorithm is simple, using a 32 bit accumulator (sum),
+	 *  we add sequential 16 bit words to it, and at the end, fold
+	 *  back all the carry bits from the top 16 bits into the lower
+	 *  16 bits.
+	 */
+	while (nleft > 1)  {
+		sum += *w++;
+		nleft -= 2;
+	}
+
+	/* mop up an odd byte, if necessary */
+	if (nleft == 1)
+		sum += *(unsigned char *)w;
+
+	/*
+	 * add back carry outs from top 16 bits to low 16 bits
+	 */
+	sum = (sum >> 16) + (sum & 0xffff);     /* add hi 16 to low 16 */
+	sum += (sum >> 16);                     /* add carry */
+	answer = ~sum;                          /* truncate to 16 bits */
+	return answer;
+}
+
+
+static void
+send_probe(int seq, int ttl, struct timeval *tp)
+{
+	int cc;
+	struct udpiphdr *ui, *oui;
+	struct ip tip;
+
+	outip->ip_ttl = ttl;
+	outip->ip_id = htons(ident + seq);
+
+	/*
+	 * In most cases, the kernel will recalculate the ip checksum.
+	 * But we must do it anyway so that the udp checksum comes out
+	 * right.
+	 */
+	if (doipcksum) {
+		outip->ip_sum =
+		    in_cksum((u_short *)outip, sizeof(*outip) + optlen);
+		if (outip->ip_sum == 0)
+			outip->ip_sum = 0xffff;
+	}
+
+	/* Payload */
+	outdata->seq = seq;
+	outdata->ttl = ttl;
+	memcpy(&outdata->tv, tp, sizeof(outdata->tv));
+
+#if ENABLE_FEATURE_TRACEROUTE_USE_ICMP
+	if (useicmp)
+		outicmp->icmp_seq = htons(seq);
+	else
+#endif
+		outudp->dest = htons(port + seq);
+
+#if ENABLE_FEATURE_TRACEROUTE_USE_ICMP
+	if (useicmp) {
+		/* Always calculate checksum for icmp packets */
+		outicmp->icmp_cksum = 0;
+		outicmp->icmp_cksum = in_cksum((u_short *)outicmp,
+		    packlen - (sizeof(*outip) + optlen));
+		if (outicmp->icmp_cksum == 0)
+			outicmp->icmp_cksum = 0xffff;
+	} else
+#endif
+	if (doipcksum) {
+		/* Checksum (we must save and restore ip header) */
+		tip = *outip;
+		ui = (struct udpiphdr *)outip;
+		oui = (struct udpiphdr *)&tip;
+		/* Easier to zero and put back things that are ok */
+		memset((char *)ui, 0, sizeof(ui->ui_i));
+		ui->ui_src = oui->ui_src;
+		ui->ui_dst = oui->ui_dst;
+		ui->ui_pr = oui->ui_pr;
+		ui->ui_len = outudp->len;
+		outudp->check = 0;
+		outudp->check = in_cksum((u_short *)ui, packlen);
+		if (outudp->check == 0)
+			outudp->check = 0xffff;
+		*outip = tip;
+	}
+
+#if ENABLE_FEATURE_TRACEROUTE_VERBOSE
+	/* XXX undocumented debugging hack */
+	if (verbose > 1) {
+		const u_short *sp;
+		int nshorts, i;
+
+		sp = (u_short *)outip;
+		nshorts = (u_int)packlen / sizeof(u_short);
+		i = 0;
+		printf("[ %d bytes", packlen);
+		while (--nshorts >= 0) {
+			if ((i++ % 8) == 0)
+				printf("\n\t");
+			printf(" %04x", ntohs(*sp));
+			sp++;
+		}
+		if (packlen & 1) {
+			if ((i % 8) == 0)
+				printf("\n\t");
+			printf(" %02x", *(unsigned char *)sp);
+		}
+		printf("]\n");
+	}
+#endif
+
+#if !defined(IP_HDRINCL) && defined(IP_TTL)
+	if (setsockopt(sndsock, IPPROTO_IP, IP_TTL,
+	    (char *)&ttl, sizeof(ttl)) < 0) {
+		bb_perror_msg_and_die("setsockopt ttl %d", ttl);
+	}
+#endif
+
+	cc = sendto(sndsock, (char *)outip,
+	    packlen, 0, (struct sockaddr *)&whereto, sizeof(whereto));
+	if (cc < 0 || cc != packlen)  {
+		if (cc < 0)
+			bb_perror_msg_and_die("sendto");
+		printf("%s: wrote %s %d chars, ret=%d\n",
+		    applet_name, hostname, packlen, cc);
+		(void)fflush(stdout);
+	}
+}
+
+static inline double
+deltaT(struct timeval *t1p, struct timeval *t2p)
+{
+	double dt;
+
+	dt = (double)(t2p->tv_sec - t1p->tv_sec) * 1000.0 +
+	     (double)(t2p->tv_usec - t1p->tv_usec) / 1000.0;
+	return dt;
+}
+
+#if ENABLE_FEATURE_TRACEROUTE_VERBOSE
+/*
+ * Convert an ICMP "type" field to a printable string.
+ */
+static inline const char *
+pr_type(unsigned char t)
+{
+	static const char * const ttab[] = {
+	"Echo Reply",   "ICMP 1",       "ICMP 2",       "Dest Unreachable",
+	"Source Quench", "Redirect",    "ICMP 6",       "ICMP 7",
+	"Echo",         "Router Advert", "Router Solicit", "Time Exceeded",
+	"Param Problem", "Timestamp",   "Timestamp Reply", "Info Request",
+	"Info Reply",   "Mask Request", "Mask Reply"
+	};
+
+	if (t > 18)
+		return "OUT-OF-RANGE";
+
+	return ttab[t];
+}
+#endif
+
+static int
+packet_ok(unsigned char *buf, int cc, struct sockaddr_in *from, int seq)
+{
+	struct icmp *icp;
+	unsigned char type, code;
+	int hlen;
+	struct ip *ip;
+
+	ip = (struct ip *) buf;
+	hlen = ip->ip_hl << 2;
+	if (cc < hlen + ICMP_MINLEN) {
+#if ENABLE_FEATURE_TRACEROUTE_VERBOSE
+		if (verbose)
+			printf("packet too short (%d bytes) from %s\n", cc,
+				inet_ntoa(from->sin_addr));
+#endif
+		return 0;
+	}
+	cc -= hlen;
+	icp = (struct icmp *)(buf + hlen);
+	type = icp->icmp_type;
+	code = icp->icmp_code;
+	/* Path MTU Discovery (RFC1191) */
+	if (code != ICMP_UNREACH_NEEDFRAG)
+		pmtu = 0;
+	else {
+		pmtu = ntohs(icp->icmp_nextmtu);
+	}
+	if ((type == ICMP_TIMXCEED && code == ICMP_TIMXCEED_INTRANS) ||
+	    type == ICMP_UNREACH || type == ICMP_ECHOREPLY) {
+		struct ip *hip;
+		struct udphdr *up;
+
+		hip = &icp->icmp_ip;
+		hlen = hip->ip_hl << 2;
+#if ENABLE_FEATURE_TRACEROUTE_USE_ICMP
+		if (useicmp) {
+			struct icmp *hicmp;
+
+			/* XXX */
+			if (type == ICMP_ECHOREPLY &&
+			    icp->icmp_id == htons(ident) &&
+			    icp->icmp_seq == htons(seq))
+				return -2;
+
+			hicmp = (struct icmp *)((unsigned char *)hip + hlen);
+			/* XXX 8 is a magic number */
+			if (hlen + 8 <= cc &&
+			    hip->ip_p == IPPROTO_ICMP &&
+			    hicmp->icmp_id == htons(ident) &&
+			    hicmp->icmp_seq == htons(seq))
+				return (type == ICMP_TIMXCEED ? -1 : code + 1);
+		} else
+#endif
+		{
+			up = (struct udphdr *)((unsigned char *)hip + hlen);
+			/* XXX 8 is a magic number */
+			if (hlen + 12 <= cc &&
+			    hip->ip_p == IPPROTO_UDP &&
+			    up->source == htons(ident) &&
+			    up->dest == htons(port + seq))
+				return (type == ICMP_TIMXCEED ? -1 : code + 1);
+		}
+	}
+#if ENABLE_FEATURE_TRACEROUTE_VERBOSE
+	if (verbose) {
+		int i;
+		u_int32_t *lp = (u_int32_t *)&icp->icmp_ip;
+
+		printf("\n%d bytes from %s to "
+		       "%s: icmp type %d (%s) code %d\n",
+		    cc, inet_ntoa(from->sin_addr),
+		    inet_ntoa(ip->ip_dst), type, pr_type(type), icp->icmp_code);
+		for (i = 4; i < cc ; i += sizeof(*lp))
+			printf("%2d: x%8.8x\n", i, *lp++);
+	}
+#endif
+	return 0;
+}
+
+
+/*
+ * Construct an Internet address representation.
+ * If the nflag has been supplied, give
+ * numeric value, otherwise try for symbolic name.
+ */
+static inline void
+inetname(struct sockaddr_in *from)
+{
+	const char *n = NULL;
+	const char *ina;
+	char name[257];
+
+	if (!nflag && from->sin_addr.s_addr != INADDR_ANY) {
+		if (INET_rresolve(name, sizeof(name), from, 0x4000, 0xffffffff) >= 0)
+			n = name;
+	}
+	ina = inet_ntoa(from->sin_addr);
+	if (nflag)
+		printf(" %s", ina);
+	else
+		printf(" %s (%s)", (n ? n : ina), ina);
+}
+
+static inline void
+print(unsigned char *buf, int cc, struct sockaddr_in *from)
+{
+	struct ip *ip;
+	int hlen;
+
+	ip = (struct ip *) buf;
+	hlen = ip->ip_hl << 2;
+	cc -= hlen;
+
+	inetname(from);
+#if ENABLE_FEATURE_TRACEROUTE_VERBOSE
+	if (verbose)
+		printf(" %d bytes to %s", cc, inet_ntoa (ip->ip_dst));
+#endif
+}
+
+
+static struct hostinfo *
+gethostinfo(const char *host)
+{
+	int n;
+	struct hostent *hp;
+	struct hostinfo *hi;
+	char **p;
+	u_int32_t addr, *ap;
+
+	hi = xzalloc(sizeof(*hi));
+	addr = inet_addr(host);
+	if ((int32_t)addr != -1) {
+		hi->name = xstrdup(host);
+		hi->n = 1;
+		hi->addrs = xzalloc(sizeof(hi->addrs[0]));
+		hi->addrs[0] = addr;
+		return hi;
+	}
+
+	hp = xgethostbyname(host);
+	if (hp->h_addrtype != AF_INET || hp->h_length != 4)
+		bb_perror_msg_and_die("bad host %s", host);
+	hi->name = xstrdup(hp->h_name);
+	for (n = 0, p = hp->h_addr_list; *p != NULL; ++n, ++p)
+		continue;
+	hi->n = n;
+	hi->addrs = xzalloc(n * sizeof(hi->addrs[0]));
+	for (ap = hi->addrs, p = hp->h_addr_list; *p != NULL; ++ap, ++p)
+		memcpy(ap, *p, sizeof(*ap));
+	return hi;
+}
+
+static void
+freehostinfo(struct hostinfo *hi)
+{
+	free(hi->name);
+	hi->name = NULL;
+	free((char *)hi->addrs);
+	free((char *)hi);
+}
+
+#if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
+static void
+getaddr(u_int32_t *ap, const char *host)
+{
+	struct hostinfo *hi;
+
+	hi = gethostinfo(host);
+	*ap = hi->addrs[0];
+	freehostinfo(hi);
+}
+#endif
+
+
+int
+traceroute_main(int argc, char *argv[])
+{
+	static const int on = 1;
+
+	int code, n;
+	unsigned char *outp;
+	u_int32_t *ap;
+	struct sockaddr_in *from = (struct sockaddr_in *)&wherefrom;
+	struct sockaddr_in *to = (struct sockaddr_in *)&whereto;
+	struct hostinfo *hi;
+	int ttl, probe, i;
+	int seq = 0;
+	int tos = 0;
+	char *tos_str = NULL;
+	char *source = NULL;
+	unsigned long op;
+
+#if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
+	int lsrr = 0;
+#endif
+	u_short off = 0;
+	struct IFADDRLIST *al;
+	char *device = NULL;
+	int max_ttl = 30;
+	char *max_ttl_str = NULL;
+	char *port_str = NULL;
+	int nprobes = 3;
+	char *nprobes_str = NULL;
+	char *waittime_str = NULL;
+	u_int pausemsecs = 0;
+	char *pausemsecs_str = NULL;
+	int first_ttl = 1;
+	char *first_ttl_str = NULL;
+#if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
+	llist_t *sourse_route_list = NULL;
+#endif
+
+	opterr = 0;
+#if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
+	opt_complementary = "x-x:g::";
+#else
+	opt_complementary = "x-x";
+#endif
+
+	op = getopt32(argc, argv, "FIlnrdvxt:i:m:p:q:s:w:z:f:"
+#define USAGE_OP_DONT_FRAGMNT (1<<0)    /* F  */
+#define USAGE_OP_USE_ICMP     (1<<1)    /* I  */
+#define USAGE_OP_TTL_FLAG     (1<<2)    /* l  */
+#define USAGE_OP_ADDR_NUM     (1<<3)    /* n  */
+#define USAGE_OP_BYPASS_ROUTE (1<<4)    /* r  */
+#define USAGE_OP_DEBUG        (1<<5)    /* d */
+#define USAGE_OP_VERBOSE      (1<<6)    /* v */
+#define USAGE_OP_IP_CHKSUM    (1<<7)    /* x */
+
+#if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
+					"g:"
+#endif
+	, &tos_str, &device, &max_ttl_str, &port_str, &nprobes_str,
+	&source, &waittime_str, &pausemsecs_str, &first_ttl_str
+#if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
+	, &sourse_route_list
+#endif
+	);
+
+	if (op & USAGE_OP_DONT_FRAGMNT)
+		off = IP_DF;
+#if ENABLE_FEATURE_TRACEROUTE_USE_ICMP
+	useicmp = op & USAGE_OP_USE_ICMP;
+#endif
+	nflag = op & USAGE_OP_ADDR_NUM;
+#if ENABLE_FEATURE_TRACEROUTE_VERBOSE
+	verbose = op &  USAGE_OP_VERBOSE;
+#endif
+	if (op & USAGE_OP_IP_CHKSUM) {
+		doipcksum = 0;
+		bb_error_msg("warning: ip checksums disabled");
+	}
+	if (tos_str)
+		tos = xatoul_range(tos_str, 0, 255);
+	if (max_ttl_str)
+		max_ttl = xatoul_range(max_ttl_str, 1, 255);
+	if (port_str)
+		port = xatou16(port_str);
+	if (nprobes_str)
+		nprobes = xatoul_range(nprobes_str, 1, INT_MAX);
+	if (source) {
+		/*
+		 * set the ip source address of the outbound
+		 * probe (e.g., on a multi-homed host).
+		 */
+		if (getuid()) bb_error_msg_and_die("-s %s: permission denied", source);
+	}
+	if (waittime_str)
+		waittime = xatoul_range(waittime_str, 2, 24 * 60 * 60);
+	if (pausemsecs_str)
+		pausemsecs = xatoul_range(pausemsecs_str, 0, 60 * 60 * 1000);
+	if (first_ttl_str)
+		first_ttl = xatoul_range(first_ttl_str, 1, 255);
+
+#if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
+	if (sourse_route_list) {
+		llist_t *l_sr;
+
+		for(l_sr = sourse_route_list; l_sr; ) {
+			if (lsrr >= NGATEWAYS)
+				bb_error_msg_and_die("no more than %d gateways", NGATEWAYS);
+			getaddr(gwlist + lsrr, l_sr->data);
+			++lsrr;
+			l_sr = l_sr->link;
+			free(sourse_route_list);
+			sourse_route_list = l_sr;
+		}
+		optlen = (lsrr + 1) * sizeof(gwlist[0]);
+	}
+#endif
+
+	if (first_ttl > max_ttl) {
+		bb_error_msg_and_die(
+		    "first ttl (%d) may not be greater than max ttl (%d)",
+		    first_ttl, max_ttl);
+	}
+
+	minpacket = sizeof(*outip) + sizeof(*outdata) + optlen;
+
+#if ENABLE_FEATURE_TRACEROUTE_USE_ICMP
+	if (useicmp)
+		minpacket += 8;                 /* XXX magic number */
+	else
+#endif
+		minpacket += sizeof(*outudp);
+	packlen = minpacket;                    /* minimum sized packet */
+
+	/* Process destination and optional packet size */
+	switch (argc - optind) {
+
+	case 2:
+		packlen = xatoul_range(argv[optind + 1], minpacket, maxpacket);
+		/* Fall through */
+
+	case 1:
+		hostname = argv[optind];
+		hi = gethostinfo(hostname);
+		setsin(to, hi->addrs[0]);
+		if (hi->n > 1)
+			bb_error_msg("warning: %s has multiple addresses; using %s",
+				hostname, inet_ntoa(to->sin_addr));
+		hostname = hi->name;
+		hi->name = NULL;
+		freehostinfo(hi);
+		break;
+
+	default:
+		bb_show_usage();
+	}
+
+	/* Insure the socket fds won't be 0, 1 or 2 */
+	do n = xopen(bb_dev_null, O_RDONLY); while (n < 2);
+	if (n > 2)
+		close(n);
+
+	s = xsocket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
+
+#if TRACEROUTE_SO_DEBUG
+	if (op & USAGE_OP_DEBUG)
+		(void)setsockopt(s, SOL_SOCKET, SO_DEBUG, (char *)&on,
+		    sizeof(on));
+#endif
+	if (op & USAGE_OP_BYPASS_ROUTE)
+		(void)setsockopt(s, SOL_SOCKET, SO_DONTROUTE, (char *)&on,
+		    sizeof(on));
+
+	sndsock = xsocket(AF_INET, SOCK_RAW, IPPROTO_RAW);
+
+#if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
+#if defined(IP_OPTIONS)
+	if (lsrr > 0) {
+		unsigned char optlist[MAX_IPOPTLEN];
+
+		/* final hop */
+		gwlist[lsrr] = to->sin_addr.s_addr;
+		++lsrr;
+
+		/* force 4 byte alignment */
+		optlist[0] = IPOPT_NOP;
+		/* loose source route option */
+		optlist[1] = IPOPT_LSRR;
+		i = lsrr * sizeof(gwlist[0]);
+		optlist[2] = i + 3;
+		/* Pointer to LSRR addresses */
+		optlist[3] = IPOPT_MINOFF;
+		memcpy(optlist + 4, gwlist, i);
+
+		if ((setsockopt(sndsock, IPPROTO_IP, IP_OPTIONS,
+		    (char *)optlist, i + sizeof(gwlist[0]))) < 0) {
+			bb_perror_msg_and_die("IP_OPTIONS");
+		}
+	}
+#endif /* IP_OPTIONS */
+#endif /* CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE */
+
+#ifdef SO_SNDBUF
+	if (setsockopt(sndsock, SOL_SOCKET, SO_SNDBUF, (char *)&packlen,
+	    sizeof(packlen)) < 0) {
+		bb_perror_msg_and_die("SO_SNDBUF");
+	}
+#endif
+#ifdef IP_HDRINCL
+	if (setsockopt(sndsock, IPPROTO_IP, IP_HDRINCL, (char *)&on,
+	    sizeof(on)) < 0 && errno != ENOPROTOOPT) {
+		bb_perror_msg_and_die("IP_HDRINCL");
+	}
+#else
+#ifdef IP_TOS
+	if (tos_str && setsockopt(sndsock, IPPROTO_IP, IP_TOS,
+	    (char *)&tos, sizeof(tos)) < 0) {
+		bb_perror_msg_and_die("setsockopt tos %d", tos);
+	}
+#endif
+#endif
+#if TRACEROUTE_SO_DEBUG
+	if (op & USAGE_OP_DEBUG)
+		(void)setsockopt(sndsock, SOL_SOCKET, SO_DEBUG, (char *)&on,
+		    sizeof(on));
+#endif
+	if (op & USAGE_OP_BYPASS_ROUTE)
+		(void)setsockopt(sndsock, SOL_SOCKET, SO_DONTROUTE, (char *)&on,
+		    sizeof(on));
+
+	/* Revert to non-privileged user after opening sockets */
+	xsetgid(getgid());
+	xsetuid(getuid());
+
+	outip = (struct ip *)xzalloc(packlen);
+
+	outip->ip_v = IPVERSION;
+	if (tos_str)
+		outip->ip_tos = tos;
+	outip->ip_len = htons(packlen);
+	outip->ip_off = htons(off);
+	outp = (unsigned char *)(outip + 1);
+	outip->ip_dst = to->sin_addr;
+
+	outip->ip_hl = (outp - (unsigned char *)outip) >> 2;
+	ident = (getpid() & 0xffff) | 0x8000;
+#if ENABLE_FEATURE_TRACEROUTE_USE_ICMP
+	if (useicmp) {
+		outip->ip_p = IPPROTO_ICMP;
+
+		outicmp = (struct icmp *)outp;
+		outicmp->icmp_type = ICMP_ECHO;
+		outicmp->icmp_id = htons(ident);
+
+		outdata = (struct outdata *)(outp + 8); /* XXX magic number */
+	} else
+#endif
+	       {
+		outip->ip_p = IPPROTO_UDP;
+
+		outudp = (struct udphdr *)outp;
+		outudp->source = htons(ident);
+		outudp->len =
+		    htons((u_short)(packlen - (sizeof(*outip) + optlen)));
+		outdata = (struct outdata *)(outudp + 1);
+	}
+
+	/* Get the interface address list */
+	n = ifaddrlist(&al);
+
+	/* Look for a specific device */
+	if (device != NULL) {
+		for (i = n; i > 0; --i, ++al)
+			if (strcmp(device, al->device) == 0)
+				break;
+		if (i <= 0) {
+			bb_error_msg_and_die("can't find interface %s", device);
+		}
+	}
+
+	/* Determine our source address */
+	if (source == NULL) {
+		/*
+		 * If a device was specified, use the interface address.
+		 * Otherwise, try to determine our source address.
+		 */
+		if (device != NULL)
+			setsin(from, al->addr);
+		findsaddr(to, from);
+	} else {
+		hi = gethostinfo(source);
+		source = hi->name;
+		hi->name = NULL;
+		/*
+		 * If the device was specified make sure it
+		 * corresponds to the source address specified.
+		 * Otherwise, use the first address (and warn if
+		 * there are more than one).
+		 */
+		if (device != NULL) {
+			for (i = hi->n, ap = hi->addrs; i > 0; --i, ++ap)
+				if (*ap == al->addr)
+					break;
+			if (i <= 0) {
+				bb_error_msg_and_die(
+				    "%s is not on interface %s",
+				    source, device);
+			}
+			setsin(from, *ap);
+		} else {
+			setsin(from, hi->addrs[0]);
+			if (hi->n > 1)
+				bb_error_msg(
+			"Warning: %s has multiple addresses; using %s",
+				    source, inet_ntoa(from->sin_addr));
+		}
+		freehostinfo(hi);
+	}
+
+	outip->ip_src = from->sin_addr;
+#ifndef IP_HDRINCL
+	xbind(sndsock, (struct sockaddr *)from, sizeof(*from));
+#endif
+
+	fprintf(stderr, "traceroute to %s (%s)", hostname, inet_ntoa(to->sin_addr));
+	if (source)
+		fprintf(stderr, " from %s", source);
+	fprintf(stderr, ", %d hops max, %d byte packets\n", max_ttl, packlen);
+	(void)fflush(stderr);
+
+	for (ttl = first_ttl; ttl <= max_ttl; ++ttl) {
+		u_int32_t lastaddr = 0;
+		int gotlastaddr = 0;
+		int got_there = 0;
+		int unreachable = 0;
+		int sentfirst = 0;
+
+		printf("%2d ", ttl);
+		for (probe = 0; probe < nprobes; ++probe) {
+			int cc;
+			struct timeval t1, t2;
+			struct timezone tz;
+			struct ip *ip;
+
+			if (sentfirst && pausemsecs > 0)
+				usleep(pausemsecs * 1000);
+			(void)gettimeofday(&t1, &tz);
+			send_probe(++seq, ttl, &t1);
+			++sentfirst;
+			while ((cc = wait_for_reply(s, from, &t1)) != 0) {
+				(void)gettimeofday(&t2, &tz);
+				i = packet_ok(packet, cc, from, seq);
+				/* Skip short packet */
+				if (i == 0)
+					continue;
+				if (!gotlastaddr ||
+				    from->sin_addr.s_addr != lastaddr) {
+					print(packet, cc, from);
+					lastaddr = from->sin_addr.s_addr;
+					++gotlastaddr;
+				}
+				printf("  %.3f ms", deltaT(&t1, &t2));
+				ip = (struct ip *)packet;
+				if (op & USAGE_OP_TTL_FLAG)
+					printf(" (%d)", ip->ip_ttl);
+				if (i == -2) {
+					if (ip->ip_ttl <= 1)
+						printf(" !");
+					++got_there;
+					break;
+				}
+				/* time exceeded in transit */
+				if (i == -1)
+					break;
+				code = i - 1;
+				switch (code) {
+
+				case ICMP_UNREACH_PORT:
+					if (ip->ip_ttl <= 1)
+						printf(" !");
+					++got_there;
+					break;
+
+				case ICMP_UNREACH_NET:
+					++unreachable;
+					printf(" !N");
+					break;
+
+				case ICMP_UNREACH_HOST:
+					++unreachable;
+					printf(" !H");
+					break;
+
+				case ICMP_UNREACH_PROTOCOL:
+					++got_there;
+					printf(" !P");
+					break;
+
+				case ICMP_UNREACH_NEEDFRAG:
+					++unreachable;
+					printf(" !F-%d", pmtu);
+					break;
+
+				case ICMP_UNREACH_SRCFAIL:
+					++unreachable;
+					printf(" !S");
+					break;
+
+				case ICMP_UNREACH_FILTER_PROHIB:
+				case ICMP_UNREACH_NET_PROHIB:   /* misuse */
+					++unreachable;
+					printf(" !A");
+					break;
+
+				case ICMP_UNREACH_HOST_PROHIB:
+					++unreachable;
+					printf(" !C");
+					break;
+
+				case ICMP_UNREACH_HOST_PRECEDENCE:
+					++unreachable;
+					printf(" !V");
+					break;
+
+				case ICMP_UNREACH_PRECEDENCE_CUTOFF:
+					++unreachable;
+					printf(" !C");
+					break;
+
+				case ICMP_UNREACH_NET_UNKNOWN:
+				case ICMP_UNREACH_HOST_UNKNOWN:
+					++unreachable;
+					printf(" !U");
+					break;
+
+				case ICMP_UNREACH_ISOLATED:
+					++unreachable;
+					printf(" !I");
+					break;
+
+				case ICMP_UNREACH_TOSNET:
+				case ICMP_UNREACH_TOSHOST:
+					++unreachable;
+					printf(" !T");
+					break;
+
+				default:
+					++unreachable;
+					printf(" !<%d>", code);
+					break;
+				}
+				break;
+			}
+			if (cc == 0)
+				printf(" *");
+			(void)fflush(stdout);
+		}
+		putchar('\n');
+		if (got_there ||
+		    (unreachable > 0 && unreachable >= nprobes - 1))
+			break;
+	}
+	return 0;
+}
diff --git a/networking/udhcp/Config.in b/networking/udhcp/Config.in
new file mode 100644
index 0000000..f633473
--- /dev/null
+++ b/networking/udhcp/Config.in
@@ -0,0 +1,67 @@
+#
+# For a description of the syntax of this configuration file,
+# see scripts/kbuild/config-language.txt.
+#
+
+config APP_UDHCPD
+	bool "udhcp Server (udhcpd)"
+	default n
+	help
+	  uDHCPd is a DHCP server geared primarily toward embedded systems,
+	  while striving to be fully functional and RFC compliant.
+
+	  See http://udhcp.busybox.net for further details.
+
+config APP_DHCPRELAY
+	bool "dhcprelay"
+	default n
+	depends on APP_UDHCPD
+	help
+	  dhcprelay listens for dhcp requests on one or more interfaces
+	  and forwards these requests to a different interface or dhcp
+	  server.
+
+config APP_DUMPLEASES
+	bool "Lease display utility (dumpleases)"
+	default n
+	depends on APP_UDHCPD
+	help
+	  dumpleases displays the leases written out by the udhcpd server.
+	  Lease times are stored in the file by time remaining in lease, or
+	  by the absolute time that it expires in seconds from epoch.
+
+	  See http://udhcp.busybox.net for further details.
+
+config APP_UDHCPC
+	bool "udhcp Client (udhcpc)"
+	default n
+	help
+	  uDHCPc is a DHCP client geared primarily toward embedded systems,
+	  while striving to be fully functional and RFC compliant.
+
+	  The udhcp client negotiates a lease with the DHCP server and
+	  notifies a set of scripts when a lease is obtained or lost.
+
+	  See http://udhcp.busybox.net for further details.
+
+config FEATURE_UDHCP_SYSLOG
+	bool "Log udhcp messages to syslog"
+	default n
+	depends on APP_UDHCPD || APP_UDHCPC
+	select FEATURE_SYSLOG
+	help
+	  If not daemonized, udhcpd prints its messages to stdout/stderr.
+	  If this option is selected, it will also log them to syslog.
+
+	  See http://udhcp.busybox.net for further details.
+
+config FEATURE_UDHCP_DEBUG
+	bool "Compile udhcp with noisy debugging messages"
+	default n
+	depends on APP_UDHCPD || APP_UDHCPC
+	help
+	  If selected, udhcpd will output extra debugging output.  If using
+	  this option, compile uDHCP with "-g", and do not fork the daemon to
+	  the background.
+
+	  See http://udhcp.busybox.net for further details.
diff --git a/networking/udhcp/Kbuild b/networking/udhcp/Kbuild
new file mode 100644
index 0000000..dc2c01f
--- /dev/null
+++ b/networking/udhcp/Kbuild
@@ -0,0 +1,18 @@
+# Makefile for busybox
+#
+# Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
+#
+# Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+#
+
+lib-y:=
+lib-$(CONFIG_APP_UDHCPC)	+= common.o options.o packet.o pidfile.o \
+				   signalpipe.o socket.o
+lib-$(CONFIG_APP_UDHCPD)	+= common.o options.o packet.o pidfile.o \
+				   signalpipe.o socket.o
+lib-$(CONFIG_APP_UDHCPC)	+= dhcpc.o clientpacket.o clientsocket.o \
+				   script.o
+lib-$(CONFIG_APP_UDHCPD)	+= dhcpd.o arpping.o files.o leases.o \
+				   serverpacket.o static_leases.o
+lib-$(CONFIG_APP_DUMPLEASES)	+= dumpleases.o
+lib-$(CONFIG_APP_DHCPRELAY)     += dhcprelay.o
diff --git a/networking/udhcp/arpping.c b/networking/udhcp/arpping.c
new file mode 100644
index 0000000..9c8b9c5
--- /dev/null
+++ b/networking/udhcp/arpping.c
@@ -0,0 +1,114 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * arpping.c
+ *
+ * Mostly stolen from: dhcpcd - DHCP client daemon
+ * by Yoichi Hariguchi <yoichi@fore.com>
+ */
+
+#include <netinet/if_ether.h>
+#include <net/if_arp.h>
+
+#include "common.h"
+#include "dhcpd.h"
+
+
+struct arpMsg {
+	/* Ethernet header */
+	u_char   h_dest[6];			/* destination ether addr */
+	u_char   h_source[6];			/* source ether addr */
+	u_short  h_proto;			/* packet type ID field */
+
+	/* ARP packet */
+	uint16_t htype;				/* hardware type (must be ARPHRD_ETHER) */
+	uint16_t ptype;				/* protocol type (must be ETH_P_IP) */
+	uint8_t  hlen;				/* hardware address length (must be 6) */
+	uint8_t  plen;				/* protocol address length (must be 4) */
+	uint16_t operation;			/* ARP opcode */
+	uint8_t  sHaddr[6];			/* sender's hardware address */
+	uint8_t  sInaddr[4];			/* sender's IP address */
+	uint8_t  tHaddr[6];			/* target's hardware address */
+	uint8_t  tInaddr[4];			/* target's IP address */
+	uint8_t  pad[18];			/* pad for min. Ethernet payload (60 bytes) */
+} ATTRIBUTE_PACKED;
+
+/* args:	yiaddr - what IP to ping
+ *		ip - our ip
+ *		mac - our arp address
+ *		interface - interface to use
+ * retn:	1 addr free
+ *		0 addr used
+ *		-1 error
+ */
+
+/* FIXME: match response against chaddr */
+int arpping(uint32_t yiaddr, uint32_t ip, uint8_t *mac, char *interface)
+{
+	int	timeout = 2;
+	int	s;			/* socket */
+	int	rv = 1;			/* return value */
+	struct sockaddr addr;		/* for interface name */
+	struct arpMsg	arp;
+	fd_set		fdset;
+	struct timeval	tm;
+	time_t		prevTime;
+
+
+	s = socket(PF_PACKET, SOCK_PACKET, htons(ETH_P_ARP));
+	if (s == -1) {
+		bb_perror_msg(bb_msg_can_not_create_raw_socket);
+		return -1;
+	}
+
+	if (setsockopt_broadcast(s) == -1) {
+		bb_perror_msg("cannot setsocketopt on raw socket");
+		close(s);
+		return -1;
+	}
+
+	/* send arp request */
+	memset(&arp, 0, sizeof(arp));
+	memcpy(arp.h_dest, MAC_BCAST_ADDR, 6);		/* MAC DA */
+	memcpy(arp.h_source, mac, 6);			/* MAC SA */
+	arp.h_proto = htons(ETH_P_ARP);			/* protocol type (Ethernet) */
+	arp.htype = htons(ARPHRD_ETHER);		/* hardware type */
+	arp.ptype = htons(ETH_P_IP);			/* protocol type (ARP message) */
+	arp.hlen = 6;					/* hardware address length */
+	arp.plen = 4;					/* protocol address length */
+	arp.operation = htons(ARPOP_REQUEST);		/* ARP op code */
+	memcpy(arp.sInaddr, &ip, sizeof(ip));		/* source IP address */
+	memcpy(arp.sHaddr, mac, 6);			/* source hardware address */
+	memcpy(arp.tInaddr, &yiaddr, sizeof(yiaddr));	/* target IP address */
+
+	memset(&addr, 0, sizeof(addr));
+	strcpy(addr.sa_data, interface);
+	if (sendto(s, &arp, sizeof(arp), 0, &addr, sizeof(addr)) < 0)
+		rv = 0;
+
+	/* wait arp reply, and check it */
+	tm.tv_usec = 0;
+	prevTime = uptime();
+	while (timeout > 0) {
+		FD_ZERO(&fdset);
+		FD_SET(s, &fdset);
+		tm.tv_sec = timeout;
+		if (select(s + 1, &fdset, (fd_set *) NULL, (fd_set *) NULL, &tm) < 0) {
+			bb_perror_msg("error on ARPING request");
+			if (errno != EINTR) rv = 0;
+		} else if (FD_ISSET(s, &fdset)) {
+			if (recv(s, &arp, sizeof(arp), 0) < 0 ) rv = 0;
+			if (arp.operation == htons(ARPOP_REPLY) &&
+			    memcmp(arp.tHaddr, mac, 6) == 0 &&
+			    *((uint32_t *) arp.sInaddr) == yiaddr) {
+				DEBUG("Valid arp reply received for this address");
+				rv = 0;
+				break;
+			}
+		}
+		timeout -= uptime() - prevTime;
+		prevTime = uptime();
+	}
+	close(s);
+	DEBUG("%salid arp replies for this address", rv ? "No v" : "V");
+	return rv;
+}
diff --git a/networking/udhcp/clientpacket.c b/networking/udhcp/clientpacket.c
new file mode 100644
index 0000000..15cbda2
--- /dev/null
+++ b/networking/udhcp/clientpacket.c
@@ -0,0 +1,224 @@
+/* vi: set sw=4 ts=4: */
+/* clientpacket.c
+ *
+ * Packet generation and dispatching functions for the DHCP client.
+ *
+ * Russ Dill <Russ.Dill@asu.edu> July 2001
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ */
+
+#include <features.h>
+#if (__GLIBC__ >= 2 && __GLIBC_MINOR__ >= 1) || defined _NEWLIB_VERSION
+#include <netpacket/packet.h>
+#include <net/ethernet.h>
+#else
+#include <asm/types.h>
+#include <linux/if_packet.h>
+#include <linux/if_ether.h>
+#endif
+
+#include "common.h"
+#include "dhcpd.h"
+#include "dhcpc.h"
+#include "options.h"
+
+
+/* Create a random xid */
+unsigned long random_xid(void)
+{
+	static int initialized;
+	if (!initialized) {
+		unsigned long seed;
+
+		if (open_read_close("/dev/urandom", &seed, sizeof(seed)) < 0) {
+			bb_info_msg("Cannot load seed "
+				"from /dev/urandom: %s", strerror(errno));
+			seed = time(0);
+		}
+		srand(seed);
+		initialized++;
+	}
+	return rand();
+}
+
+
+/* initialize a packet with the proper defaults */
+static void init_packet(struct dhcpMessage *packet, char type)
+{
+	udhcp_init_header(packet, type);
+	memcpy(packet->chaddr, client_config.arp, 6);
+	if (client_config.clientid)
+		add_option_string(packet->options, client_config.clientid);
+	if (client_config.hostname) add_option_string(packet->options, client_config.hostname);
+	if (client_config.fqdn) add_option_string(packet->options, client_config.fqdn);
+	add_option_string(packet->options, client_config.vendorclass);
+}
+
+
+/* Add a parameter request list for stubborn DHCP servers. Pull the data
+ * from the struct in options.c. Don't do bounds checking here because it
+ * goes towards the head of the packet. */
+static void add_requests(struct dhcpMessage *packet)
+{
+	int end = end_option(packet->options);
+	int i, len = 0;
+
+	packet->options[end + OPT_CODE] = DHCP_PARAM_REQ;
+	for (i = 0; dhcp_options[i].code; i++)
+		if (dhcp_options[i].flags & OPTION_REQ)
+			packet->options[end + OPT_DATA + len++] = dhcp_options[i].code;
+	packet->options[end + OPT_LEN] = len;
+	packet->options[end + OPT_DATA + len] = DHCP_END;
+
+}
+
+
+/* Broadcast a DHCP discover packet to the network, with an optionally requested IP */
+int send_discover(unsigned long xid, unsigned long requested)
+{
+	struct dhcpMessage packet;
+
+	init_packet(&packet, DHCPDISCOVER);
+	packet.xid = xid;
+	if (requested)
+		add_simple_option(packet.options, DHCP_REQUESTED_IP, requested);
+
+	add_requests(&packet);
+	bb_info_msg("Sending discover...");
+	return udhcp_raw_packet(&packet, INADDR_ANY, CLIENT_PORT, INADDR_BROADCAST,
+			SERVER_PORT, MAC_BCAST_ADDR, client_config.ifindex);
+}
+
+
+/* Broadcasts a DHCP request message */
+int send_selecting(unsigned long xid, unsigned long server, unsigned long requested)
+{
+	struct dhcpMessage packet;
+	struct in_addr addr;
+
+	init_packet(&packet, DHCPREQUEST);
+	packet.xid = xid;
+
+	add_simple_option(packet.options, DHCP_REQUESTED_IP, requested);
+	add_simple_option(packet.options, DHCP_SERVER_ID, server);
+
+	add_requests(&packet);
+	addr.s_addr = requested;
+	bb_info_msg("Sending select for %s...", inet_ntoa(addr));
+	return udhcp_raw_packet(&packet, INADDR_ANY, CLIENT_PORT, INADDR_BROADCAST,
+				SERVER_PORT, MAC_BCAST_ADDR, client_config.ifindex);
+}
+
+
+/* Unicasts or broadcasts a DHCP renew message */
+int send_renew(unsigned long xid, unsigned long server, unsigned long ciaddr)
+{
+	struct dhcpMessage packet;
+	int ret = 0;
+
+	init_packet(&packet, DHCPREQUEST);
+	packet.xid = xid;
+	packet.ciaddr = ciaddr;
+
+	add_requests(&packet);
+	bb_info_msg("Sending renew...");
+	if (server)
+		ret = udhcp_kernel_packet(&packet, ciaddr, CLIENT_PORT, server, SERVER_PORT);
+	else ret = udhcp_raw_packet(&packet, INADDR_ANY, CLIENT_PORT, INADDR_BROADCAST,
+				SERVER_PORT, MAC_BCAST_ADDR, client_config.ifindex);
+	return ret;
+}
+
+
+/* Unicasts a DHCP release message */
+int send_release(unsigned long server, unsigned long ciaddr)
+{
+	struct dhcpMessage packet;
+
+	init_packet(&packet, DHCPRELEASE);
+	packet.xid = random_xid();
+	packet.ciaddr = ciaddr;
+
+	add_simple_option(packet.options, DHCP_REQUESTED_IP, ciaddr);
+	add_simple_option(packet.options, DHCP_SERVER_ID, server);
+
+	bb_info_msg("Sending release...");
+	return udhcp_kernel_packet(&packet, ciaddr, CLIENT_PORT, server, SERVER_PORT);
+}
+
+
+/* return -1 on errors that are fatal for the socket, -2 for those that aren't */
+int get_raw_packet(struct dhcpMessage *payload, int fd)
+{
+	int bytes;
+	struct udp_dhcp_packet packet;
+	uint32_t source, dest;
+	uint16_t check;
+
+	memset(&packet, 0, sizeof(struct udp_dhcp_packet));
+	bytes = read(fd, &packet, sizeof(struct udp_dhcp_packet));
+	if (bytes < 0) {
+		DEBUG("Cannot read on raw listening socket - ignoring");
+		usleep(500000); /* possible down interface, looping condition */
+		return -1;
+	}
+
+	if (bytes < (int) (sizeof(struct iphdr) + sizeof(struct udphdr))) {
+		DEBUG("Message too short, ignoring");
+		return -2;
+	}
+
+	if (bytes < ntohs(packet.ip.tot_len)) {
+		DEBUG("Truncated packet");
+		return -2;
+	}
+
+	/* ignore any extra garbage bytes */
+	bytes = ntohs(packet.ip.tot_len);
+
+	/* Make sure its the right packet for us, and that it passes sanity checks */
+	if (packet.ip.protocol != IPPROTO_UDP || packet.ip.version != IPVERSION
+	 || packet.ip.ihl != sizeof(packet.ip) >> 2
+	 || packet.udp.dest != htons(CLIENT_PORT)
+	 || bytes > (int) sizeof(struct udp_dhcp_packet)
+	 || ntohs(packet.udp.len) != (uint16_t)(bytes - sizeof(packet.ip))
+	) {
+		DEBUG("Unrelated/bogus packet");
+		return -2;
+	}
+
+	/* check IP checksum */
+	check = packet.ip.check;
+	packet.ip.check = 0;
+	if (check != udhcp_checksum(&(packet.ip), sizeof(packet.ip))) {
+		DEBUG("bad IP header checksum, ignoring");
+		return -1;
+	}
+
+	/* verify the UDP checksum by replacing the header with a psuedo header */
+	source = packet.ip.saddr;
+	dest = packet.ip.daddr;
+	check = packet.udp.check;
+	packet.udp.check = 0;
+	memset(&packet.ip, 0, sizeof(packet.ip));
+
+	packet.ip.protocol = IPPROTO_UDP;
+	packet.ip.saddr = source;
+	packet.ip.daddr = dest;
+	packet.ip.tot_len = packet.udp.len; /* cheat on the psuedo-header */
+	if (check && check != udhcp_checksum(&packet, bytes)) {
+		bb_error_msg("packet with bad UDP checksum received, ignoring");
+		return -2;
+	}
+
+	memcpy(payload, &(packet.data), bytes - (sizeof(packet.ip) + sizeof(packet.udp)));
+
+	if (ntohl(payload->cookie) != DHCP_MAGIC) {
+		bb_error_msg("received bogus message (bad magic) - ignoring");
+		return -2;
+	}
+	DEBUG("oooooh!!! got some!");
+	return bytes - (sizeof(packet.ip) + sizeof(packet.udp));
+
+}
diff --git a/networking/udhcp/clientsocket.c b/networking/udhcp/clientsocket.c
new file mode 100644
index 0000000..8520619
--- /dev/null
+++ b/networking/udhcp/clientsocket.c
@@ -0,0 +1,59 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * clientsocket.c -- DHCP client socket creation
+ *
+ * udhcp client
+ *
+ * Russ Dill <Russ.Dill@asu.edu> July 2001
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <features.h>
+#if (__GLIBC__ >= 2 && __GLIBC_MINOR__ >= 1) || defined(_NEWLIB_VERSION)
+#include <netpacket/packet.h>
+#include <net/ethernet.h>
+#else
+#include <asm/types.h>
+#include <linux/if_packet.h>
+#include <linux/if_ether.h>
+#endif
+
+#include "common.h"
+
+
+int raw_socket(int ifindex)
+{
+	int fd;
+	struct sockaddr_ll sock;
+
+	DEBUG("Opening raw socket on ifindex %d", ifindex);
+	fd = socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_IP));
+	if (fd < 0) {
+		bb_perror_msg("socket");
+		return -1;
+	}
+
+	sock.sll_family = AF_PACKET;
+	sock.sll_protocol = htons(ETH_P_IP);
+	sock.sll_ifindex = ifindex;
+	if (bind(fd, (struct sockaddr *) &sock, sizeof(sock)) < 0) {
+		bb_perror_msg("bind");
+		close(fd);
+		return -1;
+	}
+
+	return fd;
+}
diff --git a/networking/udhcp/common.c b/networking/udhcp/common.c
new file mode 100644
index 0000000..3e916f4
--- /dev/null
+++ b/networking/udhcp/common.c
@@ -0,0 +1,75 @@
+/* vi: set sw=4 ts=4: */
+/* common.c
+ *
+ * Functions for debugging and logging as well as some other
+ * simple helper functions.
+ *
+ * Russ Dill <Russ.Dill@asu.edu> 2001-2003
+ * Rewritten by Vladimir Oleynik <dzo@simtreas.ru> (C) 2003
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ */
+
+#include <syslog.h>
+
+#include "common.h"
+
+
+long uptime(void)
+{
+	struct sysinfo info;
+	sysinfo(&info);
+	return info.uptime;
+}
+
+/*
+ * This function makes sure our first socket calls
+ * aren't going to fd 1 (printf badness...) and are
+ * not later closed by daemon()
+ */
+static inline void sanitize_fds(void)
+{
+	int fd = xopen(bb_dev_null, O_RDWR);
+	while (fd < 3)
+		fd = dup(fd);
+	close(fd);
+}
+
+
+void udhcp_background(const char *pidfile)
+{
+#ifdef __uClinux__
+	bb_error_msg("cannot background in uclinux (yet)");
+#else /* __uClinux__ */
+	int pid_fd;
+
+	/* hold lock during fork. */
+	pid_fd = pidfile_acquire(pidfile);
+	setsid();
+	xdaemon(0, 0);
+	logmode &= ~LOGMODE_STDIO;
+	pidfile_write_release(pid_fd);
+#endif /* __uClinux__ */
+}
+
+void udhcp_start_log_and_pid(const char *pidfile)
+{
+	int pid_fd;
+
+	/* Make sure our syslog fd isn't overwritten */
+	sanitize_fds();
+
+	/* do some other misc startup stuff while we are here to save bytes */
+	pid_fd = pidfile_acquire(pidfile);
+	pidfile_write_release(pid_fd);
+
+	/* equivelent of doing a fflush after every \n */
+	setlinebuf(stdout);
+
+	if (ENABLE_FEATURE_UDHCP_SYSLOG) {
+		openlog(applet_name, LOG_PID, LOG_LOCAL0);
+		logmode |= LOGMODE_SYSLOG;
+	}
+
+	bb_info_msg("%s (v%s) started", applet_name, BB_VER);
+}
diff --git a/networking/udhcp/common.h b/networking/udhcp/common.h
new file mode 100644
index 0000000..70a7693
--- /dev/null
+++ b/networking/udhcp/common.h
@@ -0,0 +1,108 @@
+/* vi: set sw=4 ts=4: */
+/* common.h
+ *
+ * Russ Dill <Russ.Dill@asu.edu> September 2001
+ * Rewritten by Vladimir Oleynik <dzo@simtreas.ru> (C) 2003
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ */
+
+#ifndef _COMMON_H
+#define _COMMON_H
+
+#include "busybox.h"
+
+#ifdef CONFIG_INSTALL_NO_USR
+# define DEFAULT_SCRIPT  "/share/udhcpc/default.script"
+#else
+# define DEFAULT_SCRIPT  "/usr/share/udhcpc/default.script"
+#endif
+
+#define COMBINED_BINARY
+
+
+/*** packet.h ***/
+
+#include <netinet/udp.h>
+#include <netinet/ip.h>
+
+struct dhcpMessage {
+	uint8_t op;
+	uint8_t htype;
+	uint8_t hlen;
+	uint8_t hops;
+	uint32_t xid;
+	uint16_t secs;
+	uint16_t flags;
+	uint32_t ciaddr;
+	uint32_t yiaddr;
+	uint32_t siaddr;
+	uint32_t giaddr;
+	uint8_t chaddr[16];
+	uint8_t sname[64];
+	uint8_t file[128];
+	uint32_t cookie;
+	uint8_t options[308]; /* 312 - cookie */
+};
+
+struct udp_dhcp_packet {
+	struct iphdr ip;
+	struct udphdr udp;
+	struct dhcpMessage data;
+};
+
+void udhcp_init_header(struct dhcpMessage *packet, char type);
+int udhcp_get_packet(struct dhcpMessage *packet, int fd);
+uint16_t udhcp_checksum(void *addr, int count);
+int udhcp_raw_packet(struct dhcpMessage *payload,
+		uint32_t source_ip, int source_port,
+		uint32_t dest_ip, int dest_port, uint8_t *dest_arp, int ifindex);
+int udhcp_kernel_packet(struct dhcpMessage *payload,
+		uint32_t source_ip, int source_port,
+		uint32_t dest_ip, int dest_port);
+
+
+/**/
+
+void udhcp_background(const char *pidfile);
+void udhcp_start_log_and_pid(const char *pidfile);
+
+void udhcp_run_script(struct dhcpMessage *packet, const char *name);
+
+// Still need to clean these up...
+
+/* from pidfile.h */
+#define pidfile_acquire		udhcp_pidfile_acquire
+#define pidfile_write_release	udhcp_pidfile_write_release
+/* from options.h */
+#define get_option		udhcp_get_option
+#define end_option		udhcp_end_option
+#define add_option_string	udhcp_add_option_string
+#define add_simple_option	udhcp_add_simple_option
+#define option_lengths		udhcp_option_lengths
+/* from socket.h */
+#define listen_socket		udhcp_listen_socket
+#define read_interface		udhcp_read_interface
+/* from dhcpc.h */
+#define client_config		udhcp_client_config
+/* from dhcpd.h */
+#define server_config		udhcp_server_config
+
+long uptime(void);
+void udhcp_sp_setup(void);
+int udhcp_sp_fd_set(fd_set *rfds, int extra_fd);
+int udhcp_sp_read(fd_set *rfds);
+int raw_socket(int ifindex);
+int read_interface(char *interface, int *ifindex, uint32_t *addr, uint8_t *arp);
+int listen_socket(uint32_t ip, int port, char *inf);
+int pidfile_acquire(const char *pidfile);
+void pidfile_write_release(int pid_fd);
+int arpping(uint32_t yiaddr, uint32_t ip, uint8_t *arp, char *interface);
+
+#if ENABLE_FEATURE_UDHCP_DEBUG
+# define DEBUG(str, args...) bb_info_msg(str, ## args)
+#else
+# define DEBUG(str, args...) do {;} while (0)
+#endif
+
+#endif
diff --git a/networking/udhcp/dhcpc.c b/networking/udhcp/dhcpc.c
new file mode 100644
index 0000000..71315ff
--- /dev/null
+++ b/networking/udhcp/dhcpc.c
@@ -0,0 +1,509 @@
+/* vi: set sw=4 ts=4: */
+/* dhcpc.c
+ *
+ * udhcp DHCP client
+ *
+ * Russ Dill <Russ.Dill@asu.edu> July 2001
+ *
+ * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+ */
+
+#include <getopt.h>
+
+#include "common.h"
+#include "dhcpd.h"
+#include "dhcpc.h"
+#include "options.h"
+
+
+static int state;
+/* Something is definitely wrong here. IPv4 addresses
+ * in variables of type long?? BTW, we use inet_ntoa()
+ * in the code. Manpage says that struct in_addr has a member of type long (!)
+ * which holds IPv4 address, and the struct is passed by value (!!)
+ */
+static unsigned long requested_ip; /* = 0 */
+static unsigned long server_addr;
+static unsigned long timeout;
+static int packet_num; /* = 0 */
+static int fd = -1;
+
+#define LISTEN_NONE 0
+#define LISTEN_KERNEL 1
+#define LISTEN_RAW 2
+static int listen_mode;
+
+struct client_config_t client_config;
+
+
+/* just a little helper */
+static void change_mode(int new_mode)
+{
+	DEBUG("entering %s listen mode",
+		new_mode ? (new_mode == 1 ? "kernel" : "raw") : "none");
+	if (fd >= 0) close(fd);
+	fd = -1;
+	listen_mode = new_mode;
+}
+
+
+/* perform a renew */
+static void perform_renew(void)
+{
+	bb_info_msg("Performing a DHCP renew");
+	switch (state) {
+	case BOUND:
+		change_mode(LISTEN_KERNEL);
+	case RENEWING:
+	case REBINDING:
+		state = RENEW_REQUESTED;
+		break;
+	case RENEW_REQUESTED: /* impatient are we? fine, square 1 */
+		udhcp_run_script(NULL, "deconfig");
+	case REQUESTING:
+	case RELEASED:
+		change_mode(LISTEN_RAW);
+		state = INIT_SELECTING;
+		break;
+	case INIT_SELECTING:
+		break;
+	}
+
+	/* start things over */
+	packet_num = 0;
+
+	/* Kill any timeouts because the user wants this to hurry along */
+	timeout = 0;
+}
+
+
+/* perform a release */
+static void perform_release(void)
+{
+	char buffer[16];
+	struct in_addr temp_addr;
+
+	/* send release packet */
+	if (state == BOUND || state == RENEWING || state == REBINDING) {
+		temp_addr.s_addr = server_addr;
+		sprintf(buffer, "%s", inet_ntoa(temp_addr));
+		temp_addr.s_addr = requested_ip;
+		bb_info_msg("Unicasting a release of %s to %s",
+				inet_ntoa(temp_addr), buffer);
+		send_release(server_addr, requested_ip); /* unicast */
+		udhcp_run_script(NULL, "deconfig");
+	}
+	bb_info_msg("Entering released state");
+
+	change_mode(LISTEN_NONE);
+	state = RELEASED;
+	timeout = 0x7fffffff;
+}
+
+
+static void client_background(void)
+{
+	udhcp_background(client_config.pidfile);
+	client_config.foreground = 1; /* Do not fork again. */
+	client_config.background_if_no_lease = 0;
+}
+
+
+static uint8_t* alloc_dhcp_option(int code, const char *str, int extra)
+{
+	uint8_t *storage;
+	int len = strlen(str);
+	if (len > 255) len = 255;
+	storage = xzalloc(len + extra + OPT_DATA);
+	storage[OPT_CODE] = code;
+	storage[OPT_LEN] = len + extra;
+	memcpy(storage + extra + OPT_DATA, str, len);
+	return storage;
+}
+
+
+int udhcpc_main(int argc, char *argv[])
+{
+	uint8_t *temp, *message;
+	char *str_c, *str_V, *str_h, *str_F, *str_r, *str_T, *str_t;
+	unsigned long t1 = 0, t2 = 0, xid = 0;
+	unsigned long start = 0, lease = 0;
+	long now;
+	unsigned opt;
+	int max_fd;
+	int sig;
+	int retval;
+	int len;
+	int no_clientid = 0;
+	fd_set rfds;
+	struct timeval tv;
+	struct dhcpMessage packet;
+	struct in_addr temp_addr;
+
+	enum {
+		OPT_c = 1 << 0,
+		OPT_C = 1 << 1,
+		OPT_V = 1 << 2,
+		OPT_f = 1 << 3,
+		OPT_b = 1 << 4,
+		OPT_H = 1 << 5,
+		OPT_h = 1 << 6,
+		OPT_F = 1 << 7,
+		OPT_i = 1 << 8,
+		OPT_n = 1 << 9,
+		OPT_p = 1 << 10,
+		OPT_q = 1 << 11,
+		OPT_R = 1 << 12,
+		OPT_r = 1 << 13,
+		OPT_s = 1 << 14,
+		OPT_T = 1 << 15,
+		OPT_t = 1 << 16,
+		OPT_v = 1 << 17,
+	};
+#if ENABLE_GETOPT_LONG
+	static const struct option arg_options[] = {
+		{ "clientid",   required_argument,      0, 'c' },
+		{ "clientid-none", no_argument,         0, 'C' },
+		{ "vendorclass", required_argument,     0, 'V' },
+		{ "foreground", no_argument,            0, 'f' },
+		{ "background", no_argument,            0, 'b' },
+		{ "hostname",   required_argument,      0, 'H' },
+		{ "hostname",   required_argument,      0, 'h' },
+		{ "fqdn",       required_argument,      0, 'F' },
+		{ "interface",  required_argument,      0, 'i' },
+		{ "now",        no_argument,            0, 'n' },
+		{ "pidfile",    required_argument,      0, 'p' },
+		{ "quit",       no_argument,            0, 'q' },
+		{ "release",    no_argument,            0, 'R' },
+		{ "request",    required_argument,      0, 'r' },
+		{ "script",     required_argument,      0, 's' },
+		{ "timeout",    required_argument,      0, 'T' },
+		{ "version",    no_argument,            0, 'v' },
+		{ "retries",    required_argument,      0, 't' },
+		{ 0, 0, 0, 0 }
+	};
+#endif
+	/* Default options. */
+	client_config.interface = "eth0";
+	client_config.script = DEFAULT_SCRIPT;
+	client_config.retries = 3;
+	client_config.timeout = 3;
+
+	/* Parse command line */
+	opt_complementary = "?:c--C:C--c" // mutually exclusive
+	                    ":hH:Hh"; // -h and -H are the same
+#if ENABLE_GETOPT_LONG
+	applet_long_options = arg_options;
+#endif
+	opt = getopt32(argc, argv, "c:CV:fbH:h:F:i:np:qRr:s:T:t:v",
+		&str_c, &str_V, &str_h, &str_h, &str_F,
+		&client_config.interface, &client_config.pidfile, &str_r,
+		&client_config.script, &str_T, &str_t
+		);
+
+	if (opt & OPT_c)
+		client_config.clientid = alloc_dhcp_option(DHCP_CLIENT_ID, str_c, 0);
+	if (opt & OPT_C)
+		no_clientid = 1;
+	if (opt & OPT_V)
+		client_config.vendorclass = alloc_dhcp_option(DHCP_VENDOR, str_V, 0);
+	if (opt & OPT_f)
+		client_config.foreground = 1;
+	if (opt & OPT_b)
+		client_config.background_if_no_lease = 1;
+	if (opt & OPT_h)
+		client_config.hostname = alloc_dhcp_option(DHCP_HOST_NAME, str_h, 0);
+	if (opt & OPT_F) {
+		client_config.fqdn = alloc_dhcp_option(DHCP_FQDN, str_F, 3);
+		/* Flags: 0000NEOS
+		S: 1 => Client requests Server to update A RR in DNS as well as PTR
+		O: 1 => Server indicates to client that DNS has been updated regardless
+		E: 1 => Name data is DNS format, i.e. <4>host<6>domain<4>com<0> not "host.domain.com"
+		N: 1 => Client requests Server to not update DNS
+		*/
+		client_config.fqdn[OPT_DATA + 0] = 0x1;
+		/* client_config.fqdn[OPT_DATA + 1] = 0; - redundant */
+		/* client_config.fqdn[OPT_DATA + 2] = 0; - redundant */
+	}
+	// if (opt & OPT_i) client_config.interface = ...
+	if (opt & OPT_n)
+		client_config.abort_if_no_lease = 1;
+	// if (opt & OPT_p) client_config.pidfile = ...
+	if (opt & OPT_q)
+		client_config.quit_after_lease = 1;
+	if (opt & OPT_R)
+		client_config.release_on_quit = 1;
+	if (opt & OPT_r)
+		requested_ip = inet_addr(str_r);
+	// if (opt & OPT_s) client_config.script = ...
+	if (opt & OPT_T)
+		client_config.timeout = xatoi_u(str_T);
+	if (opt & OPT_t)
+		client_config.retries = xatoi_u(str_t);
+	if (opt & OPT_v) {
+		printf("version %s\n\n", BB_VER);
+		return 0;
+	}
+
+	/* Start the log, sanitize fd's, and write a pid file */
+	udhcp_start_log_and_pid(client_config.pidfile);
+
+	if (read_interface(client_config.interface, &client_config.ifindex,
+			   NULL, client_config.arp) < 0)
+		return 1;
+
+	/* if not set, and not suppressed, setup the default client ID */
+	if (!client_config.clientid && !no_clientid) {
+		client_config.clientid = alloc_dhcp_option(DHCP_CLIENT_ID, "", 7);
+		client_config.clientid[OPT_DATA] = 1;
+		memcpy(client_config.clientid + OPT_DATA+1, client_config.arp, 6);
+	}
+
+	if (!client_config.vendorclass)
+		client_config.vendorclass = alloc_dhcp_option(DHCP_VENDOR, "udhcp "BB_VER, 0);
+
+	/* setup the signal pipe */
+	udhcp_sp_setup();
+
+	state = INIT_SELECTING;
+	udhcp_run_script(NULL, "deconfig");
+	change_mode(LISTEN_RAW);
+
+	for (;;) {
+		tv.tv_sec = timeout - uptime();
+		tv.tv_usec = 0;
+
+		if (listen_mode != LISTEN_NONE && fd < 0) {
+			if (listen_mode == LISTEN_KERNEL)
+				fd = listen_socket(INADDR_ANY, CLIENT_PORT, client_config.interface);
+			else
+				fd = raw_socket(client_config.ifindex);
+			if (fd < 0) {
+				bb_perror_msg("FATAL: cannot listen on socket");
+				return 0;
+			}
+		}
+		max_fd = udhcp_sp_fd_set(&rfds, fd);
+
+		if (tv.tv_sec > 0) {
+			DEBUG("Waiting on select...");
+			retval = select(max_fd + 1, &rfds, NULL, NULL, &tv);
+		} else retval = 0; /* If we already timed out, fall through */
+
+		now = uptime();
+		if (retval == 0) {
+			/* timeout dropped to zero */
+			switch (state) {
+			case INIT_SELECTING:
+				if (packet_num < client_config.retries) {
+					if (packet_num == 0)
+						xid = random_xid();
+
+					/* send discover packet */
+					send_discover(xid, requested_ip); /* broadcast */
+
+					timeout = now + client_config.timeout;
+					packet_num++;
+				} else {
+					udhcp_run_script(NULL, "leasefail");
+					if (client_config.background_if_no_lease) {
+						bb_info_msg("No lease, forking to background");
+						client_background();
+					} else if (client_config.abort_if_no_lease) {
+						bb_info_msg("No lease, failing");
+						return 1;
+					}
+					/* wait to try again */
+					packet_num = 0;
+					timeout = now + 60;
+				}
+				break;
+			case RENEW_REQUESTED:
+			case REQUESTING:
+				if (packet_num < client_config.retries) {
+					/* send request packet */
+					if (state == RENEW_REQUESTED)
+						send_renew(xid, server_addr, requested_ip); /* unicast */
+					else send_selecting(xid, server_addr, requested_ip); /* broadcast */
+
+					timeout = now + ((packet_num == 2) ? 10 : 2);
+					packet_num++;
+				} else {
+					/* timed out, go back to init state */
+					if (state == RENEW_REQUESTED) udhcp_run_script(NULL, "deconfig");
+					state = INIT_SELECTING;
+					timeout = now;
+					packet_num = 0;
+					change_mode(LISTEN_RAW);
+				}
+				break;
+			case BOUND:
+				/* Lease is starting to run out, time to enter renewing state */
+				state = RENEWING;
+				change_mode(LISTEN_KERNEL);
+				DEBUG("Entering renew state");
+				/* fall right through */
+			case RENEWING:
+				/* Either set a new T1, or enter REBINDING state */
+				if ((t2 - t1) <= (lease / 14400 + 1)) {
+					/* timed out, enter rebinding state */
+					state = REBINDING;
+					timeout = now + (t2 - t1);
+					DEBUG("Entering rebinding state");
+				} else {
+					/* send a request packet */
+					send_renew(xid, server_addr, requested_ip); /* unicast */
+
+					t1 = (t2 - t1) / 2 + t1;
+					timeout = t1 + start;
+				}
+				break;
+			case REBINDING:
+				/* Either set a new T2, or enter INIT state */
+				if ((lease - t2) <= (lease / 14400 + 1)) {
+					/* timed out, enter init state */
+					state = INIT_SELECTING;
+					bb_info_msg("Lease lost, entering init state");
+					udhcp_run_script(NULL, "deconfig");
+					timeout = now;
+					packet_num = 0;
+					change_mode(LISTEN_RAW);
+				} else {
+					/* send a request packet */
+					send_renew(xid, 0, requested_ip); /* broadcast */
+
+					t2 = (lease - t2) / 2 + t2;
+					timeout = t2 + start;
+				}
+				break;
+			case RELEASED:
+				/* yah, I know, *you* say it would never happen */
+				timeout = 0x7fffffff;
+				break;
+			}
+		} else if (retval > 0 && listen_mode != LISTEN_NONE && FD_ISSET(fd, &rfds)) {
+			/* a packet is ready, read it */
+
+			if (listen_mode == LISTEN_KERNEL)
+				len = udhcp_get_packet(&packet, fd);
+			else len = get_raw_packet(&packet, fd);
+
+			if (len == -1 && errno != EINTR) {
+				DEBUG("error on read, %s, reopening socket", strerror(errno));
+				change_mode(listen_mode); /* just close and reopen */
+			}
+			if (len < 0) continue;
+
+			if (packet.xid != xid) {
+				DEBUG("Ignoring XID %lx (our xid is %lx)",
+					(unsigned long) packet.xid, xid);
+				continue;
+			}
+
+			/* Ignore packets that aren't for us */
+			if (memcmp(packet.chaddr, client_config.arp, 6)) {
+				DEBUG("Packet does not have our chaddr - ignoring");
+				continue;
+			}
+
+			if ((message = get_option(&packet, DHCP_MESSAGE_TYPE)) == NULL) {
+				bb_error_msg("cannot get option from packet - ignoring");
+				continue;
+			}
+
+			switch (state) {
+			case INIT_SELECTING:
+				/* Must be a DHCPOFFER to one of our xid's */
+				if (*message == DHCPOFFER) {
+					temp = get_option(&packet, DHCP_SERVER_ID);
+					if (temp) {
+						server_addr = *(uint32_t*)temp;
+						xid = packet.xid;
+						requested_ip = packet.yiaddr;
+
+						/* enter requesting state */
+						state = REQUESTING;
+						timeout = now;
+						packet_num = 0;
+					} else {
+						bb_error_msg("no server ID in message");
+					}
+				}
+				break;
+			case RENEW_REQUESTED:
+			case REQUESTING:
+			case RENEWING:
+			case REBINDING:
+				if (*message == DHCPACK) {
+					temp = get_option(&packet, DHCP_LEASE_TIME);
+					if (!temp) {
+						bb_error_msg("no lease time with ACK, using 1 hour lease");
+						lease = 60 * 60;
+					} else {
+						lease = ntohl(*(uint32_t*)temp);
+					}
+
+					/* enter bound state */
+					t1 = lease / 2;
+
+					/* little fixed point for n * .875 */
+					t2 = (lease * 0x7) >> 3;
+					temp_addr.s_addr = packet.yiaddr;
+					bb_info_msg("Lease of %s obtained, lease time %ld",
+						inet_ntoa(temp_addr), lease);
+					start = now;
+					timeout = t1 + start;
+					requested_ip = packet.yiaddr;
+					udhcp_run_script(&packet,
+						   ((state == RENEWING || state == REBINDING) ? "renew" : "bound"));
+
+					state = BOUND;
+					change_mode(LISTEN_NONE);
+					if (client_config.quit_after_lease) {
+						if (client_config.release_on_quit)
+							perform_release();
+						return 0;
+					}
+					if (!client_config.foreground)
+						client_background();
+
+				} else if (*message == DHCPNAK) {
+					/* return to init state */
+					bb_info_msg("Received DHCP NAK");
+					udhcp_run_script(&packet, "nak");
+					if (state != REQUESTING)
+						udhcp_run_script(NULL, "deconfig");
+					state = INIT_SELECTING;
+					timeout = now;
+					requested_ip = 0;
+					packet_num = 0;
+					change_mode(LISTEN_RAW);
+					sleep(3); /* avoid excessive network traffic */
+				}
+				break;
+			/* case BOUND, RELEASED: - ignore all packets */
+			}
+		} else if (retval > 0 && (sig = udhcp_sp_read(&rfds))) {
+			switch (sig) {
+			case SIGUSR1:
+				perform_renew();
+				break;
+			case SIGUSR2:
+				perform_release();
+				break;
+			case SIGTERM:
+				bb_info_msg("Received SIGTERM");
+				if (client_config.release_on_quit)
+					perform_release();
+				return 0;
+			}
+		} else if (retval == -1 && errno == EINTR) {
+			/* a signal was caught */
+		} else {
+			/* An error occured */
+			bb_perror_msg("select");
+		}
+
+	}
+	return 0;
+}
diff --git a/networking/udhcp/dhcpc.h b/networking/udhcp/dhcpc.h
new file mode 100644
index 0000000..fd17917
--- /dev/null
+++ b/networking/udhcp/dhcpc.h
@@ -0,0 +1,50 @@
+/* vi: set sw=4 ts=4: */
+/* dhcpc.h */
+#ifndef _DHCPC_H
+#define _DHCPC_H
+
+#define INIT_SELECTING	0
+#define REQUESTING	1
+#define BOUND		2
+#define RENEWING	3
+#define REBINDING	4
+#define INIT_REBOOT	5
+#define RENEW_REQUESTED 6
+#define RELEASED	7
+
+struct client_config_t {
+	/* TODO: combine flag fields into single "unsigned opt" */
+	/* (can be set directly to the result of getopt32) */
+	char foreground;                /* Do not fork */
+	char quit_after_lease;          /* Quit after obtaining lease */
+	char release_on_quit;           /* perform release on quit */
+	char abort_if_no_lease;         /* Abort if no lease */
+	char background_if_no_lease;    /* Fork to background if no lease */
+	char *interface;                /* The name of the interface to use */
+	char *pidfile;                  /* Optionally store the process ID */
+	char *script;                   /* User script to run at dhcp events */
+	uint8_t *clientid;              /* Optional client id to use */
+	uint8_t *vendorclass;           /* Optional vendor class-id to use */
+	uint8_t *hostname;              /* Optional hostname to use */
+	uint8_t *fqdn;                  /* Optional fully qualified domain name to use */
+	int ifindex;                    /* Index number of the interface to use */
+	int retries;                    /* Max number of request packets */
+	int timeout;                    /* Number of seconds to try to get a lease */
+	uint8_t arp[6];                 /* Our arp address */
+};
+
+extern struct client_config_t client_config;
+
+
+/*** clientpacket.h ***/
+
+unsigned long random_xid(void);
+int send_discover(unsigned long xid, unsigned long requested);
+int send_selecting(unsigned long xid, unsigned long server, unsigned long requested);
+int send_renew(unsigned long xid, unsigned long server, unsigned long ciaddr);
+int send_renew(unsigned long xid, unsigned long server, unsigned long ciaddr);
+int send_release(unsigned long server, unsigned long ciaddr);
+int get_raw_packet(struct dhcpMessage *payload, int fd);
+
+
+#endif
diff --git a/networking/udhcp/dhcpd.c b/networking/udhcp/dhcpd.c
new file mode 100644
index 0000000..7438036
--- /dev/null
+++ b/networking/udhcp/dhcpd.c
@@ -0,0 +1,226 @@
+/* vi: set sw=4 ts=4: */
+/* dhcpd.c
+ *
+ * udhcp Server
+ * Copyright (C) 1999 Matthew Ramsay <matthewr@moreton.com.au>
+ *			Chris Trew <ctrew@moreton.com.au>
+ *
+ * Rewrite by Russ Dill <Russ.Dill@asu.edu> July 2001
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ */
+
+#include "common.h"
+#include "dhcpd.h"
+#include "options.h"
+
+
+/* globals */
+struct dhcpOfferedAddr *leases;
+struct server_config_t server_config;
+
+
+int udhcpd_main(int argc, char *argv[])
+{
+	fd_set rfds;
+	struct timeval tv;
+	int server_socket = -1, bytes, retval, max_sock;
+	struct dhcpMessage packet;
+	uint8_t *state, *server_id, *requested;
+	uint32_t server_id_align, requested_align, static_lease_ip;
+	unsigned long timeout_end, num_ips;
+	struct option_set *option;
+	struct dhcpOfferedAddr *lease, static_lease;
+
+	read_config(argc < 2 ? DHCPD_CONF_FILE : argv[1]);
+
+	/* Start the log, sanitize fd's, and write a pid file */
+	udhcp_start_log_and_pid(server_config.pidfile);
+
+	if ((option = find_option(server_config.options, DHCP_LEASE_TIME))) {
+		memcpy(&server_config.lease, option->data + 2, 4);
+		server_config.lease = ntohl(server_config.lease);
+	}
+	else server_config.lease = LEASE_TIME;
+
+	/* Sanity check */
+	num_ips = ntohl(server_config.end) - ntohl(server_config.start) + 1;
+	if (server_config.max_leases > num_ips) {
+		bb_error_msg("max_leases value (%lu) not sane, "
+			"setting to %lu instead",
+			server_config.max_leases, num_ips);
+		server_config.max_leases = num_ips;
+	}
+
+	leases = xzalloc(server_config.max_leases * sizeof(struct dhcpOfferedAddr));
+	read_leases(server_config.lease_file);
+
+	if (read_interface(server_config.interface, &server_config.ifindex,
+			   &server_config.server, server_config.arp) < 0)
+		return 1;
+
+	if (!ENABLE_FEATURE_UDHCP_DEBUG)
+		udhcp_background(server_config.pidfile); /* hold lock during fork. */
+
+	/* Setup the signal pipe */
+	udhcp_sp_setup();
+
+	timeout_end = time(0) + server_config.auto_time;
+	while (1) { /* loop until universe collapses */
+
+		if (server_socket < 0) {
+			server_socket = listen_socket(INADDR_ANY, SERVER_PORT, server_config.interface);
+			if (server_socket < 0) {
+				bb_perror_msg("FATAL: cannot create server socket");
+				return 2;
+			}
+		}
+
+		max_sock = udhcp_sp_fd_set(&rfds, server_socket);
+		if (server_config.auto_time) {
+			tv.tv_sec = timeout_end - time(0);
+			tv.tv_usec = 0;
+		}
+		if (!server_config.auto_time || tv.tv_sec > 0) {
+			retval = select(max_sock + 1, &rfds, NULL, NULL,
+					server_config.auto_time ? &tv : NULL);
+		} else retval = 0; /* If we already timed out, fall through */
+
+		if (retval == 0) {
+			write_leases();
+			timeout_end = time(0) + server_config.auto_time;
+			continue;
+		} else if (retval < 0 && errno != EINTR) {
+			DEBUG("error on select");
+			continue;
+		}
+
+		switch (udhcp_sp_read(&rfds)) {
+		case SIGUSR1:
+			bb_info_msg("Received a SIGUSR1");
+			write_leases();
+			/* why not just reset the timeout, eh */
+			timeout_end = time(0) + server_config.auto_time;
+			continue;
+		case SIGTERM:
+			bb_info_msg("Received a SIGTERM");
+			return 0;
+		case 0: break;		/* no signal */
+		default: continue;	/* signal or error (probably EINTR) */
+		}
+
+		if ((bytes = udhcp_get_packet(&packet, server_socket)) < 0) { /* this waits for a packet - idle */
+			if (bytes == -1 && errno != EINTR) {
+				DEBUG("error on read, %s, reopening socket", strerror(errno));
+				close(server_socket);
+				server_socket = -1;
+			}
+			continue;
+		}
+
+		if ((state = get_option(&packet, DHCP_MESSAGE_TYPE)) == NULL) {
+			bb_error_msg("cannot get option from packet, ignoring");
+			continue;
+		}
+
+		/* Look for a static lease */
+		static_lease_ip = getIpByMac(server_config.static_leases, &packet.chaddr);
+
+		if (static_lease_ip) {
+			bb_info_msg("Found static lease: %x", static_lease_ip);
+
+			memcpy(&static_lease.chaddr, &packet.chaddr, 16);
+			static_lease.yiaddr = static_lease_ip;
+			static_lease.expires = 0;
+
+			lease = &static_lease;
+
+		} else {
+			lease = find_lease_by_chaddr(packet.chaddr);
+		}
+
+		switch (state[0]) {
+		case DHCPDISCOVER:
+			DEBUG("Received DISCOVER");
+
+			if (sendOffer(&packet) < 0) {
+				bb_error_msg("send OFFER failed");
+			}
+			break;
+		case DHCPREQUEST:
+			DEBUG("received REQUEST");
+
+			requested = get_option(&packet, DHCP_REQUESTED_IP);
+			server_id = get_option(&packet, DHCP_SERVER_ID);
+
+			if (requested) memcpy(&requested_align, requested, 4);
+			if (server_id) memcpy(&server_id_align, server_id, 4);
+
+			if (lease) {
+				if (server_id) {
+					/* SELECTING State */
+					DEBUG("server_id = %08x", ntohl(server_id_align));
+					if (server_id_align == server_config.server && requested &&
+					    requested_align == lease->yiaddr) {
+						sendACK(&packet, lease->yiaddr);
+					}
+				} else {
+					if (requested) {
+						/* INIT-REBOOT State */
+						if (lease->yiaddr == requested_align)
+							sendACK(&packet, lease->yiaddr);
+						else sendNAK(&packet);
+					} else {
+						/* RENEWING or REBINDING State */
+						if (lease->yiaddr == packet.ciaddr)
+							sendACK(&packet, lease->yiaddr);
+						else {
+							/* don't know what to do!!!! */
+							sendNAK(&packet);
+						}
+					}
+				}
+
+			/* what to do if we have no record of the client */
+			} else if (server_id) {
+				/* SELECTING State */
+
+			} else if (requested) {
+				/* INIT-REBOOT State */
+				if ((lease = find_lease_by_yiaddr(requested_align))) {
+					if (lease_expired(lease)) {
+						/* probably best if we drop this lease */
+						memset(lease->chaddr, 0, 16);
+					/* make some contention for this address */
+					} else sendNAK(&packet);
+				} else if (requested_align < server_config.start ||
+					   requested_align > server_config.end) {
+					sendNAK(&packet);
+				} /* else remain silent */
+
+			} else {
+				 /* RENEWING or REBINDING State */
+			}
+			break;
+		case DHCPDECLINE:
+			DEBUG("Received DECLINE");
+			if (lease) {
+				memset(lease->chaddr, 0, 16);
+				lease->expires = time(0) + server_config.decline_time;
+			}
+			break;
+		case DHCPRELEASE:
+			DEBUG("Received RELEASE");
+			if (lease) lease->expires = time(0);
+			break;
+		case DHCPINFORM:
+			DEBUG("Received INFORM");
+			send_inform(&packet);
+			break;
+		default:
+			bb_info_msg("Unsupported DHCP message (%02x) - ignoring", state[0]);
+		}
+	}
+
+	return 0;
+}
diff --git a/networking/udhcp/dhcpd.h b/networking/udhcp/dhcpd.h
new file mode 100644
index 0000000..40959e4
--- /dev/null
+++ b/networking/udhcp/dhcpd.h
@@ -0,0 +1,190 @@
+/* vi: set sw=4 ts=4: */
+/* dhcpd.h */
+#ifndef _DHCPD_H
+#define _DHCPD_H
+
+/************************************/
+/* Defaults _you_ may want to tweak */
+/************************************/
+
+/* the period of time the client is allowed to use that address */
+#define LEASE_TIME              (60*60*24*10) /* 10 days of seconds */
+#define LEASES_FILE		"/var/lib/misc/udhcpd.leases"
+
+/* where to find the DHCP server configuration file */
+#define DHCPD_CONF_FILE         "/etc/udhcpd.conf"
+
+/*****************************************************************/
+/* Do not modify below here unless you know what you are doing!! */
+/*****************************************************************/
+
+/* DHCP protocol -- see RFC 2131 */
+#define SERVER_PORT		67
+#define CLIENT_PORT		68
+
+#define DHCP_MAGIC		0x63825363
+
+/* DHCP option codes (partial list) */
+#define DHCP_PADDING		0x00
+#define DHCP_SUBNET		0x01
+#define DHCP_TIME_OFFSET	0x02
+#define DHCP_ROUTER		0x03
+#define DHCP_TIME_SERVER	0x04
+#define DHCP_NAME_SERVER	0x05
+#define DHCP_DNS_SERVER		0x06
+#define DHCP_LOG_SERVER		0x07
+#define DHCP_COOKIE_SERVER	0x08
+#define DHCP_LPR_SERVER		0x09
+#define DHCP_HOST_NAME		0x0c
+#define DHCP_BOOT_SIZE		0x0d
+#define DHCP_DOMAIN_NAME	0x0f
+#define DHCP_SWAP_SERVER	0x10
+#define DHCP_ROOT_PATH		0x11
+#define DHCP_IP_TTL		0x17
+#define DHCP_MTU		0x1a
+#define DHCP_BROADCAST		0x1c
+#define DHCP_NTP_SERVER		0x2a
+#define DHCP_WINS_SERVER	0x2c
+#define DHCP_REQUESTED_IP	0x32
+#define DHCP_LEASE_TIME		0x33
+#define DHCP_OPTION_OVER	0x34
+#define DHCP_MESSAGE_TYPE	0x35
+#define DHCP_SERVER_ID		0x36
+#define DHCP_PARAM_REQ		0x37
+#define DHCP_MESSAGE		0x38
+#define DHCP_MAX_SIZE		0x39
+#define DHCP_T1			0x3a
+#define DHCP_T2			0x3b
+#define DHCP_VENDOR		0x3c
+#define DHCP_CLIENT_ID		0x3d
+#define DHCP_FQDN		0x51
+
+#define DHCP_END		0xFF
+
+
+#define BOOTREQUEST		1
+#define BOOTREPLY		2
+
+#define ETH_10MB		1
+#define ETH_10MB_LEN		6
+
+#define DHCPDISCOVER		1
+#define DHCPOFFER		2
+#define DHCPREQUEST		3
+#define DHCPDECLINE		4
+#define DHCPACK			5
+#define DHCPNAK			6
+#define DHCPRELEASE		7
+#define DHCPINFORM		8
+
+#define BROADCAST_FLAG		0x8000
+
+#define OPTION_FIELD		0
+#define FILE_FIELD		1
+#define SNAME_FIELD		2
+
+/* miscellaneous defines */
+#define MAC_BCAST_ADDR		(uint8_t *) "\xff\xff\xff\xff\xff\xff"
+#define OPT_CODE 0
+#define OPT_LEN 1
+#define OPT_DATA 2
+
+struct option_set {
+	uint8_t *data;
+	struct option_set *next;
+};
+
+struct static_lease {
+	uint8_t *mac;
+	uint32_t *ip;
+	struct static_lease *next;
+};
+
+struct server_config_t {
+	uint32_t server;		/* Our IP, in network order */
+	uint32_t start;			/* Start address of leases, network order */
+	uint32_t end;			/* End of leases, network order */
+	struct option_set *options;	/* List of DHCP options loaded from the config file */
+	char *interface;		/* The name of the interface to use */
+	int ifindex;			/* Index number of the interface to use */
+	uint8_t arp[6];			/* Our arp address */
+	unsigned long lease;		/* lease time in seconds (host order) */
+	unsigned long max_leases;	/* maximum number of leases (including reserved address) */
+	char remaining;			/* should the lease file be interpreted as lease time remaining, or
+					 * as the time the lease expires */
+	unsigned long auto_time;	/* how long should udhcpd wait before writing a config file.
+					 * if this is zero, it will only write one on SIGUSR1 */
+	unsigned long decline_time;	/* how long an address is reserved if a client returns a
+					 * decline message */
+	unsigned long conflict_time;	/* how long an arp conflict offender is leased for */
+	unsigned long offer_time;	/* how long an offered address is reserved */
+	unsigned long min_lease;	/* minimum lease a client can request*/
+	char *lease_file;
+	char *pidfile;
+	char *notify_file;		/* What to run whenever leases are written */
+	uint32_t siaddr;		/* next server bootp option */
+	char *sname;			/* bootp server name */
+	char *boot_file;		/* bootp boot file option */
+	struct static_lease *static_leases; /* List of ip/mac pairs to assign static leases */
+};
+
+extern struct server_config_t server_config;
+extern struct dhcpOfferedAddr *leases;
+
+
+/*** leases.h ***/
+
+struct dhcpOfferedAddr {
+	uint8_t chaddr[16];
+	uint32_t yiaddr;	/* network order */
+	uint32_t expires;	/* host order */
+};
+
+extern uint8_t blank_chaddr[];
+
+void clear_lease(uint8_t *chaddr, uint32_t yiaddr);
+struct dhcpOfferedAddr *add_lease(uint8_t *chaddr, uint32_t yiaddr, unsigned long lease);
+int lease_expired(struct dhcpOfferedAddr *lease);
+struct dhcpOfferedAddr *oldest_expired_lease(void);
+struct dhcpOfferedAddr *find_lease_by_chaddr(uint8_t *chaddr);
+struct dhcpOfferedAddr *find_lease_by_yiaddr(uint32_t yiaddr);
+uint32_t find_address(int check_expired);
+
+
+/*** static_leases.h ***/
+
+/* Config file will pass static lease info to this function which will add it
+ * to a data structure that can be searched later */
+int addStaticLease(struct static_lease **lease_struct, uint8_t *mac, uint32_t *ip);
+/* Check to see if a mac has an associated static lease */
+uint32_t getIpByMac(struct static_lease *lease_struct, void *arg);
+/* Check to see if an ip is reserved as a static ip */
+uint32_t reservedIp(struct static_lease *lease_struct, uint32_t ip);
+/* Print out static leases just to check what's going on (debug code) */
+void printStaticLeases(struct static_lease **lease_struct);
+
+
+/*** serverpacket.h ***/
+
+int sendOffer(struct dhcpMessage *oldpacket);
+int sendNAK(struct dhcpMessage *oldpacket);
+int sendACK(struct dhcpMessage *oldpacket, uint32_t yiaddr);
+int send_inform(struct dhcpMessage *oldpacket);
+
+
+/*** files.h ***/
+
+struct config_keyword {
+	const char *keyword;
+	int (* const handler)(const char *line, void *var);
+	void *var;
+	const char *def;
+};
+
+int read_config(const char *file);
+void write_leases(void);
+void read_leases(const char *file);
+struct option_set *find_option(struct option_set *opt_list, char code);
+
+
+#endif
diff --git a/networking/udhcp/dhcprelay.c b/networking/udhcp/dhcprelay.c
new file mode 100644
index 0000000..e3a8168
--- /dev/null
+++ b/networking/udhcp/dhcprelay.c
@@ -0,0 +1,340 @@
+/* vi: set sw=4 ts=4: */
+/* Port to Busybox Copyright (C) 2006 Jesse Dutton <jessedutton@gmail.com>
+ *
+ * Licensed under GPL v2, see file LICENSE in this tarball for details.
+ *
+ * DHCP Relay for 'DHCPv4 Configuration of IPSec Tunnel Mode' support
+ * Copyright (C) 2002 Mario Strasser <mast@gmx.net>,
+ *                   Zuercher Hochschule Winterthur,
+ *                   Netbeat AG
+ * Upstream has GPL v2 or later
+ */
+
+#include "common.h"
+#include "dhcpd.h"
+#include "options.h"
+
+/* constants */
+#define SELECT_TIMEOUT 5 /* select timeout in sec. */
+#define MAX_LIFETIME 2*60 /* lifetime of an xid entry in sec. */
+#define MAX_INTERFACES 9
+
+
+/* This list holds information about clients. The xid_* functions manipulate this list. */
+static struct xid_item {
+	u_int32_t xid;
+	struct sockaddr_in ip;
+	int client;
+	time_t timestamp;
+	struct xid_item *next;
+} dhcprelay_xid_list = {0, {0}, 0, 0, NULL};
+
+
+static struct xid_item * xid_add(u_int32_t xid, struct sockaddr_in *ip, int client)
+{
+	struct xid_item *item;
+
+	/* create new xid entry */
+	item = xmalloc(sizeof(struct xid_item));
+
+	/* add xid entry */
+	item->ip = *ip;
+	item->xid = xid;
+	item->client = client;
+	item->timestamp = time(NULL);
+	item->next = dhcprelay_xid_list.next;
+	dhcprelay_xid_list.next = item;
+
+	return item;
+}
+
+
+static void xid_expire(void)
+{
+	struct xid_item *item = dhcprelay_xid_list.next;
+	struct xid_item *last = &dhcprelay_xid_list;
+	time_t current_time = time(NULL);
+
+	while (item != NULL) {
+		if ((current_time-item->timestamp) > MAX_LIFETIME) {
+			last->next = item->next;
+			free(item);
+			item = last->next;
+		} else {
+			last = item;
+			item = item->next;
+		}
+	}
+}
+
+static struct xid_item * xid_find(u_int32_t xid)
+{
+	struct xid_item *item = dhcprelay_xid_list.next;
+	while (item != NULL) {
+		if (item->xid == xid) {
+			return item;
+		}
+		item = item->next;
+	}
+	return NULL;
+}
+
+static void xid_del(u_int32_t xid)
+{
+	struct xid_item *item = dhcprelay_xid_list.next;
+	struct xid_item *last = &dhcprelay_xid_list;
+	while (item != NULL) {
+		if (item->xid == xid) {
+			last->next = item->next;
+			free(item);
+			item = last->next;
+		} else {
+			last = item;
+			item = item->next;
+		}
+	}
+}
+
+
+/**
+ * get_dhcp_packet_type - gets the message type of a dhcp packet
+ * p - pointer to the dhcp packet
+ * returns the message type on success, -1 otherwise
+ */
+static int get_dhcp_packet_type(struct dhcpMessage *p)
+{
+	u_char *op;
+
+	/* it must be either a BOOTREQUEST or a BOOTREPLY */
+	if (p->op != BOOTREQUEST && p->op != BOOTREPLY)
+		return -1;
+	/* get message type option */
+	op = get_option(p, DHCP_MESSAGE_TYPE);
+	if (op != NULL)
+		return op[0];
+	return -1;
+}
+
+/**
+ * signal_handler - handles signals ;-)
+ * sig - sent signal
+ */
+static int dhcprelay_stopflag;
+static void dhcprelay_signal_handler(int sig)
+{
+	dhcprelay_stopflag = 1;
+}
+
+/**
+ * get_client_devices - parses the devices list
+ * dev_list - comma separated list of devices
+ * returns array
+ */
+static char ** get_client_devices(char *dev_list, int *client_number)
+{
+	char *s, *list, **client_dev;
+	int i, cn;
+
+	/* copy list */
+	list = xstrdup(dev_list);
+	if (list == NULL) return NULL;
+
+	/* get number of items */
+	for (s = dev_list, cn = 1; *s; s++)
+		if (*s == ',')
+			cn++;
+
+	client_dev = xzalloc(cn * sizeof(*client_dev));
+
+	/* parse list */
+	s = strtok(list, ",");
+	i = 0;
+	while (s != NULL) {
+		client_dev[i++] = xstrdup(s);
+		s = strtok(NULL, ",");
+	}
+
+	/* free copy and exit */
+	free(list);
+	*client_number = cn;
+	return client_dev;
+}
+
+
+/* Creates listen sockets (in fds) and returns the number allocated. */
+static int init_sockets(char **client, int num_clients,
+			char *server, int *fds, int *max_socket)
+{
+	int i;
+
+	/* talk to real server on bootps */
+	fds[0] = listen_socket(htonl(INADDR_ANY), 67, server);
+	if (fds[0] < 0) return -1;
+	*max_socket = fds[0];
+
+	/* array starts at 1 since server is 0 */
+	num_clients++;
+
+	for (i=1; i < num_clients; i++) {
+		/* listen for clients on bootps */
+		fds[i] = listen_socket(htonl(INADDR_ANY), 67, client[i-1]);
+		if (fds[i] < 0) return -1;
+		if (fds[i] > *max_socket) *max_socket = fds[i];
+	}
+
+	return i;
+}
+
+
+/**
+ * pass_on() - forwards dhcp packets from client to server
+ * p - packet to send
+ * client - number of the client
+ */
+static void pass_on(struct dhcpMessage *p, int packet_len, int client, int *fds,
+			struct sockaddr_in *client_addr, struct sockaddr_in *server_addr)
+{
+	int res, type;
+	struct xid_item *item;
+
+	/* check packet_type */
+	type = get_dhcp_packet_type(p);
+	if (type != DHCPDISCOVER && type != DHCPREQUEST
+	 && type != DHCPDECLINE && type != DHCPRELEASE
+	 && type != DHCPINFORM
+	) {
+		return;
+	}
+
+	/* create new xid entry */
+	item = xid_add(p->xid, client_addr, client);
+
+	/* forward request to LAN (server) */
+	res = sendto(fds[0], p, packet_len, 0, (struct sockaddr*)server_addr,
+			sizeof(struct sockaddr_in));
+	if (res != packet_len) {
+		bb_perror_msg("pass_on");
+		return;
+	}
+}
+
+/**
+ * pass_back() - forwards dhcp packets from server to client
+ * p - packet to send
+ */
+static void pass_back(struct dhcpMessage *p, int packet_len, int *fds)
+{
+	int res, type;
+	struct xid_item *item;
+
+	/* check xid */
+	item = xid_find(p->xid);
+	if (!item) {
+		return;
+	}
+
+	/* check packet type */
+	type = get_dhcp_packet_type(p);
+	if (type != DHCPOFFER && type != DHCPACK && type != DHCPNAK) {
+		return;
+	}
+
+	if (item->ip.sin_addr.s_addr == htonl(INADDR_ANY))
+		item->ip.sin_addr.s_addr = htonl(INADDR_BROADCAST);
+	if (item->client > MAX_INTERFACES)
+		return;
+	res = sendto(fds[item->client], p, packet_len, 0, (struct sockaddr*)(&item->ip),
+				sizeof(item->ip));
+	if (res != packet_len) {
+		bb_perror_msg("pass_back");
+		return;
+	}
+
+	/* remove xid entry */
+	xid_del(p->xid);
+}
+
+static void dhcprelay_loop(int *fds, int num_sockets, int max_socket, char **clients,
+		struct sockaddr_in *server_addr, uint32_t gw_ip)
+{
+	struct dhcpMessage dhcp_msg;
+	fd_set rfds;
+	size_t packlen, addr_size;
+	struct sockaddr_in client_addr;
+	struct timeval tv;
+	int i;
+
+	while (!dhcprelay_stopflag) {
+		FD_ZERO(&rfds);
+		for (i = 0; i < num_sockets; i++)
+			FD_SET(fds[i], &rfds);
+		tv.tv_sec = SELECT_TIMEOUT;
+		tv.tv_usec = 0;
+		if (select(max_socket + 1, &rfds, NULL, NULL, &tv) > 0) {
+			/* server */
+			if (FD_ISSET(fds[0], &rfds)) {
+				packlen = udhcp_get_packet(&dhcp_msg, fds[0]);
+				if (packlen > 0) {
+					pass_back(&dhcp_msg, packlen, fds);
+				}
+			}
+			for (i = 1; i < num_sockets; i++) {
+				/* clients */
+				if (!FD_ISSET(fds[i], &rfds))
+					continue;
+				addr_size = sizeof(struct sockaddr_in);
+				packlen = recvfrom(fds[i], &dhcp_msg, sizeof(dhcp_msg), 0,
+							(struct sockaddr *)(&client_addr), &addr_size);
+				if (packlen <= 0)
+					continue;
+				if (read_interface(clients[i-1], NULL, &dhcp_msg.giaddr, NULL) < 0)
+					dhcp_msg.giaddr = gw_ip;
+				pass_on(&dhcp_msg, packlen, i, fds, &client_addr, server_addr);
+			}
+		}
+		xid_expire();
+	}
+}
+
+int dhcprelay_main(int argc, char **argv)
+{
+	int i, num_sockets, max_socket, fds[MAX_INTERFACES];
+	uint32_t gw_ip;
+	char **clients;
+	struct sockaddr_in server_addr;
+
+	server_addr.sin_family = AF_INET;
+	server_addr.sin_port = htons(67);
+	if (argc == 4) {
+		if (!inet_aton(argv[3], &server_addr.sin_addr))
+			bb_perror_msg_and_die("didn't grok server");
+	} else if (argc == 3) {
+		server_addr.sin_addr.s_addr = htonl(INADDR_BROADCAST);
+	} else {
+		bb_show_usage();
+	}
+	clients = get_client_devices(argv[1], &num_sockets);
+	if (!clients) return 0;
+
+	signal(SIGTERM, dhcprelay_signal_handler);
+	signal(SIGQUIT, dhcprelay_signal_handler);
+	signal(SIGINT, dhcprelay_signal_handler);
+
+	num_sockets = init_sockets(clients, num_sockets, argv[2], fds, &max_socket);
+	if (num_sockets == -1)
+		bb_perror_msg_and_die("init_sockets() failed");
+
+	if (read_interface(argv[2], NULL, &gw_ip, NULL) == -1)
+		return 1;
+
+	dhcprelay_loop(fds, num_sockets, max_socket, clients, &server_addr, gw_ip);
+
+	if (ENABLE_FEATURE_CLEAN_UP) {
+		for (i = 0; i < num_sockets; i++) {
+			close(fds[i]);
+			free(clients[i]);
+		}
+	}
+
+	return 0;
+}
diff --git a/networking/udhcp/dumpleases.c b/networking/udhcp/dumpleases.c
new file mode 100644
index 0000000..a0e81bb
--- /dev/null
+++ b/networking/udhcp/dumpleases.c
@@ -0,0 +1,74 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+ */
+#include <getopt.h>
+
+#include "common.h"
+#include "dhcpd.h"
+
+
+#define REMAINING 0
+#define ABSOLUTE 1
+
+int dumpleases_main(int argc, char *argv[])
+{
+	int fp;
+	int i, c, mode = REMAINING;
+	unsigned long expires;
+	const char *file = LEASES_FILE;
+	struct dhcpOfferedAddr lease;
+	struct in_addr addr;
+
+	static const struct option options[] = {
+		{"absolute", 0, 0, 'a'},
+		{"remaining", 0, 0, 'r'},
+		{"file", 1, 0, 'f'},
+		{0, 0, 0, 0}
+	};
+
+	while (1) {
+		int option_index = 0;
+		c = getopt_long(argc, argv, "arf:", options, &option_index);
+		if (c == -1) break;
+
+		switch (c) {
+		case 'a': mode = ABSOLUTE; break;
+		case 'r': mode = REMAINING; break;
+		case 'f':
+			file = optarg;
+			break;
+		default:
+			bb_show_usage();
+		}
+	}
+
+	fp = xopen(file, O_RDONLY);
+
+	printf("Mac Address       IP-Address      Expires %s\n", mode == REMAINING ? "in" : "at");
+	/*     "00:00:00:00:00:00 255.255.255.255 Wed Jun 30 21:49:08 1993" */
+	while (full_read(fp, &lease, sizeof(lease)) == sizeof(lease)) {
+		printf(":%02x"+1, lease.chaddr[0]);
+		for (i = 1; i < 6; i++) {
+			printf(":%02x", lease.chaddr[i]);
+		}
+		addr.s_addr = lease.yiaddr;
+		printf(" %-15s ", inet_ntoa(addr));
+		expires = ntohl(lease.expires);
+		if (mode == REMAINING) {
+			if (!expires)
+				printf("expired\n");
+			else {
+				unsigned d, h, m;
+				d = expires / (24*60*60); expires %= (24*60*60);
+				h = expires / (60*60); expires %= (60*60);
+				m = expires / 60; expires %= 60;
+				if (d) printf("%u days ", d);
+				printf("%02u:%02u:%02u\n", h, m, (unsigned)expires);
+			}
+		} else fputs(ctime(&expires), stdout);
+	}
+	/* close(fp); */
+
+	return 0;
+}
diff --git a/networking/udhcp/files.c b/networking/udhcp/files.c
new file mode 100644
index 0000000..5e399e1
--- /dev/null
+++ b/networking/udhcp/files.c
@@ -0,0 +1,395 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * files.c -- DHCP server file manipulation *
+ * Rewrite by Russ Dill <Russ.Dill@asu.edu> July 2001
+ */
+
+#include <netinet/ether.h>
+
+#include "common.h"
+#include "dhcpd.h"
+#include "options.h"
+
+
+/*
+ * Domain names may have 254 chars, and string options can be 254
+ * chars long. However, 80 bytes will be enough for most, and won't
+ * hog up memory. If you have a special application, change it
+ */
+#define READ_CONFIG_BUF_SIZE 80
+
+/* on these functions, make sure you datatype matches */
+static int read_ip(const char *line, void *arg)
+{
+	struct in_addr *addr = arg;
+	struct hostent *host;
+	int retval = 1;
+
+	if (!inet_aton(line, addr)) {
+		host = gethostbyname(line);
+		if (host)
+			addr->s_addr = *((unsigned long *) host->h_addr_list[0]);
+		else retval = 0;
+	}
+	return retval;
+}
+
+static int read_mac(const char *line, void *arg)
+{
+	uint8_t *mac_bytes = arg;
+	struct ether_addr *temp_ether_addr;
+	int retval = 1;
+
+	temp_ether_addr = ether_aton(line);
+
+	if (temp_ether_addr == NULL)
+		retval = 0;
+	else
+		memcpy(mac_bytes, temp_ether_addr, 6);
+
+	return retval;
+}
+
+
+static int read_str(const char *line, void *arg)
+{
+	char **dest = arg;
+
+	free(*dest);
+	*dest = strdup(line);
+
+	return 1;
+}
+
+
+static int read_u32(const char *line, void *arg)
+{
+	*((uint32_t*)arg) = bb_strtou32(line, NULL, 10);
+	return errno == 0;
+}
+
+
+static int read_yn(const char *line, void *arg)
+{
+	char *dest = arg;
+	int retval = 1;
+
+	if (!strcasecmp("yes", line))
+		*dest = 1;
+	else if (!strcasecmp("no", line))
+		*dest = 0;
+	else retval = 0;
+
+	return retval;
+}
+
+
+/* find option 'code' in opt_list */
+struct option_set *find_option(struct option_set *opt_list, char code)
+{
+	while (opt_list && opt_list->data[OPT_CODE] < code)
+		opt_list = opt_list->next;
+
+	if (opt_list && opt_list->data[OPT_CODE] == code) return opt_list;
+	else return NULL;
+}
+
+
+/* add an option to the opt_list */
+static void attach_option(struct option_set **opt_list,
+		const struct dhcp_option *option, char *buffer, int length)
+{
+	struct option_set *existing, *new, **curr;
+
+	/* add it to an existing option */
+	existing = find_option(*opt_list, option->code);
+	if (existing) {
+		DEBUG("Attaching option %s to existing member of list", option->name);
+		if (option->flags & OPTION_LIST) {
+			if (existing->data[OPT_LEN] + length <= 255) {
+				existing->data = realloc(existing->data,
+						existing->data[OPT_LEN] + length + 2);
+				memcpy(existing->data + existing->data[OPT_LEN] + 2, buffer, length);
+				existing->data[OPT_LEN] += length;
+			} /* else, ignore the data, we could put this in a second option in the future */
+		} /* else, ignore the new data */
+	} else {
+		DEBUG("Attaching option %s to list", option->name);
+
+		/* make a new option */
+		new = xmalloc(sizeof(struct option_set));
+		new->data = xmalloc(length + 2);
+		new->data[OPT_CODE] = option->code;
+		new->data[OPT_LEN] = length;
+		memcpy(new->data + 2, buffer, length);
+
+		curr = opt_list;
+		while (*curr && (*curr)->data[OPT_CODE] < option->code)
+			curr = &(*curr)->next;
+
+		new->next = *curr;
+		*curr = new;
+	}
+}
+
+
+/* read a dhcp option and add it to opt_list */
+static int read_opt(const char *const_line, void *arg)
+{
+	struct option_set **opt_list = arg;
+	char *opt, *val, *endptr;
+	const struct dhcp_option *option;
+	int retval = 0, length;
+	char buffer[8];
+	char *line;
+	uint16_t *result_u16 = (uint16_t *) buffer;
+	uint32_t *result_u32 = (uint32_t *) buffer;
+
+	/* Cheat, the only const line we'll actually get is "" */
+	line = (char *) const_line;
+	opt = strtok(line, " \t=");
+	if (!opt) return 0;
+
+	option = dhcp_options;
+	while (1) {
+		if (!option->code)
+			return 0;
+		if (!strcasecmp(option->name, opt))
+			break;
+		 option++;
+	}
+
+	do {
+		val = strtok(NULL, ", \t");
+		if (!val) break;
+		length = option_lengths[option->flags & TYPE_MASK];
+		retval = 0;
+		opt = buffer; /* new meaning for variable opt */
+		switch (option->flags & TYPE_MASK) {
+		case OPTION_IP:
+			retval = read_ip(val, buffer);
+			break;
+		case OPTION_IP_PAIR:
+			retval = read_ip(val, buffer);
+			if (!(val = strtok(NULL, ", \t/-"))) retval = 0;
+			if (retval) retval = read_ip(val, buffer + 4);
+			break;
+		case OPTION_STRING:
+			length = strlen(val);
+			if (length > 0) {
+				if (length > 254) length = 254;
+				opt = val;
+				retval = 1;
+			}
+			break;
+		case OPTION_BOOLEAN:
+			retval = read_yn(val, buffer);
+			break;
+		case OPTION_U8:
+			buffer[0] = strtoul(val, &endptr, 0);
+			retval = (endptr[0] == '\0');
+			break;
+		case OPTION_U16:
+			*result_u16 = htons(strtoul(val, &endptr, 0));
+			retval = (endptr[0] == '\0');
+			break;
+		case OPTION_S16:
+			*result_u16 = htons(strtol(val, &endptr, 0));
+			retval = (endptr[0] == '\0');
+			break;
+		case OPTION_U32:
+			*result_u32 = htonl(strtoul(val, &endptr, 0));
+			retval = (endptr[0] == '\0');
+			break;
+		case OPTION_S32:
+			*result_u32 = htonl(strtol(val, &endptr, 0));
+			retval = (endptr[0] == '\0');
+			break;
+		default:
+			break;
+		}
+		if (retval)
+			attach_option(opt_list, option, opt, length);
+	} while (retval && option->flags & OPTION_LIST);
+	return retval;
+}
+
+static int read_staticlease(const char *const_line, void *arg)
+{
+	char *line;
+	char *mac_string;
+	char *ip_string;
+	uint8_t *mac_bytes;
+	uint32_t *ip;
+
+
+	/* Allocate memory for addresses */
+	mac_bytes = xmalloc(sizeof(unsigned char) * 8);
+	ip = xmalloc(sizeof(uint32_t));
+
+	/* Read mac */
+	line = (char *) const_line;
+	mac_string = strtok(line, " \t");
+	read_mac(mac_string, mac_bytes);
+
+	/* Read ip */
+	ip_string = strtok(NULL, " \t");
+	read_ip(ip_string, ip);
+
+	addStaticLease(arg, mac_bytes, ip);
+
+	if (ENABLE_FEATURE_UDHCP_DEBUG) printStaticLeases(arg);
+
+	return 1;
+}
+
+
+static const struct config_keyword keywords[] = {
+	/* keyword	handler   variable address		default */
+	{"start",	read_ip,  &(server_config.start),	"192.168.0.20"},
+	{"end",		read_ip,  &(server_config.end),		"192.168.0.254"},
+	{"interface",	read_str, &(server_config.interface),	"eth0"},
+	{"option",	read_opt, &(server_config.options),	""},
+	{"opt",		read_opt, &(server_config.options),	""},
+	{"max_leases",	read_u32, &(server_config.max_leases),	"254"},
+	{"remaining",	read_yn,  &(server_config.remaining),	"yes"},
+	{"auto_time",	read_u32, &(server_config.auto_time),	"7200"},
+	{"decline_time",read_u32, &(server_config.decline_time),"3600"},
+	{"conflict_time",read_u32,&(server_config.conflict_time),"3600"},
+	{"offer_time",	read_u32, &(server_config.offer_time),	"60"},
+	{"min_lease",	read_u32, &(server_config.min_lease),	"60"},
+	{"lease_file",	read_str, &(server_config.lease_file),	LEASES_FILE},
+	{"pidfile",	read_str, &(server_config.pidfile),	"/var/run/udhcpd.pid"},
+	{"notify_file", read_str, &(server_config.notify_file),	""},
+	{"siaddr",	read_ip,  &(server_config.siaddr),	"0.0.0.0"},
+	{"sname",	read_str, &(server_config.sname),	""},
+	{"boot_file",	read_str, &(server_config.boot_file),	""},
+	{"static_lease",read_staticlease, &(server_config.static_leases),	""},
+	/*ADDME: static lease */
+	{"",		NULL,	  NULL,				""}
+};
+
+
+int read_config(const char *file)
+{
+	FILE *in;
+	char buffer[READ_CONFIG_BUF_SIZE], *token, *line;
+	int i, lm = 0;
+
+	for (i = 0; keywords[i].keyword[0]; i++)
+		if (keywords[i].def[0])
+			keywords[i].handler(keywords[i].def, keywords[i].var);
+
+	in = fopen(file, "r");
+	if (!in) {
+		bb_error_msg("cannot open config file: %s", file);
+		return 0;
+	}
+
+	while (fgets(buffer, READ_CONFIG_BUF_SIZE, in)) {
+		char debug_orig[READ_CONFIG_BUF_SIZE];
+		char *p;
+
+		lm++;
+		p = strchr(buffer, '\n');
+		if (p) *p = '\0';
+		if (ENABLE_FEATURE_UDHCP_DEBUG) strcpy(debug_orig, buffer);
+		p = strchr(buffer, '#');
+		if (p) *p = '\0';
+
+		if (!(token = strtok(buffer, " \t"))) continue;
+		if (!(line = strtok(NULL, ""))) continue;
+
+		/* eat leading whitespace */
+		line = skip_whitespace(line);
+		/* eat trailing whitespace */
+		i = strlen(line) - 1;
+		while (i >= 0 && isspace(line[i]))
+			line[i--] = '\0';
+
+		for (i = 0; keywords[i].keyword[0]; i++)
+			if (!strcasecmp(token, keywords[i].keyword))
+				if (!keywords[i].handler(line, keywords[i].var)) {
+					bb_error_msg("cannot parse line %d of %s", lm, file);
+					if (ENABLE_FEATURE_UDHCP_DEBUG)
+						bb_error_msg("cannot parse '%s'", debug_orig);
+					/* reset back to the default value */
+					keywords[i].handler(keywords[i].def, keywords[i].var);
+				}
+	}
+	fclose(in);
+	return 1;
+}
+
+
+void write_leases(void)
+{
+	int fp;
+	unsigned i;
+	time_t curr = time(0);
+	unsigned long tmp_time;
+
+	fp = open(server_config.lease_file, O_WRONLY|O_CREAT|O_TRUNC, 0666);
+	if (fp < 0) {
+		bb_error_msg("cannot open %s for writing", server_config.lease_file);
+		return;
+	}
+
+	for (i = 0; i < server_config.max_leases; i++) {
+		if (leases[i].yiaddr != 0) {
+
+			/* screw with the time in the struct, for easier writing */
+			tmp_time = leases[i].expires;
+
+			if (server_config.remaining) {
+				if (lease_expired(&(leases[i])))
+					leases[i].expires = 0;
+				else leases[i].expires -= curr;
+			} /* else stick with the time we got */
+			leases[i].expires = htonl(leases[i].expires);
+			// FIXME: error check??
+			full_write(fp, &leases[i], sizeof(leases[i]));
+
+			/* then restore it when done */
+			leases[i].expires = tmp_time;
+		}
+	}
+	close(fp);
+
+	if (server_config.notify_file) {
+		char *cmd = xasprintf("%s %s", server_config.notify_file, server_config.lease_file);
+		system(cmd);
+		free(cmd);
+	}
+}
+
+
+void read_leases(const char *file)
+{
+	int fp;
+	unsigned int i = 0;
+	struct dhcpOfferedAddr lease;
+
+	fp = open(file, O_RDONLY);
+	if (fp < 0) {
+		bb_error_msg("cannot open %s for reading", file);
+		return;
+	}
+
+	while (i < server_config.max_leases
+	 && full_read(fp, &lease, sizeof(lease)) == sizeof(lease)
+	) {
+		/* ADDME: is it a static lease */
+		if (lease.yiaddr >= server_config.start && lease.yiaddr <= server_config.end) {
+			lease.expires = ntohl(lease.expires);
+			if (!server_config.remaining) lease.expires -= time(0);
+			if (!(add_lease(lease.chaddr, lease.yiaddr, lease.expires))) {
+				bb_error_msg("too many leases while loading %s", file);
+				break;
+			}
+			i++;
+		}
+	}
+	DEBUG("Read %d leases", i);
+	close(fp);
+}
diff --git a/networking/udhcp/leases.c b/networking/udhcp/leases.c
new file mode 100644
index 0000000..2f7847d
--- /dev/null
+++ b/networking/udhcp/leases.c
@@ -0,0 +1,145 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * leases.c -- tools to manage DHCP leases
+ * Russ Dill <Russ.Dill@asu.edu> July 2001
+ */
+
+#include "common.h"
+#include "dhcpd.h"
+
+
+uint8_t blank_chaddr[] = {[0 ... 15] = 0};
+
+/* clear every lease out that chaddr OR yiaddr matches and is nonzero */
+void clear_lease(uint8_t *chaddr, uint32_t yiaddr)
+{
+	unsigned int i, j;
+
+	for (j = 0; j < 16 && !chaddr[j]; j++);
+
+	for (i = 0; i < server_config.max_leases; i++)
+		if ((j != 16 && !memcmp(leases[i].chaddr, chaddr, 16)) ||
+		    (yiaddr && leases[i].yiaddr == yiaddr)) {
+			memset(&(leases[i]), 0, sizeof(struct dhcpOfferedAddr));
+		}
+}
+
+
+/* add a lease into the table, clearing out any old ones */
+struct dhcpOfferedAddr *add_lease(uint8_t *chaddr, uint32_t yiaddr, unsigned long lease)
+{
+	struct dhcpOfferedAddr *oldest;
+
+	/* clean out any old ones */
+	clear_lease(chaddr, yiaddr);
+
+	oldest = oldest_expired_lease();
+
+	if (oldest) {
+		memcpy(oldest->chaddr, chaddr, 16);
+		oldest->yiaddr = yiaddr;
+		oldest->expires = time(0) + lease;
+	}
+
+	return oldest;
+}
+
+
+/* true if a lease has expired */
+int lease_expired(struct dhcpOfferedAddr *lease)
+{
+	return (lease->expires < (unsigned long) time(0));
+}
+
+
+/* Find the oldest expired lease, NULL if there are no expired leases */
+struct dhcpOfferedAddr *oldest_expired_lease(void)
+{
+	struct dhcpOfferedAddr *oldest = NULL;
+	unsigned long oldest_lease = time(0);
+	unsigned int i;
+
+
+	for (i = 0; i < server_config.max_leases; i++)
+		if (oldest_lease > leases[i].expires) {
+			oldest_lease = leases[i].expires;
+			oldest = &(leases[i]);
+		}
+	return oldest;
+
+}
+
+
+/* Find the first lease that matches chaddr, NULL if no match */
+struct dhcpOfferedAddr *find_lease_by_chaddr(uint8_t *chaddr)
+{
+	unsigned int i;
+
+	for (i = 0; i < server_config.max_leases; i++)
+		if (!memcmp(leases[i].chaddr, chaddr, 16)) return &(leases[i]);
+
+	return NULL;
+}
+
+
+/* Find the first lease that matches yiaddr, NULL is no match */
+struct dhcpOfferedAddr *find_lease_by_yiaddr(uint32_t yiaddr)
+{
+	unsigned int i;
+
+	for (i = 0; i < server_config.max_leases; i++)
+		if (leases[i].yiaddr == yiaddr) return &(leases[i]);
+
+	return NULL;
+}
+
+
+/* check is an IP is taken, if it is, add it to the lease table */
+static int check_ip(uint32_t addr)
+{
+	struct in_addr temp;
+
+	if (arpping(addr, server_config.server, server_config.arp, server_config.interface) == 0) {
+		temp.s_addr = addr;
+		bb_info_msg("%s belongs to someone, reserving it for %ld seconds",
+			inet_ntoa(temp), server_config.conflict_time);
+		add_lease(blank_chaddr, addr, server_config.conflict_time);
+		return 1;
+	} else return 0;
+}
+
+
+/* find an assignable address, it check_expired is true, we check all the expired leases as well.
+ * Maybe this should try expired leases by age... */
+uint32_t find_address(int check_expired)
+{
+	uint32_t addr, ret;
+	struct dhcpOfferedAddr *lease = NULL;
+
+	addr = ntohl(server_config.start); /* addr is in host order here */
+	for (;addr <= ntohl(server_config.end); addr++) {
+
+		/* ie, 192.168.55.0 */
+		if (!(addr & 0xFF)) continue;
+
+		/* ie, 192.168.55.255 */
+		if ((addr & 0xFF) == 0xFF) continue;
+
+		/* Only do if it isn't an assigned as a static lease */
+		if (!reservedIp(server_config.static_leases, htonl(addr))) {
+
+			/* lease is not taken */
+			ret = htonl(addr);
+			lease = find_lease_by_yiaddr(ret);
+
+			/* no lease or it expired and we are checking for expired leases */
+			if ( (!lease || (check_expired && lease_expired(lease)))
+			 && /* and it isn't on the network */ !check_ip(ret)
+			) {
+				return ret;
+				break;
+			}
+		}
+	}
+	return 0;
+}
diff --git a/networking/udhcp/options.c b/networking/udhcp/options.c
new file mode 100644
index 0000000..4a46da5
--- /dev/null
+++ b/networking/udhcp/options.c
@@ -0,0 +1,174 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * options.c -- DHCP server option packet tools
+ * Rewrite by Russ Dill <Russ.Dill@asu.edu> July 2001
+ */
+
+#include "common.h"
+#include "dhcpd.h"
+#include "options.h"
+
+
+/* supported options are easily added here */
+const struct dhcp_option dhcp_options[] = {
+	/* name[10]     flags                                   code */
+	{"subnet",      OPTION_IP | OPTION_REQ,                 0x01},
+	{"timezone",    OPTION_S32,                             0x02},
+	{"router",      OPTION_IP | OPTION_LIST | OPTION_REQ,   0x03},
+	{"timesvr",     OPTION_IP | OPTION_LIST,                0x04},
+	{"namesvr",     OPTION_IP | OPTION_LIST,                0x05},
+	{"dns",         OPTION_IP | OPTION_LIST | OPTION_REQ,   0x06},
+	{"logsvr",      OPTION_IP | OPTION_LIST,                0x07},
+	{"cookiesvr",   OPTION_IP | OPTION_LIST,                0x08},
+	{"lprsvr",      OPTION_IP | OPTION_LIST,                0x09},
+	{"hostname",    OPTION_STRING | OPTION_REQ,             0x0c},
+	{"bootsize",    OPTION_U16,                             0x0d},
+	{"domain",      OPTION_STRING | OPTION_REQ,             0x0f},
+	{"swapsvr",     OPTION_IP,                              0x10},
+	{"rootpath",    OPTION_STRING,                          0x11},
+	{"ipttl",       OPTION_U8,                              0x17},
+	{"mtu",         OPTION_U16,                             0x1a},
+	{"broadcast",   OPTION_IP | OPTION_REQ,                 0x1c},
+	{"nisdomain",   OPTION_STRING | OPTION_REQ,             0x28},
+	{"nissrv",      OPTION_IP | OPTION_LIST | OPTION_REQ,   0x29},
+	{"ntpsrv",      OPTION_IP | OPTION_LIST | OPTION_REQ,   0x2a},
+	{"wins",        OPTION_IP | OPTION_LIST,                0x2c},
+	{"requestip",   OPTION_IP,                              0x32},
+	{"lease",       OPTION_U32,                             0x33},
+	{"dhcptype",    OPTION_U8,                              0x35},
+	{"serverid",    OPTION_IP,                              0x36},
+	{"message",     OPTION_STRING,                          0x38},
+	{"vendorclass", OPTION_STRING,                          0x3C},
+	{"clientid",    OPTION_STRING,                          0x3D},
+	{"tftp",        OPTION_STRING,                          0x42},
+	{"bootfile",    OPTION_STRING,                          0x43},
+	{"userclass",   OPTION_STRING,                          0x4D},
+	/* MSIE's "Web Proxy Autodiscovery Protocol" support */
+	{"wpad",        OPTION_STRING,                          0xfc},
+	{"",            0x00,                                   0x00}
+};
+
+/* Lengths of the different option types */
+const unsigned char option_lengths[] = {
+	[OPTION_IP] =      4,
+	[OPTION_IP_PAIR] = 8,
+	[OPTION_BOOLEAN] = 1,
+	[OPTION_STRING] =  1,
+	[OPTION_U8] =      1,
+	[OPTION_U16] =     2,
+	[OPTION_S16] =     2,
+	[OPTION_U32] =     4,
+	[OPTION_S32] =     4
+};
+
+
+/* get an option with bounds checking (warning, not aligned). */
+uint8_t *get_option(struct dhcpMessage *packet, int code)
+{
+	int i, length;
+	uint8_t *optionptr;
+	int over = 0, done = 0, curr = OPTION_FIELD;
+
+	optionptr = packet->options;
+	i = 0;
+	length = 308;
+	while (!done) {
+		if (i >= length) {
+			bb_error_msg("bogus packet, option fields too long");
+			return NULL;
+		}
+		if (optionptr[i + OPT_CODE] == code) {
+			if (i + 1 + optionptr[i + OPT_LEN] >= length) {
+				bb_error_msg("bogus packet, option fields too long");
+				return NULL;
+			}
+			return optionptr + i + 2;
+		}
+		switch (optionptr[i + OPT_CODE]) {
+		case DHCP_PADDING:
+			i++;
+			break;
+		case DHCP_OPTION_OVER:
+			if (i + 1 + optionptr[i + OPT_LEN] >= length) {
+				bb_error_msg("bogus packet, option fields too long");
+				return NULL;
+			}
+			over = optionptr[i + 3];
+			i += optionptr[OPT_LEN] + 2;
+			break;
+		case DHCP_END:
+			if (curr == OPTION_FIELD && over & FILE_FIELD) {
+				optionptr = packet->file;
+				i = 0;
+				length = 128;
+				curr = FILE_FIELD;
+			} else if (curr == FILE_FIELD && over & SNAME_FIELD) {
+				optionptr = packet->sname;
+				i = 0;
+				length = 64;
+				curr = SNAME_FIELD;
+			} else done = 1;
+			break;
+		default:
+			i += optionptr[OPT_LEN + i] + 2;
+		}
+	}
+	return NULL;
+}
+
+
+/* return the position of the 'end' option (no bounds checking) */
+int end_option(uint8_t *optionptr)
+{
+	int i = 0;
+
+	while (optionptr[i] != DHCP_END) {
+		if (optionptr[i] == DHCP_PADDING) i++;
+		else i += optionptr[i + OPT_LEN] + 2;
+	}
+	return i;
+}
+
+
+/* add an option string to the options (an option string contains an option code,
+ * length, then data) */
+int add_option_string(uint8_t *optionptr, uint8_t *string)
+{
+	int end = end_option(optionptr);
+
+	/* end position + string length + option code/length + end option */
+	if (end + string[OPT_LEN] + 2 + 1 >= 308) {
+		bb_error_msg("option 0x%02x did not fit into the packet",
+				string[OPT_CODE]);
+		return 0;
+	}
+	DEBUG("adding option 0x%02x", string[OPT_CODE]);
+	memcpy(optionptr + end, string, string[OPT_LEN] + 2);
+	optionptr[end + string[OPT_LEN] + 2] = DHCP_END;
+	return string[OPT_LEN] + 2;
+}
+
+
+/* add a one to four byte option to a packet */
+int add_simple_option(uint8_t *optionptr, uint8_t code, uint32_t data)
+{
+	const struct dhcp_option *dh;
+
+	for (dh = dhcp_options; dh->code; dh++) {
+		if (dh->code == code) {
+			uint8_t option[6], len;
+
+			option[OPT_CODE] = code;
+			len = option_lengths[dh->flags & TYPE_MASK];
+			option[OPT_LEN] = len;
+			if (BB_BIG_ENDIAN) data <<= 8 * (4 - len);
+			/* This memcpy is for broken processors which can't
+			 * handle a simple unaligned 32-bit assignment */
+			memcpy(&option[OPT_DATA], &data, 4);
+			return add_option_string(optionptr, option);
+		}
+	}
+
+	bb_error_msg("cannot add option 0x%02x", code);
+	return 0;
+}
diff --git a/networking/udhcp/options.h b/networking/udhcp/options.h
new file mode 100644
index 0000000..588504e
--- /dev/null
+++ b/networking/udhcp/options.h
@@ -0,0 +1,37 @@
+/* vi: set sw=4 ts=4: */
+/* options.h */
+#ifndef _OPTIONS_H
+#define _OPTIONS_H
+
+#define TYPE_MASK	0x0F
+
+enum {
+	OPTION_IP=1,
+	OPTION_IP_PAIR,
+	OPTION_STRING,
+	OPTION_BOOLEAN,
+	OPTION_U8,
+	OPTION_U16,
+	OPTION_S16,
+	OPTION_U32,
+	OPTION_S32
+};
+
+#define OPTION_REQ	0x10 /* have the client request this option */
+#define OPTION_LIST	0x20 /* There can be a list of 1 or more of these */
+
+struct dhcp_option {
+	char name[12];
+	char flags;
+	uint8_t code;
+};
+
+extern const struct dhcp_option dhcp_options[];
+extern const unsigned char option_lengths[];
+
+uint8_t *get_option(struct dhcpMessage *packet, int code);
+int end_option(uint8_t *optionptr);
+int add_option_string(uint8_t *optionptr, uint8_t *string);
+int add_simple_option(uint8_t *optionptr, uint8_t code, uint32_t data);
+
+#endif
diff --git a/networking/udhcp/packet.c b/networking/udhcp/packet.c
new file mode 100644
index 0000000..dec9d0a
--- /dev/null
+++ b/networking/udhcp/packet.c
@@ -0,0 +1,211 @@
+/* vi: set sw=4 ts=4: */
+
+#include <netinet/in.h>
+#if (__GLIBC__ >= 2 && __GLIBC_MINOR__ >= 1) || defined _NEWLIB_VERSION
+#include <netpacket/packet.h>
+#include <net/ethernet.h>
+#else
+#include <asm/types.h>
+#include <linux/if_packet.h>
+#include <linux/if_ether.h>
+#endif
+
+#include "common.h"
+#include "dhcpd.h"
+#include "options.h"
+
+
+void udhcp_init_header(struct dhcpMessage *packet, char type)
+{
+	memset(packet, 0, sizeof(struct dhcpMessage));
+	switch (type) {
+	case DHCPDISCOVER:
+	case DHCPREQUEST:
+	case DHCPRELEASE:
+	case DHCPINFORM:
+		packet->op = BOOTREQUEST;
+		break;
+	case DHCPOFFER:
+	case DHCPACK:
+	case DHCPNAK:
+		packet->op = BOOTREPLY;
+	}
+	packet->htype = ETH_10MB;
+	packet->hlen = ETH_10MB_LEN;
+	packet->cookie = htonl(DHCP_MAGIC);
+	packet->options[0] = DHCP_END;
+	add_simple_option(packet->options, DHCP_MESSAGE_TYPE, type);
+}
+
+
+/* read a packet from socket fd, return -1 on read error, -2 on packet error */
+int udhcp_get_packet(struct dhcpMessage *packet, int fd)
+{
+	static const char broken_vendors[][8] = {
+		"MSFT 98",
+		""
+	};
+	int bytes;
+	int i;
+	char unsigned *vendor;
+
+	memset(packet, 0, sizeof(struct dhcpMessage));
+	bytes = read(fd, packet, sizeof(struct dhcpMessage));
+	if (bytes < 0) {
+		DEBUG("cannot read on listening socket, ignoring");
+		return -1;
+	}
+
+	if (ntohl(packet->cookie) != DHCP_MAGIC) {
+		bb_error_msg("received bogus message, ignoring");
+		return -2;
+	}
+	DEBUG("Received a packet");
+
+	if (packet->op == BOOTREQUEST && (vendor = get_option(packet, DHCP_VENDOR))) {
+		for (i = 0; broken_vendors[i][0]; i++) {
+			if (vendor[OPT_LEN - 2] == (uint8_t)strlen(broken_vendors[i])
+			 && !strncmp((char*)vendor, broken_vendors[i], vendor[OPT_LEN - 2])
+			) {
+				DEBUG("broken client (%s), forcing broadcast",
+					broken_vendors[i]);
+				packet->flags |= htons(BROADCAST_FLAG);
+			}
+		}
+	}
+
+	return bytes;
+}
+
+
+uint16_t udhcp_checksum(void *addr, int count)
+{
+	/* Compute Internet Checksum for "count" bytes
+	 *         beginning at location "addr".
+	 */
+	int32_t sum = 0;
+	uint16_t *source = (uint16_t *) addr;
+
+	while (count > 1)  {
+		/*  This is the inner loop */
+		sum += *source++;
+		count -= 2;
+	}
+
+	/*  Add left-over byte, if any */
+	if (count > 0) {
+		/* Make sure that the left-over byte is added correctly both
+		 * with little and big endian hosts */
+		uint16_t tmp = 0;
+		*(uint8_t *) (&tmp) = * (uint8_t *) source;
+		sum += tmp;
+	}
+	/*  Fold 32-bit sum to 16 bits */
+	while (sum >> 16)
+		sum = (sum & 0xffff) + (sum >> 16);
+
+	return ~sum;
+}
+
+
+/* Construct a ip/udp header for a packet, and specify the source and dest hardware address */
+void BUG_sizeof_struct_udp_dhcp_packet_must_be_576(void);
+int udhcp_raw_packet(struct dhcpMessage *payload,
+		uint32_t source_ip, int source_port,
+		uint32_t dest_ip, int dest_port, uint8_t *dest_arp, int ifindex)
+{
+	int fd;
+	int result;
+	struct sockaddr_ll dest;
+	struct udp_dhcp_packet packet;
+
+	fd = socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_IP));
+	if (fd < 0) {
+		bb_perror_msg("socket");
+		return -1;
+	}
+
+	memset(&dest, 0, sizeof(dest));
+	memset(&packet, 0, sizeof(packet));
+
+	dest.sll_family = AF_PACKET;
+	dest.sll_protocol = htons(ETH_P_IP);
+	dest.sll_ifindex = ifindex;
+	dest.sll_halen = 6;
+	memcpy(dest.sll_addr, dest_arp, 6);
+	if (bind(fd, (struct sockaddr *)&dest, sizeof(struct sockaddr_ll)) < 0) {
+		bb_perror_msg("bind");
+		close(fd);
+		return -1;
+	}
+
+	packet.ip.protocol = IPPROTO_UDP;
+	packet.ip.saddr = source_ip;
+	packet.ip.daddr = dest_ip;
+	packet.udp.source = htons(source_port);
+	packet.udp.dest = htons(dest_port);
+	packet.udp.len = htons(sizeof(packet.udp) + sizeof(struct dhcpMessage)); /* cheat on the psuedo-header */
+	packet.ip.tot_len = packet.udp.len;
+	memcpy(&(packet.data), payload, sizeof(struct dhcpMessage));
+	packet.udp.check = udhcp_checksum(&packet, sizeof(struct udp_dhcp_packet));
+
+	packet.ip.tot_len = htons(sizeof(struct udp_dhcp_packet));
+	packet.ip.ihl = sizeof(packet.ip) >> 2;
+	packet.ip.version = IPVERSION;
+	packet.ip.ttl = IPDEFTTL;
+	packet.ip.check = udhcp_checksum(&(packet.ip), sizeof(packet.ip));
+
+	if (sizeof(struct udp_dhcp_packet) != 576)
+		BUG_sizeof_struct_udp_dhcp_packet_must_be_576();
+
+	result = sendto(fd, &packet, sizeof(struct udp_dhcp_packet), 0,
+			(struct sockaddr *) &dest, sizeof(dest));
+	if (result <= 0) {
+		bb_perror_msg("sendto");
+	}
+	close(fd);
+	return result;
+}
+
+
+/* Let the kernel do all the work for packet generation */
+int udhcp_kernel_packet(struct dhcpMessage *payload,
+		uint32_t source_ip, int source_port,
+		uint32_t dest_ip, int dest_port)
+{
+	int fd, result;
+	struct sockaddr_in client;
+
+	fd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
+	if (fd < 0)
+		return -1;
+
+	if (setsockopt_reuseaddr(fd) == -1) {
+		close(fd);
+		return -1;
+	}
+
+	memset(&client, 0, sizeof(client));
+	client.sin_family = AF_INET;
+	client.sin_port = htons(source_port);
+	client.sin_addr.s_addr = source_ip;
+
+	if (bind(fd, (struct sockaddr *)&client, sizeof(struct sockaddr)) == -1) {
+		close(fd);
+		return -1;
+	}
+
+	memset(&client, 0, sizeof(client));
+	client.sin_family = AF_INET;
+	client.sin_port = htons(dest_port);
+	client.sin_addr.s_addr = dest_ip;
+
+	if (connect(fd, (struct sockaddr *)&client, sizeof(struct sockaddr)) == -1) {
+		close(fd);
+		return -1;
+	}
+
+	result = write(fd, payload, sizeof(struct dhcpMessage));
+	close(fd);
+	return result;
+}
diff --git a/networking/udhcp/pidfile.c b/networking/udhcp/pidfile.c
new file mode 100644
index 0000000..bcb2608
--- /dev/null
+++ b/networking/udhcp/pidfile.c
@@ -0,0 +1,66 @@
+/* vi: set sw=4 ts=4: */
+/* pidfile.c
+ *
+ * Functions to assist in the writing and removing of pidfiles.
+ *
+ * Russ Dill <Russ.Dill@asu.edu> September 2001
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "common.h"
+
+
+static const char *saved_pidfile;
+
+static void pidfile_delete(void)
+{
+	if (saved_pidfile) unlink(saved_pidfile);
+}
+
+
+int pidfile_acquire(const char *pidfile)
+{
+	int pid_fd;
+	if (!pidfile) return -1;
+
+	pid_fd = open(pidfile, O_CREAT|O_WRONLY|O_TRUNC, 0644);
+	if (pid_fd < 0) {
+		bb_perror_msg("cannot open pidfile %s", pidfile);
+	} else {
+		lockf(pid_fd, F_LOCK, 0);
+		if (!saved_pidfile)
+			atexit(pidfile_delete);
+		saved_pidfile = pidfile;
+	}
+
+	return pid_fd;
+}
+
+
+void pidfile_write_release(int pid_fd)
+{
+	FILE *out;
+
+	if (pid_fd < 0) return;
+
+	out = fdopen(pid_fd, "w");
+	if (out) {
+		fprintf(out, "%d\n", getpid());
+		fclose(out);
+	}
+	lockf(pid_fd, F_UNLCK, 0);
+	close(pid_fd);
+}
diff --git a/networking/udhcp/script.c b/networking/udhcp/script.c
new file mode 100644
index 0000000..07f6836
--- /dev/null
+++ b/networking/udhcp/script.c
@@ -0,0 +1,213 @@
+/* vi: set sw=4 ts=4: */
+/* script.c
+ *
+ * Functions to call the DHCP client notification scripts
+ *
+ * Russ Dill <Russ.Dill@asu.edu> July 2001
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ */
+
+#include "common.h"
+#include "dhcpd.h"
+#include "dhcpc.h"
+#include "options.h"
+
+
+/* get a rough idea of how long an option will be (rounding up...) */
+static const int max_option_length[] = {
+	[OPTION_IP] =		sizeof("255.255.255.255 "),
+	[OPTION_IP_PAIR] =	sizeof("255.255.255.255 ") * 2,
+	[OPTION_STRING] =	1,
+	[OPTION_BOOLEAN] =	sizeof("yes "),
+	[OPTION_U8] =		sizeof("255 "),
+	[OPTION_U16] =		sizeof("65535 "),
+	[OPTION_S16] =		sizeof("-32768 "),
+	[OPTION_U32] =		sizeof("4294967295 "),
+	[OPTION_S32] =		sizeof("-2147483684 "),
+};
+
+
+static inline int upper_length(int length, int opt_index)
+{
+	return max_option_length[opt_index] *
+		(length / option_lengths[opt_index]);
+}
+
+
+static int sprintip(char *dest, char *pre, uint8_t *ip)
+{
+	return sprintf(dest, "%s%d.%d.%d.%d", pre, ip[0], ip[1], ip[2], ip[3]);
+}
+
+
+/* really simple implementation, just count the bits */
+static int mton(struct in_addr *mask)
+{
+	int i;
+	unsigned long bits = ntohl(mask->s_addr);
+	/* too bad one can't check the carry bit, etc in c bit
+	 * shifting */
+	for (i = 0; i < 32 && !((bits >> i) & 1); i++);
+	return 32 - i;
+}
+
+
+/* Fill dest with the text of option 'option'. */
+static void fill_options(char *dest, uint8_t *option,
+			const struct dhcp_option *type_p)
+{
+	int type, optlen;
+	uint16_t val_u16;
+	int16_t val_s16;
+	uint32_t val_u32;
+	int32_t val_s32;
+	int len = option[OPT_LEN - 2];
+
+	dest += sprintf(dest, "%s=", type_p->name);
+
+	type = type_p->flags & TYPE_MASK;
+	optlen = option_lengths[type];
+	for (;;) {
+		switch (type) {
+		case OPTION_IP_PAIR:
+			dest += sprintip(dest, "", option);
+			*(dest++) = '/';
+			option += 4;
+			optlen = 4;
+		case OPTION_IP:	/* Works regardless of host byte order. */
+			dest += sprintip(dest, "", option);
+			break;
+		case OPTION_BOOLEAN:
+			dest += sprintf(dest, *option ? "yes" : "no");
+			break;
+		case OPTION_U8:
+			dest += sprintf(dest, "%u", *option);
+			break;
+		case OPTION_U16:
+			memcpy(&val_u16, option, 2);
+			dest += sprintf(dest, "%u", ntohs(val_u16));
+			break;
+		case OPTION_S16:
+			memcpy(&val_s16, option, 2);
+			dest += sprintf(dest, "%d", ntohs(val_s16));
+			break;
+		case OPTION_U32:
+			memcpy(&val_u32, option, 4);
+			dest += sprintf(dest, "%lu", (unsigned long) ntohl(val_u32));
+			break;
+		case OPTION_S32:
+			memcpy(&val_s32, option, 4);
+			dest += sprintf(dest, "%ld", (long) ntohl(val_s32));
+			break;
+		case OPTION_STRING:
+			memcpy(dest, option, len);
+			dest[len] = '\0';
+			return;	 /* Short circuit this case */
+		}
+		option += optlen;
+		len -= optlen;
+		if (len <= 0) break;
+		dest += sprintf(dest, " ");
+	}
+}
+
+
+/* put all the parameters into an environment */
+static char **fill_envp(struct dhcpMessage *packet)
+{
+	int num_options = 0;
+	int i, j;
+	char **envp;
+	uint8_t *temp;
+	struct in_addr subnet;
+	char over = 0;
+
+	if (packet == NULL)
+		num_options = 0;
+	else {
+		for (i = 0; dhcp_options[i].code; i++)
+			if (get_option(packet, dhcp_options[i].code)) {
+				num_options++;
+				if (dhcp_options[i].code == DHCP_SUBNET)
+					num_options++; /* for mton */
+			}
+		if (packet->siaddr) num_options++;
+		if ((temp = get_option(packet, DHCP_OPTION_OVER)))
+			over = *temp;
+		if (!(over & FILE_FIELD) && packet->file[0]) num_options++;
+		if (!(over & SNAME_FIELD) && packet->sname[0]) num_options++;
+	}
+
+	envp = xzalloc(sizeof(char *) * (num_options + 5));
+	j = 0;
+	envp[j++] = xasprintf("interface=%s", client_config.interface);
+	envp[j++] = xasprintf("PATH=%s",
+		getenv("PATH") ? : "/bin:/usr/bin:/sbin:/usr/sbin");
+	envp[j++] = xasprintf("HOME=%s", getenv("HOME") ? : "/");
+
+	if (packet == NULL) return envp;
+
+	envp[j] = xmalloc(sizeof("ip=255.255.255.255"));
+	sprintip(envp[j++], "ip=", (uint8_t *) &packet->yiaddr);
+
+	for (i = 0; dhcp_options[i].code; i++) {
+		temp = get_option(packet, dhcp_options[i].code);
+		if (!temp)
+			continue;
+		envp[j] = xmalloc(upper_length(temp[OPT_LEN - 2],
+			dhcp_options[i].flags & TYPE_MASK) + strlen(dhcp_options[i].name) + 2);
+		fill_options(envp[j++], temp, &dhcp_options[i]);
+
+		/* Fill in a subnet bits option for things like /24 */
+		if (dhcp_options[i].code == DHCP_SUBNET) {
+			memcpy(&subnet, temp, 4);
+			envp[j++] = xasprintf("mask=%d", mton(&subnet));
+		}
+	}
+	if (packet->siaddr) {
+		envp[j] = xmalloc(sizeof("siaddr=255.255.255.255"));
+		sprintip(envp[j++], "siaddr=", (uint8_t *) &packet->siaddr);
+	}
+	if (!(over & FILE_FIELD) && packet->file[0]) {
+		/* watch out for invalid packets */
+		packet->file[sizeof(packet->file) - 1] = '\0';
+		envp[j++] = xasprintf("boot_file=%s", packet->file);
+	}
+	if (!(over & SNAME_FIELD) && packet->sname[0]) {
+		/* watch out for invalid packets */
+		packet->sname[sizeof(packet->sname) - 1] = '\0';
+		envp[j++] = xasprintf("sname=%s", packet->sname);
+	}
+	return envp;
+}
+
+
+/* Call a script with a par file and env vars */
+void udhcp_run_script(struct dhcpMessage *packet, const char *name)
+{
+	int pid;
+	char **envp, **curr;
+
+	if (client_config.script == NULL)
+		return;
+
+	DEBUG("vfork'ing and execle'ing %s", client_config.script);
+
+	envp = fill_envp(packet);
+	/* call script */
+	pid = vfork();
+	if (pid) {
+		waitpid(pid, NULL, 0);
+		for (curr = envp; *curr; curr++) free(*curr);
+		free(envp);
+		return;
+	} else if (pid == 0) {
+		/* close fd's? */
+		/* exec script */
+		execle(client_config.script, client_config.script,
+		       name, NULL, envp);
+		bb_perror_msg("script %s failed", client_config.script);
+		exit(1);
+	}
+}
diff --git a/networking/udhcp/serverpacket.c b/networking/udhcp/serverpacket.c
new file mode 100644
index 0000000..8889fda
--- /dev/null
+++ b/networking/udhcp/serverpacket.c
@@ -0,0 +1,261 @@
+/* vi: set sw=4 ts=4: */
+/* serverpacket.c
+ *
+ * Construct and send DHCP server packets
+ *
+ * Russ Dill <Russ.Dill@asu.edu> July 2001
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "common.h"
+#include "dhcpd.h"
+#include "options.h"
+
+
+/* send a packet to giaddr using the kernel ip stack */
+static int send_packet_to_relay(struct dhcpMessage *payload)
+{
+	DEBUG("Forwarding packet to relay");
+
+	return udhcp_kernel_packet(payload, server_config.server, SERVER_PORT,
+			payload->giaddr, SERVER_PORT);
+}
+
+
+/* send a packet to a specific arp address and ip address by creating our own ip packet */
+static int send_packet_to_client(struct dhcpMessage *payload, int force_broadcast)
+{
+	uint8_t *chaddr;
+	uint32_t ciaddr;
+
+	if (force_broadcast) {
+		DEBUG("broadcasting packet to client (NAK)");
+		ciaddr = INADDR_BROADCAST;
+		chaddr = MAC_BCAST_ADDR;
+	} else if (payload->ciaddr) {
+		DEBUG("unicasting packet to client ciaddr");
+		ciaddr = payload->ciaddr;
+		chaddr = payload->chaddr;
+	} else if (ntohs(payload->flags) & BROADCAST_FLAG) {
+		DEBUG("broadcasting packet to client (requested)");
+		ciaddr = INADDR_BROADCAST;
+		chaddr = MAC_BCAST_ADDR;
+	} else {
+		DEBUG("unicasting packet to client yiaddr");
+		ciaddr = payload->yiaddr;
+		chaddr = payload->chaddr;
+	}
+	return udhcp_raw_packet(payload, server_config.server, SERVER_PORT,
+			ciaddr, CLIENT_PORT, chaddr, server_config.ifindex);
+}
+
+
+/* send a dhcp packet, if force broadcast is set, the packet will be broadcast to the client */
+static int send_packet(struct dhcpMessage *payload, int force_broadcast)
+{
+	int ret;
+
+	if (payload->giaddr)
+		ret = send_packet_to_relay(payload);
+	else ret = send_packet_to_client(payload, force_broadcast);
+	return ret;
+}
+
+
+static void init_packet(struct dhcpMessage *packet, struct dhcpMessage *oldpacket, char type)
+{
+	udhcp_init_header(packet, type);
+	packet->xid = oldpacket->xid;
+	memcpy(packet->chaddr, oldpacket->chaddr, 16);
+	packet->flags = oldpacket->flags;
+	packet->giaddr = oldpacket->giaddr;
+	packet->ciaddr = oldpacket->ciaddr;
+	add_simple_option(packet->options, DHCP_SERVER_ID, server_config.server);
+}
+
+
+/* add in the bootp options */
+static void add_bootp_options(struct dhcpMessage *packet)
+{
+	packet->siaddr = server_config.siaddr;
+	if (server_config.sname)
+		strncpy((char*)packet->sname, server_config.sname, sizeof(packet->sname) - 1);
+	if (server_config.boot_file)
+		strncpy((char*)packet->file, server_config.boot_file, sizeof(packet->file) - 1);
+}
+
+
+/* send a DHCP OFFER to a DHCP DISCOVER */
+int sendOffer(struct dhcpMessage *oldpacket)
+{
+	struct dhcpMessage packet;
+	struct dhcpOfferedAddr *lease = NULL;
+	uint32_t req_align, lease_time_align = server_config.lease;
+	uint8_t *req, *lease_time;
+	struct option_set *curr;
+	struct in_addr addr;
+
+	uint32_t static_lease_ip;
+
+	init_packet(&packet, oldpacket, DHCPOFFER);
+
+	static_lease_ip = getIpByMac(server_config.static_leases, oldpacket->chaddr);
+
+	/* ADDME: if static, short circuit */
+	if (!static_lease_ip) {
+		/* the client is in our lease/offered table */
+		lease = find_lease_by_chaddr(oldpacket->chaddr);
+		if (lease) {
+			if (!lease_expired(lease))
+				lease_time_align = lease->expires - time(0);
+			packet.yiaddr = lease->yiaddr;
+
+		/* Or the client has a requested ip */
+		} else if ((req = get_option(oldpacket, DHCP_REQUESTED_IP))
+			/* Don't look here (ugly hackish thing to do) */
+			&& memcpy(&req_align, req, 4)
+			/* and the ip is in the lease range */
+			&& ntohl(req_align) >= ntohl(server_config.start)
+			&& ntohl(req_align) <= ntohl(server_config.end)
+			&& !static_lease_ip /* Check that its not a static lease */
+			/* and is not already taken/offered */
+			&& (!(lease = find_lease_by_yiaddr(req_align))
+				/* or its taken, but expired */ /* ADDME: or maybe in here */
+				|| lease_expired(lease))
+		) {
+			packet.yiaddr = req_align; /* FIXME: oh my, is there a host using this IP? */
+			/* otherwise, find a free IP */
+		} else {
+			/* Is it a static lease? (No, because find_address skips static lease) */
+			packet.yiaddr = find_address(0);
+			/* try for an expired lease */
+			if (!packet.yiaddr) packet.yiaddr = find_address(1);
+		}
+
+		if (!packet.yiaddr) {
+			bb_error_msg("no IP addresses to give - OFFER abandoned");
+			return -1;
+		}
+		if (!add_lease(packet.chaddr, packet.yiaddr, server_config.offer_time)) {
+			bb_error_msg("lease pool is full - OFFER abandoned");
+			return -1;
+		}
+		lease_time = get_option(oldpacket, DHCP_LEASE_TIME);
+		if (lease_time) {
+			memcpy(&lease_time_align, lease_time, 4);
+			lease_time_align = ntohl(lease_time_align);
+			if (lease_time_align > server_config.lease)
+				lease_time_align = server_config.lease;
+		}
+
+		/* Make sure we aren't just using the lease time from the previous offer */
+		if (lease_time_align < server_config.min_lease)
+			lease_time_align = server_config.lease;
+		/* ADDME: end of short circuit */
+	} else {
+		/* It is a static lease... use it */
+		packet.yiaddr = static_lease_ip;
+	}
+
+	add_simple_option(packet.options, DHCP_LEASE_TIME, htonl(lease_time_align));
+
+	curr = server_config.options;
+	while (curr) {
+		if (curr->data[OPT_CODE] != DHCP_LEASE_TIME)
+			add_option_string(packet.options, curr->data);
+		curr = curr->next;
+	}
+
+	add_bootp_options(&packet);
+
+	addr.s_addr = packet.yiaddr;
+	bb_info_msg("Sending OFFER of %s", inet_ntoa(addr));
+	return send_packet(&packet, 0);
+}
+
+
+int sendNAK(struct dhcpMessage *oldpacket)
+{
+	struct dhcpMessage packet;
+
+	init_packet(&packet, oldpacket, DHCPNAK);
+
+	DEBUG("Sending NAK");
+	return send_packet(&packet, 1);
+}
+
+
+int sendACK(struct dhcpMessage *oldpacket, uint32_t yiaddr)
+{
+	struct dhcpMessage packet;
+	struct option_set *curr;
+	uint8_t *lease_time;
+	uint32_t lease_time_align = server_config.lease;
+	struct in_addr addr;
+
+	init_packet(&packet, oldpacket, DHCPACK);
+	packet.yiaddr = yiaddr;
+
+	if ((lease_time = get_option(oldpacket, DHCP_LEASE_TIME))) {
+		memcpy(&lease_time_align, lease_time, 4);
+		lease_time_align = ntohl(lease_time_align);
+		if (lease_time_align > server_config.lease)
+			lease_time_align = server_config.lease;
+		else if (lease_time_align < server_config.min_lease)
+			lease_time_align = server_config.lease;
+	}
+
+	add_simple_option(packet.options, DHCP_LEASE_TIME, htonl(lease_time_align));
+
+	curr = server_config.options;
+	while (curr) {
+		if (curr->data[OPT_CODE] != DHCP_LEASE_TIME)
+			add_option_string(packet.options, curr->data);
+		curr = curr->next;
+	}
+
+	add_bootp_options(&packet);
+
+	addr.s_addr = packet.yiaddr;
+	bb_info_msg("Sending ACK to %s", inet_ntoa(addr));
+
+	if (send_packet(&packet, 0) < 0)
+		return -1;
+
+	add_lease(packet.chaddr, packet.yiaddr, lease_time_align);
+
+	return 0;
+}
+
+
+int send_inform(struct dhcpMessage *oldpacket)
+{
+	struct dhcpMessage packet;
+	struct option_set *curr;
+
+	init_packet(&packet, oldpacket, DHCPACK);
+
+	curr = server_config.options;
+	while (curr) {
+		if (curr->data[OPT_CODE] != DHCP_LEASE_TIME)
+			add_option_string(packet.options, curr->data);
+		curr = curr->next;
+	}
+
+	add_bootp_options(&packet);
+
+	return send_packet(&packet, 0);
+}
diff --git a/networking/udhcp/signalpipe.c b/networking/udhcp/signalpipe.c
new file mode 100644
index 0000000..3615965
--- /dev/null
+++ b/networking/udhcp/signalpipe.c
@@ -0,0 +1,77 @@
+/* vi: set sw=4 ts=4: */
+/* signalpipe.c
+ *
+ * Signal pipe infrastructure. A reliable way of delivering signals.
+ *
+ * Russ Dill <Russ.Dill@asu.edu> December 2003
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "common.h"
+
+
+static int signal_pipe[2];
+
+static void signal_handler(int sig)
+{
+	if (send(signal_pipe[1], &sig, sizeof(sig), MSG_DONTWAIT) < 0)
+		bb_perror_msg("cannot send signal");
+}
+
+
+/* Call this before doing anything else. Sets up the socket pair
+ * and installs the signal handler */
+void udhcp_sp_setup(void)
+{
+	socketpair(AF_UNIX, SOCK_STREAM, 0, signal_pipe);
+	fcntl(signal_pipe[0], F_SETFD, FD_CLOEXEC);
+	fcntl(signal_pipe[1], F_SETFD, FD_CLOEXEC);
+	signal(SIGUSR1, signal_handler);
+	signal(SIGUSR2, signal_handler);
+	signal(SIGTERM, signal_handler);
+}
+
+
+/* Quick little function to setup the rfds. Will return the
+ * max_fd for use with select. Limited in that you can only pass
+ * one extra fd */
+int udhcp_sp_fd_set(fd_set *rfds, int extra_fd)
+{
+	FD_ZERO(rfds);
+	FD_SET(signal_pipe[0], rfds);
+	if (extra_fd >= 0) {
+		fcntl(extra_fd, F_SETFD, FD_CLOEXEC);
+		FD_SET(extra_fd, rfds);
+	}
+	return signal_pipe[0] > extra_fd ? signal_pipe[0] : extra_fd;
+}
+
+
+/* Read a signal from the signal pipe. Returns 0 if there is
+ * no signal, -1 on error (and sets errno appropriately), and
+ * your signal on success */
+int udhcp_sp_read(fd_set *rfds)
+{
+	int sig;
+
+	if (!FD_ISSET(signal_pipe[0], rfds))
+		return 0;
+
+	if (read(signal_pipe[0], &sig, sizeof(sig)) < 0)
+		return -1;
+
+	return sig;
+}
diff --git a/networking/udhcp/socket.c b/networking/udhcp/socket.c
new file mode 100644
index 0000000..2bae68f
--- /dev/null
+++ b/networking/udhcp/socket.c
@@ -0,0 +1,130 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * socket.c -- DHCP server client/server socket creation
+ *
+ * udhcp client/server
+ * Copyright (C) 1999 Matthew Ramsay <matthewr@moreton.com.au>
+ *			Chris Trew <ctrew@moreton.com.au>
+ *
+ * Rewrite by Russ Dill <Russ.Dill@asu.edu> July 2001
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <net/if.h>
+#include <features.h>
+#if (__GLIBC__ >= 2 && __GLIBC_MINOR__ >= 1) || defined _NEWLIB_VERSION
+#include <netpacket/packet.h>
+#include <net/ethernet.h>
+#else
+#include <asm/types.h>
+#include <linux/if_packet.h>
+#include <linux/if_ether.h>
+#endif
+
+#include "common.h"
+
+
+int read_interface(char *interface, int *ifindex, uint32_t *addr, uint8_t *arp)
+{
+	int fd;
+	struct ifreq ifr;
+	struct sockaddr_in *our_ip;
+
+	memset(&ifr, 0, sizeof(struct ifreq));
+	fd = socket(AF_INET, SOCK_RAW, IPPROTO_RAW);
+	if (fd < 0) {
+		bb_perror_msg("socket failed");
+		return -1;
+	}
+
+	ifr.ifr_addr.sa_family = AF_INET;
+	strncpy(ifr.ifr_name, interface, sizeof(ifr.ifr_name));
+	if (addr) {
+		if (ioctl(fd, SIOCGIFADDR, &ifr) != 0) {
+			bb_perror_msg("SIOCGIFADDR failed, is the interface up and configured?");
+			close(fd);
+			return -1;
+		}
+		our_ip = (struct sockaddr_in *) &ifr.ifr_addr;
+		*addr = our_ip->sin_addr.s_addr;
+		DEBUG("%s (our ip) = %s", ifr.ifr_name, inet_ntoa(our_ip->sin_addr));
+	}
+
+	if (ifindex) {
+		if (ioctl(fd, SIOCGIFINDEX, &ifr) != 0) {
+			bb_perror_msg("SIOCGIFINDEX failed");
+			close(fd);
+			return -1;
+		}
+		DEBUG("adapter index %d", ifr.ifr_ifindex);
+		*ifindex = ifr.ifr_ifindex;
+	}
+
+	if (arp) {
+		if (ioctl(fd, SIOCGIFHWADDR, &ifr) != 0) {
+			bb_perror_msg("SIOCGIFHWADDR failed");
+			close(fd);
+			return -1;
+		}
+		memcpy(arp, ifr.ifr_hwaddr.sa_data, 6);
+		DEBUG("adapter hardware address %02x:%02x:%02x:%02x:%02x:%02x",
+			arp[0], arp[1], arp[2], arp[3], arp[4], arp[5]);
+	}
+
+	return 0;
+}
+
+
+int listen_socket(uint32_t ip, int port, char *inf)
+{
+	struct ifreq interface;
+	int fd;
+	struct sockaddr_in addr;
+
+	DEBUG("Opening listen socket on 0x%08x:%d %s", ip, port, inf);
+	fd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
+	if (fd < 0) {
+		bb_perror_msg("socket");
+		return -1;
+	}
+
+	memset(&addr, 0, sizeof(addr));
+	addr.sin_family = AF_INET;
+	addr.sin_port = htons(port);
+	addr.sin_addr.s_addr = ip;
+
+	if (setsockopt_reuseaddr(fd) == -1) {
+		close(fd);
+		return -1;
+	}
+	if (setsockopt_broadcast(fd) == -1) {
+		close(fd);
+		return -1;
+	}
+
+	strncpy(interface.ifr_name, inf, IFNAMSIZ);
+	if (setsockopt(fd, SOL_SOCKET, SO_BINDTODEVICE, (char *)&interface, sizeof(interface)) < 0) {
+		close(fd);
+		return -1;
+	}
+
+	if (bind(fd, (struct sockaddr *)&addr, sizeof(struct sockaddr)) == -1) {
+		close(fd);
+		return -1;
+	}
+
+	return fd;
+}
diff --git a/networking/udhcp/static_leases.c b/networking/udhcp/static_leases.c
new file mode 100644
index 0000000..aabfb81
--- /dev/null
+++ b/networking/udhcp/static_leases.c
@@ -0,0 +1,99 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * static_leases.c -- Couple of functions to assist with storing and
+ * retrieving data for static leases
+ *
+ * Wade Berrier <wberrier@myrealbox.com> September 2004
+ *
+ */
+
+#include "common.h"
+#include "dhcpd.h"
+
+
+/* Takes the address of the pointer to the static_leases linked list,
+ *   Address to a 6 byte mac address
+ *   Address to a 4 byte ip address */
+int addStaticLease(struct static_lease **lease_struct, uint8_t *mac, uint32_t *ip)
+{
+	struct static_lease *cur;
+	struct static_lease *new_static_lease;
+
+	/* Build new node */
+	new_static_lease = xmalloc(sizeof(struct static_lease));
+	new_static_lease->mac = mac;
+	new_static_lease->ip = ip;
+	new_static_lease->next = NULL;
+
+	/* If it's the first node to be added... */
+	if (*lease_struct == NULL) {
+		*lease_struct = new_static_lease;
+	} else {
+		cur = *lease_struct;
+		while (cur->next) {
+			cur = cur->next;
+		}
+
+		cur->next = new_static_lease;
+	}
+
+	return 1;
+}
+
+/* Check to see if a mac has an associated static lease */
+uint32_t getIpByMac(struct static_lease *lease_struct, void *arg)
+{
+	uint32_t return_ip;
+	struct static_lease *cur = lease_struct;
+	uint8_t *mac = arg;
+
+	return_ip = 0;
+
+	while (cur) {
+		/* If the client has the correct mac  */
+		if (memcmp(cur->mac, mac, 6) == 0) {
+			return_ip = *(cur->ip);
+		}
+
+		cur = cur->next;
+	}
+
+	return return_ip;
+}
+
+/* Check to see if an ip is reserved as a static ip */
+uint32_t reservedIp(struct static_lease *lease_struct, uint32_t ip)
+{
+	struct static_lease *cur = lease_struct;
+
+	uint32_t return_val = 0;
+
+	while (cur) {
+		/* If the client has the correct ip  */
+		if (*cur->ip == ip)
+			return_val = 1;
+
+		cur = cur->next;
+	}
+
+	return return_val;
+}
+
+#if ENABLE_FEATURE_UDHCP_DEBUG
+/* Print out static leases just to check what's going on */
+/* Takes the address of the pointer to the static_leases linked list */
+void printStaticLeases(struct static_lease **arg)
+{
+	/* Get a pointer to the linked list */
+	struct static_lease *cur = *arg;
+
+	while (cur) {
+		/* printf("PrintStaticLeases: Lease mac Address: %x\n", cur->mac); */
+		printf("PrintStaticLeases: Lease mac Value: %x\n", *(cur->mac));
+		/* printf("PrintStaticLeases: Lease ip Address: %x\n", cur->ip); */
+		printf("PrintStaticLeases: Lease ip Value: %x\n", *(cur->ip));
+
+		cur = cur->next;
+	}
+}
+#endif
diff --git a/networking/vconfig.c b/networking/vconfig.c
new file mode 100644
index 0000000..003c1a8
--- /dev/null
+++ b/networking/vconfig.c
@@ -0,0 +1,164 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * vconfig implementation for busybox
+ *
+ * Copyright (C) 2001  Manuel Novoa III  <mjn3@codepoet.org>
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ */
+
+/* BB_AUDIT SUSv3 N/A */
+
+#include "busybox.h"
+#include <net/if.h>
+
+/* Stuff from linux/if_vlan.h, kernel version 2.4.23 */
+enum vlan_ioctl_cmds {
+	ADD_VLAN_CMD,
+	DEL_VLAN_CMD,
+	SET_VLAN_INGRESS_PRIORITY_CMD,
+	SET_VLAN_EGRESS_PRIORITY_CMD,
+	GET_VLAN_INGRESS_PRIORITY_CMD,
+	GET_VLAN_EGRESS_PRIORITY_CMD,
+	SET_VLAN_NAME_TYPE_CMD,
+	SET_VLAN_FLAG_CMD
+};
+enum vlan_name_types {
+	VLAN_NAME_TYPE_PLUS_VID, /* Name will look like:  vlan0005 */
+	VLAN_NAME_TYPE_RAW_PLUS_VID, /* name will look like:  eth1.0005 */
+	VLAN_NAME_TYPE_PLUS_VID_NO_PAD, /* Name will look like:  vlan5 */
+	VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD, /* Name will look like:  eth0.5 */
+	VLAN_NAME_TYPE_HIGHEST
+};
+
+struct vlan_ioctl_args {
+	int cmd; /* Should be one of the vlan_ioctl_cmds enum above. */
+	char device1[24];
+
+	union {
+		char device2[24];
+		int VID;
+		unsigned int skb_priority;
+		unsigned int name_type;
+		unsigned int bind_type;
+		unsigned int flag; /* Matches vlan_dev_info flags */
+	} u;
+
+	short vlan_qos;
+};
+
+#define VLAN_GROUP_ARRAY_LEN 4096
+#define SIOCSIFVLAN	0x8983		/* Set 802.1Q VLAN options */
+
+/* On entry, table points to the length of the current string plus
+ * nul terminator plus data length for the subsequent entry.  The
+ * return value is the last data entry for the matching string. */
+static const char *xfind_str(const char *table, const char *str)
+{
+	while (strcasecmp(str, table+1) != 0) {
+		if (!*(table += table[0])) {
+			bb_show_usage();
+		}
+	}
+	return table - 1;
+}
+
+static const char cmds[] = {
+	4, ADD_VLAN_CMD, 7,
+	'a', 'd', 'd', 0,
+	3, DEL_VLAN_CMD, 7,
+	'r', 'e', 'm', 0,
+	3, SET_VLAN_NAME_TYPE_CMD, 17,
+	's', 'e', 't', '_',
+	'n', 'a', 'm', 'e', '_',
+	't', 'y', 'p', 'e', 0,
+	5, SET_VLAN_FLAG_CMD, 12,
+	's', 'e', 't', '_',
+	'f', 'l', 'a', 'g', 0,
+	5, SET_VLAN_EGRESS_PRIORITY_CMD, 18,
+	's', 'e', 't', '_',
+	'e', 'g', 'r', 'e', 's', 's', '_',
+	'm', 'a', 'p', 0,
+	5, SET_VLAN_INGRESS_PRIORITY_CMD, 16,
+	's', 'e', 't', '_',
+	'i', 'n', 'g', 'r', 'e', 's', 's', '_',
+	'm', 'a', 'p', 0,
+};
+
+static const char name_types[] = {
+	VLAN_NAME_TYPE_PLUS_VID, 16,
+	'V', 'L', 'A', 'N',
+	'_', 'P', 'L', 'U', 'S', '_', 'V', 'I', 'D',
+	0,
+	VLAN_NAME_TYPE_PLUS_VID_NO_PAD, 22,
+	'V', 'L', 'A', 'N',
+	'_', 'P', 'L', 'U', 'S', '_', 'V', 'I', 'D',
+	'_', 'N', 'O', '_', 'P', 'A', 'D', 0,
+	VLAN_NAME_TYPE_RAW_PLUS_VID, 15,
+	'D', 'E', 'V',
+	'_', 'P', 'L', 'U', 'S', '_', 'V', 'I', 'D',
+	0,
+	VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD, 20,
+	'D', 'E', 'V',
+	'_', 'P', 'L', 'U', 'S', '_', 'V', 'I', 'D',
+	'_', 'N', 'O', '_', 'P', 'A', 'D', 0,
+};
+
+static const char conf_file_name[] = "/proc/net/vlan/config";
+
+int vconfig_main(int argc, char **argv)
+{
+	struct vlan_ioctl_args ifr;
+	const char *p;
+	int fd;
+
+	if (argc < 3) {
+		bb_show_usage();
+	}
+
+	/* Don't bother closing the filedes.  It will be closed on cleanup. */
+	/* Will die if 802.1q is not present */
+	xopen(conf_file_name, O_RDONLY);
+
+	memset(&ifr, 0, sizeof(struct vlan_ioctl_args));
+
+	++argv;
+	p = xfind_str(cmds+2, *argv);
+	ifr.cmd = *p;
+	if (argc != p[-1]) {
+		bb_show_usage();
+	}
+
+	if (ifr.cmd == SET_VLAN_NAME_TYPE_CMD) { /* set_name_type */
+		ifr.u.name_type = *xfind_str(name_types+1, argv[1]);
+	} else {
+		if (strlen(argv[1]) >= IF_NAMESIZE) {
+			bb_error_msg_and_die("if_name >= %d chars", IF_NAMESIZE);
+		}
+		strcpy(ifr.device1, argv[1]);
+		p = argv[2];
+
+		/* I suppose one could try to combine some of the function calls below,
+		 * since ifr.u.flag, ifr.u.VID, and ifr.u.skb_priority are all same-sized
+		 * (unsigned) int members of a unions.  But because of the range checking,
+		 * doing so wouldn't save that much space and would also make maintainence
+		 * more of a pain. */
+		if (ifr.cmd == SET_VLAN_FLAG_CMD) { /* set_flag */
+			ifr.u.flag = xatoul_range(p, 0, 1);
+			/* DM: in order to set reorder header, qos must be set */
+			ifr.vlan_qos = xatoul_range(argv[3], 0, 7);
+		} else if (ifr.cmd == ADD_VLAN_CMD) { /* add */
+			ifr.u.VID = xatoul_range(p, 0, VLAN_GROUP_ARRAY_LEN-1);
+		} else if (ifr.cmd != DEL_VLAN_CMD) { /* set_{egress|ingress}_map */
+			ifr.u.skb_priority = xatou(p);
+			ifr.vlan_qos = xatoul_range(argv[3], 0, 7);
+		}
+	}
+
+	fd = xsocket(AF_INET, SOCK_STREAM, 0);
+	if (ioctl(fd, SIOCSIFVLAN, &ifr) < 0) {
+		bb_perror_msg_and_die("ioctl error for %s", *argv);
+	}
+
+	return 0;
+}
diff --git a/networking/wget.c b/networking/wget.c
new file mode 100644
index 0000000..028e18c
--- /dev/null
+++ b/networking/wget.c
@@ -0,0 +1,832 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * wget - retrieve a file using HTTP or FTP
+ *
+ * Chip Rosenthal Covad Communications <chip@laserlink.net>
+ *
+ */
+
+/* We want libc to give us xxx64 functions also */
+/* http://www.unix.org/version2/whatsnew/lfs20mar.html */
+#define _LARGEFILE64_SOURCE 1
+
+#include "busybox.h"
+#include <getopt.h>	/* for struct option */
+
+struct host_info {
+	// May be used if we ever will want to free() all xstrdup()s...
+	/* char *allocated; */
+	char *host;
+	int port;
+	char *path;
+	int is_ftp;
+	char *user;
+};
+
+static void parse_url(char *url, struct host_info *h);
+static FILE *open_socket(struct sockaddr_in *s_in);
+static char *gethdr(char *buf, size_t bufsiz, FILE *fp, int *istrunc);
+static int ftpcmd(char *s1, char *s2, FILE *fp, char *buf);
+
+/* Globals (can be accessed from signal handlers */
+static off_t content_len;        /* Content-length of the file */
+static off_t beg_range;          /* Range at which continue begins */
+#if ENABLE_FEATURE_WGET_STATUSBAR
+static off_t transferred;        /* Number of bytes transferred so far */
+#endif
+static int chunked;                     /* chunked transfer encoding */
+#if ENABLE_FEATURE_WGET_STATUSBAR
+static void progressmeter(int flag);
+static char *curfile;                   /* Name of current file being transferred */
+static struct timeval start;            /* Time a transfer started */
+enum {
+	STALLTIME = 5                   /* Seconds when xfer considered "stalled" */
+};
+#else
+static void progressmeter(int flag) {}
+#endif
+
+/* Read NMEMB elements of SIZE bytes into PTR from STREAM.  Returns the
+ * number of elements read, and a short count if an eof or non-interrupt
+ * error is encountered.  */
+static size_t safe_fread(void *ptr, size_t size, size_t nmemb, FILE *stream)
+{
+	size_t ret = 0;
+
+	do {
+		clearerr(stream);
+		ret += fread((char *)ptr + (ret * size), size, nmemb - ret, stream);
+	} while (ret < nmemb && ferror(stream) && errno == EINTR);
+
+	return ret;
+}
+
+/* Read a line or SIZE - 1 bytes into S, whichever is less, from STREAM.
+ * Returns S, or NULL if an eof or non-interrupt error is encountered.  */
+static char *safe_fgets(char *s, int size, FILE *stream)
+{
+	char *ret;
+
+	do {
+		clearerr(stream);
+		ret = fgets(s, size, stream);
+	} while (ret == NULL && ferror(stream) && errno == EINTR);
+
+	return ret;
+}
+
+#if ENABLE_FEATURE_WGET_AUTHENTICATION
+/*
+ *  Base64-encode character string and return the string.
+ */
+static char *base64enc(unsigned char *p, char *buf, int len)
+{
+	bb_uuencode(p, buf, len, bb_uuenc_tbl_base64);
+	return buf;
+}
+#endif
+
+int wget_main(int argc, char **argv)
+{
+	char buf[512];
+	struct host_info server, target;
+	struct sockaddr_in s_in;
+	int n, status;
+	int port;
+	int try = 5;
+	unsigned opt;
+	char *s;
+	char *proxy = 0;
+	char *dir_prefix = NULL;
+#if ENABLE_FEATURE_WGET_LONG_OPTIONS
+	char *extra_headers = NULL;
+	llist_t *headers_llist = NULL;
+#endif
+
+	/* server.allocated = target.allocated = NULL; */
+
+	FILE *sfp = NULL;               /* socket to web/ftp server         */
+	FILE *dfp = NULL;               /* socket to ftp server (data)      */
+	char *fname_out = NULL;         /* where to direct output (-O)      */
+	int got_clen = 0;               /* got content-length: from server  */
+	int output_fd = -1;
+	int use_proxy = 1;              /* Use proxies if env vars are set  */
+	const char *proxy_flag = "on";  /* Use proxies if env vars are set  */
+	const char *user_agent = "Wget";/* Content of the "User-Agent" header field */
+
+	/*
+	 * Crack command line.
+	 */
+	enum {
+		WGET_OPT_CONTINUE   = 0x1,
+		WGET_OPT_QUIET      = 0x2,
+		WGET_OPT_OUTNAME    = 0x4,
+		WGET_OPT_PREFIX     = 0x8,
+		WGET_OPT_PROXY      = 0x10,
+		WGET_OPT_USER_AGENT = 0x20,
+		WGET_OPT_PASSIVE    = 0x40,
+		WGET_OPT_HEADER     = 0x80,
+	};
+#if ENABLE_FEATURE_WGET_LONG_OPTIONS
+	static const struct option wget_long_options[] = {
+		// name, has_arg, flag, val
+		{ "continue",         no_argument, NULL, 'c' },
+		{ "quiet",            no_argument, NULL, 'q' },
+		{ "output-document",  required_argument, NULL, 'O' },
+		{ "directory-prefix", required_argument, NULL, 'P' },
+		{ "proxy",            required_argument, NULL, 'Y' },
+		{ "user-agent",       required_argument, NULL, 'U' },
+		{ "passive-ftp",      no_argument, NULL, 0xff },
+		{ "header",           required_argument, NULL, 0xfe },
+		{ 0, 0, 0, 0 }
+	};
+	applet_long_options = wget_long_options;
+#endif
+	opt_complementary = "-1" USE_FEATURE_WGET_LONG_OPTIONS(":\xfe::");
+	opt = getopt32(argc, argv, "cqO:P:Y:U:",
+				&fname_out, &dir_prefix,
+				&proxy_flag, &user_agent
+				USE_FEATURE_WGET_LONG_OPTIONS(, &headers_llist)
+				);
+	if (strcmp(proxy_flag, "off") == 0) {
+		/* Use the proxy if necessary. */
+		use_proxy = 0;
+	}
+#if ENABLE_FEATURE_WGET_LONG_OPTIONS
+	if (headers_llist) {
+		int size = 1;
+		char *cp;
+		llist_t *ll = headers_llist = rev_llist(headers_llist);
+		while (ll) {
+			size += strlen(ll->data) + 2;
+			ll = ll->link;
+		}
+		extra_headers = cp = xmalloc(size);
+		while (headers_llist) {
+			cp += sprintf(cp, "%s\r\n", headers_llist->data);
+			headers_llist = headers_llist->link;
+		}
+	}
+#endif
+
+	parse_url(argv[optind], &target);
+	server.host = target.host;
+	server.port = target.port;
+
+	/*
+	 * Use the proxy if necessary.
+	 */
+	if (use_proxy) {
+		proxy = getenv(target.is_ftp ? "ftp_proxy" : "http_proxy");
+		if (proxy && *proxy) {
+			parse_url(proxy, &server);
+		} else {
+			use_proxy = 0;
+		}
+	}
+
+	/* Guess an output filename */
+	if (!fname_out) {
+		// Dirty hack. Needed because bb_get_last_path_component
+		// will destroy trailing / by storing '\0' in last byte!
+		if (*target.path && target.path[strlen(target.path)-1] != '/') {
+			fname_out =
+#if ENABLE_FEATURE_WGET_STATUSBAR
+				curfile =
+#endif
+				bb_get_last_path_component(target.path);
+		}
+		if (!fname_out || !fname_out[0]) {
+			fname_out =
+#if ENABLE_FEATURE_WGET_STATUSBAR
+				curfile =
+#endif
+				"index.html";
+		}
+		if (dir_prefix != NULL)
+			fname_out = concat_path_file(dir_prefix, fname_out);
+#if ENABLE_FEATURE_WGET_STATUSBAR
+	} else {
+		curfile = bb_get_last_path_component(fname_out);
+#endif
+	}
+	/* Impossible?
+	if ((opt & WGET_OPT_CONTINUE) && !fname_out)
+		bb_error_msg_and_die("cannot specify continue (-c) without a filename (-O)"); */
+
+	/*
+	 * Determine where to start transfer.
+	 */
+	if (fname_out[0] == '-' && !fname_out[1]) {
+		output_fd = 1;
+		opt &= ~WGET_OPT_CONTINUE;
+	}
+	if (opt & WGET_OPT_CONTINUE) {
+		output_fd = open(fname_out, O_WRONLY);
+		if (output_fd >= 0) {
+			beg_range = xlseek(output_fd, 0, SEEK_END);
+		}
+		/* File doesn't exist. We do not create file here yet.
+		   We are not sure it exists on remove side */
+	}
+
+	/* We want to do exactly _one_ DNS lookup, since some
+	 * sites (i.e. ftp.us.debian.org) use round-robin DNS
+	 * and we want to connect to only one IP... */
+	bb_lookup_host(&s_in, server.host);
+	s_in.sin_port = server.port;
+	if (!(opt & WGET_OPT_QUIET)) {
+		fprintf(stderr, "Connecting to %s[%s]:%d\n",
+				server.host, inet_ntoa(s_in.sin_addr), ntohs(server.port));
+	}
+
+	if (use_proxy || !target.is_ftp) {
+		/*
+		 *  HTTP session
+		 */
+		do {
+			got_clen = chunked = 0;
+
+			if (!--try)
+				bb_error_msg_and_die("too many redirections");
+
+			/*
+			 * Open socket to http server
+			 */
+			if (sfp) fclose(sfp);
+			sfp = open_socket(&s_in);
+
+			/*
+			 * Send HTTP request.
+			 */
+			if (use_proxy) {
+				const char *format = "GET %stp://%s:%d/%s HTTP/1.1\r\n";
+#if ENABLE_FEATURE_WGET_IP6_LITERAL
+				if (strchr(target.host, ':'))
+					format = "GET %stp://[%s]:%d/%s HTTP/1.1\r\n";
+#endif
+				fprintf(sfp, format,
+					target.is_ftp ? "f" : "ht", target.host,
+					ntohs(target.port), target.path);
+			} else {
+				fprintf(sfp, "GET /%s HTTP/1.1\r\n", target.path);
+			}
+
+			fprintf(sfp, "Host: %s\r\nUser-Agent: %s\r\n", target.host,
+			        user_agent);
+
+#if ENABLE_FEATURE_WGET_AUTHENTICATION
+			if (target.user) {
+				fprintf(sfp, "Authorization: Basic %s\r\n",
+					base64enc((unsigned char*)target.user, buf, sizeof(buf)));
+			}
+			if (use_proxy && server.user) {
+				fprintf(sfp, "Proxy-Authorization: Basic %s\r\n",
+					base64enc((unsigned char*)server.user, buf, sizeof(buf)));
+			}
+#endif
+
+			if (beg_range)
+				fprintf(sfp, "Range: bytes=%"OFF_FMT"d-\r\n", beg_range);
+#if ENABLE_FEATURE_WGET_LONG_OPTIONS
+			if (extra_headers)
+				fputs(extra_headers, sfp);
+#endif
+			fprintf(sfp, "Connection: close\r\n\r\n");
+
+			/*
+			* Retrieve HTTP response line and check for "200" status code.
+			*/
+ read_response:
+			if (fgets(buf, sizeof(buf), sfp) == NULL)
+				bb_error_msg_and_die("no response from server");
+
+			s = buf;
+			while (*s != '\0' && !isspace(*s)) ++s;
+			s = skip_whitespace(s);
+			// FIXME: no error check
+			// xatou wouldn't work: "200 OK"
+			status = atoi(s);
+			switch (status) {
+			case 0:
+			case 100:
+				while (gethdr(buf, sizeof(buf), sfp, &n) != NULL)
+					/* eat all remaining headers */;
+				goto read_response;
+			case 200:
+				break;
+			case 300:	/* redirection */
+			case 301:
+			case 302:
+			case 303:
+				break;
+			case 206:
+				if (beg_range)
+					break;
+				/*FALLTHRU*/
+			default:
+				/* Show first line only and kill any ESC tricks */
+				buf[strcspn(buf, "\n\r\x1b")] = '\0';
+				bb_error_msg_and_die("server returned error: %s", buf);
+			}
+
+			/*
+			 * Retrieve HTTP headers.
+			 */
+			while ((s = gethdr(buf, sizeof(buf), sfp, &n)) != NULL) {
+				if (strcasecmp(buf, "content-length") == 0) {
+					content_len = BB_STRTOOFF(s, NULL, 10);
+					if (errno || content_len < 0) {
+						bb_error_msg_and_die("content-length %s is garbage", s);
+					}
+					got_clen = 1;
+					continue;
+				}
+				if (strcasecmp(buf, "transfer-encoding") == 0) {
+					if (strcasecmp(s, "chunked") != 0)
+						bb_error_msg_and_die("server wants to do %s transfer encoding", s);
+					chunked = got_clen = 1;
+				}
+				if (strcasecmp(buf, "location") == 0) {
+					if (s[0] == '/')
+						/* free(target.allocated); */
+						target.path = /* target.allocated = */ xstrdup(s+1);
+					else {
+						parse_url(s, &target);
+						if (use_proxy == 0) {
+							server.host = target.host;
+							server.port = target.port;
+						}
+						bb_lookup_host(&s_in, server.host);
+						s_in.sin_port = server.port;
+						break;
+					}
+				}
+			}
+		} while(status >= 300);
+
+		dfp = sfp;
+
+	} else {
+
+		/*
+		 *  FTP session
+		 */
+		if (!target.user)
+			target.user = xstrdup("anonymous:busybox@");
+
+		sfp = open_socket(&s_in);
+		if (ftpcmd(NULL, NULL, sfp, buf) != 220)
+			bb_error_msg_and_die("%s", buf+4);
+
+		/*
+		 * Splitting username:password pair,
+		 * trying to log in
+		 */
+		s = strchr(target.user, ':');
+		if (s)
+			*(s++) = '\0';
+		switch (ftpcmd("USER ", target.user, sfp, buf)) {
+		case 230:
+			break;
+		case 331:
+			if (ftpcmd("PASS ", s, sfp, buf) == 230)
+				break;
+			/* FALLTHRU (failed login) */
+		default:
+			bb_error_msg_and_die("ftp login: %s", buf+4);
+		}
+
+		ftpcmd("TYPE I", NULL, sfp, buf);
+
+		/*
+		 * Querying file size
+		 */
+		if (ftpcmd("SIZE ", target.path, sfp, buf) == 213) {
+			content_len = BB_STRTOOFF(buf+4, NULL, 10);
+			if (errno || content_len < 0) {
+				bb_error_msg_and_die("SIZE value is garbage");
+			}
+			got_clen = 1;
+		}
+
+		/*
+		 * Entering passive mode
+		 */
+		if (ftpcmd("PASV", NULL, sfp, buf) != 227) {
+ pasv_error:
+			bb_error_msg_and_die("bad response to %s: %s", "PASV", buf);
+		}
+		// Response is "227 garbageN1,N2,N3,N4,P1,P2[)garbage]
+		// Server's IP is N1.N2.N3.N4 (we ignore it)
+		// Server's port for data connection is P1*256+P2
+		s = strrchr(buf, ')');
+		if (s) s[0] = '\0';
+		s = strrchr(buf, ',');
+		if (!s) goto pasv_error;
+		port = xatou_range(s+1, 0, 255);
+		*s = '\0';
+		s = strrchr(buf, ',');
+		if (!s) goto pasv_error;
+		port += xatou_range(s+1, 0, 255) * 256;
+		s_in.sin_port = htons(port);
+		dfp = open_socket(&s_in);
+
+		if (beg_range) {
+			sprintf(buf, "REST %"OFF_FMT"d", beg_range);
+			if (ftpcmd(buf, NULL, sfp, buf) == 350)
+				content_len -= beg_range;
+		}
+
+		if (ftpcmd("RETR ", target.path, sfp, buf) > 150)
+			bb_error_msg_and_die("bad response to RETR: %s", buf);
+	}
+
+
+	/*
+	 * Retrieve file
+	 */
+	if (chunked) {
+		fgets(buf, sizeof(buf), dfp);
+		content_len = STRTOOFF(buf, NULL, 16);
+		/* FIXME: error check?? */
+	}
+
+	/* Do it before progressmeter (want to have nice error message) */
+	if (output_fd < 0)
+		output_fd = xopen(fname_out,
+			O_WRONLY|O_CREAT|O_EXCL|O_TRUNC);
+
+	if (!(opt & WGET_OPT_QUIET))
+		progressmeter(-1);
+
+	do {
+		while (content_len > 0 || !got_clen) {
+			unsigned rdsz = sizeof(buf);
+			if (content_len < sizeof(buf) && (chunked || got_clen))
+				rdsz = (unsigned)content_len;
+			n = safe_fread(buf, 1, rdsz, dfp);
+			if (n <= 0)
+				break;
+			if (full_write(output_fd, buf, n) != n) {
+				bb_perror_msg_and_die(bb_msg_write_error);
+			}
+#if ENABLE_FEATURE_WGET_STATUSBAR
+			transferred += n;
+#endif
+			if (got_clen) {
+				content_len -= n;
+			}
+		}
+
+		if (chunked) {
+			safe_fgets(buf, sizeof(buf), dfp); /* This is a newline */
+			safe_fgets(buf, sizeof(buf), dfp);
+			content_len = STRTOOFF(buf, NULL, 16);
+			/* FIXME: error check? */
+			if (content_len == 0) {
+				chunked = 0; /* all done! */
+			}
+		}
+
+		if (n == 0 && ferror(dfp)) {
+			bb_perror_msg_and_die(bb_msg_read_error);
+		}
+	} while (chunked);
+
+	if (!(opt & WGET_OPT_QUIET))
+		progressmeter(1);
+
+	if ((use_proxy == 0) && target.is_ftp) {
+		fclose(dfp);
+		if (ftpcmd(NULL, NULL, sfp, buf) != 226)
+			bb_error_msg_and_die("ftp error: %s", buf+4);
+		ftpcmd("QUIT", NULL, sfp, buf);
+	}
+	exit(EXIT_SUCCESS);
+}
+
+
+static void parse_url(char *src_url, struct host_info *h)
+{
+	char *url, *p, *cp, *sp, *up, *pp;
+
+	/* h->allocated = */ url = xstrdup(src_url);
+
+	if (strncmp(url, "http://", 7) == 0) {
+		h->port = bb_lookup_port("http", "tcp", 80);
+		h->host = url + 7;
+		h->is_ftp = 0;
+	} else if (strncmp(url, "ftp://", 6) == 0) {
+		h->port = bb_lookup_port("ftp", "tcp", 21);
+		h->host = url + 6;
+		h->is_ftp = 1;
+	} else
+		bb_error_msg_and_die("not an http or ftp url: %s", url);
+
+	// FYI:
+	// "Real" wget 'http://busybox.net?var=a/b' sends this request:
+	//   'GET /?var=a/b HTTP 1.0'
+	//   and saves 'index.html?var=a%2Fb' (we save 'b')
+	// wget 'http://busybox.net?login=john@doe':
+	//   request: 'GET /?login=john@doe HTTP/1.0'
+	//   saves: 'index.html?login=john@doe' (we save '?login=john@doe')
+	// wget 'http://busybox.net#test/test':
+	//   request: 'GET / HTTP/1.0'
+	//   saves: 'index.html' (we save 'test')
+	//
+	// We also don't add unique .N suffix if file exists...
+	sp = strchr(h->host, '/');
+	p = strchr(h->host, '?'); if (!sp || (p && sp > p)) sp = p;
+	p = strchr(h->host, '#'); if (!sp || (p && sp > p)) sp = p;
+	if (!sp) {
+		h->path = "";
+	} else if (*sp == '/') {
+		*sp++ = '\0';
+		h->path = sp;
+	} else { // '#' or '?'
+		// http://busybox.net?login=john@doe is a valid URL
+		// memmove converts to:
+		// http:/busybox.nett?login=john@doe...
+		memmove(h->host-1, h->host, sp - h->host);
+		h->host--;
+		sp[-1] = '\0';
+		h->path = sp;
+	}
+
+	up = strrchr(h->host, '@');
+	if (up != NULL) {
+		h->user = h->host;
+		*up++ = '\0';
+		h->host = up;
+	} else
+		h->user = NULL;
+
+	pp = h->host;
+
+#if ENABLE_FEATURE_WGET_IP6_LITERAL
+	if (h->host[0] == '[') {
+		char *ep;
+
+		ep = h->host + 1;
+		while (*ep == ':' || isxdigit(*ep))
+			ep++;
+		if (*ep == ']') {
+			h->host++;
+			*ep = '\0';
+			pp = ep + 1;
+		}
+	}
+#endif
+
+	cp = strchr(pp, ':');
+	if (cp != NULL) {
+		*cp++ = '\0';
+		h->port = htons(xatou16(cp));
+	}
+}
+
+
+static FILE *open_socket(struct sockaddr_in *s_in)
+{
+	FILE *fp;
+
+	/* glibc 2.4 seems to try seeking on it - ??! */
+	/* hopefully it understands what ESPIPE means... */
+	fp = fdopen(xconnect_tcp_v4(s_in), "r+");
+	if (fp == NULL)
+		bb_perror_msg_and_die("fdopen");
+
+	return fp;
+}
+
+
+static char *gethdr(char *buf, size_t bufsiz, FILE *fp, int *istrunc)
+{
+	char *s, *hdrval;
+	int c;
+
+	*istrunc = 0;
+
+	/* retrieve header line */
+	if (fgets(buf, bufsiz, fp) == NULL)
+		return NULL;
+
+	/* see if we are at the end of the headers */
+	for (s = buf; *s == '\r'; ++s)
+		;
+	if (s[0] == '\n')
+		return NULL;
+
+	/* convert the header name to lower case */
+	for (s = buf; isalnum(*s) || *s == '-'; ++s)
+		*s = tolower(*s);
+
+	/* verify we are at the end of the header name */
+	if (*s != ':')
+		bb_error_msg_and_die("bad header line: %s", buf);
+
+	/* locate the start of the header value */
+	for (*s++ = '\0'; *s == ' ' || *s == '\t'; ++s)
+		;
+	hdrval = s;
+
+	/* locate the end of header */
+	while (*s != '\0' && *s != '\r' && *s != '\n')
+		++s;
+
+	/* end of header found */
+	if (*s != '\0') {
+		*s = '\0';
+		return hdrval;
+	}
+
+	/* Rats!  The buffer isn't big enough to hold the entire header value. */
+	while (c = getc(fp), c != EOF && c != '\n')
+		;
+	*istrunc = 1;
+	return hdrval;
+}
+
+static int ftpcmd(char *s1, char *s2, FILE *fp, char *buf)
+{
+	int result;
+	if (s1) {
+		if (!s2) s2 = "";
+		fprintf(fp, "%s%s\r\n", s1, s2);
+		fflush(fp);
+	}
+
+	do {
+		char *buf_ptr;
+
+		if (fgets(buf, 510, fp) == NULL) {
+			bb_perror_msg_and_die("error getting response");
+		}
+		buf_ptr = strstr(buf, "\r\n");
+		if (buf_ptr) {
+			*buf_ptr = '\0';
+		}
+	} while (!isdigit(buf[0]) || buf[3] != ' ');
+
+	buf[3] = '\0';
+	result = xatoi_u(buf);
+	buf[3] = ' ';
+	return result;
+}
+
+#if ENABLE_FEATURE_WGET_STATUSBAR
+/* Stuff below is from BSD rcp util.c, as added to openshh.
+ * Original copyright notice is retained at the end of this file.
+ */
+static int
+getttywidth(void)
+{
+	int width;
+	get_terminal_width_height(0, &width, NULL);
+	return width;
+}
+
+static void
+updateprogressmeter(int ignore)
+{
+	int save_errno = errno;
+
+	progressmeter(0);
+	errno = save_errno;
+}
+
+static void alarmtimer(int iwait)
+{
+	struct itimerval itv;
+
+	itv.it_value.tv_sec = iwait;
+	itv.it_value.tv_usec = 0;
+	itv.it_interval = itv.it_value;
+	setitimer(ITIMER_REAL, &itv, NULL);
+}
+
+
+static void
+progressmeter(int flag)
+{
+	static struct timeval lastupdate;
+	static off_t lastsize, totalsize;
+
+	struct timeval now, td, tvwait;
+	off_t abbrevsize;
+	int elapsed, ratio, barlength, i;
+	char buf[256];
+
+	if (flag == -1) { /* first call to progressmeter */
+		gettimeofday(&start, (struct timezone *) 0);
+		lastupdate = start;
+		lastsize = 0;
+		totalsize = content_len + beg_range; /* as content_len changes.. */
+	}
+
+	gettimeofday(&now, (struct timezone *) 0);
+	ratio = 100;
+	if (totalsize != 0 && !chunked) {
+		/* long long helps to have working ETA even if !LFS */
+		ratio = (int) (100 * (unsigned long long)(transferred+beg_range) / totalsize);
+		ratio = MIN(ratio, 100);
+	}
+
+	fprintf(stderr, "\r%-20.20s%4d%% ", curfile, ratio);
+
+	barlength = getttywidth() - 51;
+	if (barlength > 0 && barlength < sizeof(buf)) {
+		i = barlength * ratio / 100;
+		memset(buf, '*', i);
+		memset(buf + i, ' ', barlength - i);
+		buf[barlength] = '\0';
+		fprintf(stderr, "|%s|", buf);
+	}
+	i = 0;
+	abbrevsize = transferred + beg_range;
+	while (abbrevsize >= 100000) {
+		i++;
+		abbrevsize >>= 10;
+	}
+	/* see http://en.wikipedia.org/wiki/Tera */
+	fprintf(stderr, "%6d %c%c ", (int)abbrevsize, " KMGTPEZY"[i], i?'B':' ');
+
+	timersub(&now, &lastupdate, &tvwait);
+	if (transferred > lastsize) {
+		lastupdate = now;
+		lastsize = transferred;
+		if (tvwait.tv_sec >= STALLTIME)
+			timeradd(&start, &tvwait, &start);
+		tvwait.tv_sec = 0;
+	}
+	timersub(&now, &start, &td);
+	elapsed = td.tv_sec;
+
+	if (tvwait.tv_sec >= STALLTIME) {
+		fprintf(stderr, " - stalled -");
+	} else {
+		off_t to_download = totalsize - beg_range;
+		if (transferred <= 0 || elapsed <= 0 || transferred > to_download || chunked) {
+			fprintf(stderr, "--:--:-- ETA");
+		} else {
+			/* to_download / (transferred/elapsed) - elapsed: */
+			int eta = (int) ((unsigned long long)to_download*elapsed/transferred - elapsed);
+			/* (long long helps to have working ETA even if !LFS) */
+			i = eta % 3600;
+			fprintf(stderr, "%02d:%02d:%02d ETA", eta / 3600, i / 60, i % 60);
+		}
+	}
+
+	if (flag == -1) { /* first call to progressmeter */
+		struct sigaction sa;
+		sa.sa_handler = updateprogressmeter;
+		sigemptyset(&sa.sa_mask);
+		sa.sa_flags = SA_RESTART;
+		sigaction(SIGALRM, &sa, NULL);
+		alarmtimer(1);
+	} else if (flag == 1) { /* last call to progressmeter */
+		alarmtimer(0);
+		transferred = 0;
+		putc('\n', stderr);
+	}
+}
+#endif
+
+/* Original copyright notice which applies to the CONFIG_FEATURE_WGET_STATUSBAR stuff,
+ * much of which was blatantly stolen from openssh.  */
+
+/*-
+ * Copyright (c) 1992, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * 3. <BSD Advertising Clause omitted per the July 22, 1999 licensing change
+ *		ftp://ftp.cs.berkeley.edu/pub/4bsd/README.Impt.License.Change>
+ *
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *	$Id: wget.c,v 1.75 2004/10/08 08:27:40 andersen Exp $
+ */
diff --git a/networking/zcip.c b/networking/zcip.c
new file mode 100644
index 0000000..27e281c
--- /dev/null
+++ b/networking/zcip.c
@@ -0,0 +1,546 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * RFC3927 ZeroConf IPv4 Link-Local addressing
+ * (see <http://www.zeroconf.org/>)
+ *
+ * Copyright (C) 2003 by Arthur van Hoff (avh@strangeberry.com)
+ * Copyright (C) 2004 by David Brownell
+ *
+ * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+ */
+
+/*
+ * ZCIP just manages the 169.254.*.* addresses.  That network is not
+ * routed at the IP level, though various proxies or bridges can
+ * certainly be used.  Its naming is built over multicast DNS.
+ */
+
+//#define DEBUG
+
+// TODO:
+// - more real-world usage/testing, especially daemon mode
+// - kernel packet filters to reduce scheduling noise
+// - avoid silent script failures, especially under load...
+// - link status monitoring (restart on link-up; stop on link-down)
+
+#include "busybox.h"
+#include <syslog.h>
+#include <poll.h>
+#include <sys/wait.h>
+#include <netinet/ether.h>
+#include <net/ethernet.h>
+#include <net/if.h>
+#include <net/if_arp.h>
+
+#include <linux/if_packet.h>
+#include <linux/sockios.h>
+
+
+struct arp_packet {
+	struct ether_header hdr;
+	struct ether_arp arp;
+} ATTRIBUTE_PACKED;
+
+enum {
+/* 169.254.0.0 */
+	LINKLOCAL_ADDR = 0xa9fe0000,
+
+/* protocol timeout parameters, specified in seconds */
+	PROBE_WAIT = 1,
+	PROBE_MIN = 1,
+	PROBE_MAX = 2,
+	PROBE_NUM = 3,
+	MAX_CONFLICTS = 10,
+	RATE_LIMIT_INTERVAL = 60,
+	ANNOUNCE_WAIT = 2,
+	ANNOUNCE_NUM = 2,
+	ANNOUNCE_INTERVAL = 2,
+	DEFEND_INTERVAL = 10
+};
+
+/* States during the configuration process. */
+enum {
+	PROBE = 0,
+	RATE_LIMIT_PROBE,
+	ANNOUNCE,
+	MONITOR,
+	DEFEND
+};
+
+#define VDBG(fmt,args...) \
+	do { } while (0)
+
+static unsigned opts;
+#define FOREGROUND (opts & 1)
+#define QUIT (opts & 2)
+
+/**
+ * Pick a random link local IP address on 169.254/16, except that
+ * the first and last 256 addresses are reserved.
+ */
+static void pick(struct in_addr *ip)
+{
+	unsigned tmp;
+
+	/* use cheaper math than lrand48() mod N */
+	do {
+		tmp = (lrand48() >> 16) & IN_CLASSB_HOST;
+	} while (tmp > (IN_CLASSB_HOST - 0x0200));
+	ip->s_addr = htonl((LINKLOCAL_ADDR + 0x0100) + tmp);
+}
+
+/* TODO: we need a flag to direct bb_[p]error_msg output to stderr. */
+
+/**
+ * Broadcast an ARP packet.
+ */
+static void arp(int fd, struct sockaddr *saddr, int op,
+	const struct ether_addr *source_addr, struct in_addr source_ip,
+	const struct ether_addr *target_addr, struct in_addr target_ip)
+{
+	struct arp_packet p;
+	memset(&p, 0, sizeof(p));
+
+	// ether header
+	p.hdr.ether_type = htons(ETHERTYPE_ARP);
+	memcpy(p.hdr.ether_shost, source_addr, ETH_ALEN);
+	memset(p.hdr.ether_dhost, 0xff, ETH_ALEN);
+
+	// arp request
+	p.arp.arp_hrd = htons(ARPHRD_ETHER);
+	p.arp.arp_pro = htons(ETHERTYPE_IP);
+	p.arp.arp_hln = ETH_ALEN;
+	p.arp.arp_pln = 4;
+	p.arp.arp_op = htons(op);
+	memcpy(&p.arp.arp_sha, source_addr, ETH_ALEN);
+	memcpy(&p.arp.arp_spa, &source_ip, sizeof (p.arp.arp_spa));
+	memcpy(&p.arp.arp_tha, target_addr, ETH_ALEN);
+	memcpy(&p.arp.arp_tpa, &target_ip, sizeof (p.arp.arp_tpa));
+
+	// send it
+	if (sendto(fd, &p, sizeof (p), 0, saddr, sizeof (*saddr)) < 0) {
+		bb_perror_msg("sendto");
+		//return -errno;
+	}
+	// Currently all callers ignore errors, that's why returns are
+	// commented out...
+	//return 0;
+}
+
+/**
+ * Run a script.
+ */
+static int run(char *script, char *arg, char *intf, struct in_addr *ip)
+{
+	int pid, status;
+	char *why;
+
+	if(1) { //always true: if (script != NULL)
+		VDBG("%s run %s %s\n", intf, script, arg);
+		if (ip != NULL) {
+			char *addr = inet_ntoa(*ip);
+			setenv("ip", addr, 1);
+			bb_info_msg("%s %s %s", arg, intf, addr);
+		}
+
+		pid = vfork();
+		if (pid < 0) {			// error
+			why = "vfork";
+			goto bad;
+		} else if (pid == 0) {		// child
+			execl(script, script, arg, NULL);
+			bb_perror_msg("execl");
+			_exit(EXIT_FAILURE);
+		}
+
+		if (waitpid(pid, &status, 0) <= 0) {
+			why = "waitpid";
+			goto bad;
+		}
+		if (WEXITSTATUS(status) != 0) {
+			bb_error_msg("script %s failed, exit=%d",
+				script, WEXITSTATUS(status));
+			return -errno;
+		}
+	}
+	return 0;
+bad:
+	status = -errno;
+	bb_perror_msg("%s %s, %s", arg, intf, why);
+	return status;
+}
+
+
+/**
+ * Return milliseconds of random delay, up to "secs" seconds.
+ */
+static unsigned ATTRIBUTE_ALWAYS_INLINE ms_rdelay(unsigned secs)
+{
+	return lrand48() % (secs * 1000);
+}
+
+/**
+ * main program
+ */
+
+/* Used to be auto variables on main() stack, but
+ * most of them were zero-inited. Moving them to bss
+ * is more space-efficient.
+ */
+static	const struct in_addr null_ip; // = { 0 };
+static	const struct ether_addr null_addr; // = { {0, 0, 0, 0, 0, 0} };
+
+static	struct sockaddr saddr; // memset(0);
+static	struct in_addr ip; // = { 0 };
+static	struct ifreq ifr; //memset(0);
+
+static	char *intf; // = NULL;
+static	char *script; // = NULL;
+static	suseconds_t timeout; // = 0;	// milliseconds
+static	unsigned conflicts; // = 0;
+static	unsigned nprobes; // = 0;
+static	unsigned nclaims; // = 0;
+static	int ready; // = 0;
+static	int verbose; // = 0;
+static	int state = PROBE;
+
+int zcip_main(int argc, char *argv[])
+{
+	struct ether_addr eth_addr;
+	char *why;
+	int fd;
+
+	// parse commandline: prog [options] ifname script
+	char *r_opt;
+	opt_complementary = "vv:vf"; // -v accumulates and implies -f
+	opts = getopt32(argc, argv, "fqr:v", &r_opt, &verbose);
+	if (!FOREGROUND) {
+		/* Do it early, before all bb_xx_msg calls */
+		logmode = LOGMODE_SYSLOG;
+		openlog(applet_name, 0, LOG_DAEMON);
+	}
+	if (opts & 4) { // -r n.n.n.n
+		if (inet_aton(r_opt, &ip) == 0
+		|| (ntohl(ip.s_addr) & IN_CLASSB_NET) != LINKLOCAL_ADDR) {
+			bb_error_msg_and_die("invalid link address");
+		}
+	}
+	argc -= optind;
+	argv += optind;
+	if (argc != 2)
+		bb_show_usage();
+	intf = argv[0];
+	script = argv[1];
+	setenv("interface", intf, 1);
+
+	// initialize the interface (modprobe, ifup, etc)
+	if (run(script, "init", intf, NULL) < 0)
+		return EXIT_FAILURE;
+
+	// initialize saddr
+	//memset(&saddr, 0, sizeof (saddr));
+	safe_strncpy(saddr.sa_data, intf, sizeof (saddr.sa_data));
+
+	// open an ARP socket
+	fd = xsocket(PF_PACKET, SOCK_PACKET, htons(ETH_P_ARP));
+	// bind to the interface's ARP socket
+	xbind(fd, &saddr, sizeof (saddr));
+
+	// get the interface's ethernet address
+	//memset(&ifr, 0, sizeof (ifr));
+	strncpy(ifr.ifr_name, intf, sizeof (ifr.ifr_name));
+	if (ioctl(fd, SIOCGIFHWADDR, &ifr) < 0) {
+		bb_perror_msg_and_die("get ethernet address");
+	}
+	memcpy(&eth_addr, &ifr.ifr_hwaddr.sa_data, ETH_ALEN);
+
+	// start with some stable ip address, either a function of
+	// the hardware address or else the last address we used.
+	// NOTE: the sequence of addresses we try changes only
+	// depending on when we detect conflicts.
+	// (SVID 3 bogon: who says that "short" is always 16 bits?)
+	seed48( (unsigned short*)&ifr.ifr_hwaddr.sa_data );
+	if (ip.s_addr == 0)
+		pick(&ip);
+
+	// FIXME cases to handle:
+	//  - zcip already running!
+	//  - link already has local address... just defend/update
+
+	// daemonize now; don't delay system startup
+	if (!FOREGROUND) {
+		setsid();
+		xdaemon(0, 0);
+		bb_info_msg("start, interface %s", intf);
+	}
+
+	// run the dynamic address negotiation protocol,
+	// restarting after address conflicts:
+	//  - start with some address we want to try
+	//  - short random delay
+	//  - arp probes to see if another host else uses it
+	//  - arp announcements that we're claiming it
+	//  - use it
+	//  - defend it, within limits
+	while (1) {
+		struct pollfd fds[1];
+		struct timeval tv1;
+		struct arp_packet p;
+
+		int source_ip_conflict = 0;
+		int target_ip_conflict = 0;
+
+		fds[0].fd = fd;
+		fds[0].events = POLLIN;
+		fds[0].revents = 0;
+
+		// poll, being ready to adjust current timeout
+		if (!timeout) {
+			timeout = ms_rdelay(PROBE_WAIT);
+			// FIXME setsockopt(fd, SO_ATTACH_FILTER, ...) to
+			// make the kernel filter out all packets except
+			// ones we'd care about.
+		}
+		// set tv1 to the point in time when we timeout
+		gettimeofday(&tv1, NULL);
+		tv1.tv_usec += (timeout % 1000) * 1000;
+		while (tv1.tv_usec > 1000000) {
+			tv1.tv_usec -= 1000000;
+			tv1.tv_sec++;
+		}
+		tv1.tv_sec += timeout / 1000;
+
+		VDBG("...wait %ld %s nprobes=%d, nclaims=%d\n",
+				timeout, intf, nprobes, nclaims);
+		switch (poll(fds, 1, timeout)) {
+
+		// timeout
+		case 0:
+			VDBG("state = %d\n", state);
+			switch (state) {
+			case PROBE:
+				// timeouts in the PROBE state mean no conflicting ARP packets
+				// have been received, so we can progress through the states
+				if (nprobes < PROBE_NUM) {
+					nprobes++;
+					VDBG("probe/%d %s@%s\n",
+							nprobes, intf, inet_ntoa(ip));
+					arp(fd, &saddr, ARPOP_REQUEST,
+							&eth_addr, null_ip,
+							&null_addr, ip);
+					timeout = PROBE_MIN * 1000;
+					timeout += ms_rdelay(PROBE_MAX
+							- PROBE_MIN);
+				}
+				else {
+					// Switch to announce state.
+					state = ANNOUNCE;
+					nclaims = 0;
+					VDBG("announce/%d %s@%s\n",
+							nclaims, intf, inet_ntoa(ip));
+					arp(fd, &saddr, ARPOP_REQUEST,
+							&eth_addr, ip,
+							&eth_addr, ip);
+					timeout = ANNOUNCE_INTERVAL * 1000;
+				}
+				break;
+			case RATE_LIMIT_PROBE:
+				// timeouts in the RATE_LIMIT_PROBE state mean no conflicting ARP packets
+				// have been received, so we can move immediately to the announce state
+				state = ANNOUNCE;
+				nclaims = 0;
+				VDBG("announce/%d %s@%s\n",
+						nclaims, intf, inet_ntoa(ip));
+				arp(fd, &saddr, ARPOP_REQUEST,
+						&eth_addr, ip,
+						&eth_addr, ip);
+				timeout = ANNOUNCE_INTERVAL * 1000;
+				break;
+			case ANNOUNCE:
+				// timeouts in the ANNOUNCE state mean no conflicting ARP packets
+				// have been received, so we can progress through the states
+				if (nclaims < ANNOUNCE_NUM) {
+					nclaims++;
+					VDBG("announce/%d %s@%s\n",
+							nclaims, intf, inet_ntoa(ip));
+					arp(fd, &saddr, ARPOP_REQUEST,
+							&eth_addr, ip,
+							&eth_addr, ip);
+					timeout = ANNOUNCE_INTERVAL * 1000;
+				}
+				else {
+					// Switch to monitor state.
+					state = MONITOR;
+					// link is ok to use earlier
+					// FIXME update filters
+					run(script, "config", intf, &ip);
+					ready = 1;
+					conflicts = 0;
+					timeout = -1; // Never timeout in the monitor state.
+
+					// NOTE: all other exit paths
+					// should deconfig ...
+					if (QUIT)
+						return EXIT_SUCCESS;
+				}
+				break;
+			case DEFEND:
+				// We won!  No ARP replies, so just go back to monitor.
+				state = MONITOR;
+				timeout = -1;
+				conflicts = 0;
+				break;
+			default:
+				// Invalid, should never happen.  Restart the whole protocol.
+				state = PROBE;
+				pick(&ip);
+				timeout = 0;
+				nprobes = 0;
+				nclaims = 0;
+				break;
+			} // switch (state)
+			break; // case 0 (timeout)
+		// packets arriving
+		case 1:
+			// We need to adjust the timeout in case we didn't receive
+			// a conflicting packet.
+			if (timeout > 0) {
+				struct timeval tv2;
+
+				gettimeofday(&tv2, NULL);
+				if (timercmp(&tv1, &tv2, <)) {
+					// Current time is greater than the expected timeout time.
+					// Should never happen.
+					VDBG("missed an expected timeout\n");
+					timeout = 0;
+				} else {
+					VDBG("adjusting timeout\n");
+					timersub(&tv1, &tv2, &tv1);
+					timeout = 1000 * tv1.tv_sec
+							+ tv1.tv_usec / 1000;
+				}
+			}
+
+			if ((fds[0].revents & POLLIN) == 0) {
+				if (fds[0].revents & POLLERR) {
+					// FIXME: links routinely go down;
+					// this shouldn't necessarily exit.
+					bb_error_msg("%s: poll error", intf);
+					if (ready) {
+						run(script, "deconfig",
+								intf, &ip);
+					}
+					return EXIT_FAILURE;
+				}
+				continue;
+			}
+
+			// read ARP packet
+			if (recv(fd, &p, sizeof (p), 0) < 0) {
+				why = "recv";
+				goto bad;
+			}
+			if (p.hdr.ether_type != htons(ETHERTYPE_ARP))
+				continue;
+
+#ifdef DEBUG
+			{
+				struct ether_addr * sha = (struct ether_addr *) p.arp.arp_sha;
+				struct ether_addr * tha = (struct ether_addr *) p.arp.arp_tha;
+				struct in_addr * spa = (struct in_addr *) p.arp.arp_spa;
+				struct in_addr * tpa = (struct in_addr *) p.arp.arp_tpa;
+				VDBG("%s recv arp type=%d, op=%d,\n",
+					intf, ntohs(p.hdr.ether_type),
+					ntohs(p.arp.arp_op));
+				VDBG("\tsource=%s %s\n",
+					ether_ntoa(sha),
+					inet_ntoa(*spa));
+				VDBG("\ttarget=%s %s\n",
+					ether_ntoa(tha),
+					inet_ntoa(*tpa));
+			}
+#endif
+			if (p.arp.arp_op != htons(ARPOP_REQUEST)
+					&& p.arp.arp_op != htons(ARPOP_REPLY))
+				continue;
+
+			if (memcmp(p.arp.arp_spa, &ip.s_addr, sizeof(struct in_addr)) == 0 &&
+				memcmp(&eth_addr, &p.arp.arp_sha, ETH_ALEN) != 0) {
+				source_ip_conflict = 1;
+			}
+			if (memcmp(p.arp.arp_tpa, &ip.s_addr, sizeof(struct in_addr)) == 0 &&
+				p.arp.arp_op == htons(ARPOP_REQUEST) &&
+				memcmp(&eth_addr, &p.arp.arp_tha, ETH_ALEN) != 0) {
+				target_ip_conflict = 1;
+			}
+
+			VDBG("state = %d, source ip conflict = %d, target ip conflict = %d\n",
+				state, source_ip_conflict, target_ip_conflict);
+			switch (state) {
+			case PROBE:
+			case ANNOUNCE:
+				// When probing or announcing, check for source IP conflicts
+				// and other hosts doing ARP probes (target IP conflicts).
+				if (source_ip_conflict || target_ip_conflict) {
+					conflicts++;
+					if (conflicts >= MAX_CONFLICTS) {
+						VDBG("%s ratelimit\n", intf);
+						timeout = RATE_LIMIT_INTERVAL * 1000;
+						state = RATE_LIMIT_PROBE;
+					}
+
+					// restart the whole protocol
+					pick(&ip);
+					timeout = 0;
+					nprobes = 0;
+					nclaims = 0;
+				}
+				break;
+			case MONITOR:
+				// If a conflict, we try to defend with a single ARP probe.
+				if (source_ip_conflict) {
+					VDBG("monitor conflict -- defending\n");
+					state = DEFEND;
+					timeout = DEFEND_INTERVAL * 1000;
+					arp(fd, &saddr,
+							ARPOP_REQUEST,
+							&eth_addr, ip,
+							&eth_addr, ip);
+				}
+				break;
+			case DEFEND:
+				// Well, we tried.  Start over (on conflict).
+				if (source_ip_conflict) {
+					state = PROBE;
+					VDBG("defend conflict -- starting over\n");
+					ready = 0;
+					run(script, "deconfig", intf, &ip);
+
+					// restart the whole protocol
+					pick(&ip);
+					timeout = 0;
+					nprobes = 0;
+					nclaims = 0;
+				}
+				break;
+			default:
+				// Invalid, should never happen.  Restart the whole protocol.
+				VDBG("invalid state -- starting over\n");
+				state = PROBE;
+				pick(&ip);
+				timeout = 0;
+				nprobes = 0;
+				nclaims = 0;
+				break;
+			} // switch state
+
+			break; // case 1 (packets arriving)
+		default:
+			why = "poll";
+			goto bad;
+		} // switch poll
+	}
+bad:
+	bb_perror_msg("%s, %s", intf, why);
+	return EXIT_FAILURE;
+}