diff --git a/include/applets.src.h b/include/applets.src.h
index 1d2d9c8..3fd9ba0 100644
--- a/include/applets.src.h
+++ b/include/applets.src.h
@@ -76,11 +76,8 @@
 IF_TEST(APPLET_NOFORK([,  test, BB_DIR_USR_BIN, BB_SUID_DROP, test))
 IF_TEST(APPLET_NOFORK([[, test, BB_DIR_USR_BIN, BB_SUID_DROP, test))
 IF_ACPID(APPLET(acpid, BB_DIR_SBIN, BB_SUID_DROP))
-IF_ARP(APPLET(arp, BB_DIR_SBIN, BB_SUID_DROP))
-IF_ARPING(APPLET(arping, BB_DIR_USR_SBIN, BB_SUID_DROP))
 IF_BASENAME(APPLET_NOFORK(basename, basename, BB_DIR_USR_BIN, BB_SUID_DROP, basename))
 IF_BLKID(APPLET(blkid, BB_DIR_SBIN, BB_SUID_DROP))
-IF_BRCTL(APPLET(brctl, BB_DIR_USR_SBIN, BB_SUID_DROP))
 IF_CAL(APPLET(cal, BB_DIR_USR_BIN, BB_SUID_DROP))
 IF_CAT(APPLET_NOFORK(cat, cat, BB_DIR_BIN, BB_SUID_DROP, cat))
 IF_CATV(APPLET(catv, BB_DIR_BIN, BB_SUID_DROP))
@@ -101,7 +98,6 @@
 IF_DHCPRELAY(APPLET(dhcprelay, BB_DIR_USR_SBIN, BB_SUID_DROP))
 IF_DIRNAME(APPLET_NOFORK(dirname, dirname, BB_DIR_USR_BIN, BB_SUID_DROP, dirname))
 IF_DMESG(APPLET(dmesg, BB_DIR_BIN, BB_SUID_DROP))
-IF_DNSD(APPLET(dnsd, BB_DIR_USR_SBIN, BB_SUID_DROP))
 IF_DOS2UNIX(APPLET_NOEXEC(dos2unix, dos2unix, BB_DIR_USR_BIN, BB_SUID_DROP, dos2unix))
 IF_DU(APPLET(du, BB_DIR_USR_BIN, BB_SUID_DROP))
 IF_DUMPKMAP(APPLET(dumpkmap, BB_DIR_BIN, BB_SUID_DROP))
@@ -110,10 +106,8 @@
 //IF_E2LABEL(APPLET_ODDNAME(e2label, tune2fs, BB_DIR_SBIN, BB_SUID_DROP, e2label))
 IF_ECHO(APPLET_NOFORK(echo, echo, BB_DIR_BIN, BB_SUID_DROP, echo))
 IF_ENV(APPLET_NOEXEC(env, env, BB_DIR_USR_BIN, BB_SUID_DROP, env))
-IF_ETHER_WAKE(APPLET_ODDNAME(ether-wake, ether_wake, BB_DIR_USR_SBIN, BB_SUID_DROP, ether_wake))
 IF_EXPAND(APPLET(expand, BB_DIR_USR_BIN, BB_SUID_DROP))
 IF_EXPR(APPLET(expr, BB_DIR_USR_BIN, BB_SUID_DROP))
-IF_FAKEIDENTD(APPLET(fakeidentd, BB_DIR_USR_SBIN, BB_SUID_DROP))
 IF_FALSE(APPLET_NOFORK(false, false, BB_DIR_BIN, BB_SUID_DROP, false))
 IF_FBSET(APPLET(fbset, BB_DIR_USR_SBIN, BB_SUID_DROP))
 IF_FDFLUSH(APPLET_ODDNAME(fdflush, freeramdisk, BB_DIR_BIN, BB_SUID_DROP, fdflush))
@@ -129,37 +123,16 @@
 //IF_E2FSCK(APPLET_ODDNAME(fsck.ext3, e2fsck, BB_DIR_SBIN, BB_SUID_DROP, fsck_ext3))
 IF_FSCK_MINIX(APPLET_ODDNAME(fsck.minix, fsck_minix, BB_DIR_SBIN, BB_SUID_DROP, fsck_minix))
 IF_FSYNC(APPLET_NOFORK(fsync, fsync, BB_DIR_BIN, BB_SUID_DROP, fsync))
-IF_FTPD(APPLET(ftpd, BB_DIR_USR_SBIN, BB_SUID_DROP))
-IF_FTPGET(APPLET_ODDNAME(ftpget, ftpgetput, BB_DIR_USR_BIN, BB_SUID_DROP, ftpget))
-IF_FTPPUT(APPLET_ODDNAME(ftpput, ftpgetput, BB_DIR_USR_BIN, BB_SUID_DROP, ftpput))
 IF_GETENFORCE(APPLET(getenforce, BB_DIR_USR_SBIN, BB_SUID_DROP))
 IF_GETOPT(APPLET(getopt, BB_DIR_BIN, BB_SUID_DROP))
 IF_GETSEBOOL(APPLET(getsebool, BB_DIR_USR_SBIN, BB_SUID_DROP))
 IF_HD(APPLET_NOEXEC(hd, hexdump, BB_DIR_USR_BIN, BB_SUID_DROP, hd))
 IF_HEAD(APPLET_NOEXEC(head, head, BB_DIR_USR_BIN, BB_SUID_DROP, head))
 IF_HEXDUMP(APPLET_NOEXEC(hexdump, hexdump, BB_DIR_USR_BIN, BB_SUID_DROP, hexdump))
-IF_HTTPD(APPLET(httpd, BB_DIR_USR_SBIN, BB_SUID_DROP))
 IF_HWCLOCK(APPLET(hwclock, BB_DIR_SBIN, BB_SUID_DROP))
-IF_IFCONFIG(APPLET(ifconfig, BB_DIR_SBIN, BB_SUID_DROP))
-IF_IFENSLAVE(APPLET(ifenslave, BB_DIR_SBIN, BB_SUID_DROP))
-IF_IFPLUGD(APPLET(ifplugd, BB_DIR_USR_SBIN, BB_SUID_DROP))
-IF_INETD(APPLET(inetd, BB_DIR_USR_SBIN, BB_SUID_DROP))
 IF_INSTALL(APPLET(install, BB_DIR_USR_BIN, BB_SUID_DROP))
-#if ENABLE_FEATURE_IP_ADDRESS \
- || ENABLE_FEATURE_IP_ROUTE \
- || ENABLE_FEATURE_IP_LINK \
- || ENABLE_FEATURE_IP_TUNNEL \
- || ENABLE_FEATURE_IP_RULE
-IF_IP(APPLET(ip, BB_DIR_SBIN, BB_SUID_DROP))
-#endif
-IF_IPADDR(APPLET(ipaddr, BB_DIR_SBIN, BB_SUID_DROP))
-IF_IPCALC(APPLET(ipcalc, BB_DIR_BIN, BB_SUID_DROP))
 IF_IPCRM(APPLET(ipcrm, BB_DIR_USR_BIN, BB_SUID_DROP))
 IF_IPCS(APPLET(ipcs, BB_DIR_USR_BIN, BB_SUID_DROP))
-IF_IPLINK(APPLET(iplink, BB_DIR_SBIN, BB_SUID_DROP))
-IF_IPROUTE(APPLET(iproute, BB_DIR_SBIN, BB_SUID_DROP))
-IF_IPRULE(APPLET(iprule, BB_DIR_SBIN, BB_SUID_DROP))
-IF_IPTUNNEL(APPLET(iptunnel, BB_DIR_SBIN, BB_SUID_DROP))
 IF_KBD_MODE(APPLET(kbd_mode, BB_DIR_BIN, BB_SUID_DROP))
 //IF_LENGTH(APPLET_NOFORK(length, length, BB_DIR_USR_BIN, BB_SUID_DROP, length))
 IF_LN(APPLET_NOEXEC(ln, ln, BB_DIR_BIN, BB_SUID_DROP, ln))
@@ -186,13 +159,8 @@
  * Therefore we use BB_SUID_MAYBE instead of BB_SUID_REQUIRE: */
 IF_MOUNT(APPLET(mount, BB_DIR_BIN, IF_DESKTOP(BB_SUID_MAYBE) IF_NOT_DESKTOP(BB_SUID_DROP)))
 IF_MV(APPLET(mv, BB_DIR_BIN, BB_SUID_DROP))
-IF_NAMEIF(APPLET(nameif, BB_DIR_SBIN, BB_SUID_DROP))
-IF_NC(APPLET(nc, BB_DIR_USR_BIN, BB_SUID_DROP))
-IF_NETSTAT(APPLET(netstat, BB_DIR_BIN, BB_SUID_DROP))
 IF_NICE(APPLET(nice, BB_DIR_BIN, BB_SUID_DROP))
 IF_NOHUP(APPLET(nohup, BB_DIR_USR_BIN, BB_SUID_DROP))
-IF_NSLOOKUP(APPLET(nslookup, BB_DIR_USR_BIN, BB_SUID_DROP))
-IF_NTPD(APPLET(ntpd, BB_DIR_USR_SBIN, BB_SUID_DROP))
 IF_OD(APPLET(od, BB_DIR_USR_BIN, BB_SUID_DROP))
 IF_OPENVT(APPLET(openvt, BB_DIR_USR_BIN, BB_SUID_DROP))
 //IF_PARSE(APPLET(parse, BB_DIR_USR_BIN, BB_SUID_DROP))
@@ -200,7 +168,6 @@
 IF_POPMAILDIR(APPLET(popmaildir, BB_DIR_USR_SBIN, BB_SUID_DROP))
 IF_PRINTENV(APPLET_NOFORK(printenv, printenv, BB_DIR_BIN, BB_SUID_DROP, printenv))
 IF_PRINTF(APPLET_NOFORK(printf, printf, BB_DIR_USR_BIN, BB_SUID_DROP, printf))
-IF_PSCAN(APPLET(pscan, BB_DIR_USR_BIN, BB_SUID_DROP))
 IF_PWD(APPLET_NOFORK(pwd, pwd, BB_DIR_BIN, BB_SUID_DROP, pwd))
 IF_RDATE(APPLET(rdate, BB_DIR_USR_SBIN, BB_SUID_DROP))
 IF_RDEV(APPLET(rdev, BB_DIR_USR_SBIN, BB_SUID_DROP))
@@ -213,7 +180,6 @@
 IF_RESTORECON(APPLET_ODDNAME(restorecon, setfiles, BB_DIR_SBIN, BB_SUID_DROP, restorecon))
 IF_RM(APPLET_NOFORK(rm, rm, BB_DIR_BIN, BB_SUID_DROP, rm))
 IF_RMDIR(APPLET_NOFORK(rmdir, rmdir, BB_DIR_BIN, BB_SUID_DROP, rmdir))
-IF_ROUTE(APPLET(route, BB_DIR_SBIN, BB_SUID_DROP))
 IF_RTCWAKE(APPLET(rtcwake, BB_DIR_USR_SBIN, BB_SUID_DROP))
 IF_RUNCON(APPLET(runcon, BB_DIR_USR_BIN, BB_SUID_DROP))
 IF_SCRIPT(APPLET(script, BB_DIR_USR_BIN, BB_SUID_DROP))
@@ -230,7 +196,6 @@
 IF_SETLOGCONS(APPLET(setlogcons, BB_DIR_USR_SBIN, BB_SUID_DROP))
 IF_SETSEBOOL(APPLET(setsebool, BB_DIR_USR_SBIN, BB_SUID_DROP))
 IF_SHOWKEY(APPLET(showkey, BB_DIR_USR_BIN, BB_SUID_DROP))
-IF_SLATTACH(APPLET(slattach, BB_DIR_SBIN, BB_SUID_DROP))
 /* Do not make this applet NOFORK. It breaks ^C-ing of pauses in shells: */
 IF_SLEEP(APPLET(sleep, BB_DIR_BIN, BB_SUID_DROP))
 IF_SORT(APPLET_NOEXEC(sort, sort, BB_DIR_USR_BIN, BB_SUID_DROP, sort))
@@ -242,25 +207,13 @@
 IF_TAC(APPLET_NOEXEC(tac, tac, BB_DIR_USR_BIN, BB_SUID_DROP, tac))
 IF_TAIL(APPLET(tail, BB_DIR_USR_BIN, BB_SUID_DROP))
 /* IF_TC(APPLET(tc, BB_DIR_SBIN, BB_SUID_DROP)) */
-IF_TCPSVD(APPLET_ODDNAME(tcpsvd, tcpudpsvd, BB_DIR_USR_BIN, BB_SUID_DROP, tcpsvd))
 IF_TEE(APPLET(tee, BB_DIR_USR_BIN, BB_SUID_DROP))
-IF_TELNET(APPLET(telnet, BB_DIR_USR_BIN, BB_SUID_DROP))
-IF_TELNETD(APPLET(telnetd, BB_DIR_USR_SBIN, BB_SUID_DROP))
 IF_TEST(APPLET_NOFORK(test, test, BB_DIR_USR_BIN, BB_SUID_DROP, test))
-#if ENABLE_FEATURE_TFTP_GET || ENABLE_FEATURE_TFTP_PUT
-IF_TFTP(APPLET(tftp, BB_DIR_USR_BIN, BB_SUID_DROP))
-IF_TFTPD(APPLET(tftpd, BB_DIR_USR_SBIN, BB_SUID_DROP))
-#endif
 IF_TR(APPLET(tr, BB_DIR_USR_BIN, BB_SUID_DROP))
-/* Needs socket(AF_INET, SOCK_RAW, IPPROTO_ICMP), therefore BB_SUID_MAYBE: */
-IF_TRACEROUTE(APPLET(traceroute, BB_DIR_USR_BIN, BB_SUID_MAYBE))
-IF_TRACEROUTE6(APPLET(traceroute6, BB_DIR_USR_BIN, BB_SUID_MAYBE))
 IF_TRUE(APPLET_NOFORK(true, true, BB_DIR_BIN, BB_SUID_DROP, true))
 IF_TTY(APPLET(tty, BB_DIR_USR_BIN, BB_SUID_DROP))
-IF_TUNCTL(APPLET(tunctl, BB_DIR_SBIN, BB_SUID_DROP))
 IF_UDHCPC(APPLET(udhcpc, BB_DIR_SBIN, BB_SUID_DROP))
 IF_UDHCPD(APPLET(udhcpd, BB_DIR_USR_SBIN, BB_SUID_DROP))
-IF_UDPSVD(APPLET_ODDNAME(udpsvd, tcpudpsvd, BB_DIR_USR_BIN, BB_SUID_DROP, udpsvd))
 IF_UMOUNT(APPLET(umount, BB_DIR_BIN, BB_SUID_DROP))
 IF_UNAME(APPLET(uname, BB_DIR_BIN, BB_SUID_DROP))
 IF_UNEXPAND(APPLET_ODDNAME(unexpand, expand, BB_DIR_USR_BIN, BB_SUID_DROP, unexpand))
@@ -269,11 +222,9 @@
 IF_USLEEP(APPLET_NOFORK(usleep, usleep, BB_DIR_BIN, BB_SUID_DROP, usleep))
 IF_UUDECODE(APPLET(uudecode, BB_DIR_USR_BIN, BB_SUID_DROP))
 IF_UUENCODE(APPLET(uuencode, BB_DIR_USR_BIN, BB_SUID_DROP))
-IF_VCONFIG(APPLET(vconfig, BB_DIR_SBIN, BB_SUID_DROP))
 IF_WC(APPLET(wc, BB_DIR_USR_BIN, BB_SUID_DROP))
 IF_WHOAMI(APPLET_NOFORK(whoami, whoami, BB_DIR_USR_BIN, BB_SUID_DROP, whoami))
 IF_YES(APPLET_NOFORK(yes, yes, BB_DIR_USR_BIN, BB_SUID_DROP, yes))
-IF_ZCIP(APPLET(zcip, BB_DIR_SBIN, BB_SUID_DROP))
 
 #if !defined(PROTOTYPES) && !defined(NAME_MAIN) && !defined(MAKE_USAGE) \
 	&& !defined(MAKE_LINKS) && !defined(MAKE_SUID)
diff --git a/networking/Config.src b/networking/Config.src
index 43667fe..4d92188 100644
--- a/networking/Config.src
+++ b/networking/Config.src
@@ -5,8 +5,6 @@
 
 menu "Networking Utilities"
 
-INSERT
-
 config FEATURE_IPV6
 	bool "Enable IPv6 support"
 	default y
@@ -48,558 +46,7 @@
 	  "can't resolve 'hostname.com'" and want to know more.
 	  This may increase size of your executable a bit.
 
-config ARP
-	bool "arp"
-	default y
-	select PLATFORM_LINUX
-	help
-	  Manipulate the system ARP cache.
-
-config ARPING
-	bool "arping"
-	default y
-	select PLATFORM_LINUX
-	help
-	  Ping hosts by ARP packets.
-
-config BRCTL
-	bool "brctl"
-	default y
-	select PLATFORM_LINUX
-	help
-	  Manage ethernet bridges.
-	  Supports addbr/delbr and addif/delif.
-
-config FEATURE_BRCTL_FANCY
-	bool "Fancy options"
-	default y
-	depends on BRCTL
-	help
-	  Add support for extended option like:
-	    setageing, setfd, sethello, setmaxage,
-	    setpathcost, setportprio, setbridgeprio,
-	    stp
-	  This adds about 600 bytes.
-
-config FEATURE_BRCTL_SHOW
-	bool "Support show"
-	default y
-	depends on BRCTL && FEATURE_BRCTL_FANCY
-	help
-	  Add support for option which prints the current config:
-	    show
-
-config DNSD
-	bool "dnsd"
-	default y
-	help
-	  Small and static DNS server daemon.
-
-config ETHER_WAKE
-	bool "ether-wake"
-	default y
-	select PLATFORM_LINUX
-	help
-	  Send a magic packet to wake up sleeping machines.
-
-config FAKEIDENTD
-	bool "fakeidentd"
-	default y
-	select FEATURE_SYSLOG
-	help
-	  fakeidentd listens on the ident port and returns a predefined
-	  fake value on any query.
-
-config FTPD
-	bool "ftpd"
-	default y
-	help
-	  simple FTP daemon. You have to run it via inetd.
-
-config FEATURE_FTP_WRITE
-	bool "Enable upload commands"
-	default y
-	depends on FTPD
-	help
-	  Enable all kinds of FTP upload commands (-w option)
-
-config FEATURE_FTPD_ACCEPT_BROKEN_LIST
-	bool "Enable workaround for RFC-violating clients"
-	default y
-	depends on FTPD
-	help
-	  Some ftp clients (among them KDE's Konqueror) issue illegal
-	  "LIST -l" requests. This option works around such problems.
-	  It might prevent you from listing files starting with "-" and
-	  it increases the code size by ~40 bytes.
-	  Most other ftp servers seem to behave similar to this.
-
-config FEATURE_FTP_AUTHENTICATION
-	bool "Enable authentication"
-	default y
-	depends on FTPD
-	help
-	  Enable basic system login as seen in telnet etc.
-
-config FTPGET
-	bool "ftpget"
-	default y
-	help
-	  Retrieve a remote file via FTP.
-
-config FTPPUT
-	bool "ftpput"
-	default y
-	help
-	  Store a remote file via FTP.
-
-config FEATURE_FTPGETPUT_LONG_OPTIONS
-	bool "Enable long options in ftpget/ftpput"
-	default y
-	depends on LONG_OPTS && (FTPGET || FTPPUT)
-	help
-	  Support long options for the ftpget/ftpput applet.
-
-config HTTPD
-	bool "httpd"
-	default y
-	help
-	  Serve web pages via an HTTP server.
-
-config FEATURE_HTTPD_RANGES
-	bool "Support 'Ranges:' header"
-	default y
-	depends on HTTPD
-	help
-	  Makes httpd emit "Accept-Ranges: bytes" header and understand
-	  "Range: bytes=NNN-[MMM]" header. Allows for resuming interrupted
-	  downloads, seeking in multimedia players etc.
-
-config FEATURE_HTTPD_SETUID
-	bool "Enable -u <user> option"
-	default y
-	depends on HTTPD
-	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.
-	  Example for httpd.conf file:
-	  /adm:toor:PaSsWd
-
-config FEATURE_HTTPD_AUTH_MD5
-	bool "Support MD5 crypted passwords for http Authentication"
-	default y
-	depends on FEATURE_HTTPD_BASIC_AUTH
-	help
-	  Enables encrypted passwords, and wildcard user/passwords
-	  in httpd.conf file.
-	  User '*' means 'any system user name is ok',
-	  password of '*' means 'use system password for this user'
-	  Examples:
-	  /adm:toor:$1$P/eKnWXS$aI1aPGxT.dJD5SzqAKWrF0
-	  /adm:root:*
-	  /wiki:*:*
-
-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 "Support for running scripts through an interpreter"
-	default y
-	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 additional line in your
-	  httpd.conf file:
-	  *.php:/path/to/your/php
-
-config FEATURE_HTTPD_SET_REMOTE_PORT_TO_ENV
-	bool "Set REMOTE_PORT environment variable for CGI"
-	default y
-	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 -e option (useful for CGIs written as shell scripts)"
-	default y
-	depends on HTTPD
-	help
-	  This option allows html encoding of arbitrary strings for display
-	  by the browser. Output goes to stdout.
-	  For example, httpd -e "<Hello World>" produces
-	  "&#60Hello&#32World&#62".
-
-config FEATURE_HTTPD_ERROR_PAGES
-	bool "Support for custom error pages"
-	default y
-	depends on HTTPD
-	help
-	  This option allows you to define custom error pages in
-	  the configuration file instead of the default HTTP status
-	  error pages. For instance, if you add the line:
-	        E404:/path/e404.html
-	  in the config file, the server will respond the specified
-	  '/path/e404.html' file instead of the terse '404 NOT FOUND'
-	  message.
-
-config FEATURE_HTTPD_PROXY
-	bool "Support for reverse proxy"
-	default y
-	depends on HTTPD
-	help
-	  This option allows you to define URLs that will be forwarded
-	  to another HTTP server. To setup add the following line to the
-	  configuration file
-	        P:/url/:http://hostname[:port]/new/path/
-	  Then a request to /url/myfile will be forwarded to
-	  http://hostname[:port]/new/path/myfile.
-
-config FEATURE_HTTPD_GZIP
-	bool "Support for GZIP content encoding"
-	default y
-	depends on HTTPD
-	help
-	  Makes httpd send files using GZIP content encoding if the
-	  client supports it and a pre-compressed <file>.gz exists.
-
-config IFCONFIG
-	bool "ifconfig"
-	default y
-	select PLATFORM_LINUX
-	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 y
-	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 y
-	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 y
-	depends on IFCONFIG
-	help
-	  Setting this will make ifconfig attempt to find the broadcast
-	  automatically if the value '+' is used.
-
-config IFENSLAVE
-	bool "ifenslave"
-	default y
-	select PLATFORM_LINUX
-	help
-	  Userspace application to bind several interfaces
-	  to a logical interface (use with kernel bonding driver).
-
-config IFPLUGD
-	bool "ifplugd"
-	default y
-	select PLATFORM_LINUX
-	help
-	  Network interface plug detection daemon.
-
-config INETD
-	bool "inetd"
-	default y
-	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  # very rarely used, and needs Sun RPC support in libc
-	depends on INETD
-	select FEATURE_HAVE_RPC
-	help
-	  Support Sun-RPC based services
-
-config IP
-	bool "ip"
-	default y
-	select PLATFORM_LINUX
-	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_ROUTE_DIR
-	string "ip route configuration directory"
-	default "/etc/iproute2"
-	depends on FEATURE_IP_ROUTE
-	help
-	  Location of the "ip" applet routing configuration.
-
-config FEATURE_IP_TUNNEL
-	bool "ip tunnel"
-	default y
-	depends on IP
-	help
-	  Add support for tunneling commands to "ip".
-
-config FEATURE_IP_RULE
-	bool "ip rule"
-	default y
-	depends on IP
-	help
-	  Add support for rule commands to "ip".
-
-config FEATURE_IP_NEIGH
-	bool "ip neighbor"
-	default y
-	depends on IP
-	help
-	  Add support for neighbor commands to "ip".
-
-config FEATURE_IP_SHORT_FORMS
-	bool "Support short forms of ip commands"
-	default y
-	depends on IP
-	help
-	  Also support short-form of ip <OBJECT> commands:
-	  ip addr   -> ipaddr
-	  ip link   -> iplink
-	  ip route  -> iproute
-	  ip tunnel -> iptunnel
-	  ip rule   -> iprule
-	  ip neigh  -> ipneigh
-
-	  Say N unless you desparately need the short form of the ip
-	  object commands.
-
-config FEATURE_IP_RARE_PROTOCOLS
-	bool "Support displaying rarely used link types"
-	default n
-	depends on IP
-	help
-	  If you are not going to use links of type "frad", "econet",
-	  "bif" etc, you probably don't need to enable this.
-	  Ethernet, wireless, infrared, ppp/slip, ip tunnelling
-	  link types are supported without this option selected.
-
-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 IPNEIGH
-	bool
-	default y
-	depends on FEATURE_IP_SHORT_FORMS && FEATURE_IP_NEIGH
-
-config IPCALC
-	bool "ipcalc"
-	default y
-	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 y
-	depends on IPCALC && LONG_OPTS
-	help
-	  Support long options for the ipcalc applet.
-
-config NETSTAT
-	bool "netstat"
-	default y
-	select PLATFORM_LINUX
-	help
-	  netstat prints information about the Linux networking subsystem.
-
-config FEATURE_NETSTAT_WIDE
-	bool "Enable wide netstat output"
-	default y
-	depends on NETSTAT
-	help
-	  Add support for wide columns. Useful when displaying IPv6 addresses
-	  (-W option).
-
-config FEATURE_NETSTAT_PRG
-	bool "Enable PID/Program name output"
-	default y
-	depends on NETSTAT
-	help
-	  Add support for -p flag to print out PID and program name.
-	  +700 bytes of code.
-
-config NSLOOKUP
-	bool "nslookup"
-	default y
-	help
-	  nslookup is a tool to query Internet name servers.
-
-config NTPD
-	bool "ntpd"
-	default y
-	select PLATFORM_LINUX
-	help
-	  The NTP client/server daemon.
-
-config FEATURE_NTPD_SERVER
-	bool "Make ntpd usable as a NTP server"
-	default y
-	depends on NTPD
-	help
-	  Make ntpd usable as a NTP server. If you disable this option
-	  ntpd will be usable only as a NTP client.
-
-config FEATURE_NTPD_CONF
-	bool "Make ntpd understand /etc/ntp.conf"
-	default y
-	depends on NTPD
-	help
-	  Make ntpd look in /etc/ntp.conf for peers. Only "server address"
-	  is supported.
-
-config PSCAN
-	bool "pscan"
-	default y
-	help
-	  Simple network port scanner.
-
-config ROUTE
-	bool "route"
-	default y
-	select PLATFORM_LINUX
-	help
-	  Route displays or manipulates the kernel's IP routing tables.
-
-config SLATTACH
-	bool "slattach"
-	default y
-	select PLATFORM_LINUX
-	help
-	  slattach is a small utility to attach network interfaces to serial
-	  lines.
+INSERT
 
 #config TC
 #	bool "tc"
@@ -611,218 +58,6 @@
 #	def_bool n
 #	depends on TC
 
-config TCPSVD
-	bool "tcpsvd"
-	default y
-	help
-	  tcpsvd listens on a TCP port and runs a program for each new
-	  connection.
-
-config TELNET
-	bool "telnet"
-	default y
-	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 y
-	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:
-		  CONFIG_UNIX98_PTYS=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 y
-	depends on TELNETD
-	help
-	  Selecting this will make telnetd able to run standalone.
-
-config FEATURE_TELNETD_INETD_WAIT
-	bool "Support -w SEC option (inetd wait mode)"
-	default y
-	depends on FEATURE_TELNETD_STANDALONE
-	help
-	  This option allows you to run telnetd in "inet wait" mode.
-	  Example inetd.conf line (note "wait", not usual "nowait"):
-
-	  telnet stream tcp wait root /bin/telnetd telnetd -w10
-
-	  In this example, inetd passes _listening_ socket_ as fd 0
-	  to telnetd when connection appears.
-	  telnetd will wait for connections until all existing
-	  connections are closed, and no new connections
-	  appear during 10 seconds. Then it exits, and inetd continues
-	  to listen for new connections.
-
-	  This option is rarely used. "tcp nowait" is much more usual
-	  way of running tcp services, including telnetd.
-	  You most probably want to say N here.
-
-config TFTP
-	bool "tftp"
-	default y
-	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 TFTPD
-	bool "tftpd"
-	default y
-	help
-	  This enables the Trivial File Transfer Protocol server program.
-	  It expects that stdin is a datagram socket and a packet
-	  is already pending on it. It will exit after one transfer.
-	  In other words: it should be run from inetd in nowait mode,
-	  or from udpsvd. Example: "udpsvd -E 0 69 tftpd DIR"
-
-comment "Common options for tftp/tftpd"
-	depends on TFTP || TFTPD
-
-config FEATURE_TFTP_GET
-	bool "Enable 'tftp get' and/or tftpd upload code"
-	default y
-	depends on TFTP || TFTPD
-	help
-	  Add support for the GET command within the TFTP client. This allows
-	  a client to retrieve a file from a TFTP server.
-	  Also enable upload support in tftpd, if tftpd is selected.
-
-	  Note: this option does _not_ make tftpd capable of download
-	  (the usual operation people need from it)!
-
-config FEATURE_TFTP_PUT
-	bool "Enable 'tftp put' and/or tftpd download code"
-	default y
-	depends on TFTP || TFTPD
-	help
-	  Add support for the PUT command within the TFTP client. This allows
-	  a client to transfer a file to a TFTP server.
-	  Also enable download support in tftpd, if tftpd is selected.
-
-config FEATURE_TFTP_BLOCKSIZE
-	bool "Enable 'blksize' and 'tsize' protocol options"
-	default y
-	depends on TFTP || TFTPD
-	help
-	  Allow tftp to specify block size, and tftpd to understand
-	  "blksize" and "tsize" options.
-
-config FEATURE_TFTP_PROGRESS_BAR
-	bool "Enable tftp progress meter"
-	default y
-	depends on TFTP && FEATURE_TFTP_BLOCKSIZE
-	help
-	  Show progress bar.
-
-config TFTP_DEBUG
-	bool "Enable debug"
-	default n
-	depends on TFTP || TFTPD
-	help
-	  Make tftp[d] print debugging messages on stderr.
-	  This is useful if you are diagnosing a bug in tftp[d].
-
-config TRACEROUTE
-	bool "traceroute"
-	default y
-	select PLATFORM_LINUX
-	help
-	  Utility to trace the route of IP packets.
-
-config TRACEROUTE6
-	bool "traceroute6"
-	default y
-	depends on FEATURE_IPV6 && TRACEROUTE
-	help
-	  Utility to trace the route of IPv6 packets.
-
-config FEATURE_TRACEROUTE_VERBOSE
-	bool "Enable verbose output"
-	default y
-	depends on TRACEROUTE
-	help
-	  Add some verbosity to traceroute. This includes among other things
-	  hostnames and ICMP response types.
-
-config FEATURE_TRACEROUTE_USE_ICMP
-	bool "Enable -I option (use ICMP instead of UDP)"
-	default y
-	depends on TRACEROUTE
-	help
-	  Add option -I to use ICMP ECHO instead of UDP datagrams.
-
-config TUNCTL
-	bool "tunctl"
-	default y
-	select PLATFORM_LINUX
-	help
-	  tunctl creates or deletes tun devices.
-
-config FEATURE_TUNCTL_UG
-	bool "Support owner:group assignment"
-	default y
-	depends on TUNCTL
-	help
-	  Allow to specify owner and group of newly created interface.
-	  340 bytes of pure bloat. Say no here.
-
 source networking/udhcp/Config.in
 
 config IFUPDOWN_UDHCPC_CMD_OPTIONS
@@ -834,31 +69,4 @@
 	  Intended to alter options not available in /etc/network/interfaces.
 	  (IE: --syslog --background etc...)
 
-config UDPSVD
-	bool "udpsvd"
-	default y
-	help
-	  udpsvd listens on an UDP port and runs a program for each new
-	  connection.
-
-config VCONFIG
-	bool "vconfig"
-	default y
-	select PLATFORM_LINUX
-	help
-	  Creates, removes, and configures VLAN interfaces
-
-config ZCIP
-	bool "zcip"
-	default y
-	select PLATFORM_LINUX
-	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.src b/networking/Kbuild.src
index 4ad7502..6b4fb74 100644
--- a/networking/Kbuild.src
+++ b/networking/Kbuild.src
@@ -7,39 +7,3 @@
 lib-y:=
 
 INSERT
-lib-$(CONFIG_ARP)          += arp.o interface.o
-lib-$(CONFIG_ARPING)       += arping.o
-lib-$(CONFIG_BRCTL)        += brctl.o
-lib-$(CONFIG_DNSD)         += dnsd.o
-lib-$(CONFIG_ETHER_WAKE)   += ether-wake.o
-lib-$(CONFIG_FAKEIDENTD)   += isrv_identd.o isrv.o
-lib-$(CONFIG_FTPD)         += ftpd.o
-lib-$(CONFIG_FTPGET)       += ftpgetput.o
-lib-$(CONFIG_FTPPUT)       += ftpgetput.o
-lib-$(CONFIG_HTTPD)        += httpd.o
-lib-$(CONFIG_IFCONFIG)     += ifconfig.o interface.o
-lib-$(CONFIG_IFENSLAVE)    += ifenslave.o interface.o
-lib-$(CONFIG_IFPLUGD)      += ifplugd.o
-lib-$(CONFIG_INETD)        += inetd.o
-lib-$(CONFIG_IP)           += ip.o
-lib-$(CONFIG_IPCALC)       += ipcalc.o
-lib-$(CONFIG_NAMEIF)       += nameif.o
-lib-$(CONFIG_NC)           += nc.o
-lib-$(CONFIG_NETSTAT)      += netstat.o
-lib-$(CONFIG_NSLOOKUP)     += nslookup.o
-lib-$(CONFIG_NTPD)         += ntpd.o
-lib-$(CONFIG_PSCAN)        += pscan.o
-lib-$(CONFIG_ROUTE)        += route.o
-lib-$(CONFIG_SLATTACH)     += slattach.o
-lib-$(CONFIG_TC)           += tc.o
-lib-$(CONFIG_TELNET)       += telnet.o
-lib-$(CONFIG_TELNETD)      += telnetd.o
-lib-$(CONFIG_TFTP)         += tftp.o
-lib-$(CONFIG_TFTPD)        += tftp.o
-lib-$(CONFIG_TRACEROUTE)   += traceroute.o
-lib-$(CONFIG_TUNCTL)       += tunctl.o
-lib-$(CONFIG_VCONFIG)      += vconfig.o
-lib-$(CONFIG_ZCIP)         += zcip.o
-
-lib-$(CONFIG_TCPSVD)       += tcpudp.o tcpudp_perhost.o
-lib-$(CONFIG_UDPSVD)       += tcpudp.o tcpudp_perhost.o
diff --git a/networking/arp.c b/networking/arp.c
index 69a5816..a62a376 100644
--- a/networking/arp.c
+++ b/networking/arp.c
@@ -12,6 +12,16 @@
  *
  * modified for getopt32 by Arne Bernin <arne [at] alamut.de>
  */
+//config:config ARP
+//config:	bool "arp"
+//config:	default y
+//config:	select PLATFORM_LINUX
+//config:	help
+//config:	  Manipulate the system ARP cache.
+
+//applet:IF_ARP(APPLET(arp, BB_DIR_SBIN, BB_SUID_DROP))
+
+//kbuild:lib-$(CONFIG_ARP) += arp.o interface.o
 
 //usage:#define arp_trivial_usage
 //usage:     "\n[-vn]	[-H HWTYPE] [-i IF] -a [HOSTNAME]"
diff --git a/networking/arping.c b/networking/arping.c
index 46bd65e..5bfeb1b 100644
--- a/networking/arping.c
+++ b/networking/arping.c
@@ -5,6 +5,17 @@
  * Author: Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
  * Busybox port: Nick Fedchik <nick@fedchik.org.ua>
  */
+//config:config ARPING
+//config:	bool "arping"
+//config:	default y
+//config:	select PLATFORM_LINUX
+//config:	help
+//config:	  Ping hosts by ARP packets.
+//config:
+
+//applet:IF_ARPING(APPLET(arping, BB_DIR_USR_SBIN, BB_SUID_DROP))
+
+//kbuild:lib-$(CONFIG_ARPING) += arping.o
 
 //usage:#define arping_trivial_usage
 //usage:       "[-fqbDUA] [-c CNT] [-w TIMEOUT] [-I IFACE] [-s SRC_IP] DST_IP"
diff --git a/networking/brctl.c b/networking/brctl.c
index b732096..3587689 100644
--- a/networking/brctl.c
+++ b/networking/brctl.c
@@ -12,6 +12,36 @@
 /* This applet currently uses only the ioctl interface and no sysfs at all.
  * At the time of this writing this was considered a feature.
  */
+//config:config BRCTL
+//config:	bool "brctl"
+//config:	default y
+//config:	select PLATFORM_LINUX
+//config:	help
+//config:	  Manage ethernet bridges.
+//config:	  Supports addbr/delbr and addif/delif.
+//config:
+//config:config FEATURE_BRCTL_FANCY
+//config:	bool "Fancy options"
+//config:	default y
+//config:	depends on BRCTL
+//config:	help
+//config:	  Add support for extended option like:
+//config:	    setageing, setfd, sethello, setmaxage,
+//config:	    setpathcost, setportprio, setbridgeprio,
+//config:	    stp
+//config:	  This adds about 600 bytes.
+//config:
+//config:config FEATURE_BRCTL_SHOW
+//config:	bool "Support show"
+//config:	default y
+//config:	depends on BRCTL && FEATURE_BRCTL_FANCY
+//config:	help
+//config:	  Add support for option which prints the current config:
+//config:	    show
+
+//applet:IF_BRCTL(APPLET(brctl, BB_DIR_USR_SBIN, BB_SUID_DROP))
+
+//kbuild:lib-$(CONFIG_BRCTL) += brctl.o
 
 //usage:#define brctl_trivial_usage
 //usage:       "COMMAND [BRIDGE [INTERFACE]]"
diff --git a/networking/dnsd.c b/networking/dnsd.c
index 923ad6b..7be9001 100644
--- a/networking/dnsd.c
+++ b/networking/dnsd.c
@@ -16,6 +16,15 @@
  * Some bugfix and minor changes was applied by Roberto A. Foglietta who made
  * the first porting of oao' scdns to busybox also.
  */
+//config:config DNSD
+//config:	bool "dnsd"
+//config:	default y
+//config:	help
+//config:	  Small and static DNS server daemon.
+
+//applet:IF_DNSD(APPLET(dnsd, BB_DIR_USR_SBIN, BB_SUID_DROP))
+
+//kbuild:lib-$(CONFIG_DNSD) += dnsd.o
 
 //usage:#define dnsd_trivial_usage
 //usage:       "[-dvs] [-c CONFFILE] [-t TTL_SEC] [-p PORT] [-i ADDR]"
diff --git a/networking/ether-wake.c b/networking/ether-wake.c
index c38547d..d7d6917 100644
--- a/networking/ether-wake.c
+++ b/networking/ether-wake.c
@@ -63,6 +63,16 @@
  *   doing so only works with adapters configured for unicast+broadcast Rx
  *   filter.  That configuration consumes more power.
  */
+//config:config ETHER_WAKE
+//config:	bool "ether-wake"
+//config:	default y
+//config:	select PLATFORM_LINUX
+//config:	help
+//config:	  Send a magic packet to wake up sleeping machines.
+
+//applet:IF_ETHER_WAKE(APPLET_ODDNAME(ether-wake, ether_wake, BB_DIR_USR_SBIN, BB_SUID_DROP, ether_wake))
+
+//kbuild:lib-$(CONFIG_ETHER_WAKE) += ether-wake.o
 
 //usage:#define ether_wake_trivial_usage
 //usage:       "[-b] [-i IFACE] [-p aa:bb:cc:dd[:ee:ff]/a.b.c.d] MAC"
diff --git a/networking/ftpd.c b/networking/ftpd.c
index 4cbb9b6..d4e6c27 100644
--- a/networking/ftpd.c
+++ b/networking/ftpd.c
@@ -11,6 +11,40 @@
  *
  * You have to run this daemon via inetd.
  */
+//config:config FTPD
+//config:	bool "ftpd"
+//config:	default y
+//config:	help
+//config:	  simple FTP daemon. You have to run it via inetd.
+//config:
+//config:config FEATURE_FTP_WRITE
+//config:	bool "Enable upload commands"
+//config:	default y
+//config:	depends on FTPD
+//config:	help
+//config:	  Enable all kinds of FTP upload commands (-w option)
+//config:
+//config:config FEATURE_FTPD_ACCEPT_BROKEN_LIST
+//config:	bool "Enable workaround for RFC-violating clients"
+//config:	default y
+//config:	depends on FTPD
+//config:	help
+//config:	  Some ftp clients (among them KDE's Konqueror) issue illegal
+//config:	  "LIST -l" requests. This option works around such problems.
+//config:	  It might prevent you from listing files starting with "-" and
+//config:	  it increases the code size by ~40 bytes.
+//config:	  Most other ftp servers seem to behave similar to this.
+//config:
+//config:config FEATURE_FTP_AUTHENTICATION
+//config:	bool "Enable authentication"
+//config:	default y
+//config:	depends on FTPD
+//config:	help
+//config:	  Enable basic system login as seen in telnet etc.
+
+//applet:IF_FTPD(APPLET(ftpd, BB_DIR_USR_SBIN, BB_SUID_DROP))
+
+//kbuild:lib-$(CONFIG_FTPD) += ftpd.o
 
 //usage:#define ftpd_trivial_usage
 //usage:       "[-wvS] [-t N] [-T N] [DIR]"
diff --git a/networking/ftpgetput.c b/networking/ftpgetput.c
index 91fb456..40a3271 100644
--- a/networking/ftpgetput.c
+++ b/networking/ftpgetput.c
@@ -12,6 +12,30 @@
  *
  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
+//config:config FTPGET
+//config:	bool "ftpget"
+//config:	default y
+//config:	help
+//config:	  Retrieve a remote file via FTP.
+//config:
+//config:config FTPPUT
+//config:	bool "ftpput"
+//config:	default y
+//config:	help
+//config:	  Store a remote file via FTP.
+//config:
+//config:config FEATURE_FTPGETPUT_LONG_OPTIONS
+//config:	bool "Enable long options in ftpget/ftpput"
+//config:	default y
+//config:	depends on LONG_OPTS && (FTPGET || FTPPUT)
+//config:	help
+//config:	  Support long options for the ftpget/ftpput applet.
+
+//applet:IF_FTPGET(APPLET_ODDNAME(ftpget, ftpgetput, BB_DIR_USR_BIN, BB_SUID_DROP, ftpget))
+//applet:IF_FTPPUT(APPLET_ODDNAME(ftpput, ftpgetput, BB_DIR_USR_BIN, BB_SUID_DROP, ftpput))
+
+//kbuild:lib-$(CONFIG_FTPGET) += ftpgetput.o
+//kbuild:lib-$(CONFIG_FTPPUT) += ftpgetput.o
 
 //usage:#define ftpget_trivial_usage
 //usage:       "[OPTIONS] HOST [LOCAL_FILE] REMOTE_FILE"
diff --git a/networking/httpd.c b/networking/httpd.c
index c20642e..d301d59 100644
--- a/networking/httpd.c
+++ b/networking/httpd.c
@@ -98,6 +98,128 @@
  *
  */
  /* TODO: use TCP_CORK, parse_config() */
+//config:config HTTPD
+//config:	bool "httpd"
+//config:	default y
+//config:	help
+//config:	  Serve web pages via an HTTP server.
+//config:
+//config:config FEATURE_HTTPD_RANGES
+//config:	bool "Support 'Ranges:' header"
+//config:	default y
+//config:	depends on HTTPD
+//config:	help
+//config:	  Makes httpd emit "Accept-Ranges: bytes" header and understand
+//config:	  "Range: bytes=NNN-[MMM]" header. Allows for resuming interrupted
+//config:	  downloads, seeking in multimedia players etc.
+//config:
+//config:config FEATURE_HTTPD_SETUID
+//config:	bool "Enable -u <user> option"
+//config:	default y
+//config:	depends on HTTPD
+//config:	help
+//config:	  This option allows the server to run as a specific user
+//config:	  rather than defaulting to the user that starts the server.
+//config:	  Use of this option requires special privileges to change to a
+//config:	  different user.
+//config:
+//config:config FEATURE_HTTPD_BASIC_AUTH
+//config:	bool "Enable Basic http Authentication"
+//config:	default y
+//config:	depends on HTTPD
+//config:	help
+//config:	  Utilizes password settings from /etc/httpd.conf for basic
+//config:	  authentication on a per url basis.
+//config:	  Example for httpd.conf file:
+//config:	  /adm:toor:PaSsWd
+//config:
+//config:config FEATURE_HTTPD_AUTH_MD5
+//config:	bool "Support MD5 crypted passwords for http Authentication"
+//config:	default y
+//config:	depends on FEATURE_HTTPD_BASIC_AUTH
+//config:	help
+//config:	  Enables encrypted passwords, and wildcard user/passwords
+//config:	  in httpd.conf file.
+//config:	  User '*' means 'any system user name is ok',
+//config:	  password of '*' means 'use system password for this user'
+//config:	  Examples:
+//config:	  /adm:toor:$1$P/eKnWXS$aI1aPGxT.dJD5SzqAKWrF0
+//config:	  /adm:root:*
+//config:	  /wiki:*:*
+//config:
+//config:config FEATURE_HTTPD_CGI
+//config:	bool "Support Common Gateway Interface (CGI)"
+//config:	default y
+//config:	depends on HTTPD
+//config:	help
+//config:	  This option allows scripts and executables to be invoked
+//config:	  when specific URLs are requested.
+//config:
+//config:config FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
+//config:	bool "Support for running scripts through an interpreter"
+//config:	default y
+//config:	depends on FEATURE_HTTPD_CGI
+//config:	help
+//config:	  This option enables support for running scripts through an
+//config:	  interpreter. Turn this on if you want PHP scripts to work
+//config:	  properly. You need to supply an additional line in your
+//config:	  httpd.conf file:
+//config:	  *.php:/path/to/your/php
+//config:
+//config:config FEATURE_HTTPD_SET_REMOTE_PORT_TO_ENV
+//config:	bool "Set REMOTE_PORT environment variable for CGI"
+//config:	default y
+//config:	depends on FEATURE_HTTPD_CGI
+//config:	help
+//config:	  Use of this option can assist scripts in generating
+//config:	  references that contain a unique port number.
+//config:
+//config:config FEATURE_HTTPD_ENCODE_URL_STR
+//config:	bool "Enable -e option (useful for CGIs written as shell scripts)"
+//config:	default y
+//config:	depends on HTTPD
+//config:	help
+//config:	  This option allows html encoding of arbitrary strings for display
+//config:	  by the browser. Output goes to stdout.
+//config:	  For example, httpd -e "<Hello World>" produces
+//config:	  "&#60Hello&#32World&#62".
+//config:
+//config:config FEATURE_HTTPD_ERROR_PAGES
+//config:	bool "Support for custom error pages"
+//config:	default y
+//config:	depends on HTTPD
+//config:	help
+//config:	  This option allows you to define custom error pages in
+//config:	  the configuration file instead of the default HTTP status
+//config:	  error pages. For instance, if you add the line:
+//config:	        E404:/path/e404.html
+//config:	  in the config file, the server will respond the specified
+//config:	  '/path/e404.html' file instead of the terse '404 NOT FOUND'
+//config:	  message.
+//config:
+//config:config FEATURE_HTTPD_PROXY
+//config:	bool "Support for reverse proxy"
+//config:	default y
+//config:	depends on HTTPD
+//config:	help
+//config:	  This option allows you to define URLs that will be forwarded
+//config:	  to another HTTP server. To setup add the following line to the
+//config:	  configuration file
+//config:	        P:/url/:http://hostname[:port]/new/path/
+//config:	  Then a request to /url/myfile will be forwarded to
+//config:	  http://hostname[:port]/new/path/myfile.
+//config:
+//config:config FEATURE_HTTPD_GZIP
+//config:	bool "Support for GZIP content encoding"
+//config:	default y
+//config:	depends on HTTPD
+//config:	help
+//config:	  Makes httpd send files using GZIP content encoding if the
+//config:	  client supports it and a pre-compressed <file>.gz exists.
+
+//applet:IF_HTTPD(APPLET(httpd, BB_DIR_USR_SBIN, BB_SUID_DROP))
+
+//kbuild:lib-$(CONFIG_HTTPD) += httpd.o
 
 //usage:#define httpd_trivial_usage
 //usage:       "[-ifv[v]]"
diff --git a/networking/ifconfig.c b/networking/ifconfig.c
index 8984b02..9e16936 100644
--- a/networking/ifconfig.c
+++ b/networking/ifconfig.c
@@ -25,6 +25,57 @@
  * 2002-04-20
  * IPV6 support added by Bart Visscher <magick@linux-fan.com>
  */
+//config:config IFCONFIG
+//config:	bool "ifconfig"
+//config:	default y
+//config:	select PLATFORM_LINUX
+//config:	help
+//config:	  Ifconfig is used to configure the kernel-resident network interfaces.
+//config:
+//config:config FEATURE_IFCONFIG_STATUS
+//config:	bool "Enable status reporting output (+7k)"
+//config:	default y
+//config:	depends on IFCONFIG
+//config:	help
+//config:	  If ifconfig is called with no arguments it will display the status
+//config:	  of the currently active interfaces.
+//config:
+//config:config FEATURE_IFCONFIG_SLIP
+//config:	bool "Enable slip-specific options \"keepalive\" and \"outfill\""
+//config:	default y
+//config:	depends on IFCONFIG
+//config:	help
+//config:	  Allow "keepalive" and "outfill" support for SLIP. If you're not
+//config:	  planning on using serial lines, leave this unchecked.
+//config:
+//config:config FEATURE_IFCONFIG_MEMSTART_IOADDR_IRQ
+//config:	bool "Enable options \"mem_start\", \"io_addr\", and \"irq\""
+//config:	default y
+//config:	depends on IFCONFIG
+//config:	help
+//config:	  Allow the start address for shared memory, start address for I/O,
+//config:	  and/or the interrupt line used by the specified device.
+//config:
+//config:config FEATURE_IFCONFIG_HW
+//config:	bool "Enable option \"hw\" (ether only)"
+//config:	default y
+//config:	depends on IFCONFIG
+//config:	help
+//config:	  Set the hardware address of this interface, if the device driver
+//config:	  supports  this  operation. Currently, we only support the 'ether'
+//config:	  class.
+//config:
+//config:config FEATURE_IFCONFIG_BROADCAST_PLUS
+//config:	bool "Set the broadcast automatically"
+//config:	default y
+//config:	depends on IFCONFIG
+//config:	help
+//config:	  Setting this will make ifconfig attempt to find the broadcast
+//config:	  automatically if the value '+' is used.
+
+//applet:IF_IFCONFIG(APPLET(ifconfig, BB_DIR_SBIN, BB_SUID_DROP))
+
+//kbuild:lib-$(CONFIG_IFCONFIG) += ifconfig.o interface.o
 
 //usage:#define ifconfig_trivial_usage
 //usage:	IF_FEATURE_IFCONFIG_STATUS("[-a]") " interface [address]"
diff --git a/networking/ifenslave.c b/networking/ifenslave.c
index 6b234ad..1cb765e 100644
--- a/networking/ifenslave.c
+++ b/networking/ifenslave.c
@@ -97,6 +97,17 @@
  *       - Code cleanup and style changes
  *         set version to 1.1.0
  */
+//config:config IFENSLAVE
+//config:	bool "ifenslave"
+//config:	default y
+//config:	select PLATFORM_LINUX
+//config:	help
+//config:	  Userspace application to bind several interfaces
+//config:	  to a logical interface (use with kernel bonding driver).
+
+//applet:IF_IFENSLAVE(APPLET(ifenslave, BB_DIR_SBIN, BB_SUID_DROP))
+
+//kbuild:lib-$(CONFIG_IFENSLAVE) += ifenslave.o interface.o
 
 //usage:#define ifenslave_trivial_usage
 //usage:       "[-cdf] MASTER_IFACE SLAVE_IFACE..."
diff --git a/networking/ifplugd.c b/networking/ifplugd.c
index 029cba1..4f8a274 100644
--- a/networking/ifplugd.c
+++ b/networking/ifplugd.c
@@ -6,6 +6,16 @@
  *
  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
+//config:config IFPLUGD
+//config:	bool "ifplugd"
+//config:	default y
+//config:	select PLATFORM_LINUX
+//config:	help
+//config:	  Network interface plug detection daemon.
+
+//applet:IF_IFPLUGD(APPLET(ifplugd, BB_DIR_USR_SBIN, BB_SUID_DROP))
+
+//kbuild:lib-$(CONFIG_IFPLUGD) += ifplugd.o
 
 //usage:#define ifplugd_trivial_usage
 //usage:       "[OPTIONS]"
diff --git a/networking/inetd.c b/networking/inetd.c
index f9295e3..4d0ab2e 100644
--- a/networking/inetd.c
+++ b/networking/inetd.c
@@ -153,6 +153,59 @@
  *                      setgid(specified group)
  *                      setuid()
  */
+//config:config INETD
+//config:	bool "inetd"
+//config:	default y
+//config:	select FEATURE_SYSLOG
+//config:	help
+//config:	  Internet superserver daemon
+//config:
+//config:config FEATURE_INETD_SUPPORT_BUILTIN_ECHO
+//config:	bool "Support echo service"
+//config:	default y
+//config:	depends on INETD
+//config:	help
+//config:	  Echo received data internal inetd service
+//config:
+//config:config FEATURE_INETD_SUPPORT_BUILTIN_DISCARD
+//config:	bool "Support discard service"
+//config:	default y
+//config:	depends on INETD
+//config:	help
+//config:	  Internet /dev/null internal inetd service
+//config:
+//config:config FEATURE_INETD_SUPPORT_BUILTIN_TIME
+//config:	bool "Support time service"
+//config:	default y
+//config:	depends on INETD
+//config:	help
+//config:	  Return 32 bit time since 1900 internal inetd service
+//config:
+//config:config FEATURE_INETD_SUPPORT_BUILTIN_DAYTIME
+//config:	bool "Support daytime service"
+//config:	default y
+//config:	depends on INETD
+//config:	help
+//config:	  Return human-readable time internal inetd service
+//config:
+//config:config FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN
+//config:	bool "Support chargen service"
+//config:	default y
+//config:	depends on INETD
+//config:	help
+//config:	  Familiar character generator internal inetd service
+//config:
+//config:config FEATURE_INETD_RPC
+//config:	bool "Support RPC services"
+//config:	default n  # very rarely used, and needs Sun RPC support in libc
+//config:	depends on INETD
+//config:	select FEATURE_HAVE_RPC
+//config:	help
+//config:	  Support Sun-RPC based services
+
+//applet:IF_INETD(APPLET(inetd, BB_DIR_USR_SBIN, BB_SUID_DROP))
+
+//kbuild:lib-$(CONFIG_INETD) += inetd.o
 
 //usage:#define inetd_trivial_usage
 //usage:       "[-fe] [-q N] [-R N] [CONFFILE]"
diff --git a/networking/ip.c b/networking/ip.c
index ddfe74e..99f150e 100644
--- a/networking/ip.c
+++ b/networking/ip.c
@@ -8,6 +8,130 @@
  * Rani Assaf <rani@magic.metawire.com> 980929: resolve addresses
  * Bernhard Reutner-Fischer rewrote to use index_in_substr_array
  */
+//config:config IP
+//config:	bool "ip"
+//config:	default y
+//config:	select PLATFORM_LINUX
+//config:	help
+//config:	  The "ip" applet is a TCP/IP interface configuration and routing
+//config:	  utility. You generally don't need "ip" to use busybox with
+//config:	  TCP/IP.
+//config:
+//config:config FEATURE_IP_ADDRESS
+//config:	bool "ip address"
+//config:	default y
+//config:	depends on IP
+//config:	help
+//config:	  Address manipulation support for the "ip" applet.
+//config:
+//config:config FEATURE_IP_LINK
+//config:	bool "ip link"
+//config:	default y
+//config:	depends on IP
+//config:	help
+//config:	  Configure network devices with "ip".
+//config:
+//config:config FEATURE_IP_ROUTE
+//config:	bool "ip route"
+//config:	default y
+//config:	depends on IP
+//config:	help
+//config:	  Add support for routing table management to "ip".
+//config:
+//config:config FEATURE_IP_ROUTE_DIR
+//config:	string "ip route configuration directory"
+//config:	default "/etc/iproute2"
+//config:	depends on FEATURE_IP_ROUTE
+//config:	help
+//config:	  Location of the "ip" applet routing configuration.
+//config:
+//config:config FEATURE_IP_TUNNEL
+//config:	bool "ip tunnel"
+//config:	default y
+//config:	depends on IP
+//config:	help
+//config:	  Add support for tunneling commands to "ip".
+//config:
+//config:config FEATURE_IP_RULE
+//config:	bool "ip rule"
+//config:	default y
+//config:	depends on IP
+//config:	help
+//config:	  Add support for rule commands to "ip".
+//config:
+//config:config FEATURE_IP_NEIGH
+//config:	bool "ip neighbor"
+//config:	default y
+//config:	depends on IP
+//config:	help
+//config:	  Add support for neighbor commands to "ip".
+//config:
+//config:config FEATURE_IP_SHORT_FORMS
+//config:	bool "Support short forms of ip commands"
+//config:	default y
+//config:	depends on IP
+//config:	help
+//config:	  Also support short-form of ip <OBJECT> commands:
+//config:	  ip addr   -> ipaddr
+//config:	  ip link   -> iplink
+//config:	  ip route  -> iproute
+//config:	  ip tunnel -> iptunnel
+//config:	  ip rule   -> iprule
+//config:	  ip neigh  -> ipneigh
+//config:
+//config:	  Say N unless you desparately need the short form of the ip
+//config:	  object commands.
+//config:
+//config:config FEATURE_IP_RARE_PROTOCOLS
+//config:	bool "Support displaying rarely used link types"
+//config:	default n
+//config:	depends on IP
+//config:	help
+//config:	  If you are not going to use links of type "frad", "econet",
+//config:	  "bif" etc, you probably don't need to enable this.
+//config:	  Ethernet, wireless, infrared, ppp/slip, ip tunnelling
+//config:	  link types are supported without this option selected.
+//config:
+//config:config IPADDR
+//config:	bool
+//config:	default y
+//config:	depends on FEATURE_IP_SHORT_FORMS && FEATURE_IP_ADDRESS
+//config:
+//config:config IPLINK
+//config:	bool
+//config:	default y
+//config:	depends on FEATURE_IP_SHORT_FORMS && FEATURE_IP_LINK
+//config:
+//config:config IPROUTE
+//config:	bool
+//config:	default y
+//config:	depends on FEATURE_IP_SHORT_FORMS && FEATURE_IP_ROUTE
+//config:
+//config:config IPTUNNEL
+//config:	bool
+//config:	default y
+//config:	depends on FEATURE_IP_SHORT_FORMS && FEATURE_IP_TUNNEL
+//config:
+//config:config IPRULE
+//config:	bool
+//config:	default y
+//config:	depends on FEATURE_IP_SHORT_FORMS && FEATURE_IP_RULE
+//config:
+//config:config IPNEIGH
+//config:	bool
+//config:	default y
+//config:	depends on FEATURE_IP_SHORT_FORMS && FEATURE_IP_NEIGH
+
+//applet:#if ENABLE_FEATURE_IP_ADDRESS || ENABLE_FEATURE_IP_ROUTE || ENABLE_FEATURE_IP_LINK || ENABLE_FEATURE_IP_TUNNEL || ENABLE_FEATURE_IP_RULE
+//applet:IF_IP(APPLET(ip, BB_DIR_SBIN, BB_SUID_DROP))
+//applet:#endif
+//applet:IF_IPADDR(APPLET(ipaddr, BB_DIR_SBIN, BB_SUID_DROP))
+//applet:IF_IPLINK(APPLET(iplink, BB_DIR_SBIN, BB_SUID_DROP))
+//applet:IF_IPROUTE(APPLET(iproute, BB_DIR_SBIN, BB_SUID_DROP))
+//applet:IF_IPRULE(APPLET(iprule, BB_DIR_SBIN, BB_SUID_DROP))
+//applet:IF_IPTUNNEL(APPLET(iptunnel, BB_DIR_SBIN, BB_SUID_DROP))
+
+//kbuild:lib-$(CONFIG_IP) += ip.o
 
 /* would need to make the " | " optional depending on more than one selected: */
 //usage:#define ip_trivial_usage
diff --git a/networking/ipcalc.c b/networking/ipcalc.c
index f4bacd7..2121942 100644
--- a/networking/ipcalc.c
+++ b/networking/ipcalc.c
@@ -11,6 +11,31 @@
  *
  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
+//config:config IPCALC
+//config:	bool "ipcalc"
+//config:	default y
+//config:	help
+//config:	  ipcalc takes an IP address and netmask and calculates the
+//config:	  resulting broadcast, network, and host range.
+//config:
+//config:config FEATURE_IPCALC_FANCY
+//config:	bool "Fancy IPCALC, more options, adds 1 kbyte"
+//config:	default y
+//config:	depends on IPCALC
+//config:	help
+//config:	  Adds the options hostname, prefix and silent to the output of
+//config:	  "ipcalc".
+//config:
+//config:config FEATURE_IPCALC_LONG_OPTIONS
+//config:	bool "Enable long options"
+//config:	default y
+//config:	depends on IPCALC && LONG_OPTS
+//config:	help
+//config:	  Support long options for the ipcalc applet.
+
+//applet:IF_IPCALC(APPLET(ipcalc, BB_DIR_BIN, BB_SUID_DROP))
+
+//kbuild:lib-$(CONFIG_IPCALC) += ipcalc.o
 
 //usage:#define ipcalc_trivial_usage
 //usage:       "[OPTIONS] ADDRESS"
diff --git a/networking/isrv_identd.c b/networking/isrv_identd.c
index 8a15926..219c64b 100644
--- a/networking/isrv_identd.c
+++ b/networking/isrv_identd.c
@@ -6,6 +6,17 @@
  *
  * Licensed under GPLv2, see file LICENSE in this source tree.
  */
+//config:config FAKEIDENTD
+//config:	bool "fakeidentd"
+//config:	default y
+//config:	select FEATURE_SYSLOG
+//config:	help
+//config:	  fakeidentd listens on the ident port and returns a predefined
+//config:	  fake value on any query.
+
+//applet:IF_FAKEIDENTD(APPLET(fakeidentd, BB_DIR_USR_SBIN, BB_SUID_DROP))
+
+//kbuild:lib-$(CONFIG_FAKEIDENTD) += isrv_identd.o isrv.o
 
 //usage:#define fakeidentd_trivial_usage
 //usage:       "[-fiw] [-b ADDR] [STRING]"
diff --git a/networking/nameif.c b/networking/nameif.c
index 9b18a6d..cffd5bf 100644
--- a/networking/nameif.c
+++ b/networking/nameif.c
@@ -40,6 +40,10 @@
 //config:	    new_interface_name  mac=00:80:C8:38:91:B5
 //config:	    new_interface_name  00:80:C8:38:91:B5
 
+//applet:IF_NAMEIF(APPLET(nameif, BB_DIR_SBIN, BB_SUID_DROP))
+
+//kbuild:lib-$(CONFIG_NAMEIF) += nameif.o
+
 //usage:#define nameif_trivial_usage
 //usage:	IF_NOT_FEATURE_NAMEIF_EXTENDED(
 //usage:		"[-s] [-c FILE] [IFNAME HWADDR]..."
diff --git a/networking/nc.c b/networking/nc.c
index 13a9b48..1b70434 100644
--- a/networking/nc.c
+++ b/networking/nc.c
@@ -6,10 +6,6 @@
  *
  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
-
-#include "libbb.h"
-#include "common_bufsiz.h"
-
 //config:config NC
 //config:	bool "nc"
 //config:	default y
@@ -43,6 +39,12 @@
 //config:	  -s ADDR, -n, -u, -v, -o FILE, -z options, but loses
 //config:	  busybox-specific extensions: -f FILE.
 
+//applet:IF_NC(APPLET(nc, BB_DIR_USR_BIN, BB_SUID_DROP))
+
+//kbuild:lib-$(CONFIG_NC) += nc.o
+
+#include "libbb.h"
+#include "common_bufsiz.h"
 #if ENABLE_NC_110_COMPAT
 # include "nc_bloaty.c"
 #else
diff --git a/networking/netstat.c b/networking/netstat.c
index 2196d42..90da6cd 100644
--- a/networking/netstat.c
+++ b/networking/netstat.c
@@ -13,6 +13,32 @@
  *
  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
+//config:config NETSTAT
+//config:	bool "netstat"
+//config:	default y
+//config:	select PLATFORM_LINUX
+//config:	help
+//config:	  netstat prints information about the Linux networking subsystem.
+//config:
+//config:config FEATURE_NETSTAT_WIDE
+//config:	bool "Enable wide netstat output"
+//config:	default y
+//config:	depends on NETSTAT
+//config:	help
+//config:	  Add support for wide columns. Useful when displaying IPv6 addresses
+//config:	  (-W option).
+//config:
+//config:config FEATURE_NETSTAT_PRG
+//config:	bool "Enable PID/Program name output"
+//config:	default y
+//config:	depends on NETSTAT
+//config:	help
+//config:	  Add support for -p flag to print out PID and program name.
+//config:	  +700 bytes of code.
+
+//applet:IF_NETSTAT(APPLET(netstat, BB_DIR_BIN, BB_SUID_DROP))
+
+//kbuild:lib-$(CONFIG_NETSTAT) += netstat.o
 
 #include "libbb.h"
 #include "inet_common.h"
diff --git a/networking/nslookup.c b/networking/nslookup.c
index dd4b1ff..8e3c8fe 100644
--- a/networking/nslookup.c
+++ b/networking/nslookup.c
@@ -10,6 +10,15 @@
  *
  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
+//config:config NSLOOKUP
+//config:	bool "nslookup"
+//config:	default y
+//config:	help
+//config:	  nslookup is a tool to query Internet name servers.
+
+//applet:IF_NSLOOKUP(APPLET(nslookup, BB_DIR_USR_BIN, BB_SUID_DROP))
+
+//kbuild:lib-$(CONFIG_NSLOOKUP) += nslookup.o
 
 //usage:#define nslookup_trivial_usage
 //usage:       "[HOST] [SERVER]"
diff --git a/networking/ntpd.c b/networking/ntpd.c
index 8ca62cf..b7fa5dc 100644
--- a/networking/ntpd.c
+++ b/networking/ntpd.c
@@ -40,6 +40,32 @@
  * purpose. It is provided "as is" without express or implied warranty.
  ***********************************************************************
  */
+//config:config NTPD
+//config:	bool "ntpd"
+//config:	default y
+//config:	select PLATFORM_LINUX
+//config:	help
+//config:	  The NTP client/server daemon.
+//config:
+//config:config FEATURE_NTPD_SERVER
+//config:	bool "Make ntpd usable as a NTP server"
+//config:	default y
+//config:	depends on NTPD
+//config:	help
+//config:	  Make ntpd usable as a NTP server. If you disable this option
+//config:	  ntpd will be usable only as a NTP client.
+//config:
+//config:config FEATURE_NTPD_CONF
+//config:	bool "Make ntpd understand /etc/ntp.conf"
+//config:	default y
+//config:	depends on NTPD
+//config:	help
+//config:	  Make ntpd look in /etc/ntp.conf for peers. Only "server address"
+//config:	  is supported.
+
+//applet:IF_NTPD(APPLET(ntpd, BB_DIR_USR_SBIN, BB_SUID_DROP))
+
+//kbuild:lib-$(CONFIG_NTPD) += ntpd.o
 
 //usage:#define ntpd_trivial_usage
 //usage:	"[-dnqNw"IF_FEATURE_NTPD_SERVER("l -I IFACE")"] [-S PROG] [-p PEER]..."
diff --git a/networking/pscan.c b/networking/pscan.c
index 72ed8cd..0893c35 100644
--- a/networking/pscan.c
+++ b/networking/pscan.c
@@ -5,6 +5,15 @@
  *
  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
+//config:config PSCAN
+//config:	bool "pscan"
+//config:	default y
+//config:	help
+//config:	  Simple network port scanner.
+
+//applet:IF_PSCAN(APPLET(pscan, BB_DIR_USR_BIN, BB_SUID_DROP))
+
+//kbuild:lib-$(CONFIG_PSCAN) += pscan.o
 
 //usage:#define pscan_trivial_usage
 //usage:       "[-cb] [-p MIN_PORT] [-P MAX_PORT] [-t TIMEOUT] [-T MIN_RTT] HOST"
diff --git a/networking/route.c b/networking/route.c
index 102a6ec..7dc2b5a 100644
--- a/networking/route.c
+++ b/networking/route.c
@@ -24,6 +24,16 @@
  * Rewritten to fix several bugs, add additional error checking, and
  * remove ridiculous amounts of bloat.
  */
+//config:config ROUTE
+//config:	bool "route"
+//config:	default y
+//config:	select PLATFORM_LINUX
+//config:	help
+//config:	  Route displays or manipulates the kernel's IP routing tables.
+
+//applet:IF_ROUTE(APPLET(route, BB_DIR_SBIN, BB_SUID_DROP))
+
+//kbuild:lib-$(CONFIG_ROUTE) += route.o
 
 //usage:#define route_trivial_usage
 //usage:       "[{add|del|delete}]"
diff --git a/networking/slattach.c b/networking/slattach.c
index 2d1305e..9267eb1 100644
--- a/networking/slattach.c
+++ b/networking/slattach.c
@@ -12,6 +12,17 @@
  *
  * - The -F options allows disabling of RTS/CTS flow control.
  */
+//config:config SLATTACH
+//config:	bool "slattach"
+//config:	default y
+//config:	select PLATFORM_LINUX
+//config:	help
+//config:	  slattach is a small utility to attach network interfaces to serial
+//config:	  lines.
+
+//applet:IF_SLATTACH(APPLET(slattach, BB_DIR_SBIN, BB_SUID_DROP))
+
+//kbuild:lib-$(CONFIG_SLATTACH) += slattach.o
 
 //usage:#define slattach_trivial_usage
 //usage:       "[-cehmLF] [-s SPEED] [-p PROTOCOL] DEVICE"
diff --git a/networking/tc.c b/networking/tc.c
index d0bcbde..e10200c 100644
--- a/networking/tc.c
+++ b/networking/tc.c
@@ -6,6 +6,7 @@
  *
  * Bernhard Reutner-Fischer adjusted for busybox
  */
+//kbuild:lib-$(CONFIG_TC) += tc.o
 
 //usage:#define tc_trivial_usage
 /* //usage: "[OPTIONS] OBJECT CMD [dev STRING]" */
diff --git a/networking/tcpudp.c b/networking/tcpudp.c
index b27cf3e..94c89b9 100644
--- a/networking/tcpudp.c
+++ b/networking/tcpudp.c
@@ -28,6 +28,25 @@
  *   with wrong source IP...
  * - don't know how to retrieve ORIGDST for udp.
  */
+//config:config TCPSVD
+//config:	bool "tcpsvd"
+//config:	default y
+//config:	help
+//config:	  tcpsvd listens on a TCP port and runs a program for each new
+//config:	  connection.
+//config:
+//config:config UDPSVD
+//config:	bool "udpsvd"
+//config:	default y
+//config:	help
+//config:	  udpsvd listens on an UDP port and runs a program for each new
+//config:	  connection.
+
+//applet:IF_TCPSVD(APPLET_ODDNAME(tcpsvd, tcpudpsvd, BB_DIR_USR_BIN, BB_SUID_DROP, tcpsvd))
+//applet:IF_UDPSVD(APPLET_ODDNAME(udpsvd, tcpudpsvd, BB_DIR_USR_BIN, BB_SUID_DROP, udpsvd))
+
+//kbuild:lib-$(CONFIG_TCPSVD) += tcpudp.o tcpudp_perhost.o
+//kbuild:lib-$(CONFIG_UDPSVD) += tcpudp.o tcpudp_perhost.o
 
 //usage:#define tcpsvd_trivial_usage
 //usage:       "[-hEv] [-c N] [-C N[:MSG]] [-b N] [-u USER] [-l NAME] IP PORT PROG"
diff --git a/networking/telnet.c b/networking/telnet.c
index 1a6986b..f520fe1 100644
--- a/networking/telnet.c
+++ b/networking/telnet.c
@@ -20,6 +20,35 @@
  * by Fernando Silveira <swrh@gmx.net>
  *
  */
+//config:config TELNET
+//config:	bool "telnet"
+//config:	default y
+//config:	help
+//config:	  Telnet is an interface to the TELNET protocol, but is also commonly
+//config:	  used to test other simple protocols.
+//config:
+//config:config FEATURE_TELNET_TTYPE
+//config:	bool "Pass TERM type to remote host"
+//config:	default y
+//config:	depends on TELNET
+//config:	help
+//config:	  Setting this option will forward the TERM environment variable to the
+//config:	  remote host you are connecting to. This is useful to make sure that
+//config:	  things like ANSI colors and other control sequences behave.
+//config:
+//config:config FEATURE_TELNET_AUTOLOGIN
+//config:	bool "Pass USER type to remote host"
+//config:	default y
+//config:	depends on TELNET
+//config:	help
+//config:	  Setting this option will forward the USER environment variable to the
+//config:	  remote host you are connecting to. This is useful when you need to
+//config:	  log into a machine without telling the username (autologin). This
+//config:	  option enables `-a' and `-l USER' arguments.
+
+//applet:IF_TELNET(APPLET(telnet, BB_DIR_USR_BIN, BB_SUID_DROP))
+
+//kbuild:lib-$(CONFIG_TELNET) += telnet.o
 
 //usage:#if ENABLE_FEATURE_TELNET_AUTOLOGIN
 //usage:#define telnet_trivial_usage
diff --git a/networking/telnetd.c b/networking/telnetd.c
index 303ef1b..f06e958 100644
--- a/networking/telnetd.c
+++ b/networking/telnetd.c
@@ -20,6 +20,78 @@
  * Vladimir Oleynik <dzo@simtreas.ru> 2001
  * Set process group corrections, initial busybox port
  */
+//config:config TELNETD
+//config:	bool "telnetd"
+//config:	default y
+//config:	select FEATURE_SYSLOG
+//config:	help
+//config:	  A daemon for the TELNET protocol, allowing you to log onto the host
+//config:	  running the daemon. Please keep in mind that the TELNET protocol
+//config:	  sends passwords in plain text. If you can't afford the space for an
+//config:	  SSH daemon and you trust your network, you may say 'y' here. As a
+//config:	  more secure alternative, you should seriously consider installing the
+//config:	  very small Dropbear SSH daemon instead:
+//config:		http://matt.ucc.asn.au/dropbear/dropbear.html
+//config:
+//config:	  Note that for busybox telnetd to work you need several things:
+//config:	  First of all, your kernel needs:
+//config:		  CONFIG_UNIX98_PTYS=y
+//config:
+//config:	  Next, you need a /dev/pts directory on your root filesystem:
+//config:
+//config:		  $ ls -ld /dev/pts
+//config:		  drwxr-xr-x  2 root root 0 Sep 23 13:21 /dev/pts/
+//config:
+//config:	  Next you need the pseudo terminal master multiplexer /dev/ptmx:
+//config:
+//config:		  $ ls -la /dev/ptmx
+//config:		  crw-rw-rw-  1 root tty 5, 2 Sep 23 13:55 /dev/ptmx
+//config:
+//config:	  Any /dev/ttyp[0-9]* files you may have can be removed.
+//config:	  Next, you need to mount the devpts filesystem on /dev/pts using:
+//config:
+//config:		  mount -t devpts devpts /dev/pts
+//config:
+//config:	  You need to be sure that busybox has LOGIN and
+//config:	  FEATURE_SUID enabled. And finally, you should make
+//config:	  certain that Busybox has been installed setuid root:
+//config:
+//config:		chown root.root /bin/busybox
+//config:		chmod 4755 /bin/busybox
+//config:
+//config:	  with all that done, telnetd _should_ work....
+//config:
+//config:config FEATURE_TELNETD_STANDALONE
+//config:	bool "Support standalone telnetd (not inetd only)"
+//config:	default y
+//config:	depends on TELNETD
+//config:	help
+//config:	  Selecting this will make telnetd able to run standalone.
+//config:
+//config:config FEATURE_TELNETD_INETD_WAIT
+//config:	bool "Support -w SEC option (inetd wait mode)"
+//config:	default y
+//config:	depends on FEATURE_TELNETD_STANDALONE
+//config:	help
+//config:	  This option allows you to run telnetd in "inet wait" mode.
+//config:	  Example inetd.conf line (note "wait", not usual "nowait"):
+//config:
+//config:	  telnet stream tcp wait root /bin/telnetd telnetd -w10
+//config:
+//config:	  In this example, inetd passes _listening_ socket_ as fd 0
+//config:	  to telnetd when connection appears.
+//config:	  telnetd will wait for connections until all existing
+//config:	  connections are closed, and no new connections
+//config:	  appear during 10 seconds. Then it exits, and inetd continues
+//config:	  to listen for new connections.
+//config:
+//config:	  This option is rarely used. "tcp nowait" is much more usual
+//config:	  way of running tcp services, including telnetd.
+//config:	  You most probably want to say N here.
+
+//applet:IF_TELNETD(APPLET(telnetd, BB_DIR_USR_SBIN, BB_SUID_DROP))
+
+//kbuild:lib-$(CONFIG_TELNETD) += telnetd.o
 
 //usage:#define telnetd_trivial_usage
 //usage:       "[OPTIONS]"
diff --git a/networking/tftp.c b/networking/tftp.c
index e879c46..ed86720 100644
--- a/networking/tftp.c
+++ b/networking/tftp.c
@@ -18,6 +18,78 @@
  *
  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
+//config:config TFTP
+//config:	bool "tftp"
+//config:	default y
+//config:	help
+//config:	  This enables the Trivial File Transfer Protocol client program. TFTP
+//config:	  is usually used for simple, small transfers such as a root image
+//config:	  for a network-enabled bootloader.
+//config:
+//config:config TFTPD
+//config:	bool "tftpd"
+//config:	default y
+//config:	help
+//config:	  This enables the Trivial File Transfer Protocol server program.
+//config:	  It expects that stdin is a datagram socket and a packet
+//config:	  is already pending on it. It will exit after one transfer.
+//config:	  In other words: it should be run from inetd in nowait mode,
+//config:	  or from udpsvd. Example: "udpsvd -E 0 69 tftpd DIR"
+//config:
+//config:comment "Common options for tftp/tftpd"
+//config:	depends on TFTP || TFTPD
+//config:
+//config:config FEATURE_TFTP_GET
+//config:	bool "Enable 'tftp get' and/or tftpd upload code"
+//config:	default y
+//config:	depends on TFTP || TFTPD
+//config:	help
+//config:	  Add support for the GET command within the TFTP client. This allows
+//config:	  a client to retrieve a file from a TFTP server.
+//config:	  Also enable upload support in tftpd, if tftpd is selected.
+//config:
+//config:	  Note: this option does _not_ make tftpd capable of download
+//config:	  (the usual operation people need from it)!
+//config:
+//config:config FEATURE_TFTP_PUT
+//config:	bool "Enable 'tftp put' and/or tftpd download code"
+//config:	default y
+//config:	depends on TFTP || TFTPD
+//config:	help
+//config:	  Add support for the PUT command within the TFTP client. This allows
+//config:	  a client to transfer a file to a TFTP server.
+//config:	  Also enable download support in tftpd, if tftpd is selected.
+//config:
+//config:config FEATURE_TFTP_BLOCKSIZE
+//config:	bool "Enable 'blksize' and 'tsize' protocol options"
+//config:	default y
+//config:	depends on TFTP || TFTPD
+//config:	help
+//config:	  Allow tftp to specify block size, and tftpd to understand
+//config:	  "blksize" and "tsize" options.
+//config:
+//config:config FEATURE_TFTP_PROGRESS_BAR
+//config:	bool "Enable tftp progress meter"
+//config:	default y
+//config:	depends on TFTP && FEATURE_TFTP_BLOCKSIZE
+//config:	help
+//config:	  Show progress bar.
+//config:
+//config:config TFTP_DEBUG
+//config:	bool "Enable debug"
+//config:	default n
+//config:	depends on TFTP || TFTPD
+//config:	help
+//config:	  Make tftp[d] print debugging messages on stderr.
+//config:	  This is useful if you are diagnosing a bug in tftp[d].
+
+//applet:#if ENABLE_FEATURE_TFTP_GET || ENABLE_FEATURE_TFTP_PUT
+//applet:IF_TFTP(APPLET(tftp, BB_DIR_USR_BIN, BB_SUID_DROP))
+//applet:IF_TFTPD(APPLET(tftpd, BB_DIR_USR_SBIN, BB_SUID_DROP))
+//applet:#endif
+
+//kbuild:lib-$(CONFIG_TFTP) += tftp.o
+//kbuild:lib-$(CONFIG_TFTPD) += tftp.o
 
 //usage:#define tftp_trivial_usage
 //usage:       "[OPTIONS] HOST [PORT]"
diff --git a/networking/traceroute.c b/networking/traceroute.c
index b9a9ca4..58a9b69 100644
--- a/networking/traceroute.c
+++ b/networking/traceroute.c
@@ -209,6 +209,40 @@
  *  -- Van Jacobson (van@ee.lbl.gov)
  *     Tue Dec 20 03:50:13 PST 1988
  */
+//config:config TRACEROUTE
+//config:	bool "traceroute"
+//config:	default y
+//config:	select PLATFORM_LINUX
+//config:	help
+//config:	  Utility to trace the route of IP packets.
+//config:
+//config:config TRACEROUTE6
+//config:	bool "traceroute6"
+//config:	default y
+//config:	depends on FEATURE_IPV6 && TRACEROUTE
+//config:	help
+//config:	  Utility to trace the route of IPv6 packets.
+//config:
+//config:config FEATURE_TRACEROUTE_VERBOSE
+//config:	bool "Enable verbose output"
+//config:	default y
+//config:	depends on TRACEROUTE
+//config:	help
+//config:	  Add some verbosity to traceroute. This includes among other things
+//config:	  hostnames and ICMP response types.
+//config:
+//config:config FEATURE_TRACEROUTE_USE_ICMP
+//config:	bool "Enable -I option (use ICMP instead of UDP)"
+//config:	default y
+//config:	depends on TRACEROUTE
+//config:	help
+//config:	  Add option -I to use ICMP ECHO instead of UDP datagrams.
+
+/* Needs socket(AF_INET, SOCK_RAW, IPPROTO_ICMP), therefore BB_SUID_MAYBE: */
+//applet:IF_TRACEROUTE(APPLET(traceroute, BB_DIR_USR_BIN, BB_SUID_MAYBE))
+//applet:IF_TRACEROUTE6(APPLET(traceroute6, BB_DIR_USR_BIN, BB_SUID_MAYBE))
+
+//kbuild:lib-$(CONFIG_TRACEROUTE) += traceroute.o
 
 //usage:#define traceroute_trivial_usage
 //usage:       "[-"IF_TRACEROUTE6("46")"FIlnrv] [-f 1ST_TTL] [-m MAXTTL] [-q PROBES] [-p PORT]\n"
diff --git a/networking/tunctl.c b/networking/tunctl.c
index 941e8bb..fa904c2 100644
--- a/networking/tunctl.c
+++ b/networking/tunctl.c
@@ -9,6 +9,24 @@
  *
  * Licensed under GPLv2, see file LICENSE in this source tree.
  */
+//config:config TUNCTL
+//config:	bool "tunctl"
+//config:	default y
+//config:	select PLATFORM_LINUX
+//config:	help
+//config:	  tunctl creates or deletes tun devices.
+//config:
+//config:config FEATURE_TUNCTL_UG
+//config:	bool "Support owner:group assignment"
+//config:	default y
+//config:	depends on TUNCTL
+//config:	help
+//config:	  Allow to specify owner and group of newly created interface.
+//config:	  340 bytes of pure bloat. Say no here.
+
+//applet:IF_TUNCTL(APPLET(tunctl, BB_DIR_SBIN, BB_SUID_DROP))
+
+//kbuild:lib-$(CONFIG_TUNCTL) += tunctl.o
 
 //usage:#define tunctl_trivial_usage
 //usage:       "[-f device] ([-t name] | -d name)" IF_FEATURE_TUNCTL_UG(" [-u owner] [-g group] [-b]")
diff --git a/networking/vconfig.c b/networking/vconfig.c
index 924b2f0..f302040 100644
--- a/networking/vconfig.c
+++ b/networking/vconfig.c
@@ -9,6 +9,17 @@
 
 /* BB_AUDIT SUSv3 N/A */
 
+//config:config VCONFIG
+//config:	bool "vconfig"
+//config:	default y
+//config:	select PLATFORM_LINUX
+//config:	help
+//config:	  Creates, removes, and configures VLAN interfaces
+
+//applet:IF_VCONFIG(APPLET(vconfig, BB_DIR_SBIN, BB_SUID_DROP))
+
+//kbuild:lib-$(CONFIG_VCONFIG) += vconfig.o
+
 //usage:#define vconfig_trivial_usage
 //usage:       "COMMAND [OPTIONS]"
 //usage:#define vconfig_full_usage "\n\n"
diff --git a/networking/zcip.c b/networking/zcip.c
index 47f3216..9122bd6 100644
--- a/networking/zcip.c
+++ b/networking/zcip.c
@@ -14,6 +14,22 @@
  * routed at the IP level, though various proxies or bridges can
  * certainly be used.  Its naming is built over multicast DNS.
  */
+//config:config ZCIP
+//config:	bool "zcip"
+//config:	default y
+//config:	select PLATFORM_LINUX
+//config:	select FEATURE_SYSLOG
+//config:	help
+//config:	  ZCIP provides ZeroConf IPv4 address selection, according to RFC 3927.
+//config:	  It's a daemon that allocates and defends a dynamically assigned
+//config:	  address on the 169.254/16 network, requiring no system administrator.
+//config:
+//config:	  See http://www.zeroconf.org for further details, and "zcip.script"
+//config:	  in the busybox examples.
+
+//applet:IF_ZCIP(APPLET(zcip, BB_DIR_SBIN, BB_SUID_DROP))
+
+//kbuild:lib-$(CONFIG_ZCIP) += zcip.o
 
 //#define DEBUG
 
